From 2c2a803dadf2cbfed6b3c2b8b34971b54a42e76c Mon Sep 17 00:00:00 2001 From: Ghost Date: Mon, 4 Jul 2016 10:52:59 +0200 Subject: [PATCH 001/234] GitBook Example --- .gitignore | 16 ++++++++++++++++ README.md | 3 +++ SUMMARY.md | 3 +++ chapter1.md | 3 +++ 4 files changed, 25 insertions(+) create mode 100644 .gitignore create mode 100644 README.md create mode 100644 SUMMARY.md create mode 100644 chapter1.md diff --git a/.gitignore b/.gitignore new file mode 100644 index 000000000..1a366fb0b --- /dev/null +++ b/.gitignore @@ -0,0 +1,16 @@ +# Node rules: +## Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files) +.grunt + +## Dependency directory +## Commenting this out is preferred by some people, see +## https://docs.npmjs.com/misc/faq#should-i-check-my-node_modules-folder-into-git +node_modules + +# Book build output +_book + +# eBook build output +*.epub +*.mobi +*.pdf \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 000000000..f35b4c5a8 --- /dev/null +++ b/README.md @@ -0,0 +1,3 @@ +# My Awesome Book + +This file file serves as your book's preface, a great place to describe your book's content and ideas. diff --git a/SUMMARY.md b/SUMMARY.md new file mode 100644 index 000000000..84616cd78 --- /dev/null +++ b/SUMMARY.md @@ -0,0 +1,3 @@ +# Summary + +* [First Chapter](chapter1.md) diff --git a/chapter1.md b/chapter1.md new file mode 100644 index 000000000..c0e22c649 --- /dev/null +++ b/chapter1.md @@ -0,0 +1,3 @@ +# First Chapter + +GitBook allows you to organize your book into chapters, each chapter is stored in a separate file like this one. From 29b5d4856a7744046de66938d1067c15eafb76f4 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sun, 9 Apr 2017 21:26:34 +0000 Subject: [PATCH 002/234] Updates README.md Auto commit by GitBook Editor --- README.md | 25 +++++++++++++++++++++++-- 1 file changed, 23 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index f35b4c5a8..4b68729e9 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,24 @@ -# My Awesome Book +# DBFlow + +DBFlow is a SQLite library for Android that makes it ridiculously easy to interact and use databases. Built with Annotation Processing that generates most of the boilerplate code for you, code use within a DB is fast, efficient, and type-safe. It removes the tedious \(and tough-to-maintain\) database interaction code. + +Creating a database is as easy as a few lines of code: + +```java +@Database(name = AppDatabase.NAME, version = AppDatabase.VERSION) +public class AppDatabase { + + public static final String NAME = "AppDatabase"; + + public static final int VERSION = 1; +} +``` + +The `@Database` annotation generates a `DatabaseDefinition` which now references your SQLite Database on disk in the file named "AppDatabase.db". You can reference it in code as: + +```java +DatabaseDefinition db = FlowManager.getDatabase(AppDatabase.class); +``` + + -This file file serves as your book's preface, a great place to describe your book's content and ideas. From 3d8a2b656596b55e92e25843d956b95169d56563 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sun, 9 Apr 2017 21:38:31 +0000 Subject: [PATCH 003/234] Updates README.md Auto commit by GitBook Editor --- README.md | 80 +++++++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 78 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 4b68729e9..5927777eb 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # DBFlow -DBFlow is a SQLite library for Android that makes it ridiculously easy to interact and use databases. Built with Annotation Processing that generates most of the boilerplate code for you, code use within a DB is fast, efficient, and type-safe. It removes the tedious \(and tough-to-maintain\) database interaction code. +DBFlow is a SQLite library for Android that makes it ridiculously easy to interact and use databases. Built with Annotation Processing that generates most of the boilerplate code for you, code use within a DB is fast, efficient, and type-safe. It removes the tedious \(and tough-to-maintain\) database interaction code. Creating a database is as easy as a few lines of code: @@ -9,7 +9,7 @@ Creating a database is as easy as a few lines of code: public class AppDatabase { public static final String NAME = "AppDatabase"; - + public static final int VERSION = 1; } ``` @@ -20,5 +20,81 @@ The `@Database` annotation generates a `DatabaseDefinition` which now references DatabaseDefinition db = FlowManager.getDatabase(AppDatabase.class); ``` +To ensure generated code in DBFlow is found by the library, initialize the library in your `Application` class: + +```java +public class MyApp extends Application { + + @Override + public void onCreate() { + super.onCreate(); + FlowManager.init(this); + } +} +``` + +By default, DBFlow generates the `GeneratedDatabaseHolder` class, which is instantiated once by reflection, only once in memory. + +Creating a table is also very simple: + +``` +@Table(database = AppDatabase.class) +public class User { + + @PrimaryKey // at least one primary key required + UUID id; + + @Column + String name; + + @Column + int age; +} +``` + +Then to create, read, update, and delete the model: + +``` +User user = new User(); +user.id = UUID.randomUUID(); +user.name = "Andrew Grosner"; +user.age = 27; + +ModelAdapter adapter = FlowManager.getModelAdapter(User.class); +adapter.insert(user); + +user.name = "Not Andrew Grosner"; +adapter.update(user); + +adapter.delete(user); + +// find adult users +List users = SQLite.select() + .from(User.class) + .where(User_Table.age.greaterThan(18)) + .queryList(); +// or asynchronous retrieval +SQLite.select() + .from(User.class) + .where(User_Table.age.greaterThan(18)) + .async() + .queryListCallback(new QueryTransaction.QueryResultCallback() { + @Override + public void onQueryResult(QueryTransaction transaction, @NonNull CursorResult tResult) { + // called when query returns on UI thread + List autos = tResult.toListClose(); + // do something with results + } + }) + .error(new Transaction.Error() { + @Override + public void onError(Transaction transaction, Throwable error) { + // handle any errors + } + }) + .execute(); + +``` + From c90df664f68ed2c94ea7d854ca4e7e8d8124e158 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sun, 9 Apr 2017 21:39:02 +0000 Subject: [PATCH 004/234] Updates README.md Auto commit by GitBook Editor --- README.md | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) diff --git a/README.md b/README.md index 5927777eb..0a5074248 100644 --- a/README.md +++ b/README.md @@ -33,7 +33,7 @@ public class MyApp extends Application { } ``` -By default, DBFlow generates the `GeneratedDatabaseHolder` class, which is instantiated once by reflection, only once in memory. +By default, DBFlow generates the `GeneratedDatabaseHolder` class, which is instantiated once by reflection, only once in memory. Creating a table is also very simple: @@ -46,7 +46,7 @@ public class User { @Column String name; - + @Column int age; } @@ -73,17 +73,17 @@ List users = SQLite.select() .from(User.class) .where(User_Table.age.greaterThan(18)) .queryList(); + // or asynchronous retrieval SQLite.select() .from(User.class) .where(User_Table.age.greaterThan(18)) .async() - .queryListCallback(new QueryTransaction.QueryResultCallback() { + .queryListCallback(new QueryTransaction.QueryResultCallback() { @Override - public void onQueryResult(QueryTransaction transaction, @NonNull CursorResult tResult) { + public void onQueryResult(QueryTransaction transaction, @NonNull CursorResult tResult) { // called when query returns on UI thread - List autos = tResult.toListClose(); - // do something with results + List users = tResult.toListClose(); } }) .error(new Transaction.Error() { @@ -93,7 +93,6 @@ SQLite.select() } }) .execute(); - ``` From 0da62c210fa75720dcdb50b5ad6bfe17acc06f5f Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sun, 9 Apr 2017 21:40:33 +0000 Subject: [PATCH 005/234] Updates README.md Auto commit by GitBook Editor --- README.md | 2 +- SUMMARY.md | 3 +++ including-in-project.md | 8 ++++++++ 3 files changed, 12 insertions(+), 1 deletion(-) create mode 100644 including-in-project.md diff --git a/README.md b/README.md index 0a5074248..5750b2a7b 100644 --- a/README.md +++ b/README.md @@ -73,7 +73,7 @@ List users = SQLite.select() .from(User.class) .where(User_Table.age.greaterThan(18)) .queryList(); - + // or asynchronous retrieval SQLite.select() .from(User.class) diff --git a/SUMMARY.md b/SUMMARY.md index 84616cd78..401109d6f 100644 --- a/SUMMARY.md +++ b/SUMMARY.md @@ -1,3 +1,6 @@ # Summary +* [Introduction](README.md) +* [Including in Project](including-in-project.md) * [First Chapter](chapter1.md) + diff --git a/including-in-project.md b/including-in-project.md new file mode 100644 index 000000000..0ef0467c7 --- /dev/null +++ b/including-in-project.md @@ -0,0 +1,8 @@ +# Including in your Project + +DBFlow has a number of artifacts that you can include in the project. + + + + + From 14e923625b8c9e41755632cf6b4297e62d1d667a Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Wed, 26 Apr 2017 17:00:12 +0000 Subject: [PATCH 006/234] Updates README.md Auto commit by GitBook Editor --- README.md | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 5750b2a7b..a6769a94f 100644 --- a/README.md +++ b/README.md @@ -37,7 +37,7 @@ By default, DBFlow generates the `GeneratedDatabaseHolder` class, which is insta Creating a table is also very simple: -``` +```java @Table(database = AppDatabase.class) public class User { @@ -54,7 +54,7 @@ public class User { Then to create, read, update, and delete the model: -``` +```java User user = new User(); user.id = UUID.randomUUID(); user.name = "Andrew Grosner"; @@ -68,6 +68,12 @@ adapter.update(user); adapter.delete(user); +// if you extend BaseModel or implement Model +user.insert(); +user.update(); +user.delete(); +user.save(); + // find adult users List users = SQLite.select() .from(User.class) From 4bbe08b11dbb4d5276209abe9e19bce8c99c69ad Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Wed, 26 Apr 2017 17:05:26 +0000 Subject: [PATCH 007/234] Updates README.md Auto commit by GitBook Editor --- README.md | 21 ++++++++++----------- 1 file changed, 10 insertions(+), 11 deletions(-) diff --git a/README.md b/README.md index a6769a94f..6185659d7 100644 --- a/README.md +++ b/README.md @@ -85,19 +85,18 @@ SQLite.select() .from(User.class) .where(User_Table.age.greaterThan(18)) .async() - .queryListCallback(new QueryTransaction.QueryResultCallback() { - @Override - public void onQueryResult(QueryTransaction transaction, @NonNull CursorResult tResult) { + .queryListCallback((QueryTransaction transaction, @NonNull CursorResult result) -> { // called when query returns on UI thread - List users = tResult.toListClose(); - } - }) - .error(new Transaction.Error() { - @Override - public void onError(Transaction transaction, Throwable error) { + try { + List users = result.toList(); + // do something with users + } finally { + result.close(); + } + }) + .error((Transaction transaction, Throwable error) -> { // handle any errors - } - }) + }) .execute(); ``` From d0e79482deed57be6dc039ce853e81d284eaf227 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Wed, 26 Apr 2017 17:14:51 +0000 Subject: [PATCH 008/234] Updates including-in-project.md Auto commit by GitBook Editor --- including-in-project.md | 48 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 48 insertions(+) diff --git a/including-in-project.md b/including-in-project.md index 0ef0467c7..ef2cd42f3 100644 --- a/including-in-project.md +++ b/including-in-project.md @@ -2,7 +2,55 @@ DBFlow has a number of artifacts that you can include in the project. +**Annotation Processor**: Generates the necessary code that you don't need to write. +**Core:** Contains the main annotations and misc classes that are shared across all of DBFlow. + +**DBFlow: **The main library artifact used in conjunction with the previous two artifacts. + +**SCLCipher Support:** Replaces most of inner database interaction with an [Encrypted Database](https://www.zetetic.net/sqlcipher/) that's useful for sensitive information. DBFlow contains wrapper around most of the implementation, so adding it is minimal. + +**Kotlin: **DBFlow has Kotlin extensions support for the library, enabling more concise syntax and tons of inline helper methods! Also most of the public library API is annotated with `@Nullable` or `@NonNull`, providing nice interop when used in Kotlin. + +**RXJava: **RX1 and RX2 supported. Wraps around normal DB operations by providing RXJava support for Model CRUD updates and SQLite wrapper language. Also Kotlin extensions exist for RX-specific methods. + + + +```Groovy + def dbflow_version = "xxxx" // reference the releases tab on Github for latest versions + // or you can grab a 10-digit commit hash of any commit in the project that builds. + + dependencies { + annotationProcessor "com.github.Raizlabs.DBFlow:dbflow-processor:${dbflow_version}" + + // use kapt for kotlin apt if you're a Kotlin user + kapt "com.github.Raizlabs.DBFlow:dbflow-processor:${dbflow_version}" + + compile "com.github.Raizlabs.DBFlow:dbflow-core:${dbflow_version}" + compile "com.github.Raizlabs.DBFlow:dbflow:${dbflow_version}" + + // sql-cipher database encryption (optional) + compile "com.github.Raizlabs.DBFlow:dbflow-sqlcipher:${dbflow_version}" + compile "net.zetetic:android-database-sqlcipher:${sqlcipher_version}@aar" + + // kotlin extensions + compile "com.github.Raizlabs.DBFlow:dbflow-kotlinextensions:${dbflow_version}" + + // RXJava 1 support + compile "com.github.Raizlabs.DBFlow:dbflow-rx:${dbflow_version}" + + // RXJava 1 Kotlin Extensions Support + compile "com.github.Raizlabs.DBFlow:dbflow-rx-kotlinextensions:${dbflow_version}" + + // RXJava 2 support + compile "com.github.Raizlabs.DBFlow:dbflow-rx2:${dbflow_version}" + + // RXJava 2 Kotlin Extensions Support + compile "com.github.Raizlabs.DBFlow:dbflow-rx2-kotlinextensions:${dbflow_version}" + + } + +``` From d83377e0d4aa7932a72316737a725f2b9531cbe1 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Wed, 26 Apr 2017 17:16:53 +0000 Subject: [PATCH 009/234] Updates including-in-project.md Auto commit by GitBook Editor --- including-in-project.md | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/including-in-project.md b/including-in-project.md index ef2cd42f3..a0242ba9e 100644 --- a/including-in-project.md +++ b/including-in-project.md @@ -14,7 +14,18 @@ DBFlow has a number of artifacts that you can include in the project. **RXJava: **RX1 and RX2 supported. Wraps around normal DB operations by providing RXJava support for Model CRUD updates and SQLite wrapper language. Also Kotlin extensions exist for RX-specific methods. +### Add the jitpack.io repository +This repo is used to publish the artifacts. It also enables dynamic builds, allowing you to specify specific branches or commit hashes of the project to include outside of normal releases. + +```Groovy +allProjects { + repositories { + // required to find the project's artifacts + maven { url "https://www.jitpack.io" } + } +} +``` ```Groovy def dbflow_version = "xxxx" // reference the releases tab on Github for latest versions @@ -49,7 +60,6 @@ DBFlow has a number of artifacts that you can include in the project. compile "com.github.Raizlabs.DBFlow:dbflow-rx2-kotlinextensions:${dbflow_version}" } - ``` From 586c6a7ef038af027a9a590a536e250a579555fc Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Wed, 26 Apr 2017 17:17:19 +0000 Subject: [PATCH 010/234] Updates including-in-project.md Auto commit by GitBook Editor --- including-in-project.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/including-in-project.md b/including-in-project.md index a0242ba9e..fc6599678 100644 --- a/including-in-project.md +++ b/including-in-project.md @@ -16,7 +16,7 @@ DBFlow has a number of artifacts that you can include in the project. ### Add the jitpack.io repository -This repo is used to publish the artifacts. It also enables dynamic builds, allowing you to specify specific branches or commit hashes of the project to include outside of normal releases. +This repo is used to publish the artifacts. It also enables [dynamic builds](https://jitpack.io/docs/), allowing you to specify specific branches or commit hashes of the project to include outside of normal releases. ```Groovy allProjects { From b449b064b5376f348a839194ee51dd65c829d1fe Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Wed, 26 Apr 2017 17:18:03 +0000 Subject: [PATCH 011/234] Updates including-in-project.md Auto commit by GitBook Editor --- including-in-project.md | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/including-in-project.md b/including-in-project.md index fc6599678..88594c2ae 100644 --- a/including-in-project.md +++ b/including-in-project.md @@ -60,6 +60,11 @@ allProjects { compile "com.github.Raizlabs.DBFlow:dbflow-rx2-kotlinextensions:${dbflow_version}" } + + // if you build with Kotlin KAPT1 (Kapt2/3 do not require this) + kapt { + generateStubs = true + } ``` From 91af03a3fa75e4ad1b37a23754d84af1092f2366 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Wed, 26 Apr 2017 17:25:32 +0000 Subject: [PATCH 012/234] Updates proguard.md Auto commit by GitBook Editor --- SUMMARY.md | 3 ++- proguard.md | 10 ++++++++++ 2 files changed, 12 insertions(+), 1 deletion(-) create mode 100644 proguard.md diff --git a/SUMMARY.md b/SUMMARY.md index 401109d6f..005cb9945 100644 --- a/SUMMARY.md +++ b/SUMMARY.md @@ -2,5 +2,6 @@ * [Introduction](README.md) * [Including in Project](including-in-project.md) -* [First Chapter](chapter1.md) +* [Proguard](proguard.md) +* [Usage](chapter1.md) diff --git a/proguard.md b/proguard.md new file mode 100644 index 000000000..de1c956dd --- /dev/null +++ b/proguard.md @@ -0,0 +1,10 @@ +# Proguard + +Since DBFlow uses annotation processing, which is run pre-proguard phase, the configuration is highly minimal. Also since we combine all generated files into the `GeneratedDatabaseHolder`, any other class generated can be obfuscated. + +``` +-keep class * extends com.raizlabs.android.dbflow.config.DatabaseHolder { *; } +``` + + + From 99d26a9899dc20ac34f14c12b4e7fc7ddbc4feb5 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Wed, 26 Apr 2017 17:26:01 +0000 Subject: [PATCH 013/234] Updates proguard.md Auto commit by GitBook Editor --- proguard.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/proguard.md b/proguard.md index de1c956dd..20a2015cc 100644 --- a/proguard.md +++ b/proguard.md @@ -6,5 +6,5 @@ Since DBFlow uses annotation processing, which is run pre-proguard phase, the co -keep class * extends com.raizlabs.android.dbflow.config.DatabaseHolder { *; } ``` - +This also works on modules from other library projects that use DBFlow. From 29cd3f78fcfffe5c6c53faab0d64ab2be4a73e75 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Wed, 26 Apr 2017 17:30:17 +0000 Subject: [PATCH 014/234] Updates chapter1.md Auto commit by GitBook Editor --- chapter1.md | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/chapter1.md b/chapter1.md index c0e22c649..26fda404a 100644 --- a/chapter1.md +++ b/chapter1.md @@ -1,3 +1,4 @@ -# First Chapter +# Usage + +DBFlow supports a number of database features that will enhance and decrease time you need to spend coding with databases. -GitBook allows you to organize your book into chapters, each chapter is stored in a separate file like this one. From c1cc5b88de93f191a198a93ab2fa9e143898cae8 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Wed, 26 Apr 2017 17:31:04 +0000 Subject: [PATCH 015/234] Updates chapter1.md Auto commit by GitBook Editor --- chapter1.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/chapter1.md b/chapter1.md index 26fda404a..d79dce668 100644 --- a/chapter1.md +++ b/chapter1.md @@ -2,3 +2,5 @@ DBFlow supports a number of database features that will enhance and decrease time you need to spend coding with databases. +What is covered in these docs are not all inclusive, but should give you an idea of how to operate with DBFlow on databases. + From 93ea81228ca953491e3c8b17132a8388226c5992 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Wed, 26 Apr 2017 17:35:26 +0000 Subject: [PATCH 016/234] Updates chapter1.md Auto commit by GitBook Editor --- chapter1.md | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/chapter1.md b/chapter1.md index d79dce668..97938835d 100644 --- a/chapter1.md +++ b/chapter1.md @@ -4,3 +4,23 @@ DBFlow supports a number of database features that will enhance and decrease tim What is covered in these docs are not all inclusive, but should give you an idea of how to operate with DBFlow on databases. + + +There are a few concepts to familiarize yourself with: + +**SQLite Wrapper Language:** DBFlow provides a number of convenience methods, extensions, and generated helpers that produce a concise, flowable query syntax. + +``` +List users = SQLite.select() + .from(User.class) + .where(name.is("Andrew Grosner")) + .queryList(); + +SQLite.update(User.class) + .set(name.eq("Andrew Grosner")) + .where(name.eq("Andy Grosner")) + .executeUpdateDelete() +``` + + + From 5c71c1a0eb57ed96c803aadf419a61c2cbd267fd Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Wed, 26 Apr 2017 17:37:26 +0000 Subject: [PATCH 017/234] Updates chapter1.md Auto commit by GitBook Editor --- chapter1.md | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/chapter1.md b/chapter1.md index 97938835d..d294de41b 100644 --- a/chapter1.md +++ b/chapter1.md @@ -4,8 +4,6 @@ DBFlow supports a number of database features that will enhance and decrease tim What is covered in these docs are not all inclusive, but should give you an idea of how to operate with DBFlow on databases. - - There are a few concepts to familiarize yourself with: **SQLite Wrapper Language:** DBFlow provides a number of convenience methods, extensions, and generated helpers that produce a concise, flowable query syntax. @@ -20,6 +18,10 @@ SQLite.update(User.class) .set(name.eq("Andrew Grosner")) .where(name.eq("Andy Grosner")) .executeUpdateDelete() + +database.beginTransactionAsync((DatabaseWrapper wrapper) -> { + // wraps in a SQLite transaction, do something on BG thread. +}); ``` From fd538543a2be973cf6d71363fc4661ef5f5b1f0d Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Wed, 26 Apr 2017 17:37:45 +0000 Subject: [PATCH 018/234] Updates chapter1.md Auto commit by GitBook Editor --- chapter1.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/chapter1.md b/chapter1.md index d294de41b..8ea1752f5 100644 --- a/chapter1.md +++ b/chapter1.md @@ -6,7 +6,7 @@ What is covered in these docs are not all inclusive, but should give you an idea There are a few concepts to familiarize yourself with: -**SQLite Wrapper Language:** DBFlow provides a number of convenience methods, extensions, and generated helpers that produce a concise, flowable query syntax. +**SQLite Wrapper Language:** DBFlow provides a number of convenience methods, extensions, and generated helpers that produce a concise, flowable query syntax. A few examples below: ``` List users = SQLite.select() @@ -22,6 +22,8 @@ SQLite.update(User.class) database.beginTransactionAsync((DatabaseWrapper wrapper) -> { // wraps in a SQLite transaction, do something on BG thread. }); + + ``` From dc170900a700b1f4cf61c782a82f1d5a7fab0d47 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Wed, 26 Apr 2017 17:48:56 +0000 Subject: [PATCH 019/234] Updates chapter1.md Auto commit by GitBook Editor --- chapter1.md | 24 +++++++++++++++++++++--- 1 file changed, 21 insertions(+), 3 deletions(-) diff --git a/chapter1.md b/chapter1.md index 8ea1752f5..dd7a7e9b4 100644 --- a/chapter1.md +++ b/chapter1.md @@ -1,6 +1,6 @@ # Usage -DBFlow supports a number of database features that will enhance and decrease time you need to spend coding with databases. +DBFlow supports a number of database features that will enhance and decrease time you need to spend coding with databases. We support multiple databases at the same time as long as there's no shared models. What is covered in these docs are not all inclusive, but should give you an idea of how to operate with DBFlow on databases. @@ -19,12 +19,30 @@ SQLite.update(User.class) .where(name.eq("Andy Grosner")) .executeUpdateDelete() -database.beginTransactionAsync((DatabaseWrapper wrapper) -> { +FlowManager.getDatabase(AppDatabase.class).beginTransactionAsync((DatabaseWrapper wrapper) -> { // wraps in a SQLite transaction, do something on BG thread. }); - +CursorResult results = SQLite.select().from(User.class).queryResults(); +for (User user: results) { // memory efficient iterator + +} ``` +Or in Kotlin: + + val users = (select from User::class where (name `is` "Andrew Grosner")).list + + (update() set (name eq "Andrew Grosner") where (name eq "Andy Grosner")).executeUpdateDelete() + + database().beginTransactionAsync { + + } + + + + + + From 38b726c294c461b2394511878e483b6ac797c3f3 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Wed, 26 Apr 2017 17:49:08 +0000 Subject: [PATCH 020/234] Updates chapter1.md Auto commit by GitBook Editor --- chapter1.md | 9 ++------- 1 file changed, 2 insertions(+), 7 deletions(-) diff --git a/chapter1.md b/chapter1.md index dd7a7e9b4..af1d3beb6 100644 --- a/chapter1.md +++ b/chapter1.md @@ -1,6 +1,6 @@ # Usage -DBFlow supports a number of database features that will enhance and decrease time you need to spend coding with databases. We support multiple databases at the same time as long as there's no shared models. +DBFlow supports a number of database features that will enhance and decrease time you need to spend coding with databases. We support multiple databases at the same time \(and in separate modules\) as long as there's no shared models. What is covered in these docs are not all inclusive, but should give you an idea of how to operate with DBFlow on databases. @@ -25,7 +25,7 @@ FlowManager.getDatabase(AppDatabase.class).beginTransactionAsync((DatabaseWrappe CursorResult results = SQLite.select().from(User.class).queryResults(); for (User user: results) { // memory efficient iterator - + } ``` @@ -41,8 +41,3 @@ Or in Kotlin: - - - - - From a0a9db3d2d764e00fe24132d2be7a5f714b44b24 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Wed, 26 Apr 2017 17:52:45 +0000 Subject: [PATCH 021/234] Updates chapter1.md Auto commit by GitBook Editor --- chapter1.md | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/chapter1.md b/chapter1.md index af1d3beb6..21ce06c68 100644 --- a/chapter1.md +++ b/chapter1.md @@ -24,8 +24,12 @@ FlowManager.getDatabase(AppDatabase.class).beginTransactionAsync((DatabaseWrappe }); CursorResult results = SQLite.select().from(User.class).queryResults(); -for (User user: results) { // memory efficient iterator +try { + for (User user: results) { // memory efficient iterator + } +} finally { + results.close() } ``` @@ -39,5 +43,13 @@ Or in Kotlin: } + (select from User::class).queryResults().use { results -> + for (user in results) { + + } + } + + + From cba60a92d3f4100cb421af9b5b9da8b54165479b Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Wed, 26 Apr 2017 17:53:48 +0000 Subject: [PATCH 022/234] Updates chapter1.md Auto commit by GitBook Editor --- chapter1.md | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/chapter1.md b/chapter1.md index 21ce06c68..bf5a3c5ff 100644 --- a/chapter1.md +++ b/chapter1.md @@ -49,7 +49,12 @@ Or in Kotlin: } } +**Caching: **DBFlow supports caching in models. +``` +@Table(cachingEnabled = true) +public class User +``` From 1f174db57b144076f1e13ce78af047de9eb92abf Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Wed, 26 Apr 2017 17:54:19 +0000 Subject: [PATCH 023/234] Updates chapter1.md Auto commit by GitBook Editor --- chapter1.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/chapter1.md b/chapter1.md index bf5a3c5ff..9d668ded8 100644 --- a/chapter1.md +++ b/chapter1.md @@ -4,7 +4,7 @@ DBFlow supports a number of database features that will enhance and decrease tim What is covered in these docs are not all inclusive, but should give you an idea of how to operate with DBFlow on databases. -There are a few concepts to familiarize yourself with: +There are a few concepts to familiarize yourself with. We will go more in depth in other sections in this doc. **SQLite Wrapper Language:** DBFlow provides a number of convenience methods, extensions, and generated helpers that produce a concise, flowable query syntax. A few examples below: From aaca0c029c0c051ea179dd2b84d0681fd92b918c Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Wed, 26 Apr 2017 17:54:59 +0000 Subject: [PATCH 024/234] Updates chapter1.md Auto commit by GitBook Editor --- chapter1.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/chapter1.md b/chapter1.md index 9d668ded8..4c36d1cf3 100644 --- a/chapter1.md +++ b/chapter1.md @@ -49,7 +49,7 @@ Or in Kotlin: } } -**Caching: **DBFlow supports caching in models. +**Caching: **DBFlow supports caching in models. Caching them greatly increases speed, but cache carefully. ``` @Table(cachingEnabled = true) From bf2aaaeb94393d816ab7e801fc73298af27dae77 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Wed, 26 Apr 2017 17:57:38 +0000 Subject: [PATCH 025/234] Updates chapter1.md Auto commit by GitBook Editor --- chapter1.md | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/chapter1.md b/chapter1.md index 4c36d1cf3..db11c6dbb 100644 --- a/chapter1.md +++ b/chapter1.md @@ -49,12 +49,16 @@ Or in Kotlin: } } -**Caching: **DBFlow supports caching in models. Caching them greatly increases speed, but cache carefully. +**Caching: **DBFlow supports caching in models. Caching them greatly increases speed, but cache carefully as it can lead to problems such as stale data. ``` @Table(cachingEnabled = true) public class User ``` +**Migrations: **Migrations are made very simple in DBFlow. We only support the kinds that [SQLite provide](https://sqlite.org/lang_altertable.html), but also allow you to modify the data within the DB in a structured way during these. They are also run whenever the `SQLiteOpenHelper` detects a version change in the order of version they specify. + + + From 31f1856ffad99ba850b11040ab4543e5176b868a Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Wed, 26 Apr 2017 17:58:50 +0000 Subject: [PATCH 026/234] Updates chapter1.md Auto commit by GitBook Editor --- chapter1.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/chapter1.md b/chapter1.md index db11c6dbb..c2e945f4b 100644 --- a/chapter1.md +++ b/chapter1.md @@ -58,7 +58,7 @@ public class User **Migrations: **Migrations are made very simple in DBFlow. We only support the kinds that [SQLite provide](https://sqlite.org/lang_altertable.html), but also allow you to modify the data within the DB in a structured way during these. They are also run whenever the `SQLiteOpenHelper` detects a version change in the order of version they specify. - +**Multiple Modules:** DBFlow can be used in library projects, in any number of inner-project modules simultaneously. However these models must reside in separate databases. From 88c5251b6bef04793c94099259f3db7402089a4a Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Wed, 26 Apr 2017 18:00:16 +0000 Subject: [PATCH 027/234] Updates chapter1.md Auto commit by GitBook Editor --- chapter1.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/chapter1.md b/chapter1.md index c2e945f4b..b2faa3d59 100644 --- a/chapter1.md +++ b/chapter1.md @@ -60,5 +60,5 @@ public class User **Multiple Modules:** DBFlow can be used in library projects, in any number of inner-project modules simultaneously. However these models must reside in separate databases. - +**Relationships:** Not the human kind. We support `@ForeignKey` including multiple foreign keys for 1-1. `@OneToMany` is a manual relationship generated by the compiler between two tables to manage data. From 5dd83932b819c352e47f6a4eda813e7b74c2da78 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Wed, 26 Apr 2017 18:01:06 +0000 Subject: [PATCH 028/234] Updates chapter1.md Auto commit by GitBook Editor --- chapter1.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/chapter1.md b/chapter1.md index b2faa3d59..d50438618 100644 --- a/chapter1.md +++ b/chapter1.md @@ -60,5 +60,7 @@ public class User **Multiple Modules:** DBFlow can be used in library projects, in any number of inner-project modules simultaneously. However these models must reside in separate databases. -**Relationships:** Not the human kind. We support `@ForeignKey` including multiple foreign keys for 1-1. `@OneToMany` is a manual relationship generated by the compiler between two tables to manage data. +**Relationships:** Not the human kind. We support `@ForeignKey` including multiple foreign keys for 1-1. `@OneToMany` is a manual relationship generated by the compiler between two tables to manage data.`@ManyToMany` generates a join table between two tables for many to many relationships. + + From 52c3b1aa2d39057ebad1b9bd4a47e3c3601f5443 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Wed, 26 Apr 2017 18:03:24 +0000 Subject: [PATCH 029/234] Updates chapter1.md Auto commit by GitBook Editor --- chapter1.md | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/chapter1.md b/chapter1.md index d50438618..6e4f08ef1 100644 --- a/chapter1.md +++ b/chapter1.md @@ -62,5 +62,11 @@ public class User **Relationships:** Not the human kind. We support `@ForeignKey` including multiple foreign keys for 1-1. `@OneToMany` is a manual relationship generated by the compiler between two tables to manage data.`@ManyToMany` generates a join table between two tables for many to many relationships. +**Views:** Declared like tables, Views \(Virtual Tables\) are supported. + +**Query Models:** Query models have no SQLite connection, but are extremely useful for custom queries or join queries that return a result set not mappable to any model you currently use for tables. + +**Encrypted Databases:** DBFlow supports database encryption for security using SQLCipher through a separate, easy-to-integrate artifact. + From 33e6a535a62372860e5cd7e173e0677434a21bc2 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Wed, 26 Apr 2017 18:04:16 +0000 Subject: [PATCH 030/234] Updates chapter1.md Auto commit by GitBook Editor --- chapter1.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/chapter1.md b/chapter1.md index 6e4f08ef1..dc7685493 100644 --- a/chapter1.md +++ b/chapter1.md @@ -64,9 +64,9 @@ public class User **Views:** Declared like tables, Views \(Virtual Tables\) are supported. -**Query Models:** Query models have no SQLite connection, but are extremely useful for custom queries or join queries that return a result set not mappable to any model you currently use for tables. +**Query Models:** Query models have no SQLite connection, but are extremely useful for custom queries or join queries that return a result set not mappable to any model you currently use for tables. **Encrypted Databases:** DBFlow supports database encryption for security using SQLCipher through a separate, easy-to-integrate artifact. - +**Indexes: **A SQLite feature that drastically improves query performance on large datasets. Dead-easy to implement. From 9716c55872e2d00d36625b2635d85236b73f4be5 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Wed, 26 Apr 2017 18:05:08 +0000 Subject: [PATCH 031/234] Updates chapter1.md Auto commit by GitBook Editor --- chapter1.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/chapter1.md b/chapter1.md index dc7685493..23f4aed7a 100644 --- a/chapter1.md +++ b/chapter1.md @@ -70,3 +70,5 @@ public class User **Indexes: **A SQLite feature that drastically improves query performance on large datasets. Dead-easy to implement. +**Reactive: **Easily listen to changes in database data via `ModelNotifier` system. + From c1f39bd09f90cde0a5079347ca8b7ae424fdc9fc Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Wed, 26 Apr 2017 18:05:55 +0000 Subject: [PATCH 032/234] Updates chapter1.md Auto commit by GitBook Editor --- chapter1.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/chapter1.md b/chapter1.md index 23f4aed7a..d719a3ffe 100644 --- a/chapter1.md +++ b/chapter1.md @@ -72,3 +72,5 @@ public class User **Reactive: **Easily listen to changes in database data via `ModelNotifier` system. +**Transactions:** Place all transactions and retrievals on same background thread for maximum efficiency and to prevent UI-hiccups. + From f80f7129deb34427a725ea5c6daa8bb6fdffcf02 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Wed, 26 Apr 2017 18:06:00 +0000 Subject: [PATCH 033/234] Updates chapter1.md Auto commit by GitBook Editor --- chapter1.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/chapter1.md b/chapter1.md index d719a3ffe..17562a74f 100644 --- a/chapter1.md +++ b/chapter1.md @@ -72,5 +72,5 @@ public class User **Reactive: **Easily listen to changes in database data via `ModelNotifier` system. -**Transactions:** Place all transactions and retrievals on same background thread for maximum efficiency and to prevent UI-hiccups. +**Transaction Management:** Place all transactions and retrievals on same background thread for maximum efficiency and to prevent UI-hiccups. From 16e4bde4e9c6fd997a658abfa6dc363cbf2085b9 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Wed, 26 Apr 2017 18:07:20 +0000 Subject: [PATCH 034/234] Updates chapter1.md Auto commit by GitBook Editor --- chapter1.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/chapter1.md b/chapter1.md index 17562a74f..1554644e1 100644 --- a/chapter1.md +++ b/chapter1.md @@ -74,3 +74,7 @@ public class User **Transaction Management:** Place all transactions and retrievals on same background thread for maximum efficiency and to prevent UI-hiccups. +**Type Converters**: Have custom data? Define a TypeConverter to map it to SQLite data types. + + + From 5e824297770ec32d487c7439d4b25b6465095bf5 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Wed, 26 Apr 2017 18:07:27 +0000 Subject: [PATCH 035/234] Updates chapter1.md Auto commit by GitBook Editor --- chapter1.md | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/chapter1.md b/chapter1.md index 1554644e1..6c6952438 100644 --- a/chapter1.md +++ b/chapter1.md @@ -74,7 +74,5 @@ public class User **Transaction Management:** Place all transactions and retrievals on same background thread for maximum efficiency and to prevent UI-hiccups. -**Type Converters**: Have custom data? Define a TypeConverter to map it to SQLite data types. - - +**Type Converters**: Have custom data? Define a `TypeConverter` to map it to SQLite data types. From 3e1a98a9f005ad4fa6314c9047114b7fdee3e737 Mon Sep 17 00:00:00 2001 From: fuzzagrosner Date: Wed, 26 Apr 2017 14:26:22 -0400 Subject: [PATCH 036/234] [book] add usage docs to book. --- Caching.md | 143 ++++++++ ContentProviderGeneration.md | 234 +++++++++++++ Databases.md | 131 ++++++++ GettingStarted.md | 154 +++++++++ Indexing.md | 78 +++++ Intro.md | 126 +++++++ KotlinSupport.md | 231 +++++++++++++ ListBasedQueries.md | 157 +++++++++ Migration3Guide.md | 630 +++++++++++++++++++++++++++++++++++ Migration4Guide.md | 40 +++ Migrations.md | 175 ++++++++++ ModelViews.md | 47 +++ Models.md | 163 +++++++++ MultipleModules.md | 48 +++ Observability.md | 154 +++++++++ QueryModels.md | 107 ++++++ RXSupport.md | 170 ++++++++++ Relationships.md | 227 +++++++++++++ Retrieval.md | 116 +++++++ SQLCipherSupport.md | 57 ++++ SQLiteWrapperLanguage.md | 384 +++++++++++++++++++++ SUMMARY.md | 22 ++ StoringData.md | 313 +++++++++++++++++ TypeConverters.md | 58 ++++ 24 files changed, 3965 insertions(+) create mode 100644 Caching.md create mode 100644 ContentProviderGeneration.md create mode 100644 Databases.md create mode 100644 GettingStarted.md create mode 100644 Indexing.md create mode 100644 Intro.md create mode 100644 KotlinSupport.md create mode 100644 ListBasedQueries.md create mode 100644 Migration3Guide.md create mode 100644 Migration4Guide.md create mode 100644 Migrations.md create mode 100644 ModelViews.md create mode 100644 Models.md create mode 100644 MultipleModules.md create mode 100644 Observability.md create mode 100644 QueryModels.md create mode 100644 RXSupport.md create mode 100644 Relationships.md create mode 100644 Retrieval.md create mode 100644 SQLCipherSupport.md create mode 100644 SQLiteWrapperLanguage.md create mode 100644 StoringData.md create mode 100644 TypeConverters.md diff --git a/Caching.md b/Caching.md new file mode 100644 index 000000000..834f88a74 --- /dev/null +++ b/Caching.md @@ -0,0 +1,143 @@ +# Caching + +DBFlow provides powerful caching mechanisms to speed up retrieval from the database +to enable high performance in our applications. + +Caching is not enabled by default, but it is very easy to enable. + +**Note**: caching functions correctly in only when we do CRUD operations on full model queries (i.e. Single table, no projections). + +Caching should be used when: + 1. Loading the same set of `Model` many times with slightly different selection. + 2. Operating on full `Model` objects (containing all `@PrimaryKey`) + +Caching should be avoided (or clear caches) when: + 1. Performing selection, complex queries, anything different than starting with `SQLite.select()` + 2. Using the wrapper modifications such as `Insert`, `Update`, or `Delete`. In this case you should clear the associated cache, post-operation. + +## Supported Caching Classes + +Caching is supported for: + 1. `SparseArray` via `SparseArrayBasedCache` (platform SparseArray) + 2. `Map` via `SimpleMapCache` + 3. `LruCache` via `ModelLruCache` (copy of `LruCache`, so dependency avoided) + 4. Custom Caching classes that implement `ModelCache` + +Cache sizes are not supported for `SimpleMapCache`. This is because `Map` can hold +arbitrary size of contents. + +## Enable Caching + +To enable caching on a single-primary key table, simply specify that it is enabled: + +```java + + +@Table(database = AppDatabase.class, cachingEnabled = true) +public class CacheableModel { + + @PrimaryKey(autoincrement = true) + long id; + + @Column + String name; +} + +``` + +to use caching on a table that uses multiple primary keys, [see](/usage2/Caching.md#multiple-primary-key-caching). + +By default we use a `SimpleMapCache`, which loads `Model` into a `Map`. The key is +either the primary key of the object or a combination of the two, but it should have +an associated `HashCode` and `equals()` value. + +## Loading from the DB + +When retrieving from the database, we still run a full query that returns a `Cursor`. +We skirt the expensive conversion process by checking the combination of Primary key on each row. +If an item exists with the same primary key combination, we return that object out of the cache. + +If you operate on a model object, that change gets reflected in the cache. But beware +modifying them in a separate thread might result in state state returned if the cache is not synchronized +properly. + +Any time a field on these objects are modified, you _should_ immediately save those +since we have a direct reference to the object from the cache. Otherwise, the DB +and cache could get into an inconsistent state. + +```java + +MyModel model = SQLite.select().from(MyModel.class).where(...).querySingle(); +model.setName("Name"); +model.save(); // save it to DB post any modifications to this object. + +``` + +## Disable Caching For Some Queries + +To disable caching on certain queries as you might want to project on only a few columns, +rather than the full dataset. Just call `disableCaching()`: + +```java + +select(My_Table.column, My_Table.column2) + .from(My.class) + .disableCaching() + .queryList(); + +``` + +## Advanced + +### Specifying cache Size + +To specify cache size, set `@Table(cacheSize = {size})`. Please note that not all +caches support sizing. It's up to each cache. + +### Custom Caches + +To specify a custom cache for a table, please define a `public static final` field: + +```java + +@ModelCacheField +public static ModelCache modelCache = new SimpleMapCache<>(); // replace with any cache you want. + +``` + +### Multiple Primary Key Caching + +This allows for tables that have multiple primary keys be used in caching. To use, +add a `@MultiCacheField` `public static final` field. +for example we have a `Coordinate` class: + + +```java + + +@Table(database = AppDatabase.class, cachingEnabled = true) +public class Coordinate { + + @MultiCacheField + public static final IMultiKeyCacheConverter multiKeyCacheModel = new IMultiKeyCacheConverter() { + + @Override + @NonNull + public String getCachingKey(@NonNull Object[] values) { + return "(" + values[0] + "," + values[1] + ")"; + } + }; + + @PrimaryKey + double latitude; + + @PrimaryKey + double longitude; + + +``` + +In this case we use the `IMultiKeyCacheConverter` class, which specifies a key type +that the object returns. The `getCachingKey` method returns an ordered set of `@PrimaryKey` +columns in declaration order. Also the value that is returned should have an `equals()` or `hashcode()` specified +especially when used in the `SimpleMapCache`. diff --git a/ContentProviderGeneration.md b/ContentProviderGeneration.md new file mode 100644 index 000000000..3bf2d5566 --- /dev/null +++ b/ContentProviderGeneration.md @@ -0,0 +1,234 @@ +# Content Provider Generation +This library includes a very fast, easy way to use `ContentProvider`! Using annotations, you can generate `ContentProvider` with ease. + +## Getting Started +This feature is largely based off of [schematic](https://github.com/SimonVT/schematic), + while leveraging DBFlow's power. + +### Placeholder ContentProvider +In order to define a `ContentProvider`, you must define it in a placeholder class: + +```java + +@ContentProvider(authority = TestContentProvider.AUTHORITY, + database = TestDatabase.class, + baseContentUri = TestContentProvider.BASE_CONTENT_URI) +public class TestContentProvider { + + public static final String AUTHORITY = "com.raizlabs.android.dbflow.test.provider"; + + public static final String BASE_CONTENT_URI = "content://"; + +} +``` + +or you can use the annotation in any class you wish. The recommended place would be in a `@Database` placeholder class. This is to simplify some of the declarations and keep it all in one place. + +```java + +@ContentProvider(authority = TestDatabase.AUTHORITY, + database = TestDatabase.class, + baseContentUri = TestDatabase.BASE_CONTENT_URI) +@Database(name = TestDatabase.NAME, version = TestDatabase.VERSION) +public class TestDatabase { + + public static final String NAME = "TestDatabase"; + + public static final int VERSION = "1"; + + public static final String AUTHORITY = "com.raizlabs.android.dbflow.test.provider"; + + public static final String BASE_CONTENT_URI = "content://"; + +} +``` + +### Adding To Manifest +In other applications or your current's `AndroidManifest.xml` add the **generated $Provider** class: + +```xml + + +``` + +`android:exported`: setting this to true, enables other applications to make use of it. + +**True** is recommended for outside application access. + +**Note you must have at least one `@TableEndpoint` for it to compile/pass error checking** + +### Adding endpoints into the data +There are two ways of defining `@TableEndpoint`: +1. Create an inner class within the `@ContentProvider` annotation. +2. Or Add the annotation to a `@Table` and specify the content provider class name (ex. TestContentProvider) + +`@TableEndpoint`: links up a query, insert, delete, and update to a specific table in the `ContentProvider` local database. + +Some recommendations: +1. (if inside a `@ContentProvider` class) Name the inner class same as the table it's referencing +2. Create a `public static final String ENDPOINT = "{tableName}"` field for reusability +3. Create `buildUri()` method (see below) to aid in creating other ones. + +To define one: + +```java + +@TableEndpoint(ContentProviderModel.ENDPOINT) +public static class ContentProviderModel { + + public static final String ENDPOINT = "ContentProviderModel"; + + private static Uri buildUri(String... paths) { + Uri.Builder builder = Uri.parse(BASE_CONTENT_URI + AUTHORITY).buildUpon(); + for (String path : paths) { + builder.appendPath(path); + } + return builder.build(); + } + + @ContentUri(path = ContentProviderModel.ENDPOINT, + type = ContentUri.ContentType.VND_MULTIPLE + ENDPOINT) + public static Uri CONTENT_URI = buildUri(ENDPOINT); + +} +``` + +or via the table it belongs to + +```java + + +@TableEndpoint(name = ContentProviderModel.NAME, contentProvider = ContentDatabase.class) +@Table(database = ContentDatabase.class, tableName = ContentProviderModel.NAME) +public class ContentProviderModel extends BaseProviderModel { + + public static final String NAME = "ContentProviderModel"; + + @ContentUri(path = NAME, type = ContentUri.ContentType.VND_MULTIPLE + NAME) + public static final Uri CONTENT_URI = ContentUtils.buildUriWithAuthority(ContentDatabase.AUTHORITY); + + @PrimaryKey(autoincrement = true) + long id; + + @Column + String notes; + + @Column + String title; + + @Override + public Uri getDeleteUri() { + return TestContentProvider.ContentProviderModel.CONTENT_URI; + } + + @Override + public Uri getInsertUri() { + return TestContentProvider.ContentProviderModel.CONTENT_URI; + } + + @Override + public Uri getUpdateUri() { + return TestContentProvider.ContentProviderModel.CONTENT_URI; + } + + @Override + public Uri getQueryUri() { + return TestContentProvider.ContentProviderModel.CONTENT_URI; + } +} +``` + +There are much more detailed usages of the `@ContentUri` annotation. Those will be in a later section. + +### Connect Model operations to the newly created ContentProvider +There are two kinds of `Model` that connect your application to a ContentProvider that was defined in your app, or another app. Extend these for convenience, however they are not required. + +`BaseProviderModel`: Overrides all `Model` methods and performs them on the `ContentProvider` + +`BaseSyncableProviderModel`: same as above, except it will synchronize the data changes with the local app database as well! + +#### Interacting with the Content Provider +You can use the `ContentUtils` methods: + +```java + +ContentProviderModel contentProviderModel = ...; // some instance + +int count = ContentUtils.update(getContentResolver(), ContentProviderModel.CONTENT_URI, contentProviderModel); + +Uri uri = ContentUtils.insert(getContentResolver(), ContentProviderModel.CONTENT_URI, contentProviderModel); + +int count = ContentUtils.delete(getContentResolver(), someContentUri, contentProviderModel); +``` + +**Recommended** usage is extending `BaseSyncableProviderModel` (for inter-app usage) so the local database contains the same data. Otherwise `BaseProviderModel` works just as well. + +```java + +MyModel model = new MyModel(); +model.id = 5; +model.load(); // queries the content provider + +model.someProp = "Hello" +model.update(false); // runs an update on the CP + +model.insert(false); // inserts the data into the CP +``` + +## Advanced Usage +### Notify Methods +You can define `@Notify` method to specify a custom interaction with the `ContentProvider` and return a custom `Uri[]` that notifies the contained `ContentResolver`. These methods can have any valid parameter from the `ContentProvider` methods. + +Supported kinds include: +1. Update +2. Insert +3. Delete + +#### Example + +```java + +@Notify(method = Notify.Method.UPDATE, +paths = {}) // specify paths that will call this method when specified. +public static Uri[] onUpdate(Context context, Uri uri) { + + return new Uri[] { + // return custom uris here + }; +} +``` + +### ContentUri Advanced +#### Path Segments +Path segments enable you to "filter" the uri query, update, insert, and deletion by a specific column and a value define by '#'. + +To specify one, this is an example `path` + +```java + +path = "Friends/#/#" +``` + +then match up the segments as: + +```java + +segments = {@PathSegment(segment = 1, column = "id"), + @PathSegment(segment = 2, column = "name")} +``` + +And to put it all together: + +```java + +@ContentUri(type = ContentType.VND_MULTIPLE, +path = "Friends/#/#", +segments = {@PathSegment(segment = 1, column = "id"), + @PathSegment(segment = 2, column = "name")}) +public static Uri withIdAndName(int id, String name) { + return buildUri(id, name); +} +``` diff --git a/Databases.md b/Databases.md new file mode 100644 index 000000000..b61b8feb4 --- /dev/null +++ b/Databases.md @@ -0,0 +1,131 @@ +# Databases + +This section describes how databases are created in DBFlow and some more +advanced features. + +## Creating a Database + +In DBFlow, creating a database is as simple as only a few lines of code. DBFlow +supports any number of databases, however individual tables and other related files +can only be associated with one database. + +```java + +@Database(name = AppDatabase.NAME, version = AppDatabase.VERSION) +public class AppDatabase { + + public static final String NAME = "AppDatabase"; // we will add the .db extension + + public static final int VERSION = 1; +} + + +``` + +## Database Migrations + +Database migrations are run when upon open of the database connection, +the version number increases on an existing database. + +It is preferred that `Migration` files go in the same file as the database, for +organizational purposes. +An example migration: + +```java + +@Database(name = AppDatabase.NAME, version = AppDatabase.VERSION) +public class AppDatabase { + + public static final String NAME = "AppDatabase"; // we will add the .db extension + + public static final int VERSION = 2; + + @Migration(version = 2, database = MigrationDatabase.class) + public static class AddEmailToUserMigration extends AlterTableMigration { + + public AddEmailToUserMigration(Class table) { + super(table); + } + + @Override + public void onPreMigrate() { + addColumn(SQLiteType.TEXT, "email"); + } + } +} + +``` +This simple example adds a column to the `User` table named "email". In code, just add +the column to the `Model` class and this migration runs only on existing dbs. + To read more on migrations and more examples of different kinds, visit the [page](/usage2/Migrations.md). + +## Advanced Database features + +This section goes through features that are for more advanced use of a database, +and may be very useful. + +### Prepackaged Databases +To include a prepackaged database for your application, simply include the ".db" file in `src/main/assets/{databaseName}.db`. On creation of the database, we copy over the file into the application for usage. Since this is prepackaged within the APK, we cannot delete it once it's copied over, +which can bulk up your raw APK size. _Note_ this is only copied over on initial creation +of the database for the app. + +### Global Conflict Handling +In DBFlow when an INSERT or UPDATE are performed, by default, we use `NONE`. If you wish to configure this globally, you can define it to apply for all tables from a given database: + + +```java + +@Database(name = AppDatabase.NAME, version = AppDatabase.VERSION, insertConflict = ConflictAction.IGNORE, updateConflict= ConflictAction.REPLACE) +public class AppDatabase { +} + +``` + +These follow the SQLite standard [here](https://www.sqlite.org/conflict.html). + +### Integrity Checking + +Databases can get corrupted or in an invalid state at some point. If you specify +`consistencyChecksEnabled=true` It runs a `PRAGMA quick_check(1)` +whenever the database is opened. If it fails, you should provide a backup database +that it will copy over. If not, **we wipe the internal database**. Note that during this +time in case of failure we create a **third copy of the database** in case transfer fails. + +### Custom FlowSQLiteOpenHelper + +For variety of reasons, you may want to provide your own `FlowSQLiteOpenHelper` +to manage database interactions. To do so, you must implement `OpenHelper`, but +for convenience you should extend `FlowSQLiteOpenHelper` (for Android databases), +or `SQLCipherOpenHelper` for SQLCipher. Read more [here](/usage2/SQLCipherSupport.md) + +```java + + +public class CustomFlowSQliteOpenHelper extends FlowSQLiteOpenHelper { + + public CustomFlowSQliteOpenHelper(BaseDatabaseDefinition databaseDefinition, DatabaseHelperListener listener) { + super(databaseDefinition, listener); + } +} + + +``` + +Then in your `DatabaseConfig`: + +```java + +FlowManager.init(new FlowConfig.Builder(RuntimeEnvironment.application) + .addDatabaseConfig( + new DatabaseConfig.Builder(CipherDatabase.class) + .openHelper(new DatabaseConfig.OpenHelperCreator() { + @Override + public OpenHelper createHelper(DatabaseDefinition databaseDefinition, DatabaseHelperListener helperListener) { + return new CustomFlowSQliteOpenHelper(databaseDefinition, helperListener); + } + }) + .build()) + .build()); + + +``` diff --git a/GettingStarted.md b/GettingStarted.md new file mode 100644 index 000000000..9f40e7307 --- /dev/null +++ b/GettingStarted.md @@ -0,0 +1,154 @@ +# Getting Started + +This section describes how Models and tables are constructed via DBFlow. first +let's describe how to get a database up and running. + +## Creating a Database + +In DBFlow, creating a database is as simple as only a few lines of code. DBFlow +supports any number of databases, however individual tables and other related files +can only be associated with one database. + +```java + +@Database(name = AppDatabase.NAME, version = AppDatabase.VERSION) +public class AppDatabase { + + public static final String NAME = "AppDatabase"; // we will add the .db extension + + public static final int VERSION = 1; +} + + +``` + +Writing this file generates (by default) a `AppDatabaseAppDatabase_Database.java` +file, which contains tables, views, and more all tied to a specific database. This +class is automatically placed into the main `GeneratedDatabaseHolder`, which holds +potentially many databases. The name, `AppDatabaseAppDatabase_Database.java`, is generated +via {DatabaseClassName}{DatabaseFileName}{GeneratedClassSepator, default = "\_"}Database + +To learn more about what you can configure in a database, read [here](/usage2/Databases.md) + +## Initialize FlowManager + +DBFlow needs an instance of `Context` in order to use it for a few features such +as reading from assets, content observing, and generating `ContentProvider`. + +Initialize in your `Application` subclass. You can also initialize it from other +`Context` but we always grab the `Application` `Context` (this is done only once). + +```java +public class ExampleApplication extends Application { + + @Override + public void onCreate() { + super.onCreate(); + FlowManager.init(this); + } +} + +``` + +Finally, add the definition to the manifest (with the name that you chose for your custom application): +```xml + + +``` + +A database within DBFlow is only initialized once you call `FlowManager.getDatabase(SomeDatabase.class).getWritableDatabase()`. If you +don't want this behavior or prefer it to happen immediately, modify your `FlowConfig`: + +```java + +@Override +public void onCreate() { + super.onCreate(); + FlowManager.init(new FlowConfig.Builder(this) + .openDatabasesOnInit(true).build()); +} + +``` + +If you do not like the built-in `DefaultTransactionManager`, or just want to roll your own existing system: + +```java + +FlowManager.init(new FlowConfig.Builder(this) + .addDatabaseConfig( + new DatabaseConfig.Builder(AppDatabase.class) + .transactionManager(new CustomTransactionManager()) + .build())); + +``` +You can define different kinds for each database. +To read more on transactions and subclassing `BaseTransactionManager` go [here](/usage2/StoringData.md) + + +## Create Models + +Creating models are as simple as defining the model class, and adding the `@Table` annotation. +To read more on this, read [here](/usage2/Models.md). + +An example: + +```java + + +@Table(database = TestDatabase.class) +public class Currency { + + @PrimaryKey(autoincrement = true) + long id; // package-private recommended, not required + + @Column + @Unique + String symbol; + + @Column + String shortName; + + @Column + @Unique + private String name; // private with getters and setters + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } +} + +``` + +## Perform Some Queries + +DBFlow uses expressive builders to represent and translate to the SQLite language. + +A simple query in SQLite: + +```sqlite + +SELECT * FROM Currency WHERE symbol='$'; + +``` + +Can be represented by: + +```java + +SQLite.select() + .from(Currency.class) + .where(Currency_Table.symbol.eq("$")); + +``` + +We support many kinds of complex and complicated queries using the builder +language. To read more about this, see [the wrapper language docs](/usage2/SQLiteWrapperLanguage.md) + +There is much more you can do in DBFlow. Read through the other docs to +get a sense of the library. diff --git a/Indexing.md b/Indexing.md new file mode 100644 index 000000000..1e8129b55 --- /dev/null +++ b/Indexing.md @@ -0,0 +1,78 @@ +# Indexing + +In SQLite, an `Index` is a pointer to specific columns in a table that enable super-fast retrieval. + +__Note__: The database size can increase significantly, however if performance is more important, the tradeoff is worth it. + +Indexes are defined using the `indexGroups()` property of the `@Table` annotation. These operate similar to how `UniqueGroup` work: +1. specify an `@IndexGroup` +2. Add the `@Index` +3. Build and an `IndexProperty` gets generated. This allows super-easy access to the index so you can enable/disable it with ease. + +__Note__: `Index` are not explicitly enabled unless coupled with an `IndexMigration`. ([read here](/usage2/Migrations.md#index-migrations)). + +You can define as many `@IndexGroup` you want within a `@Table` as long as one field references the group. Also individual `@Column` can belong to any number of groups: + +```java + +@Table(database = TestDatabase.class, + indexGroups = { + @IndexGroup(number = 1, name = "firstIndex"), + @IndexGroup(number = 2, name = "secondIndex"), + @IndexGroup(number = 3, name = "thirdIndex") + }) +public class IndexModel2 { + + @Index(indexGroups = {1, 2, 3}) + @PrimaryKey + int id; + + @Index(indexGroups = 1) + @Column + String first_name; + + @Index(indexGroups = 2) + @Column + String last_name; + + @Index(indexGroups = {1, 3}) + @Column + Date created_date; + + @Index(indexGroups = {2, 3}) + @Column + boolean isPro; +} +``` + +By defining the index this way, we generate an `IndexProperty`, which makes it very +easy to enable, disable, and use it within queries: + +```java + +IndexModel2_Table.firstIndex.createIfNotExists(); + +SQLite.select() + .from(IndexModel2.class) + .indexedBy(IndexModel2_Table.firstIndex) + .where(...); // do a query here. + +IndexModel2_Table.firstIndex.drop(); // turn it off when no longer needed. +``` + +## SQLite Index Wrapper + +For flexibility, we also support the SQLite `Index` wrapper object, in which the `IndexProperty` +uses underneath. + +```java + +Index index = SQLite.index("MyIndex") + .on(SomeTable.class, SomeTable_Table.name, SomeTable_Table.othercolumn); +index.enable(); + +// do some operations + +index.disable(); // disable when no longer needed + +``` diff --git a/Intro.md b/Intro.md new file mode 100644 index 000000000..cb3ae6b7b --- /dev/null +++ b/Intro.md @@ -0,0 +1,126 @@ +# DBFlow + +DBFlow for Android lets you write very efficient database code while remaining +expressive and concise. + +```java + +@Table(database = AppDatabase.class) +public class Automobile extends BaseModel { // convenience, but not required to interact with db + + @PrimaryKey + String vin; + + @Column + String make; + + @Column + String model; + + @Column + int year; + +} + +Automobile venza = new Automobile(); +venza.vin = "499499449"; +venza.make = "Toyota"; +venza.model = "Venza"; +venza.year = 2013; +venza.save(); // inserts if not exists by primary key, updates if exists. + +// querying +// SELECT * FROM `Automobile` WHERE `year`=2001 AND `model`='Camry' +// we autogen a "_Table" class that contains convenience Properties which provide easy SQL ops. +SQLite().select() + .from(Automobile.class) + .where(Automobile_Table.year.is(2001)) + .and(Automobile_Table.model.is("Camry")) + .async() + .queryResultCallback(new QueryTransaction.QueryResultCallback() { + @Override + public void onQueryResult(QueryTransaction transaction, @NonNull CursorResult tResult) { + // called when query returns on UI thread + List autos = tResult.toListClose(); + // do something with results + } + }, new Transaction.Error() { + @Override + public void onError(Transaction transaction, Throwable error) { + // handle any errors + } + }).execute(); + +// run a transaction synchronous easily. +DatabaseDefinition database = FlowManager.getDatabase(AppDatabase.class); +database.executeTransaction(new ITransaction() { + @Override + public void execute(DatabaseWrapper databaseWrapper) { + // do something here + } +}); + +// run asynchronous transactions easily, with expressive builders +database.beginTransactionAsync(new ITransaction() { + @Override + public void execute(DatabaseWrapper databaseWrapper) { + // do something in BG + } + }).success(successCallback).error(errorCallback).build().execute(); + +``` + +## Proguard + +Since DBFlow uses annotation processing, which is run pre-proguard phase, +the configuration is highly minimal: + +``` +-keep class * extends com.raizlabs.android.dbflow.config.DatabaseHolder { *; } +``` + +## Sections + +For migrating from 3.x to 4.0, read [here](/usage2/Migration4Guide.md) + +The list of documentation is listed here: + + [Getting Started](/usage2/GettingStarted.md) + + [Databases](/usage2/Databases.md) + + [Models](/usage2/Models.md) + + [Relationships](/usage2/Relationships.md) + + [Storing Data](/usage2/StoringData.md) + + [Retrieval](/usage2/Retrieval.md) + + [The SQLite Wrapper Language](/usage2/SQLiteWrapperLanguage.md) + + [Caching](/usage2/Caching.md) + + [List-Based Queries](/usage2/ListBasedQueries.md) + + [Migrations](/usage2/Migrations.md) + + [Observability](/usage2/Observability.md) + + [Type Converters](/usage2/TypeConverters.md) + +For advanced DBFlow usages: + + [Kotlin Support](/usage2/KotlinSupport.md) + + [RX Java Support](/usage2/RXSupport.md) + + [Multiple Modules](/usage2/MultipleModules.md) + + [Views](/usage2/ModelViews.md) + + [Query Models](/usage2/QueryModels.md) + + [Indexing](/usage2/Indexing.md) + + [SQLCipher](/usage2/SQLCipherSupport.md) diff --git a/KotlinSupport.md b/KotlinSupport.md new file mode 100644 index 000000000..51eb891eb --- /dev/null +++ b/KotlinSupport.md @@ -0,0 +1,231 @@ +# Kotlin Support + Extensions + +DBFlow supports Kotlin out of the box and is fairly easily to use and implement. + +To add useful Kotlin-specific extensions: +``` +dependencies { + compile "com.github.Raizlabs.DBFlow:dbflow-kotlinextensions:${dbflow_version}@aar" +} + +``` +We also support [kotlin extensions for RX 1 + 2](/usage2/RXSupport.md)! + +## Classes + +DBFlow Classes are beautifully concise to write: + +```kotlin +@Table(database = KotlinDatabase::class) +class Person(@PrimaryKey var id: Int = 0, @Column var name: String? = null) +``` + +Also `data` classes are supported. + +```kotlin +@Table(database = KotlinTestDatabase::class) +data class Car(@PrimaryKey var id: Int = 0, @Column var name: String? = null) +``` + +In 4.0.0+, DBFlow contains a few extensions for Kotlin models which enable you +to keep your models acting like `BaseModel`, but do not have to explicitly extend +the class! + +```kotlin + +car.save() // extension method, optional databaseWrapper parameter. +car.insert() +car.update() +car.delete() +car.exists() + +``` + +## Query LINQ Syntax + +Kotlin has nice support for custim `infix` operators. Using this we can convert a regular, Plain old java query into a C#-like LINQ syntax. + +java: +``` + +List = SQLite.select() + .from(Result.class) + .where(Result_Table.column.eq(6)) + .and(Result_Table.column2.in("5", "6", "9")).queryList() + +``` + +kotlin: + +``` +val 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 +``` + +Enabling us to write code that is closer in syntax to SQLite! + +This supported for almost any SQLite operator that this library provides including: + 1. `Select` + 2. `Insert` + 3. `Update` + 4. `Delete` + +**Async Operations**: +With extensions we also support `async` operations on queries: + +```kotlin + +// easy async list query +(select + from Result::class + where (column eq 6)) +.async list { transaction, list -> + // do something here + updateUI(list) +} + +// easy single result query +(select + from Result::class + where (column eq 6)) +.async result { transaction, model -> + // do something here + updateUI(model) +} + +val model = Result() + +model.async save { + // completed, now do something with model +} + +``` + +### Property Extensions + +With Kotlin, we can define extension methods on pretty much any class. + +With this, we added methods to easily create `IProperty` from anything to make +queries a little more streamlined. In this query, we also make use of the extension +method for `from` to streamline the query even more. + +```kotlin + +var query = (select + from TestModel::class + where (5.property lessThan column) + and (clause(date.property between start_date) + and(end_date))) + + +``` + +### Query Extensions + +We can easily create nested `Operator` into `OperatorGroup` also fairly easily, also +other, random extensions: +```kotlin + +select from SomeTable::class where (name.eq("name") and id.eq(0)) + +"name".op() collate NOCASE + +"name".nameAlias + +"name".nameAlias `as` "My Name" + +// query sugar + +select from SomeTable::class where (name eq "name") or (id eq 0) + +``` + + +### Database Extensions + +#### Process Models Asynchronously + +In Java, we need to write something of the fashion: + +```java + +List items = SQLite.select() + .from(TestModel.class) + .queryList(); + + database.beginTransactionAsync(new ProcessModelTransaction.Builder<>( + new ProcessModel() { + @Override + public void processModel(TestModel model, DatabaseWrapper database) { + + } + }) + .success(successCallback) + .error(errorCallback).build() + .execute(); + +``` + +In Kotlin, we can use a combo of DSL and extension methods to: + +```kotlin + +var items = (select from TestModel1::class).list + + // easily delete all these items. + items.processInTransactionAsync { it, databaseWrapper -> it.delete(databaseWrapper) } + + // easily delete all these items with success + items.processInTransactionAsync({ it, databaseWrapper -> it.delete(databaseWrapper) }, + Transaction.Success { + // do something here + }) +// delete with all callbacks +items.processInTransactionAsync({ it, databaseWrapper -> it.delete(databaseWrapper) }, + Transaction.Success { + // do something here + }, + Transaction.Error { transaction, throwable -> + + }) + +``` + +The extension method on `Collection` allows you to perform this on all +collections from your Table! + +If you wish to easily do them _synchronously_ then use: + +```kotlin + +items.processInTransaction { it, databaseWrapper -> it.delete(databaseWrapper) } + +``` + +#### Class Extensions + +If you need access to the Database, ModelAdapter, etc for a specific class you +can now use the following (and more) reified global functions for easy access! + +```kotlin + +database() + +databaseForTable() + +writableDatabaseForTable() + +tableName() + +modelAdapter() + + +``` + +Which under-the-hood call their corresponding `FlowManager` methods. diff --git a/ListBasedQueries.md b/ListBasedQueries.md new file mode 100644 index 000000000..1e2949e01 --- /dev/null +++ b/ListBasedQueries.md @@ -0,0 +1,157 @@ +# List-Based Queries + +When we have large datasets from the database in our application, we wish to +display them in a `ListView`, `RecyclerView` or some other component that recycles +it's views. Instead of running a potentially very large query on the database, +converting it to a `List` and then keeping that chunk of memory active, we +can lazy-load each row from the query/table. + +DBFlow makes it easy using the `FlowCursorList`, for simple `BaseAdapter`-like methods, +or the `FlowQueryList`, which implements the `List` interface. + +Getting one of these lists is as simple as: + +```java + +FlowQueryList list = SQLite.select() + .from(MyTable.class) + .where(...) // some conditions + .flowQueryList(); +FlowCursorList list = SQLite.select() + .from(MyTable.class) + .where(...) // some conditions + .cursorList(); + + list.close(); // ensure you close these, as they utilize active cursors :) + +``` + +Any query method allows you to retrieve a default implementation of each. You +can also manually instantiate them: + +```java + +FlowQueryList list = new FlowQueryList.Builder<>(SQLite.select().from(MyTable.class)) + .cachingEnabled(false) // caching enabled by default + .build(); + +FlowCursorList list = new FlowCursorList.Builder<>(SQLite.select().from(MyTable.class)) + .cachingEnabled(true) + .modelCache(cache) // provide custom cache for this list + .build(); + +``` + +## Caching + +Both of these classes come with the ability to cache `Model` used in it's queries +so that loading only happens once and performance can remain high once loaded. The default +caching mechanism is a `ModelLruCache`, which provides an `LruCache` to manage +loading `Model`. + +They are done in almost the same way: + +```java + +FlowCursorList list = new FlowCursorList.Builder<>(SQLite.select().from(MyTable.class)) + .modelCache(cache) // provide custom cache for this list + .build(); +FlowQueryList list = new FlowQueryList.Builder<>(SQLite.select().from(MyTable.class)) + .modelCache(cache) + .build(); + +``` + +## FlowCursorList + +The `FlowCursorList` is simply a wrapper around a standard `Cursor`, giving it the +ability to cache `Model`, load items at specific position with conversion, and refresh +it's content easily. + +The `FlowCursorList` by default caches its results, for fast usage. The cache size is determined by the `ModelCache` you're using. Read on [here](/usage2/Caching.md). + +The `FlowCursorList` provides these methods: + + 1. `getItem(position)` - loads item from `Cursor` at specified position, caching and loading from cache (if enabled) + 2. `refresh()` - re-queries the underlying `Cursor`, clears out the cache, and reconstructs it. Use a `OnCursorRefreshListener` to get callbacks when this occurs. + 3. `getAll()` - returns a `List` of all items from the `Cursor`, no caching used + 4. `getCount()` - returns count of `Cursor` or 0 if `Cursor` is `null` + 5. `isEmpty()` - returns if count == 0 + 6. `clearCache()` - manually clears cache + +## Flow Query List + +This class is a much more powerful version of the `FlowCursorList`. It contains a `FlowCursorList`, +which backs it's retrieval operations. + +This class acts as `List` and can be used almost wherever a `List` is used. Also, it is a `FlowContentObserver` +see [Observability](/usage2/Observability.md), meaning other classes can listen +for its specific changes and it can auto-refresh itself when content changes. + +Feature rundown: + 1. `List` implementation of a Query + 2. `FlowContentObserver`, only for the table that it corresponds to in its initial `ModelQueriable` query statement. Mostly used for self refreshes. + 3. Transact changes to the query asynchronously (note that this refreshes itself every callback unless in a transaction state) + 5. Caching (almost same implementation as `FlowCursorList`) + +### List Implementation + +The `List` implementation is mostly for convenience. Please note that most of the modification +methods (`add`, `addAll` etc.) may not affect the query that you expect it to, unless the object you pass +objects that are valid for the query and you enable self refreshes. + +The retrieval methods are where the query works as you would expect. `get()` calls +`getItem()` on the internal `FlowCursorList`, `isEmpty()`, `getCount()`, etc all correspond +to the `Cursor` underneath. + +Both `FlowQueryList` and `FlowTableList` support `Iterator` and provide a very +efficient class: `FlowCursorIterator` that iterates through each row in a `Cursor` +and provides efficient operations. + +**Note**: any retrieval operation that turns it into another object (i.e. `subList()`, +`toArray`, etc) retrieves all objects contained in the query into memory, +and then converts it using the associated method on that returned `List`. + +### FlowContentObserver Implementation + +Using the `FlowContentObserver`, we can enable self-refreshes whenever a model changes +for the table this query points to. See [Observability](/usage2/Observability.md). + +To turn on self-refreshes, call `registerForContentChanges(context)`, which requeries +the data whenever it changes. + +We recommend placing this within a transaction on the `FlowQueryList`, so we only +refresh content the minimal amount of times: + +```java + +flowQueryList.beginTransaction(); + +// perform a bunch of modifications + +flowQueryList.endTransactionAndNotify(); + +``` + +To listen for `Cursor` refreshes register a `OnCursorRefreshListener`: + +```java + +modelList + .addOnCursorRefreshListener(new FlowCursorList.OnCursorRefreshListener() { + @Override + public void onCursorRefreshed(FlowCursorList cursorList) { + + } + }); + +``` + + +### Transact Changes Asynchronously + +If you want to pass or modify the `FlowQueryList` asynchronously, set `setTransact(true)`. +This will run all modifications in a `Transaction` and when completed, a `Cursor` refresh occurs. + +You can also register `Transaction.Error` and `Transaction.Success` callbacks for these modifications +on the `FlowQueryList` to handle when these `Transaction` finish. diff --git a/Migration3Guide.md b/Migration3Guide.md new file mode 100644 index 000000000..dd2c606c6 --- /dev/null +++ b/Migration3Guide.md @@ -0,0 +1,630 @@ +# DBFlow 3.0 Migration Guide +DBFlow has undergone the most _significant_ changes in its lifetime in 3.0. This guide is meant to assist you in migrating from 2.1.x and above and _may not_ be fully inclusive of all changes. This doc will mention the most glaring and significant changes. If in doubt, consult the usage2 docs. + +A significant portion of the changes include the _complete_ overhaul of the underlying annotation processor, leading to wonderful improvements in maintainability of the code, readability, and stability of the generated code. Now it uses the updated [JavaPoet](https://github.com/square/javapoet) vs the outdated JavaWriter. The changes in this library alone _significantly_ helps out the stability of the generated code. + +_Some Changes to Note:_ +1. `update` no longer attempts to `insert` if it fails. +2. Package private fields from other packages are now automatically accessible via generated `_Helper` classes. The referenced fields must be annotated with `@Column`, `@PrimaryKey`, or `@ForeignKey`. if its a legacy `ForeignKeyReference`, `referendFieldIsPackagePrivate()` must be set to true. +3. `@Column` no longer required in conjunction with `@PrimaryKey` or `@ForeignKey` +4. Can now have DBFlow in multiple modules, libraries, etc via "Modules"! +5. `TransactionManager` has been replaced with a new per-database `BaseTransactionManager`. Each DB has its own `DBTransactionQueue` and you can replace the default with your own system. Also, no longer is this priority-based, but rather order-based. See more [here](/usage2/Transactions.md) + +This doc is to provide some basic examples of what has changed, but read all of the new usage docs! +Starting with [Intro](/usage2/Intro.md) + +## Table Of Contents + 1. [Initialization](/usage2/Migration3Guide.md#initialization) + 2. [Database + Table Structure](/usage2/Migration3Guide.md#database-and-table-structure) + 3. [Transactions Overhaul](/usage2/Migration3Guide.md#transactions-overhaul) + 4. [Properties](/usage2/Migration3Guide.md#properties) + 5. [ModelContainers](/usage2/Migration3Guide.md#modelcontainers) + 6. [ModelViews](/usage2/Migration3Guide.md#modelviews) + 7. [Caching](/usage2/Migration3Guide.md#caching) + 8. [Database Modules](/usage2/Migration3Guide.md#database-modules) + +## Initialization + +Previously DBFlow was intialized via: + +```java +public class ExampleApplication extends Application { + + @Override + public void onCreate() { + super.onCreate(); + FlowManager.init(this); + } +} + +``` + +Now we use the `FlowConfig.Builder`: + +```java +public class ExampleApplication extends Application { + + @Override + public void onCreate() { + super.onCreate(); + FlowManager.init(new FlowConfig.Builder(this).build()); + } +} + +``` + +See more of what you can customize [here](/usage2/GettingStarted.md) + +## Database And Table Structure +### Database changes +The default `generatedClassSeparator` is now `_` instead of `$` to play nice with Kotlin by default. A simple addition of: + +```java + +@Database(generatedClassSeparator = "$") +``` + +will keep your generated "Table" and other classes the same name. + +Globally, we no longer reference what `@Database` any database-specific element (Table, Migration, etc) by `String` name, but by `Class` now. + +Before: + +```java + +@Table(databaseName = AppDatabase.NAME) +@Migration(databaseName = AppDatabase.NAME) +``` + +After: + +```java + +@Table(database = AppDatabase.class) +@Migration(database = AppDatabase.class) +``` + +Why: We decided that referencing it directly by class name enforces type-safety and direct enforcement of the database placeholder class. Previously, + +```java + +@Table(databaseName = "AppDatabase") +``` + +was a valid specifier, which might lead to typos or errors. + +## Table Changes +`@Table` have some significant changes. + +Private boolean fields by default have changed. +`useIsForPrivateBooleans()` has changed to `useBooleanGetterSetters()`. By default +this is enabled, meaning `boolean` variables follow the convention: + +```java + +private boolean isEnabled; + +public boolean isEnabled() { + return isEnabled; +} + +public void setEnabled(boolean isEnabled) { + this.isEnabled = isEnabled; +} + +``` + +Instead of generating just `String` column name within a corresponding `$Table` class, it now generates `Property` fields. These fields are significantly smarter and more powerful. They considerably aid in the simplification of many complex queries and make the code in general more readable, type-safe, and just overall better. _NOTE: the properties are no longer capitalized, rather they match exact casing of the Column name._ + +Previously, when you defined a class as: + +```java + +@Table(databaseName = TestDatabase.NAME) +@ModelContainer +public class TestModel2 extends BaseModel { + + @Column + @PrimaryKey + String name; + + @Column(name = "model_order") + int order; +} +``` + +It generated a `TestModel2$Table` class: + +```java + +public final class TestModel2_Table { + + public static final String NAME = "name"; + + public static final String MODEL_ORDER = "model_order"; +} +``` + +Now when you define a class, it generates a definition as follows: + +```java +public final class TestModel2_Table { + public static final Property name = new Property(TestModel2.class, "name"); + + public static final IntProperty model_order = new IntProperty(TestModel2.class, "model_order"); + + public static final IProperty[] getAllColumnProperties() { + return new IProperty[]{name,model_order}; + } + + public static BaseProperty getProperty(String columnName) { + columnName = QueryBuilder.quoteIfNeeded(columnName); + switch (columnName) { + case "`name`": { + return name; + } + case "`model_order`": { + return model_order; + } + default: { + throw new IllegalArgumentException("Invalid column name passed. Ensure you are calling the correct table's column"); + } + } + } +} +``` + +Each `Property` now is used for each all references to a column in query statements. + +The `getProperty()` method allows to keep compatibility with the old format, solve some `ContentProvider` compatibility issues, or allow looking up `Property` by key. + +To read on how these properties interact read "Properties, Conditions, Queries, Replacement of ConditionQueryBuilder and more". + +### Index changes +Added was an `IndexGroup[]` of `indexGroups()`. + +Now we can generate `IndexProperty` (see properties for more information), which provide us a convenient generated `Index` to use for the table. This then is used in a queries that rely on indexes and make it dead simple to activate and deactivate indexes. + +A class written like: + +```java +@Table(database = TestDatabase.class, + indexGroups = { + @IndexGroup(number = 1, name = "firstIndex"), + @IndexGroup(number = 2, name = "secondIndex"), + @IndexGroup(number = 3, name = "thirdIndex") + }) +public class IndexModel2 extends BaseModel { + + @Index(indexGroups = {1, 2, 3}) + @PrimaryKey + int id; + + @Index(indexGroups = 1) + @Column + String first_name; + + @Index(indexGroups = 2) + @Column + String last_name; + + @Index(indexGroups = {1, 3}) + @Column + Date created_date; + + @Index(indexGroups = {2, 3}) + @Column + boolean isPro; +} +``` + +Generates in its "Table" class: + +```java +public final class IndexModel2_Table { + //...previous code omitted + + public static final IndexProperty index_firstIndex = new IndexProperty<>("firstIndex", false, IndexModel2.class, id, first_name, created_date); + + public static final IndexProperty index_secondIndex = new IndexProperty<>("secondIndex", false, IndexModel2.class, id, last_name, isPro); + + public static final IndexProperty index_thirdIndex = new IndexProperty<>("thirdIndex", false, IndexModel2.class, id, created_date, isPro); +``` + +### Foreign Key Changes +`@ForeignKey` fields no longer need to specify it's references or the `@Column` annotation!!! The old way still works, but is no longer necessary for `Model`-based ForeignKeys. The annotation processor takes the primary keys of the referenced table and generates a column with {fieldName}_{referencedColumnName} that represents the same SQLite Type of the field.
_Note: that is not backwards compatible_ with apps already with references. + +Going forward with new tables, you can leave them out. + +Previously: + +```java +@Table(database = TestDatabase.class) +public class ForeignInteractionModel extends TestModel1 { + + @Column + @ForeignKey( + onDelete = ForeignKeyAction.CASCADE, + onUpdate = ForeignKeyAction.CASCADE, + references = + {@ForeignKeyReference(columnName = "testmodel_id", + foreignColumnName = "name", + columnType = String.class), + @ForeignKeyReference(columnName = "testmodel_type", + foreignColumnName = "type", + columnType = String.class)}, + saveForeignKeyModel = false) + ForeignKeyContainer testModel1; +} +``` + +Now: + +```java +@Table(database = TestDatabase.class) +public class ForeignInteractionModel extends TestModel1 { + + @ForeignKey( + onDelete = ForeignKeyAction.CASCADE, + onUpdate = ForeignKeyAction.CASCADE, + saveForeignKeyModel = false) + ForeignKeyContainer testModel1; +} +``` + +The result is _significantly_ cleaner and less overhead to maintain. + +If you wish to keep old references, please keep in mind that `foreignColumnName` is now `foreignKeyColumnName`. + +## Transactions Overhaul + +In 3.0, Transactions got a serious facelift and should be easier to use and handle. +Also their logic and use are much more consolidated a focused. There is no longer +just one `TransactionManager`, rather each database has its own instance so that +operations between databases don't interfere. + +### Inserting Data +The format of how to declare them has changed: +Previously to run a transaction, you had to set it up as so: + +```java +ProcessModelInfo processModelInfo = ProcessModelInfo.withModels(models) + .result(resultReceiver) + .info(myInfo); +TransactionManager.getInstance().addTransaction(new SaveModelTransaction<>(processModelInfo)) +TransactionManager.getInstance().addTransaction(new UpdateModelListTransaction<>(processModelInfo)) +TransactionManager.getInstance().addTransaction(new DeleteModelListTransaction<>(processModelInfo)) + + +``` + +In 3.0, we have dropped the individual transaction types, use a new builder notation, +and with _every_ `Transaction` you get completion and error handling: + +```java + +FlowManager.getDatabase(AppDatabase.class) + .beginTransactionAsync(new ProcessModelTransaction.Builder<>( + new ProcessModelTransaction.ProcessModel() { + @Override + public void processModel(Model model) { + + } + }).build()) + .error(new Transaction.Error() { + @Override + public void onError(Transaction transaction, Throwable error) { + + } + }) + .success(new Transaction.Success() { + @Override + public void onSuccess(Transaction transaction) { + + } + }).build().execute(); + +``` + +One thing to note about the `Transaction.Error` is that if specified, _all_ exceptions +are caught and passed to the callback, otherwise any exception that happens in the Transaction system +gets thrown. + +You still can use the `DBBatchSaveQueue` for batch saves: + +Previously: + +```java + +TransactionManager.getInstance().saveOnSaveQueue(models); + +``` + +In 3.0: + +```java + +FlowManager.getDatabase(AppDatabase.class).getTransactionManager() + .getSaveQueue().addAll(models); + + +``` + +### Querying Data + +Previously when you queried data you have a few different classes that did almost same thing +such as `SelectListTransaction`, `BaseResultTransaction`, `QueryTransaction`, etc. +3.0 consolidates these into much simpler operations via: + +Previously: + +```java + +TransactionManager.getInstance().addTransaction(new SelectListTransaction<>(new TransactionListenerAdapter() { + @Override + public void onResultReceived(List testModels) { + + } + }, TestModel.class, condition1, condition2,..); + + +``` +In 3.0: + +```java + +database.beginTransactionAsync( + new QueryTransaction.Builder<>( + SQLite.select().from(TestModel1.class)) + .queryResult(new QueryTransaction.QueryResultCallback() { + @Override + public void onQueryResult(QueryTransaction transaction, @NonNull CursorResult result) { + + } + }).build()).build(); + +``` + +The `QueryResultCallback` gives back a `CursorResult`, which is a wrapper around abstract +`Cursor` that lets you retrieve easily `Models` from that cursor: + +```java +List models = result.toListClose(); +TestModel1 singleModel = result.toModelClose(); +``` + +Just ensure that you close the `Cursor`. + +### Callback Changes + +With 3.0, we modified the callback for a `Transaction`. Instead of having the +3 methods: + +```java +public interface TransactionListener { + + void onResultReceived(ResultClass result); + + boolean onReady(BaseTransaction transaction); + + boolean hasResult(BaseTransaction transaction, ResultClass result); + +} +``` + +Each `Transaction` automatically gives you ability to handle callbacks: + +```java + + +FlowManager.getDatabase(AppDatabase.class) + .beginTransactionAsync(new ITransaction() { + @Override + public void execute(DatabaseWrapper databaseWrapper) { + // do anything you want here. + } + }).build()) + .error(new Transaction.Error() { + @Override + public void onError(Transaction transaction, Throwable error) { + + } + }) + .success(new Transaction.Success() { + @Override + public void onSuccess(Transaction transaction) { + + } + }).build().execute(); + +``` + +For more usage on the new system, including the ability to roll your own `TransactionManager`, +visit [Transactions](/usage2/Transactions.md) + + +## Properties +Perhaps the most significant external change to this library is making queries, conditions, and interactions with the database much stricter and more type-safe. + +### Property +Properties replace `String` column names generated in the "$Table" classes. They also match exact case to the column name. They have methods that generate `Condition` that drastically simplify queries. (Please note the `Condition` class has moved to the `.language` package). + +Properties are represented by the interface `IProperty` which are subclassed into `Property`, `Method`, and the primitive properties (`IntProperty`, `CharProperty`, etc). + +Properties can also be represented by values via the `PropertyFactory` class, enabling values to appear first in queries: + +```java +PropertyFactory.from(5l) // generates LongProperty +PropertyFactory.from(5d) // generates DoubleProperty +PropertyFactory.from("Hello") // generates Property +PropertyFactory.from(Date.class, someDate) // generates Property +``` + +It will become apparent why this change was necessary with some examples: + +A non-simple query by SQLite standards: + +```sql +SELECT `name` AS `employee_name`, AVG(`salary`) AS `average_salary`, `order`, SUM(`salary`) as `sum_salary` + FROM `SomeTable` + WHERE `salary` > 150000 +``` + +Before: + +```java +List items = + new Select(ColumnAlias.column(SomeTable$Table.NAME).as("employee_name"), + ColumnAlias.columnsWithFunction("AVG", SomeTable$Table.SALARY).as("average_salary"), + SomeTable$Table.ORDER, + ColumnAlias.columnsWithFunction("SUM", SomeTable$Table.SALARY).as("sum_salary")) + .from(SomeTable.class) + .where(Condition.column(SomeTable$Table.SALARY).greaterThan(150000)) + .queryCustomList(SomeQueryTable.class); +``` + +Now (with static import on `SomeTable_Table` and `Method` ): + +```java +List items = + SQLite.select(name.as("employee_name"), + avg(salary).as("average_salary"), + order, + sum(salary).as("sum_salary")) + .from(SomeTable.class) + .where(salary.greaterThan(150000)) + .queryCustomList(SomeQueryTable.class); +``` + +The code instantly becomes cleaner, and reads more like an actual query. + +### Replacement of the ConditionQueryBuilder +ConditionQueryBuilder was fundamentally flawed. It represented a group of `Condition`, required a `Table`, yet extended `QueryBuilder`, meaning arbitrary `String` information could be appended to it, leading to potential for messy piece of query. + +It has been replaced with the `ConditionGroup` class. This class represents an arbitrary group of `SQLCondition` in which it's sole purpose is to group together `SQLCondition`. Even better a `ConditionGroup` itself is a `SQLCondition`, meaning it can _nest_ inside of other `ConditionGroup` to allow complicated and insane queries. + +Now you can take this: + +```sql +SELECT FROM `SomeTable` WHERE 0 < `latitude` AND (`longitude` > 50 OR `longitude` < 25) AND `name`='MyHome' +``` + +and turn it into: + +```java +SQLite.select() + .from(SomeTable.class) + .where(PropertyFactory.from(0).lessThan(SomeTable_Table.latitude)) + .and(ConditionGroup.clause() + .and(SomeTable_Table.longitude.greaterThan(50)) + .or(SomeTable_Table.longitude.lessThan(25))) + .and(SomeTable_Table.name.eq("MyHome")) +``` + +## ModelContainers +Now `ModelContainer` objects have a multitude of type-safe methods to ensure that they can convert their contained object's data into the field they associate with. What this means is that if our `Model` has a `long` field, while the data object for the `ModelContainer` has a `Integer` object. Previously, we would get a classcastexception. Now what it does is "coerce" the value into the type you need. Supported Types: +1. Integer/int +2. Double/Double +3. Boolean/boolean +4. Short/short +5. Long/long +6. Float/Float +7. String +8. Blob/byte[]/Byte[] +9. Byte/byte +10. Using TypeConverter to retrieve value safely. + +You can now `queryModelContainer` from the database to retrieve a single `Model` into `ModelContainer` format instead of into `Model` and then `ModelContainer`: + +```java + +JSONModel model = SQLite.select().from(SomeTable.class).where(SomeTable_Table.id.eq(5)).queryModelContainer(new JSONModel()); +JSONObject json = model.getData(); +// has data now +``` + +For the `toModel()` conversion/parse method from `ModelContainer` to `Model`, you can now: +1. Have `@Column` excluded from it via `excludeFromToModelMethod()` +2. include other fields in the method as well by adding the `@ContainerKey` annotation to them. + +## ModelViews +No longer do we need to specify the query for the `ModelView` in the annotation without ability to use the wrappper classes. We define a `@ModelViewQuery` field to use and then it simply becomes: + +```java +@ModelViewQuery + public static final Query QUERY = new Select(AModel_Table.time) + .from(AModel.class).where(AModel_Table.time.greaterThan(0l)); +``` + +What this means is that its easier than before to use Views. + +## Caching +I significantly revamped model caching in this release to make it easier, support more tables, and more consistent. Some of the significant changes: + +Previously you needed to extend `BaseCacheableModel` to enable model caching. No longer! The code that was there now generates in the corresponding `ModelAdapter` by setting `cachingEnabled = true` in the `@Table` annotation. + +Before + +```java +@Table(databaseName = TestDatabase.NAME) +public class CacheableModel extends BaseCacheableModel { + + @Column + @PrimaryKey(autoincrement = true) + long id; + + @Column + String name; + + @Override + public int getCacheSize() { + return 1000; + } +} +``` + +After: + +```java +@Table(database = TestDatabase.class, cachingEnabled = true, cacheSize = 1000) +public class CacheableModel extends BaseModel { + + @PrimaryKey(autoincrement = true) + long id; + + @Column + String name; +} +``` + +Also, you can now have caching objects with _multiple_ primary keys!!! + +Simply in your model class define a `@MultiCacheField` and now you can cache objects with multiple primary keys: + +```java +@Table(database = TestDatabase.class, cachingEnabled = true) +public class MultipleCacheableModel extends BaseModel { + + @MultiCacheField + public static IMultiKeyCacheConverter multiKeyCacheModel = new IMultiKeyCacheConverter() { + + @Override + @NonNull + public String getCachingKey(@NonNull Object[] values) { + return "(" + values[0] + "," + values[1] + ")"; + } + }; + + @PrimaryKey + double latitude; + + @PrimaryKey + double longitude; + +} +``` + +Please note that the field must be of type `IMultiKeyCacheConverter` in order to compile and convert correctly. You must provide one, otherwise caching will not work. Also the return caching key _must_ be unique, otherwise inconsistent results may occur from within the cache. + +## Database Modules +Now in DBFlow we have support for libraries, other subprojects, and more in general to all use DBFlow at the same time. The only requirement is that they specify an argument to `apt` in order to prevent clashes and the library loads the class during the initialization phase. To read on how to do this (fairly simply), please check it out here: ([Database Modules](https://github.com/Raizlabs/DBFlow/blob/master/usage/DatabaseModules.md)) diff --git a/Migration4Guide.md b/Migration4Guide.md new file mode 100644 index 000000000..d90d65c75 --- /dev/null +++ b/Migration4Guide.md @@ -0,0 +1,40 @@ +# DBFlow 4.0 Migration guide + +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 much less 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. + +8. `Condition` are now `Operator`, this includes `SQLCondition` -> `SQLOperator`, `ConditionGroup` -> `OperatorGroup`. `Operator` are now typed and safer to use. + 1. `Operator` now also have `div`, `times`, `rem`, `plus` and `minus` methods. + +9. Property class changes: + 1. All primitive `Property` classes have been removed. We already boxed the values internally anyways so removing them cut down on method count and maintenance. + 2. `BaseProperty` no longer needs to exist, so all of it's methods now exist in `Property` + 3. `mod` method is now `rem` (remainder) method to match Kotlin 1.1's changes. + 4. `dividedBy` is now `div` to match Kotlin operators. + 5. `multipliedBy` is now `times` to match Kotlin operators. + +10. Rewrote all Unit tests to be more concise, better tested, and cleaner. + +11. A lot of bug fixes + +12. Kotlin: + 1. Added more Kotlin extensions. + 2. Most importantly you don't need to use `BaseModel`/`Model` at all anymore if you so choose. There are `Model`-like extension methods that supply the `Model` methods. + 3. Updated to version 1.1.1 + +13. RXJava1 and RXJava2 support! Can now write queries that return `Observable` and more. diff --git a/Migrations.md b/Migrations.md new file mode 100644 index 000000000..ad73848fd --- /dev/null +++ b/Migrations.md @@ -0,0 +1,175 @@ +# Migrations + +In this section we will discuss how migrations work, how each of the provided +migration classes work, and how to create your own custom one. + +There are two kinds of migrations that DBFlow supports: Script-based SQL files +and class annotation-based migrations. + +## How Migrations Work + +In SQL databases, migrations are used to modify or change existing database schema to adapt +to changing format or nature of stored data. In SQLite we have a limited ability +compared to SQL to modify tables and columns of an existing database. There are only +two kinds of modifications that exist: rename table and add a new column. + +In DBFlow migrations are not only used to modify the _structure_ of the database, but also other operations such as insert data into a database (for prepopulate), or add an index on a specific table. + +Migrations are only run on an existing database _except_ for the "0th" migration. Read [initial database setup](/usage2/Migrations.md#initial-database-setup) + +### Migration Classes + +We recommend placing any `Migration` inside an associated `@Database` class so it's apparent the migration is tied to it. +An example migration class: + +```java +@Database(version = 2, name = AppDatabase.NAME) +public class AppDatabase { + + public static final String NAME = "AppDatabase"; + + @Migration(version = 2, database = AppDatabase.class) + public static class Migration2 extends BaseMigration { + + @Override + public void migrate(DatabaseWrapper database) { + // run some code here + SQLite.update(Employee.class) + .set(Employee_Table.status.eq("Invalid")) + .where(Employee_Table.job.eq("Laid Off")) + .execute(database); // required inside a migration to pass the wrapper + } + } +} +``` + +The classes provide the ability to set a `priority` on the `Migration` so that an order is established. The higher the priority, that one will execute first. + +`Migration` have three methods: + 1. `onPreMigrate()` - called first, do setup, and construction here. + 2. `migrate()` -> called with the `DatabaseWrapper` specified, this is where the actual migration code should execute. + 3. `onPostMigrate()` -> perform some cleanup, or any notifications that it was executed. + +### Migration files + +DBFlow also supports `.sql` migration files. The rules on these follows must be followed: + 1. Place them in `assets/migrations/{DATABASE_NAME}/{versionNumber}.sql`. So that an example `AppDatabase` migration for version 2 resides in `assets/migrations/AppDatabase/2.sql` + 2. The file can contain any number of SQL statements - they are executed in order. Each statement must be on a single line or multiline and must end with `;` + 3. Comments are allowed as long as they appear on an individual file with standard SQLite comment syntax `--` + +### Prevent Recursive Access to the DB + +Since `Migration` occur when the database is opening, we cannot recursively access the database object in our models, SQLite wrapper statements, and other classes in DBFlow that are inside a `Migration`. + +To remedy that, DBFlow comes with support to pass the `DatabaseWrapper` into almost all places that require it: + 1. All query language `BaseQueriable` objects such as `Select`, `Insert`, `Update`, `Delete`, etc have methods that take in the `DatabaseWrapper` + 2. Any subclass of `BaseModel` (`Model` does not provide the methods for simplicity) + +### Initial Database Setup + +DBFlow supports `Migration` that run on version "0" of a database. When Android opens a `SQLiteDatabase` object, if the database is created, DBFlow calls on a `Migration` of -1 to 0th version. In this case, any `Migration` run at `version = 0` will get called. Once a database is created, this migration will not run again. So if you had an existent database at version 1, and changed version to 2, the "0th" `Migration` is not run because the old version the database would have been 1. + +## Provided Migration Classes + +In DBFlow we provide a few helper `Migration` subclasses +to provide default and easier implementation: + 1. `AlterTableMigration` + 2. `IndexMigration/IndexPropertyMigration` + 3. `UpdateTableMigration` + +### AlterTableMigration + +The _structural_ modification of a table is brought to a handy `Migration` subclass. + +It performs both of SQLite supported operations: + 1. Rename tables + 2. Add columns. + +For renaming tables, you should rename the `Model` class' `@Table(name = "{newName}")` before running +this `Migration`. The reason is that DBFlow will know +the new name only and the existing database will get caught up on it through this migration. Any new database created on a device will automatically have the new table name. + +For adding columns, we only support `SQLiteType` (all supported ones [here](https://www.sqlite.org/datatype3.html)) operations to add or remove columns. This is to enforce that the columns are created properly. If a column needs to be a `TypeConverter` column, use the database value from it. We map the associated type of the database field to a `SQLiteType` in [SQLiteType.java](/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/SQLiteType.java). So if you have a `DateConverter` that specifies a `Date` column converted to `Long`, then you should look up `Long` in the `Map`. In this case `Long` converts to `INTEGER`. + +```java + + +@Migration(version = 2, database = AppDatabase.class) +public class Migration2 extends AlterTableMigration { + + public Migration2(Class table) { + super(table); + } + + @Override + public void onPreMigrate() { + addColumn(SQLiteType.TEXT, "myColumn"); + addColumn(SQLiteType.REAL, "anotherColumn"); + } +} + +``` + +### Index Migrations + +An `IndexMigration` (and `IndexPropertyMigration`) is used to structurally activate an `Index` on the database at a specific version. See [here](/usage2/Indexing.md) for information on creating them. + +`IndexMigration` does not require an `IndexProperty` to run, while `IndexPropertyMigration` makes use of the property to run. + +An `IndexMigration`: + +```java + +@Migration(version = 2, priority = 0, database = MigrationDatabase.class) +public static class IndexMigration2 extends IndexMigration { + + public IndexMigration2(@NonNull Class onTable) { + super(onTable); + } + + @NonNull + @Override + public String getName() { + return "TestIndex"; + } +} +``` + +An `IndexPropertyMigration`: + +```java + +@Migration(version = 2, priority = 1, database = MigrationDatabase.class) +public static class IndexPropertyMigration2 extends IndexPropertyMigration { + + @NonNull + @Override + public IndexProperty getIndexProperty() { + return IndexModel_Table.index_customIndex; + } +} + +``` + +### Update Table Migration + +A simple wrapper around `Update`, provides simply a default way to update data during a migration. + +```java + + +@Migration(version = 2, priority = 2, database = MigrationDatabase.class) +public static class UpdateMigration2 extends UpdateTableMigration { + + /** + * Creates an update migration. + * + * @param table The table to update + */ + public UpdateMigration2(Class table) { + super(table); + set(MigrationModel_Table.name.eq("New Name")); + } + +} + ``` diff --git a/ModelViews.md b/ModelViews.md new file mode 100644 index 000000000..f9eb4dcbb --- /dev/null +++ b/ModelViews.md @@ -0,0 +1,47 @@ +# ModelViews + +A `ModelView` is a SQLite representation of a `VIEW`. Read official SQLite docs +[here](https://www.sqlite.org/lang_createview.html) for more information. + +As with SQLite a `ModelView` cannot insert, update, or delete itself as it's +read-only. It is a virtual "view" placed on top of a regular table as a prepackaged +`Select` statement. In DBFlow using a `ModelView` should feel familiar and be very simple. + +```java + +@ModelView(database = TestDatabase.class) +public class TestModelView { + + @ModelViewQuery + public static final Query QUERY = SQLite.select().from(TestModel2.class) + .where(TestModel2_Table.model_order.greaterThan(5)); + + @Column + long model_order; +} + +``` + +To specify the query that a `ModelView` creates itself with, we _must_ define +a public static final field annotated with `@ModelViewQuery`. This tells DBFlow +what field is the query. This query is used only once when the database is created +(or updated) to create the view. + + +The full list of limitations/supported types are: + 1. Only `@Column` are allowed + 2. No `@PrimaryKey` or `@ForeignKey` + 3. Supports all fields, and accessibility modifiers that `Model` support + 4. Does not support `@InheritedField`, `@InheritedPrimaryKey` + 5. Basic, type-converted, non-model `@Column`. + 6. __Cannot__: update, insert, or delete + +`ModelView` are used identical to `Model` when retrieving from the database: + +```java + +SQLite.select() + .from(TestModelView.class) + .where(...) // ETC + +``` diff --git a/Models.md b/Models.md new file mode 100644 index 000000000..f48853b45 --- /dev/null +++ b/Models.md @@ -0,0 +1,163 @@ +# Models + +In DBFlow we dont have any restrictions on what your table class is. We do, however recommend you subclass `BaseModel` on +your highest-order base-class, which provides a default implementation for you. + +When using regular models: +```java +FlowManager.getModelAdapter(MyTable.class).save(myTableObject); +``` + +When using `BaseModel`, it is much cleaner: + +```java +myTableObject.save(); +``` + +## Columns + +We, by default, lazily look for columns. This means that they all must contain either `@PrimaryKey`, `@Column`, or `@ForeignKey` to be used in tables. + +If you wish to make it simpler and include all fields in a class, set `@Table(allFields = true)`. +However this still requires you to specify at least one `@PrimaryKey` field. You +can then explicitly ignore fields via the `@ColumnIgnore` annotation. + +Columns can be `public`, package-private, or `private`. +`private` fields __must__ come with `public` java-bean-style getters and setters. + +Here is an example of a "nice" `private` field: + +```java +@Table(database = AppDatabase.class) +public class Dog { + + @PrimaryKey + private String name; + + public void setName(String name) { + this.name = name; + } + + public String getName() { + return name; + } + +} + +``` + +Columns have a wide-range of supported types in the `Model` classes: +**Supported Types**: + 1. all java primitives including `char`,`byte`, `short`, and `boolean`. + 2. All java boxed primitive classes + 3. String, Date, java.sql.Date, Calendar, Blob, Boolean + 4. Custom data types via a [TypeConverter](/usage2/TypeConverters.md) + 5. `Model` as fields, but only as `@PrimaryKey` and/or `@ForeignKey` + +**Unsupported Types**: + 1. `List` : List columns are not supported and not generally proper for a relational database. However, you can get away with a non-generic `List` column via a `TypeConverter`. But again, avoid this if you can. + 2. Anything that is generically typed (even with an associated `TypeConverter`). If you need to include the field, subclass the generic object and provide a `TypeConverter`. + +## Inherited Columns + +Since we don't require extension on `BaseModel` directly, tables can extend non-model classes and inherit their fields directly (given proper accessibility) via the `@InheritedColumn` annotation (or `@InheritedPrimaryKey` for primary keys): + +```java + +@Table(database = AppDatabase.class, + inheritedColumns = {@InheritedColumn(column = @Column, fieldName = "name"), + @InheritedColumn(column = @Column, fieldName = "number")}, + inheritedPrimaryKeys = {@InheritedPrimaryKey(column = @Column, + primaryKey = @PrimaryKey, + fieldName = "inherited_primary_key")}) +public class InheritorModel extends InheritedModel implements Model { + +``` + +## Primary Keys + +DBFlow supports multiple primary keys, right out of the box. Simply create a table with multiple `@PrimaryKey`: + +```java +@Table(database = AppDatabase.class) +public class Dog extends BaseModel { + + @PrimaryKey + String name; + + @PrimaryKey + String breed; + +} + +``` + +If we want an auto-incrementing key, you specify `@PrimaryKey(autoincrement = true)`, but only one of these kind can exist in a table and you cannot mix with regular primary keys. + +## Unique Columns + +DBFlow has support for SQLite `UNIQUE` constraint (here for documentation)[http://www.tutorialspoint.com/sqlite/sqlite_constraints.htm]. + +Add `@Unique` annotation to your existing `@Column` and DBFlow adds it as a constraint when +the database table is first created. This means that once it is created you should not change or modify this. + +We can _also_ support multiple unique clauses in order to ensure any combination of fields are unique. For example: + +To generate this in the creation query: +```sqlite +UNIQUE('name', 'number') ON CONFLICT FAIL, UNIQUE('name', 'address') ON CONFLICT ROLLBACK +``` +We declare the annotations as such: + +```java + +@Table(database = AppDatabase.class, + uniqueColumnGroups = {@UniqueGroup(groupNumber = 1, uniqueConflict = ConflictAction.FAIL), + @UniqueGroup(groupNumber = 2, uniqueConflict = ConflictAction.ROLLBACK)) +public class UniqueModel { + + @PrimaryKey + @Unique(unique = false, uniqueGroups = {1,2}) + String name; + + @Column + @Unique(unique = false, uniqueGroups = 1) + String number; + + @Column + @Unique(unique = false, uniqueGroups = 2) + String address; + +} + +``` + +The `groupNumber` within each defined `uniqueColumnGroups` with an associated `@Unique` column. We need to specify `unique=false` for any column used in a group so we expect the column to be part of a group. If true as well, the column will _also_ alone be unique. + +## Default Values + +DBFlow supports default values in a slighty different way that SQLite does. Since we do not know +exactly the intention of missing data when saving a `Model`, since we group all fields, `defaultValue` specifies +a value that we replace when saving to the database when the value of the field is `null`. + +This feature only works on Boxed primitive and the `DataClass` equivalent of objects (such as from TypeConverter), such as String, Integer, Long, Double, etc. +__Note__: If the `DataClass` is a `Blob`, unfortunately this will not work. +For `Boolean` classes, use "1" for true, "0" for false. + +```java + +@Column(defaultValue = "55") +Integer count; + +@Column(defaultValue = "\"this is\"") +String test; + +@Column(defaultValue = "1000L") +Date date; + +@Column(defaultValue = "1") +Boolean aBoolean; + +``` + +DBFlow inserts it's literal value into the `ModelAdapter` for the table so any `String` must be escaped. diff --git a/MultipleModules.md b/MultipleModules.md new file mode 100644 index 000000000..69c963f83 --- /dev/null +++ b/MultipleModules.md @@ -0,0 +1,48 @@ +# Multiple Database Modules + +In apps that want to share DBFlow across multiple modules or when developing a library +module that uses DBFlow, we have to provide a little extra configuration to properly +ensure that all database classes are accounted for. + +It's directly related to the fact that annotation processors are isolated between projects +and are not shared. + +In order to add support for multiple modules, in each and every library/subproject that uses +a DBFlow instance, you must add an APT argument (using the [android-apt plugin](https://bitbucket.org/hvisser/android-apt)) to its `build.gradle`: + +```java +apt { + arguments { + targetModuleName 'SomeUniqueModuleName' + } +} +``` + +or for if you use Kotlin, KAPT: + +```java +kapt { + generateStubs = true + arguments { + arg("targetModuleName", "SomeUniqueModuleName") + } +} +``` + + +By passing the targetModuleName, we append that to the `GeneratedDatabaseHolder` class name to create the `{targetModuleName}GeneratedDatabaseHolder` module. __Note__: Specifying this in code means +you need to specify the module when initializing DBFlow: + +From previous sample code, we recommend initializing the specific module inside your library, +to prevent developer error. __Note__: Multiple calls to `FlowManager` will not adversely +affect DBFlow. If DBFlow is already initialized, we append the module to DBFlow if and only if it does not already exist. + +```java + +public void initialize(Context context) { + FlowManager.init(new FlowConfig.Builder(context) + .addDatabaseHolder(SomeUniqueModuleNameGeneratedDatabaseHolder.class) + .build()); +} + +``` diff --git a/Observability.md b/Observability.md new file mode 100644 index 000000000..9655381f8 --- /dev/null +++ b/Observability.md @@ -0,0 +1,154 @@ +# Observability + +DBFlow provides a flexible way to observe changes on models and tables in this library. + +By default, DBFlow utilizes the [`ContentResolver`](https://developer.android.com/reference/android/content/ContentResolver.html) +to send changes through the android system. We then can utilize [`ContentObserver`](http://developer.android.com/reference/android/database/ContentObserver.html) to listen for these changes via the `FlowContentObserver`. + +Also, DBFlow also supports direct [model notification](/usage2/Observability.md#direct-changes) via a custom `ModelNotifier`. + +## FlowContentObserver + +The content observer converts each model passed to it into `Uri` format that describes the `Action`, primary keys, and table of the class that changed. + +A model: +```kotlin + +@Table(database = AppDatabase.class) +class User(@PrimaryKey var id: Int = 0, @Column var name: String = "") + +``` + +with data: +```kotlin + +User(55, "Andrew Grosner").delete() + +``` + +converts to: + +``` +dbflow://%60User%60?%2560id%2560=55#DELETE +``` + +Then after we register a `FlowContentObserver`: + +```java + +FlowContentObserver observer = new FlowContentObserver(); + +observer.registerForContentChanges(context, User.class); + +// do something here +// unregister when done +observer.unregisterForContentChanges(context); + +``` + +## Model Changes + +It will now receive the `Uri` for that table. Once we have that, we can register for model changes on that content: + +```java + +observer.addModelChangeListener(new OnModelStateChangedListener() { + @Override + public void onModelStateChanged(@Nullable Class table, BaseModel.Action action, @NonNull SQLOperator[] primaryKeyValues) { + // do something here + } +}); + + +``` +The method will return the `Action` which is one of: + 1. `SAVE` (will call `INSERT` or `UPDATE` as well if that operation was used) + 2. `INSERT` + 3. `UPDATE` + 4. `DELETE` + +The `SQLOperator[]` passed back specify the primary column and value pairs that were changed for the model. + +If we want to get less granular and just get notifications when generally a table changes, read on. + +## Register for Table Changes + +Table change events are similar to `OnModelStateChangedListener`, except that they only specify the table and action taken. These get called for any action on a table, including granular model changes. We recommend batching those events together, which we describe in the next section. + +```java + +addOnTableChangedListener(new OnTableChangedListener() { + @Override + public void onTableChanged(@Nullable Class tableChanged, BaseModel.Action action) { + // perform an action. May get called many times! Use batch transactions to combine them. + } +}); + +``` + +## Batch Up Many Events + +Sometimes we're modifying tens or hundreds of items at the same time and we do not wish to get notified for _every_ one but only once for each _kind_ of change that occurs. + +To batch up the notifications so that they fire all at once, we use batch transactions: + +```java + +FlowContentObserver observer = new FlowContentObserver(); + +observer.beginTransaction(); + +// save, modify models here +for(User user: users) { + users.save(); +} + +observer.endTransactionAndNotify(); // callback batched + +``` + +Batch interactions will store up all unique `Uri` for each action (these include `@Primary` key of the `Model` changed). When `endTransactionAndNotify()` is called, +all those `Uri` are called in the `onChange()` method from the `FlowContentObserver` as expected. + +If we are using `OnTableChangedListener` callbacks, then by default we will receive one callback per `Action` per table. If we wish to only receive a single callback, set `setNotifyAllUris(false)`, which will make the `Uri` all only specify `CHANGE`. + +# Direct Changes + +DBFlow also supports direct observability on model changes rather than convert those models into `Uri` and have to decipher what has changed. + +To set up direct changes we override the default `ModelNotifier`: + +```java + +FlowManager.init(FlowConfig.Builder(context) + .addDatabaseConfig(DatabaseConfig.Builder(TestDatabase.class) + .modelNotifier(DirectModelNotifier.get()) + .build()).build()); + +``` + +We must use the shared instance of the `DirectModelNotifier` since if we do not, your listeners will not receive callbacks. + +Next register for changes on the `DirectModelNotifier`: +```java + +DirectModelNotifier.get().registerForModelChanges(User.class, new ModelChangedListener() { + @Override + public void onModelChanged(User model, BaseModel.Action action) { + // react to model changes + } + + @Override + public void onTableChanged(BaseModel.Action action) { + // react to table changes. + } + };) + +``` + +Then unregister your model change listener when you don't need it anymore (to prevent memory leaks): + +```java +DirectModelNotifier.get().unregisterForModelChanges(Userr.class, modelChangedListener); + +``` diff --git a/QueryModels.md b/QueryModels.md new file mode 100644 index 000000000..8fd081423 --- /dev/null +++ b/QueryModels.md @@ -0,0 +1,107 @@ +# Query Models + +A `QueryModel` is purely an ORM object that maps rows from a `Cursor` into +a `Model` such that when loading from the DB, we can easily use the data from it. + +We use a different annotation, `@QueryModel`, to define it separately. These +do not allow for modifications in the DB, rather act as a marshal agent out of the DB. + +## Define a QueryModel + +For this example, we have a list of employees that we want to gather the average salary +for each position in each department from our company. + +We defined an `Employee` table: + +```java + +@Table(database = AppDatabase.class) +public class EmployeeModel { + + @PrimaryKey + String uid; + + @Column + long salary; + + @Column + String name; + + @Column + String title; + + @Column + String department; +} + +``` + +We need someway to retrieve the results of this query, since we want to avoid +dealing with the `Cursor` directly. We can use a SQLite query with our existing models, but +we have no way to map it currently to our tables, since the query returns new Columns +that do not represent any existing table: + +```java + +SQLite.select(EmployeeModel_Table.department, + Method.avg(EmployeeModel_Table.salary.as("average_salary")), + EmployeeModel_Table.title) + .from(EmployeeModel.class) + .groupBy(EmployeeModel_Table.department, EmployeeModel_Table.title); + +``` + +So we must define a `QueryModel`, representing the results of the query: + +```java +@QueryModel(database = AppDatabase.class) +public class AverageSalary { + + @Column + String title; + + @Column + long average_salary; + + @Column + String department; +} +``` + +And adjust our query to handle the new output: + +```java + +SQLite.select(EmployeeModel_Table.department, + Method.avg(EmployeeModel_Table.salary.as("average_salary")), + EmployeeModel_Table.title) + .from(EmployeeModel.class) + .groupBy(EmployeeModel_Table.department, EmployeeModel_Table.title) + .async() + .queryResultCallback(new QueryTransaction.QueryResultCallback() { + @Override + public void onQueryResult(QueryTransaction transaction, @NonNull CursorResult tResult) { + List queryModels = tResult.toCustomListClose(AverageSalary.class); + + // do something with the result + } + }).execute(); + +``` + +## Query Model Support + +`QueryModel` support only a limited subset of `Model` features. + +If you use the optional base class of `BaseQueryModel`, + Modifications such as `insert()`, `update()`, `save()`, and `delete()` will throw + an `InvalidSqlViewOperationException`. Otherwise, `RetrievalAdapter` do not + contain modification methods. + +They support `allFields` and inheritance and visibility modifiers as defined by [Models](/usage2/Models.md). + +`QueryModel` **do not** support: + 1. `InheritedField`/`InheritedPrimaryKey` + 2. `@PrimaryKey`/`@ForeignKey` + 3. caching + 4. changing "useBooleanGetterSetters" for private boolean fields. diff --git a/RXSupport.md b/RXSupport.md new file mode 100644 index 000000000..c9e365377 --- /dev/null +++ b/RXSupport.md @@ -0,0 +1,170 @@ +# RXJava Support + +RXJava support in DBFlow is an _incubating_ feature and likely to change over time. We support both RX1 and RX2 and have made the extensions + DBFlow compatibility almost identical - save for the changes and where it makes sense in each version. + +Currently it supports + 1. `Insert`, `Update`, `Delete`, `Set`, `Join`, and all wrapper query mechanisms by wrapping them in `rx()` + 2. Single + `List` model `save()`, `insert()`, `update()`, and `delete()`. + 3. Streaming a set of results from a query + 4. Observing on table changes for specific `ModelQueriable` and providing ability to query from that set repeatedly as needed. + 5. Kotlin extension methods in a separate artifact that enhance the conversion. + +## Getting Started + +Add the separate packages to your project: +```groovy + +dependencies { + // RXJava1 + compile "com.github.Raizlabs.DBFlow:dbflow-rx:${dbflow_version}" + + // optional, for use with Kotlin as a nice companion. + compile "com.github.Raizlabs.DBFlow:dbflow-rx-kotlinextensions:${dbflow_version}" + + // RXJava2 + compile "com.github.Raizlabs.DBFlow:dbflow-rx2:${dbflow_version}" + + // optional, for use with Kotlin as a nice companion. + compile "com.github.Raizlabs.DBFlow:dbflow-rx2-kotlinextensions:${dbflow_version}" +} + +``` + +## Wrapper Language +Using the classes is as easy as wrapping all SQL wrapper calls with `RXSQLite.rx()` (Kotlin we supply extension method): + +Before: +```java + +List list = SQLite.select() + .from(MyTable.class) + .queryList(); + +``` + +After: + +```java + +RXSQLite.rx( + SQLite.select().from(MyTable.class)) + .queryList() + .subscribe((list) -> { + + }); + +``` + +or with Kotlin + extension methods: +```kotlin + + select.from(MyTable::class.java) + .rx() + .list { list -> + + } + +``` + +## Model operations +To make the transition as smoothest as possible, we've provided a `BaseRXModel` which replaces `BaseModel` for convenience in the RX space. + +```kotlin + +class Person(@PrimaryKey var id: Int = 0, @Column var name: String? = "") : BaseRXModel + +``` + +Operations are as easy as: +```java + +new Person(5, "Andrew Grosner") + .insert() + .subscribe((rowId) -> { + + }); + +``` + +or with Kotlin+extensions: +```kotlin + +Person(5, "Andrew Grosner") + .insert { rowId -> + + } + +``` + +## Query Stream + +We can use RX to stream the result set, one at a time from the `ModelQueriable` using +the method `queryStreamResults()`: + +```java + +RXSQLite.rx( + SQLite.select() + .from(TestModel1.class)) + .queryStreamResults() + .subscribe((model) -> { + + }); + +``` + +## Kotlin Support + +Most of the support mirrors [kotlin support](/usage2/KotlinSupport.md) with a few +minor changes. + +Extension properties/methods include: + 1. `rx()` extension method making it super easy to integrate RX. + 2. `RXModelQueriable.streamResults` - stream results one at time to a `Subscription` + 3. `list`, `result`,`streamResults`, `cursorResult`,`statement`, `hasData`, `cursor`, and `count` all provide a method lambda that is called within a `Subscription`. + +```kotlin + +select from MyTable::class + where (MyTable.name `is` "Good") + list { list -> // + + } + +``` + +which is the same with RX as: + +```kotlin + +(select.from(MyTable::class.java) + .where(MyTable.name `is` "Good")) + .rx() + .list { list -> + + } + +``` + + +Or if we want to get pretty with `BaseRXModel` + extensions: + +```kotlin + +Person("Somebody").save { success -> + // do something +} + +Person("Somebody").update { success -> + // do something +} + +Person("Somebody").insert { rowId -> + // do something +} + +Person("Somebody").delete { success -> + // do something +} + +``` diff --git a/Relationships.md b/Relationships.md new file mode 100644 index 000000000..ba69ce54d --- /dev/null +++ b/Relationships.md @@ -0,0 +1,227 @@ +# Relationships + +We can link `@Table` in DBFlow via 1-1, 1-many, or many-to-many. For 1-1 we use +`@PrimaryKey`, for 1-many we use `@OneToMany`, and for many-to-many we use the `@ManyToMany` annotation. + + +## One To One + +DBFlow supports multiple `@ForeignKey` right out of the box as well (and for the most part, they can also be `@PrimaryKey`). + +```java +@Table(database = AppDatabase.class) +public class Dog extends BaseModel { + + @PrimaryKey + String name; + + @ForeignKey(tableClass = Breed.class) + @PrimaryKey + String breed; + + @ForeignKey + Owner owner; +} + +``` + +`@ForeignKey` can only be a subset of types: + 1. `Model` + 2. Any field not requiring a `TypeConverter`. If not a `Model` or a table class, you _must_ specify the `tableClass` it points to. + 3. Cannot inherit `@ForeignKey` from non-model classes (see [Inherited Columns](/usage2/Models.md#inherited-columns)) + +If you create a circular reference (i.e. two tables with strong references to `Model` as `@ForeignKey` to each other), read on. + +## Stubbed Relationships + +For efficiency reasons we recommend specifying `@ForeignKey(stubbedRelationship = true)`. What this will do is only _preset_ the primary key references into a table object. All other fields will not be set. If you need to access the full object, you will have to call `load()` for `Model`, or use the `ModelAdapter` to load the object from the DB. + +From our previous example of `Dog`, instead of using a `String` field for **breed** +we recommended by using a `Breed`. It is nearly identical, but the difference being +we would then only need to call `load()` on the reference and it would query the `Breed` +table for a row with the `breed` id. This also makes it easier if the table you +reference has multiple primary keys, since DBFlow will handle the work for you. + +Multiple calls to `load()` will query the DB every time, so call when needed. Also if you don't specify `@Database(foreignKeyConstraintsEnforced = true)`, calling `load()` may not have any effect. Essentially without enforcing `@ForeignKey` at a SQLite level, you can end up with floating key references that do not exist in the referenced table. + +In normal circumstances, for every load of a `Dog` object from the database, +we would also do a load of related `Owner`. This means that even if multiple `Dog` say (50) +all point to same owner we end up doing 2x retrievals for every load of `Dog`. Replacing +that model field of `Owner` with a stubbed relationship prevents the extra N lookup time, +leading to much faster loads of `Dog`. + +__Note__: using stubbed relationships also helps to prevent circular references that can +get you in a `StackOverFlowError` if two tables strongly reference each other in `@ForeignKey`. + +Our modified example now looks like this: + +```java +@Table(database = AppDatabase.class) +public class Dog extends BaseModel { + + @PrimaryKey + String name; + + @ForeignKey(stubbedRelationship = true) + @PrimaryKey + Breed breed; // tableClass only needed for single-field refs that are not Model. + + @ForeignKey(stubbedRelationship = true) + Owner owner; +} + +``` + +## One To Many + +In DBFlow, `@OneToMany` is an annotation that you provide to a method in your `Model` class that will allow management of those objects during CRUD operations. +This can allow you to combine a relationship of objects to a single `Model` to happen together on load, save, insert, update, and deletion. + +```java + +@Table(database = ColonyDatabase.class) +public class Queen extends BaseModel { + + @PrimaryKey(autoincrement = true) + long id; + + @Column + String name; + + @ForeignKey(saveForeignKeyModel = false) + Colony colony; + + List ants; + + @OneToMany(methods = {OneToMany.Method.ALL}, _variableName = "ants") + public List getMyAnts() { + if (ants == null || ants.isEmpty()) { + ants = SQLite.select() + .from(Ant.class) + .where(Ant_Table.queenForeignKeyContainer_id.eq(id)) + .queryList(); + } + return ants; + } +} + +``` + +### Custom ForeignKeyReferences +When simple `@ForeignKey` annotation is not enough, you can manually specify references for your table: + +```java + +@ForeignKey(saveForeignKeyModel = false, +references = {@ForeignKeyReference(columnName = "colony", foreignKeyColumnName = "id")}) +Colony colony; + +``` + +By default not specifying references will take each field and append "${foreignKeyFieldName}_${ForeignKeyReferenceColumnName}" to make the reference column name. So by default the previous example would use `colony_id` without references. With references it becomes `colony`. + +## Many To Many + + +In DBFlow many to many is done via source-gen. A simple table: + +```java + +@Table(database = TestDatabase.class) +@ManyToMany(referencedTable = Follower.class) +public class User extends BaseModel { + + @PrimaryKey + String name; + + @PrimaryKey + int id; + +} + +``` + +Generates a `@Table` class named `User_Follower`, which DBFlow treats as if you +coded the class yourself!: + +```java + +@Table( + database = TestDatabase.class +) +public final class User_Follower extends BaseModel { + @PrimaryKey( + autoincrement = true + ) + long _id; + + @ForeignKey( + saveForeignKeyModel = false + ) + Follower follower; + + @ForeignKey( + saveForeignKeyModel = false + ) + User user; + + public final long getId() { + return _id; + } + + public final Followers getFollower() { + return follower; + } + + public final void setFollower(Follower param) { + follower = param; + } + + public final Users getUser() { + return user; + } + + public final void setUser(User param) { + user = param; + } +} + +``` + +This annotation makes it very easy to generate "join" tables for you to use in the app for a ManyToMany relationship. It only generates the table you need. To use it you must reference it in code as normal. + +_Note_: This annotation is only a helper to generate tables that otherwise you +would have to write yourself. It is expected that management still is done by you, the developer. + +### Custom Column Names + +You can change the name of the columns that are generated. By default they are simply +lower case first letter version of the table name. + +`referencedTableColumnName` -> Refers to the referenced table. +`thisTableColumnName` -> Refers to the table that is creating the reference. + +### Multiple ManyToMany + +You can also specify `@MultipleManyToMany` which enables you to define more +than a single `@ManyToMany` relationship on the table. + +A class can use both: + +```java +@Table(database = TestDatabase.class) +@ManyToMany(referencedTable = TestModel1.class) +@MultipleManyToMany({@ManyToMany(referencedTable = TestModel2.class), + @ManyToMany(referencedTable = com.raizlabs.android.dbflow.test.sql.TestModel3.class)}) +public class ManyToManyModel extends BaseModel { + + @PrimaryKey + String name; + + @PrimaryKey + int id; + + @Column + char anotherColumn; +} +``` diff --git a/Retrieval.md b/Retrieval.md new file mode 100644 index 000000000..e398e82ec --- /dev/null +++ b/Retrieval.md @@ -0,0 +1,116 @@ +# Retrieval + +DBFlow provides a few ways to retrieve information from the database. Through +the `Model` classes we can map this information to easy-to-use objects. + +DBFlow provides a few different ways to retrieve information from the database. We +can retrieve synchronously or asynchronous (preferred). + +We can also use `ModelView` ([read here](/usage2/ModelViews.md)) and `@Index` ([read here](/usage2/Indexing.md)) to perform faster retrieval on a set of data constantly queried. + +## Synchronous Retrieval + +Using the [SQLite query language](/usage2/SQLiteWrapperLanguage.md) we can retrieve +data easily and expressively. To perform it synchronously: + + +```java + +// list +List employees = SQLite.select() + .from(Employee.class) + .queryList(); + +// single result, we apply a limit(1) automatically to get the result even faster. +Employee employee = SQLite.select() + .from(Employee.class) + .where(Employee_Table.name.eq("Andrew Grosner")) + .querySingle(); + +// get a custom list +List employees = SQLite.select() + .from(Employee.class) + .queryCustomList(AnotherTable.class); + +// custom object +AnotherTable anotherObject = SQLite.select() + .from(Employee.class) + .where(Employee_Table.name.eq("Andrew Grosner")) + .queryCustomSingle(AnotherTable.class); + +``` + +To query custom objects or lists, see how to do so in [QueryModel](/usage2/QueryModel.md). + +Also you can query a `FlowCursorList`/`FlowTableList` from a query easily +via `queryCursorList()` and the `queryTableList()` methods. To see more on these, +go to [Flow Lists](/usage2/FlowLists.md). + + +## Asynchronous Retrieval + +DBFlow provides the very-handy `Transaction` system that allows you to place all +calls to the DB in a queue. Using this system, we recommend placing retrieval queries +on this queue to help prevent locking and threading issues when using a database. + +A quick sample of retrieving data asyncly: + +```java + +SQLite.select() + .from(TestModel1.class) + .where(TestModel1_Table.name.is("Async")) + .async() + .queryResultCallback(new QueryTransaction.QueryResultCallback() { + @Override + public void onQueryResult(QueryTransaction transaction, @NonNull CursorResult tResult) { + + } + }).execute(); + +``` + +This is fundamentally equal to: + +```java + + +FlowManager.getDatabaseForTable(TestModel1.class) + .beginTransactionAsync(new QueryTransaction.Builder<>( + SQLite.select() + .from(TestModel1.class) + .where(TestModel1_Table.name.is("Async"))) + .queryResult(new QueryTransaction.QueryResultCallback() { + @Override + public void onQueryResult(QueryTransaction transaction, @NonNull CursorResult tResult) { + + } + }).build()) +.build().execute(); + +``` + +The first example in this section is more of a convenience for (2). + +By default the library uses the `DefaultTransactionManager` which utilizes +a `DefaultTransactionQueue`. This queue is essentially an ordered queue that +executes FIFO (first-in-first-out) and blocks itself until new `Transaction` are added. + +If you wish to customize and provide a different queue (or map it to an existing system), read up on [Transactions](/usage2/StoringData.md). + + +Compared to pre-3.0 DBFlow, this is a breaking change from the old, priority-based +queue system. The reason for this change was to simplify the queuing system and +allow other systems to exist without confusing loss of functionality. To keep the old +system read [Transactions](/usage2/StoringData.md). + +## Faster Retrieval + +In an effort to squeeze out more speed at the potential cost of flexibility, DBFlow provides a +couple ways to optimize loads from the DB. If you do not wish to use caching but wish +to speed conversion from `Cursor` to `Model`, read on. + + If you simply retrieve a `List` of `Model` +without any projection from your DB, you can take advantage of 2 features: + 1. `@Table(orderedCursorLookUp = true)` -> We do not call `Cursor.getColumnIndex()` and assume that the `Cursor` is ordered by column declarations in the class. + 2. `@Table(assignDefaultValuesFromCursor = false)` -> We do not expect to reuse an object from the DB (or care) if the corresponding fields aren't assigned a value when missing from the `Cursor`. diff --git a/SQLCipherSupport.md b/SQLCipherSupport.md new file mode 100644 index 000000000..83bfee79e --- /dev/null +++ b/SQLCipherSupport.md @@ -0,0 +1,57 @@ +# SQLCipher Support + +As of 3.0.0-beta2+, DBFlow now supports [SQLCipher](https://www.zetetic.net/sqlcipher/) fairly easily. + +To add the library add the library to your `build.gradle` with same version you are using with the rest of the library. + +```groovy +dependencies { + compile "com.github.Raizlabs.DBFlow:dbflow-sqlcipher:${version}" + compile "net.zetetic:android-database-sqlcipher:${sqlcipher_version}@aar" + +} +``` + +You also need to add the Proguard rule: +``` +-keep class net.sqlcipher.** { *; } +-dontwarn net.sqlcipher.** +``` + +Next, you need to subclass the provided `SQLCipherOpenHelper` (taken from test files): + +```java +public class SQLCipherHelperImpl extends SQLCipherOpenHelper { + + public SQLCipherHelperImpl(DatabaseDefinition databaseDefinition, DatabaseHelperListener listener) { + super(databaseDefinition, listener); + } + + @Override + protected String getCipherSecret() { + return "dbflow-rules"; + } +} +``` + +_Note:_ that the constructor with `DatabaseDefinition` and `DatabaseHelperListener` is required. + +Then in your application class when initializing DBFlow: + +```java + +FlowManager.init(new FlowConfig.Builder(this) + .addDatabaseConfig( + new DatabaseConfig.Builder(CipherDatabase.class) + .openHelper(new DatabaseConfig.OpenHelperCreator() { + @Override + public OpenHelper createHelper(DatabaseDefinition databaseDefinition, DatabaseHelperListener helperListener) { + return new SQLCipherHelperImpl(databaseDefinition, helperListener); + } + }) + .build()) + .build()); + +``` + +And that's it. You're all set to start using SQLCipher! diff --git a/SQLiteWrapperLanguage.md b/SQLiteWrapperLanguage.md new file mode 100644 index 000000000..fb24b014b --- /dev/null +++ b/SQLiteWrapperLanguage.md @@ -0,0 +1,384 @@ +# SQLite Wrapper Language + +DBFlow's SQLite wrapper language attempts to make it as easy as possible to +write queries, execute statements, and more. + +We will attempt to make this doc comprehensive, but reference the SQLite language +for how to formulate queries, as DBFlow follows it as much as possible. + +## SELECT + +The way to query data, `SELECT` are started by: + +```java + +SQLite.select().from(SomeTable.class) + +``` + +### Projections + +By default if no parameters are specified in the `select()` query, we use the `*` wildcard qualifier, +meaning all columns are returned in the results. + +To specify individual columns, you _must_ use `Property` variables. +These get generated when you annotate your `Model` with columns, or created manually. + +```java + +SQLite.select(Player_Table.name, Player_Table.position) + .from(Player.class) + +``` + +To specify methods such as `COUNT()` or `SUM()` (static import on `Method`): + + +```java + +SQLite.select(count(Employee_Table.name), sum(Employee_Table.salary)) + .from(Employee.class) + +``` + +Translates to: + +```sqlite + +SELECT COUNT(`name`), SUM(`salary`) FROM `Employee`; + +``` + +There are more handy methods in `Method`. + +### Operators + +DBFlow supports many kinds of operations. They are formulated into a `OperatorGroup`, +which represent a set of `SQLOperator` subclasses combined into a SQLite conditional piece. +`Property` translate themselves into `SQLOperator` via their conditional methods such as +`eq()`, `lessThan()`, `greaterThan()`, `between()`, `in()`, etc. + +They make it very easy to construct concise and meaningful queries: + +```java + +int taxBracketCount = SQLite.select(count(Employee_Table.name)) + .from(Employee.class) + .where(Employee_Table.salary.lessThan(150000)) + .and(Employee_Table.salary.greaterThan(80000)) + .count(); + +``` + +Translates to: + +```sqlite + +SELECT COUNT(`name`) FROM `Employee` WHERE `salary`<150000 AND `salary`>80000; + +``` + +DBFlow supports `IN`/`NOT IN` and `BETWEEN` as well. + +A more comprehensive list of operations DBFlow supports and what they translate to: + + 1. is(), eq() -> = + 2. isNot(), notEq() -> != + 3. isNull() -> IS NULL / isNotNull() -> IS NOT NULL + 4. like(), glob() + 5. greaterThan(), greaterThanOrEqual(), lessThan(), lessThanOrEqual() + 6. between() -> BETWEEN + 7. in(), notIn() + +#### Nested Conditions + +To create nested conditions (in parenthesis more often than not), just include +an `OperatorGroup` as a `SQLOperator` in a query: + + +```java + +SQLite.select() + .from(Location.class) + .where(Location_Table.latitude.eq(home.getLatitude())) + .and(OperatorGroup.clause() + .and(Location_Table.latitude + .minus(PropertyFactory.from(home.getLatitude()) + .eq(1000L)))) + +``` + +Translates to: + +```sqlite + +SELECT * FROM `Location` WHERE `latitude`=45.05 AND (`latitude` - 45.05) = 1000 + +``` + +#### Nested Queries + +To create a nested query simply include it as a `Property` via `PropertyFactory.from(BaseQueriable)`: + +```java + +.where(PropertyFactory.from(SQLite.select().from(...).where(...)) + +``` + +This appends a `WHERE (SELECT * FROM {table} )` to the query. + +### JOINS + +For reference, ([JOIN examples](http://www.tutorialspoint.com/sqlite/sqlite_using_joins.htm)). + +`JOIN` statements are great for combining many-to-many relationships. +If your query returns non-table fields and cannot map to an existing object, +see about [query models](/usage2/QueryModels.md) + +For example we have a table named `Customer` and another named `Reservations`. + +```SQL +SELECT FROM `Customer` AS `C` INNER JOIN `Reservations` AS `R` ON `C`.`customerId`=`R`.`customerId` +``` + +```java +// use the different QueryModel (instead of Table) if the result cannot be applied to existing Model classes. +List customers = new Select() + .from(Customer.class).as("C") + .join(Reservations.class, JoinType.INNER).as("R") + .on(Customer_Table.customerId + .withTable(NameAlias.builder("C").build()) + .eq(Reservations_Table.customerId.withTable("R")) + .queryCustomList(CustomTable.class); +``` + +The `IProperty.withTable()` method will prepend a `NameAlias` or the `Table` alias to the `IProperty` in the query, convenient for JOIN queries: + +```sqlite +SELECT EMP_ID, NAME, DEPT FROM COMPANY LEFT OUTER JOIN DEPARTMENT + ON COMPANY.ID = DEPARTMENT.EMP_ID +``` + +in DBFlow: + +```java +SQLite.select(Company_Table.EMP_ID, Company_Table.DEPT) + .from(Company.class) + .leftOuterJoin(Department.class) + .on(Company_Table.ID.withTable().eq(Department_Table.EMP_ID.withTable())) +``` + +### Order By + +```java + +// true for 'ASC', false for 'DESC' +SQLite.select() + .from(table) + .where() + .orderBy(Customer_Table.customer_id, true) + + SQLite.select() + .from(table) + .where() + .orderBy(Customer_Table.customer_id, true) + .orderBy(Customer_Table.name, false) +``` + +### Group By + +```java +SQLite.select() + .from(table) + .groupBy(Customer_Table.customer_id, Customer_Table.customer_name) +``` + +### HAVING + +```java +SQLite.select() + .from(table) + .groupBy(Customer_Table.customer_id, Customer_Table.customer_name)) + .having(Customer_Table.customer_id.greaterThan(2)) +``` + +### LIMIT + OFFSET + +```java +SQLite.select() + .from(table) + .limit(3) + .offset(2) +``` + +## UPDATE + +DBFlow supports two kind of UPDATE: + 1. `Model.update()` + 2. `SQLite.update()` + +For simple `UPDATE` for a single or few, concrete set of `Model` stick with (1). +For powerful multiple `Model` update that can span many rows, use (2). In this +section we speak on (2). **Note:** if using model caching, you'll need to clear it out +post an operation from (2). + + +```sql + +UPDATE Ant SET type = 'other' WHERE male = 1 AND type = 'worker'; +``` + +Using DBFlow: + +```java + +// Native SQL wrapper +SQLite.update(Ant.class) + .set(Ant_Table.type.eq("other")) + .where(Ant_Table.type.is("worker")) + .and(Ant_Table.isMale.is(true)) + .async() + .execute(); // non-UI blocking +``` + +The `Set` part of the `Update` supports different kinds of values: + 1. `ContentValues` -> converts to key/value as a `SQLOperator` of `is()`/`eq()` + 2. `SQLOperator`, which are grouped together as part of the `SET` statement. + +## DELETE + +`DELETE` queries in DBFlow are similiar to `Update` in that we have two kinds: + + 1. `Model.delete()` + 2. `SQLite.delete()` + +For simple `DELETE` for a single or few, concrete set of `Model` stick with (1). +For powerful multiple `Model` deletion that can span many rows, use (2). In this +section we speak on (2). **Note:** if using model caching, you'll need to clear it out +post an operation from (2). + + +```java + +// Delete a whole table +Delete.table(MyTable.class); + +// Delete multiple instantly +Delete.tables(MyTable1.class, MyTable2.class); + +// Delete using query +SQLite.delete(MyTable.class) + .where(DeviceObject_Table.carrier.is("T-MOBILE")) + .and(DeviceObject_Table.device.is("Samsung-Galaxy-S5")) + .async() + .execute(); +``` + +## INSERT + +`INSERT` queries in DBFlow are also similiar to `Update` and `Delete` in that we +have two kinds: + + 1. `Model.insert()` + 2. `SQLite.insert()` + +For simple `INSERT` for a single or few, concrete set of `Model` stick with (1). +For powerful multiple `Model` insertion that can span many rows, use (2). In this +section we speak on (2). **Note:** using model caching, you'll need to clear it out +post an operation from (2). + +```java + +// columns + values separately +SQLite.insert(SomeTable.class) + .columns(SomeTable_Table.name, SomeTable_Table.phoneNumber) + .values("Default", "5555555") + .async() + .execute() + +// or combine into Operators + SQLite.insert(SomeTable.class) + .columnValues(SomeTable_Table.name.eq("Default"), + SomeTable_Table.phoneNumber.eq("5555555")) + .async() + .execute() + +``` + +`INSERT` supports inserting multiple rows as well. + +```java + +// columns + values separately +SQLite.insert(SomeTable.class) + .columns(SomeTable_Table.name, SomeTable_Table.phoneNumber) + .values("Default1", "5555555") + .values("Default2", "6666666") + .async() + .execute() + +// or combine into Operators + SQLite.insert(SomeTable.class) + .columnValues(SomeTable_Table.name.eq("Default1"), + SomeTable_Table.phoneNumber.eq("5555555")) + .columnValues(SomeTable_Table.name.eq("Default2"), + SomeTable_Table.phoneNumber.eq("6666666")) + .async() + .execute() + +``` + +## Trigger + +Triggers enable SQLite-level listener operations that perform some operation, modification, +or action to run when a specific database event occurs. [See](https://www.sqlite.org/lang_createtrigger.html) for more documentation on its usage. + +```java + +Trigger.create("SomeTrigger") + .after().insert(ConditionModel.class).begin(new Update<>(TestUpdateModel.class) + .set(TestUpdateModel_Table.value.is("Fired"))).enable(); // enables the trigger if it does not exist, so subsequent calls are OK + + +``` + +## Case + +The SQLite `CASE` operator is very useful to evaluate a set of conditions and "map" them +to a certain value that returns in a SELECT query. + +We have two kinds of case: +1. Simple +2. Searched + +The simple CASE query in DBFlow: + +```java + +SQLite.select(CaseModel_Table.customerId, + CaseModel_Table.firstName, + CaseModel_Table.lastName, + SQLite._case(CaseModel_Table.country) + .when("USA").then("Domestic") + ._else("Foreign") + .end("CustomerGroup")).from(CaseModel.class) + +``` + +The CASE is returned as `CustomerGroup` with the valyes of "Domestic" if the country is from +the 'USA' otherwise we mark the value as "Foreign". These appear alongside the results +set from the SELECT. + +The search CASE is a little more complicated in that each `when()` statement +represents a `SQLOperator`, which return a `boolean` expression: + +```java + +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); +``` diff --git a/SUMMARY.md b/SUMMARY.md index 005cb9945..59248475e 100644 --- a/SUMMARY.md +++ b/SUMMARY.md @@ -4,4 +4,26 @@ * [Including in Project](including-in-project.md) * [Proguard](proguard.md) * [Usage](chapter1.md) + * [Databases] (Databases.md) + * [Models](Models.md) + * [Migrations] (Migrations.md) + * [Views] (ModelViews.md) + * [Relationships] (Relationships.md) + * [Storing Data] (StoringData.md) + * [Retrieval] (Retrieval.md) + * [SQLite Wrapper Language] (SQLiteWrapperLanguage.md) + * [Migrations] (Migrations.md) + * [Type Converters] (TypeConverters.md) + * [Caching] (Caching.md) + * [List Based Queries] (ListBasedQueries.md) + * [Observability] (Observability.md) + * [Kotlin Support] (KotlinSupport.md) + * [RX Java Support] (RXJavaSupport.md) + * [Multiple Modules] (MultipleModules.md) + * [Query Models] (QueryModels.md) + * [Indexing] (Indexing.md) + * [SQLCipher] (SQLCipher.md) +* [Migration 3 Guide] (Migration3Guide.md) +* [Migration 4 Guide] (Migration4Guide.md) + diff --git a/StoringData.md b/StoringData.md new file mode 100644 index 000000000..692451c3f --- /dev/null +++ b/StoringData.md @@ -0,0 +1,313 @@ +# Storing Data + +DBFlow provide a few mechanisms by which we store data to the database. The difference of options +should not provide confusion but rather allow flexibility in what you decide is the best way +to store information. + +## Synchronous Storage + +While generally saving data synchronous should be avoided, for small amounts of data +it has little effect. + +```java + +FlowManager.getModelAdapter(SomeTable.class).save(model); + +FlowManager.getModelAdapter(SomeTable.class).insert(model); + +FlowManager.getModelAdapter(SomeTable.class).update(model); + +model.insert(); // inserts +model.update(); // updates +model.save(); // checks if exists, if true update, else insert. + +``` + +Code (without running in a transaction) like this should be avoided: + +```java + +for (int i = 0; i < models.size(), i++) { + models.get(i).save(); +} + +``` + +Doing operations on the main thread can block it if you read and write to the DB on a different thread while accessing DB on the main. + +## Synchronous Transactions + +A simple database transaction can be wrapped in a call: + +```java + +FlowManager.getDatabase(AppDatabase.class).executeTransaction(new ITransaction() { + @Override + public void execute(DatabaseWrapper databaseWrapper) { + // something here + Player player = new Player("Andrew", "Grosner"); + player.save(databaseWrapper); // use wrapper (from BaseModel) + } +}); + +``` + +Even though DBFlow is ridiculously fast, this should be put on a separate thread + outside of the UI, so that your UI remains responsive on all devices. + + Instead we should move onto `Transaction` (the preferred method). + +### Async Transactions + +## Transactions + +Transactions are ACID in SQLite, meaning they either occur completely or not at all. +Using transactions significantly speed up the time it takes to store. So recommendation +you should use transactions whenever you can. + +Async is the preferred method. Transactions, using the `DefaultTransactionManager`, + occur on one thread per-database (to prevent flooding from other DB in your app) + and receive callbacks on the UI. You can override this behavior and roll your own + or hook into an existing system, read [here](/usage2/StoringData.md#custom-transactionmanager). + +Also to use the legacy, priority-based system, read [here](/usage2/StoringData.md#priority-queue). + + A basic transaction: + + ```java + +DatabaseDefinition database = FlowManager.getDatabase(AppDatabase.class); +Transaction transaction = database.beginTransactionAsync(new ITransaction() { + @Override + public void execute(DatabaseWrapper databaseWrapper) { + called.set(true); + } + }).build(); +transaction.execute(); // execute + +transaction.cancel(); + // attempt to cancel before its run. If it's already ran, this call has no effect. + + ``` + + `Transaction` have callbacks to allow you to "listen" for success and errors. + + ```java + + + transaction + .success(new Transaction.Success() { + @Override + public void onSuccess(Transaction transaction) { + // called post-execution on the UI thread. + } + }) + .error(new Transaction.Error() { + @Override + public void onError(Transaction transaction, Throwable error) { + // call if any errors occur in the transaction. + } + }); + + + ``` + + The `Success` callback runs post-transaction on the UI thread. + The `Error` callback is called on the UI thread if and only if it is specified and an exception occurs, + otherwise it is thrown in the `Transaction` as a `RuntimeException`. **Note**: + all exceptions are caught when specifying the callback. Ensure you handle all + errors, otherwise you might miss some problems. + +### ProcessModelTransaction + +`ProcessModelTransaction` allows for more flexibility and for you to easily operate on a set of `Model` in a +`Transaction` easily. It holds a list of `Model` by which you provide the modification +method in the `Builder`. You can listen for when each are processed inside a normal +`Transaction`. + +It is a convenient way to operate on them: + +```java + +ProcessModelTransaction processModelTransaction = + new ProcessModelTransaction.Builder<>(new ProcessModelTransaction.ProcessModel() { + @Override + public void processModel(TestModel1 model) { + // call some operation on model here + model.save(); + model.insert(); // or + model.delete(); // or + } + }).processListener(new ProcessModelTransaction.OnModelProcessListener() { + @Override + public void onModelProcessed(long current, long total, TestModel1 modifiedModel) { + modelProcessedCount.incrementAndGet(); + } + }).addAll(items).build(); +Transaction transaction = database.beginTransactionAsync(processModelTransaction).build(); +transaction.execute(); + +``` + +In Kotlin (with `dbflow-kotlinextensions`), we can drastically simplify: + +```java + +items.processInTransactionAsync({ it, databaseWrapper -> it.delete(databaseWrapper) }, + ProcessModelTransaction.OnModelProcessListener { current, size, model -> + modelProcessedCount.incrementAndGet(); + }) + +``` +You can listen to when operations complete for each model via the `OnModelProcessListener`. +These callbacks occur on the UI thread. If you wish to run them on same thread (great for tests), +set `runProcessListenerOnSameThread()` to `true`. + +### FastStoreModelTransaction + +The `FastStoreModelTransaction` is the quickest, lightest way to store a `List` of +`Model` into the database through a `Transaction`. It comes with some restrictions when compared to `ProcessModelTransaction`: + 1. All `Model` must be from same Table/Model Class. + 2. No progress listening + 3. Can only `save`, `insert`, or `update` the whole list entirely. + +```java + +FastStoreModelTransaction + .insertBuilder(FlowManager.getModelAdapter(TestModel2.class)) + .addAll(modelList) + .build() + + // updateBuilder + saveBuilder also available. + +``` + +What it provides: + 1. Reuses `ContentValues`, `DatabaseStatement`, and other classes where possible. + 2. Opens and closes own `DatabaseStatement` per total execution. + 3. Significant speed bump over `ProcessModelTransaction` at the expense of flexibility. + +### Custom TransactionManager + +If you prefer to roll your own thread-management system or have an existing +system you can override the default system included. + + +To begin you must implement a `ITransactionQueue`: + +```java + +public class CustomQueue implements ITransactionQueue { + + @Override + public void add(Transaction transaction) { + + } + + @Override + public void cancel(Transaction transaction) { + + } + + @Override + public void startIfNotAlive() { + + } + + @Override + public void cancel(String name) { + + } + + @Override + public void quit() { + + } +} + +``` + +You must provide ways to `add()`, `cancel(Transaction)`, and `startIfNotAlive()`. +The other two methods are optional, but recommended. + +`startIfNotAlive()` in the `DefaultTransactionQueue` will start itself (since it's +a thread). + + Next you can override the `BaseTransactionManager` (not required, see later): + +```java + +public class CustomTransactionManager extends BaseTransactionManager { + + public CustomTransactionManager(DatabaseDefinition databaseDefinition) { + super(new CustomTransactionQueue(), databaseDefinition); + } + +} + +``` + +To register it with DBFlow, in your `FlowConfig`, you must: + +```java + +FlowManager.init(builder + .addDatabaseConfig(new DatabaseConfig.Builder(AppDatabase.class) + .transactionManagerCreator(new DatabaseConfig.TransactionManagerCreator() { + @Override + public BaseTransactionManager createManager(DatabaseDefinition databaseDefinition) { + // this will be called once database modules are loaded and created. + return new CustomTransactionManager(databaseDefinition); + + // or you can: + //return new DefaultTransactionManager(new CustomTransactionQueue(), databaseDefinition); + } + }) + .build()) + .build()); + +``` + +### Priority Queue + +In versions pre-3.0, DBFlow utilized a `PriorityBlockingQueue` to manage the asynchronous +dispatch of `Transaction`. As of 3.0, it has switched to simply a FIFO queue. To +keep the legacy way, a `PriorityTransactionQueue` was created. + +As seen in [Custom Transaction Managers](/usage2/StoringData.md#custom-transactionmanager), +we provide a custom instance of the `DefaultTransactionManager` with the `PriorityTransactionQueue` specified: + +```java + +FlowManager.init(builder + .addDatabaseConfig(new DatabaseConfig.Builder(AppDatabase.class) + .transactionManagerCreator(new DatabaseConfig.TransactionManagerCreator() { + @Override + public BaseTransactionManager createManager(DatabaseDefinition databaseDefinition) { + // this will be called once database modules are loaded and created. + return new DefaultTransactionManager( + new PriorityTransactionQueue("DBFlow Priority Queue"), + databaseDefinition); + } + }) + .build()) + .build()); + +``` + +What this does is for the specified database (in this case `AppDatabase`), +now require each `ITransaction` specified for the database should wrap itself around +the `PriorityTransactionWrapper`. Otherwise an the `PriorityTransactionQueue` +wraps the existing `Transaction` in a `PriorityTransactionWrapper` with normal priority. + + +To specify a priority: + +```java + +FlowManager.getDatabase(AppDatabase.class) + .beginTransactionAsync(new PriorityTransactionWrapper.Builder(myTransaction) + .priority(PriorityTransactionWrapper.PRIORITY_HIGH).build()) + .build().execute(); + +``` diff --git a/TypeConverters.md b/TypeConverters.md new file mode 100644 index 000000000..6593b83aa --- /dev/null +++ b/TypeConverters.md @@ -0,0 +1,58 @@ +# Type conversion + +When building out `Model` classes, you may wish to provide a different type of `@Column` that from the standard supported column types. To recap the standard column types include: + 1. `String`, `char`, `Character` + 2. All numbers types (primitive + boxed) + 3. `byte[]`/`Byte` + 4. `Blob` (DBFlow's version) + 5. `Date`/`java.sql.Date` + 6. Bools + 7. `Model` as `@ForeignKey` + 8. `Calendar` + 9. `BigDecimal` + 10. `UUID` + +`TypeConverter` do _not_ support: + 1. Any Parameterized fields. + 2. `List`, `Map`, etc. Best way to fix this is to create a separate table [relationship](/usage2/Relationships.md) + 3. Conversion from one type-converter to another (i.e `JSONObject` to `Date`). The first parameter of `TypeConverter` is the value of the type as if it was a primitive/boxed type. + 4. Conversion from custom type to `Model`, or `Model` to a supported type. + 5. The custom class _must_ map to a non-complex field such as `String`, numbers, `char`/`Character` or `Blob` + +## Define a TypeConverter + +Defining a `TypeConverter` is quick and easy. + +This example creates a `TypeConverter` for a field that is `JSONObject` and converts it to a `String` representation: + +```java + +@com.raizlabs.android.dbflow.annotation.TypeConverter +public class JSONConverter extends TypeConverter { + + @Override + public String getDBValue(JSONObject model) { + return model == null ? null : model.toString(); + } + + @Override + public JSONObject getModelValue(String data) { + JSONObject jsonObject = null; + try { + jsonObject = new JSONObject(data); + } catch (JSONException e) { + // you should consider logging or throwing exception. + } + return jsonObject; + } +} + +``` + +Once this is defined, by using the annotation `@TypeConverter`, it is registered automatically accross all databases. + +There are cases where you wish to provide multiple `TypeConverter` for same kind of field (i.e. `Date` with different date formats stored in a DB). + +## TypeConverter for specific `@Column` + +In DBFlow, specifying a `TypeConverter` for a `@Column` is as easy as `@Column(typeConverter = JSONConverter.class)`. What it will do is create the converter once for use only when that column is used. From 913c970cf95d3427e5b549de67b610211a3f1481 Mon Sep 17 00:00:00 2001 From: fuzzagrosner Date: Wed, 26 Apr 2017 14:29:22 -0400 Subject: [PATCH 037/234] [book] rename usage docs. --- SUMMARY.md | 2 +- chapter1.md => Usage.md | 0 2 files changed, 1 insertion(+), 1 deletion(-) rename chapter1.md => Usage.md (100%) diff --git a/SUMMARY.md b/SUMMARY.md index 59248475e..f61820265 100644 --- a/SUMMARY.md +++ b/SUMMARY.md @@ -3,7 +3,7 @@ * [Introduction](README.md) * [Including in Project](including-in-project.md) * [Proguard](proguard.md) -* [Usage](chapter1.md) +* [Usage](Usage.md) * [Databases] (Databases.md) * [Models](Models.md) * [Migrations] (Migrations.md) diff --git a/chapter1.md b/Usage.md similarity index 100% rename from chapter1.md rename to Usage.md From a7bb4bc6941bd2c90ea5c374bd3edc7cefa45c01 Mon Sep 17 00:00:00 2001 From: fuzzagrosner Date: Wed, 26 Apr 2017 14:31:24 -0400 Subject: [PATCH 038/234] [book] fix links. --- SUMMARY.md | 40 ++++++++++++++++++++-------------------- 1 file changed, 20 insertions(+), 20 deletions(-) diff --git a/SUMMARY.md b/SUMMARY.md index f61820265..d2bf1d1ee 100644 --- a/SUMMARY.md +++ b/SUMMARY.md @@ -4,26 +4,26 @@ * [Including in Project](including-in-project.md) * [Proguard](proguard.md) * [Usage](Usage.md) - * [Databases] (Databases.md) + * [Databases](Databases.md) * [Models](Models.md) - * [Migrations] (Migrations.md) - * [Views] (ModelViews.md) - * [Relationships] (Relationships.md) - * [Storing Data] (StoringData.md) - * [Retrieval] (Retrieval.md) - * [SQLite Wrapper Language] (SQLiteWrapperLanguage.md) - * [Migrations] (Migrations.md) - * [Type Converters] (TypeConverters.md) - * [Caching] (Caching.md) - * [List Based Queries] (ListBasedQueries.md) - * [Observability] (Observability.md) - * [Kotlin Support] (KotlinSupport.md) - * [RX Java Support] (RXJavaSupport.md) - * [Multiple Modules] (MultipleModules.md) - * [Query Models] (QueryModels.md) - * [Indexing] (Indexing.md) - * [SQLCipher] (SQLCipher.md) -* [Migration 3 Guide] (Migration3Guide.md) -* [Migration 4 Guide] (Migration4Guide.md) + * [Migrations](Migrations.md) + * [Views](ModelViews.md) + * [Relationships](Relationships.md) + * [Storing Data](StoringData.md) + * [Retrieval](Retrieval.md) + * [SQLite Wrapper Language](SQLiteWrapperLanguage.md) + * [Migrations](Migrations.md) + * [Type Converters](TypeConverters.md) + * [Caching](Caching.md) + * [List Based Queries](ListBasedQueries.md) + * [Observability](Observability.md) + * [Kotlin Support](KotlinSupport.md) + * [RX Java Support](RXJavaSupport.md) + * [Multiple Modules](MultipleModules.md) + * [Query Models](QueryModels.md) + * [Indexing](Indexing.md) + * [SQLCipher](SQLCipher.md) +* [Migration 3 Guide](Migration3Guide.md) +* [Migration 4 Guide](Migration4Guide.md) From 0227ac1cfc045e2aa460bfc07e553b1ecc073950 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Wed, 26 Apr 2017 18:34:23 +0000 Subject: [PATCH 039/234] Creates advanced-usage/cac.md Auto commit by GitBook Editor --- SUMMARY.md | 40 ++++++++++++++++++++-------------------- advanced-usage.md | 6 ++++++ advanced-usage/cac.md | 0 3 files changed, 26 insertions(+), 20 deletions(-) create mode 100644 advanced-usage.md create mode 100644 advanced-usage/cac.md diff --git a/SUMMARY.md b/SUMMARY.md index d2bf1d1ee..24200069f 100644 --- a/SUMMARY.md +++ b/SUMMARY.md @@ -4,26 +4,26 @@ * [Including in Project](including-in-project.md) * [Proguard](proguard.md) * [Usage](Usage.md) - * [Databases](Databases.md) - * [Models](Models.md) - * [Migrations](Migrations.md) - * [Views](ModelViews.md) - * [Relationships](Relationships.md) - * [Storing Data](StoringData.md) - * [Retrieval](Retrieval.md) - * [SQLite Wrapper Language](SQLiteWrapperLanguage.md) - * [Migrations](Migrations.md) - * [Type Converters](TypeConverters.md) - * [Caching](Caching.md) - * [List Based Queries](ListBasedQueries.md) - * [Observability](Observability.md) - * [Kotlin Support](KotlinSupport.md) - * [RX Java Support](RXJavaSupport.md) - * [Multiple Modules](MultipleModules.md) - * [Query Models](QueryModels.md) - * [Indexing](Indexing.md) - * [SQLCipher](SQLCipher.md) + * [Databases](Databases.md) + * [Models](Models.md) + * [Migrations](Migrations.md) + * [Views](ModelViews.md) + * [Relationships](Relationships.md) + * [Storing Data](StoringData.md) + * [Retrieval](Retrieval.md) + * [SQLite Wrapper Language](SQLiteWrapperLanguage.md) + * [Migrations](Migrations.md) + * [Type Converters](TypeConverters.md) + * [Observability](Observability.md) + * [Kotlin Support](KotlinSupport.md) + * [RX Java Support](RXJavaSupport.md) + * [Multiple Modules](MultipleModules.md) + * [Query Models](QueryModels.md) + * [Indexing](Indexing.md) + * [SQLCipher](SQLCipher.md) +* [Advanced Usage](advanced-usage.md) +* [Caching](Caching.md) +* [List Based Queries](ListBasedQueries.md) * [Migration 3 Guide](Migration3Guide.md) * [Migration 4 Guide](Migration4Guide.md) - diff --git a/advanced-usage.md b/advanced-usage.md new file mode 100644 index 000000000..0eb5b4c7c --- /dev/null +++ b/advanced-usage.md @@ -0,0 +1,6 @@ +# Advanced Usage + +This section details the more advanced usages of DBFlow. + + + diff --git a/advanced-usage/cac.md b/advanced-usage/cac.md new file mode 100644 index 000000000..e69de29bb From fe6ae45188ef20613e0f8143448a58bbf1c9538e Mon Sep 17 00:00:00 2001 From: fuzzagrosner Date: Wed, 26 Apr 2017 14:35:17 -0400 Subject: [PATCH 040/234] [book] make some pages nestedd in advanced. --- SUMMARY.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/SUMMARY.md b/SUMMARY.md index 24200069f..2af556c00 100644 --- a/SUMMARY.md +++ b/SUMMARY.md @@ -17,13 +17,13 @@ * [Observability](Observability.md) * [Kotlin Support](KotlinSupport.md) * [RX Java Support](RXJavaSupport.md) +* [Advanced Usage](advanced-usage.md) + * [Caching](Caching.md) + * [List Based Queries](ListBasedQueries.md) * [Multiple Modules](MultipleModules.md) * [Query Models](QueryModels.md) * [Indexing](Indexing.md) * [SQLCipher](SQLCipher.md) -* [Advanced Usage](advanced-usage.md) -* [Caching](Caching.md) -* [List Based Queries](ListBasedQueries.md) * [Migration 3 Guide](Migration3Guide.md) * [Migration 4 Guide](Migration4Guide.md) From 5eaa6f02a951798c35d1405ad2d99ec4752cc30d Mon Sep 17 00:00:00 2001 From: fuzzagrosner Date: Wed, 26 Apr 2017 14:36:03 -0400 Subject: [PATCH 041/234] [book] promote RXJava and Kotlin to top level. --- SUMMARY.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/SUMMARY.md b/SUMMARY.md index 2af556c00..6b7273716 100644 --- a/SUMMARY.md +++ b/SUMMARY.md @@ -15,8 +15,8 @@ * [Migrations](Migrations.md) * [Type Converters](TypeConverters.md) * [Observability](Observability.md) - * [Kotlin Support](KotlinSupport.md) - * [RX Java Support](RXJavaSupport.md) +* [Kotlin Support](KotlinSupport.md) +* [RX Java Support](RXJavaSupport.md) * [Advanced Usage](advanced-usage.md) * [Caching](Caching.md) * [List Based Queries](ListBasedQueries.md) From acbf59ea7a647150696e3aaea386acb39b392176 Mon Sep 17 00:00:00 2001 From: fuzzagrosner Date: Wed, 26 Apr 2017 14:36:43 -0400 Subject: [PATCH 042/234] remove unnecessary file folder. --- advanced-usage/cac.md | 0 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 advanced-usage/cac.md diff --git a/advanced-usage/cac.md b/advanced-usage/cac.md deleted file mode 100644 index e69de29bb..000000000 From efb7f1ff4e0ce55e9293b28b123956a63e75a313 Mon Sep 17 00:00:00 2001 From: fuzzagrosner Date: Wed, 26 Apr 2017 15:05:32 -0400 Subject: [PATCH 043/234] [links] fix symbolic links here. --- Caching.md | 2 +- TypeConverters.md | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/Caching.md b/Caching.md index 834f88a74..b9ff0141b 100644 --- a/Caching.md +++ b/Caching.md @@ -45,7 +45,7 @@ public class CacheableModel { ``` -to use caching on a table that uses multiple primary keys, [see](/usage2/Caching.md#multiple-primary-key-caching). +to use caching on a table that uses multiple primary keys, [see](Caching.md#multiple-primary-key-caching). By default we use a `SimpleMapCache`, which loads `Model` into a `Map`. The key is either the primary key of the object or a combination of the two, but it should have diff --git a/TypeConverters.md b/TypeConverters.md index 6593b83aa..26e958643 100644 --- a/TypeConverters.md +++ b/TypeConverters.md @@ -14,7 +14,7 @@ When building out `Model` classes, you may wish to provide a different type of ` `TypeConverter` do _not_ support: 1. Any Parameterized fields. - 2. `List`, `Map`, etc. Best way to fix this is to create a separate table [relationship](/usage2/Relationships.md) + 2. `List`, `Map`, etc. Best way to fix this is to create a separate table [relationship](Relationships.md) 3. Conversion from one type-converter to another (i.e `JSONObject` to `Date`). The first parameter of `TypeConverter` is the value of the type as if it was a primitive/boxed type. 4. Conversion from custom type to `Model`, or `Model` to a supported type. 5. The custom class _must_ map to a non-complex field such as `String`, numbers, `char`/`Character` or `Blob` From 4ae04948a8a2e93491cf3f4733ea165fcd9e2c6d Mon Sep 17 00:00:00 2001 From: fuzzagrosner Date: Wed, 26 Apr 2017 15:10:32 -0400 Subject: [PATCH 044/234] [links] fix rest of relative links to readmes. --- Databases.md | 4 ++-- GettingStarted.md | 8 ++++---- Indexing.md | 2 +- Intro.md | 1 + KotlinSupport.md | 2 +- ListBasedQueries.md | 6 +++--- Migration3Guide.md | 24 ++++++++++++------------ Migrations.md | 4 ++-- Models.md | 2 +- Observability.md | 2 +- QueryModels.md | 2 +- RXSupport.md | 2 +- Relationships.md | 2 +- Retrieval.md | 12 ++++++------ SQLiteWrapperLanguage.md | 2 +- StoringData.md | 6 +++--- 16 files changed, 41 insertions(+), 40 deletions(-) diff --git a/Databases.md b/Databases.md index b61b8feb4..27fa95047 100644 --- a/Databases.md +++ b/Databases.md @@ -57,7 +57,7 @@ public class AppDatabase { ``` This simple example adds a column to the `User` table named "email". In code, just add the column to the `Model` class and this migration runs only on existing dbs. - To read more on migrations and more examples of different kinds, visit the [page](/usage2/Migrations.md). + To read more on migrations and more examples of different kinds, visit the [page](Migrations.md). ## Advanced Database features @@ -96,7 +96,7 @@ time in case of failure we create a **third copy of the database** in case trans For variety of reasons, you may want to provide your own `FlowSQLiteOpenHelper` to manage database interactions. To do so, you must implement `OpenHelper`, but for convenience you should extend `FlowSQLiteOpenHelper` (for Android databases), -or `SQLCipherOpenHelper` for SQLCipher. Read more [here](/usage2/SQLCipherSupport.md) +or `SQLCipherOpenHelper` for SQLCipher. Read more [here](SQLCipherSupport.md) ```java diff --git a/GettingStarted.md b/GettingStarted.md index 9f40e7307..702d12b6a 100644 --- a/GettingStarted.md +++ b/GettingStarted.md @@ -28,7 +28,7 @@ class is automatically placed into the main `GeneratedDatabaseHolder`, which hol potentially many databases. The name, `AppDatabaseAppDatabase_Database.java`, is generated via {DatabaseClassName}{DatabaseFileName}{GeneratedClassSepator, default = "\_"}Database -To learn more about what you can configure in a database, read [here](/usage2/Databases.md) +To learn more about what you can configure in a database, read [here](Databases.md) ## Initialize FlowManager @@ -84,13 +84,13 @@ FlowManager.init(new FlowConfig.Builder(this) ``` You can define different kinds for each database. -To read more on transactions and subclassing `BaseTransactionManager` go [here](/usage2/StoringData.md) +To read more on transactions and subclassing `BaseTransactionManager` go [here](StoringData.md) ## Create Models Creating models are as simple as defining the model class, and adding the `@Table` annotation. -To read more on this, read [here](/usage2/Models.md). +To read more on this, read [here](Models.md). An example: @@ -148,7 +148,7 @@ SQLite.select() ``` We support many kinds of complex and complicated queries using the builder -language. To read more about this, see [the wrapper language docs](/usage2/SQLiteWrapperLanguage.md) +language. To read more about this, see [the wrapper language docs](SQLiteWrapperLanguage.md) There is much more you can do in DBFlow. Read through the other docs to get a sense of the library. diff --git a/Indexing.md b/Indexing.md index 1e8129b55..2cefa6091 100644 --- a/Indexing.md +++ b/Indexing.md @@ -9,7 +9,7 @@ Indexes are defined using the `indexGroups()` property of the `@Table` annotatio 2. Add the `@Index` 3. Build and an `IndexProperty` gets generated. This allows super-easy access to the index so you can enable/disable it with ease. -__Note__: `Index` are not explicitly enabled unless coupled with an `IndexMigration`. ([read here](/usage2/Migrations.md#index-migrations)). +__Note__: `Index` are not explicitly enabled unless coupled with an `IndexMigration`. ([read here](Migrations.md#index-migrations)). You can define as many `@IndexGroup` you want within a `@Table` as long as one field references the group. Also individual `@Column` can belong to any number of groups: diff --git a/Intro.md b/Intro.md index cb3ae6b7b..33e9cd444 100644 --- a/Intro.md +++ b/Intro.md @@ -1,4 +1,5 @@ # DBFlow +## Outdated - use https://agrosner.gitbooks.io/dbflow/content DBFlow for Android lets you write very efficient database code while remaining expressive and concise. diff --git a/KotlinSupport.md b/KotlinSupport.md index 51eb891eb..4c324de17 100644 --- a/KotlinSupport.md +++ b/KotlinSupport.md @@ -9,7 +9,7 @@ dependencies { } ``` -We also support [kotlin extensions for RX 1 + 2](/usage2/RXSupport.md)! +We also support [kotlin extensions for RX 1 + 2](RXSupport.md)! ## Classes diff --git a/ListBasedQueries.md b/ListBasedQueries.md index 1e2949e01..c2af48a64 100644 --- a/ListBasedQueries.md +++ b/ListBasedQueries.md @@ -68,7 +68,7 @@ The `FlowCursorList` is simply a wrapper around a standard `Cursor`, giving it t ability to cache `Model`, load items at specific position with conversion, and refresh it's content easily. -The `FlowCursorList` by default caches its results, for fast usage. The cache size is determined by the `ModelCache` you're using. Read on [here](/usage2/Caching.md). +The `FlowCursorList` by default caches its results, for fast usage. The cache size is determined by the `ModelCache` you're using. Read on [here](Caching.md). The `FlowCursorList` provides these methods: @@ -85,7 +85,7 @@ This class is a much more powerful version of the `FlowCursorList`. It contains which backs it's retrieval operations. This class acts as `List` and can be used almost wherever a `List` is used. Also, it is a `FlowContentObserver` -see [Observability](/usage2/Observability.md), meaning other classes can listen +see [Observability](Observability.md), meaning other classes can listen for its specific changes and it can auto-refresh itself when content changes. Feature rundown: @@ -115,7 +115,7 @@ and then converts it using the associated method on that returned `List`. ### FlowContentObserver Implementation Using the `FlowContentObserver`, we can enable self-refreshes whenever a model changes -for the table this query points to. See [Observability](/usage2/Observability.md). +for the table this query points to. See [Observability](Observability.md). To turn on self-refreshes, call `registerForContentChanges(context)`, which requeries the data whenever it changes. diff --git a/Migration3Guide.md b/Migration3Guide.md index dd2c606c6..04f37ebc6 100644 --- a/Migration3Guide.md +++ b/Migration3Guide.md @@ -8,20 +8,20 @@ _Some Changes to Note:_ 2. Package private fields from other packages are now automatically accessible via generated `_Helper` classes. The referenced fields must be annotated with `@Column`, `@PrimaryKey`, or `@ForeignKey`. if its a legacy `ForeignKeyReference`, `referendFieldIsPackagePrivate()` must be set to true. 3. `@Column` no longer required in conjunction with `@PrimaryKey` or `@ForeignKey` 4. Can now have DBFlow in multiple modules, libraries, etc via "Modules"! -5. `TransactionManager` has been replaced with a new per-database `BaseTransactionManager`. Each DB has its own `DBTransactionQueue` and you can replace the default with your own system. Also, no longer is this priority-based, but rather order-based. See more [here](/usage2/Transactions.md) +5. `TransactionManager` has been replaced with a new per-database `BaseTransactionManager`. Each DB has its own `DBTransactionQueue` and you can replace the default with your own system. Also, no longer is this priority-based, but rather order-based. See more [here](Transactions.md) This doc is to provide some basic examples of what has changed, but read all of the new usage docs! -Starting with [Intro](/usage2/Intro.md) +Starting with [Intro](Intro.md) ## Table Of Contents - 1. [Initialization](/usage2/Migration3Guide.md#initialization) - 2. [Database + Table Structure](/usage2/Migration3Guide.md#database-and-table-structure) - 3. [Transactions Overhaul](/usage2/Migration3Guide.md#transactions-overhaul) - 4. [Properties](/usage2/Migration3Guide.md#properties) - 5. [ModelContainers](/usage2/Migration3Guide.md#modelcontainers) - 6. [ModelViews](/usage2/Migration3Guide.md#modelviews) - 7. [Caching](/usage2/Migration3Guide.md#caching) - 8. [Database Modules](/usage2/Migration3Guide.md#database-modules) + 1. [Initialization](Migration3Guide.md#initialization) + 2. [Database + Table Structure](Migration3Guide.md#database-and-table-structure) + 3. [Transactions Overhaul](Migration3Guide.md#transactions-overhaul) + 4. [Properties](Migration3Guide.md#properties) + 5. [ModelContainers](Migration3Guide.md#modelcontainers) + 6. [ModelViews](Migration3Guide.md#modelviews) + 7. [Caching](Migration3Guide.md#caching) + 8. [Database Modules](Migration3Guide.md#database-modules) ## Initialization @@ -53,7 +53,7 @@ public class ExampleApplication extends Application { ``` -See more of what you can customize [here](/usage2/GettingStarted.md) +See more of what you can customize [here](GettingStarted.md) ## Database And Table Structure ### Database changes @@ -440,7 +440,7 @@ FlowManager.getDatabase(AppDatabase.class) ``` For more usage on the new system, including the ability to roll your own `TransactionManager`, -visit [Transactions](/usage2/Transactions.md) +visit [Transactions](Transactions.md) ## Properties diff --git a/Migrations.md b/Migrations.md index ad73848fd..36b78c6b8 100644 --- a/Migrations.md +++ b/Migrations.md @@ -15,7 +15,7 @@ two kinds of modifications that exist: rename table and add a new column. In DBFlow migrations are not only used to modify the _structure_ of the database, but also other operations such as insert data into a database (for prepopulate), or add an index on a specific table. -Migrations are only run on an existing database _except_ for the "0th" migration. Read [initial database setup](/usage2/Migrations.md#initial-database-setup) +Migrations are only run on an existing database _except_ for the "0th" migration. Read [initial database setup](Migrations.md#initial-database-setup) ### Migration Classes @@ -112,7 +112,7 @@ public class Migration2 extends AlterTableMigration { ### Index Migrations -An `IndexMigration` (and `IndexPropertyMigration`) is used to structurally activate an `Index` on the database at a specific version. See [here](/usage2/Indexing.md) for information on creating them. +An `IndexMigration` (and `IndexPropertyMigration`) is used to structurally activate an `Index` on the database at a specific version. See [here](Indexing.md) for information on creating them. `IndexMigration` does not require an `IndexProperty` to run, while `IndexPropertyMigration` makes use of the property to run. diff --git a/Models.md b/Models.md index f48853b45..30f4108b7 100644 --- a/Models.md +++ b/Models.md @@ -51,7 +51,7 @@ Columns have a wide-range of supported types in the `Model` classes: 1. all java primitives including `char`,`byte`, `short`, and `boolean`. 2. All java boxed primitive classes 3. String, Date, java.sql.Date, Calendar, Blob, Boolean - 4. Custom data types via a [TypeConverter](/usage2/TypeConverters.md) + 4. Custom data types via a [TypeConverter](TypeConverters.md) 5. `Model` as fields, but only as `@PrimaryKey` and/or `@ForeignKey` **Unsupported Types**: diff --git a/Observability.md b/Observability.md index 9655381f8..1e9be9659 100644 --- a/Observability.md +++ b/Observability.md @@ -5,7 +5,7 @@ DBFlow provides a flexible way to observe changes on models and tables in this l By default, DBFlow utilizes the [`ContentResolver`](https://developer.android.com/reference/android/content/ContentResolver.html) to send changes through the android system. We then can utilize [`ContentObserver`](http://developer.android.com/reference/android/database/ContentObserver.html) to listen for these changes via the `FlowContentObserver`. -Also, DBFlow also supports direct [model notification](/usage2/Observability.md#direct-changes) via a custom `ModelNotifier`. +Also, DBFlow also supports direct [model notification](Observability.md#direct-changes) via a custom `ModelNotifier`. ## FlowContentObserver diff --git a/QueryModels.md b/QueryModels.md index 8fd081423..804d1ad40 100644 --- a/QueryModels.md +++ b/QueryModels.md @@ -98,7 +98,7 @@ If you use the optional base class of `BaseQueryModel`, an `InvalidSqlViewOperationException`. Otherwise, `RetrievalAdapter` do not contain modification methods. -They support `allFields` and inheritance and visibility modifiers as defined by [Models](/usage2/Models.md). +They support `allFields` and inheritance and visibility modifiers as defined by [Models](Models.md). `QueryModel` **do not** support: 1. `InheritedField`/`InheritedPrimaryKey` diff --git a/RXSupport.md b/RXSupport.md index c9e365377..37ca77be8 100644 --- a/RXSupport.md +++ b/RXSupport.md @@ -115,7 +115,7 @@ RXSQLite.rx( ## Kotlin Support -Most of the support mirrors [kotlin support](/usage2/KotlinSupport.md) with a few +Most of the support mirrors [kotlin support](KotlinSupport.md) with a few minor changes. Extension properties/methods include: diff --git a/Relationships.md b/Relationships.md index ba69ce54d..9b6192374 100644 --- a/Relationships.md +++ b/Relationships.md @@ -28,7 +28,7 @@ public class Dog extends BaseModel { `@ForeignKey` can only be a subset of types: 1. `Model` 2. Any field not requiring a `TypeConverter`. If not a `Model` or a table class, you _must_ specify the `tableClass` it points to. - 3. Cannot inherit `@ForeignKey` from non-model classes (see [Inherited Columns](/usage2/Models.md#inherited-columns)) + 3. Cannot inherit `@ForeignKey` from non-model classes (see [Inherited Columns](Models.md#inherited-columns)) If you create a circular reference (i.e. two tables with strong references to `Model` as `@ForeignKey` to each other), read on. diff --git a/Retrieval.md b/Retrieval.md index e398e82ec..6bb002636 100644 --- a/Retrieval.md +++ b/Retrieval.md @@ -6,11 +6,11 @@ the `Model` classes we can map this information to easy-to-use objects. DBFlow provides a few different ways to retrieve information from the database. We can retrieve synchronously or asynchronous (preferred). -We can also use `ModelView` ([read here](/usage2/ModelViews.md)) and `@Index` ([read here](/usage2/Indexing.md)) to perform faster retrieval on a set of data constantly queried. +We can also use `ModelView` ([read here](ModelViews.md)) and `@Index` ([read here](Indexing.md)) to perform faster retrieval on a set of data constantly queried. ## Synchronous Retrieval -Using the [SQLite query language](/usage2/SQLiteWrapperLanguage.md) we can retrieve +Using the [SQLite query language](SQLiteWrapperLanguage.md) we can retrieve data easily and expressively. To perform it synchronously: @@ -40,11 +40,11 @@ AnotherTable anotherObject = SQLite.select() ``` -To query custom objects or lists, see how to do so in [QueryModel](/usage2/QueryModel.md). +To query custom objects or lists, see how to do so in [QueryModel](QueryModel.md). Also you can query a `FlowCursorList`/`FlowTableList` from a query easily via `queryCursorList()` and the `queryTableList()` methods. To see more on these, -go to [Flow Lists](/usage2/FlowLists.md). +go to [Flow Lists](FlowLists.md). ## Asynchronous Retrieval @@ -96,13 +96,13 @@ By default the library uses the `DefaultTransactionManager` which utilizes a `DefaultTransactionQueue`. This queue is essentially an ordered queue that executes FIFO (first-in-first-out) and blocks itself until new `Transaction` are added. -If you wish to customize and provide a different queue (or map it to an existing system), read up on [Transactions](/usage2/StoringData.md). +If you wish to customize and provide a different queue (or map it to an existing system), read up on [Transactions](StoringData.md). Compared to pre-3.0 DBFlow, this is a breaking change from the old, priority-based queue system. The reason for this change was to simplify the queuing system and allow other systems to exist without confusing loss of functionality. To keep the old -system read [Transactions](/usage2/StoringData.md). +system read [Transactions](StoringData.md). ## Faster Retrieval diff --git a/SQLiteWrapperLanguage.md b/SQLiteWrapperLanguage.md index fb24b014b..dc85f59dd 100644 --- a/SQLiteWrapperLanguage.md +++ b/SQLiteWrapperLanguage.md @@ -134,7 +134,7 @@ For reference, ([JOIN examples](http://www.tutorialspoint.com/sqlite/sqlite_usin `JOIN` statements are great for combining many-to-many relationships. If your query returns non-table fields and cannot map to an existing object, -see about [query models](/usage2/QueryModels.md) +see about [query models](QueryModels.md) For example we have a table named `Customer` and another named `Reservations`. diff --git a/StoringData.md b/StoringData.md index 692451c3f..baf748bd4 100644 --- a/StoringData.md +++ b/StoringData.md @@ -68,9 +68,9 @@ you should use transactions whenever you can. Async is the preferred method. Transactions, using the `DefaultTransactionManager`, occur on one thread per-database (to prevent flooding from other DB in your app) and receive callbacks on the UI. You can override this behavior and roll your own - or hook into an existing system, read [here](/usage2/StoringData.md#custom-transactionmanager). + or hook into an existing system, read [here](StoringData.md#custom-transactionmanager). -Also to use the legacy, priority-based system, read [here](/usage2/StoringData.md#priority-queue). +Also to use the legacy, priority-based system, read [here](StoringData.md#priority-queue). A basic transaction: @@ -274,7 +274,7 @@ In versions pre-3.0, DBFlow utilized a `PriorityBlockingQueue` to manage the asy dispatch of `Transaction`. As of 3.0, it has switched to simply a FIFO queue. To keep the legacy way, a `PriorityTransactionQueue` was created. -As seen in [Custom Transaction Managers](/usage2/StoringData.md#custom-transactionmanager), +As seen in [Custom Transaction Managers](StoringData.md#custom-transactionmanager), we provide a custom instance of the `DefaultTransactionManager` with the `PriorityTransactionQueue` specified: ```java From 99495e3566e38785870f6c580caa3915709f8d1f Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Thu, 11 May 2017 14:59:57 +0000 Subject: [PATCH 045/234] Deletes RXSupport.md Auto commit by GitBook Editor --- RXSupport.md => RXJavaSupport.md | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename RXSupport.md => RXJavaSupport.md (100%) diff --git a/RXSupport.md b/RXJavaSupport.md similarity index 100% rename from RXSupport.md rename to RXJavaSupport.md From 62206511b837e8b74c7d65383e6ae048e66b0a49 Mon Sep 17 00:00:00 2001 From: Albert Armea Date: Thu, 18 May 2017 23:50:37 -0700 Subject: [PATCH 046/234] Fix compile errors in retrieval docs This change updates the retrieval page so that the examples pass the table class to the QueryTransaction. In my testing of the queryResultCallback, I've had to provide the table class to the QueryTransaction in addition to the CursorResult. If I did not, I would get something similar to the following compile error: Error:(65, 94) error: is not abstract and does not override abstract method onQueryResult(QueryTransaction,CursorResult) in QueryResultCallback Error:(67, 33) error: name clash: onQueryResult(QueryTransaction,CursorResult) in and onQueryResult(QueryTransaction,CursorResult) in QueryResultCallback have the same erasure, yet neither overrides the other where TResult is a type-variable: TResult extends Object declared in interface QueryResultCallback Error:(66, 21) error: method does not override or implement a method from a supertype --- Retrieval.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Retrieval.md b/Retrieval.md index 6bb002636..d04acb0d0 100644 --- a/Retrieval.md +++ b/Retrieval.md @@ -63,7 +63,7 @@ SQLite.select() .async() .queryResultCallback(new QueryTransaction.QueryResultCallback() { @Override - public void onQueryResult(QueryTransaction transaction, @NonNull CursorResult tResult) { + public void onQueryResult(QueryTransaction transaction, @NonNull CursorResult tResult) { } }).execute(); @@ -82,7 +82,7 @@ FlowManager.getDatabaseForTable(TestModel1.class) .where(TestModel1_Table.name.is("Async"))) .queryResult(new QueryTransaction.QueryResultCallback() { @Override - public void onQueryResult(QueryTransaction transaction, @NonNull CursorResult tResult) { + public void onQueryResult(QueryTransaction transaction, @NonNull CursorResult tResult) { } }).build()) From 1e795c7d033130786c6dee215cca56cd88280cf7 Mon Sep 17 00:00:00 2001 From: Albert Armea Date: Thu, 6 Jul 2017 20:07:52 -0700 Subject: [PATCH 047/234] Update dead link in Retrieval QueryModel.md was renamed to QueryModels.md at one point but the link in here was not updated to reflect that change. Fixes #2 --- Retrieval.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Retrieval.md b/Retrieval.md index 6bb002636..f63cc10cd 100644 --- a/Retrieval.md +++ b/Retrieval.md @@ -40,7 +40,7 @@ AnotherTable anotherObject = SQLite.select() ``` -To query custom objects or lists, see how to do so in [QueryModel](QueryModel.md). +To query custom objects or lists, see how to do so in [QueryModel](QueryModels.md). Also you can query a `FlowCursorList`/`FlowTableList` from a query easily via `queryCursorList()` and the `queryTableList()` methods. To see more on these, From 2ddb639a8903b9a822107b50dc81a116330cdd39 Mon Sep 17 00:00:00 2001 From: fuzzagrosner Date: Thu, 20 Jul 2017 12:08:28 -0400 Subject: [PATCH 048/234] [kotlin] adding in kotlin examples throughout the documentation. --- Caching.md | 56 +++++++++++++++++++-- Databases.md | 106 +++++++++++++++++++++++++++++++++++++--- GettingStarted.md | 69 +++++++++++++++++++++----- Indexing.md | 24 ++++++++- Intro.md | 102 +++++++++++++++++--------------------- KotlinSupport.md | 12 +++-- ListBasedQueries.md | 6 +++ Migrations.md | 53 ++++++++++++++++++-- Relationships.md | 22 ++++++++- including-in-project.md | 12 ++--- 10 files changed, 364 insertions(+), 98 deletions(-) diff --git a/Caching.md b/Caching.md index b9ff0141b..c144ac5f3 100644 --- a/Caching.md +++ b/Caching.md @@ -45,6 +45,22 @@ public class CacheableModel { ``` +or in Kotlin: + +```kotlin + +@Table(database = AppDatabase.class, cachingEnabled = true) +class CacheableModel { + + @PrimaryKey(autoincrement = true) + var id: Long = 0L + + @Column + var name: String? = null; +} + +``` + to use caching on a table that uses multiple primary keys, [see](Caching.md#multiple-primary-key-caching). By default we use a `SimpleMapCache`, which loads `Model` into a `Map`. The key is @@ -73,6 +89,14 @@ model.save(); // save it to DB post any modifications to this object. ``` +```kotlin + +(select from MyModel::class where (...)).result?.let { result -> + result.name = "Name" + result.save() +} + +``` ## Disable Caching For Some Queries To disable caching on certain queries as you might want to project on only a few columns, @@ -87,6 +111,14 @@ select(My_Table.column, My_Table.column2) ``` +```kotlin + +select(My_Table.column, My_Table.column2) + .from(My::class) + .disableCaching() + .list; + +``` ## Advanced ### Specifying cache Size @@ -99,12 +131,17 @@ caches support sizing. It's up to each cache. To specify a custom cache for a table, please define a `public static final` field: ```java - @ModelCacheField public static ModelCache modelCache = new SimpleMapCache<>(); // replace with any cache you want. - ``` +```kotlin +companion object { + + @JvmField @ModelCacheField + val modelCache = SimpleMapCache() +} +``` ### Multiple Primary Key Caching This allows for tables that have multiple primary keys be used in caching. To use, @@ -113,8 +150,6 @@ for example we have a `Coordinate` class: ```java - - @Table(database = AppDatabase.class, cachingEnabled = true) public class Coordinate { @@ -133,7 +168,20 @@ public class Coordinate { @PrimaryKey double longitude; +``` +```kotlin + +@Table(database = AppDatabase.class, cachingEnabled = true) +class Coordinate(@PrimaryKey latitude: Double = 0.0, + @PrimaryKey longitude: Double = 0.0) { + + companion object { + @JvmField + @MultiCacheField + val cacheConverter = IMultiKeyCacheConverter { values -> "${values[0]},${values[1]}" } + } +} ``` diff --git a/Databases.md b/Databases.md index 27fa95047..257252b65 100644 --- a/Databases.md +++ b/Databases.md @@ -11,17 +11,70 @@ can only be associated with one database. ```java -@Database(name = AppDatabase.NAME, version = AppDatabase.VERSION) +@Database(version = AppDatabase.VERSION) public class AppDatabase { - public static final String NAME = "AppDatabase"; // we will add the .db extension - public static final int VERSION = 1; } +``` + +```kotlin +@Database(version = AppDatabase.VERSION) +object AppDatabase { + const val VERSION = 1 +} +``` +## Initialization + +To specify a custom **name** to the database, in previous versions of DBFlow (< 4.1.0), you had to specify it in the `@Database` annotation. As of 4.1.0, that method is deprecated and now it's preferred to pass it in the initialization of the `FlowManager`: + +```java + +FlowManager.init(FlowConfig.builder() + .addDatabaseConfig(DatabaseConfig.builder(AppDatabase.class) + .databaseName("AppDatabase") + .build()) + .build()) + +``` + +To dynamically change the database name, call: +```java + +FlowManager.getDatabase(AppDatabase.class) + .reset(DatabaseConfig.builder(AppDatabase.class) + .databaseName("AppDatabase-2") + .build()) + +``` + +```kotlin + +database() + .reset(DatabaseConfig.builder(AppDatabase.class) + .databaseName("AppDatabase-2") + .build()) + +``` + +This will close the open DB, reopen the DB, and replace previous `DatabaseConfig` with this new one. Ensure that you persist the changes to the `DatabaseConfig` somewhere as next time app is launched and DBFlow is initialized, the new config would get overwritten. + +### In Memory Databases + +As with **name**, in previous versions of DBFlow (< 4.1.0), you specified `inMemory` in the `@Database` annotation. Starting with 4.1.0 that is deprecated, and replaced with: +```java + +FlowManager.init(FlowConfig.builder() + .addDatabaseConfig(DatabaseConfig.inMemoryBuilder(AppDatabase.class) + .databaseName("AppDatabase") + .build()) + .build()) ``` +This will allow you to use in-memory databases in your tests, while writing to disk in your apps. Also if your device the app is running on is low on memory, you could also swap the DB into memory by calling `reset(DatabaseConfig)` as explained above. + ## Database Migrations Database migrations are run when upon open of the database connection, @@ -55,6 +108,25 @@ public class AppDatabase { } ``` + +```kotlin + +@Database(version = AppDatabase.VERSION) +object AppDatabase { + + const val VERSION = 2 + + @Migration(version = 2, database = MigrationDatabase.class) + class AddEmailToUserMigration : AlterTableMigration(User::class.java) { + + override fun onPreMigrate() { + addColumn(SQLiteType.TEXT, "email") + } + } +} + +``` + This simple example adds a column to the `User` table named "email". In code, just add the column to the `Model` class and this migration runs only on existing dbs. To read more on migrations and more examples of different kinds, visit the [page](Migrations.md). @@ -75,12 +147,19 @@ In DBFlow when an INSERT or UPDATE are performed, by default, we use `NONE`. If ```java -@Database(name = AppDatabase.NAME, version = AppDatabase.VERSION, insertConflict = ConflictAction.IGNORE, updateConflict= ConflictAction.REPLACE) +@Database(version = AppDatabase.VERSION, insertConflict = ConflictAction.IGNORE, updateConflict= ConflictAction.REPLACE) public class AppDatabase { } ``` +```kotlin +@Database(version = AppDatabase.VERSION, insertConflict = ConflictAction.IGNORE, updateConflict= ConflictAction.REPLACE) +object AppDatabase { +} + +``` + These follow the SQLite standard [here](https://www.sqlite.org/conflict.html). ### Integrity Checking @@ -111,13 +190,19 @@ public class CustomFlowSQliteOpenHelper extends FlowSQLiteOpenHelper { ``` + +```kotlin + +class CustomFlowSQliteOpenHelper(databaseDefinition: DatabaseDefinition, listener: DatabaseHelperListener) : FlowSQLiteOpenHelper(databaseDefinition, listener) + +``` Then in your `DatabaseConfig`: ```java -FlowManager.init(new FlowConfig.Builder(RuntimeEnvironment.application) +FlowManager.init(FlowConfig.builder(context) .addDatabaseConfig( - new DatabaseConfig.Builder(CipherDatabase.class) + DatabaseConfig.builder(CipherDatabase.class) .openHelper(new DatabaseConfig.OpenHelperCreator() { @Override public OpenHelper createHelper(DatabaseDefinition databaseDefinition, DatabaseHelperListener helperListener) { @@ -129,3 +214,12 @@ FlowManager.init(new FlowConfig.Builder(RuntimeEnvironment.application) ``` + +```kotlin +FlowManager.init(FlowConfig.builder(context) + .addDatabaseConfig(DatabaseConfig.Builder(CipherDatabase.class) + .openHelper(::CustomFlowSQliteOpenHelper) + .build()) + .build()) + +``` diff --git a/GettingStarted.md b/GettingStarted.md index 702d12b6a..6514d9f6f 100644 --- a/GettingStarted.md +++ b/GettingStarted.md @@ -11,22 +11,30 @@ can only be associated with one database. ```java -@Database(name = AppDatabase.NAME, version = AppDatabase.VERSION) +@Database(version = AppDatabase.VERSION) public class AppDatabase { - - public static final String NAME = "AppDatabase"; // we will add the .db extension - public static final int VERSION = 1; } ``` + +```kotlin + +@Database(version = AppDatabase.VERSION) +object AppDatabase { + const val VERSION = 1 +} +``` + +The name of the database by default is the class name. To change it, read [here](Databases.md). + Writing this file generates (by default) a `AppDatabaseAppDatabase_Database.java` file, which contains tables, views, and more all tied to a specific database. This class is automatically placed into the main `GeneratedDatabaseHolder`, which holds potentially many databases. The name, `AppDatabaseAppDatabase_Database.java`, is generated -via {DatabaseClassName}{DatabaseFileName}{GeneratedClassSepator, default = "\_"}Database +via {DatabaseClassName}{DatabaseFileName}_Database To learn more about what you can configure in a database, read [here](Databases.md) @@ -50,6 +58,16 @@ public class ExampleApplication extends Application { ``` +```kotlin +class ExampleApplication : Application { + + override fun onCreate() { + super.onCreate() + FlowManager.init(this) + } +} +``` + Finally, add the definition to the manifest (with the name that you chose for your custom application): ```xml ("MyIndex", SomeTable_Table.name, SomeTable_Table.othercolumn) +index.enable() + +index.disable() + +``` diff --git a/Intro.md b/Intro.md index 33e9cd444..32047cf28 100644 --- a/Intro.md +++ b/Intro.md @@ -3,71 +3,57 @@ DBFlow for Android lets you write very efficient database code while remaining expressive and concise. +DBFlow fully supports Kotlin and public API reflects that via `@NonNull` and `@Nullable` annotations. -```java +```kotlin -@Table(database = AppDatabase.class) -public class Automobile extends BaseModel { // convenience, but not required to interact with db +@Table(database = AppDatabase::class) +class Automobile(@PrimaryKey var vin: String? = null, + @Column var make: String? = null, + @Column var model: String = "", // nullability of kotlin fields respected + @Column var year: Int = 0) // default constructor required - @PrimaryKey - String vin; - - @Column - String make; - - @Column - String model; - - @Column - int year; - -} - -Automobile venza = new Automobile(); -venza.vin = "499499449"; -venza.make = "Toyota"; -venza.model = "Venza"; -venza.year = 2013; -venza.save(); // inserts if not exists by primary key, updates if exists. +val venza = new Automobile(vin = "499499449", + make = "Toyota", + model = "Venza", + year = 2013); +venza.save(); +// inserts if not exists by primary key, updates if exists. +// Kotlin extensions add methods found in BaseModel // querying // SELECT * FROM `Automobile` WHERE `year`=2001 AND `model`='Camry' // we autogen a "_Table" class that contains convenience Properties which provide easy SQL ops. -SQLite().select() - .from(Automobile.class) - .where(Automobile_Table.year.is(2001)) - .and(Automobile_Table.model.is("Camry")) - .async() - .queryResultCallback(new QueryTransaction.QueryResultCallback() { - @Override - public void onQueryResult(QueryTransaction transaction, @NonNull CursorResult tResult) { - // called when query returns on UI thread - List autos = tResult.toListClose(); - // do something with results - } - }, new Transaction.Error() { - @Override - public void onError(Transaction transaction, Throwable error) { - // handle any errors - } - }).execute(); - -// run a transaction synchronous easily. -DatabaseDefinition database = FlowManager.getDatabase(AppDatabase.class); -database.executeTransaction(new ITransaction() { - @Override - public void execute(DatabaseWrapper databaseWrapper) { - // do something here - } -}); - -// run asynchronous transactions easily, with expressive builders -database.beginTransactionAsync(new ITransaction() { - @Override - public void execute(DatabaseWrapper databaseWrapper) { - // do something in BG - } - }).success(successCallback).error(errorCallback).build().execute(); +(select from Automobile:::class + where Automobile_Table.year.is(2001) + and Automobile_Table.model.is("Camry")).async() + +(select from Automobile::class + where Automobile_Table.year.`is`(2001) + and Automobile_Table.model.`is`("Camry")).async() + .queryResultCallback { transaction, tResult -> + // called when query returns on UI thread + val autos = tResult.toListClose() + // do something with results + } + .error { transaction, error -> + // handle any errors + }.execute() + + // run a transaction synchronous easily. + val database = database() + database.executeTransaction { + // do something here + } + + // run asynchronous transactions easily, with expressive builders + database.beginTransactionAsync { + // do something in BG + }.success { transaction -> + + }.error { transaction, error -> + + }.build().execute() ``` diff --git a/KotlinSupport.md b/KotlinSupport.md index 4c324de17..fde094179 100644 --- a/KotlinSupport.md +++ b/KotlinSupport.md @@ -41,6 +41,10 @@ car.exists() ``` +## Null Safety +DBFlow reflects the nullability on fields defined in their classes. If you define a +`@Column` as not null, it will not assign a null value to that field in the generated java. + ## Query LINQ Syntax Kotlin has nice support for custim `infix` operators. Using this we can convert a regular, Plain old java query into a C#-like LINQ syntax. @@ -183,15 +187,15 @@ var items = (select from TestModel1::class).list // easily delete all these items with success items.processInTransactionAsync({ it, databaseWrapper -> it.delete(databaseWrapper) }, - Transaction.Success { + success = { transaction -> // do something here }) // delete with all callbacks items.processInTransactionAsync({ it, databaseWrapper -> it.delete(databaseWrapper) }, - Transaction.Success { + success = { transaction -> // do something here }, - Transaction.Error { transaction, throwable -> + error = { transaction, throwable -> }) @@ -211,7 +215,7 @@ items.processInTransaction { it, databaseWrapper -> it.delete(databaseWrapper) } #### Class Extensions If you need access to the Database, ModelAdapter, etc for a specific class you -can now use the following (and more) reified global functions for easy access! +can now use the following (and more) inline reified global functions for easy access! ```kotlin diff --git a/ListBasedQueries.md b/ListBasedQueries.md index c2af48a64..593a29c57 100644 --- a/ListBasedQueries.md +++ b/ListBasedQueries.md @@ -26,6 +26,12 @@ FlowCursorList list = SQLite.select() ``` +```kotlin +val list = (select from MyTable::class where (...)).cursorList +val list = (select from MyTable::class where (...)).flowQueryList +list.close() +``` + Any query method allows you to retrieve a default implementation of each. You can also manually instantiate them: diff --git a/Migrations.md b/Migrations.md index 36b78c6b8..b9ca5e593 100644 --- a/Migrations.md +++ b/Migrations.md @@ -23,11 +23,9 @@ We recommend placing any `Migration` inside an associated `@Database` class so i An example migration class: ```java -@Database(version = 2, name = AppDatabase.NAME) +@Database(version = 2) public class AppDatabase { - public static final String NAME = "AppDatabase"; - @Migration(version = 2, database = AppDatabase.class) public static class Migration2 extends BaseMigration { @@ -43,6 +41,24 @@ public class AppDatabase { } ``` +```kotlin +@Database(version = 2) +object AppDatabase { + + @Migration(version = 2, database = AppDatabase.class) + class Migration2 : BaseMigration() { + + override fun migrate(database: DatabaseWrapper) { + // run some code here + (update() + set Employee_Table.status.eq("Invalid") + where Employee_Table.job.eq("Laid Off")) + .execute(database) // required to pass wrapper in migration + } + } +} +``` + The classes provide the ability to set a `priority` on the `Migration` so that an order is established. The higher the priority, that one will execute first. `Migration` have three methods: @@ -110,6 +126,19 @@ public class Migration2 extends AlterTableMigration { ``` + +```kotlin +@Migration(version = 2, database = AppDatabase.class) +class Migration2 : AlterTableMigration(AModel::class.java) { + + override fun onPreMigrate() { + addColumn(SQLiteType.TEXT, "myColumn") + addColumn(SQLiteType.REAL, "anotherColumn") + } +} + +``` + ### Index Migrations An `IndexMigration` (and `IndexPropertyMigration`) is used to structurally activate an `Index` on the database at a specific version. See [here](Indexing.md) for information on creating them. @@ -135,6 +164,15 @@ public static class IndexMigration2 extends IndexMigration { } ``` +```kotlin +@Migration(version = 2, priority = 0, database = MigrationDatabase::class) +class IndexMigration2 : IndexMigration(MigrationModel::class.java) { + + override fun getName() = "TestIndex" +} + +``` + An `IndexPropertyMigration`: ```java @@ -151,6 +189,15 @@ public static class IndexPropertyMigration2 extends IndexPropertyMigration { ``` +```kotlin +@Migration(version = 2, priority = 1, database = MigrationDatabase.class) +class IndexPropertyMigration2 : IndexPropertyMigration { + + override fun getIndexProperty() = IndexModel_Table.index_customIndex +} + +``` + ### Update Table Migration A simple wrapper around `Update`, provides simply a default way to update data during a migration. diff --git a/Relationships.md b/Relationships.md index 9b6192374..f10c24759 100644 --- a/Relationships.md +++ b/Relationships.md @@ -93,12 +93,12 @@ public class Queen extends BaseModel { List ants; - @OneToMany(methods = {OneToMany.Method.ALL}, _variableName = "ants") + @OneToMany(methods = {OneToMany.Method.ALL}, variableName = "ants") public List getMyAnts() { if (ants == null || ants.isEmpty()) { ants = SQLite.select() .from(Ant.class) - .where(Ant_Table.queenForeignKeyContainer_id.eq(id)) + .where(Ant_Table.queen_id.eq(id)) .queryList(); } return ants; @@ -107,6 +107,24 @@ public class Queen extends BaseModel { ``` +### Efficient Methods +When using `@ManyToMany`, by default we skip the `Model` methods in each retrieved `Ant` (in this example). +If you have nested `@ManyToMany` (which should strongly be avoided), you can turn off the efficient operations. +Call `@OneToMany(efficientMethods = false)` and it will instead loop through each model and perform `save()`, `delete()`, etc +when the parent model is called. + +### Kotlin Support + +Also, with DBFlow Kotlin extensions, we can make this much more concise: +```kotlin + +@get:OneToMany(methods = arrayOf(OneToMany.Method.ALL)) +var ants by oneToMany { select from Ant::class where (Ant_Table.queen_id.eq(id)) } +``` + +This creates a delegated property which does the same operation as above. The only difference is the +variable is nullable. + ### Custom ForeignKeyReferences When simple `@ForeignKey` annotation is not enough, you can manually specify references for your table: diff --git a/including-in-project.md b/including-in-project.md index 88594c2ae..1b58dfa29 100644 --- a/including-in-project.md +++ b/including-in-project.md @@ -28,6 +28,9 @@ allProjects { ``` ```Groovy + + apply plugin: 'kotlin-kapt' // required for Kotlin + def dbflow_version = "xxxx" // reference the releases tab on Github for latest versions // or you can grab a 10-digit commit hash of any commit in the project that builds. @@ -60,12 +63,5 @@ allProjects { compile "com.github.Raizlabs.DBFlow:dbflow-rx2-kotlinextensions:${dbflow_version}" } - - // if you build with Kotlin KAPT1 (Kapt2/3 do not require this) - kapt { - generateStubs = true - } -``` - - +``` From b7028acd1bf6f8250b7496afdb2ad57bf5b14a00 Mon Sep 17 00:00:00 2001 From: fuzzagrosner Date: Thu, 20 Jul 2017 16:00:18 -0400 Subject: [PATCH 049/234] [kotlin] more examples in kotlin. add reference for ColumnMap --- ModelViews.md | 19 +++++++++++++++++-- Models.md | 23 +++++++++++++++++++++-- MultipleModules.md | 2 +- 3 files changed, 39 insertions(+), 5 deletions(-) diff --git a/ModelViews.md b/ModelViews.md index f9eb4dcbb..3c6e49436 100644 --- a/ModelViews.md +++ b/ModelViews.md @@ -22,14 +22,25 @@ public class TestModelView { ``` +```kotlin +@ModelView(database = TestDatabase::class) +class TestModelView(@Column modelOrder: Long = 0L) { + + companion object { + @ModelViewQuery @JvmField + val query = (select from TestModel2::class where TestModel2_Table.model_order.greaterThan(5)) + } +} + +``` + To specify the query that a `ModelView` creates itself with, we _must_ define a public static final field annotated with `@ModelViewQuery`. This tells DBFlow what field is the query. This query is used only once when the database is created (or updated) to create the view. - The full list of limitations/supported types are: - 1. Only `@Column` are allowed + 1. Only `@Column`/`@ColumnMap` are allowed 2. No `@PrimaryKey` or `@ForeignKey` 3. Supports all fields, and accessibility modifiers that `Model` support 4. Does not support `@InheritedField`, `@InheritedPrimaryKey` @@ -45,3 +56,7 @@ SQLite.select() .where(...) // ETC ``` + +```kotlin +(select from TestModelView::class where (...)) +``` diff --git a/Models.md b/Models.md index 30f4108b7..e2b59e3ef 100644 --- a/Models.md +++ b/Models.md @@ -1,6 +1,6 @@ # Models -In DBFlow we dont have any restrictions on what your table class is. We do, however recommend you subclass `BaseModel` on +In DBFlow we dont have any restrictions on what your table class is. We do, however if you use Java, we recommend you subclass `BaseModel` on your highest-order base-class, which provides a default implementation for you. When using regular models: @@ -14,9 +14,14 @@ When using `BaseModel`, it is much cleaner: myTableObject.save(); ``` +if you use Kotlin, you can add the [kotlin extensions](/KotlinSupport.md) to your project use them as extension methods: +```kotlin +myTableObject.save() +``` + ## Columns -We, by default, lazily look for columns. This means that they all must contain either `@PrimaryKey`, `@Column`, or `@ForeignKey` to be used in tables. +By default, DBFlow lazily looks for columns. This means that they all must contain either `@PrimaryKey`, `@Column`, or `@ForeignKey` to be used in tables. If you wish to make it simpler and include all fields in a class, set `@Table(allFields = true)`. However this still requires you to specify at least one `@PrimaryKey` field. You @@ -46,6 +51,11 @@ public class Dog { ``` +```kotlin +@Table(database = AppDatabase.class) +public class Dog(@Primary var name: String? = null) +``` + Columns have a wide-range of supported types in the `Model` classes: **Supported Types**: 1. all java primitives including `char`,`byte`, `short`, and `boolean`. @@ -53,6 +63,7 @@ Columns have a wide-range of supported types in the `Model` classes: 3. String, Date, java.sql.Date, Calendar, Blob, Boolean 4. Custom data types via a [TypeConverter](TypeConverters.md) 5. `Model` as fields, but only as `@PrimaryKey` and/or `@ForeignKey` + 6. `@ColumnMap` objects that flatten an object into the current table. Just like a `@ForeignKey`, but without requiring a separate table. (4.1.0+). Avoid nesting more than one object, as the column count could get out of control. **Unsupported Types**: 1. `List` : List columns are not supported and not generally proper for a relational database. However, you can get away with a non-generic `List` column via a `TypeConverter`. But again, avoid this if you can. @@ -92,6 +103,14 @@ public class Dog extends BaseModel { ``` +```kotlin +@Table(database = AppDatabase::class) +class Dog(@PrimaryKey var name: String? = null, + @PrimaryKey var breed: String? = null) + +``` + + If we want an auto-incrementing key, you specify `@PrimaryKey(autoincrement = true)`, but only one of these kind can exist in a table and you cannot mix with regular primary keys. ## Unique Columns diff --git a/MultipleModules.md b/MultipleModules.md index 69c963f83..8b2ce6f57 100644 --- a/MultipleModules.md +++ b/MultipleModules.md @@ -40,7 +40,7 @@ affect DBFlow. If DBFlow is already initialized, we append the module to DBFlow ```java public void initialize(Context context) { - FlowManager.init(new FlowConfig.Builder(context) + FlowManager.init(FlowConfig.builder(context) .addDatabaseHolder(SomeUniqueModuleNameGeneratedDatabaseHolder.class) .build()); } From c2bc988209ca481f3c5cfd72c289851c1fbf7fd6 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sun, 22 Oct 2017 11:59:11 -0400 Subject: [PATCH 050/234] [5.0] converting lib to kotlin. --- .../rx/language/CursorResultSubscriber.java | 4 +- .../rx2/language/CursorResultFlowable.java | 4 +- .../dbflow/sqlcipher/SQLCipherOpenHelper.java | 2 +- .../dbflow/config/ConfigIntegrationTest.kt | 37 +- .../dbflow/config/DatabaseConfigTest.kt | 14 +- dbflow/build.gradle | 4 +- .../android/dbflow/config/DatabaseConfig.java | 194 ------- .../android/dbflow/config/DatabaseConfig.kt | 137 +++++ .../dbflow/config/DatabaseDefinition.java | 444 --------------- .../dbflow/config/DatabaseDefinition.kt | 381 +++++++++++++ .../android/dbflow/config/DatabaseHolder.java | 72 --- .../android/dbflow/config/DatabaseHolder.kt | 66 +++ .../android/dbflow/config/FlowConfig.java | 96 ---- .../android/dbflow/config/FlowConfig.kt | 57 ++ .../android/dbflow/config/FlowLog.java | 139 ----- .../raizlabs/android/dbflow/config/FlowLog.kt | 110 ++++ .../android/dbflow/config/FlowManager.java | 533 ------------------ .../android/dbflow/config/FlowManager.kt | 429 ++++++++++++++ .../android/dbflow/list/FlowCursorList.java | 2 +- .../runtime/BaseTransactionManager.java | 2 +- .../dbflow/runtime/DBBatchSaveQueue.java | 2 +- .../sql/language/BaseModelQueriable.java | 12 +- .../dbflow/sql/language/BaseQueriable.java | 8 +- .../android/dbflow/sql/language/Operator.java | 2 +- .../sql/saveable/AutoIncrementModelSaver.java | 2 +- .../dbflow/structure/ModelAdapter.java | 8 +- .../structure/cache/SimpleMapCache.java | 2 +- .../cache/SparseArrayBasedCache.java | 2 +- .../database/BaseDatabaseHelper.java | 16 +- .../database/DatabaseHelperDelegate.java | 12 +- .../database/FlowSQLiteOpenHelper.java | 8 +- .../transaction/DefaultTransactionQueue.java | 2 +- .../transaction/PriorityTransactionQueue.java | 2 +- .../database/transaction/Transaction.java | 2 +- .../structure/provider/ContentUtils.java | 4 +- 35 files changed, 1254 insertions(+), 1557 deletions(-) delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseHolder.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseHolder.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowConfig.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowConfig.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowLog.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowLog.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriber.java b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriber.java index db0f5fd63..87f2c4d1a 100644 --- a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriber.java +++ b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriber.java @@ -82,13 +82,13 @@ public void call(CursorResult ts) { } limit = requested.addAndGet(-limit); } catch (Exception e) { - FlowLog.logError(e); + FlowLog.INSTANCE.logError(e); subscriber.onError(e); } finally { try { iterator.close(); } catch (Exception e) { - FlowLog.logError(e); + FlowLog.INSTANCE.logError(e); subscriber.onError(e); } } diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/CursorResultFlowable.java b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/CursorResultFlowable.java index d6922f376..b39b3b73a 100644 --- a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/CursorResultFlowable.java +++ b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/CursorResultFlowable.java @@ -88,13 +88,13 @@ public void onSuccess(CursorResult ts) { } limit = requested.addAndGet(-limit); } catch (Exception e) { - FlowLog.logError(e); + FlowLog.INSTANCE.logError(e); subscriber.onError(e); } finally { try { iterator.close(); } catch (Exception e) { - FlowLog.logError(e); + FlowLog.INSTANCE.logError(e); subscriber.onError(e); } } diff --git a/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherOpenHelper.java b/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherOpenHelper.java index ea34301a5..8465cb8c0 100644 --- a/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherOpenHelper.java +++ b/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherOpenHelper.java @@ -17,7 +17,7 @@ import net.sqlcipher.database.SQLiteOpenHelper; /** - * Description: The replacement {@link OpenHelper} for SQLCipher. Specify a subclass of this is {@link DatabaseConfig#databaseClass()} + * Description: The replacement {@link OpenHelper} for SQLCipher. Specify a subclass of this is {@link DatabaseConfig#getDatabaseClass()} * of your database to get it to work with specifying the secret you use for the database. */ public abstract class SQLCipherOpenHelper extends SQLiteOpenHelper implements OpenHelper { diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/config/ConfigIntegrationTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/config/ConfigIntegrationTest.kt index e475503cb..b7711d9cf 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/config/ConfigIntegrationTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/config/ConfigIntegrationTest.kt @@ -1,19 +1,12 @@ package com.raizlabs.android.dbflow.config -import com.nhaarman.mockito_kotlin.mock import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.TestDatabase import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.runtime.BaseTransactionManager import com.raizlabs.android.dbflow.sql.queriable.ListModelLoader import com.raizlabs.android.dbflow.sql.queriable.SingleModelLoader import com.raizlabs.android.dbflow.sql.saveable.ModelSaver -import com.raizlabs.android.dbflow.structure.database.DatabaseHelperListener -import com.raizlabs.android.dbflow.structure.database.OpenHelper -import com.raizlabs.android.dbflow.structure.database.transaction.ITransactionQueue -import org.junit.Assert.assertEquals -import org.junit.Assert.assertNotNull -import org.junit.Assert.assertTrue +import org.junit.Assert.* import org.junit.Before import org.junit.Test @@ -35,14 +28,14 @@ class ConfigIntegrationTest : BaseUnitTest() { @Test fun test_flowConfig() { FlowManager.init(builder - .openDatabasesOnInit(true) - .build()) + .openDatabasesOnInit(true) + .build()) val config = FlowManager.getConfig() assertNotNull(config) - assertEquals(config.openDatabasesOnInit(), true) - assertTrue(config.databaseConfigMap().isEmpty()) - assertTrue(config.databaseHolders().isEmpty()) + assertEquals(config.openDatabasesOnInit, true) + assertTrue(config.databaseConfigMap.isEmpty()) + assertTrue(config.databaseHolders.isEmpty()) } @Test @@ -53,23 +46,23 @@ class ConfigIntegrationTest : BaseUnitTest() { val modelSaver = ModelSaver() FlowManager.init(builder - .addDatabaseConfig(DatabaseConfig.Builder(TestDatabase::class.java) - .addTableConfig(TableConfig.Builder(SimpleModel::class.java) - .singleModelLoader(singleModelLoader) - .listModelLoader(customListModelLoader) - .modelAdapterModelSaver(modelSaver) - .build()) + .addDatabaseConfig(DatabaseConfig.Builder(TestDatabase::class.java) + .addTableConfig(TableConfig.Builder(SimpleModel::class.java) + .singleModelLoader(singleModelLoader) + .listModelLoader(customListModelLoader) + .modelAdapterModelSaver(modelSaver) + .build()) + .build()) .build()) - .build()) val flowConfig = FlowManager.getConfig() assertNotNull(flowConfig) - val databaseConfig = flowConfig.databaseConfigMap()[TestDatabase::class.java] as DatabaseConfig + val databaseConfig = flowConfig.databaseConfigMap[TestDatabase::class.java] as DatabaseConfig assertNotNull(databaseConfig) - val config = databaseConfig.tableConfigMap()[SimpleModel::class.java] as TableConfig + val config = databaseConfig.tableConfigMap[SimpleModel::class.java] as TableConfig assertNotNull(config) assertEquals(config.listModelLoader(), customListModelLoader) diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/config/DatabaseConfigTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/config/DatabaseConfigTest.kt index 4ac3564ad..8596a1623 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/config/DatabaseConfigTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/config/DatabaseConfigTest.kt @@ -46,14 +46,14 @@ class DatabaseConfigTest : BaseUnitTest() { val flowConfig = FlowManager.getConfig() Assert.assertNotNull(flowConfig) - val databaseConfig = flowConfig.databaseConfigMap()[TestDatabase::class.java]!! + val databaseConfig = flowConfig.getDatabaseConfigMap()[TestDatabase::class.java]!! Assert.assertEquals("Test", databaseConfig.databaseName) Assert.assertEquals(".db", databaseConfig.databaseExtensionName) - Assert.assertEquals(databaseConfig.transactionManagerCreator(), managerCreator) - Assert.assertEquals(databaseConfig.databaseClass(), TestDatabase::class.java) - Assert.assertEquals(databaseConfig.helperCreator(), openHelperCreator) - Assert.assertEquals(databaseConfig.helperListener(), helperListener) - Assert.assertTrue(databaseConfig.tableConfigMap().isEmpty()) + Assert.assertEquals(databaseConfig.getTransactionManagerCreator(), managerCreator) + Assert.assertEquals(databaseConfig.getDatabaseClass(), TestDatabase::class.java) + Assert.assertEquals(databaseConfig.getOpenHelperCreator(), openHelperCreator) + Assert.assertEquals(databaseConfig.getHelperListener(), helperListener) + Assert.assertTrue(databaseConfig.getTableConfigMap().isEmpty()) val databaseDefinition = FlowManager.getDatabase(TestDatabase::class.java) @@ -71,7 +71,7 @@ class DatabaseConfigTest : BaseUnitTest() { .build()) .build()) - val databaseConfig = FlowManager.getConfig().databaseConfigMap()[TestDatabase::class.java]!! + val databaseConfig = FlowManager.getConfig().getDatabaseConfigMap()[TestDatabase::class.java]!! Assert.assertEquals("Test", databaseConfig.databaseName) Assert.assertEquals("", databaseConfig.databaseExtensionName) } diff --git a/dbflow/build.gradle b/dbflow/build.gradle index 896bdc472..e05d7ae7b 100644 --- a/dbflow/build.gradle +++ b/dbflow/build.gradle @@ -1,4 +1,5 @@ apply plugin: 'com.android.library' +apply plugin: 'kotlin-android' project.ext.artifactId = bt_name @@ -25,7 +26,8 @@ android { dependencies { api project("${dbflow_project_prefix}dbflow-core") - api "com.android.support:support-annotations:26.0.1" + api "com.android.support:support-annotations:26.1.0" + compile "org.jetbrains.kotlin:kotlin-stdlib-jre7:$kotlin_version" } apply from: '../android-artifacts.gradle' diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.java deleted file mode 100644 index 11c3d50cd..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.java +++ /dev/null @@ -1,194 +0,0 @@ -package com.raizlabs.android.dbflow.config; - -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.StringUtils; -import com.raizlabs.android.dbflow.runtime.BaseTransactionManager; -import com.raizlabs.android.dbflow.runtime.ModelNotifier; -import com.raizlabs.android.dbflow.structure.database.DatabaseHelperListener; -import com.raizlabs.android.dbflow.structure.database.OpenHelper; - -import java.util.HashMap; -import java.util.Map; - -/** - * Description: - */ -public final class DatabaseConfig { - - public static DatabaseConfig.Builder builder(@NonNull Class database) { - return new DatabaseConfig.Builder(database); - } - - public static DatabaseConfig.Builder inMemoryBuilder(@NonNull Class database) { - return new DatabaseConfig.Builder(database).inMemory(); - } - - public interface OpenHelperCreator { - - OpenHelper createHelper(DatabaseDefinition databaseDefinition, DatabaseHelperListener helperListener); - } - - public interface TransactionManagerCreator { - - BaseTransactionManager createManager(DatabaseDefinition databaseDefinition); - } - - private final OpenHelperCreator openHelperCreator; - private final Class databaseClass; - private final TransactionManagerCreator transactionManagerCreator; - private final DatabaseHelperListener helperListener; - private final Map, TableConfig> tableConfigMap; - private final ModelNotifier modelNotifier; - private final boolean inMemory; - private final String databaseName; - private final String databaseExtensionName; - - DatabaseConfig(Builder builder) { - openHelperCreator = builder.openHelperCreator; - databaseClass = builder.databaseClass; - transactionManagerCreator = builder.transactionManagerCreator; - helperListener = builder.helperListener; - tableConfigMap = builder.tableConfigMap; - modelNotifier = builder.modelNotifier; - inMemory = builder.inMemory; - if (builder.databaseName == null) { - databaseName = builder.databaseClass.getSimpleName(); - } else { - databaseName = builder.databaseName; - } - - if (builder.databaseExtensionName == null) { - databaseExtensionName = ".db"; - } else { - databaseExtensionName = StringUtils.isNotNullOrEmpty(builder.databaseExtensionName) - ? "." + builder.databaseExtensionName : ""; - } - } - - @NonNull - public String getDatabaseExtensionName() { - return databaseExtensionName; - } - - public boolean isInMemory() { - return inMemory; - } - - @NonNull - public String getDatabaseName() { - return databaseName; - } - - @Nullable - public OpenHelperCreator helperCreator() { - return openHelperCreator; - } - - @Nullable - public DatabaseHelperListener helperListener() { - return helperListener; - } - - @NonNull - public Class databaseClass() { - return databaseClass; - } - - @Nullable - public TransactionManagerCreator transactionManagerCreator() { - return transactionManagerCreator; - } - - @Nullable - public ModelNotifier modelNotifier() { - return modelNotifier; - } - - @NonNull - public Map, TableConfig> tableConfigMap() { - return tableConfigMap; - } - - @SuppressWarnings("unchecked") - @Nullable - public TableConfig getTableConfigForTable(Class modelClass) { - return tableConfigMap().get(modelClass); - } - - public static final class Builder { - - OpenHelperCreator openHelperCreator; - final Class databaseClass; - TransactionManagerCreator transactionManagerCreator; - DatabaseHelperListener helperListener; - final Map, TableConfig> tableConfigMap = new HashMap<>(); - ModelNotifier modelNotifier; - boolean inMemory = false; - String databaseName; - String databaseExtensionName; - - public Builder(@NonNull Class databaseClass) { - this.databaseClass = databaseClass; - } - - public Builder transactionManagerCreator(TransactionManagerCreator transactionManager) { - this.transactionManagerCreator = transactionManager; - return this; - } - - public Builder helperListener(DatabaseHelperListener helperListener) { - this.helperListener = helperListener; - return this; - } - - public Builder addTableConfig(TableConfig tableConfig) { - tableConfigMap.put(tableConfig.tableClass(), tableConfig); - return this; - } - - public Builder modelNotifier(ModelNotifier modelNotifier) { - this.modelNotifier = modelNotifier; - return this; - } - - @NonNull - public Builder inMemory() { - inMemory = true; - return this; - } - - /** - * @return Pass in dynamic database name here. Otherwise it defaults to class name. - */ - @NonNull - public Builder databaseName(String name) { - databaseName = name; - return this; - } - - /** - * @return Pass in the extension for the DB here. - * Otherwise defaults to ".db". If empty string passed, no extension is used. - */ - public Builder extensionName(String name) { - databaseExtensionName = name; - return this; - } - - /** - * Overrides the default {@link OpenHelper} for a {@link DatabaseDefinition}. - * - * @param openHelper The openhelper to use. - */ - public Builder openHelper(OpenHelperCreator openHelper) { - openHelperCreator = openHelper; - return this; - } - - public DatabaseConfig build() { - return new DatabaseConfig(this); - } - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.kt new file mode 100644 index 000000000..fac7dce98 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.kt @@ -0,0 +1,137 @@ +package com.raizlabs.android.dbflow.config + +import com.raizlabs.android.dbflow.StringUtils +import com.raizlabs.android.dbflow.runtime.BaseTransactionManager +import com.raizlabs.android.dbflow.runtime.ModelNotifier +import com.raizlabs.android.dbflow.structure.database.DatabaseHelperListener +import com.raizlabs.android.dbflow.structure.database.OpenHelper +import java.util.* + +/** + * Description: + */ +class DatabaseConfig( + val databaseClass: Class<*>, + val openHelperCreator: ((DatabaseDefinition, DatabaseHelperListener?) -> OpenHelper)? = null, + val transactionManagerCreator: ((DatabaseDefinition) -> BaseTransactionManager)? = null, + val helperListener: DatabaseHelperListener? = null, + val tableConfigMap: Map, TableConfig<*>> = mapOf(), + val modelNotifier: ModelNotifier? = null, + val isInMemory: Boolean = false, + val databaseName: String? = null, + val databaseExtensionName: String? = null) { + + + interface OpenHelperCreator { + + fun createHelper(databaseDefinition: DatabaseDefinition, helperListener: DatabaseHelperListener?): OpenHelper + } + + interface TransactionManagerCreator { + + fun createManager(databaseDefinition: DatabaseDefinition): BaseTransactionManager + } + + internal constructor(builder: Builder) : this( + // convert java interface to kotlin function. + openHelperCreator = builder.openHelperCreator?.let { + { databaseDefinition: DatabaseDefinition, helperListener: DatabaseHelperListener? -> + it.createHelper(databaseDefinition, helperListener) + } + }, + databaseClass = builder.databaseClass, + transactionManagerCreator = builder.transactionManagerCreator?.let { + { databaseDefinition: DatabaseDefinition -> + it.createManager(databaseDefinition) + } + }, + helperListener = builder.helperListener, + tableConfigMap = builder.tableConfigMap, + modelNotifier = builder.modelNotifier, + isInMemory = builder.inMemory, + databaseName = builder.databaseName ?: builder.databaseClass.simpleName, + databaseExtensionName = when { + builder.databaseExtensionName == null -> ".db" + StringUtils.isNotNullOrEmpty(builder.databaseExtensionName) -> ".${builder.databaseExtensionName}" + else -> "" + }) + + @Suppress("UNCHECKED_CAST") + fun getTableConfigForTable(modelClass: Class): TableConfig? { + return tableConfigMap[modelClass] as TableConfig? + } + + /** + * Build compatibility class for Java. Use the [DatabaseConfig] class directly if Kotlin consumer. + */ + class Builder(internal val databaseClass: Class<*>) { + + internal var openHelperCreator: OpenHelperCreator? = null + internal var transactionManagerCreator: TransactionManagerCreator? = null + internal var helperListener: DatabaseHelperListener? = null + internal val tableConfigMap: MutableMap, TableConfig<*>> = HashMap() + internal var modelNotifier: ModelNotifier? = null + internal var inMemory = false + internal var databaseName: String? = null + internal var databaseExtensionName: String? = null + + fun transactionManagerCreator(transactionManager: TransactionManagerCreator) = apply { + this.transactionManagerCreator = transactionManager + } + + fun helperListener(helperListener: DatabaseHelperListener) = apply { + this.helperListener = helperListener + } + + fun addTableConfig(tableConfig: TableConfig<*>) = apply { + tableConfigMap.put(tableConfig.tableClass(), tableConfig) + } + + fun modelNotifier(modelNotifier: ModelNotifier) = apply { + this.modelNotifier = modelNotifier + } + + fun inMemory() = apply { + inMemory = true + } + + /** + * @return Pass in dynamic database name here. Otherwise it defaults to class name. + */ + fun databaseName(name: String) = apply { + databaseName = name + } + + /** + * @return Pass in the extension for the DB here. + * Otherwise defaults to ".db". If empty string passed, no extension is used. + */ + fun extensionName(name: String) = apply { + databaseExtensionName = name + } + + /** + * Overrides the default [OpenHelper] for a [DatabaseDefinition]. + * + * @param openHelper The openhelper to use. + */ + fun openHelper(openHelper: OpenHelperCreator) = apply { + openHelperCreator = openHelper + } + + fun build() = DatabaseConfig(this) + } + + companion object { + + @JvmStatic + fun builder(database: Class<*>): DatabaseConfig.Builder { + return DatabaseConfig.Builder(database) + } + + @JvmStatic + fun inMemoryBuilder(database: Class<*>): DatabaseConfig.Builder { + return DatabaseConfig.Builder(database).inMemory() + } + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.java deleted file mode 100644 index 737c0e13f..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.java +++ /dev/null @@ -1,444 +0,0 @@ -package com.raizlabs.android.dbflow.config; - -import android.content.Context; -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.annotation.Database; -import com.raizlabs.android.dbflow.annotation.QueryModel; -import com.raizlabs.android.dbflow.annotation.Table; -import com.raizlabs.android.dbflow.runtime.BaseTransactionManager; -import com.raizlabs.android.dbflow.runtime.ContentResolverNotifier; -import com.raizlabs.android.dbflow.runtime.ModelNotifier; -import com.raizlabs.android.dbflow.sql.migration.Migration; -import com.raizlabs.android.dbflow.structure.BaseModelView; -import com.raizlabs.android.dbflow.structure.ModelAdapter; -import com.raizlabs.android.dbflow.structure.ModelViewAdapter; -import com.raizlabs.android.dbflow.structure.QueryModelAdapter; -import com.raizlabs.android.dbflow.structure.database.DatabaseHelperListener; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; -import com.raizlabs.android.dbflow.structure.database.FlowSQLiteOpenHelper; -import com.raizlabs.android.dbflow.structure.database.OpenHelper; -import com.raizlabs.android.dbflow.structure.database.transaction.DefaultTransactionManager; -import com.raizlabs.android.dbflow.structure.database.transaction.DefaultTransactionQueue; -import com.raizlabs.android.dbflow.structure.database.transaction.ITransaction; -import com.raizlabs.android.dbflow.structure.database.transaction.Transaction; - -import java.util.ArrayList; -import java.util.Collection; -import java.util.HashMap; -import java.util.LinkedHashMap; -import java.util.List; -import java.util.Map; - -/** - * Description: The main interface that all Database implementations extend from. This is for internal usage only - * as it will be generated for every {@link Database}. - */ -@SuppressWarnings("NullableProblems") -public abstract class DatabaseDefinition { - - private final Map> migrationMap = new HashMap<>(); - - private final Map, ModelAdapter> modelAdapters = new HashMap<>(); - - private final Map> modelTableNames = new HashMap<>(); - - private final Map, ModelViewAdapter> modelViewAdapterMap = new LinkedHashMap<>(); - - private final Map, QueryModelAdapter> queryModelAdapterMap = new LinkedHashMap<>(); - - /** - * The helper that manages database changes and initialization - */ - private OpenHelper openHelper; - - /** - * Allows for the app to listen for database changes. - */ - private DatabaseHelperListener helperListener; - - /** - * Used when resetting the DB - */ - private boolean isResetting = false; - - @NonNull - private BaseTransactionManager transactionManager; - - @Nullable - private DatabaseConfig databaseConfig; - - @Nullable - private ModelNotifier modelNotifier; - - public DatabaseDefinition() { - applyDatabaseConfig(FlowManager.getConfig().databaseConfigMap().get(getAssociatedDatabaseClassFile())); - } - - /** - * Applies a database configuration object to this class. - */ - @SuppressWarnings({"unchecked", "ConstantConditions"}) - void applyDatabaseConfig(@Nullable DatabaseConfig databaseConfig) { - this.databaseConfig = databaseConfig; - if (databaseConfig != null) { - // initialize configuration if exists. - Collection tableConfigCollection = databaseConfig.tableConfigMap().values(); - for (TableConfig tableConfig : tableConfigCollection) { - ModelAdapter modelAdapter = modelAdapters.get(tableConfig.tableClass()); - if (modelAdapter == null) { - continue; - } - if (tableConfig.listModelLoader() != null) { - modelAdapter.setListModelLoader(tableConfig.listModelLoader()); - } - - if (tableConfig.singleModelLoader() != null) { - modelAdapter.setSingleModelLoader(tableConfig.singleModelLoader()); - } - - if (tableConfig.modelSaver() != null) { - modelAdapter.setModelSaver(tableConfig.modelSaver()); - } - - } - helperListener = databaseConfig.helperListener(); - } - if (databaseConfig == null || databaseConfig.transactionManagerCreator() == null) { - transactionManager = new DefaultTransactionManager(this); - } else { - transactionManager = databaseConfig.transactionManagerCreator().createManager(this); - } - } - - protected void addModelAdapter(ModelAdapter modelAdapter, DatabaseHolder holder) { - holder.putDatabaseForTable(modelAdapter.getModelClass(), this); - modelTableNames.put(modelAdapter.getTableName(), modelAdapter.getModelClass()); - modelAdapters.put(modelAdapter.getModelClass(), modelAdapter); - } - - protected void addModelViewAdapter(ModelViewAdapter modelViewAdapter, DatabaseHolder holder) { - holder.putDatabaseForTable(modelViewAdapter.getModelClass(), this); - modelViewAdapterMap.put(modelViewAdapter.getModelClass(), modelViewAdapter); - } - - protected void addQueryModelAdapter(QueryModelAdapter queryModelAdapter, DatabaseHolder holder) { - holder.putDatabaseForTable(queryModelAdapter.getModelClass(), this); - queryModelAdapterMap.put(queryModelAdapter.getModelClass(), queryModelAdapter); - } - - protected void addMigration(int version, Migration migration) { - List list = migrationMap.get(version); - if (list == null) { - list = new ArrayList<>(); - migrationMap.put(version, list); - } - list.add(migration); - } - - /** - * @return a list of all model classes in this database. - */ - @NonNull - public List> getModelClasses() { - return new ArrayList<>(modelAdapters.keySet()); - } - - @NonNull - public BaseTransactionManager getTransactionManager() { - return transactionManager; - } - - /** - * Internal method used to create the database schema. - * - * @return List of Model Adapters - */ - @NonNull - public List getModelAdapters() { - return new ArrayList<>(modelAdapters.values()); - } - - /** - * Returns the associated {@link ModelAdapter} within this database for - * the specified table. If the Model is missing the {@link Table} annotation, - * this will return null. - * - * @param table The model that exists in this database. - * @return The ModelAdapter for the table. - */ - @SuppressWarnings("unchecked") - @Nullable - public ModelAdapter getModelAdapterForTable(Class table) { - return modelAdapters.get(table); - } - - /** - * @param tableName The name of the table in this db. - * @return The associated {@link ModelAdapter} within this database for the specified table name. - * If the Model is missing the {@link Table} annotation, this will return null. - */ - @Nullable - public Class getModelClassForName(String tableName) { - return modelTableNames.get(tableName); - } - - /** - * @return the {@link BaseModelView} list for this database. - */ - @NonNull - public List> getModelViews() { - return new ArrayList<>(modelViewAdapterMap.keySet()); - } - - /** - * @param table the VIEW class to retrieve the ModelViewAdapter from. - * @return the associated {@link ModelViewAdapter} for the specified table. - */ - @SuppressWarnings("unchecked") - @Nullable - public ModelViewAdapter getModelViewAdapterForTable(Class table) { - return modelViewAdapterMap.get(table); - } - - /** - * @return The list of {@link ModelViewAdapter}. Internal method for - * creating model views in the DB. - */ - @NonNull - public List getModelViewAdapters() { - return new ArrayList<>(modelViewAdapterMap.values()); - } - - /** - * @return The list of {@link QueryModelAdapter}. Internal method for creating query models in the DB. - */ - @NonNull - public List getModelQueryAdapters() { - return new ArrayList<>(queryModelAdapterMap.values()); - } - - /** - * @param queryModel The {@link QueryModel} class - * @return The adapter that corresponds to the specified class. - */ - @SuppressWarnings("unchecked") - @Nullable - public QueryModelAdapter getQueryModelAdapterForQueryClass(Class queryModel) { - return queryModelAdapterMap.get(queryModel); - } - - /** - * @return The map of migrations to DB version - */ - @NonNull - public Map> getMigrations() { - return migrationMap; - } - - @NonNull - public synchronized OpenHelper getHelper() { - if (openHelper == null) { - DatabaseConfig config = FlowManager.getConfig().databaseConfigMap() - .get(getAssociatedDatabaseClassFile()); - if (config == null || config.helperCreator() == null) { - openHelper = new FlowSQLiteOpenHelper(this, helperListener); - } else { - openHelper = config.helperCreator().createHelper(this, helperListener); - } - openHelper.performRestoreFromBackup(); - } - return openHelper; - } - - @NonNull - public DatabaseWrapper getWritableDatabase() { - return getHelper().getDatabase(); - } - - @NonNull - public ModelNotifier getModelNotifier() { - if (modelNotifier == null) { - DatabaseConfig config = FlowManager.getConfig().databaseConfigMap() - .get(getAssociatedDatabaseClassFile()); - if (config == null || config.modelNotifier() == null) { - modelNotifier = new ContentResolverNotifier(); - } else { - modelNotifier = config.modelNotifier(); - } - } - return modelNotifier; - } - - @NonNull - public Transaction.Builder beginTransactionAsync(@NonNull ITransaction transaction) { - return new Transaction.Builder(transaction, this); - } - - public void executeTransaction(@NonNull ITransaction transaction) { - DatabaseWrapper database = getWritableDatabase(); - try { - database.beginTransaction(); - transaction.execute(database); - database.setTransactionSuccessful(); - } finally { - database.endTransaction(); - } - } - - /** - * @return The name of this database as defined in {@link Database} - */ - @NonNull - public String getDatabaseName() { - return databaseConfig != null ? databaseConfig.getDatabaseName() : getAssociatedDatabaseClassFile().getSimpleName(); - } - - /** - * @return The file name that this database points to - */ - @NonNull - public String getDatabaseFileName() { - return getDatabaseName() + getDatabaseExtensionName(); - } - - /** - * @return the extension for the file name. - */ - @NonNull - public String getDatabaseExtensionName() { - return databaseConfig != null ? databaseConfig.getDatabaseExtensionName() : ".db"; - } - - /** - * @return True if the database will reside in memory. - */ - public boolean isInMemory() { - return databaseConfig != null && databaseConfig.isInMemory(); - } - - /** - * @return The version of the database currently. - */ - public abstract int getDatabaseVersion(); - - /** - * @return True if the {@link Database#consistencyCheckEnabled()} annotation is true. - */ - public abstract boolean areConsistencyChecksEnabled(); - - /** - * @return True if the {@link Database#foreignKeyConstraintsEnforced()} annotation is true. - */ - public abstract boolean isForeignKeysSupported(); - - /** - * @return True if the {@link Database#backupEnabled()} annotation is true. - */ - public abstract boolean backupEnabled(); - - /** - * @return The class that defines the {@link Database} annotation. - */ - @NonNull - public abstract Class getAssociatedDatabaseClassFile(); - - - /** - * @deprecated use {@link #reset()} - */ - @Deprecated - public void reset(Context context) { - reset(databaseConfig); - } - - /** - * Performs a full deletion of this database. Reopens the {@link FlowSQLiteOpenHelper} as well. - * Reapplies the {@link DatabaseConfig} if we have one. - */ - public void reset() { - reset(databaseConfig); - } - - /** - * Performs a full deletion of this database. Reopens the {@link FlowSQLiteOpenHelper} as well. - * - * @param databaseConfig sets a new {@link DatabaseConfig} on this class. - */ - public void reset(@Nullable DatabaseConfig databaseConfig) { - if (!isResetting) { - destroy(); - // reapply configuration before opening it. - applyDatabaseConfig(databaseConfig); - getHelper().getDatabase(); - } - } - - /** - * Reopens the DB with the new {@link DatabaseConfig} specified. - */ - public void reopen(@Nullable DatabaseConfig databaseConfig) { - if (!isResetting) { - close(); - openHelper = null; - applyDatabaseConfig(databaseConfig); - getHelper().getDatabase(); - isResetting = false; - } - } - - /** - * Closes and reopens the database. - */ - public void reopen() { - reopen(databaseConfig); - } - - /** - * Deletes the underlying database and destroys it. - */ - public void destroy() { - if (!isResetting) { - isResetting = true; - close(); - FlowManager.getContext().deleteDatabase(getDatabaseFileName()); - openHelper = null; - isResetting = false; - } - } - - /** - * Closes the DB and stops the {@link BaseTransactionManager} - */ - public void close() { - getTransactionManager().stopQueue(); - for (ModelAdapter modelAdapter : modelAdapters.values()) { - modelAdapter.closeInsertStatement(); - modelAdapter.closeCompiledStatement(); - modelAdapter.closeDeleteStatement(); - modelAdapter.closeUpdateStatement(); - } - getHelper().closeDB(); - } - - /** - * @return True if the database is ok. If backups are enabled, we restore from backup and will - * override the return value if it replaces the main DB. - */ - public boolean isDatabaseIntegrityOk() { - return getHelper().isDatabaseIntegrityOk(); - } - - /** - * Saves the database as a backup on the {@link DefaultTransactionQueue}. This will - * create a THIRD database to use as a backup to the backup in case somehow the overwrite fails. - * - * @throws java.lang.IllegalStateException if {@link Database#backupEnabled()} - * or {@link Database#consistencyCheckEnabled()} is not enabled. - */ - public void backupDatabase() { - getHelper().backupDB(); - } - -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.kt new file mode 100644 index 000000000..00ecd5945 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.kt @@ -0,0 +1,381 @@ +package com.raizlabs.android.dbflow.config + +import android.content.Context +import com.raizlabs.android.dbflow.annotation.Database +import com.raizlabs.android.dbflow.annotation.QueryModel +import com.raizlabs.android.dbflow.annotation.Table +import com.raizlabs.android.dbflow.runtime.BaseTransactionManager +import com.raizlabs.android.dbflow.runtime.ContentResolverNotifier +import com.raizlabs.android.dbflow.runtime.ModelNotifier +import com.raizlabs.android.dbflow.sql.migration.Migration +import com.raizlabs.android.dbflow.structure.BaseModelView +import com.raizlabs.android.dbflow.structure.ModelAdapter +import com.raizlabs.android.dbflow.structure.ModelViewAdapter +import com.raizlabs.android.dbflow.structure.QueryModelAdapter +import com.raizlabs.android.dbflow.structure.database.DatabaseHelperListener +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.structure.database.FlowSQLiteOpenHelper +import com.raizlabs.android.dbflow.structure.database.OpenHelper +import com.raizlabs.android.dbflow.structure.database.transaction.DefaultTransactionManager +import com.raizlabs.android.dbflow.structure.database.transaction.DefaultTransactionQueue +import com.raizlabs.android.dbflow.structure.database.transaction.ITransaction +import com.raizlabs.android.dbflow.structure.database.transaction.Transaction +import java.util.* + +/** + * Description: The main interface that all Database implementations extend from. This is for internal usage only + * as it will be generated for every [Database]. + */ +abstract class DatabaseDefinition { + + private val migrationMap = hashMapOf>() + + private val modelAdapters = hashMapOf, ModelAdapter<*>>() + + private val modelTableNames = hashMapOf>() + + private val modelViewAdapterMap = linkedMapOf, ModelViewAdapter<*>>() + + private val queryModelAdapterMap = linkedMapOf, QueryModelAdapter<*>>() + + /** + * The helper that manages database changes and initialization + */ + private var openHelper: OpenHelper? = null + + /** + * Allows for the app to listen for database changes. + */ + private var helperListener: DatabaseHelperListener? = null + + /** + * Used when resetting the DB + */ + private var isResetting = false + + lateinit var transactionManager: BaseTransactionManager + private set + + private var databaseConfig: DatabaseConfig? = null + + private var modelNotifier: ModelNotifier? = null + + /** + * @return a list of all model classes in this database. + */ + val modelClasses: List> + get() = ArrayList(modelAdapters.keys) + + /** + * @return the [BaseModelView] list for this database. + */ + val modelViews: List> + get() = ArrayList(modelViewAdapterMap.keys) + + /** + * @return The list of [ModelViewAdapter]. Internal method for + * creating model views in the DB. + */ + val modelViewAdapters: List> + get() = ArrayList(modelViewAdapterMap.values) + + /** + * @return The list of [QueryModelAdapter]. Internal method for creating query models in the DB. + */ + val modelQueryAdapters: List> + get() = ArrayList(queryModelAdapterMap.values) + + /** + * @return The map of migrations to DB version + */ + val migrations: Map> + get() = migrationMap + + val helper: OpenHelper + @Synchronized get() { + if (openHelper == null) { + val config = FlowManager.getConfig().getDatabaseConfigMap()[associatedDatabaseClassFile] + openHelper = if (config?.openHelperCreator != null) { + config.openHelperCreator.invoke(this, helperListener) + } else { + FlowSQLiteOpenHelper(this, helperListener) + } + openHelper?.performRestoreFromBackup() + } + return openHelper!! + } + + val writableDatabase: DatabaseWrapper + get() = helper.database + + /** + * @return The name of this database as defined in [Database] + */ + val databaseName: String + get() = databaseConfig?.databaseName ?: associatedDatabaseClassFile.simpleName + + /** + * @return The file name that this database points to + */ + val databaseFileName: String + get() = databaseName + databaseExtensionName + + /** + * @return the extension for the file name. + */ + val databaseExtensionName: String + get() = databaseConfig?.databaseExtensionName ?: ".db" + + /** + * @return True if the database will reside in memory. + */ + val isInMemory: Boolean + get() = databaseConfig?.isInMemory ?: false + + /** + * @return The version of the database currently. + */ + abstract val databaseVersion: Int + + /** + * @return True if the [Database.foreignKeyConstraintsEnforced] annotation is true. + */ + abstract val isForeignKeysSupported: Boolean + + /** + * @return The class that defines the [Database] annotation. + */ + abstract val associatedDatabaseClassFile: Class<*> + + /** + * @return True if the database is ok. If backups are enabled, we restore from backup and will + * override the return value if it replaces the main DB. + */ + val isDatabaseIntegrityOk: Boolean + get() = helper.isDatabaseIntegrityOk + + init { + applyDatabaseConfig(FlowManager.getConfig().getDatabaseConfigMap()[associatedDatabaseClassFile]) + } + + /** + * Applies a database configuration object to this class. + */ + internal fun applyDatabaseConfig(databaseConfig: DatabaseConfig?) { + this.databaseConfig = databaseConfig + if (databaseConfig != null) { + // initialize configuration if exists. + val tableConfigCollection = databaseConfig.tableConfigMap.values + for (tableConfig in tableConfigCollection) { + val modelAdapter = modelAdapters[tableConfig.tableClass()] ?: continue + if (tableConfig.listModelLoader() != null) { + modelAdapter.setListModelLoader(tableConfig.listModelLoader()) + } + + if (tableConfig.singleModelLoader() != null) { + modelAdapter.setSingleModelLoader(tableConfig.singleModelLoader()) + } + + if (tableConfig.modelSaver() != null) { + modelAdapter.setModelSaver(tableConfig.modelSaver()) + } + + } + helperListener = databaseConfig.helperListener + } + transactionManager = if (databaseConfig?.transactionManagerCreator == null) { + DefaultTransactionManager(this) + } else { + databaseConfig.transactionManagerCreator.invoke(this) + } + } + + protected fun addModelAdapter(modelAdapter: ModelAdapter, holder: DatabaseHolder) { + holder.putDatabaseForTable(modelAdapter.modelClass, this) + modelTableNames.put(modelAdapter.tableName, modelAdapter.modelClass) + modelAdapters.put(modelAdapter.modelClass, modelAdapter) + } + + protected fun addModelViewAdapter(modelViewAdapter: ModelViewAdapter, holder: DatabaseHolder) { + holder.putDatabaseForTable(modelViewAdapter.modelClass, this) + modelViewAdapterMap.put(modelViewAdapter.modelClass, modelViewAdapter) + } + + protected fun addQueryModelAdapter(queryModelAdapter: QueryModelAdapter, holder: DatabaseHolder) { + holder.putDatabaseForTable(queryModelAdapter.modelClass, this) + queryModelAdapterMap.put(queryModelAdapter.modelClass, queryModelAdapter) + } + + protected fun addMigration(version: Int, migration: Migration) { + var list: MutableList? = migrationMap[version] + if (list == null) { + list = arrayListOf() + migrationMap.put(version, list) + } + list.add(migration) + } + + /** + * Internal method used to create the database schema. + * + * @return List of Model Adapters + */ + fun getModelAdapters(): List> = modelAdapters.values.toList() + + /** + * Returns the associated [ModelAdapter] within this database for + * the specified table. If the Model is missing the [Table] annotation, + * this will return null. + * + * @param table The model that exists in this database. + * @return The ModelAdapter for the table. + */ + fun getModelAdapterForTable(table: Class): ModelAdapter? { + @Suppress("UNCHECKED_CAST") + return modelAdapters[table] as ModelAdapter? + } + + /** + * @param tableName The name of the table in this db. + * @return The associated [ModelAdapter] within this database for the specified table name. + * If the Model is missing the [Table] annotation, this will return null. + */ + fun getModelClassForName(tableName: String): Class<*>? { + return modelTableNames[tableName] + } + + /** + * @param table the VIEW class to retrieve the ModelViewAdapter from. + * @return the associated [ModelViewAdapter] for the specified table. + */ + @Suppress("UNCHECKED_CAST") + fun getModelViewAdapterForTable(table: Class): ModelViewAdapter? { + return modelViewAdapterMap[table] as ModelViewAdapter? + } + + /** + * @param queryModel The [QueryModel] class + * @return The adapter that corresponds to the specified class. + */ + @Suppress("UNCHECKED_CAST") + fun getQueryModelAdapterForQueryClass(queryModel: Class): QueryModelAdapter? { + return queryModelAdapterMap[queryModel] as QueryModelAdapter? + } + + fun getModelNotifier(): ModelNotifier { + if (modelNotifier == null) { + val config = FlowManager.getConfig().getDatabaseConfigMap()[associatedDatabaseClassFile] + modelNotifier = if (config?.modelNotifier == null) { + ContentResolverNotifier() + } else { + config.modelNotifier + } + } + return modelNotifier!! + } + + fun beginTransactionAsync(transaction: ITransaction): Transaction.Builder { + return Transaction.Builder(transaction, this) + } + + fun executeTransaction(transaction: ITransaction) { + val database = writableDatabase + try { + database.beginTransaction() + transaction.execute(database) + database.setTransactionSuccessful() + } finally { + database.endTransaction() + } + } + + /** + * @return True if the [Database.consistencyCheckEnabled] annotation is true. + */ + abstract fun areConsistencyChecksEnabled(): Boolean + + /** + * @return True if the [Database.backupEnabled] annotation is true. + */ + abstract fun backupEnabled(): Boolean + + + @Deprecated("use {@link #reset()}") + fun reset(context: Context) { + reset(databaseConfig) + } + + /** + * Performs a full deletion of this database. Reopens the [FlowSQLiteOpenHelper] as well. + * + * Reapplies the [DatabaseConfig] if we have one. + * @param databaseConfig sets a new [DatabaseConfig] on this class. + */ + @JvmOverloads + fun reset(databaseConfig: DatabaseConfig? = this.databaseConfig) { + if (!isResetting) { + destroy() + // reapply configuration before opening it. + applyDatabaseConfig(databaseConfig) + helper.database + } + } + + /** + * Reopens the DB with the new [DatabaseConfig] specified. + * Reapplies the [DatabaseConfig] if we have one. + * + * @param databaseConfig sets a new [DatabaseConfig] on this class. + */ + @JvmOverloads + fun reopen(databaseConfig: DatabaseConfig? = this.databaseConfig) { + if (!isResetting) { + close() + openHelper = null + applyDatabaseConfig(databaseConfig) + helper.database + isResetting = false + } + } + + /** + * Deletes the underlying database and destroys it. + */ + fun destroy() { + if (!isResetting) { + isResetting = true + close() + FlowManager.context.deleteDatabase(databaseFileName) + openHelper = null + isResetting = false + } + } + + /** + * Closes the DB and stops the [BaseTransactionManager] + */ + fun close() { + transactionManager.stopQueue() + modelAdapters.values.forEach { + with(it) { + closeInsertStatement() + closeCompiledStatement() + closeDeleteStatement() + closeUpdateStatement() + } + } + helper.closeDB() + } + + /** + * Saves the database as a backup on the [DefaultTransactionQueue]. This will + * create a THIRD database to use as a backup to the backup in case somehow the overwrite fails. + * + * @throws java.lang.IllegalStateException if [Database.backupEnabled] + * or [Database.consistencyCheckEnabled] is not enabled. + */ + fun backupDatabase() { + helper.backupDB() + } + +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseHolder.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseHolder.java deleted file mode 100644 index 0900d38b6..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseHolder.java +++ /dev/null @@ -1,72 +0,0 @@ -package com.raizlabs.android.dbflow.config; - -import com.raizlabs.android.dbflow.converter.TypeConverter; - -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; -import java.util.Map; - -/** - * Description: The base interface for interacting with all of the database and top-level data that's shared - * between them. - */ -public abstract class DatabaseHolder { - protected final Map, DatabaseDefinition> databaseDefinitionMap = new HashMap<>(); - protected final Map databaseNameMap = new HashMap<>(); - protected final Map, DatabaseDefinition> databaseClassLookupMap = new HashMap<>(); - protected final Map, TypeConverter> typeConverters = new HashMap<>(); - - /** - * @param clazz The model value class to get a {@link com.raizlabs.android.dbflow.converter.TypeConverter} - * @return Type converter for the specified model value. - */ - public TypeConverter getTypeConverterForClass(Class clazz) { - return typeConverters.get(clazz); - } - - /** - * @param table The model class - * @return The database that the table belongs in - */ - public DatabaseDefinition getDatabaseForTable(Class table) { - return databaseDefinitionMap.get(table); - } - - public DatabaseDefinition getDatabase(Class databaseClass) { - return databaseClassLookupMap.get(databaseClass); - } - - /** - * @param databaseName The name of the database to retrieve - * @return The database that has the specified name - */ - public DatabaseDefinition getDatabase(String databaseName) { - return databaseNameMap.get(databaseName); - } - - /** - * Helper method used to store a database for the specified table. - * - * @param table The model table - * @param databaseDefinition The database definition - */ - public void putDatabaseForTable(Class table, DatabaseDefinition databaseDefinition) { - databaseDefinitionMap.put(table, databaseDefinition); - databaseNameMap.put(databaseDefinition.getDatabaseName(), databaseDefinition); - databaseClassLookupMap.put(databaseDefinition.getAssociatedDatabaseClassFile(), databaseDefinition); - } - - public void reset() { - databaseDefinitionMap.clear(); - databaseNameMap.clear(); - databaseClassLookupMap.clear(); - typeConverters.clear(); - } - - public List getDatabaseDefinitions() { - return new ArrayList<>(databaseNameMap.values()); - } - - -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseHolder.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseHolder.kt new file mode 100644 index 000000000..32da5e366 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseHolder.kt @@ -0,0 +1,66 @@ +package com.raizlabs.android.dbflow.config + +import com.raizlabs.android.dbflow.converter.TypeConverter +import java.util.* + +/** + * Description: The base interface for interacting with all of the database and top-level data that's shared + * between them. + */ +abstract class DatabaseHolder { + + val databaseDefinitionMap: MutableMap, DatabaseDefinition> = HashMap() + val databaseNameMap: MutableMap = HashMap() + val databaseClassLookupMap: MutableMap, DatabaseDefinition> = HashMap() + val typeConverters: MutableMap, TypeConverter<*, *>> = HashMap() + + val databaseDefinitions: List + get() = ArrayList(databaseNameMap.values) + + /** + * @param clazz The model value class to get a [com.raizlabs.android.dbflow.converter.TypeConverter] + * @return Type converter for the specified model value. + */ + fun getTypeConverterForClass(clazz: Class<*>): TypeConverter<*, *>? { + return typeConverters[clazz] + } + + /** + * @param table The model class + * @return The database that the table belongs in + */ + fun getDatabaseForTable(table: Class<*>): DatabaseDefinition? { + return databaseDefinitionMap[table] + } + + fun getDatabase(databaseClass: Class<*>): DatabaseDefinition? { + return databaseClassLookupMap[databaseClass] + } + + /** + * @param databaseName The name of the database to retrieve + * @return The database that has the specified name + */ + fun getDatabase(databaseName: String): DatabaseDefinition? { + return databaseNameMap[databaseName] + } + + /** + * Helper method used to store a database for the specified table. + * + * @param table The model table + * @param databaseDefinition The database definition + */ + fun putDatabaseForTable(table: Class<*>, databaseDefinition: DatabaseDefinition) { + databaseDefinitionMap.put(table, databaseDefinition) + databaseNameMap.put(databaseDefinition.databaseName, databaseDefinition) + databaseClassLookupMap.put(databaseDefinition.associatedDatabaseClassFile, databaseDefinition) + } + + fun reset() { + databaseDefinitionMap.clear() + databaseNameMap.clear() + databaseClassLookupMap.clear() + typeConverters.clear() + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowConfig.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowConfig.java deleted file mode 100644 index 8a6136917..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowConfig.java +++ /dev/null @@ -1,96 +0,0 @@ -package com.raizlabs.android.dbflow.config; - -import android.content.Context; -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import java.util.Collections; -import java.util.HashMap; -import java.util.HashSet; -import java.util.Map; -import java.util.Set; - -/** - * Description: The main configuration instance for DBFlow. This - */ -public final class FlowConfig { - - public static FlowConfig.Builder builder(Context context) { - return new FlowConfig.Builder(context); - } - - private final Set> databaseHolders; - private final Map, DatabaseConfig> databaseConfigMap; - private final Context context; - private final boolean openDatabasesOnInit; - - FlowConfig(Builder builder) { - databaseHolders = Collections.unmodifiableSet(builder.databaseHolders); - databaseConfigMap = builder.databaseConfigMap; - context = builder.context; - openDatabasesOnInit = builder.openDatabasesOnInit; - } - - @NonNull - public Set> databaseHolders() { - return databaseHolders; - } - - @NonNull - public Map, DatabaseConfig> databaseConfigMap() { - return databaseConfigMap; - } - - @Nullable - public DatabaseConfig getConfigForDatabase(@NonNull Class databaseClass) { - return databaseConfigMap().get(databaseClass); - } - - @NonNull - public Context getContext() { - return context; - } - - public boolean openDatabasesOnInit() { - return openDatabasesOnInit; - } - - public static class Builder { - - final Context context; - Set> databaseHolders = new HashSet<>(); - final Map, DatabaseConfig> databaseConfigMap = new HashMap<>(); - boolean openDatabasesOnInit; - - public Builder(Context context) { - this.context = context.getApplicationContext(); - } - - @NonNull - public Builder addDatabaseHolder(@NonNull Class databaseHolderClass) { - databaseHolders.add(databaseHolderClass); - return this; - } - - @NonNull - public Builder addDatabaseConfig(@NonNull DatabaseConfig databaseConfig) { - databaseConfigMap.put(databaseConfig.databaseClass(), databaseConfig); - return this; - } - - /** - * @param openDatabasesOnInit true if we want all databases open. - * @return True to open all associated databases in DBFlow on calling of {@link FlowManager#init(FlowConfig)} - */ - @NonNull - public Builder openDatabasesOnInit(boolean openDatabasesOnInit) { - this.openDatabasesOnInit = openDatabasesOnInit; - return this; - } - - @NonNull - public FlowConfig build() { - return new FlowConfig(this); - } - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowConfig.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowConfig.kt new file mode 100644 index 000000000..03328c0b0 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowConfig.kt @@ -0,0 +1,57 @@ +package com.raizlabs.android.dbflow.config + +import android.content.Context +import java.util.* + +/** + * Description: The main configuration instance for DBFlow. This + */ +class FlowConfig(val context: Context, + val databaseHolders: Set> = setOf(), + val databaseConfigMap: Map, DatabaseConfig> = mapOf(), + val openDatabasesOnInit: Boolean = false) { + + internal constructor(builder: Builder) : this( + databaseHolders = Collections.unmodifiableSet(builder.databaseHolders), + databaseConfigMap = builder.databaseConfigMap, + context = builder.context, + openDatabasesOnInit = builder.openDatabasesOnInit + ) + + fun getConfigForDatabase(databaseClass: Class<*>): DatabaseConfig? { + return databaseConfigMap[databaseClass] + } + + class Builder(context: Context) { + + internal val context: Context = context.applicationContext + internal var databaseHolders: MutableSet> = HashSet() + internal val databaseConfigMap: MutableMap, DatabaseConfig> = HashMap() + internal var openDatabasesOnInit: Boolean = false + + fun addDatabaseHolder(databaseHolderClass: Class) = apply { + databaseHolders.add(databaseHolderClass) + } + + fun addDatabaseConfig(databaseConfig: DatabaseConfig) = apply { + databaseConfigMap.put(databaseConfig.databaseClass, databaseConfig) + } + + /** + * @param openDatabasesOnInit true if we want all databases open. + * @return True to open all associated databases in DBFlow on calling of [FlowManager.init] + */ + fun openDatabasesOnInit(openDatabasesOnInit: Boolean) = apply { + this.openDatabasesOnInit = openDatabasesOnInit + } + + fun build() = FlowConfig(this) + } + + companion object { + + fun builder(context: Context): FlowConfig.Builder { + return FlowConfig.Builder(context) + } + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowLog.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowLog.java deleted file mode 100644 index f59c7f6d9..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowLog.java +++ /dev/null @@ -1,139 +0,0 @@ -package com.raizlabs.android.dbflow.config; - -import android.os.Build; -import android.util.Log; - -/** - * Description: Mirrors {@link Log} with its own {@link Level} flag. - */ -public class FlowLog { - - public static final String TAG = FlowLog.class.getSimpleName(); - private static Level level = Level.E; - - /** - * Sets the minimum level that we wish to print out log statements with. - * The default is {@link Level#E}. - * - * @param level - */ - public static void setMinimumLoggingLevel(Level level) { - FlowLog.level = level; - } - - /** - * Logs information to the {@link Log} class. It wraps around the standard implementation. - * It uses the {@link #TAG} for messages and sends a null throwable. - * - * @param level The log level to use - * @param message The message to print out - */ - public static void log(Level level, String message) { - log(level, message, null); - } - - /** - * Logs information to the {@link Log} class. It wraps around the standard implementation. - * It uses the {@link #TAG} for messages - * - * @param level The log level to use - * @param message The message to print out - * @param throwable The optional stack trace to print - */ - public static void log(Level level, String message, Throwable throwable) { - log(level, TAG, message, throwable); - } - - /** - * Logs information to the {@link Log} class. It wraps around the standard implementation. - * - * @param level The log level to use - * @param tag The tag of the log - * @param message The message to print out - * @param throwable The optional stack trace to print - */ - public static void log(Level level, String tag, String message, Throwable throwable) { - if (isEnabled(level)) { - level.call(tag, message, throwable); - } - } - - /** - * Returns true if the logging level is lower than the specified {@link Level} - * - * @return - */ - public static boolean isEnabled(Level level) { - return level.ordinal() >= FlowLog.level.ordinal(); - } - - /** - * Logs a {@link java.lang.Throwable} as an error. - * - * @param throwable The stack trace to print - */ - public static void logError(Throwable throwable) { - log(Level.E, throwable); - } - - /** - * Logs information to the {@link Log} class. It wraps around the standard implementation. - * It uses the {@link #TAG} for messages and sends an empty message - * - * @param level The log level to use - * @param throwable The stack trace to print - */ - public static void log(Level level, Throwable throwable) { - log(level, TAG, "", throwable); - } - - /** - * Defines a log level that will execute - */ - public enum Level { - V { - @Override - void call(String tag, String message, Throwable throwable) { - Log.v(tag, message, throwable); - } - }, - D { - @Override - void call(String tag, String message, Throwable throwable) { - Log.d(tag, message, throwable); - } - }, - I { - @Override - void call(String tag, String message, Throwable throwable) { - Log.i(tag, message, throwable); - } - }, - W { - @Override - void call(String tag, String message, Throwable throwable) { - Log.w(tag, message, throwable); - } - }, - E { - @Override - void call(String tag, String message, Throwable throwable) { - Log.e(tag, message, throwable); - } - }, - WTF { - @Override - void call(String tag, String message, Throwable throwable) { - if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.FROYO) { - Log.wtf(tag, message, throwable); - } else { - // If on older platform, we will just exaggerate the log message in the error level - Log.e(tag, "!!!!!!!!*******" + message + "********!!!!!!", throwable); - } - } - }; - - abstract void call(String tag, String message, Throwable throwable); - } - -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowLog.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowLog.kt new file mode 100644 index 000000000..8676299f5 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowLog.kt @@ -0,0 +1,110 @@ +package com.raizlabs.android.dbflow.config + +import android.os.Build +import android.util.Log +import com.raizlabs.android.dbflow.config.FlowLog.Level + +/** + * Description: Mirrors [Log] with its own [Level] flag. + */ +object FlowLog { + + val TAG = FlowLog::class.java.simpleName + private var level = Level.E + + /** + * Sets the minimum level that we wish to print out log statements with. + * The default is [Level.E]. + * + * @param level + */ + @JvmStatic + fun setMinimumLoggingLevel(level: Level) { + FlowLog.level = level + } + + /** + * Logs information to the [Log] class. It wraps around the standard implementation. + * + * @param level The log level to use + * @param tag The tag of the log + * @param message The message to print out + * @param throwable The optional stack trace to print + */ + @JvmOverloads + @JvmStatic + fun log(level: Level, tag: String = TAG, message: String = "", throwable: Throwable? = null) { + if (isEnabled(level)) { + level.call(tag, message, throwable) + } + } + + /** + * Returns true if the logging level is lower than the specified [Level] + * + * @return + */ + @JvmStatic + fun isEnabled(level: Level) = level.ordinal >= FlowLog.level.ordinal + + /** + * Logs a [java.lang.Throwable] as an error. + * + * @param throwable The stack trace to print + */ + @JvmStatic + fun logError(throwable: Throwable) { + log(Level.E, throwable) + } + + /** + * Defines a log level that will execute + */ + enum class Level { + V { + override fun call(tag: String, message: String, throwable: Throwable?) { + Log.v(tag, message, throwable) + } + }, + D { + override fun call(tag: String, message: String, throwable: Throwable?) { + Log.d(tag, message, throwable) + } + }, + I { + override fun call(tag: String, message: String, throwable: Throwable?) { + Log.i(tag, message, throwable) + } + }, + W { + override fun call(tag: String, message: String, throwable: Throwable?) { + Log.w(tag, message, throwable) + } + }, + E { + override fun call(tag: String, message: String, throwable: Throwable?) { + Log.e(tag, message, throwable) + } + }, + WTF { + override fun call(tag: String, message: String, throwable: Throwable?) { + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.FROYO) { + Log.wtf(tag, message, throwable) + } else { + // If on older platform, we will just exaggerate the log message in the error level + Log.e(tag, "!!!!!!!!*******$message********!!!!!!", throwable) + } + } + }; + + internal abstract fun call(tag: String, message: String, throwable: Throwable?) + } + +} +/** + * Logs information to the [Log] class. It wraps around the standard implementation. + * It uses the [.TAG] for messages and sends a null throwable. + * + * @param level The log level to use + * @param message The message to print out + */ diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.java deleted file mode 100644 index 836d0d913..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.java +++ /dev/null @@ -1,533 +0,0 @@ -package com.raizlabs.android.dbflow.config; - -import android.content.Context; -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.annotation.Table; -import com.raizlabs.android.dbflow.converter.TypeConverter; -import com.raizlabs.android.dbflow.runtime.ModelNotifier; -import com.raizlabs.android.dbflow.runtime.TableNotifierRegister; -import com.raizlabs.android.dbflow.sql.QueryBuilder; -import com.raizlabs.android.dbflow.sql.migration.Migration; -import com.raizlabs.android.dbflow.structure.BaseModel; -import com.raizlabs.android.dbflow.structure.BaseModelView; -import com.raizlabs.android.dbflow.structure.BaseQueryModel; -import com.raizlabs.android.dbflow.structure.InstanceAdapter; -import com.raizlabs.android.dbflow.structure.InvalidDBConfiguration; -import com.raizlabs.android.dbflow.structure.Model; -import com.raizlabs.android.dbflow.structure.ModelAdapter; -import com.raizlabs.android.dbflow.structure.ModelViewAdapter; -import com.raizlabs.android.dbflow.structure.QueryModelAdapter; -import com.raizlabs.android.dbflow.structure.RetrievalAdapter; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; - -import java.util.HashSet; -import java.util.List; -import java.util.Map; -import java.util.Set; - -/** - * Description: The main entry point into the generated database code. It uses reflection to look up - * and construct the generated database holder class used in defining the structure for all databases - * used in this application. - */ -public class FlowManager { - - private static class GlobalDatabaseHolder extends DatabaseHolder { - - private boolean initialized = false; - - public void add(DatabaseHolder holder) { - databaseDefinitionMap.putAll(holder.databaseDefinitionMap); - databaseNameMap.putAll(holder.databaseNameMap); - typeConverters.putAll(holder.typeConverters); - databaseClassLookupMap.putAll(holder.databaseClassLookupMap); - initialized = true; - } - - public boolean isInitialized() { - return initialized; - } - } - - static FlowConfig config; - - private static GlobalDatabaseHolder globalDatabaseHolder = new GlobalDatabaseHolder(); - - private static HashSet> loadedModules = new HashSet<>(); - - private static final String DEFAULT_DATABASE_HOLDER_NAME = "GeneratedDatabaseHolder"; - - private static final String DEFAULT_DATABASE_HOLDER_PACKAGE_NAME = - FlowManager.class.getPackage().getName(); - - private static final String DEFAULT_DATABASE_HOLDER_CLASSNAME = - DEFAULT_DATABASE_HOLDER_PACKAGE_NAME + "." + DEFAULT_DATABASE_HOLDER_NAME; - - /** - * Returns the table name for the specific model class - * - * @param table The class that implements {@link Model} - * @return The table name, which can be different than the {@link Model} class name - */ - @SuppressWarnings("unchecked") - @NonNull - public static String getTableName(Class table) { - ModelAdapter modelAdapter = getModelAdapterOrNull(table); - String tableName = null; - if (modelAdapter == null) { - ModelViewAdapter modelViewAdapter = getModelViewAdapterOrNull(table); - if (modelViewAdapter != null) { - tableName = modelViewAdapter.getViewName(); - } else { - throwCannotFindAdapter("ModelAdapter/ModelViewAdapter", table); - } - } else { - tableName = modelAdapter.getTableName(); - } - return tableName; - } - - /** - * @param databaseName The name of the database. Will throw an exception if the database doesn't exist. - * @param tableName The name of the table in the DB. - * @return The associated table class for the specified name. - */ - public static Class getTableClassForName(String databaseName, String tableName) { - DatabaseDefinition databaseDefinition = getDatabase(databaseName); - Class modelClass = databaseDefinition.getModelClassForName(tableName); - if (modelClass == null) { - modelClass = databaseDefinition.getModelClassForName(QueryBuilder.quote(tableName)); - if (modelClass == null) { - throw new IllegalArgumentException(String.format("The specified table %1s was not found. " + - "Did you forget to add the @Table annotation and point it to %1s?", - tableName, databaseName)); - } - } - return modelClass; - } - - /** - * @param databaseClass The class of the database. Will throw an exception if the database doesn't exist. - * @param tableName The name of the table in the DB. - * @return The associated table class for the specified name. - */ - public static Class getTableClassForName(Class databaseClass, String tableName) { - DatabaseDefinition databaseDefinition = getDatabase(databaseClass); - Class modelClass = databaseDefinition.getModelClassForName(tableName); - if (modelClass == null) { - modelClass = databaseDefinition.getModelClassForName(QueryBuilder.quote(tableName)); - if (modelClass == null) { - throw new IllegalArgumentException(String.format("The specified table %1s was not found. " + - "Did you forget to add the @Table annotation and point it to %1s?", - tableName, databaseClass)); - } - } - return modelClass; - } - - /** - * @param table The table to lookup the database for. - * @return the corresponding {@link DatabaseDefinition} for the specified model - */ - @NonNull - public static DatabaseDefinition getDatabaseForTable(Class table) { - checkDatabaseHolder(); - DatabaseDefinition databaseDefinition = globalDatabaseHolder.getDatabaseForTable(table); - if (databaseDefinition == null) { - throw new InvalidDBConfiguration("Model object: " + table.getName() + - " is not registered with a Database. " + "Did you forget an annotation?"); - } - return databaseDefinition; - } - - @NonNull - public static DatabaseDefinition getDatabase(Class databaseClass) { - checkDatabaseHolder(); - DatabaseDefinition databaseDefinition = globalDatabaseHolder.getDatabase(databaseClass); - if (databaseDefinition == null) { - throw new InvalidDBConfiguration("Database: " + databaseClass.getName() + " is not a registered Database. " + - "Did you forget the @Database annotation?"); - } - return databaseDefinition; - } - - @NonNull - public static String getDatabaseName(Class database) { - return getDatabase(database).getDatabaseName(); - } - - @NonNull - public static DatabaseWrapper getWritableDatabaseForTable(Class table) { - return getDatabaseForTable(table).getWritableDatabase(); - } - - /** - * @param databaseName The name of the database. Will throw an exception if the database doesn't exist. - * @return the {@link DatabaseDefinition} for the specified database - */ - @NonNull - public static DatabaseDefinition getDatabase(String databaseName) { - checkDatabaseHolder(); - DatabaseDefinition database = globalDatabaseHolder.getDatabase(databaseName); - - if (database != null) { - return database; - } - - throw new InvalidDBConfiguration("The specified database" + databaseName + " was not found. " + - "Did you forget the @Database annotation?"); - } - - @NonNull - public static DatabaseWrapper getWritableDatabase(String databaseName) { - return getDatabase(databaseName).getWritableDatabase(); - } - - @NonNull - public static DatabaseWrapper getWritableDatabase(Class databaseClass) { - return getDatabase(databaseClass).getWritableDatabase(); - } - - /** - * Loading the module Database holder via reflection. - *

- * It is assumed FlowManager.init() is called by the application that uses the - * module database. This method should only be called if you need to load databases - * that are part of a module. Building once will give you the ability to add the class. - */ - public static void initModule(Class generatedClassName) { - loadDatabaseHolder(generatedClassName); - } - - public static FlowConfig getConfig() { - if (config == null) { - throw new IllegalStateException("Configuration is not initialized. " + - "Please call init(FlowConfig) in your application class."); - } - return config; - } - - /** - * @return The database holder, creating if necessary using reflection. - */ - protected static void loadDatabaseHolder(Class holderClass) { - if (loadedModules.contains(holderClass)) { - return; - } - - try { - // Load the database holder, and add it to the global collection. - DatabaseHolder dbHolder = holderClass.newInstance(); - - if (dbHolder != null) { - globalDatabaseHolder.add(dbHolder); - - // Cache the holder for future reference. - loadedModules.add(holderClass); - } - } catch (Throwable e) { - e.printStackTrace(); - throw new ModuleNotFoundException("Cannot load " + holderClass, e); - } - } - - /** - * Resets all databases and associated files. - */ - public static void reset() { - Set, DatabaseDefinition>> entrySet = globalDatabaseHolder.databaseClassLookupMap.entrySet(); - for (Map.Entry, DatabaseDefinition> value : entrySet) { - value.getValue().reset(); - } - globalDatabaseHolder.reset(); - loadedModules.clear(); - } - - /** - * Close all DB files and resets {@link FlowConfig} and the {@link GlobalDatabaseHolder}. Brings - * DBFlow back to initial application state. - */ - public static synchronized void close() { - Set, DatabaseDefinition>> entrySet = - globalDatabaseHolder.databaseClassLookupMap.entrySet(); - for (Map.Entry, DatabaseDefinition> value : entrySet) { - value.getValue().close(); - } - - config = null; - - globalDatabaseHolder = new GlobalDatabaseHolder(); - loadedModules.clear(); - } - - /** - * Will throw an exception if this class is not initialized yet in {@link #init(FlowConfig)} - * - * @return The shared context. - */ - @NonNull - public static Context getContext() { - if (config == null) { - throw new IllegalStateException("You must provide a valid FlowConfig instance. " + - "We recommend calling init() in your application class."); - } - return config.getContext(); - } - - /** - * Helper method to simplify the {@link #init(FlowConfig)}. Use {@link #init(FlowConfig)} to provide - * more customization. - * - * @param context - should be application context, but not necessary as we retrieve it anyways. - */ - public static void init(@NonNull Context context) { - init(new FlowConfig.Builder(context).build()); - } - - /** - * Initializes DBFlow, loading the main application Database holder via reflection one time only. - * This will trigger all creations, updates, and instantiation for each database defined. - * - * @param flowConfig The configuration instance that will help shape how DBFlow gets constructed. - */ - public static void init(@NonNull FlowConfig flowConfig) { - FlowManager.config = flowConfig; - - try { - //noinspection unchecked - Class defaultHolderClass = (Class) Class.forName(DEFAULT_DATABASE_HOLDER_CLASSNAME); - loadDatabaseHolder(defaultHolderClass); - } catch (ModuleNotFoundException e) { - // Ignore this exception since it means the application does not have its - // own database. The initialization happens because the application is using - // a module that has a database. - FlowLog.log(FlowLog.Level.W, e.getMessage()); - } catch (ClassNotFoundException e) { - // warning if a library uses DBFlow with module support but the app you're using doesn't support it. - FlowLog.log(FlowLog.Level.W, "Could not find the default GeneratedDatabaseHolder"); - } - - if (!flowConfig.databaseHolders().isEmpty()) { - for (Class holder : flowConfig.databaseHolders()) { - loadDatabaseHolder(holder); - } - } - - if (flowConfig.openDatabasesOnInit()) { - List databaseDefinitions = globalDatabaseHolder.getDatabaseDefinitions(); - for (DatabaseDefinition databaseDefinition : databaseDefinitions) { - // triggers open, create, migrations. - databaseDefinition.getWritableDatabase(); - } - } - } - - /** - * @param objectClass A class with an associated type converter. May return null if not found. - * @return The specific {@link TypeConverter} for the specified class. It defines - * how the custom datatype is handled going into and out of the DB. - */ - public static TypeConverter getTypeConverterForClass(Class objectClass) { - checkDatabaseHolder(); - return globalDatabaseHolder.getTypeConverterForClass(objectClass); - } - - // region Getters - - /** - * Release reference to context and {@link FlowConfig} - */ - public static synchronized void destroy() { - Set, DatabaseDefinition>> entrySet = - globalDatabaseHolder.databaseClassLookupMap.entrySet(); - for (Map.Entry, DatabaseDefinition> value : entrySet) { - value.getValue().destroy(); - } - - config = null; - - // Reset the global database holder. - globalDatabaseHolder = new GlobalDatabaseHolder(); - loadedModules.clear(); - } - - /** - * @param modelClass The class that implements {@link Model} to find an adapter for. - * @return The adapter associated with the class. If its not a {@link ModelAdapter}, - * it checks both the {@link ModelViewAdapter} and {@link QueryModelAdapter}. - */ - @SuppressWarnings("unchecked") - @NonNull - public static InstanceAdapter getInstanceAdapter(Class modelClass) { - InstanceAdapter internalAdapter = getModelAdapterOrNull(modelClass); - if (internalAdapter == null) { - internalAdapter = getModelViewAdapterOrNull(modelClass); - if (internalAdapter == null) { - internalAdapter = getQueryModelAdapterOrNull(modelClass); - } - } - - if (internalAdapter == null) { - throwCannotFindAdapter("InstanceAdapter", modelClass); - } - - return internalAdapter; - } - - /** - * @param modelClass The class that implements {@link Model} to find an adapter for. - * @return The adapter associated with the class. If its not a {@link ModelAdapter}, - * it checks both the {@link ModelViewAdapter} and {@link QueryModelAdapter}. - */ - @SuppressWarnings("unchecked") - @NonNull - public static RetrievalAdapter getRetrievalAdapter(Class modelClass) { - RetrievalAdapter retrievalAdapter = getModelAdapterOrNull(modelClass); - if (retrievalAdapter == null) { - retrievalAdapter = getModelViewAdapterOrNull(modelClass); - if (retrievalAdapter == null) { - retrievalAdapter = getQueryModelAdapterOrNull(modelClass); - } - } - if (retrievalAdapter == null) { - throwCannotFindAdapter("RetrievalAdapter", modelClass); - } - - return retrievalAdapter; - } - - - /** - * @param modelClass The class of the table - * @param The class that implements {@link Model} - * @return The associated model adapter (DAO) that is generated from a {@link Table} class. Handles - * interactions with the database. This method is meant for internal usage only. - * We strongly prefer you use the built-in methods associated with {@link Model} and {@link BaseModel}. - */ - @SuppressWarnings("unchecked") - @NonNull - public static ModelAdapter getModelAdapter(Class modelClass) { - final ModelAdapter modelAdapter = getModelAdapterOrNull(modelClass); - if (modelAdapter == null) { - throwCannotFindAdapter("ModelAdapter", modelClass); - } - return modelAdapter; - } - - /** - * Returns the model view adapter for a SQLite VIEW. These are only created with the {@link com.raizlabs.android.dbflow.annotation.ModelView} annotation. - * - * @param modelViewClass The class of the VIEW - * @param The class that extends {@link BaseModelView} - * @return The model view adapter for the specified model view. - */ - @SuppressWarnings("unchecked") - @NonNull - public static ModelViewAdapter getModelViewAdapter( - Class modelViewClass) { - final ModelViewAdapter modelViewAdapter = getModelViewAdapterOrNull(modelViewClass); - if (modelViewAdapter == null) { - throwCannotFindAdapter("ModelViewAdapter", modelViewClass); - } - return modelViewAdapter; - } - - /** - * Returns the query model adapter for an undefined query. These are only created with the {@link TQueryModel} annotation. - * - * @param queryModelClass The class of the query - * @param The class that extends {@link BaseQueryModel} - * @return The query model adapter for the specified model query. - */ - @SuppressWarnings("unchecked") - @NonNull - public static QueryModelAdapter getQueryModelAdapter( - Class queryModelClass) { - final QueryModelAdapter queryModelAdapter = getQueryModelAdapterOrNull(queryModelClass); - if (queryModelAdapter == null) { - throwCannotFindAdapter("QueryModelAdapter", queryModelClass); - } - return queryModelAdapter; - } - - @NonNull - public static ModelNotifier getModelNotifierForTable(Class table) { - return getDatabaseForTable(table).getModelNotifier(); - } - - @NonNull - public static TableNotifierRegister newRegisterForTable(Class table) { - return getModelNotifierForTable(table).newRegister(); - } - - @Nullable - private static ModelAdapter getModelAdapterOrNull(Class modelClass) { - return FlowManager.getDatabaseForTable(modelClass).getModelAdapterForTable(modelClass); - } - - @Nullable - private static ModelViewAdapter getModelViewAdapterOrNull(Class modelClass) { - return FlowManager.getDatabaseForTable(modelClass).getModelViewAdapterForTable(modelClass); - } - - @Nullable - private static QueryModelAdapter getQueryModelAdapterOrNull(Class modelClass) { - return FlowManager.getDatabaseForTable(modelClass).getQueryModelAdapterForQueryClass(modelClass); - } - - /** - * @param databaseName The name of the database. Will throw an exception if the database doesn't exist. - * @return The map of migrations for the specified database. - */ - static Map> getMigrations(String databaseName) { - return getDatabase(databaseName).getMigrations(); - } - - /** - * Checks a standard database helper for integrity using quick_check(1). - * - * @param databaseName The name of the database to check. Will thrown an exception if it does not exist. - * @return true if it's integrity is OK. - */ - public static boolean isDatabaseIntegrityOk(String databaseName) { - return getDatabase(databaseName).getHelper().isDatabaseIntegrityOk(); - } - - private static void throwCannotFindAdapter(String type, Class clazz) { - throw new IllegalArgumentException("Cannot find " + type + " for " + clazz + ". Ensure " + - "the class is annotated with proper annotation."); - } - - private static void checkDatabaseHolder() { - if (!globalDatabaseHolder.isInitialized()) { - throw new IllegalStateException("The global database holder is not initialized. Ensure you call " + - "FlowManager.init() before accessing the database."); - } - } - - // endregion - - /** - * Exception thrown when a database holder cannot load the database holder - * for a module. - */ - public static class ModuleNotFoundException extends RuntimeException { - public ModuleNotFoundException() { - } - - public ModuleNotFoundException(String detailMessage) { - super(detailMessage); - } - - public ModuleNotFoundException(String detailMessage, Throwable throwable) { - super(detailMessage, throwable); - } - - public ModuleNotFoundException(Throwable throwable) { - super(throwable); - } - } - -} \ No newline at end of file diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt new file mode 100644 index 000000000..6b022ba82 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt @@ -0,0 +1,429 @@ +package com.raizlabs.android.dbflow.config + +import android.content.Context +import com.raizlabs.android.dbflow.annotation.Table +import com.raizlabs.android.dbflow.converter.TypeConverter +import com.raizlabs.android.dbflow.runtime.ModelNotifier +import com.raizlabs.android.dbflow.runtime.TableNotifierRegister +import com.raizlabs.android.dbflow.sql.QueryBuilder +import com.raizlabs.android.dbflow.sql.migration.Migration +import com.raizlabs.android.dbflow.structure.BaseModel +import com.raizlabs.android.dbflow.structure.BaseModelView +import com.raizlabs.android.dbflow.structure.BaseQueryModel +import com.raizlabs.android.dbflow.structure.InstanceAdapter +import com.raizlabs.android.dbflow.structure.InvalidDBConfiguration +import com.raizlabs.android.dbflow.structure.Model +import com.raizlabs.android.dbflow.structure.ModelAdapter +import com.raizlabs.android.dbflow.structure.ModelViewAdapter +import com.raizlabs.android.dbflow.structure.QueryModelAdapter +import com.raizlabs.android.dbflow.structure.RetrievalAdapter +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import java.util.* + +/** + * Description: The main entry point into the generated database code. It uses reflection to look up + * and construct the generated database holder class used in defining the structure for all databases + * used in this application. + */ +object FlowManager { + + internal var config: FlowConfig? = null + + private var globalDatabaseHolder = GlobalDatabaseHolder() + + private val loadedModules = HashSet>() + + private val DEFAULT_DATABASE_HOLDER_NAME = "GeneratedDatabaseHolder" + + private val DEFAULT_DATABASE_HOLDER_PACKAGE_NAME = FlowManager::class.java.`package`.name + + private val DEFAULT_DATABASE_HOLDER_CLASSNAME = + DEFAULT_DATABASE_HOLDER_PACKAGE_NAME + "." + DEFAULT_DATABASE_HOLDER_NAME + + /** + * Will throw an exception if this class is not initialized yet in [.init] + * + * @return The shared context. + */ + @JvmStatic + val context: Context + get() = config?.context ?: + throw IllegalStateException("You must provide a valid FlowConfig instance." + + " We recommend calling init() in your application class.") + + private class GlobalDatabaseHolder : DatabaseHolder() { + + var isInitialized = false + private set + + fun add(holder: DatabaseHolder) { + databaseDefinitionMap.putAll(holder.databaseDefinitionMap) + databaseNameMap.putAll(holder.databaseNameMap) + typeConverters.putAll(holder.typeConverters) + databaseClassLookupMap.putAll(holder.databaseClassLookupMap) + isInitialized = true + } + } + + /** + * Returns the table name for the specific model class + * + * @param table The class that implements [Model] + * @return The table name, which can be different than the [Model] class name + */ + @JvmStatic + fun getTableName(table: Class<*>): String { + return getModelAdapterOrNull(table)?.tableName + ?: getModelViewAdapterOrNull(table)?.viewName + ?: throwCannotFindAdapter("ModelAdapter/ModelViewAdapter", table) + } + + /** + * @param databaseName The name of the database. Will throw an exception if the database doesn't exist. + * @param tableName The name of the table in the DB. + * @return The associated table class for the specified name. + */ + @JvmStatic + fun getTableClassForName(databaseName: String, tableName: String): Class<*> { + val databaseDefinition = getDatabase(databaseName) + return databaseDefinition.getModelClassForName(tableName) + ?: databaseDefinition.getModelClassForName(QueryBuilder.quote(tableName)) + ?: throw IllegalArgumentException("The specified table $tableName was not found." + + " Did you forget to add the @Table annotation and point it to $databaseName?") + } + + /** + * @param databaseClass The class of the database. Will throw an exception if the database doesn't exist. + * @param tableName The name of the table in the DB. + * @return The associated table class for the specified name. + */ + @JvmStatic + fun getTableClassForName(databaseClass: Class<*>, tableName: String): Class<*> { + val databaseDefinition = getDatabase(databaseClass) + return databaseDefinition.getModelClassForName(tableName) + ?: databaseDefinition.getModelClassForName(QueryBuilder.quote(tableName)) + ?: throw IllegalArgumentException("The specified table $tableName was not found." + + " Did you forget to add the @Table annotation and point it to $databaseClass?") + } + + /** + * @param table The table to lookup the database for. + * @return the corresponding [DatabaseDefinition] for the specified model + */ + @JvmStatic + fun getDatabaseForTable(table: Class<*>): DatabaseDefinition { + checkDatabaseHolder() + return globalDatabaseHolder.getDatabaseForTable(table) ?: + throw InvalidDBConfiguration("Model object: ${table.name} is not registered with a Database." + + " Did you forget an annotation?") + } + + @JvmStatic + fun getDatabase(databaseClass: Class<*>): DatabaseDefinition { + checkDatabaseHolder() + return globalDatabaseHolder.getDatabase(databaseClass) ?: + throw InvalidDBConfiguration("Database: ${databaseClass.name} is not a registered Database. " + + "Did you forget the @Database annotation?") + } + + @JvmStatic + fun getDatabaseName(database: Class<*>): String = getDatabase(database).databaseName + + @JvmStatic + fun getWritableDatabaseForTable(table: Class<*>): DatabaseWrapper = + getDatabaseForTable(table).writableDatabase + + /** + * @param databaseName The name of the database. Will throw an exception if the database doesn't exist. + * @return the [DatabaseDefinition] for the specified database + */ + @JvmStatic + fun getDatabase(databaseName: String): DatabaseDefinition { + checkDatabaseHolder() + return globalDatabaseHolder.getDatabase(databaseName) ?: + throw InvalidDBConfiguration("The specified database $databaseName was not found. " + + "Did you forget the @Database annotation?") + } + + @JvmStatic + fun getWritableDatabase(databaseName: String): DatabaseWrapper = + getDatabase(databaseName).writableDatabase + + @JvmStatic + fun getWritableDatabase(databaseClass: Class<*>): DatabaseWrapper = + getDatabase(databaseClass).writableDatabase + + /** + * Loading the module Database holder via reflection. + * + * + * It is assumed FlowManager.init() is called by the application that uses the + * module database. This method should only be called if you need to load databases + * that are part of a module. Building once will give you the ability to add the class. + */ + @JvmStatic + fun initModule(generatedClassName: Class) { + loadDatabaseHolder(generatedClassName) + } + + @JvmStatic + fun getConfig(): FlowConfig = config ?: + throw IllegalStateException("Configuration is not initialized. " + + "Please call init(FlowConfig) in your application class.") + + /** + * @return The database holder, creating if necessary using reflection. + */ + @JvmStatic + internal fun loadDatabaseHolder(holderClass: Class) { + if (loadedModules.contains(holderClass)) { + return + } + + try { + // Load the database holder, and add it to the global collection. + val dbHolder = holderClass.newInstance() + if (dbHolder != null) { + globalDatabaseHolder.add(dbHolder) + + // Cache the holder for future reference. + loadedModules.add(holderClass) + } + } catch (e: Throwable) { + e.printStackTrace() + throw ModuleNotFoundException("Cannot load $holderClass", e) + } + + } + + /** + * Resets all databases and associated files. + */ + @Synchronized + @JvmStatic + fun reset() { + globalDatabaseHolder.databaseClassLookupMap.values.forEach { it.reset() } + globalDatabaseHolder.reset() + loadedModules.clear() + } + + /** + * Close all DB files and resets [FlowConfig] and the [GlobalDatabaseHolder]. Brings + * DBFlow back to initial application state. + */ + @Synchronized + @JvmStatic + fun close() { + globalDatabaseHolder.databaseClassLookupMap.values.forEach { it.close() } + config = null + globalDatabaseHolder = GlobalDatabaseHolder() + loadedModules.clear() + } + + /** + * Helper method to simplify the [.init]. Use [.init] to provide + * more customization. + * + * @param context - should be application context, but not necessary as we retrieve it anyways. + */ + @JvmStatic + fun init(context: Context) { + init(FlowConfig.Builder(context).build()) + } + + /** + * Initializes DBFlow, loading the main application Database holder via reflection one time only. + * This will trigger all creations, updates, and instantiation for each database defined. + * + * @param flowConfig The configuration instance that will help shape how DBFlow gets constructed. + */ + @JvmStatic + fun init(flowConfig: FlowConfig) { + FlowManager.config = flowConfig + + try { + + val defaultHolderClass = Class.forName(DEFAULT_DATABASE_HOLDER_CLASSNAME) as Class + loadDatabaseHolder(defaultHolderClass) + } catch (e: ModuleNotFoundException) { + // Ignore this exception since it means the application does not have its + // own database. The initialization happens because the application is using + // a module that has a database. + FlowLog.log(FlowLog.Level.W, e.message) + } catch (e: ClassNotFoundException) { + // warning if a library uses DBFlow with module support but the app you're using doesn't support it. + FlowLog.log(FlowLog.Level.W, "Could not find the default GeneratedDatabaseHolder") + } + + flowConfig.databaseHolders.forEach { loadDatabaseHolder(it) } + + if (flowConfig.openDatabasesOnInit) { + globalDatabaseHolder.databaseDefinitions.forEach { + // triggers open, create, migrations. + it.writableDatabase + } + } + } + + /** + * @param objectClass A class with an associated type converter. May return null if not found. + * @return The specific [TypeConverter] for the specified class. It defines + * how the custom datatype is handled going into and out of the DB. + */ + @JvmStatic + fun getTypeConverterForClass(objectClass: Class<*>): TypeConverter<*, *>? { + checkDatabaseHolder() + return globalDatabaseHolder.getTypeConverterForClass(objectClass) + } + + // region Getters + + /** + * Release reference to context and [FlowConfig] + */ + @JvmStatic + @Synchronized + fun destroy() { + globalDatabaseHolder.databaseClassLookupMap.values.forEach { it.destroy() } + config = null + // Reset the global database holder. + globalDatabaseHolder = GlobalDatabaseHolder() + loadedModules.clear() + } + + /** + * @param modelClass The class that implements [Model] to find an adapter for. + * @return The adapter associated with the class. If its not a [ModelAdapter], + * it checks both the [ModelViewAdapter] and [QueryModelAdapter]. + */ + @Suppress("UNCHECKED_CAST") + @JvmStatic + fun getInstanceAdapter(modelClass: Class): InstanceAdapter { + var internalAdapter: InstanceAdapter<*>? = getModelAdapterOrNull(modelClass) + if (internalAdapter == null) { + internalAdapter = getModelViewAdapterOrNull(modelClass) + if (internalAdapter == null) { + internalAdapter = getQueryModelAdapterOrNull(modelClass) + } + } + return internalAdapter as InstanceAdapter? ?: throwCannotFindAdapter("InstanceAdapter", modelClass) + } + + /** + * @param modelClass The class that implements [Model] to find an adapter for. + * @return The adapter associated with the class. If its not a [ModelAdapter], + * it checks both the [ModelViewAdapter] and [QueryModelAdapter]. + */ + @JvmStatic + fun getRetrievalAdapter(modelClass: Class): RetrievalAdapter { + var retrievalAdapter: RetrievalAdapter? = getModelAdapterOrNull(modelClass) + if (retrievalAdapter == null) { + retrievalAdapter = getModelViewAdapterOrNull(modelClass) + if (retrievalAdapter == null) { + retrievalAdapter = getQueryModelAdapterOrNull(modelClass) + } + } + return retrievalAdapter ?: throwCannotFindAdapter("RetrievalAdapter", modelClass) + } + + + /** + * @param modelClass The class of the table + * @param The class that implements [Model] + * @return The associated model adapter (DAO) that is generated from a [Table] class. Handles + * interactions with the database. This method is meant for internal usage only. + * We strongly prefer you use the built-in methods associated with [Model] and [BaseModel]. + */ + @JvmStatic + fun getModelAdapter(modelClass: Class): ModelAdapter { + return getModelAdapterOrNull(modelClass) ?: throwCannotFindAdapter("ModelAdapter", modelClass) + } + + /** + * Returns the model view adapter for a SQLite VIEW. These are only created with the [com.raizlabs.android.dbflow.annotation.ModelView] annotation. + * + * @param modelViewClass The class of the VIEW + * @param The class that extends [BaseModelView] + * @return The model view adapter for the specified model view. + */ + @JvmStatic + fun getModelViewAdapter(modelViewClass: Class): ModelViewAdapter { + return getModelViewAdapterOrNull(modelViewClass) ?: throwCannotFindAdapter("ModelViewAdapter", modelViewClass) + } + + /** + * Returns the query model adapter for an undefined query. These are only created with the [TQueryModel] annotation. + * + * @param queryModelClass The class of the query + * @param The class that extends [BaseQueryModel] + * @return The query model adapter for the specified model query. + */ + @JvmStatic + fun getQueryModelAdapter(queryModelClass: Class): QueryModelAdapter { + return getQueryModelAdapterOrNull(queryModelClass) ?: throwCannotFindAdapter("QueryModelAdapter", queryModelClass) + } + + @JvmStatic + fun getModelNotifierForTable(table: Class<*>): ModelNotifier = + getDatabaseForTable(table).getModelNotifier() + + @JvmStatic + fun newRegisterForTable(table: Class<*>): TableNotifierRegister = + getModelNotifierForTable(table).newRegister() + + private fun getModelAdapterOrNull(modelClass: Class): ModelAdapter? { + return FlowManager.getDatabaseForTable(modelClass).getModelAdapterForTable(modelClass) + } + + private fun getModelViewAdapterOrNull(modelClass: Class): ModelViewAdapter? { + return FlowManager.getDatabaseForTable(modelClass).getModelViewAdapterForTable(modelClass) + } + + private fun getQueryModelAdapterOrNull(modelClass: Class): QueryModelAdapter? { + return FlowManager.getDatabaseForTable(modelClass).getQueryModelAdapterForQueryClass(modelClass) + } + + /** + * @param databaseName The name of the database. Will throw an exception if the database doesn't exist. + * @return The map of migrations for the specified database. + */ + @JvmStatic + internal fun getMigrations(databaseName: String): Map> = + getDatabase(databaseName).migrations + + /** + * Checks a standard database helper for integrity using quick_check(1). + * + * @param databaseName The name of the database to check. Will thrown an exception if it does not exist. + * @return true if it's integrity is OK. + */ + @JvmStatic + fun isDatabaseIntegrityOk(databaseName: String) = getDatabase(databaseName).helper.isDatabaseIntegrityOk + + private fun throwCannotFindAdapter(type: String, clazz: Class<*>): Nothing = + throw IllegalArgumentException("Cannot find $type for $clazz. Ensure the class is annotated with proper annotation.") + + private fun checkDatabaseHolder() { + if (!globalDatabaseHolder.isInitialized) { + throw IllegalStateException("The global database holder is not initialized. Ensure you call " + + "FlowManager.init() before accessing the database.") + } + } + + // endregion + + /** + * Exception thrown when a database holder cannot load the database holder + * for a module. + */ + class ModuleNotFoundException : RuntimeException { + constructor() {} + + constructor(detailMessage: String) : super(detailMessage) {} + + constructor(detailMessage: String, throwable: Throwable) : super(detailMessage, throwable) {} + + constructor(throwable: Throwable) : super(throwable) {} + } + +} \ No newline at end of file diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorList.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorList.java index 411ab6eac..b5dcb6bde 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorList.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorList.java @@ -285,7 +285,7 @@ private void throwIfCursorClosed() { private void warnEmptyCursor() { if (cursor == null) { - FlowLog.log(FlowLog.Level.W, "Cursor was null for FlowCursorList"); + FlowLog.log(FlowLog.INSTANCE.Level.W, "Cursor was null for FlowCursorList"); } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/BaseTransactionManager.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/BaseTransactionManager.java index ffdb2f7c1..49cdd0acd 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/BaseTransactionManager.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/BaseTransactionManager.java @@ -29,7 +29,7 @@ public DBBatchSaveQueue getSaveQueue() { saveQueue.start(); } } catch (IllegalThreadStateException i) { - FlowLog.logError(i); // if queue is alive, will throw error. might occur in multithreading. + FlowLog.INSTANCE.logError(i); // if queue is alive, will throw error. might occur in multithreading. } return saveQueue; } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DBBatchSaveQueue.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DBBatchSaveQueue.java index db91ff429..c155ce43c 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DBBatchSaveQueue.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DBBatchSaveQueue.java @@ -142,7 +142,7 @@ public void run() { //sleep, and then check for leftovers Thread.sleep(modelSaveCheckTime); } catch (InterruptedException e) { - FlowLog.log(FlowLog.Level.I, "DBRequestQueue Batch interrupted to start saving"); + FlowLog.log(FlowLog.INSTANCE.Level.I, "DBRequestQueue Batch interrupted to start saving"); } if (isQuitting) { diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseModelQueriable.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseModelQueriable.java index 419c3f2a0..ab999dd7f 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseModelQueriable.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseModelQueriable.java @@ -57,7 +57,7 @@ public CursorResult queryResults() { @Override public List queryList() { String query = getQuery(); - FlowLog.log(FlowLog.Level.V, "Executing query: " + query); + FlowLog.log(FlowLog.INSTANCE.Level.V, "Executing query: " + query); return getListModelLoader().load(query); } @@ -65,14 +65,14 @@ public List queryList() { @Override public TModel querySingle() { String query = getQuery(); - FlowLog.log(FlowLog.Level.V, "Executing query: " + query); + FlowLog.log(FlowLog.INSTANCE.Level.V, "Executing query: " + query); return getSingleModelLoader().load(query); } @Override public TModel querySingle(@NonNull DatabaseWrapper wrapper) { String query = getQuery(); - FlowLog.log(FlowLog.Level.V, "Executing query: " + query); + FlowLog.log(FlowLog.INSTANCE.Level.V, "Executing query: " + query); return getSingleModelLoader().load(wrapper, query); } @@ -80,7 +80,7 @@ public TModel querySingle(@NonNull DatabaseWrapper wrapper) { @Override public List queryList(@NonNull DatabaseWrapper wrapper) { String query = getQuery(); - FlowLog.log(FlowLog.Level.V, "Executing query: " + query); + FlowLog.log(FlowLog.INSTANCE.Level.V, "Executing query: " + query); return getListModelLoader().load(wrapper, query); } @@ -127,7 +127,7 @@ public AsyncQuery async() { @Override public List queryCustomList(@NonNull Class queryModelClass) { String query = getQuery(); - FlowLog.log(FlowLog.Level.V, "Executing query: " + query); + FlowLog.log(FlowLog.INSTANCE.Level.V, "Executing query: " + query); QueryModelAdapter adapter = FlowManager.getQueryModelAdapter(queryModelClass); return cachingEnabled ? adapter.getListModelLoader().load(query) @@ -138,7 +138,7 @@ public List queryCustomList(@NonNull Class @Override public QueryClass queryCustomSingle(@NonNull Class queryModelClass) { String query = getQuery(); - FlowLog.log(FlowLog.Level.V, "Executing query: " + query); + FlowLog.log(FlowLog.INSTANCE.Level.V, "Executing query: " + query); QueryModelAdapter adapter = FlowManager.getQueryModelAdapter(queryModelClass); return cachingEnabled ? adapter.getSingleModelLoader().load(query) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseQueriable.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseQueriable.java index 34668341d..c2efa4ff9 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseQueriable.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseQueriable.java @@ -67,11 +67,11 @@ public long longValue() { public long longValue(DatabaseWrapper databaseWrapper) { try { String query = getQuery(); - FlowLog.log(FlowLog.Level.V, "Executing query: " + query); + FlowLog.log(FlowLog.INSTANCE.Level.V, "Executing query: " + query); return SqlUtils.longForQuery(databaseWrapper, query); } catch (SQLiteDoneException sde) { // catch exception here, log it but return 0; - FlowLog.log(FlowLog.Level.W, sde); + FlowLog.INSTANCE.log(FlowLog.INSTANCE.Level.W, sde); } return 0; } @@ -101,7 +101,7 @@ public FlowCursor query(@NonNull DatabaseWrapper databaseWrapper) { databaseStatement.close(); } else { String query = getQuery(); - FlowLog.log(FlowLog.Level.V, "Executing query: " + query); + FlowLog.log(FlowLog.INSTANCE.Level.V, "Executing query: " + query); databaseWrapper.execSQL(query); } return null; @@ -149,7 +149,7 @@ public DatabaseStatement compileStatement() { @Override public DatabaseStatement compileStatement(@NonNull DatabaseWrapper databaseWrapper) { String query = getQuery(); - FlowLog.log(FlowLog.Level.V, "Compiling Query Into Statement: " + query); + FlowLog.log(FlowLog.INSTANCE.Level.V, "Compiling Query Into Statement: " + query); return new DatabaseStatementWrapper<>(databaseWrapper.compileStatement(query), this); } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Operator.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Operator.java index 6f1a0862d..cea1082b7 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Operator.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Operator.java @@ -617,7 +617,7 @@ public String convertObjectToString(Object object, boolean appendInnerParenthesi converted = convertToDB ? typeConverter.getDBValue(object) : object; } catch (ClassCastException c) { // if object type is not valid converted type, just use type as is here. - FlowLog.log(FlowLog.Level.W, c); + FlowLog.INSTANCE.log(FlowLog.INSTANCE.Level.W, c); } return BaseOperator.convertValueToString(converted, appendInnerParenthesis, false); } else { diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/AutoIncrementModelSaver.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/AutoIncrementModelSaver.java index 43d7c1dd6..a8c887817 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/AutoIncrementModelSaver.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/AutoIncrementModelSaver.java @@ -51,7 +51,7 @@ public synchronized long insert(@NonNull TModel model, if (!getModelAdapter().hasAutoIncrement(model)) { return super.insert(model, insertStatement, wrapper); } else { - FlowLog.log(FlowLog.Level.W, "Ignoring insert statement " + insertStatement + " since an autoincrement column specified in the insert."); + FlowLog.log(FlowLog.INSTANCE.Level.W, "Ignoring insert statement " + insertStatement + " since an autoincrement column specified in the insert."); return insert(model, wrapper); } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelAdapter.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelAdapter.java index 69714d2b0..a8d81cfb4 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelAdapter.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelAdapter.java @@ -55,7 +55,7 @@ public ModelAdapter(@NonNull DatabaseDefinition databaseDefinition) { @NonNull public DatabaseStatement getInsertStatement() { if (insertStatement == null) { - insertStatement = getInsertStatement(getWritableDatabaseForTable(getModelClass())); + insertStatement = getInsertStatement(INSTANCE.getWritableDatabaseForTable(getModelClass())); } return insertStatement; @@ -67,7 +67,7 @@ public DatabaseStatement getInsertStatement() { @NonNull public DatabaseStatement getUpdateStatement() { if (updateStatement == null) { - updateStatement = getUpdateStatement(getWritableDatabaseForTable(getModelClass())); + updateStatement = getUpdateStatement(INSTANCE.getWritableDatabaseForTable(getModelClass())); } return updateStatement; @@ -79,7 +79,7 @@ public DatabaseStatement getUpdateStatement() { @NonNull public DatabaseStatement getDeleteStatement() { if (deleteStatement == null) { - deleteStatement = getDeleteStatement(getWritableDatabaseForTable(getModelClass())); + deleteStatement = getDeleteStatement(INSTANCE.getWritableDatabaseForTable(getModelClass())); } return deleteStatement; @@ -145,7 +145,7 @@ public DatabaseStatement getDeleteStatement(@NonNull DatabaseWrapper databaseWra @NonNull public DatabaseStatement getCompiledStatement() { if (compiledStatement == null) { - compiledStatement = getCompiledStatement(getWritableDatabaseForTable(getModelClass())); + compiledStatement = getCompiledStatement(INSTANCE.getWritableDatabaseForTable(getModelClass())); } return compiledStatement; diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/SimpleMapCache.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/SimpleMapCache.java index 59bbdeb5e..67e5f3dcb 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/SimpleMapCache.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/SimpleMapCache.java @@ -54,7 +54,7 @@ public TModel get(@Nullable Object id) { @Override public void setCacheSize(int size) { - FlowLog.log(FlowLog.Level.I, "The cache size for " + SimpleMapCache.class.getSimpleName() + + FlowLog.log(FlowLog.INSTANCE.Level.I, "The cache size for " + SimpleMapCache.class.getSimpleName() + " is not re-configurable."); } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/SparseArrayBasedCache.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/SparseArrayBasedCache.java index 4db00dca0..d5024499a 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/SparseArrayBasedCache.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/SparseArrayBasedCache.java @@ -66,7 +66,7 @@ public void clear() { @Override public void setCacheSize(int size) { - FlowLog.log(FlowLog.Level.I, "The cache size for " + SparseArrayBasedCache.class.getSimpleName() + " is not re-configurable."); + FlowLog.log(FlowLog.INSTANCE.Level.I, "The cache size for " + SparseArrayBasedCache.class.getSimpleName() + " is not re-configurable."); } @Override diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/BaseDatabaseHelper.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/BaseDatabaseHelper.java index 807056552..80bb3cc90 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/BaseDatabaseHelper.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/BaseDatabaseHelper.java @@ -71,7 +71,7 @@ public void onDowngrade(@NonNull DatabaseWrapper db, int oldVersion, int newVers protected void checkForeignKeySupport(@NonNull DatabaseWrapper database) { if (databaseDefinition.isForeignKeysSupported()) { database.execSQL("PRAGMA foreign_keys=ON;"); - FlowLog.log(FlowLog.Level.I, "Foreign Keys supported. Enabling foreign key features."); + FlowLog.log(FlowLog.INSTANCE.Level.I, "Foreign Keys supported. Enabling foreign key features."); } } @@ -84,7 +84,7 @@ protected void executeTableCreations(@NonNull final DatabaseWrapper database){ try { database.execSQL(modelAdapter.getCreationQuery()); } catch (SQLiteException e) { - FlowLog.logError(e); + FlowLog.INSTANCE.logError(e); } } } @@ -111,7 +111,7 @@ protected void executeViewCreations(@NonNull final DatabaseWrapper database){ try { database.execSQL(queryBuilder.getQuery()); } catch (SQLiteException e) { - FlowLog.logError(e); + FlowLog.INSTANCE.logError(e); } } database.setTransactionSuccessful(); @@ -140,7 +140,7 @@ protected void executeMigrations(@NonNull final DatabaseWrapper db, } fileList.add(file); } catch (NumberFormatException e) { - FlowLog.log(FlowLog.Level.W, "Skipping invalidly named file: " + file, e); + FlowLog.INSTANCE.log(FlowLog.INSTANCE.Level.W, "Skipping invalidly named file: " + file, e); } } @@ -157,7 +157,7 @@ protected void executeMigrations(@NonNull final DatabaseWrapper db, if (migrationFiles != null) { for (String migrationFile : migrationFiles) { executeSqlScript(db, migrationFile); - FlowLog.log(FlowLog.Level.I, migrationFile + " executed successfully."); + FlowLog.log(FlowLog.INSTANCE.Level.I, migrationFile + " executed successfully."); } } @@ -172,7 +172,7 @@ protected void executeMigrations(@NonNull final DatabaseWrapper db, // after migration cleanup migration.onPostMigrate(); - FlowLog.log(FlowLog.Level.I, migration.getClass() + " executed successfully."); + FlowLog.log(FlowLog.INSTANCE.Level.I, migration.getClass() + " executed successfully."); } } } @@ -181,7 +181,7 @@ protected void executeMigrations(@NonNull final DatabaseWrapper db, db.endTransaction(); } } catch (IOException e) { - FlowLog.log(FlowLog.Level.E, "Failed to execute migrations.", e); + FlowLog.INSTANCE.log(FlowLog.INSTANCE.Level.E, "Failed to execute migrations.", e); } } @@ -227,7 +227,7 @@ private void executeSqlScript(@NonNull DatabaseWrapper db, db.execSQL(queryString); } } catch (IOException e) { - FlowLog.log(FlowLog.Level.E, "Failed to execute " + file, e); + FlowLog.INSTANCE.log(FlowLog.INSTANCE.Level.E, "Failed to execute " + file, e); } } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseHelperDelegate.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseHelperDelegate.java index edfb62be7..f3c888a78 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseHelperDelegate.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseHelperDelegate.java @@ -138,7 +138,7 @@ && isDatabaseIntegrityOk(getWritableDatabase())))) { writeDB(dbPath, inputStream); } catch (IOException e) { - FlowLog.log(FlowLog.Level.W, "Failed to open file", e); + FlowLog.INSTANCE.log(FlowLog.INSTANCE.Level.W, "Failed to open file", e); } } @@ -169,7 +169,7 @@ public boolean isDatabaseIntegrityOk(DatabaseWrapper databaseWrapper) { String result = statement.simpleQueryForString(); if (!result.equalsIgnoreCase("ok")) { // integrity_checker failed on main or attached databases - FlowLog.log(FlowLog.Level.E, "PRAGMA integrity_check on " + + FlowLog.log(FlowLog.INSTANCE.Level.E, "PRAGMA integrity_check on " + getDatabaseDefinition().getDatabaseName() + " returned: " + result); integrityOk = false; @@ -199,11 +199,11 @@ public boolean restoreBackUp() { try { writeDB(corrupt, new FileInputStream(db)); } catch (IOException e) { - FlowLog.logError(e); + FlowLog.INSTANCE.logError(e); success = false; } } else { - FlowLog.log(FlowLog.Level.E, "Failed to delete DB"); + FlowLog.log(FlowLog.INSTANCE.Level.E, "Failed to delete DB"); } return success; } @@ -262,7 +262,7 @@ public void restoreDatabase(String databaseName, String prepackagedName) { } writeDB(dbPath, inputStream); } catch (IOException e) { - FlowLog.logError(e); + FlowLog.INSTANCE.logError(e); } } @@ -302,7 +302,7 @@ public void execute(DatabaseWrapper databaseWrapper) { temp.delete(); } catch (Exception e) { - FlowLog.logError(e); + FlowLog.INSTANCE.logError(e); } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/FlowSQLiteOpenHelper.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/FlowSQLiteOpenHelper.java index 922fff94c..42e0db042 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/FlowSQLiteOpenHelper.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/FlowSQLiteOpenHelper.java @@ -19,16 +19,16 @@ public class FlowSQLiteOpenHelper extends SQLiteOpenHelper implements OpenHelper public FlowSQLiteOpenHelper(@NonNull DatabaseDefinition databaseDefinition, - @NonNull DatabaseHelperListener listener) { + @Nullable DatabaseHelperListener listener) { super(FlowManager.getContext(), databaseDefinition.isInMemory() ? null : databaseDefinition.getDatabaseFileName(), - null, databaseDefinition.getDatabaseVersion()); + null, databaseDefinition.getDatabaseVersion()); OpenHelper backupHelper = null; if (databaseDefinition.backupEnabled()) { // Temp database mirrors existing backupHelper = new BackupHelper(FlowManager.getContext(), - DatabaseHelperDelegate.getTempDbFileName(databaseDefinition), - databaseDefinition.getDatabaseVersion(), databaseDefinition); + DatabaseHelperDelegate.getTempDbFileName(databaseDefinition), + databaseDefinition.getDatabaseVersion(), databaseDefinition); } databaseHelperDelegate = new DatabaseHelperDelegate(listener, databaseDefinition, backupHelper); diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/DefaultTransactionQueue.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/DefaultTransactionQueue.java index 75503e926..dd395b98b 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/DefaultTransactionQueue.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/DefaultTransactionQueue.java @@ -105,7 +105,7 @@ public void startIfNotAlive() { start(); } catch (IllegalThreadStateException i) { // log if failure from thread is still alive. - FlowLog.log(FlowLog.Level.E, i); + FlowLog.INSTANCE.log(FlowLog.INSTANCE.Level.E, i); } } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/PriorityTransactionQueue.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/PriorityTransactionQueue.java index 280e5e431..1b573fe87 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/PriorityTransactionQueue.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/PriorityTransactionQueue.java @@ -102,7 +102,7 @@ public void startIfNotAlive() { start(); } catch (IllegalThreadStateException i) { // log if failure from thread is still alive. - FlowLog.log(FlowLog.Level.E, i); + FlowLog.INSTANCE.log(FlowLog.INSTANCE.Level.E, i); } } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Transaction.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Transaction.java index 5f5a4bd64..e42fd13a1 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Transaction.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Transaction.java @@ -135,7 +135,7 @@ public void run() { } } } catch (final Throwable throwable) { - FlowLog.logError(throwable); + FlowLog.INSTANCE.logError(throwable); if (errorCallback != null) { if (runCallbacksOnSameThread) { errorCallback.onError(this, throwable); diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/ContentUtils.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/ContentUtils.java index 31902791e..187e41f98 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/ContentUtils.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/ContentUtils.java @@ -155,7 +155,7 @@ public static int update(ContentResolver contentResolver, Uri updat adapter.bindToContentValues(contentValues, model); int count = contentResolver.update(updateUri, contentValues, adapter.getPrimaryConditionClause(model).getQuery(), null); if (count == 0) { - FlowLog.log(FlowLog.Level.W, "Updated failed of: " + model.getClass()); + FlowLog.log(FlowLog.INSTANCE.Level.W, "Updated failed of: " + model.getClass()); } return count; } @@ -192,7 +192,7 @@ public static int delete(ContentResolver contentResolver, Uri delet if (count > 0) { adapter.updateAutoIncrement(model, 0); } else { - FlowLog.log(FlowLog.Level.W, "A delete on " + model.getClass() + " within the ContentResolver appeared to fail."); + FlowLog.log(FlowLog.INSTANCE.Level.W, "A delete on " + model.getClass() + " within the ContentResolver appeared to fail."); } return count; } From 2f2aee29fd43db8639a798c8299a378474251e32 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sun, 22 Oct 2017 19:31:15 -0400 Subject: [PATCH 051/234] [5.0] convert list package to kotlin. remove caching mechanisms from list + cursor list so we can provide better caching mechanism. --- .../rx/language/CursorResultSubscriber.java | 4 +- .../rx2/language/CursorResultFlowable.java | 4 +- .../android/dbflow/list/FlowCursorListTest.kt | 10 +- .../android/dbflow/list/FlowQueryListTest.kt | 32 +- .../raizlabs/android/dbflow/config/FlowLog.kt | 23 +- .../dbflow/list/FlowCursorIterator.java | 115 --- .../android/dbflow/list/FlowCursorIterator.kt | 75 ++ .../android/dbflow/list/FlowCursorList.java | 361 --------- .../android/dbflow/list/FlowCursorList.kt | 223 ++++++ .../android/dbflow/list/FlowQueryList.java | 739 ------------------ .../android/dbflow/list/FlowQueryList.kt | 307 ++++++++ .../dbflow/list/IFlowCursorIterator.java | 46 -- .../dbflow/list/IFlowCursorIterator.kt | 37 + .../runtime/BaseTransactionManager.java | 2 +- .../dbflow/runtime/DBBatchSaveQueue.java | 2 +- .../sql/language/BaseModelQueriable.java | 12 +- .../dbflow/sql/language/BaseQueriable.java | 8 +- .../android/dbflow/sql/language/Operator.java | 2 +- .../sql/saveable/AutoIncrementModelSaver.java | 2 +- .../structure/cache/SimpleMapCache.java | 2 +- .../cache/SparseArrayBasedCache.java | 2 +- .../database/BaseDatabaseHelper.java | 16 +- .../database/DatabaseHelperDelegate.java | 12 +- .../transaction/DefaultTransactionQueue.java | 2 +- .../transaction/PriorityTransactionQueue.java | 2 +- .../database/transaction/Transaction.java | 2 +- .../structure/provider/ContentUtils.java | 4 +- 27 files changed, 716 insertions(+), 1330 deletions(-) delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorIterator.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorIterator.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorList.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorList.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowQueryList.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowQueryList.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/list/IFlowCursorIterator.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/list/IFlowCursorIterator.kt diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriber.java b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriber.java index 87f2c4d1a..db0f5fd63 100644 --- a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriber.java +++ b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriber.java @@ -82,13 +82,13 @@ public void call(CursorResult ts) { } limit = requested.addAndGet(-limit); } catch (Exception e) { - FlowLog.INSTANCE.logError(e); + FlowLog.logError(e); subscriber.onError(e); } finally { try { iterator.close(); } catch (Exception e) { - FlowLog.INSTANCE.logError(e); + FlowLog.logError(e); subscriber.onError(e); } } diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/CursorResultFlowable.java b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/CursorResultFlowable.java index b39b3b73a..d6922f376 100644 --- a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/CursorResultFlowable.java +++ b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/CursorResultFlowable.java @@ -88,13 +88,13 @@ public void onSuccess(CursorResult ts) { } limit = requested.addAndGet(-limit); } catch (Exception e) { - FlowLog.INSTANCE.logError(e); + FlowLog.logError(e); subscriber.onError(e); } finally { try { iterator.close(); } catch (Exception e) { - FlowLog.INSTANCE.logError(e); + FlowLog.logError(e); subscriber.onError(e); } } diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorListTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorListTest.kt index 301fcec18..eef5f1279 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorListTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorListTest.kt @@ -30,8 +30,8 @@ class FlowCursorListTest : BaseUnitTest() { .modelCache(SimpleMapCache(55)) .build() - assertTrue(list.modelCache() is SimpleMapCache<*>) - assertTrue(list.cachingEnabled()) + assertTrue(list.modelCache is SimpleMapCache<*>) + assertTrue(list.cachingEnabled) } @Test @@ -41,7 +41,7 @@ class FlowCursorListTest : BaseUnitTest() { .cacheModels(false) .build() - assertFalse(list.cachingEnabled()) + assertFalse(list.cachingEnabled) } @Test @@ -57,11 +57,11 @@ class FlowCursorListTest : BaseUnitTest() { @Test fun validateModelQueriable() { val modelQueriable = (select from SimpleModel::class) - val list = FlowCursorList.Builder(SimpleModel::class.java) + val list = FlowCursorList.Builder(SimpleModel::class.java) .modelQueriable(modelQueriable) .build() - assertEquals(modelQueriable, list.modelQueriable()) + assertEquals(modelQueriable, list.modelQueriable) } @Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowQueryListTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowQueryListTest.kt index 49680b476..03bd7969d 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowQueryListTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowQueryListTest.kt @@ -9,9 +9,7 @@ import com.raizlabs.android.dbflow.kotlinextensions.select import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.structure.cache.SimpleMapCache import com.raizlabs.android.dbflow.structure.database.transaction.Transaction -import org.junit.Assert.assertEquals -import org.junit.Assert.assertFalse -import org.junit.Assert.assertTrue +import org.junit.Assert.* import org.junit.Test class FlowQueryListTest : BaseUnitTest() { @@ -20,37 +18,23 @@ class FlowQueryListTest : BaseUnitTest() { fun validateBuilder() { val list = FlowQueryList.Builder(select from SimpleModel::class) - .modelCache(SimpleMapCache(55)) - .transact(true) - .changeInTransaction(true) - .build() + .modelCache(SimpleMapCache(55)) + .transact(true) + .changeInTransaction(true) + .build() - assertTrue(list.cursorList().modelCache() is SimpleMapCache<*>) - assertTrue(list.cursorList().cachingEnabled()) assertTrue(list.transact()) assertTrue(list.changeInTransaction()) } - @Test - fun validateNonCachedBuilder() { - - val list = FlowQueryList.Builder(select from SimpleModel::class) - .cacheModels(false) - .build() - - assertFalse(list.cursorList().cachingEnabled()) - - } - - @Test fun validateListOperations() { val mockSuccess = mock() val mockError = mock() val list = (select from SimpleModel::class).flowQueryList() - .newBuilder().success(mockSuccess) - .error(mockError) - .build() + .newBuilder().success(mockSuccess) + .error(mockError) + .build() list += SimpleModel("1") // verify added diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowLog.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowLog.kt index 8676299f5..4a1fce24d 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowLog.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowLog.kt @@ -39,6 +39,17 @@ object FlowLog { } } + /** + * Logs information to the [Log] class. It wraps around the standard implementation. + * + * @param level The log level to use + * @param tag The tag of the log + * @param message The message to print out + * @param throwable The optional stack trace to print + */ + @JvmStatic + fun log(level: Level, message: String, throwable: Throwable?) = log(level = level, tag = TAG, message = message, throwable = throwable) + /** * Returns true if the logging level is lower than the specified [Level] * @@ -54,7 +65,17 @@ object FlowLog { */ @JvmStatic fun logError(throwable: Throwable) { - log(Level.E, throwable) + log(Level.E, throwable = throwable) + } + + /** + * Logs a [java.lang.Throwable] as a warning. + * + * @param throwable The stack trace to print + */ + @JvmStatic + fun logWarning(throwable: Throwable) { + log(Level.W, throwable = throwable) } /** diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorIterator.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorIterator.java deleted file mode 100644 index e6a1347ae..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorIterator.java +++ /dev/null @@ -1,115 +0,0 @@ -package com.raizlabs.android.dbflow.list; - -import android.database.Cursor; -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import java.util.ConcurrentModificationException; -import java.util.ListIterator; - -/** - * Description: Provides iteration capabilities to a {@link FlowCursorList}. - */ -public class FlowCursorIterator implements ListIterator, AutoCloseable { - - private final IFlowCursorIterator cursorList; - private long reverseIndex; - private long startingCount; - private long count; - - public FlowCursorIterator(@NonNull IFlowCursorIterator cursorList) { - this(cursorList, 0, cursorList.getCount()); - } - - public FlowCursorIterator(@NonNull IFlowCursorIterator cursorList, int startingLocation) { - this(cursorList, startingLocation, cursorList.getCount() - startingLocation); - } - - public FlowCursorIterator(@NonNull IFlowCursorIterator cursorList, int startingLocation, - long count) { - this.cursorList = cursorList; - this.count = count; - Cursor cursor = cursorList.cursor(); - if (cursor != null) { - // request larger than actual count. - if (this.count > cursor.getCount() - startingLocation) { - this.count = cursor.getCount() - startingLocation; - } - - cursor.moveToPosition(startingLocation - 1); - startingCount = cursorList.getCount(); - reverseIndex = this.count; - reverseIndex -= startingLocation; - - if (reverseIndex < 0) { - reverseIndex = 0; - } - } - } - - @Override - public void close() throws Exception { - cursorList.close(); - } - - @Override - public void add(@Nullable TModel object) { - throw new UnsupportedOperationException("Cursor Iterator: Cannot add a model in the iterator"); - } - - @Override - public boolean hasNext() { - checkSizes(); - return reverseIndex > 0; - } - - @Override - public boolean hasPrevious() { - checkSizes(); - return reverseIndex < count; - } - - @Nullable - @Override - public TModel next() { - checkSizes(); - TModel item = cursorList.getItem(count - reverseIndex); - reverseIndex--; - return item; - } - - @Override - public int nextIndex() { - return (int) (reverseIndex + 1); - } - - @Nullable - @Override - public TModel previous() { - checkSizes(); - TModel item = cursorList.getItem(count - reverseIndex); - reverseIndex++; - return item; - } - - @Override - public int previousIndex() { - return (int) reverseIndex; - } - - @Override - public void remove() { - throw new UnsupportedOperationException("Cursor Iterator: cannot remove from an active Iterator "); - } - - @Override - public void set(@Nullable TModel object) { - throw new UnsupportedOperationException("Cursor Iterator: cannot set on an active Iterator "); - } - - private void checkSizes() { - if (startingCount != cursorList.getCount()) { - throw new ConcurrentModificationException("Cannot change Cursor data during iteration."); - } - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorIterator.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorIterator.kt new file mode 100644 index 000000000..33563b75c --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorIterator.kt @@ -0,0 +1,75 @@ +package com.raizlabs.android.dbflow.list + +import java.util.* + +/** + * Description: Provides iteration capabilities to a [FlowCursorList]. + */ +class FlowCursorIterator +@JvmOverloads constructor( + private val cursorList: IFlowCursorIterator, + startingLocation: Int, + private var count: Long = cursorList.count - startingLocation) + : ListIterator, AutoCloseable { + private var reverseIndex: Long = 0 + private var startingCount: Long = 0 + + constructor(cursorList: IFlowCursorIterator) : this(cursorList, 0, cursorList.count) + + init { + cursorList.cursor()?.let { cursor -> + // request larger than actual count. + if (this.count > cursor.count - startingLocation) { + this.count = (cursor.count - startingLocation).toLong() + } + + cursor.moveToPosition(startingLocation - 1) + startingCount = cursorList.count + reverseIndex = this.count + reverseIndex -= startingLocation.toLong() + + if (reverseIndex < 0) { + reverseIndex = 0 + } + } + } + + @Throws(Exception::class) + override fun close() { + cursorList.close() + } + + override fun hasNext(): Boolean { + checkSizes() + return reverseIndex > 0 + } + + override fun hasPrevious(): Boolean { + checkSizes() + return reverseIndex < count + } + + override fun next(): TModel { + checkSizes() + val item = cursorList.getItem(count - reverseIndex) + reverseIndex-- + return item + } + + override fun nextIndex(): Int = (reverseIndex + 1).toInt() + + override fun previous(): TModel { + checkSizes() + val item = cursorList.getItem(count - reverseIndex) + reverseIndex++ + return item + } + + override fun previousIndex(): Int = reverseIndex.toInt() + + private fun checkSizes() { + if (startingCount != cursorList.count) { + throw ConcurrentModificationException("Cannot change Cursor data during iteration.") + } + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorList.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorList.java deleted file mode 100644 index b5dcb6bde..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorList.java +++ /dev/null @@ -1,361 +0,0 @@ -package com.raizlabs.android.dbflow.list; - -import android.database.Cursor; -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; -import android.widget.ListView; - -import com.raizlabs.android.dbflow.config.FlowLog; -import com.raizlabs.android.dbflow.config.FlowManager; -import com.raizlabs.android.dbflow.sql.language.SQLite; -import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable; -import com.raizlabs.android.dbflow.structure.InstanceAdapter; -import com.raizlabs.android.dbflow.structure.ModelAdapter; -import com.raizlabs.android.dbflow.structure.cache.ModelCache; -import com.raizlabs.android.dbflow.structure.cache.ModelLruCache; -import com.raizlabs.android.dbflow.structure.database.FlowCursor; - -import java.util.ArrayList; -import java.util.HashSet; -import java.util.List; - -/** - * Description: A non-modifiable, cursor-backed list that you can use in {@link ListView} or other data sources. - */ -public class FlowCursorList implements - Iterable, IFlowCursorIterator { - - /** - * Interface for callbacks when cursor gets refreshed. - */ - public interface OnCursorRefreshListener { - - /** - * Callback when cursor refreshes. - * - * @param cursorList The object that changed. - */ - void onCursorRefreshed(@NonNull FlowCursorList cursorList); - } - - /** - * The default size of the cache if cache size is 0 or not specified. - */ - public static final int DEFAULT_CACHE_SIZE = 50; - - /** - * Minimum size that we make the cache (if size is supported in cache) - */ - public static final int MIN_CACHE_SIZE = 20; - - @Nullable - private FlowCursor cursor; - - private Class table; - private ModelCache modelCache; - private boolean cacheModels; - - @Nullable - private ModelQueriable modelQueriable; - - private InstanceAdapter instanceAdapter; - - private final java.util.Set> cursorRefreshListenerSet = new HashSet<>(); - - private FlowCursorList(final Builder builder) { - table = builder.modelClass; - modelQueriable = builder.modelQueriable; - if (builder.modelQueriable == null) { - cursor = builder.cursor; - // no cursor or queriable, we formulate query from table data. - if (cursor == null) { - modelQueriable = SQLite.select().from(table); - cursor = modelQueriable.query(); - } - } else { - cursor = builder.modelQueriable.query(); - } - cacheModels = builder.cacheModels; - if (cacheModels) { - modelCache = builder.modelCache; - if (modelCache == null) { - // new cache with default size - modelCache = ModelLruCache.newInstance(0); - } - } - instanceAdapter = FlowManager.getInstanceAdapter(builder.modelClass); - - setCacheModels(cacheModels); - } - - @NonNull - InstanceAdapter getInstanceAdapter() { - return instanceAdapter; - } - - @NonNull - ModelAdapter getModelAdapter() { - return (ModelAdapter) instanceAdapter; - } - - @NonNull - @Override - public FlowCursorIterator iterator() { - return new FlowCursorIterator<>(this); - } - - @NonNull - @Override - public FlowCursorIterator iterator(int startingLocation, long limit) { - return new FlowCursorIterator<>(this, startingLocation, limit); - } - - /** - * Register listener for when cursor refreshes. - */ - public void addOnCursorRefreshListener(@NonNull OnCursorRefreshListener onCursorRefreshListener) { - synchronized (cursorRefreshListenerSet) { - cursorRefreshListenerSet.add(onCursorRefreshListener); - } - } - - public void removeOnCursorRefreshListener(@NonNull OnCursorRefreshListener onCursorRefreshListener) { - synchronized (cursorRefreshListenerSet) { - cursorRefreshListenerSet.remove(onCursorRefreshListener); - } - } - - /** - * Sets this list to cache models. If set to false, it will immediately clear the cache for you. - * - * @param cacheModels true, will cache models. If false, any and future caching is cleared. - * @deprecated use {@link Builder#cacheModels(boolean)}, {@link Builder#modelCache()} - */ - void setCacheModels(boolean cacheModels) { - this.cacheModels = cacheModels; - if (!cacheModels) { - clearCache(); - } - } - - /** - * Clears the {@link TModel} cache if we use a cache. - */ - public void clearCache() { - if (cacheModels) { - modelCache.clear(); - } - } - - /** - * Refreshes the data backing this list, and destroys the Model cache. - */ - public synchronized void refresh() { - warnEmptyCursor(); - if (cursor != null) { - cursor.close(); - } - if (modelQueriable == null) { - throw new IllegalStateException("Cannot refresh this FlowCursorList. This list was instantiated from a Cursor. Once closed, we cannot reopen " + - "it. Construct a new instance and swap with this instance."); - } - cursor = modelQueriable.query(); - - if (cacheModels) { - modelCache.clear(); - setCacheModels(true); - } - - synchronized (cursorRefreshListenerSet) { - for (OnCursorRefreshListener listener : cursorRefreshListenerSet) { - listener.onCursorRefreshed(this); - } - } - } - - @Nullable - public ModelQueriable modelQueriable() { - return modelQueriable; - } - - /** - * Returns a model at the specified position. If we are using the cache and it does not contain a model - * at that position, we move the cursor to the specified position and construct the {@link TModel}. - * - * @param position The row number in the {@link android.database.Cursor} to look at - * @return The {@link TModel} converted from the cursor - */ - @Nullable - @Override - public TModel getItem(long position) { - throwIfCursorClosed(); - warnEmptyCursor(); - - TModel model = null; - if (cacheModels) { - model = modelCache.get(position); - if (model == null && cursor != null && cursor.moveToPosition((int) position)) { - model = instanceAdapter.getSingleModelLoader().convertToData(cursor, null, false); - modelCache.addModel(position, model); - } - } else if (cursor != null && cursor.moveToPosition((int) position)) { - model = instanceAdapter.getSingleModelLoader().convertToData(cursor, null, false); - } - return model; - } - - /** - * @return the full, converted {@link TModel} list from the database on this list. For large - * data sets that require a large conversion, consider calling this on a BG thread. - */ - @NonNull - public List getAll() { - throwIfCursorClosed(); - warnEmptyCursor(); - if (!cacheModels) { - return cursor == null ? new ArrayList() : - FlowManager.getModelAdapter(table).getListModelLoader().convertToData(cursor, null); - } else { - List list = new ArrayList<>(); - for (TModel model : this) { - list.add(model); - } - return list; - } - } - - /** - * @return the count of rows on this database query list. - */ - public boolean isEmpty() { - throwIfCursorClosed(); - warnEmptyCursor(); - return getCount() == 0; - } - - /** - * @return the count of the rows in the {@link android.database.Cursor} backed by this list. - */ - @Override - public long getCount() { - throwIfCursorClosed(); - warnEmptyCursor(); - return cursor != null ? cursor.getCount() : 0; - } - - @NonNull - public ModelCache modelCache() { - return modelCache; - } - - public boolean cachingEnabled() { - return cacheModels; - } - - /** - * Closes the cursor backed by this list - */ - @Override - public void close() { - warnEmptyCursor(); - if (cursor != null) { - cursor.close(); - } - cursor = null; - } - - @Override - @Nullable - public Cursor cursor() { - throwIfCursorClosed(); - warnEmptyCursor(); - return cursor; - } - - @NonNull - public Class table() { - return table; - } - - private void throwIfCursorClosed() { - if (cursor != null && cursor.isClosed()) { - throw new IllegalStateException("Cursor has been closed for FlowCursorList"); - } - } - - private void warnEmptyCursor() { - if (cursor == null) { - FlowLog.log(FlowLog.INSTANCE.Level.W, "Cursor was null for FlowCursorList"); - } - } - - /** - * @return A new {@link Builder} that contains the same cache, query statement, and other - * underlying data, but allows for modification. - */ - @NonNull - public Builder newBuilder() { - return new Builder<>(table) - .modelQueriable(modelQueriable) - .cursor(cursor) - .cacheModels(cacheModels) - .modelCache(modelCache); - } - - /** - * Provides easy way to construct a {@link FlowCursorList}. - * - * @param - */ - public static class Builder { - - private final Class modelClass; - private FlowCursor cursor; - private ModelQueriable modelQueriable; - private boolean cacheModels = true; - private ModelCache modelCache; - - public Builder(@NonNull Class modelClass) { - this.modelClass = modelClass; - } - - public Builder(@NonNull ModelQueriable modelQueriable) { - this.modelClass = modelQueriable.getTable(); - modelQueriable(modelQueriable); - } - - @NonNull - public Builder cursor(@Nullable Cursor cursor) { - if (cursor != null) { - this.cursor = FlowCursor.from(cursor); - } - return this; - } - - @NonNull - public Builder modelQueriable(@Nullable ModelQueriable modelQueriable) { - this.modelQueriable = modelQueriable; - return this; - } - - @NonNull - public Builder cacheModels(boolean cacheModels) { - this.cacheModels = cacheModels; - return this; - } - - @NonNull - public Builder modelCache(@Nullable ModelCache modelCache) { - this.modelCache = modelCache; - if (modelCache != null) { - cacheModels(true); - } - return this; - } - - @NonNull - public FlowCursorList build() { - return new FlowCursorList<>(this); - } - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorList.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorList.kt new file mode 100644 index 000000000..063f5371b --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorList.kt @@ -0,0 +1,223 @@ +package com.raizlabs.android.dbflow.list + +import android.database.Cursor +import android.widget.ListView +import com.raizlabs.android.dbflow.config.FlowLog +import com.raizlabs.android.dbflow.config.FlowManager +import com.raizlabs.android.dbflow.sql.language.SQLite +import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable +import com.raizlabs.android.dbflow.structure.InstanceAdapter +import com.raizlabs.android.dbflow.structure.ModelAdapter +import com.raizlabs.android.dbflow.structure.database.FlowCursor +import java.util.* + +/** + * Description: A non-modifiable, cursor-backed list that you can use in [ListView] or other data sources. + */ +class FlowCursorList private constructor(builder: Builder) : IFlowCursorIterator { + + /** + * Interface for callbacks when cursor gets refreshed. + */ + interface OnCursorRefreshListener { + + /** + * Callback when cursor refreshes. + * + * @param cursorList The object that changed. + */ + fun onCursorRefreshed(cursorList: FlowCursorList) + } + + + val table: Class + val modelQueriable: ModelQueriable + private var cursor: FlowCursor? = null + private val cursorFunc: () -> FlowCursor + + internal val instanceAdapter: InstanceAdapter + + private val cursorRefreshListenerSet = HashSet>() + + internal val modelAdapter: ModelAdapter + get() = instanceAdapter as ModelAdapter + + /** + * @return the full, converted [TModel] list from the database on this list. For large + * data sets that require a large conversion, consider calling this on a BG thread. + */ + val all: List + get() { + throwIfCursorClosed() + warnEmptyCursor() + return cursor?.let { cursor -> + FlowManager.getModelAdapter(table) + .listModelLoader.convertToData(cursor, null) + } ?: listOf() + } + + /** + * @return the count of rows on this database query list. + */ + val isEmpty: Boolean + get() { + throwIfCursorClosed() + warnEmptyCursor() + return count == 0L + } + + init { + table = builder.modelClass + this.modelQueriable = builder.modelQueriable + cursorFunc = { builder.cursor ?: modelQueriable.query() ?: throw IllegalStateException("The query must evaluate to a cursor") } + instanceAdapter = FlowManager.getInstanceAdapter(builder.modelClass) + } + + override operator fun iterator(): FlowCursorIterator { + return FlowCursorIterator(this) + } + + override fun iterator(startingLocation: Int, limit: Long): FlowCursorIterator { + return FlowCursorIterator(this, startingLocation, limit) + } + + /** + * Register listener for when cursor refreshes. + */ + fun addOnCursorRefreshListener(onCursorRefreshListener: OnCursorRefreshListener) { + synchronized(cursorRefreshListenerSet) { + cursorRefreshListenerSet.add(onCursorRefreshListener) + } + } + + fun removeOnCursorRefreshListener(onCursorRefreshListener: OnCursorRefreshListener) { + synchronized(cursorRefreshListenerSet) { + cursorRefreshListenerSet.remove(onCursorRefreshListener) + } + } + + /** + * Refreshes the data backing this list, and destroys the Model cache. + */ + @Synchronized + fun refresh() { + val cursor = unpackCursor() + cursor.close() + this.cursor = modelQueriable.query() + synchronized(cursorRefreshListenerSet) { + cursorRefreshListenerSet.forEach { listener -> listener.onCursorRefreshed(this) } + } + } + + /** + * Returns a model at the specified position. If we are using the cache and it does not contain a model + * at that position, we move the cursor to the specified position and construct the [TModel]. + * + * @param position The row number in the [android.database.Cursor] to look at + * @return The [TModel] converted from the cursor + */ + override fun getItem(position: Long): TModel { + throwIfCursorClosed() + + val cursor = unpackCursor() + return if (cursor.moveToPosition(position.toInt())) { + instanceAdapter.singleModelLoader.convertToData(FlowCursor.from(cursor), null, false) + ?: throw IndexOutOfBoundsException("Invalid item at position $position. Check your cursor data.") + } else { + throw IndexOutOfBoundsException("Invalid item at position $position. Check your cursor data.") + } + } + + /** + * @return the count of the rows in the [android.database.Cursor] backed by this list. + */ + override val count: Long + get() { + throwIfCursorClosed() + warnEmptyCursor() + return (cursor?.count ?: 0).toLong() + } + + /** + * Closes the cursor backed by this list + */ + override fun close() { + warnEmptyCursor() + cursor?.close() + cursor = null + } + + override fun cursor(): Cursor? { + throwIfCursorClosed() + warnEmptyCursor() + return cursor + } + + private fun unpackCursor(): Cursor { + if (cursor == null) { + cursor = cursorFunc() + } + return cursor!! + } + + private fun throwIfCursorClosed() { + if (cursor?.isClosed == true) { + throw IllegalStateException("Cursor has been closed for FlowCursorList") + } + } + + private fun warnEmptyCursor() { + if (cursor == null) { + FlowLog.log(FlowLog.Level.W, "Cursor was null for FlowCursorList") + } + } + + /** + * @return A new [Builder] that contains the same cache, query statement, and other + * underlying data, but allows for modification. + */ + fun newBuilder(): Builder { + return Builder(modelQueriable).cursor(unpackCursor()) + } + + /** + * Provides easy way to construct a [FlowCursorList]. + * + * @param + */ + class Builder { + + internal val modelClass: Class + internal var cursor: FlowCursor? = null + internal var modelQueriable: ModelQueriable + + constructor(modelClass: Class) { + this.modelClass = modelClass + this.modelQueriable = SQLite.select().from(modelClass) + } + + constructor(modelQueriable: ModelQueriable) { + this.modelClass = modelQueriable.table + this.modelQueriable = modelQueriable + } + + fun cursor(cursor: Cursor?) = apply { + cursor?.let { this.cursor = FlowCursor.from(cursor) } + } + + fun build() = FlowCursorList(this) + } + + companion object { + + /** + * The default size of the cache if cache size is 0 or not specified. + */ + val DEFAULT_CACHE_SIZE = 50 + + /** + * Minimum size that we make the cache (if size is supported in cache) + */ + val MIN_CACHE_SIZE = 20 + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowQueryList.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowQueryList.java deleted file mode 100644 index fb7e9aef5..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowQueryList.java +++ /dev/null @@ -1,739 +0,0 @@ -package com.raizlabs.android.dbflow.list; - -import android.annotation.TargetApi; -import android.content.Context; -import android.database.Cursor; -import android.net.Uri; -import android.os.Build; -import android.os.Handler; -import android.os.Looper; -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.config.FlowManager; -import com.raizlabs.android.dbflow.list.FlowCursorList.OnCursorRefreshListener; -import com.raizlabs.android.dbflow.runtime.FlowContentObserver; -import com.raizlabs.android.dbflow.sql.language.SQLite; -import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable; -import com.raizlabs.android.dbflow.structure.InstanceAdapter; -import com.raizlabs.android.dbflow.structure.Model; -import com.raizlabs.android.dbflow.structure.ModelAdapter; -import com.raizlabs.android.dbflow.structure.cache.ModelCache; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; -import com.raizlabs.android.dbflow.structure.database.transaction.DefaultTransactionQueue; -import com.raizlabs.android.dbflow.structure.database.transaction.ProcessModelTransaction; -import com.raizlabs.android.dbflow.structure.database.transaction.QueryTransaction; -import com.raizlabs.android.dbflow.structure.database.transaction.Transaction; - -import java.util.Collection; -import java.util.List; -import java.util.ListIterator; - -/** - * Description: Operates very similiar to a {@link java.util.List} except its backed by a table cursor. All of - * the {@link java.util.List} modifications default to the main thread, but it can be set to - * run on the {@link DefaultTransactionQueue}. Register a {@link Transaction.Success} - * on this list to know when the results complete. NOTE: any modifications to this list will be reflected - * on the underlying table. - */ -public class FlowQueryList extends FlowContentObserver - implements List, IFlowCursorIterator { - - private static final Handler REFRESH_HANDLER = new Handler(Looper.myLooper()); - - /** - * Holds the table cursor - */ - private final FlowCursorList internalCursorList; - private final Transaction.Success successCallback; - private final Transaction.Error errorCallback; - - /** - * If true, we will make all modifications on the {@link DefaultTransactionQueue}, else - * we will run it on the main thread. - */ - private boolean transact = false; - - private boolean changeInTransaction = false; - - private boolean pendingRefresh = false; - - - private FlowQueryList(Builder builder) { - transact = builder.transact; - changeInTransaction = builder.changeInTransaction; - successCallback = builder.success; - errorCallback = builder.error; - internalCursorList = new FlowCursorList.Builder<>(builder.table) - .cursor(builder.cursor) - .cacheModels(builder.cacheModels) - .modelQueriable(builder.modelQueriable) - .modelCache(builder.modelCache) - .build(); - } - - /** - * Registers the list for model change events. Internally this refreshes the underlying {@link FlowCursorList}. Call - * {@link #beginTransaction()} to bunch up calls to model changes and then {@link #endTransactionAndNotify()} to dispatch - * and refresh this list when completed. - */ - public void registerForContentChanges(@NonNull Context context) { - super.registerForContentChanges(context, internalCursorList.table()); - } - - public void addOnCursorRefreshListener(@NonNull OnCursorRefreshListener onCursorRefreshListener) { - internalCursorList.addOnCursorRefreshListener(onCursorRefreshListener); - } - - public void removeOnCursorRefreshListener(@NonNull OnCursorRefreshListener onCursorRefreshListener) { - internalCursorList.removeOnCursorRefreshListener(onCursorRefreshListener); - } - - @Override - public void registerForContentChanges(Context context, Class table) { - throw new RuntimeException( - "This method is not to be used in the FlowQueryList. We should only ever receive" + - " notifications for one class here. Call registerForContentChanges(Context) instead"); - } - - @Override - public void onChange(boolean selfChange) { - super.onChange(selfChange); - if (!isInTransaction) { - refreshAsync(); - } else { - changeInTransaction = true; - } - } - - @TargetApi(Build.VERSION_CODES.JELLY_BEAN) - @Override - public void onChange(boolean selfChange, Uri uri) { - super.onChange(selfChange, uri); - if (!isInTransaction) { - refreshAsync(); - } else { - changeInTransaction = true; - } - } - - /** - * @return a mutable list that does not reflect changes on the underlying DB. - */ - @NonNull - public List getCopy() { - return internalCursorList.getAll(); - } - - @NonNull - public FlowCursorList cursorList() { - return internalCursorList; - } - - @Nullable - public Transaction.Error error() { - return errorCallback; - } - - @Nullable - public Transaction.Success success() { - return successCallback; - } - - public boolean changeInTransaction() { - return changeInTransaction; - } - - public boolean transact() { - return transact; - } - - @NonNull - ModelAdapter getModelAdapter() { - return internalCursorList.getModelAdapter(); - } - - @NonNull - InstanceAdapter getInstanceAdapter() { - return internalCursorList.getInstanceAdapter(); - } - - /** - * @return Constructs a new {@link Builder} that reuses the underlying {@link Cursor}, cache, - * callbacks, and other properties. - */ - @NonNull - public Builder newBuilder() { - return new Builder<>(internalCursorList) - .success(successCallback) - .error(errorCallback) - .changeInTransaction(changeInTransaction) - .transact(transact); - } - - /** - * Refreshes the content backing this list. - */ - public void refresh() { - internalCursorList.refresh(); - } - - /** - * Will refresh content at a slightly later time, and multiple subsequent calls to this method within - * a short period of time will be combined into one call. - */ - public void refreshAsync() { - synchronized (this) { - if (pendingRefresh) { - return; - } - pendingRefresh = true; - } - REFRESH_HANDLER.post(refreshRunnable); - } - - @Override - public void endTransactionAndNotify() { - if (changeInTransaction) { - changeInTransaction = false; - refresh(); - } - super.endTransactionAndNotify(); - } - - /** - * Adds an item to this table, but does not allow positonal insertion. Same as calling - * {@link #add(TModel)} - * - * @param location Not used. - * @param model The model to save - */ - @Override - public void add(int location, @Nullable TModel model) { - add(model); - } - - /** - * Adds an item to this table - * - * @param model The model to save - * @return always true - */ - @Override - public boolean add(@Nullable TModel model) { - if (model != null) { - Transaction transaction = FlowManager.getDatabaseForTable(internalCursorList.table()) - .beginTransactionAsync(new ProcessModelTransaction.Builder<>(saveModel) - .add(model).build()) - .error(internalErrorCallback) - .success(internalSuccessCallback).build(); - - if (transact) { - transaction.execute(); - } else { - transaction.executeSync(); - } - return true; - } else { - return false; - } - } - - /** - * Adds all items to this table, but - * does not allow positional insertion. Same as calling {@link #addAll(java.util.Collection)} - * - * @param location Not used. - * @param collection The list of items to add to the table - * @return always true - */ - @Override - public boolean addAll(int location, @NonNull Collection collection) { - return addAll(collection); - } - - /** - * Adds all items to this table. - * - * @param collection The list of items to add to the table - * @return always true - */ - @SuppressWarnings("unchecked") - @Override - public boolean addAll(@NonNull Collection collection) { - // cast to normal collection, we do not want subclasses of this table saved - final Collection tmpCollection = (Collection) collection; - - Transaction transaction = FlowManager.getDatabaseForTable(internalCursorList.table()) - .beginTransactionAsync(new ProcessModelTransaction.Builder<>(saveModel) - .addAll(tmpCollection).build()) - .error(internalErrorCallback) - .success(internalSuccessCallback).build(); - - if (transact) { - transaction.execute(); - } else { - transaction.executeSync(); - } - return true; - } - - /** - * Deletes all items from the table. Be careful as this will clear data! - */ - @Override - public void clear() { - Transaction transaction = FlowManager.getDatabaseForTable(internalCursorList.table()) - .beginTransactionAsync(new QueryTransaction.Builder<>( - SQLite.delete().from(internalCursorList.table())).build()) - .error(internalErrorCallback) - .success(internalSuccessCallback) - .build(); - - if (transact) { - transaction.execute(); - } else { - transaction.executeSync(); - } - } - - /** - * Checks to see if the table contains the object only if its a {@link TModel} - * - * @param object A model class. For interface purposes, this must be an Object. - * @return always false if its anything other than the current table. True if {@link com.raizlabs.android.dbflow.structure.Model#exists()} passes. - */ - @SuppressWarnings("unchecked") - @Override - public boolean contains(@Nullable Object object) { - boolean contains = false; - if (object != null && internalCursorList.table().isAssignableFrom(object.getClass())) { - TModel model = ((TModel) object); - contains = internalCursorList.getInstanceAdapter().exists(model); - } - - return contains; - } - - /** - * If the collection is null or empty, we return false. - * - * @param collection The collection to check if all exist within the table. - * @return true if all items exist in table, false if at least one fails. - */ - @Override - public boolean containsAll(@NonNull Collection collection) { - boolean contains = !(collection.isEmpty()); - if (contains) { - for (Object o : collection) { - if (!contains(o)) { - contains = false; - break; - } - } - } - return contains; - } - - @Override - public long getCount() { - return internalCursorList.getCount(); - } - - @Nullable - @Override - public TModel getItem(long position) { - return internalCursorList.getItem(position); - } - - @Nullable - @Override - public Cursor cursor() { - return internalCursorList.cursor(); - } - - /** - * Returns the item from the backing {@link FlowCursorList}. First call - * will load the model from the cursor, while subsequent calls will use the cache. - * - * @param row the row from the internal {@link FlowCursorList} query that we use. - * @return A model converted from the internal {@link FlowCursorList}. For - * performance improvements, ensure caching is turned on. - */ - @Nullable - @Override - public TModel get(int row) { - return internalCursorList.getItem(row); - } - - @Override - public int indexOf(Object object) { - throw new UnsupportedOperationException( - "We cannot determine which index in the table this item exists at efficiently"); - } - - @Override - public boolean isEmpty() { - return internalCursorList.isEmpty(); - } - - /** - * @return An iterator from {@link FlowCursorList#getAll()}. - * Be careful as this method will convert all data under this table into a list of {@link TModel} in the UI thread. - */ - @NonNull - @Override - public FlowCursorIterator iterator() { - return new FlowCursorIterator<>(this); - } - - @NonNull - @Override - public FlowCursorIterator iterator(int startingLocation, long limit) { - return new FlowCursorIterator<>(this, startingLocation, limit); - } - - @Override - public int lastIndexOf(Object object) { - throw new UnsupportedOperationException( - "We cannot determine which index in the table this item exists at efficiently"); - } - - /** - * @return A list iterator from the {@link FlowCursorList#getAll()}. - * Be careful as this method will convert all data under this table into a list of {@link TModel} in the UI thread. - */ - @NonNull - @Override - public ListIterator listIterator() { - return new FlowCursorIterator<>(this); - } - - /** - * @param location The index to start the iterator. - * @return A list iterator from the {@link FlowCursorList#getAll()}. - * Be careful as this method will convert all data under this table into a list of {@link TModel} in the UI thread. - */ - @NonNull - @Override - public ListIterator listIterator(int location) { - return new FlowCursorIterator<>(this, location); - } - - /** - * Deletes a {@link TModel} at a specific position within the stored {@link Cursor}. - * If {@link #transact} is true, the delete does not happen immediately. Avoid using this operation - * many times. If you need to remove multiple, use {@link #removeAll(Collection)} - * - * @param location The location within the table to remove the item from - * @return The removed item. - */ - @Override - public TModel remove(int location) { - TModel model = internalCursorList.getItem(location); - - Transaction transaction = FlowManager.getDatabaseForTable(internalCursorList.table()) - .beginTransactionAsync(new ProcessModelTransaction.Builder<>(deleteModel) - .add(model).build()) - .error(internalErrorCallback) - .success(internalSuccessCallback).build(); - - if (transact) { - transaction.execute(); - } else { - transaction.executeSync(); - } - return model; - } - - /** - * Removes an item from this table on the {@link DefaultTransactionQueue} if - * {@link #transact} is true. - * - * @param object A model class. For interface purposes, this must be an Object. - * @return true if the item was removed. Always false if the object is not from the same table as this list. - */ - @SuppressWarnings("unchecked") - @Override - public boolean remove(Object object) { - boolean removed = false; - - // if its a ModelClass - if (internalCursorList.table().isAssignableFrom(object.getClass())) { - TModel model = ((TModel) object); - Transaction transaction = FlowManager.getDatabaseForTable(internalCursorList.table()) - .beginTransactionAsync(new ProcessModelTransaction.Builder<>(deleteModel) - .add(model).build()) - .error(internalErrorCallback) - .success(internalSuccessCallback).build(); - - if (transact) { - transaction.execute(); - } else { - transaction.executeSync(); - } - removed = true; - } - - return removed; - } - - /** - * Removes all items from this table in one transaction based on the list passed. This may happen in the background - * if {@link #transact} is true. - * - * @param collection The collection to remove. - * @return Always true. Will cause a {@link ClassCastException} if the collection is not of type {@link TModel} - */ - @SuppressWarnings("unchecked") - @Override - public boolean removeAll(@NonNull Collection collection) { - - // if its a ModelClass - Collection modelCollection = (Collection) collection; - Transaction transaction = FlowManager.getDatabaseForTable(internalCursorList.table()) - .beginTransactionAsync(new ProcessModelTransaction.Builder<>(deleteModel) - .addAll(modelCollection).build()) - .error(internalErrorCallback) - .success(internalSuccessCallback).build(); - - if (transact) { - transaction.execute(); - } else { - transaction.executeSync(); - } - - return true; - } - - /** - * Retrieves the full list of {@link TModel} items from the table, removes these from the list, and - * then deletes the remaining members. This is not that efficient. - * - * @param collection The collection if models to keep in the table. - * @return Always true. - */ - @Override - public boolean retainAll(@NonNull Collection collection) { - List tableList = internalCursorList.getAll(); - tableList.removeAll(collection); - Transaction transaction = FlowManager.getDatabaseForTable(internalCursorList.table()) - .beginTransactionAsync(new ProcessModelTransaction.Builder<>(tableList, deleteModel) - .build()) - .error(internalErrorCallback) - .success(internalSuccessCallback).build(); - - if (transact) { - transaction.execute(); - } else { - transaction.executeSync(); - } - return true; - } - - /** - * Will not use the index, rather just call a {@link Model#update()} - * - * @param location Not used. - * @param object The object to update - * @return the updated model. - */ - @Override - public TModel set(int location, TModel object) { - return set(object); - } - - /** - * Updates a Model {@link Model#update()} . If {@link #transact} - * is true, this update happens in the BG, otherwise it happens immediately. - * - * @param object The object to update - * @return The updated model. - */ - public TModel set(TModel object) { - Transaction transaction = FlowManager.getDatabaseForTable(internalCursorList.table()) - .beginTransactionAsync(new ProcessModelTransaction.Builder<>(updateModel) - .add(object) - .build()) - .error(internalErrorCallback) - .success(internalSuccessCallback).build(); - - if (transact) { - transaction.execute(); - } else { - transaction.executeSync(); - } - return object; - } - - @Override - public int size() { - return (int) internalCursorList.getCount(); - } - - @NonNull - @Override - public List subList(int start, int end) { - List tableList = internalCursorList.getAll(); - return tableList.subList(start, end); - } - - @NonNull - @Override - public Object[] toArray() { - List tableList = internalCursorList.getAll(); - return tableList.toArray(); - } - - @NonNull - @Override - public T[] toArray(T[] array) { - List tableList = internalCursorList.getAll(); - return tableList.toArray(array); - } - - @Override - public void close() { - internalCursorList.close(); - } - - private final ProcessModelTransaction.ProcessModel saveModel = - new ProcessModelTransaction.ProcessModel() { - @Override - public void processModel(TModel model, DatabaseWrapper wrapper) { - getModelAdapter().save(model); - } - }; - - private final ProcessModelTransaction.ProcessModel updateModel = - new ProcessModelTransaction.ProcessModel() { - @Override - public void processModel(TModel model, DatabaseWrapper wrapper) { - getModelAdapter().update(model); - } - }; - - private final ProcessModelTransaction.ProcessModel deleteModel = - new ProcessModelTransaction.ProcessModel() { - @Override - public void processModel(TModel model, DatabaseWrapper wrapper) { - getModelAdapter().delete(model); - } - }; - - private final Transaction.Error internalErrorCallback = new Transaction.Error() { - @Override - public void onError(@NonNull Transaction transaction, @NonNull Throwable error) { - - if (errorCallback != null) { - errorCallback.onError(transaction, error); - } - } - }; - - private final Transaction.Success internalSuccessCallback = new Transaction.Success() { - @Override - public void onSuccess(@NonNull Transaction transaction) { - if (!isInTransaction) { - refreshAsync(); - } else { - changeInTransaction = true; - } - - if (successCallback != null) { - successCallback.onSuccess(transaction); - } - } - }; - - private final Runnable refreshRunnable = new Runnable() { - @Override - public void run() { - synchronized (this) { - pendingRefresh = false; - } - refresh(); - } - }; - - public static class Builder { - - private final Class table; - - private boolean transact; - private boolean changeInTransaction; - private Cursor cursor; - private boolean cacheModels = true; - private ModelQueriable modelQueriable; - private ModelCache modelCache; - - private Transaction.Success success; - private Transaction.Error error; - - private Builder(FlowCursorList cursorList) { - table = cursorList.table(); - cursor = cursorList.cursor(); - cacheModels = cursorList.cachingEnabled(); - modelQueriable = cursorList.modelQueriable(); - modelCache = cursorList.modelCache(); - } - - public Builder(Class table) { - this.table = table; - } - - public Builder(@NonNull ModelQueriable modelQueriable) { - this(modelQueriable.getTable()); - modelQueriable(modelQueriable); - } - - public Builder cursor(Cursor cursor) { - this.cursor = cursor; - return this; - } - - public Builder modelQueriable(ModelQueriable modelQueriable) { - this.modelQueriable = modelQueriable; - return this; - } - - public Builder transact(boolean transact) { - this.transact = transact; - return this; - } - - public Builder modelCache(ModelCache modelCache) { - this.modelCache = modelCache; - return this; - } - - /** - * If true, when an operation occurs when we call endTransactionAndNotify, we refresh content. - */ - public Builder changeInTransaction(boolean changeInTransaction) { - this.changeInTransaction = changeInTransaction; - return this; - } - - public Builder cacheModels(boolean cacheModels) { - this.cacheModels = cacheModels; - return this; - } - - public Builder success(Transaction.Success success) { - this.success = success; - return this; - } - - public Builder error(Transaction.Error error) { - this.error = error; - return this; - } - - public FlowQueryList build() { - return new FlowQueryList<>(this); - } - } - - -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowQueryList.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowQueryList.kt new file mode 100644 index 000000000..1a4285c5a --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowQueryList.kt @@ -0,0 +1,307 @@ +package com.raizlabs.android.dbflow.list + +import android.annotation.TargetApi +import android.content.Context +import android.database.Cursor +import android.net.Uri +import android.os.Build +import android.os.Handler +import android.os.Looper +import com.raizlabs.android.dbflow.list.FlowCursorList.OnCursorRefreshListener +import com.raizlabs.android.dbflow.runtime.FlowContentObserver +import com.raizlabs.android.dbflow.sql.language.SQLite +import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable +import com.raizlabs.android.dbflow.structure.InstanceAdapter +import com.raizlabs.android.dbflow.structure.ModelAdapter +import com.raizlabs.android.dbflow.structure.database.transaction.DefaultTransactionQueue +import com.raizlabs.android.dbflow.structure.database.transaction.Transaction + +/** + * Description: Operates very similiar to a [java.util.List] except its backed by a table cursor. All of + * the [java.util.List] modifications default to the main thread, but it can be set to + * run on the [DefaultTransactionQueue]. Register a [Transaction.Success] + * on this list to know when the results complete. NOTE: any modifications to this list will be reflected + * on the underlying table. + */ +class FlowQueryList( + /** + * If true, we will make all modifications on the [DefaultTransactionQueue], else + * we will run it on the main thread. + */ + val transact: Boolean = false, + private var changeInTransaction: Boolean = false, + /** + * Holds the table cursor + */ + val internalCursorList: FlowCursorList) + : FlowContentObserver(), List, IFlowCursorIterator { + + private var pendingRefresh = false + + /** + * @return a mutable list that does not reflect changes on the underlying DB. + */ + val copy: List + get() = internalCursorList.all + + internal val modelAdapter: ModelAdapter + get() = internalCursorList.modelAdapter + + internal val instanceAdapter: InstanceAdapter + get() = internalCursorList.instanceAdapter + + override val count: Long + get() = internalCursorList.count + + fun changeInTransaction() = changeInTransaction + + private val refreshRunnable = object : Runnable { + override fun run() { + synchronized(this) { + pendingRefresh = false + } + refresh() + } + } + + internal constructor(builder: Builder) : this( + transact = builder.transact, + changeInTransaction = builder.changeInTransaction, + internalCursorList = FlowCursorList.Builder(builder.modelQueriable) + .cursor(builder.cursor) + .build() + ) + + /** + * Registers the list for model change events. Internally this refreshes the underlying [FlowCursorList]. Call + * [.beginTransaction] to bunch up calls to model changes and then [.endTransactionAndNotify] to dispatch + * and refresh this list when completed. + */ + fun registerForContentChanges(context: Context) { + super.registerForContentChanges(context, internalCursorList.table) + } + + fun addOnCursorRefreshListener(onCursorRefreshListener: OnCursorRefreshListener) { + internalCursorList.addOnCursorRefreshListener(onCursorRefreshListener) + } + + fun removeOnCursorRefreshListener(onCursorRefreshListener: OnCursorRefreshListener) { + internalCursorList.removeOnCursorRefreshListener(onCursorRefreshListener) + } + + override fun registerForContentChanges(context: Context, table: Class<*>) { + throw RuntimeException( + "This method is not to be used in the FlowQueryList. We should only ever receive" + + " notifications for one class here. Call registerForContentChanges(Context) instead") + } + + override fun onChange(selfChange: Boolean) { + super.onChange(selfChange) + if (!isInTransaction) { + refreshAsync() + } else { + changeInTransaction = true + } + } + + @TargetApi(Build.VERSION_CODES.JELLY_BEAN) + override fun onChange(selfChange: Boolean, uri: Uri) { + super.onChange(selfChange, uri) + if (!isInTransaction) { + refreshAsync() + } else { + changeInTransaction = true + } + } + + val cursorList: FlowCursorList + get() = internalCursorList + + /** + * @return Constructs a new [Builder] that reuses the underlying [Cursor], cache, + * callbacks, and other properties. + */ + fun newBuilder(): Builder { + return Builder(internalCursorList) + .changeInTransaction(changeInTransaction) + .transact(transact) + } + + /** + * Refreshes the content backing this list. + */ + fun refresh() { + internalCursorList.refresh() + } + + /** + * Will refresh content at a slightly later time, and multiple subsequent calls to this method within + * a short period of time will be combined into one call. + */ + fun refreshAsync() { + synchronized(this) { + if (pendingRefresh) { + return + } + pendingRefresh = true + } + REFRESH_HANDLER.post(refreshRunnable) + } + + override fun endTransactionAndNotify() { + if (changeInTransaction) { + changeInTransaction = false + refresh() + } + super.endTransactionAndNotify() + } + + /** + * Checks to see if the table contains the object only if its a [TModel] + * + * @param element A model class. For interface purposes, this must be an Object. + * @return always false if its anything other than the current table. True if [com.raizlabs.android.dbflow.structure.Model.exists] passes. + */ + override operator fun contains(element: TModel): Boolean { + return internalCursorList.instanceAdapter.exists(element) + } + + /** + * If the collection is null or empty, we return false. + * + * @param elements The collection to check if all exist within the table. + * @return true if all items exist in table, false if at least one fails. + */ + override fun containsAll(elements: Collection): Boolean { + var contains = !elements.isEmpty() + if (contains) { + contains = elements.all { it in this } + } + return contains + } + + override fun getItem(position: Long): TModel { + return internalCursorList.getItem(position) + } + + override fun cursor(): Cursor? { + return internalCursorList.cursor() + } + + /** + * Returns the item from the backing [FlowCursorList]. First call + * will load the model from the cursor, while subsequent calls will use the cache. + * + * @param index the row from the internal [FlowCursorList] query that we use. + * @return A model converted from the internal [FlowCursorList]. For + * performance improvements, ensure caching is turned on. + */ + override operator fun get(index: Int): TModel { + return internalCursorList.getItem(index.toLong()) + } + + override fun indexOf(element: TModel): Int { + throw UnsupportedOperationException( + "We cannot determine which index in the table this item exists at efficiently") + } + + override fun isEmpty(): Boolean { + return internalCursorList.isEmpty + } + + /** + * @return An iterator from [FlowCursorList.getAll]. + * Be careful as this method will convert all data under this table into a list of [TModel] in the UI thread. + */ + override fun iterator(): FlowCursorIterator { + return FlowCursorIterator(this) + } + + override fun iterator(startingLocation: Int, limit: Long): FlowCursorIterator { + return FlowCursorIterator(this, startingLocation, limit) + } + + override fun lastIndexOf(element: TModel): Int { + throw UnsupportedOperationException( + "We cannot determine which index in the table this item exists at efficiently") + } + + /** + * @return A list iterator from the [FlowCursorList.getAll]. + * Be careful as this method will convert all data under this table into a list of [TModel] in the UI thread. + */ + override fun listIterator(): ListIterator { + return FlowCursorIterator(this) + } + + /** + * @param location The index to start the iterator. + * @return A list iterator from the [FlowCursorList.getAll]. + * Be careful as this method will convert all data under this table into a list of [TModel] in the UI thread. + */ + override fun listIterator(location: Int): ListIterator { + return FlowCursorIterator(this, location) + } + + override val size: Int + get() = internalCursorList.count.toInt() + + override fun subList(fromIndex: Int, toIndex: Int): List { + val tableList = internalCursorList.all + return tableList.subList(fromIndex, toIndex) + } + + override fun close() { + internalCursorList.close() + } + + class Builder { + + internal val table: Class + + internal var transact: Boolean = false + internal var changeInTransaction: Boolean = false + internal var cursor: Cursor? = null + internal var modelQueriable: ModelQueriable + + internal constructor(cursorList: FlowCursorList) { + table = cursorList.table + cursor = cursorList.cursor() + modelQueriable = cursorList.modelQueriable + } + + constructor(table: Class) { + this.table = table + modelQueriable = SQLite.select().from(table) + } + + constructor(modelQueriable: ModelQueriable) { + this.table = modelQueriable.table + this.modelQueriable = modelQueriable + } + + fun cursor(cursor: Cursor) = apply { + this.cursor = cursor + } + + fun transact(transact: Boolean) = apply { + this.transact = transact + } + + /** + * If true, when an operation occurs when we call endTransactionAndNotify, we refresh content. + */ + fun changeInTransaction(changeInTransaction: Boolean) = apply { + this.changeInTransaction = changeInTransaction + } + + fun build() = FlowQueryList(this) + } + + companion object { + + private val REFRESH_HANDLER = Handler(Looper.myLooper()) + } + + +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/IFlowCursorIterator.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/list/IFlowCursorIterator.java deleted file mode 100644 index 31b890603..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/IFlowCursorIterator.java +++ /dev/null @@ -1,46 +0,0 @@ -package com.raizlabs.android.dbflow.list; - -import android.database.Cursor; -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import java.io.Closeable; -import java.io.IOException; - -/** - * Description: Simple interface that allows you to iterate a {@link Cursor}. - */ -public interface IFlowCursorIterator extends Closeable { - - /** - * @return Count of the {@link Cursor}. - */ - long getCount(); - - /** - * @param position The position within the {@link Cursor} to retrieve and convert into a {@link TModel} - */ - @Nullable - TModel getItem(long position); - - /** - * @return The cursor. - */ - @Nullable - Cursor cursor(); - - /** - * @return Can iterate the {@link Cursor}. - */ - @NonNull - FlowCursorIterator iterator(); - - /** - * @return Can iterate the {@link Cursor}. Specifies a starting location + count limit of results. - */ - @NonNull - FlowCursorIterator iterator(int startingLocation, long limit); - - @Override - void close() throws IOException; -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/IFlowCursorIterator.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/list/IFlowCursorIterator.kt new file mode 100644 index 000000000..505ffa690 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/list/IFlowCursorIterator.kt @@ -0,0 +1,37 @@ +package com.raizlabs.android.dbflow.list + +import android.database.Cursor + +import java.io.Closeable +import java.io.IOException + +/** + * Description: Simple interface that allows you to iterate a [Cursor]. + */ +interface IFlowCursorIterator : Closeable, Iterable { + + /** + * @return Count of the [Cursor]. + */ + val count: Long + + /** + * @param position The position within the [Cursor] to retrieve and convert into a [TModel] + */ + fun getItem(position: Long): TModel + + /** + * @return The cursor. + */ + fun cursor(): Cursor? + + override fun iterator(): FlowCursorIterator + + /** + * @return Can iterate the [Cursor]. Specifies a starting location + count limit of results. + */ + fun iterator(startingLocation: Int, limit: Long): FlowCursorIterator + + @Throws(IOException::class) + override fun close() +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/BaseTransactionManager.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/BaseTransactionManager.java index 49cdd0acd..ffdb2f7c1 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/BaseTransactionManager.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/BaseTransactionManager.java @@ -29,7 +29,7 @@ public DBBatchSaveQueue getSaveQueue() { saveQueue.start(); } } catch (IllegalThreadStateException i) { - FlowLog.INSTANCE.logError(i); // if queue is alive, will throw error. might occur in multithreading. + FlowLog.logError(i); // if queue is alive, will throw error. might occur in multithreading. } return saveQueue; } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DBBatchSaveQueue.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DBBatchSaveQueue.java index c155ce43c..db91ff429 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DBBatchSaveQueue.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DBBatchSaveQueue.java @@ -142,7 +142,7 @@ public void run() { //sleep, and then check for leftovers Thread.sleep(modelSaveCheckTime); } catch (InterruptedException e) { - FlowLog.log(FlowLog.INSTANCE.Level.I, "DBRequestQueue Batch interrupted to start saving"); + FlowLog.log(FlowLog.Level.I, "DBRequestQueue Batch interrupted to start saving"); } if (isQuitting) { diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseModelQueriable.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseModelQueriable.java index ab999dd7f..419c3f2a0 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseModelQueriable.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseModelQueriable.java @@ -57,7 +57,7 @@ public CursorResult queryResults() { @Override public List queryList() { String query = getQuery(); - FlowLog.log(FlowLog.INSTANCE.Level.V, "Executing query: " + query); + FlowLog.log(FlowLog.Level.V, "Executing query: " + query); return getListModelLoader().load(query); } @@ -65,14 +65,14 @@ public List queryList() { @Override public TModel querySingle() { String query = getQuery(); - FlowLog.log(FlowLog.INSTANCE.Level.V, "Executing query: " + query); + FlowLog.log(FlowLog.Level.V, "Executing query: " + query); return getSingleModelLoader().load(query); } @Override public TModel querySingle(@NonNull DatabaseWrapper wrapper) { String query = getQuery(); - FlowLog.log(FlowLog.INSTANCE.Level.V, "Executing query: " + query); + FlowLog.log(FlowLog.Level.V, "Executing query: " + query); return getSingleModelLoader().load(wrapper, query); } @@ -80,7 +80,7 @@ public TModel querySingle(@NonNull DatabaseWrapper wrapper) { @Override public List queryList(@NonNull DatabaseWrapper wrapper) { String query = getQuery(); - FlowLog.log(FlowLog.INSTANCE.Level.V, "Executing query: " + query); + FlowLog.log(FlowLog.Level.V, "Executing query: " + query); return getListModelLoader().load(wrapper, query); } @@ -127,7 +127,7 @@ public AsyncQuery async() { @Override public List queryCustomList(@NonNull Class queryModelClass) { String query = getQuery(); - FlowLog.log(FlowLog.INSTANCE.Level.V, "Executing query: " + query); + FlowLog.log(FlowLog.Level.V, "Executing query: " + query); QueryModelAdapter adapter = FlowManager.getQueryModelAdapter(queryModelClass); return cachingEnabled ? adapter.getListModelLoader().load(query) @@ -138,7 +138,7 @@ public List queryCustomList(@NonNull Class @Override public QueryClass queryCustomSingle(@NonNull Class queryModelClass) { String query = getQuery(); - FlowLog.log(FlowLog.INSTANCE.Level.V, "Executing query: " + query); + FlowLog.log(FlowLog.Level.V, "Executing query: " + query); QueryModelAdapter adapter = FlowManager.getQueryModelAdapter(queryModelClass); return cachingEnabled ? adapter.getSingleModelLoader().load(query) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseQueriable.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseQueriable.java index c2efa4ff9..6bb1fe29e 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseQueriable.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseQueriable.java @@ -67,11 +67,11 @@ public long longValue() { public long longValue(DatabaseWrapper databaseWrapper) { try { String query = getQuery(); - FlowLog.log(FlowLog.INSTANCE.Level.V, "Executing query: " + query); + FlowLog.log(FlowLog.Level.V, "Executing query: " + query); return SqlUtils.longForQuery(databaseWrapper, query); } catch (SQLiteDoneException sde) { // catch exception here, log it but return 0; - FlowLog.INSTANCE.log(FlowLog.INSTANCE.Level.W, sde); + FlowLog.logWarning(sde); } return 0; } @@ -101,7 +101,7 @@ public FlowCursor query(@NonNull DatabaseWrapper databaseWrapper) { databaseStatement.close(); } else { String query = getQuery(); - FlowLog.log(FlowLog.INSTANCE.Level.V, "Executing query: " + query); + FlowLog.log(FlowLog.Level.V, "Executing query: " + query); databaseWrapper.execSQL(query); } return null; @@ -149,7 +149,7 @@ public DatabaseStatement compileStatement() { @Override public DatabaseStatement compileStatement(@NonNull DatabaseWrapper databaseWrapper) { String query = getQuery(); - FlowLog.log(FlowLog.INSTANCE.Level.V, "Compiling Query Into Statement: " + query); + FlowLog.log(FlowLog.Level.V, "Compiling Query Into Statement: " + query); return new DatabaseStatementWrapper<>(databaseWrapper.compileStatement(query), this); } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Operator.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Operator.java index cea1082b7..6f1a0862d 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Operator.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Operator.java @@ -617,7 +617,7 @@ public String convertObjectToString(Object object, boolean appendInnerParenthesi converted = convertToDB ? typeConverter.getDBValue(object) : object; } catch (ClassCastException c) { // if object type is not valid converted type, just use type as is here. - FlowLog.INSTANCE.log(FlowLog.INSTANCE.Level.W, c); + FlowLog.log(FlowLog.Level.W, c); } return BaseOperator.convertValueToString(converted, appendInnerParenthesis, false); } else { diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/AutoIncrementModelSaver.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/AutoIncrementModelSaver.java index a8c887817..43d7c1dd6 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/AutoIncrementModelSaver.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/AutoIncrementModelSaver.java @@ -51,7 +51,7 @@ public synchronized long insert(@NonNull TModel model, if (!getModelAdapter().hasAutoIncrement(model)) { return super.insert(model, insertStatement, wrapper); } else { - FlowLog.log(FlowLog.INSTANCE.Level.W, "Ignoring insert statement " + insertStatement + " since an autoincrement column specified in the insert."); + FlowLog.log(FlowLog.Level.W, "Ignoring insert statement " + insertStatement + " since an autoincrement column specified in the insert."); return insert(model, wrapper); } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/SimpleMapCache.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/SimpleMapCache.java index 67e5f3dcb..59bbdeb5e 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/SimpleMapCache.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/SimpleMapCache.java @@ -54,7 +54,7 @@ public TModel get(@Nullable Object id) { @Override public void setCacheSize(int size) { - FlowLog.log(FlowLog.INSTANCE.Level.I, "The cache size for " + SimpleMapCache.class.getSimpleName() + + FlowLog.log(FlowLog.Level.I, "The cache size for " + SimpleMapCache.class.getSimpleName() + " is not re-configurable."); } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/SparseArrayBasedCache.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/SparseArrayBasedCache.java index d5024499a..4db00dca0 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/SparseArrayBasedCache.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/SparseArrayBasedCache.java @@ -66,7 +66,7 @@ public void clear() { @Override public void setCacheSize(int size) { - FlowLog.log(FlowLog.INSTANCE.Level.I, "The cache size for " + SparseArrayBasedCache.class.getSimpleName() + " is not re-configurable."); + FlowLog.log(FlowLog.Level.I, "The cache size for " + SparseArrayBasedCache.class.getSimpleName() + " is not re-configurable."); } @Override diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/BaseDatabaseHelper.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/BaseDatabaseHelper.java index 80bb3cc90..807056552 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/BaseDatabaseHelper.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/BaseDatabaseHelper.java @@ -71,7 +71,7 @@ public void onDowngrade(@NonNull DatabaseWrapper db, int oldVersion, int newVers protected void checkForeignKeySupport(@NonNull DatabaseWrapper database) { if (databaseDefinition.isForeignKeysSupported()) { database.execSQL("PRAGMA foreign_keys=ON;"); - FlowLog.log(FlowLog.INSTANCE.Level.I, "Foreign Keys supported. Enabling foreign key features."); + FlowLog.log(FlowLog.Level.I, "Foreign Keys supported. Enabling foreign key features."); } } @@ -84,7 +84,7 @@ protected void executeTableCreations(@NonNull final DatabaseWrapper database){ try { database.execSQL(modelAdapter.getCreationQuery()); } catch (SQLiteException e) { - FlowLog.INSTANCE.logError(e); + FlowLog.logError(e); } } } @@ -111,7 +111,7 @@ protected void executeViewCreations(@NonNull final DatabaseWrapper database){ try { database.execSQL(queryBuilder.getQuery()); } catch (SQLiteException e) { - FlowLog.INSTANCE.logError(e); + FlowLog.logError(e); } } database.setTransactionSuccessful(); @@ -140,7 +140,7 @@ protected void executeMigrations(@NonNull final DatabaseWrapper db, } fileList.add(file); } catch (NumberFormatException e) { - FlowLog.INSTANCE.log(FlowLog.INSTANCE.Level.W, "Skipping invalidly named file: " + file, e); + FlowLog.log(FlowLog.Level.W, "Skipping invalidly named file: " + file, e); } } @@ -157,7 +157,7 @@ protected void executeMigrations(@NonNull final DatabaseWrapper db, if (migrationFiles != null) { for (String migrationFile : migrationFiles) { executeSqlScript(db, migrationFile); - FlowLog.log(FlowLog.INSTANCE.Level.I, migrationFile + " executed successfully."); + FlowLog.log(FlowLog.Level.I, migrationFile + " executed successfully."); } } @@ -172,7 +172,7 @@ protected void executeMigrations(@NonNull final DatabaseWrapper db, // after migration cleanup migration.onPostMigrate(); - FlowLog.log(FlowLog.INSTANCE.Level.I, migration.getClass() + " executed successfully."); + FlowLog.log(FlowLog.Level.I, migration.getClass() + " executed successfully."); } } } @@ -181,7 +181,7 @@ protected void executeMigrations(@NonNull final DatabaseWrapper db, db.endTransaction(); } } catch (IOException e) { - FlowLog.INSTANCE.log(FlowLog.INSTANCE.Level.E, "Failed to execute migrations.", e); + FlowLog.log(FlowLog.Level.E, "Failed to execute migrations.", e); } } @@ -227,7 +227,7 @@ private void executeSqlScript(@NonNull DatabaseWrapper db, db.execSQL(queryString); } } catch (IOException e) { - FlowLog.INSTANCE.log(FlowLog.INSTANCE.Level.E, "Failed to execute " + file, e); + FlowLog.log(FlowLog.Level.E, "Failed to execute " + file, e); } } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseHelperDelegate.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseHelperDelegate.java index f3c888a78..edfb62be7 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseHelperDelegate.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseHelperDelegate.java @@ -138,7 +138,7 @@ && isDatabaseIntegrityOk(getWritableDatabase())))) { writeDB(dbPath, inputStream); } catch (IOException e) { - FlowLog.INSTANCE.log(FlowLog.INSTANCE.Level.W, "Failed to open file", e); + FlowLog.log(FlowLog.Level.W, "Failed to open file", e); } } @@ -169,7 +169,7 @@ public boolean isDatabaseIntegrityOk(DatabaseWrapper databaseWrapper) { String result = statement.simpleQueryForString(); if (!result.equalsIgnoreCase("ok")) { // integrity_checker failed on main or attached databases - FlowLog.log(FlowLog.INSTANCE.Level.E, "PRAGMA integrity_check on " + + FlowLog.log(FlowLog.Level.E, "PRAGMA integrity_check on " + getDatabaseDefinition().getDatabaseName() + " returned: " + result); integrityOk = false; @@ -199,11 +199,11 @@ public boolean restoreBackUp() { try { writeDB(corrupt, new FileInputStream(db)); } catch (IOException e) { - FlowLog.INSTANCE.logError(e); + FlowLog.logError(e); success = false; } } else { - FlowLog.log(FlowLog.INSTANCE.Level.E, "Failed to delete DB"); + FlowLog.log(FlowLog.Level.E, "Failed to delete DB"); } return success; } @@ -262,7 +262,7 @@ public void restoreDatabase(String databaseName, String prepackagedName) { } writeDB(dbPath, inputStream); } catch (IOException e) { - FlowLog.INSTANCE.logError(e); + FlowLog.logError(e); } } @@ -302,7 +302,7 @@ public void execute(DatabaseWrapper databaseWrapper) { temp.delete(); } catch (Exception e) { - FlowLog.INSTANCE.logError(e); + FlowLog.logError(e); } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/DefaultTransactionQueue.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/DefaultTransactionQueue.java index dd395b98b..75503e926 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/DefaultTransactionQueue.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/DefaultTransactionQueue.java @@ -105,7 +105,7 @@ public void startIfNotAlive() { start(); } catch (IllegalThreadStateException i) { // log if failure from thread is still alive. - FlowLog.INSTANCE.log(FlowLog.INSTANCE.Level.E, i); + FlowLog.log(FlowLog.Level.E, i); } } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/PriorityTransactionQueue.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/PriorityTransactionQueue.java index 1b573fe87..280e5e431 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/PriorityTransactionQueue.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/PriorityTransactionQueue.java @@ -102,7 +102,7 @@ public void startIfNotAlive() { start(); } catch (IllegalThreadStateException i) { // log if failure from thread is still alive. - FlowLog.INSTANCE.log(FlowLog.INSTANCE.Level.E, i); + FlowLog.log(FlowLog.Level.E, i); } } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Transaction.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Transaction.java index e42fd13a1..5f5a4bd64 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Transaction.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Transaction.java @@ -135,7 +135,7 @@ public void run() { } } } catch (final Throwable throwable) { - FlowLog.INSTANCE.logError(throwable); + FlowLog.logError(throwable); if (errorCallback != null) { if (runCallbacksOnSameThread) { errorCallback.onError(this, throwable); diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/ContentUtils.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/ContentUtils.java index 187e41f98..31902791e 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/ContentUtils.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/ContentUtils.java @@ -155,7 +155,7 @@ public static int update(ContentResolver contentResolver, Uri updat adapter.bindToContentValues(contentValues, model); int count = contentResolver.update(updateUri, contentValues, adapter.getPrimaryConditionClause(model).getQuery(), null); if (count == 0) { - FlowLog.log(FlowLog.INSTANCE.Level.W, "Updated failed of: " + model.getClass()); + FlowLog.log(FlowLog.Level.W, "Updated failed of: " + model.getClass()); } return count; } @@ -192,7 +192,7 @@ public static int delete(ContentResolver contentResolver, Uri delet if (count > 0) { adapter.updateAutoIncrement(model, 0); } else { - FlowLog.log(FlowLog.INSTANCE.Level.W, "A delete on " + model.getClass() + " within the ContentResolver appeared to fail."); + FlowLog.log(FlowLog.Level.W, "A delete on " + model.getClass() + " within the ContentResolver appeared to fail."); } return count; } From c82c9b05d9febcac095da433274ffb25f9c141bc Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sun, 22 Oct 2017 21:49:08 -0400 Subject: [PATCH 052/234] [5.0] convert more dbflow packages to kotlin. --- .../dbflow/sql/{Query.java => Query.kt} | 6 +- .../android/dbflow/sql/QueryBuilder.java | 58 +- .../language/TableChangeListenerEmitter.java | 4 +- .../rx2/language/TableChangeOnSubscribe.java | 4 +- .../dbflow/config/DatabaseDefinition.kt | 7 +- .../runtime/BaseTransactionManager.java | 73 --- .../dbflow/runtime/BaseTransactionManager.kt | 55 ++ .../runtime/ContentResolverNotifier.java | 88 --- .../dbflow/runtime/ContentResolverNotifier.kt | 74 +++ .../dbflow/runtime/DBBatchSaveQueue.java | 268 --------- .../dbflow/runtime/DBBatchSaveQueue.kt | 240 ++++++++ .../dbflow/runtime/DirectModelNotifier.java | 187 ------ .../dbflow/runtime/DirectModelNotifier.kt | 147 +++++ .../android/dbflow/runtime/ModelNotifier.java | 19 - .../android/dbflow/runtime/ModelNotifier.kt | 16 + .../dbflow/runtime/NotifyDistributor.java | 46 -- .../dbflow/runtime/NotifyDistributor.kt | 38 ++ .../runtime/OnTableChangedListener.java | 22 - .../dbflow/runtime/OnTableChangedListener.kt | 20 + .../dbflow/runtime/TableNotifierRegister.java | 20 - .../dbflow/runtime/TableNotifierRegister.kt | 17 + .../android/dbflow/sql/BaseAsyncObject.java | 99 ---- .../android/dbflow/sql/BaseAsyncObject.kt | 66 +++ .../raizlabs/android/dbflow/sql/SqlUtils.java | 4 +- .../dbflow/sql/language/Actionable.java | 14 - .../android/dbflow/sql/language/Actionable.kt | 11 + .../sql/language/BaseModelQueriable.java | 2 +- .../dbflow/sql/language/BaseQueriable.java | 4 +- .../dbflow/sql/language/IConditional.java | 131 ----- .../dbflow/sql/language/IConditional.kt | 90 +++ .../dbflow/sql/language/IOperator.java | 187 ------ .../android/dbflow/sql/language/IOperator.kt | 162 ++++++ .../android/dbflow/sql/language/Join.java | 2 +- .../android/dbflow/sql/language/Method.java | 28 +- .../{SQLOperator.java => SQLOperator.kt} | 32 +- .../android/dbflow/sql/language/Select.java | 2 +- .../dbflow/sql/language/WhereBase.java | 24 - .../android/dbflow/sql/language/WhereBase.kt | 20 + .../sql/language/property/IndexProperty.java | 49 -- .../sql/language/property/IndexProperty.kt | 42 ++ .../sql/language/property/Property.java | 539 ------------------ .../dbflow/sql/language/property/Property.kt | 286 ++++++++++ .../language/property/PropertyFactory.java | 142 ----- .../sql/language/property/PropertyFactory.kt | 139 +++++ .../property/TypeConvertedProperty.java | 84 --- .../property/TypeConvertedProperty.kt | 72 +++ .../language/property/WrapperProperty.java | 36 -- .../sql/language/property/WrapperProperty.kt | 28 + .../sql/migration/AlterTableMigration.java | 192 ------- .../sql/migration/AlterTableMigration.kt | 143 +++++ .../dbflow/sql/migration/BaseMigration.java | 26 - .../dbflow/sql/migration/BaseMigration.kt | 21 + .../dbflow/sql/migration/IndexMigration.java | 91 --- .../dbflow/sql/migration/IndexMigration.kt | 52 ++ .../sql/migration/IndexPropertyMigration.java | 31 - .../sql/migration/IndexPropertyMigration.kt | 24 + .../{Migration.java => Migration.kt} | 18 +- .../sql/migration/UpdateTableMigration.java | 92 --- .../sql/migration/UpdateTableMigration.kt | 58 ++ .../dbflow/sql/queriable/AsyncQuery.java | 73 --- .../dbflow/sql/queriable/AsyncQuery.kt | 60 ++ .../queriable/CacheableListModelLoader.java | 80 --- .../sql/queriable/CacheableListModelLoader.kt | 51 ++ .../sql/queriable/CacheableModelLoader.java | 77 --- .../sql/queriable/CacheableModelLoader.kt | 52 ++ .../dbflow/sql/queriable/ListModelLoader.java | 83 --- .../dbflow/sql/queriable/ListModelLoader.kt | 38 ++ .../dbflow/sql/queriable/ModelLoader.java | 110 ---- .../dbflow/sql/queriable/ModelLoader.kt | 67 +++ .../dbflow/sql/queriable/ModelQueriable.java | 110 ---- .../dbflow/sql/queriable/ModelQueriable.kt | 94 +++ .../dbflow/sql/queriable/Queriable.java | 127 ----- .../android/dbflow/sql/queriable/Queriable.kt | 117 ++++ .../SingleKeyCacheableListModelLoader.java | 47 -- .../SingleKeyCacheableListModelLoader.kt | 32 ++ .../SingleKeyCacheableModelLoader.java | 48 -- .../SingleKeyCacheableModelLoader.kt | 37 ++ .../sql/queriable/SingleModelLoader.java | 34 -- .../dbflow/sql/queriable/SingleModelLoader.kt | 26 + .../dbflow/sql/queriable/StringQuery.java | 68 --- .../dbflow/sql/queriable/StringQuery.kt | 51 ++ .../sql/saveable/AutoIncrementModelSaver.java | 2 +- .../dbflow/sql/saveable/ModelSaver.java | 12 +- .../database/DatabaseStatementWrapper.java | 4 +- 84 files changed, 2531 insertions(+), 3421 deletions(-) rename dbflow-core/src/main/java/com/raizlabs/android/dbflow/sql/{Query.java => Query.kt} (62%) delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/BaseTransactionManager.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/BaseTransactionManager.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ContentResolverNotifier.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ContentResolverNotifier.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DBBatchSaveQueue.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DBBatchSaveQueue.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DirectModelNotifier.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DirectModelNotifier.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ModelNotifier.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ModelNotifier.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/NotifyDistributor.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/NotifyDistributor.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/OnTableChangedListener.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/OnTableChangedListener.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/TableNotifierRegister.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/TableNotifierRegister.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/BaseAsyncObject.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/BaseAsyncObject.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Actionable.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Actionable.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IConditional.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IConditional.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IOperator.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IOperator.kt rename dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/{SQLOperator.java => SQLOperator.kt} (50%) delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/WhereBase.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/WhereBase.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/IndexProperty.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/IndexProperty.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/Property.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/Property.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/PropertyFactory.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/PropertyFactory.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/TypeConvertedProperty.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/TypeConvertedProperty.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/WrapperProperty.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/WrapperProperty.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/AlterTableMigration.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/AlterTableMigration.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/BaseMigration.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/BaseMigration.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/IndexMigration.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/IndexMigration.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/IndexPropertyMigration.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/IndexPropertyMigration.kt rename dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/{Migration.java => Migration.kt} (58%) delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/UpdateTableMigration.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/UpdateTableMigration.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/AsyncQuery.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/AsyncQuery.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/CacheableListModelLoader.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/CacheableListModelLoader.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/CacheableModelLoader.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/CacheableModelLoader.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ListModelLoader.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ListModelLoader.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ModelLoader.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ModelLoader.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ModelQueriable.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ModelQueriable.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/Queriable.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/Queriable.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleKeyCacheableListModelLoader.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleKeyCacheableListModelLoader.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleKeyCacheableModelLoader.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleKeyCacheableModelLoader.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleModelLoader.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleModelLoader.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/StringQuery.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/StringQuery.kt diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/sql/Query.java b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/sql/Query.kt similarity index 62% rename from dbflow-core/src/main/java/com/raizlabs/android/dbflow/sql/Query.java rename to dbflow-core/src/main/java/com/raizlabs/android/dbflow/sql/Query.kt index 93c0f0dc1..f41e4732e 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/sql/Query.java +++ b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/sql/Query.kt @@ -1,12 +1,12 @@ -package com.raizlabs.android.dbflow.sql; +package com.raizlabs.android.dbflow.sql /** * Description: The basic interface for something that has a piece of a query. */ -public interface Query { +interface Query { /** * @return the SQL query statement here */ - String getQuery(); + val query: String } diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/sql/QueryBuilder.java b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/sql/QueryBuilder.java index ec85bbed2..47e5856a5 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/sql/QueryBuilder.java +++ b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/sql/QueryBuilder.java @@ -7,7 +7,7 @@ * Description: This is used as a wrapper around {@link StringBuilder} in order to provide more * database focused methods and to assist in generating queries to the DB using our SQL wrappers. */ -public class QueryBuilder implements Query { +public class QueryBuilder implements Query { private static final char QUOTE = '`'; @@ -39,7 +39,7 @@ public QueryBuilder(Object object) { * * @return This instance */ - public QueryClass appendSpace() { + public QueryBuilder appendSpace() { return append(" "); } @@ -50,8 +50,8 @@ public QueryClass appendSpace() { * @return This instance */ @SuppressWarnings("unchecked") - public QueryClass appendSpaceSeparated(Object object) { - return (QueryClass) appendSpace().append(object).appendSpace(); + public QueryBuilder appendSpaceSeparated(Object object) { + return appendSpace().append(object).appendSpace(); } /** @@ -61,8 +61,8 @@ public QueryClass appendSpaceSeparated(Object object) { * @return This instance */ @SuppressWarnings("unchecked") - public QueryClass appendParenthesisEnclosed(Object string) { - return (QueryClass) append("(").append(string).append(")"); + public QueryBuilder appendParenthesisEnclosed(Object string) { + return append("(").append(string).append(")"); } /** @@ -71,9 +71,9 @@ public QueryClass appendParenthesisEnclosed(Object string) { * @param object The object to append * @return This instance */ - public QueryClass append(Object object) { + public QueryBuilder append(Object object) { query.append(object); - return castThis(); + return this; } /** @@ -82,21 +82,11 @@ public QueryClass append(Object object) { * @param object If not null, its string representation. * @return This instance */ - public QueryClass appendOptional(Object object) { + public QueryBuilder appendOptional(Object object) { if (object != null) { append(object); } - return castThis(); - } - - /** - * Casts the current object to the {@link QueryClass} - * - * @return This casted instance - */ - @SuppressWarnings("unchecked") - protected QueryClass castThis() { - return (QueryClass) this; + return this; } /** @@ -106,7 +96,7 @@ protected QueryClass castThis() { * @param type The Class to look up from {@link SQLiteType} * @return This instance */ - public QueryClass appendType(String type) { + public QueryBuilder appendType(String type) { return appendSQLiteType(SQLiteType.get(type)); } @@ -116,7 +106,7 @@ public QueryClass appendType(String type) { * @param sqLiteType The {@link SQLiteType} to append * @return This instance */ - public QueryClass appendSQLiteType(SQLiteType sqLiteType) { + public QueryBuilder appendSQLiteType(SQLiteType sqLiteType) { return append(sqLiteType.name()); } @@ -127,7 +117,7 @@ public QueryClass appendSQLiteType(SQLiteType sqLiteType) { * @param objects The array of objects to pass in * @return This instance */ - public QueryClass appendArray(Object... objects) { + public QueryBuilder appendArray(Object... objects) { return append(join(", ", objects)); } @@ -138,7 +128,7 @@ public QueryClass appendArray(Object... objects) { * @param objects The list of objects to pass in * @return This instance */ - public QueryClass appendList(List objects) { + public QueryBuilder appendList(List objects) { return append(join(", ", objects)); } @@ -149,14 +139,14 @@ public QueryClass appendList(List objects) { * @param value The value to append after the name * @return This instance */ - public QueryClass appendQualifier(String name, String value) { + public QueryBuilder appendQualifier(String name, String value) { if (value != null && value.length() > 0) { if (name != null) { append(name); } appendSpaceSeparated(value); } - return castThis(); + return this; } /** @@ -165,11 +155,11 @@ public QueryClass appendQualifier(String name, String value) { * @param string The string to append * @return This instance */ - public QueryClass appendNotEmpty(String string) { + public QueryBuilder appendNotEmpty(String string) { if (string != null && !string.isEmpty()) { append(string); } - return castThis(); + return this; } /** @@ -179,12 +169,12 @@ public QueryClass appendNotEmpty(String string) { * @return This instance */ @SuppressWarnings("unchecked") - public QueryClass appendQuoted(String string) { + public QueryBuilder appendQuoted(String string) { if (string.equals("*")) return append(string); append(quote(string)); - return castThis(); + return this; } /** @@ -194,12 +184,12 @@ public QueryClass appendQuoted(String string) { * @return This instance */ @SuppressWarnings("unchecked") - public QueryClass appendQuotedIfNeeded(String string) { + public QueryBuilder appendQuotedIfNeeded(String string) { if (string.equals("*")) return append(string); append(quoteIfNeeded(string)); - return castThis(); + return this; } /** @@ -210,7 +200,7 @@ public QueryClass appendQuotedIfNeeded(String string) { * @return This instance */ @SuppressWarnings("unchecked") - public QueryClass appendQuotedList(List objects) { + public QueryBuilder appendQuotedList(List objects) { return appendQuoted(join("`, `", objects)); } @@ -221,7 +211,7 @@ public QueryClass appendQuotedList(List objects) { * @param objects The array of objects to pass in * @return This instance */ - public QueryClass appendQuotedArray(Object... objects) { + public QueryBuilder appendQuotedArray(Object... objects) { return appendQuoted(join("`, `", objects)); } diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/TableChangeListenerEmitter.java b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/TableChangeListenerEmitter.java index 3dcc48bd1..a2ed536b8 100644 --- a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/TableChangeListenerEmitter.java +++ b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/TableChangeListenerEmitter.java @@ -80,8 +80,8 @@ public boolean isUnsubscribed() { private final OnTableChangedListener onTableChangedListener = new OnTableChangedListener() { @Override - public void onTableChanged(@Nullable Class tableChanged, @NonNull BaseModel.Action action) { - if (modelQueriable.getTable().equals(tableChanged)) { + public void onTableChanged(@Nullable Class table, @NonNull BaseModel.Action action) { + if (modelQueriable.getTable().equals(table)) { modelQueriableEmitter.onNext(modelQueriable); } } diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/TableChangeOnSubscribe.java b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/TableChangeOnSubscribe.java index e98a0288d..63c127fde 100644 --- a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/TableChangeOnSubscribe.java +++ b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/TableChangeOnSubscribe.java @@ -68,8 +68,8 @@ public void run() { private final OnTableChangedListener onTableChangedListener = new OnTableChangedListener() { @Override - public void onTableChanged(@Nullable Class tableChanged, @NonNull BaseModel.Action action) { - if (modelQueriable.getTable().equals(tableChanged)) { + public void onTableChanged(@Nullable Class table, @NonNull BaseModel.Action action) { + if (modelQueriable.getTable().equals(table)) { flowableEmitter.onNext(modelQueriable); } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.kt index 00ecd5945..7d889a796 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.kt @@ -77,7 +77,7 @@ abstract class DatabaseDefinition { * creating model views in the DB. */ val modelViewAdapters: List> - get() = ArrayList(modelViewAdapterMap.values) + get() = modelViewAdapterMap.values.toList() /** * @return The list of [QueryModelAdapter]. Internal method for creating query models in the DB. @@ -94,7 +94,7 @@ abstract class DatabaseDefinition { val helper: OpenHelper @Synchronized get() { if (openHelper == null) { - val config = FlowManager.getConfig().getDatabaseConfigMap()[associatedDatabaseClassFile] + val config = FlowManager.getConfig().databaseConfigMap[associatedDatabaseClassFile] openHelper = if (config?.openHelperCreator != null) { config.openHelperCreator.invoke(this, helperListener) } else { @@ -155,7 +155,8 @@ abstract class DatabaseDefinition { get() = helper.isDatabaseIntegrityOk init { - applyDatabaseConfig(FlowManager.getConfig().getDatabaseConfigMap()[associatedDatabaseClassFile]) + @Suppress("LeakingThis") + applyDatabaseConfig(FlowManager.getConfig().databaseConfigMap[associatedDatabaseClassFile]) } /** diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/BaseTransactionManager.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/BaseTransactionManager.java deleted file mode 100644 index ffdb2f7c1..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/BaseTransactionManager.java +++ /dev/null @@ -1,73 +0,0 @@ -package com.raizlabs.android.dbflow.runtime; - -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.config.DatabaseDefinition; -import com.raizlabs.android.dbflow.config.FlowLog; -import com.raizlabs.android.dbflow.structure.database.transaction.ITransactionQueue; -import com.raizlabs.android.dbflow.structure.database.transaction.Transaction; - -/** - * Description: The base implementation of Transaction manager. - */ -public abstract class BaseTransactionManager { - - private final ITransactionQueue transactionQueue; - private DBBatchSaveQueue saveQueue; - - public BaseTransactionManager(@NonNull ITransactionQueue transactionQueue, - @NonNull DatabaseDefinition databaseDefinition) { - this.transactionQueue = transactionQueue; - saveQueue = new DBBatchSaveQueue(databaseDefinition); - checkQueue(); - } - - @NonNull - public DBBatchSaveQueue getSaveQueue() { - try { - if (!saveQueue.isAlive()) { - saveQueue.start(); - } - } catch (IllegalThreadStateException i) { - FlowLog.logError(i); // if queue is alive, will throw error. might occur in multithreading. - } - return saveQueue; - } - - @NonNull - public ITransactionQueue getQueue() { - return transactionQueue; - } - - /** - * Checks if queue is running. If not, should be started here. - */ - public void checkQueue() { - getQueue().startIfNotAlive(); - } - - /** - * Stops the queue this manager contains. - */ - public void stopQueue() { - getQueue().quit(); - } - - /** - * Adds a transaction to the {@link ITransactionQueue}. - * - * @param transaction The transaction to add. - */ - public void addTransaction(@NonNull Transaction transaction) { - getQueue().add(transaction); - } - - /** - * Cancels a transaction on the {@link ITransactionQueue}. - * - * @param transaction - */ - public void cancelTransaction(@NonNull Transaction transaction) { - getQueue().cancel(transaction); - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/BaseTransactionManager.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/BaseTransactionManager.kt new file mode 100644 index 000000000..cfcadaf51 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/BaseTransactionManager.kt @@ -0,0 +1,55 @@ +package com.raizlabs.android.dbflow.runtime + +import com.raizlabs.android.dbflow.config.DatabaseDefinition +import com.raizlabs.android.dbflow.config.FlowLog +import com.raizlabs.android.dbflow.structure.database.transaction.ITransactionQueue +import com.raizlabs.android.dbflow.structure.database.transaction.Transaction + +/** + * Description: The base implementation of Transaction manager. + */ +abstract class BaseTransactionManager(val queue: ITransactionQueue, + databaseDefinition: DatabaseDefinition) { + + private val saveQueue: DBBatchSaveQueue = DBBatchSaveQueue(databaseDefinition) + + init { + checkQueue() + } + + fun getSaveQueue(): DBBatchSaveQueue { + try { + if (!saveQueue.isAlive) { + saveQueue.start() + } + } catch (i: IllegalThreadStateException) { + FlowLog.logError(i) // if queue is alive, will throw error. might occur in multithreading. + } + + return saveQueue + } + + /** + * Checks if queue is running. If not, should be started here. + */ + fun checkQueue() = queue.startIfNotAlive() + + /** + * Stops the queue this manager contains. + */ + fun stopQueue() = queue.quit() + + /** + * Adds a transaction to the [ITransactionQueue]. + * + * @param transaction The transaction to add. + */ + fun addTransaction(transaction: Transaction) = queue.add(transaction) + + /** + * Cancels a transaction on the [ITransactionQueue]. + * + * @param transaction + */ + fun cancelTransaction(transaction: Transaction) = queue.cancel(transaction) +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ContentResolverNotifier.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ContentResolverNotifier.java deleted file mode 100644 index 8adc6d539..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ContentResolverNotifier.java +++ /dev/null @@ -1,88 +0,0 @@ -package com.raizlabs.android.dbflow.runtime; - -import android.content.ContentResolver; -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.config.FlowManager; -import com.raizlabs.android.dbflow.sql.SqlUtils; -import com.raizlabs.android.dbflow.sql.language.SQLOperator; -import com.raizlabs.android.dbflow.structure.BaseModel; -import com.raizlabs.android.dbflow.structure.ModelAdapter; - -/** - * The default use case, it notifies via the {@link ContentResolver} system. - */ -public class ContentResolverNotifier implements ModelNotifier { - @Override - public void notifyModelChanged(@NonNull T model, @NonNull ModelAdapter adapter, - @NonNull BaseModel.Action action) { - if (FlowContentObserver.shouldNotify()) { - FlowManager.getContext().getContentResolver() - .notifyChange(SqlUtils.getNotificationUri(adapter.getModelClass(), action, - adapter.getPrimaryConditionClause(model).getConditions()), null, true); - } - } - - @Override - public void notifyTableChanged(@NonNull Class table, @NonNull BaseModel.Action action) { - if (FlowContentObserver.shouldNotify()) { - FlowManager.getContext().getContentResolver() - .notifyChange(SqlUtils.getNotificationUri(table, action, (SQLOperator[]) null), null, true); - } - } - - @Override - public TableNotifierRegister newRegister() { - return new FlowContentTableNotifierRegister(); - } - - public static class FlowContentTableNotifierRegister implements TableNotifierRegister { - - private final FlowContentObserver flowContentObserver = new FlowContentObserver(); - - @Nullable - private OnTableChangedListener tableChangedListener; - - public FlowContentTableNotifierRegister() { - flowContentObserver.addOnTableChangedListener(internalContentChangeListener); - } - - @Override - public void register(@NonNull Class tClass) { - flowContentObserver.registerForContentChanges(FlowManager.getContext(), tClass); - } - - @Override - public void unregister(@NonNull Class tClass) { - flowContentObserver.unregisterForContentChanges(FlowManager.getContext()); - } - - @Override - public void unregisterAll() { - flowContentObserver.removeTableChangedListener(internalContentChangeListener); - this.tableChangedListener = null; - } - - @Override - public void setListener(@Nullable OnTableChangedListener contentChangeListener) { - this.tableChangedListener = contentChangeListener; - } - - @Override - public boolean isSubscribed() { - return !flowContentObserver.isSubscribed(); - } - - private final OnTableChangedListener internalContentChangeListener - = new OnTableChangedListener() { - - @Override - public void onTableChanged(@Nullable Class tableChanged, @NonNull BaseModel.Action action) { - if (tableChangedListener != null) { - tableChangedListener.onTableChanged(tableChanged, action); - } - } - }; - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ContentResolverNotifier.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ContentResolverNotifier.kt new file mode 100644 index 000000000..4ae848c17 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ContentResolverNotifier.kt @@ -0,0 +1,74 @@ +package com.raizlabs.android.dbflow.runtime + +import android.content.ContentResolver + +import com.raizlabs.android.dbflow.config.FlowManager +import com.raizlabs.android.dbflow.sql.SqlUtils +import com.raizlabs.android.dbflow.sql.language.SQLOperator +import com.raizlabs.android.dbflow.structure.BaseModel +import com.raizlabs.android.dbflow.structure.ModelAdapter + +/** + * The default use case, it notifies via the [ContentResolver] system. + */ +class ContentResolverNotifier : ModelNotifier { + + override fun notifyModelChanged(model: T, adapter: ModelAdapter, + action: BaseModel.Action) { + if (FlowContentObserver.shouldNotify()) { + FlowManager.context.contentResolver + .notifyChange(SqlUtils.getNotificationUri(adapter.modelClass, action, + adapter.getPrimaryConditionClause(model).conditions), null, true) + } + } + + override fun notifyTableChanged(table: Class, action: BaseModel.Action) { + if (FlowContentObserver.shouldNotify()) { + FlowManager.context.contentResolver + .notifyChange(SqlUtils.getNotificationUri(table, action, + null as Array?), null, true) + } + } + + override fun newRegister(): TableNotifierRegister { + return FlowContentTableNotifierRegister() + } + + class FlowContentTableNotifierRegister : TableNotifierRegister { + + private val flowContentObserver = FlowContentObserver() + + private var tableChangedListener: OnTableChangedListener? = null + + private val internalContentChangeListener = OnTableChangedListener { tableChanged, action -> + if (tableChangedListener != null) { + tableChangedListener!!.onTableChanged(tableChanged, action) + } + } + + init { + flowContentObserver.addOnTableChangedListener(internalContentChangeListener) + } + + override fun register(tClass: Class) { + flowContentObserver.registerForContentChanges(FlowManager.context, tClass) + } + + override fun unregister(tClass: Class) { + flowContentObserver.unregisterForContentChanges(FlowManager.context) + } + + override fun unregisterAll() { + flowContentObserver.removeTableChangedListener(internalContentChangeListener) + this.tableChangedListener = null + } + + override fun setListener(contentChangeListener: OnTableChangedListener?) { + this.tableChangedListener = contentChangeListener + } + + override fun isSubscribed(): Boolean { + return !flowContentObserver.isSubscribed + } + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DBBatchSaveQueue.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DBBatchSaveQueue.java deleted file mode 100644 index db91ff429..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DBBatchSaveQueue.java +++ /dev/null @@ -1,268 +0,0 @@ -package com.raizlabs.android.dbflow.runtime; - -import android.os.Looper; -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.config.DatabaseDefinition; -import com.raizlabs.android.dbflow.config.FlowLog; -import com.raizlabs.android.dbflow.config.FlowManager; -import com.raizlabs.android.dbflow.structure.Model; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; -import com.raizlabs.android.dbflow.structure.database.transaction.ProcessModelTransaction; -import com.raizlabs.android.dbflow.structure.database.transaction.Transaction; - -import java.util.ArrayList; -import java.util.Collection; - -/** - * Description: This queue will bulk save items added to it when it gets access to the DB. It should only exist as one entity. - * It will save the {@link #MODEL_SAVE_SIZE} at a time or more only when the limit is reached. It will not - */ -public class DBBatchSaveQueue extends Thread { - - /** - * Once the queue size reaches 50 or larger, the thread will be interrupted and we will batch save the models. - */ - private static final int MODEL_SAVE_SIZE = 50; - - /** - * The default time that it will awake the save queue thread to check if any models are still waiting to be saved - */ - private static final int sMODEL_SAVE_CHECK_TIME = 30000; - - /** - * Tells how many items to save at a time. This can be set using {@link #setModelSaveSize(int)} - */ - private int modelSaveSize = MODEL_SAVE_SIZE; - - /** - * Sets the time we check periodically for leftover DB objects in our queue to save. - */ - private long modelSaveCheckTime = sMODEL_SAVE_CHECK_TIME; - - /** - * The list of DB objects that we will save here - */ - private final ArrayList models; - - /** - * If true, this queue will quit. - */ - private boolean isQuitting = false; - - private Transaction.Error errorListener; - private Transaction.Success successListener; - private Runnable emptyTransactionListener; - - private DatabaseDefinition databaseDefinition; - - /** - * Creates a new instance of this class to batch save DB object classes. - */ - DBBatchSaveQueue(DatabaseDefinition databaseDefinition) { - super("DBBatchSaveQueue"); - this.databaseDefinition = databaseDefinition; - models = new ArrayList<>(); - } - - /** - * Sets how many models to save at a time in this queue. - * Increase it for larger batches, but slower recovery time. - * Smaller the batch, the more time it takes to save overall. - */ - public void setModelSaveSize(int mModelSaveSize) { - this.modelSaveSize = mModelSaveSize; - } - - /** - * Sets how long, in millis that this queue will check for leftover DB objects that have not been saved yet. - * The default is {@link #sMODEL_SAVE_CHECK_TIME} - * - * @param time The time, in millis that queue automatically checks for leftover DB objects in this queue. - */ - public void setModelSaveCheckTime(long time) { - this.modelSaveCheckTime = time; - } - - - /** - * Listener for errors in each batch {@link Transaction}. Called from the DBBatchSaveQueue thread. - * - * @param errorListener The listener to use. - */ - public void setErrorListener(@Nullable Transaction.Error errorListener) { - this.errorListener = errorListener; - } - - /** - * Listener for batch updates. Called from the DBBatchSaveQueue thread. - * - * @param successListener The listener to get notified when changes are successful. - */ - public void setSuccessListener(@Nullable Transaction.Success successListener) { - this.successListener = successListener; - } - - /** - * Listener for when there is no work done. Called from the DBBatchSaveQueue thread. - * - * @param emptyTransactionListener The listener to get notified when the save queue thread ran but was empty. - */ - public void setEmptyTransactionListener(@Nullable Runnable emptyTransactionListener) { - this.emptyTransactionListener = emptyTransactionListener; - } - - @SuppressWarnings("unchecked") - @Override - public void run() { - super.run(); - Looper.prepare(); - android.os.Process.setThreadPriority(android.os.Process.THREAD_PRIORITY_BACKGROUND); - while (true) { - final ArrayList tmpModels; - synchronized (models) { - tmpModels = new ArrayList<>(models); - models.clear(); - } - if (tmpModels.size() > 0) { - databaseDefinition.beginTransactionAsync( - new ProcessModelTransaction.Builder(modelSaver) - .addAll(tmpModels) - .build()) - .success(successCallback) - .error(errorCallback) - .build() - .execute(); - } else if (emptyTransactionListener != null) { - emptyTransactionListener.run(); - } - - try { - //sleep, and then check for leftovers - Thread.sleep(modelSaveCheckTime); - } catch (InterruptedException e) { - FlowLog.log(FlowLog.Level.I, "DBRequestQueue Batch interrupted to start saving"); - } - - if (isQuitting) { - return; - } - } - } - - /** - * Will cause the queue to wake from sleep and handle it's current list of items. - */ - public void purgeQueue() { - interrupt(); - } - - /** - * Adds an object to this queue. - */ - public void add(@NonNull final Object inModel) { - synchronized (models) { - models.add(inModel); - - if (models.size() > modelSaveSize) { - interrupt(); - } - } - } - - /** - * Adds a {@link java.util.Collection} of DB objects to this queue - */ - public void addAll(@NonNull final Collection list) { - synchronized (models) { - models.addAll(list); - - if (models.size() > modelSaveSize) { - interrupt(); - } - } - } - - /** - * Adds a {@link java.util.Collection} of class that extend Object to this queue - */ - public void addAll2(@NonNull final Collection list) { - synchronized (models) { - models.addAll(list); - - if (models.size() > modelSaveSize) { - interrupt(); - } - } - } - - /** - * Removes a DB object from this queue before it is processed. - */ - public void remove(@NonNull final Object outModel) { - synchronized (models) { - models.remove(outModel); - } - } - - /** - * Removes a {@link java.util.Collection} of DB object from this queue - * before it is processed. - */ - public void removeAll(@NonNull final Collection outCollection) { - synchronized (models) { - models.removeAll(outCollection); - } - } - - /** - * Removes a {@link java.util.Collection} of DB objects from this queue - * before it is processed. - */ - public void removeAll2(@NonNull final Collection outCollection) { - synchronized (models) { - models.removeAll(outCollection); - } - } - - /** - * Quits this queue after it sleeps for the {@link #modelSaveCheckTime} - */ - public void quit() { - isQuitting = true; - } - - private final ProcessModelTransaction.ProcessModel modelSaver = new ProcessModelTransaction.ProcessModel() { - @Override - public void processModel(Object model, DatabaseWrapper wrapper) { - if (model instanceof Model) { - ((Model) model).save(); - } else if (model != null) { - Class modelClass = model.getClass(); - //noinspection unchecked - FlowManager.getModelAdapter(modelClass).save(model); - } - } - }; - - private final Transaction.Success successCallback = new Transaction.Success() { - @Override - public void onSuccess(@NonNull Transaction transaction) { - if (successListener != null) { - successListener.onSuccess(transaction); - } - } - }; - - private final Transaction.Error errorCallback = new Transaction.Error() { - @Override - public void onError(@NonNull Transaction transaction, @NonNull Throwable error) { - if (errorListener != null) { - errorListener.onError(transaction, error); - } - } - }; - -} - diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DBBatchSaveQueue.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DBBatchSaveQueue.kt new file mode 100644 index 000000000..3dbcb054b --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DBBatchSaveQueue.kt @@ -0,0 +1,240 @@ +package com.raizlabs.android.dbflow.runtime + +import android.os.Looper +import com.raizlabs.android.dbflow.config.DatabaseDefinition +import com.raizlabs.android.dbflow.config.FlowLog +import com.raizlabs.android.dbflow.config.FlowManager +import com.raizlabs.android.dbflow.structure.Model +import com.raizlabs.android.dbflow.structure.database.transaction.ProcessModelTransaction +import com.raizlabs.android.dbflow.structure.database.transaction.Transaction +import java.util.* + +/** + * Description: This queue will bulk save items added to it when it gets access to the DB. It should only exist as one entity. + * It will save the [.MODEL_SAVE_SIZE] at a time or more only when the limit is reached. It will not + */ +class DBBatchSaveQueue +/** + * Creates a new instance of this class to batch save DB object classes. + */ +internal constructor(private val databaseDefinition: DatabaseDefinition) : Thread("DBBatchSaveQueue") { + + /** + * Tells how many items to save at a time. This can be set using [.setModelSaveSize] + */ + private var modelSaveSize = MODEL_SAVE_SIZE + + /** + * Sets the time we check periodically for leftover DB objects in our queue to save. + */ + private var modelSaveCheckTime = sMODEL_SAVE_CHECK_TIME.toLong() + + /** + * The list of DB objects that we will save here + */ + private val models: ArrayList = arrayListOf() + + /** + * If true, this queue will quit. + */ + private var isQuitting = false + + private var errorListener: Transaction.Error? = null + private var successListener: Transaction.Success? = null + private var emptyTransactionListener: Runnable? = null + + private val modelSaver = ProcessModelTransaction.ProcessModel { model, _ -> + (model as? Model)?.save() ?: if (model != null) { + val modelClass = model.javaClass + FlowManager.getModelAdapter(modelClass).save(model) + } + } + + private val successCallback = Transaction.Success { transaction -> + successListener?.onSuccess(transaction) + } + + private val errorCallback = Transaction.Error { transaction, error -> + errorListener?.onError(transaction, error) + } + + /** + * Sets how many models to save at a time in this queue. + * Increase it for larger batches, but slower recovery time. + * Smaller the batch, the more time it takes to save overall. + */ + fun setModelSaveSize(mModelSaveSize: Int) { + this.modelSaveSize = mModelSaveSize + } + + /** + * Sets how long, in millis that this queue will check for leftover DB objects that have not been saved yet. + * The default is [.sMODEL_SAVE_CHECK_TIME] + * + * @param time The time, in millis that queue automatically checks for leftover DB objects in this queue. + */ + fun setModelSaveCheckTime(time: Long) { + this.modelSaveCheckTime = time + } + + + /** + * Listener for errors in each batch [Transaction]. Called from the DBBatchSaveQueue thread. + * + * @param errorListener The listener to use. + */ + fun setErrorListener(errorListener: Transaction.Error?) { + this.errorListener = errorListener + } + + /** + * Listener for batch updates. Called from the DBBatchSaveQueue thread. + * + * @param successListener The listener to get notified when changes are successful. + */ + fun setSuccessListener(successListener: Transaction.Success?) { + this.successListener = successListener + } + + /** + * Listener for when there is no work done. Called from the DBBatchSaveQueue thread. + * + * @param emptyTransactionListener The listener to get notified when the save queue thread ran but was empty. + */ + fun setEmptyTransactionListener(emptyTransactionListener: Runnable?) { + this.emptyTransactionListener = emptyTransactionListener + } + + override fun run() { + super.run() + Looper.prepare() + android.os.Process.setThreadPriority(android.os.Process.THREAD_PRIORITY_BACKGROUND) + while (true) { + var tmpModels = listOf() + synchronized(models) { + tmpModels = arrayListOf(models) + models.clear() + } + if (tmpModels.isNotEmpty()) { + databaseDefinition.beginTransactionAsync( + ProcessModelTransaction.Builder(modelSaver) + .addAll(tmpModels) + .build()) + .success(successCallback) + .error(errorCallback) + .build() + .execute() + } else { + emptyTransactionListener?.run() + } + + try { + //sleep, and then check for leftovers + Thread.sleep(modelSaveCheckTime) + } catch (e: InterruptedException) { + FlowLog.log(FlowLog.Level.I, "DBRequestQueue Batch interrupted to start saving") + } + + if (isQuitting) { + return + } + } + } + + /** + * Will cause the queue to wake from sleep and handle it's current list of items. + */ + fun purgeQueue() { + interrupt() + } + + /** + * Adds an object to this queue. + */ + fun add(inModel: Any) { + synchronized(models) { + models.add(inModel) + + if (models.size > modelSaveSize) { + interrupt() + } + } + } + + /** + * Adds a [java.util.Collection] of DB objects to this queue + */ + fun addAll(list: Collection) { + synchronized(models) { + models.addAll(list) + + if (models.size > modelSaveSize) { + interrupt() + } + } + } + + /** + * Adds a [java.util.Collection] of class that extend Object to this queue + */ + fun addAll2(list: Collection<*>) { + synchronized(models) { + models.addAll(list) + + if (models.size > modelSaveSize) { + interrupt() + } + } + } + + /** + * Removes a DB object from this queue before it is processed. + */ + fun remove(outModel: Any) { + synchronized(models) { + models.remove(outModel) + } + } + + /** + * Removes a [java.util.Collection] of DB object from this queue + * before it is processed. + */ + fun removeAll(outCollection: Collection) { + synchronized(models) { + models.removeAll(outCollection) + } + } + + /** + * Removes a [java.util.Collection] of DB objects from this queue + * before it is processed. + */ + fun removeAll2(outCollection: Collection<*>) { + synchronized(models) { + models.removeAll(outCollection) + } + } + + /** + * Quits this queue after it sleeps for the [.modelSaveCheckTime] + */ + fun quit() { + isQuitting = true + } + + companion object { + + /** + * Once the queue size reaches 50 or larger, the thread will be interrupted and we will batch save the models. + */ + private val MODEL_SAVE_SIZE = 50 + + /** + * The default time that it will awake the save queue thread to check if any models are still waiting to be saved + */ + private val sMODEL_SAVE_CHECK_TIME = 30000 + } + +} + diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DirectModelNotifier.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DirectModelNotifier.java deleted file mode 100644 index d82ac32ab..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DirectModelNotifier.java +++ /dev/null @@ -1,187 +0,0 @@ -package com.raizlabs.android.dbflow.runtime; - -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.config.DatabaseConfig; -import com.raizlabs.android.dbflow.structure.BaseModel; -import com.raizlabs.android.dbflow.structure.ModelAdapter; - -import java.util.ArrayList; -import java.util.LinkedHashMap; -import java.util.LinkedHashSet; -import java.util.List; -import java.util.Map; -import java.util.Set; - -/** - * Description: Directly notifies about model changes. Users should use {@link #get()} to use the shared - * instance in {@link DatabaseConfig.Builder} - */ -@SuppressWarnings("unchecked") -public class DirectModelNotifier implements ModelNotifier { - - private static DirectModelNotifier notifier; - - @NonNull - public static DirectModelNotifier get() { - if (notifier == null) { - notifier = new DirectModelNotifier(); - } - return notifier; - } - - public interface OnModelStateChangedListener { - - void onModelChanged(@NonNull T model, @NonNull BaseModel.Action action); - - } - - public interface ModelChangedListener extends OnModelStateChangedListener, OnTableChangedListener { - - } - - private final Map, Set> modelChangedListenerMap = new LinkedHashMap<>(); - - private final Map, Set> tableChangedListenerMap = new LinkedHashMap<>(); - - - private final TableNotifierRegister singleRegister = new DirectTableNotifierRegister(); - - /** - * Private constructor. Use shared {@link #get()} to ensure singular instance. - */ - private DirectModelNotifier() { - if (notifier != null) { - throw new IllegalStateException("Cannot instantiate more than one DirectNotifier. Use DirectNotifier.get()"); - } - } - - @Override - public void notifyModelChanged(@NonNull T model, @NonNull ModelAdapter adapter, - @NonNull BaseModel.Action action) { - final Set listeners = modelChangedListenerMap.get(adapter.getModelClass()); - if (listeners != null) { - for (OnModelStateChangedListener listener : listeners) { - if (listener != null) { - listener.onModelChanged(model, action); - } - } - } - } - - @Override - public void notifyTableChanged(@NonNull Class table, @NonNull BaseModel.Action action) { - final Set listeners = tableChangedListenerMap.get(table); - if (listeners != null) { - for (OnTableChangedListener listener : listeners) { - if (listener != null) { - listener.onTableChanged(table, action); - } - } - } - } - - @Override - public TableNotifierRegister newRegister() { - return singleRegister; - } - - public void registerForModelChanges(@NonNull Class table, - @NonNull ModelChangedListener listener) { - registerForModelStateChanges(table, listener); - registerForTableChanges(table, listener); - } - - public void registerForModelStateChanges(@NonNull Class table, - @NonNull OnModelStateChangedListener listener) { - Set listeners = modelChangedListenerMap.get(table); - if (listeners == null) { - listeners = new LinkedHashSet<>(); - modelChangedListenerMap.put(table, listeners); - } - listeners.add(listener); - } - - public void registerForTableChanges(@NonNull Class table, - @NonNull OnTableChangedListener listener) { - Set listeners = tableChangedListenerMap.get(table); - if (listeners == null) { - listeners = new LinkedHashSet<>(); - tableChangedListenerMap.put(table, listeners); - } - listeners.add(listener); - } - - public void unregisterForModelChanges(@NonNull Class table, - @NonNull ModelChangedListener listener) { - unregisterForModelStateChanges(table, listener); - unregisterForTableChanges(table, listener); - } - - - public void unregisterForModelStateChanges(@NonNull Class table, - @NonNull OnModelStateChangedListener listener) { - Set listeners = modelChangedListenerMap.get(table); - if (listeners != null) { - listeners.remove(listener); - } - } - - public void unregisterForTableChanges(@NonNull Class table, - @NonNull OnTableChangedListener listener) { - Set listeners = tableChangedListenerMap.get(table); - if (listeners != null) { - listeners.remove(listener); - } - } - - private class DirectTableNotifierRegister implements TableNotifierRegister { - private List registeredTables = new ArrayList<>(); - - @Nullable - private OnTableChangedListener modelChangedListener; - - @Override - public void register(@NonNull Class tClass) { - registeredTables.add(tClass); - registerForTableChanges(tClass, internalChangeListener); - } - - @Override - public void unregister(@NonNull Class tClass) { - registeredTables.remove(tClass); - unregisterForTableChanges(tClass, internalChangeListener); - } - - @Override - public void unregisterAll() { - for (Class table : registeredTables) { - unregisterForTableChanges(table, internalChangeListener); - } - this.modelChangedListener = null; - } - - @Override - public void setListener(@Nullable OnTableChangedListener modelChangedListener) { - this.modelChangedListener = modelChangedListener; - } - - @Override - public boolean isSubscribed() { - return !registeredTables.isEmpty(); - } - - private final OnTableChangedListener internalChangeListener - = new OnTableChangedListener() { - - @Override - public void onTableChanged(@Nullable Class table, @NonNull BaseModel.Action action) { - if (modelChangedListener != null) { - modelChangedListener.onTableChanged(table, action); - } - } - }; - } - -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DirectModelNotifier.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DirectModelNotifier.kt new file mode 100644 index 000000000..9aed98adf --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DirectModelNotifier.kt @@ -0,0 +1,147 @@ +package com.raizlabs.android.dbflow.runtime + +import com.raizlabs.android.dbflow.config.DatabaseConfig +import com.raizlabs.android.dbflow.structure.BaseModel +import com.raizlabs.android.dbflow.structure.ModelAdapter +import java.util.* + +/** + * Description: Directly notifies about model changes. Users should use [.get] to use the shared + * instance in [DatabaseConfig.Builder] + */ +class DirectModelNotifier +/** + * Private constructor. Use shared [.get] to ensure singular instance. + */ +private constructor() : ModelNotifier { + + private val modelChangedListenerMap = linkedMapOf, MutableSet>>() + + private val tableChangedListenerMap = linkedMapOf, MutableSet>() + + + private val singleRegister = DirectTableNotifierRegister() + + interface OnModelStateChangedListener { + + fun onModelChanged(model: T, action: BaseModel.Action) + + } + + interface ModelChangedListener : OnModelStateChangedListener, OnTableChangedListener + + init { + if (instanceCount > 0) { + throw IllegalStateException("Cannot instantiate more than one DirectNotifier. Use DirectNotifier.get()") + } + instanceCount++ + } + + @Suppress("UNCHECKED_CAST") + override fun notifyModelChanged(model: T, adapter: ModelAdapter, + action: BaseModel.Action) { + modelChangedListenerMap[adapter.modelClass]?.forEach { listener -> + (listener as OnModelStateChangedListener).onModelChanged(model, action) + } + } + + override fun notifyTableChanged(table: Class, action: BaseModel.Action) { + tableChangedListenerMap[table]?.forEach { listener -> listener.onTableChanged(table, action) } + } + + override fun newRegister(): TableNotifierRegister { + return singleRegister + } + + fun registerForModelChanges(table: Class, + listener: ModelChangedListener) { + registerForModelStateChanges(table, listener) + registerForTableChanges(table, listener) + } + + fun registerForModelStateChanges(table: Class, + listener: OnModelStateChangedListener) { + var listeners = modelChangedListenerMap[table] + if (listeners == null) { + listeners = linkedSetOf() + modelChangedListenerMap.put(table, listeners) + } + listeners.add(listener) + } + + fun registerForTableChanges(table: Class, + listener: OnTableChangedListener) { + var listeners = tableChangedListenerMap[table] + if (listeners == null) { + listeners = linkedSetOf() + tableChangedListenerMap.put(table, listeners) + } + listeners.add(listener) + } + + fun unregisterForModelChanges(table: Class, + listener: ModelChangedListener) { + unregisterForModelStateChanges(table, listener) + unregisterForTableChanges(table, listener) + } + + + fun unregisterForModelStateChanges(table: Class, + listener: OnModelStateChangedListener) { + val listeners = modelChangedListenerMap[table] + listeners?.remove(listener) + } + + fun unregisterForTableChanges(table: Class, + listener: OnTableChangedListener) { + val listeners = tableChangedListenerMap[table] + listeners?.remove(listener) + } + + private inner class DirectTableNotifierRegister : TableNotifierRegister { + private val registeredTables = ArrayList>() + + private var modelChangedListener: OnTableChangedListener? = null + + private val internalChangeListener = object : OnTableChangedListener { + override fun onTableChanged(table: Class<*>?, action: BaseModel.Action) { + modelChangedListener?.onTableChanged(table, action) + } + } + + override fun register(tClass: Class) { + registeredTables.add(tClass) + registerForTableChanges(tClass, internalChangeListener) + } + + override fun unregister(tClass: Class) { + registeredTables.remove(tClass) + unregisterForTableChanges(tClass, internalChangeListener) + } + + override fun unregisterAll() { + registeredTables.forEach { table -> unregisterForTableChanges(table, internalChangeListener) } + this.modelChangedListener = null + } + + override fun setListener(modelChangedListener: OnTableChangedListener?) { + this.modelChangedListener = modelChangedListener + } + + override val isSubscribed: Boolean + get() = !registeredTables.isEmpty() + } + + companion object { + + internal var instanceCount = 0; + + private val notifier: DirectModelNotifier by lazy { + DirectModelNotifier() + } + + @JvmStatic + fun get(): DirectModelNotifier = notifier + } + +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ModelNotifier.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ModelNotifier.java deleted file mode 100644 index 279df9926..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ModelNotifier.java +++ /dev/null @@ -1,19 +0,0 @@ -package com.raizlabs.android.dbflow.runtime; - -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.structure.BaseModel; -import com.raizlabs.android.dbflow.structure.ModelAdapter; - -/** - * Interface for defining how we notify model changes. - */ -public interface ModelNotifier { - - void notifyModelChanged(@NonNull T model, @NonNull ModelAdapter adapter, - @NonNull BaseModel.Action action); - - void notifyTableChanged(@NonNull Class table, @NonNull BaseModel.Action action); - - TableNotifierRegister newRegister(); -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ModelNotifier.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ModelNotifier.kt new file mode 100644 index 000000000..0876f272c --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ModelNotifier.kt @@ -0,0 +1,16 @@ +package com.raizlabs.android.dbflow.runtime + +import com.raizlabs.android.dbflow.structure.BaseModel +import com.raizlabs.android.dbflow.structure.ModelAdapter + +/** + * Interface for defining how we notify model changes. + */ +interface ModelNotifier { + + fun notifyModelChanged(model: T, adapter: ModelAdapter, action: BaseModel.Action) + + fun notifyTableChanged(table: Class, action: BaseModel.Action) + + fun newRegister(): TableNotifierRegister +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/NotifyDistributor.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/NotifyDistributor.java deleted file mode 100644 index af8279455..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/NotifyDistributor.java +++ /dev/null @@ -1,46 +0,0 @@ -package com.raizlabs.android.dbflow.runtime; - -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.config.FlowManager; -import com.raizlabs.android.dbflow.structure.BaseModel; -import com.raizlabs.android.dbflow.structure.ModelAdapter; - -/** - * Description: Distributes notifications to the {@link ModelNotifier}. - */ -public class NotifyDistributor implements ModelNotifier { - - private static NotifyDistributor distributor; - - @NonNull - public static NotifyDistributor get() { - if (distributor == null) { - distributor = new NotifyDistributor(); - } - return distributor; - } - - @Override - public TableNotifierRegister newRegister() { - throw new RuntimeException("Cannot create a register from the distributor class"); - } - - @Override - public void notifyModelChanged(@NonNull TModel model, - @NonNull ModelAdapter adapter, - @NonNull BaseModel.Action action) { - FlowManager.getModelNotifierForTable(adapter.getModelClass()) - .notifyModelChanged(model, adapter, action); - } - - /** - * Notifies listeners of table-level changes from the SQLite-wrapper language. - */ - @Override - public void notifyTableChanged(@NonNull Class table, - @NonNull BaseModel.Action action) { - FlowManager.getModelNotifierForTable(table).notifyTableChanged(table, action); - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/NotifyDistributor.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/NotifyDistributor.kt new file mode 100644 index 000000000..e4a49371b --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/NotifyDistributor.kt @@ -0,0 +1,38 @@ +package com.raizlabs.android.dbflow.runtime + +import com.raizlabs.android.dbflow.config.FlowManager +import com.raizlabs.android.dbflow.structure.BaseModel +import com.raizlabs.android.dbflow.structure.ModelAdapter + +/** + * Description: Distributes notifications to the [ModelNotifier]. + */ +class NotifyDistributor : ModelNotifier { + + override fun newRegister(): TableNotifierRegister { + throw RuntimeException("Cannot create a register from the distributor class") + } + + override fun notifyModelChanged(model: TModel, + adapter: ModelAdapter, + action: BaseModel.Action) { + FlowManager.getModelNotifierForTable(adapter.modelClass) + .notifyModelChanged(model, adapter, action) + } + + /** + * Notifies listeners of table-level changes from the SQLite-wrapper language. + */ + override fun notifyTableChanged(table: Class, + action: BaseModel.Action) { + FlowManager.getModelNotifierForTable(table).notifyTableChanged(table, action) + } + + companion object { + + private val distributor by lazy { NotifyDistributor() } + + @JvmStatic + fun get(): NotifyDistributor = distributor + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/OnTableChangedListener.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/OnTableChangedListener.java deleted file mode 100644 index bc0285541..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/OnTableChangedListener.java +++ /dev/null @@ -1,22 +0,0 @@ -package com.raizlabs.android.dbflow.runtime; - -import android.os.Build; -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.structure.BaseModel; - -/** - * Interface for when a generic change on a table occurs. - */ -public interface OnTableChangedListener { - - /** - * Called when table changes. - * - * @param tableChanged The table that has changed. NULL unless version of app is {@link Build.VERSION_CODES#JELLY_BEAN} - * or higher. - * @param action The action that occurred. - */ - void onTableChanged(@Nullable Class tableChanged, @NonNull BaseModel.Action action); -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/OnTableChangedListener.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/OnTableChangedListener.kt new file mode 100644 index 000000000..8d79d84ec --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/OnTableChangedListener.kt @@ -0,0 +1,20 @@ +package com.raizlabs.android.dbflow.runtime + +import android.os.Build + +import com.raizlabs.android.dbflow.structure.BaseModel + +/** + * Interface for when a generic change on a table occurs. + */ +interface OnTableChangedListener { + + /** + * Called when table changes. + * + * @param table The table that has changed. NULL unless version of app is [Build.VERSION_CODES.JELLY_BEAN] + * or higher. + * @param action The action that occurred. + */ + fun onTableChanged(table: Class<*>?, action: BaseModel.Action) +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/TableNotifierRegister.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/TableNotifierRegister.java deleted file mode 100644 index 6ff597db6..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/TableNotifierRegister.java +++ /dev/null @@ -1,20 +0,0 @@ -package com.raizlabs.android.dbflow.runtime; - -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -/** - * Description: Defines how {@link ModelNotifier} registers listeners. Abstracts that away. - */ -public interface TableNotifierRegister { - - void register(@NonNull Class tClass); - - void unregister(@NonNull Class tClass); - - void unregisterAll(); - - void setListener(@Nullable OnTableChangedListener listener); - - boolean isSubscribed(); -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/TableNotifierRegister.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/TableNotifierRegister.kt new file mode 100644 index 000000000..1465e1476 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/TableNotifierRegister.kt @@ -0,0 +1,17 @@ +package com.raizlabs.android.dbflow.runtime + +/** + * Description: Defines how [ModelNotifier] registers listeners. Abstracts that away. + */ +interface TableNotifierRegister { + + val isSubscribed: Boolean + + fun register(tClass: Class) + + fun unregister(tClass: Class) + + fun unregisterAll() + + fun setListener(listener: OnTableChangedListener?) +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/BaseAsyncObject.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/BaseAsyncObject.java deleted file mode 100644 index 310012975..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/BaseAsyncObject.java +++ /dev/null @@ -1,99 +0,0 @@ -package com.raizlabs.android.dbflow.sql; - -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.config.DatabaseDefinition; -import com.raizlabs.android.dbflow.config.FlowManager; -import com.raizlabs.android.dbflow.structure.database.transaction.ITransaction; -import com.raizlabs.android.dbflow.structure.database.transaction.Transaction; - -/** - * Description: Internal use to provide common implementation for async objects. - */ -public class BaseAsyncObject { - - private Transaction.Success successCallback; - private Transaction.Error errorCallback; - private Transaction currentTransaction; - - private final Class table; - private final DatabaseDefinition databaseDefinition; - - public BaseAsyncObject(@NonNull Class table) { - this.table = table; - databaseDefinition = FlowManager.getDatabaseForTable(table); - } - - @NonNull - public Class getTable() { - return table; - } - - /** - * Listen for any errors that occur during operations on this {@link TAsync}. - */ - @SuppressWarnings("unchecked") - public TAsync error(@Nullable Transaction.Error errorCallback) { - this.errorCallback = errorCallback; - return (TAsync) this; - } - - /** - * Listens for successes on this {@link TAsync}. Will return the {@link Transaction}. - */ - @SuppressWarnings("unchecked") - public TAsync success(@Nullable Transaction.Success success) { - this.successCallback = success; - return (TAsync) this; - } - - /** - * Cancels current running transaction. - */ - public void cancel() { - if (currentTransaction != null) { - currentTransaction.cancel(); - } - } - - protected void executeTransaction(@NonNull ITransaction transaction) { - cancel(); - currentTransaction = databaseDefinition - .beginTransactionAsync(transaction) - .error(error) - .success(success) - .build(); - currentTransaction.execute(); - } - - protected void onError(@NonNull Transaction transaction, Throwable error) { - - } - - protected void onSuccess(@NonNull Transaction transaction) { - - } - - private final Transaction.Error error = new Transaction.Error() { - @Override - public void onError(@NonNull Transaction transaction, @NonNull Throwable error) { - if (errorCallback != null) { - errorCallback.onError(transaction, error); - } - BaseAsyncObject.this.onError(transaction, error); - currentTransaction = null; - } - }; - - private final Transaction.Success success = new Transaction.Success() { - @Override - public void onSuccess(@NonNull Transaction transaction) { - if (successCallback != null) { - successCallback.onSuccess(transaction); - } - BaseAsyncObject.this.onSuccess(transaction); - currentTransaction = null; - } - }; -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/BaseAsyncObject.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/BaseAsyncObject.kt new file mode 100644 index 000000000..f2384cb87 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/BaseAsyncObject.kt @@ -0,0 +1,66 @@ +package com.raizlabs.android.dbflow.sql + +import com.raizlabs.android.dbflow.config.DatabaseDefinition +import com.raizlabs.android.dbflow.config.FlowManager +import com.raizlabs.android.dbflow.structure.database.transaction.ITransaction +import com.raizlabs.android.dbflow.structure.database.transaction.Transaction + +/** + * Description: Internal use to provide common implementation for async objects. + */ +open class BaseAsyncObject(open val table: Class<*>) { + + private var successCallback: Transaction.Success? = null + private var errorCallback: Transaction.Error? = null + private var currentTransaction: Transaction? = null + private val databaseDefinition: DatabaseDefinition by lazy { FlowManager.getDatabaseForTable(table) } + + private val error = Transaction.Error { transaction, error -> + errorCallback?.onError(transaction, error) + this@BaseAsyncObject.onError(transaction, error) + currentTransaction = null + } + + private val success = Transaction.Success { transaction -> + successCallback?.onSuccess(transaction) + this@BaseAsyncObject.onSuccess(transaction) + currentTransaction = null + } + + /** + * Listen for any errors that occur during operations on this [TAsync]. + */ + fun error(errorCallback: Transaction.Error?): TAsync { + this.errorCallback = errorCallback + return this as TAsync + } + + /** + * Listens for successes on this [TAsync]. Will return the [Transaction]. + */ + fun success(success: Transaction.Success?): TAsync { + this.successCallback = success + return this as TAsync + } + + /** + * Cancels current running transaction. + */ + fun cancel() { + currentTransaction?.cancel() + } + + protected fun executeTransaction(transaction: ITransaction) { + cancel() + currentTransaction = databaseDefinition + .beginTransactionAsync(transaction) + .error(error) + .success(success) + .build() + currentTransaction?.execute() + } + + protected fun onError(transaction: Transaction, error: Throwable) = Unit + + protected open fun onSuccess(transaction: Transaction) = Unit +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/SqlUtils.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/SqlUtils.java index b90777162..3293cef7d 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/SqlUtils.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/SqlUtils.java @@ -49,7 +49,7 @@ public static void notifyModelChanged(Class table, Action action, public static void notifyModelChanged(@Nullable TModel model, @NonNull ModelAdapter modelAdapter, @NonNull Action action) { - NotifyDistributor.get().notifyModelChanged(model, modelAdapter, action); + NotifyDistributor.Companion.get().notifyModelChanged(model, modelAdapter, action); } /** @@ -60,7 +60,7 @@ public static void notifyModelChanged(@Nullable TModel model, @Deprecated public static void notifyTableChanged(@NonNull Class table, @NonNull Action action) { - NotifyDistributor.get().notifyTableChanged(table, action); + NotifyDistributor.Companion.get().notifyTableChanged(table, action); } /** diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Actionable.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Actionable.java deleted file mode 100644 index f461f91d8..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Actionable.java +++ /dev/null @@ -1,14 +0,0 @@ -package com.raizlabs.android.dbflow.sql.language; - -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.structure.BaseModel.Action; - -/** - * Description: Provides {@link Action} for SQL constructs. - */ -public interface Actionable { - - @NonNull - Action getPrimaryAction(); -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Actionable.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Actionable.kt new file mode 100644 index 000000000..d05dd3920 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Actionable.kt @@ -0,0 +1,11 @@ +package com.raizlabs.android.dbflow.sql.language + +import com.raizlabs.android.dbflow.structure.BaseModel.Action + +/** + * Description: Provides [Action] for SQL constructs. + */ +interface Actionable { + + val primaryAction: Action +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseModelQueriable.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseModelQueriable.java index 419c3f2a0..cc1f12dfa 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseModelQueriable.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseModelQueriable.java @@ -112,7 +112,7 @@ public long executeUpdateDelete(@NonNull DatabaseWrapper databaseWrapper) { // only notify for affected. if (affected > 0) { - NotifyDistributor.get().notifyTableChanged(getTable(), getPrimaryAction()); + NotifyDistributor.Companion.get().notifyTableChanged(getTable(), getPrimaryAction()); } return affected; } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseQueriable.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseQueriable.java index 6bb1fe29e..935043700 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseQueriable.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseQueriable.java @@ -124,7 +124,7 @@ public void execute() { cursor.close(); } else { // we dont query, we're executing something here. - NotifyDistributor.get().notifyTableChanged(getTable(), getPrimaryAction()); + NotifyDistributor.Companion.get().notifyTableChanged(getTable(), getPrimaryAction()); } } @@ -135,7 +135,7 @@ public void execute(@NonNull DatabaseWrapper databaseWrapper) { cursor.close(); } else { // we dont query, we're executing something here. - NotifyDistributor.get().notifyTableChanged(getTable(), getPrimaryAction()); + NotifyDistributor.Companion.get().notifyTableChanged(getTable(), getPrimaryAction()); } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IConditional.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IConditional.java deleted file mode 100644 index 817c55c28..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IConditional.java +++ /dev/null @@ -1,131 +0,0 @@ -package com.raizlabs.android.dbflow.sql.language; - -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.sql.Query; - -/** - * Description: Simple interface for objects that can be used as {@link Operator}. This class - * takes no type parameters for primitive objects. - */ -public interface IConditional extends Query { - - @NonNull - Operator is(@NonNull IConditional conditional); - - @NonNull - Operator is(@NonNull BaseModelQueriable baseModelQueriable); - - @NonNull - Operator isNull(); - - @NonNull - Operator eq(@NonNull IConditional conditional); - - @NonNull - Operator eq(@NonNull BaseModelQueriable baseModelQueriable); - - @NonNull - Operator isNotNull(); - - @NonNull - Operator concatenate(@NonNull IConditional conditional); - - @NonNull - Operator isNot(@NonNull IConditional conditional); - - @NonNull - Operator isNot(@NonNull BaseModelQueriable baseModelQueriable); - - @NonNull - Operator notEq(@NonNull IConditional conditional); - - @NonNull - Operator notEq(@NonNull BaseModelQueriable baseModelQueriable); - - @NonNull - Operator like(@NonNull IConditional conditional); - - @NonNull - Operator like(@NonNull BaseModelQueriable baseModelQueriable); - - @NonNull - Operator notLike(@NonNull IConditional conditional); - - @NonNull - Operator notLike(@NonNull BaseModelQueriable baseModelQueriable); - - @NonNull - Operator glob(@NonNull IConditional conditional); - - @NonNull - Operator glob(@NonNull BaseModelQueriable baseModelQueriable); - - @NonNull - Operator like(@NonNull String value); - - @NonNull - Operator notLike(@NonNull String value); - - @NonNull - Operator glob(@NonNull String value); - - @NonNull - Operator greaterThan(@NonNull IConditional conditional); - - @NonNull - Operator greaterThan(@NonNull BaseModelQueriable baseModelQueriable); - - @NonNull - Operator greaterThanOrEq(@NonNull IConditional conditional); - - @NonNull - Operator greaterThanOrEq(@NonNull BaseModelQueriable baseModelQueriable); - - @NonNull - Operator lessThan(@NonNull IConditional conditional); - - @NonNull - Operator lessThan(@NonNull BaseModelQueriable baseModelQueriable); - - @NonNull - Operator lessThanOrEq(@NonNull IConditional conditional); - - @NonNull - Operator lessThanOrEq(@NonNull BaseModelQueriable baseModelQueriable); - - @NonNull - Operator.Between between(@NonNull IConditional conditional); - - @NonNull - Operator.Between between(@NonNull BaseModelQueriable baseModelQueriable); - - @NonNull - Operator.In in(@NonNull IConditional firstConditional, @NonNull IConditional... conditionals); - - @NonNull - Operator.In in(@NonNull BaseModelQueriable firstBaseModelQueriable, - @NonNull BaseModelQueriable... baseModelQueriables); - - @NonNull - Operator.In notIn(@NonNull IConditional firstConditional, @NonNull IConditional... conditionals); - - @NonNull - Operator.In notIn(@NonNull BaseModelQueriable firstBaseModelQueriable, - @NonNull BaseModelQueriable... baseModelQueriables); - - @NonNull - Operator plus(@NonNull BaseModelQueriable value); - - @NonNull - Operator minus(@NonNull BaseModelQueriable value); - - @NonNull - Operator div(@NonNull BaseModelQueriable value); - - @NonNull - Operator times(@NonNull BaseModelQueriable value); - - @NonNull - Operator rem(@NonNull BaseModelQueriable value); -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IConditional.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IConditional.kt new file mode 100644 index 000000000..36e133d03 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IConditional.kt @@ -0,0 +1,90 @@ +package com.raizlabs.android.dbflow.sql.language + +import com.raizlabs.android.dbflow.sql.Query + +/** + * Description: Simple interface for objects that can be used as [Operator]. This class + * takes no type parameters for primitive objects. + */ +interface IConditional : Query { + + val isNull: Operator<*> + + val isNotNull: Operator<*> + + fun `is`(conditional: IConditional): Operator<*> + + fun `is`(baseModelQueriable: BaseModelQueriable<*>): Operator<*> + + fun eq(conditional: IConditional): Operator<*> + + fun eq(baseModelQueriable: BaseModelQueriable<*>): Operator<*> + + fun concatenate(conditional: IConditional): Operator<*> + + fun isNot(conditional: IConditional): Operator<*> + + fun isNot(baseModelQueriable: BaseModelQueriable<*>): Operator<*> + + fun notEq(conditional: IConditional): Operator<*> + + fun notEq(baseModelQueriable: BaseModelQueriable<*>): Operator<*> + + fun like(conditional: IConditional): Operator<*> + + fun like(baseModelQueriable: BaseModelQueriable<*>): Operator<*> + + fun notLike(conditional: IConditional): Operator<*> + + fun notLike(baseModelQueriable: BaseModelQueriable<*>): Operator<*> + + fun glob(conditional: IConditional): Operator<*> + + fun glob(baseModelQueriable: BaseModelQueriable<*>): Operator<*> + + fun like(value: String): Operator<*> + + fun notLike(value: String): Operator<*> + + fun glob(value: String): Operator<*> + + fun greaterThan(conditional: IConditional): Operator<*> + + fun greaterThan(baseModelQueriable: BaseModelQueriable<*>): Operator<*> + + fun greaterThanOrEq(conditional: IConditional): Operator<*> + + fun greaterThanOrEq(baseModelQueriable: BaseModelQueriable<*>): Operator<*> + + fun lessThan(conditional: IConditional): Operator<*> + + fun lessThan(baseModelQueriable: BaseModelQueriable<*>): Operator<*> + + fun lessThanOrEq(conditional: IConditional): Operator<*> + + fun lessThanOrEq(baseModelQueriable: BaseModelQueriable<*>): Operator<*> + + fun between(conditional: IConditional): Operator.Between<*> + + fun between(baseModelQueriable: BaseModelQueriable<*>): Operator.Between<*> + + fun `in`(firstConditional: IConditional, vararg conditionals: IConditional): Operator.In<*> + + fun `in`(firstBaseModelQueriable: BaseModelQueriable<*>, + vararg baseModelQueriables: BaseModelQueriable<*>): Operator.In<*> + + fun notIn(firstConditional: IConditional, vararg conditionals: IConditional): Operator.In<*> + + fun notIn(firstBaseModelQueriable: BaseModelQueriable<*>, + vararg baseModelQueriables: BaseModelQueriable<*>): Operator.In<*> + + operator fun plus(value: BaseModelQueriable<*>): Operator<*> + + operator fun minus(value: BaseModelQueriable<*>): Operator<*> + + operator fun div(value: BaseModelQueriable<*>): Operator<*> + + operator fun times(value: BaseModelQueriable<*>): Operator<*> + + operator fun rem(value: BaseModelQueriable<*>): Operator<*> +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IOperator.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IOperator.java deleted file mode 100644 index 701b6bb07..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IOperator.java +++ /dev/null @@ -1,187 +0,0 @@ -package com.raizlabs.android.dbflow.sql.language; - -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.sql.Query; - -import java.util.Collection; - -/** - * Description: Interface for objects that can be used as {@link Operator} that have a type parameter. - */ -public interface IOperator extends Query, IConditional { - - /** - * Assigns the operation to "=" - * - * @param value The {@link T} that we express equality to. - * @return A {@link Operator} that represents equality between this and the parameter. - */ - @NonNull - Operator is(@Nullable T value); - - /** - * Assigns the operation to "=". Identical to {@link #is(T)} - * - * @param value The {@link T} that we express equality to. - * @return A {@link Operator} that represents equality between this and the parameter. - * @see #is(T) - */ - @NonNull - Operator eq(@Nullable T value); - - /** - * Generates a {@link Operator} that concatenates this {@link IOperator} with the {@link T} via "||" - * by columnName=columnName || value - * - * @param value The value to concatenate. - * @return A {@link Operator} that represents concatenation. - */ - @NonNull - Operator concatenate(@Nullable T value); - - /** - * Assigns the operation to "!=" - * - * @param value The {@link T} that we express inequality to. - * @return A {@link Operator} that represents inequality between this and the parameter. - */ - @NonNull - Operator isNot(@Nullable T value); - - /** - * Assigns the operation to "!=" - * - * @param value The {@link T} that we express inequality to. - * @return A {@link Operator} that represents inequality between this and the parameter. - * @see #notEq(T) - */ - @NonNull - Operator notEq(@Nullable T value); - - /** - * Assigns operation to ">" - * - * @param value The {@link T} that this {@link IOperator} is greater than. - * @return A {@link Operator} that represents greater than between this and the parameter. - */ - @NonNull - Operator greaterThan(@NonNull T value); - - /** - * Assigns operation to ">=" - * - * @param value The {@link T} that this {@link IOperator} is greater than or equal to. - * @return A {@link Operator} that represents greater than or equal between this and the parameter. - */ - @NonNull - Operator greaterThanOrEq(@NonNull T value); - - - /** - * Assigns operation to "<" - * - * @param value The {@link T} that this {@link IOperator} is less than. - * @return A {@link Operator} that represents less than between this and the parameter. - */ - @NonNull - Operator lessThan(@NonNull T value); - - - /** - * Assigns operation to "<=" - * - * @param value The {@link T} that this {@link IOperator} is less than or equal to. - * @return A {@link Operator} that represents less than or equal to between this and the parameter. - */ - @NonNull - Operator lessThanOrEq(@NonNull T value); - - @NonNull - Operator.Between between(@NonNull T value); - - /** - * Turns this {@link IOperator} into an {@link Operator.In}. It means that this object should - * be represented by the set of {@link T} provided to follow. - * - * @param firstValue The first value (required to enforce >= 1) - * @param values The rest of the values to pass optionally. - * @return A new {@link Operator.In} built from this {@link IOperator}. - */ - @NonNull - @SuppressWarnings("unchecked") - Operator.In in(@NonNull T firstValue, T... values); - - /** - * Turns this {@link IOperator} into an {@link Operator.In} (not). It means that this object should NOT - * be represented by the set of {@link T} provided to follow. - * - * @param firstValue The first value (required to enforce >= 1) - * @param values The rest of the values to pass optionally. - * @return A new {@link Operator.In} (not) built from this {@link IOperator}. - */ - @NonNull - @SuppressWarnings("unchecked") - Operator.In notIn(@NonNull T firstValue, T... values); - - /** - * Turns this {@link IOperator} into an {@link Operator.In}. It means that this object should - * be represented by the set of {@link T} provided to follow. - * - * @param values The rest of the values to pass optionally. - * @return A new {@link Operator.In} built from this {@link IOperator}. - */ - @NonNull - Operator.In in(@NonNull Collection values); - - /** - * Turns this {@link IOperator} into an {@link Operator.In} (not). It means that this object should NOT - * be represented by the set of {@link T} provided to follow. - * - * @param values The rest of the values to pass optionally. - * @return A new {@link Operator.In} (not) built from this {@link IOperator}. - */ - @NonNull - Operator.In notIn(@NonNull Collection values); - - /** - * Adds another value and returns the operator. i.e p1 + p2 - * - * @param value the value to add. - */ - @NonNull - Operator plus(@NonNull T value); - - /** - * Subtracts another value and returns the operator. i.e p1 - p2 - * - * @param value the value to subtract. - */ - @NonNull - Operator minus(@NonNull T value); - - /** - * Divides another value and returns as the operator. i.e p1 / p2 - * - * @param value the value to divide. - * @return A new instance. - */ - @NonNull - Operator div(@NonNull T value); - - /** - * Multiplies another value and returns as the operator. i.e p1 * p2 - * - * @param value the value to multiply. - */ - Operator times(@NonNull T value); - - /** - * Modulous another value and returns as the operator. i.e p1 % p2 - * - * @param value the value to calculate remainder of. - */ - @NonNull - Operator rem(@NonNull T value); -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IOperator.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IOperator.kt new file mode 100644 index 000000000..66baa9e8b --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IOperator.kt @@ -0,0 +1,162 @@ +package com.raizlabs.android.dbflow.sql.language + +import com.raizlabs.android.dbflow.sql.Query + +/** + * Description: Interface for objects that can be used as [Operator] that have a type parameter. + */ +interface IOperator : Query, IConditional { + + /** + * Assigns the operation to "=" + * + * @param value The [T] that we express equality to. + * @return A [Operator] that represents equality between this and the parameter. + */ + fun `is`(value: T?): Operator + + /** + * Assigns the operation to "=". Identical to [.is] + * + * @param value The [T] that we express equality to. + * @return A [Operator] that represents equality between this and the parameter. + * @see .is + */ + fun eq(value: T?): Operator + + /** + * Generates a [Operator] that concatenates this [IOperator] with the [T] via "||" + * by columnName=columnName || value + * + * @param value The value to concatenate. + * @return A [<] that represents concatenation. + */ + fun concatenate(value: T?): Operator + + /** + * Assigns the operation to "!=" + * + * @param value The [T] that we express inequality to. + * @return A [<] that represents inequality between this and the parameter. + */ + fun isNot(value: T?): Operator + + /** + * Assigns the operation to "!=" + * + * @param value The [T] that we express inequality to. + * @return A [<] that represents inequality between this and the parameter. + * @see .notEq + */ + fun notEq(value: T?): Operator + + /** + * Assigns operation to ">" + * + * @param value The [T] that this [IOperator] is greater than. + * @return A [<] that represents greater than between this and the parameter. + */ + fun greaterThan(value: T): Operator + + /** + * Assigns operation to ">=" + * + * @param value The [T] that this [IOperator] is greater than or equal to. + * @return A [<] that represents greater than or equal between this and the parameter. + */ + fun greaterThanOrEq(value: T): Operator + + + /** + * Assigns operation to "<" + * + * @param value The [T] that this [IOperator] is less than. + * @return A [<] that represents less than between this and the parameter. + */ + fun lessThan(value: T): Operator + + + /** + * Assigns operation to "<=" + * + * @param value The [T] that this [IOperator] is less than or equal to. + * @return A [<] that represents less than or equal to between this and the parameter. + */ + fun lessThanOrEq(value: T): Operator + + fun between(value: T): Operator.Between + + /** + * Turns this [IOperator] into an [.In][<]. It means that this object should + * be represented by the set of [T] provided to follow. + * + * @param firstValue The first value (required to enforce >= 1) + * @param values The rest of the values to pass optionally. + * @return A new [.In][<] built from this [IOperator]. + */ + fun `in`(firstValue: T, vararg values: T): Operator.In + + /** + * Turns this [IOperator] into an [.In][<] (not). It means that this object should NOT + * be represented by the set of [T] provided to follow. + * + * @param firstValue The first value (required to enforce >= 1) + * @param values The rest of the values to pass optionally. + * @return A new [.In][<] (not) built from this [IOperator]. + */ + fun notIn(firstValue: T, vararg values: T): Operator.In + + /** + * Turns this [IOperator] into an [.In][<]. It means that this object should + * be represented by the set of [T] provided to follow. + * + * @param values The rest of the values to pass optionally. + * @return A new [.In][<] built from this [IOperator]. + */ + fun `in`(values: Collection): Operator.In + + /** + * Turns this [IOperator] into an [.In][<] (not). It means that this object should NOT + * be represented by the set of [T] provided to follow. + * + * @param values The rest of the values to pass optionally. + * @return A new [.In][<] (not) built from this [IOperator]. + */ + fun notIn(values: Collection): Operator.In + + /** + * Adds another value and returns the operator. i.e p1 + p2 + * + * @param value the value to add. + */ + operator fun plus(value: T): Operator + + /** + * Subtracts another value and returns the operator. i.e p1 - p2 + * + * @param value the value to subtract. + */ + operator fun minus(value: T): Operator + + /** + * Divides another value and returns as the operator. i.e p1 / p2 + * + * @param value the value to divide. + * @return A new instance. + */ + operator fun div(value: T): Operator + + /** + * Multiplies another value and returns as the operator. i.e p1 * p2 + * + * @param value the value to multiply. + */ + operator fun times(value: T): Operator + + /** + * Modulous another value and returns as the operator. i.e p1 % p2 + * + * @param value the value to calculate remainder of. + */ + operator fun rem(value: T): Operator +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Join.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Join.java index b607935f6..d714a33dc 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Join.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Join.java @@ -94,7 +94,7 @@ public Join(@NonNull From from, @NonNull JoinType joinType, table = modelQueriable.getTable(); this.from = from; type = joinType; - alias = PropertyFactory.from(modelQueriable).getNameAlias(); + alias = PropertyFactory.INSTANCE.from(modelQueriable).getNameAlias(); } /** diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Method.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Method.java index 73b7e0172..9aa05b9da 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Method.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Method.java @@ -92,7 +92,7 @@ public static Cast cast(@NonNull IProperty property) { @NonNull public static Method replace(@NonNull IProperty property, String findString, String replacement) { - return new Method("REPLACE", property, PropertyFactory.from(findString), PropertyFactory.from(replacement)); + return new Method("REPLACE", property, PropertyFactory.INSTANCE.from(findString), PropertyFactory.INSTANCE.from(replacement)); } /** @@ -101,10 +101,10 @@ public static Method replace(@NonNull IProperty property, String findString, Str public static Method strftime(@NonNull String formatString, @NonNull String timeString, String... modifiers) { List propertyList = new ArrayList<>(); - propertyList.add(PropertyFactory.from(formatString)); - propertyList.add(PropertyFactory.from(timeString)); + propertyList.add(PropertyFactory.INSTANCE.from(formatString)); + propertyList.add(PropertyFactory.INSTANCE.from(timeString)); for (String modifier : modifiers) { - propertyList.add(PropertyFactory.from(modifier)); + propertyList.add(PropertyFactory.INSTANCE.from(modifier)); } return new Method("strftime", propertyList.toArray(new IProperty[propertyList.size()])); } @@ -114,9 +114,9 @@ public static Method strftime(@NonNull String formatString, */ public static Method datetime(long timeStamp, String... modifiers) { List propertyList = new ArrayList<>(); - propertyList.add(PropertyFactory.from(timeStamp)); + propertyList.add(PropertyFactory.INSTANCE.from(timeStamp)); for (String modifier : modifiers) { - propertyList.add(PropertyFactory.from(modifier)); + propertyList.add(PropertyFactory.INSTANCE.from(modifier)); } return new Method("datetime", propertyList.toArray(new IProperty[propertyList.size()])); } @@ -127,9 +127,9 @@ public static Method datetime(long timeStamp, String... modifiers) { public static Method date(@NonNull String timeString, String... modifiers) { List propertyList = new ArrayList<>(); - propertyList.add(PropertyFactory.from(timeString)); + propertyList.add(PropertyFactory.INSTANCE.from(timeString)); for (String modifier : modifiers) { - propertyList.add(PropertyFactory.from(modifier)); + propertyList.add(PropertyFactory.INSTANCE.from(modifier)); } return new Method("date", propertyList.toArray(new IProperty[propertyList.size()])); } @@ -167,7 +167,7 @@ public Method(String methodName, IProperty... properties) { methodProperty = new Property<>(null, NameAlias.rawBuilder(methodName).build()); if (properties.length == 0) { - propertyList.add(Property.ALL_PROPERTY); + propertyList.add(Property.Companion.getALL_PROPERTY()); } else { for (IProperty property : properties) { addProperty(property); @@ -220,7 +220,7 @@ public Method addProperty(@NonNull IProperty property) { */ public Method append(IProperty property, String operation) { // remove all property since its not needed when we specify a property. - if (propertyList.size() == 1 && propertyList.get(0) == Property.ALL_PROPERTY) { + if (propertyList.size() == 1 && propertyList.get(0) == Property.Companion.getALL_PROPERTY()) { propertyList.remove(0); } propertyList.add(property); @@ -236,7 +236,7 @@ protected List getPropertyList() { @NonNull @Override public NameAlias getNameAlias() { - if (nameAlias == null) { + if (getNameAlias() == null) { String query = methodProperty.getQuery(); if (query == null) { query = ""; @@ -252,10 +252,10 @@ public NameAlias getNameAlias() { } query += ")"; - nameAlias = NameAlias.rawBuilder(query) - .build(); + getNameAlias(NameAlias.rawBuilder(query) + .build()); } - return nameAlias; + return getNameAlias(); } /** diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/SQLOperator.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/SQLOperator.kt similarity index 50% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/SQLOperator.java rename to dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/SQLOperator.kt index 22fb92b5b..c2369ebf6 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/SQLOperator.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/SQLOperator.kt @@ -1,37 +1,32 @@ -package com.raizlabs.android.dbflow.sql.language; +package com.raizlabs.android.dbflow.sql.language -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.sql.QueryBuilder; +import com.raizlabs.android.dbflow.sql.QueryBuilder /** * Description: Basic interface for all of the Operator classes. */ -public interface SQLOperator { +interface SQLOperator { /** - * Appends itself to the {@link QueryBuilder} + * Appends itself to the [QueryBuilder] * * @param queryBuilder The builder to append to. */ - void appendConditionToQuery(@NonNull QueryBuilder queryBuilder); + fun appendConditionToQuery(queryBuilder: QueryBuilder<*>) /** * The name of the column. * * @return The column name. */ - @NonNull - String columnName(); + fun columnName(): String /** - * The separator for this condition when paired with a {@link OperatorGroup} + * The separator for this condition when paired with a [OperatorGroup] * * @return The separator, an AND, OR, or other kinds. */ - @Nullable - String separator(); + fun separator(): String? /** * Sets the separator for this condition @@ -39,24 +34,21 @@ public interface SQLOperator { * @param separator The string AND, OR, or something else. * @return This instance. */ - @NonNull - SQLOperator separator(@NonNull String separator); + fun separator(separator: String): SQLOperator /** * @return true if it has a separator, false if not. */ - boolean hasSeparator(); + fun hasSeparator(): Boolean /** * @return the operation that is used. */ - @NonNull - String operation(); + fun operation(): String /** * @return The raw value of the condition. */ - @Nullable - Object value(); + fun value(): Any? } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Select.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Select.java index 76986122b..18477eb51 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Select.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Select.java @@ -44,7 +44,7 @@ public Select(IProperty... properties) { Collections.addAll(propertyList, properties); if (propertyList.isEmpty()) { - propertyList.add(Property.ALL_PROPERTY); + propertyList.add(Property.Companion.getALL_PROPERTY()); } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/WhereBase.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/WhereBase.java deleted file mode 100644 index cd5ff9b3e..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/WhereBase.java +++ /dev/null @@ -1,24 +0,0 @@ -package com.raizlabs.android.dbflow.sql.language; - -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.sql.Query; - -/** - * Description: The base for a {@link Where} statement. - */ -public interface WhereBase extends Query, Actionable { - - /** - * @return The table of this query. - */ - @NonNull - Class getTable(); - - /** - * @return The base Query object. - */ - @NonNull - Query getQueryBuilderBase(); - -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/WhereBase.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/WhereBase.kt new file mode 100644 index 000000000..fde4c9e7d --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/WhereBase.kt @@ -0,0 +1,20 @@ +package com.raizlabs.android.dbflow.sql.language + +import com.raizlabs.android.dbflow.sql.Query + +/** + * Description: The base for a [Where] statement. + */ +interface WhereBase : Query, Actionable { + + /** + * @return The table of this query. + */ + val table: Class + + /** + * @return The base Query object. + */ + val queryBuilderBase: Query + +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/IndexProperty.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/IndexProperty.java deleted file mode 100644 index dcb2d5061..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/IndexProperty.java +++ /dev/null @@ -1,49 +0,0 @@ -package com.raizlabs.android.dbflow.sql.language.property; - -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.annotation.Table; -import com.raizlabs.android.dbflow.sql.QueryBuilder; -import com.raizlabs.android.dbflow.sql.language.Index; -import com.raizlabs.android.dbflow.sql.language.SQLite; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; - -/** - * Description: Defines an INDEX in Sqlite. It basically speeds up data retrieval over large datasets. - * It gets generated from {@link Table#indexGroups()}, but also can be manually constructed. These are activated - * and deactivated manually. - */ -public class IndexProperty { - - private final Index index; - - public IndexProperty(String indexName, boolean unique, Class table, IProperty... properties) { - index = SQLite.index(indexName); - index.on(table, properties) - .unique(unique); - } - - public void createIfNotExists(@NonNull DatabaseWrapper wrapper) { - index.enable(wrapper); - } - - public void createIfNotExists() { - index.enable(); - } - - public void drop() { - index.disable(); - } - - public void drop(DatabaseWrapper writableDatabase) { - index.disable(writableDatabase); - } - - public Index getIndex() { - return index; - } - - public String getIndexName() { - return QueryBuilder.quoteIfNeeded(index.getIndexName()); - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/IndexProperty.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/IndexProperty.kt new file mode 100644 index 000000000..4308e0f7e --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/IndexProperty.kt @@ -0,0 +1,42 @@ +package com.raizlabs.android.dbflow.sql.language.property + +import com.raizlabs.android.dbflow.annotation.Table +import com.raizlabs.android.dbflow.sql.QueryBuilder +import com.raizlabs.android.dbflow.sql.language.Index +import com.raizlabs.android.dbflow.sql.language.SQLite +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper + +/** + * Description: Defines an INDEX in Sqlite. It basically speeds up data retrieval over large datasets. + * It gets generated from [Table.indexGroups], but also can be manually constructed. These are activated + * and deactivated manually. + */ +class IndexProperty(indexName: String, unique: Boolean, table: Class, + vararg properties: IProperty<*>) { + + val index: Index = SQLite.index(indexName) + + val indexName: String + get() = QueryBuilder.quoteIfNeeded(index.indexName) + + init { + index.on(table, *properties) + .unique(unique) + } + + fun createIfNotExists(wrapper: DatabaseWrapper) { + index.enable(wrapper) + } + + fun createIfNotExists() { + index.enable() + } + + fun drop() { + index.disable() + } + + fun drop(writableDatabase: DatabaseWrapper) { + index.disable(writableDatabase) + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/Property.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/Property.java deleted file mode 100644 index 863308993..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/Property.java +++ /dev/null @@ -1,539 +0,0 @@ -package com.raizlabs.android.dbflow.sql.language.property; - -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.config.FlowManager; -import com.raizlabs.android.dbflow.sql.language.BaseModelQueriable; -import com.raizlabs.android.dbflow.sql.language.IConditional; -import com.raizlabs.android.dbflow.sql.language.IOperator; -import com.raizlabs.android.dbflow.sql.language.NameAlias; -import com.raizlabs.android.dbflow.sql.language.Operator; -import com.raizlabs.android.dbflow.sql.language.OrderBy; - -import java.util.Collection; - -import static com.raizlabs.android.dbflow.sql.language.Operator.op; - -/** - * Description: The main, immutable property class that gets generated from a table definition. - *

- * This class delegates all of its {@link IOperator} methods to a new {@link Operator} that's used - * in the SQLite query language. - *

- * This ensures that the language is strictly type-safe and only declared - * columns get used. Also any calls on the methods return a new {@link Property}. - *

- * This is type parametrized so that all values passed to this class remain properly typed. - */ -public class Property implements IProperty>, IConditional, IOperator { - - public static final Property ALL_PROPERTY = new Property<>(null, NameAlias.rawBuilder("*").build()); - - public static final Property WILDCARD = new Property(null, NameAlias.rawBuilder("?").build()); - - public static Property allProperty(Class table) { - return new Property(table, NameAlias.rawBuilder("*").build()).withTable(); - } - - @Nullable final Class table; - - protected NameAlias nameAlias; - - public Property(@Nullable Class table, @NonNull NameAlias nameAlias) { - this.table = table; - this.nameAlias = nameAlias; - } - - public Property(@Nullable Class table, @Nullable String columnName) { - this.table = table; - if (columnName != null) { - nameAlias = new NameAlias.Builder(columnName).build(); - } - } - - public Property(@Nullable Class table, @NonNull String columnName, @NonNull String aliasName) { - this(table, NameAlias.builder(columnName).as(aliasName).build()); - } - - @NonNull - @Override - public Property withTable() { - return withTable(new NameAlias.Builder(FlowManager.getTableName(table)).build()); - } - - @NonNull - @Override - public NameAlias getNameAlias() { - return nameAlias; - } - - @Override - public String getQuery() { - return getNameAlias().getQuery(); - } - - @NonNull - @Override - public String getCursorKey() { - return getNameAlias().getQuery(); - } - - @NonNull - public String getDefinition() { - return getNameAlias().getFullQuery(); - } - - @Override - public String toString() { - return getNameAlias().toString(); - } - - @NonNull - @Override - public Operator is(@NonNull IConditional conditional) { - return getCondition().is(conditional); - } - - @NonNull - @Override - public Operator eq(@NonNull IConditional conditional) { - return getCondition().eq(conditional); - } - - @NonNull - @Override - public Operator isNot(@NonNull IConditional conditional) { - return getCondition().isNot(conditional); - } - - @NonNull - @Override - public Operator notEq(@NonNull IConditional conditional) { - return getCondition().notEq(conditional); - } - - @NonNull - @Override - public Operator like(@NonNull IConditional conditional) { - return getCondition().like(conditional); - } - - @NonNull - @Override - public Operator glob(@NonNull IConditional conditional) { - return getCondition().glob(conditional); - } - - @NonNull - @Override - public Operator like(@NonNull String value) { - return getCondition().like(value); - } - - @NonNull - @Override - public Operator notLike(@NonNull String value) { - return getCondition().notLike(value); - } - - @NonNull - @Override - public Operator glob(@NonNull String value) { - return getCondition().glob(value); - } - - @NonNull - @Override - public Operator greaterThan(@NonNull IConditional conditional) { - return getCondition().greaterThan(conditional); - } - - @NonNull - @Override - public Operator greaterThanOrEq(@NonNull IConditional conditional) { - return getCondition().greaterThanOrEq(conditional); - } - - @NonNull - @Override - public Operator lessThan(@NonNull IConditional conditional) { - return getCondition().lessThan(conditional); - } - - @NonNull - @Override - public Operator lessThanOrEq(@NonNull IConditional conditional) { - return getCondition().lessThanOrEq(conditional); - } - - @NonNull - @Override - public Operator.Between between(@NonNull IConditional conditional) { - return getCondition().between(conditional); - } - - @NonNull - @Override - public Operator.In in(@NonNull IConditional firstConditional, @NonNull IConditional... conditionals) { - return getCondition().in(firstConditional, conditionals); - } - - @NonNull - @Override - public Operator.In notIn(@NonNull IConditional firstConditional, @NonNull IConditional... conditionals) { - return getCondition().notIn(firstConditional, conditionals); - } - - @NonNull - @Override - public Operator is(@NonNull BaseModelQueriable baseModelQueriable) { - return getCondition().is(baseModelQueriable); - } - - @NonNull - @Override - public Operator isNull() { - return getCondition().isNull(); - } - - @NonNull - @Override - public Operator eq(@NonNull BaseModelQueriable baseModelQueriable) { - return getCondition().eq(baseModelQueriable); - } - - @NonNull - @Override - public Operator isNot(@NonNull BaseModelQueriable baseModelQueriable) { - return getCondition().isNot(baseModelQueriable); - } - - @NonNull - @Override - public Operator isNotNull() { - return getCondition().isNotNull(); - } - - @NonNull - @Override - public Operator notEq(@NonNull BaseModelQueriable baseModelQueriable) { - return getCondition().notEq(baseModelQueriable); - } - - @NonNull - @Override - public Operator like(@NonNull BaseModelQueriable baseModelQueriable) { - return getCondition().like(baseModelQueriable); - } - - @NonNull - @Override - public Operator notLike(@NonNull IConditional conditional) { - return getCondition().notLike(conditional); - } - - @NonNull - @Override - public Operator notLike(@NonNull BaseModelQueriable baseModelQueriable) { - return getCondition().notLike(baseModelQueriable); - } - - @NonNull - @Override - public Operator glob(@NonNull BaseModelQueriable baseModelQueriable) { - return getCondition().glob(baseModelQueriable); - } - - @NonNull - @Override - public Operator greaterThan(@NonNull BaseModelQueriable baseModelQueriable) { - return getCondition().greaterThan(baseModelQueriable); - } - - @NonNull - @Override - public Operator greaterThanOrEq(@NonNull BaseModelQueriable baseModelQueriable) { - return getCondition().greaterThanOrEq(baseModelQueriable); - } - - @NonNull - @Override - public Operator lessThan(@NonNull BaseModelQueriable baseModelQueriable) { - return getCondition().lessThan(baseModelQueriable); - } - - @NonNull - @Override - public Operator lessThanOrEq(@NonNull BaseModelQueriable baseModelQueriable) { - return getCondition().lessThanOrEq(baseModelQueriable); - } - - @NonNull - @Override - public Operator.Between between(@NonNull BaseModelQueriable baseModelQueriable) { - return getCondition().between(baseModelQueriable); - } - - @NonNull - @Override - public Operator.In in(@NonNull BaseModelQueriable firstBaseModelQueriable, @NonNull BaseModelQueriable... baseModelQueriables) { - return getCondition().in(firstBaseModelQueriable, baseModelQueriables); - } - - @NonNull - @Override - public Operator.In notIn(@NonNull BaseModelQueriable firstBaseModelQueriable, @NonNull BaseModelQueriable... baseModelQueriables) { - return getCondition().notIn(firstBaseModelQueriable, baseModelQueriables); - } - - @NonNull - @Override - public Operator concatenate(@NonNull IConditional conditional) { - return getCondition().concatenate(conditional); - } - - @NonNull - @Override - public Operator plus(@NonNull BaseModelQueriable value) { - return getCondition().plus(value); - } - - @NonNull - @Override - public Operator minus(@NonNull BaseModelQueriable value) { - return getCondition().minus(value); - } - - @NonNull - @Override - public Operator div(@NonNull BaseModelQueriable value) { - return getCondition().div(value); - } - - @NonNull - @Override - public Operator times(@NonNull BaseModelQueriable value) { - return getCondition().times(value); - } - - @NonNull - @Override - public Operator rem(@NonNull BaseModelQueriable value) { - return getCondition().rem(value); - } - - @NonNull - @Override - public Class getTable() { - return table; - } - - @NonNull - @Override - public Property plus(@NonNull IProperty iProperty) { - return new Property<>(table, NameAlias.joinNames(Operator.Operation.PLUS, - nameAlias.fullName(), iProperty.toString())); - } - - @NonNull - @Override - public Property minus(@NonNull IProperty iProperty) { - return new Property<>(table, NameAlias.joinNames(Operator.Operation.MINUS, - nameAlias.fullName(), iProperty.toString())); - } - - @NonNull - @Override - public Property div(@NonNull IProperty iProperty) { - return new Property<>(table, NameAlias.joinNames(Operator.Operation.DIVISION, - nameAlias.fullName(), iProperty.toString())); - } - - @Override - public Property times(@NonNull IProperty iProperty) { - return new Property<>(table, NameAlias.joinNames(Operator.Operation.MULTIPLY, - nameAlias.fullName(), iProperty.toString())); - } - - @NonNull - @Override - public Property rem(@NonNull IProperty iProperty) { - return new Property<>(table, NameAlias.joinNames(Operator.Operation.MOD, - nameAlias.fullName(), iProperty.toString())); - } - - @NonNull - @Override - public Property concatenate(@NonNull IProperty iProperty) { - return new Property<>(table, NameAlias.joinNames(Operator.Operation.CONCATENATE, - nameAlias.fullName(), iProperty.toString())); - } - - @NonNull - @Override - public Property as(@NonNull String aliasName) { - return new Property<>(table, getNameAlias() - .newBuilder() - .as(aliasName) - .build()); - } - - @NonNull - @Override - public Property distinct() { - return new Property<>(table, getDistinctAliasName()); - } - - @NonNull - @Override - public Property withTable(@NonNull NameAlias tableNameAlias) { - return new Property<>(table, getNameAlias() - .newBuilder() - .withTable(tableNameAlias.getQuery()) - .build()); - } - - @NonNull - @Override - public Operator is(@Nullable T value) { - return getCondition().is(value); - } - - @NonNull - @Override - public Operator eq(@Nullable T value) { - return getCondition().eq(value); - } - - @NonNull - @Override - public Operator isNot(@Nullable T value) { - return getCondition().isNot(value); - } - - @NonNull - @Override - public Operator notEq(@Nullable T value) { - return getCondition().notEq(value); - } - - @NonNull - @Override - public Operator greaterThan(@NonNull T value) { - return getCondition().greaterThan(value); - } - - @NonNull - @Override - public Operator greaterThanOrEq(@NonNull T value) { - return getCondition().greaterThanOrEq(value); - } - - @NonNull - @Override - public Operator lessThan(@NonNull T value) { - return getCondition().lessThan(value); - } - - @NonNull - @Override - public Operator lessThanOrEq(@NonNull T value) { - return getCondition().lessThanOrEq(value); - } - - @NonNull - @Override - public Operator.Between between(@NonNull T value) { - return getCondition().between(value); - } - - @NonNull - @SuppressWarnings({"ConfusingArgumentToVarargsMethod", "unchecked"}) - @Override - public Operator.In in(@NonNull T firstValue, T... values) { - return getCondition().in(firstValue, values); - } - - @NonNull - @SuppressWarnings({"ConfusingArgumentToVarargsMethod", "unchecked"}) - @Override - public Operator.In notIn(@NonNull T firstValue, T... values) { - return getCondition().notIn(firstValue, values); - } - - @NonNull - @Override - public Operator.In in(@NonNull Collection values) { - return getCondition().in(values); - } - - @NonNull - @Override - public Operator.In notIn(@NonNull Collection values) { - return getCondition().notIn(values); - } - - @NonNull - @Override - public Operator concatenate(@Nullable T value) { - return getCondition().concatenate(value); - } - - @NonNull - @Override - public Operator plus(@NonNull T value) { - return getCondition().plus(value); - } - - @NonNull - @Override - public Operator minus(@NonNull T value) { - return getCondition().minus(value); - } - - @NonNull - @Override - public Operator div(@NonNull T value) { - return getCondition().div(value); - } - - @Override - public Operator times(@NonNull T value) { - return getCondition().times(value); - } - - @NonNull - @Override - public Operator rem(@NonNull T value) { - return getCondition().rem(value); - } - - - @Override - @NonNull - public OrderBy asc() { - return OrderBy.fromProperty(this).ascending(); - } - - @Override - @NonNull - public OrderBy desc() { - return OrderBy.fromProperty(this).descending(); - } - - /** - * @return helper method to construct it in a {@link #distinct()} call. - */ - protected NameAlias getDistinctAliasName() { - return getNameAlias() - .newBuilder() - .distinct() - .build(); - } - - @NonNull - protected Operator getCondition() { - return op(getNameAlias()); - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/Property.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/Property.kt new file mode 100644 index 000000000..b0680c39f --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/Property.kt @@ -0,0 +1,286 @@ +package com.raizlabs.android.dbflow.sql.language.property + +import com.raizlabs.android.dbflow.config.FlowManager +import com.raizlabs.android.dbflow.sql.language.BaseModelQueriable +import com.raizlabs.android.dbflow.sql.language.IConditional +import com.raizlabs.android.dbflow.sql.language.IOperator +import com.raizlabs.android.dbflow.sql.language.NameAlias +import com.raizlabs.android.dbflow.sql.language.Operator +import com.raizlabs.android.dbflow.sql.language.Operator.op +import com.raizlabs.android.dbflow.sql.language.OrderBy + +/** + * Description: The main, immutable property class that gets generated from a table definition. + * + * + * This class delegates all of its [IOperator] methods to a new [Operator] that's used + * in the SQLite query language. + * + * + * This ensures that the language is strictly type-safe and only declared + * columns get used. Also any calls on the methods return a new [Property]. + * + * + * This is type parametrized so that all values passed to this class remain properly typed. + */ +open class Property : IProperty>, IConditional, IOperator { + + internal val table: Class<*>? + + private lateinit var internalNameAlias: NameAlias + + val definition: String + get() = nameAlias.fullQuery + + /** + * @return helper method to construct it in a [.distinct] call. + */ + private val distinctAliasName: NameAlias + get() = nameAlias + .newBuilder() + .distinct() + .build() + + protected open val operator: Operator + get() = op(nameAlias) + + constructor(table: Class<*>?, nameAlias: NameAlias) { + this.table = table + this.internalNameAlias = nameAlias + } + + constructor(table: Class<*>?, columnName: String?) { + this.table = table + if (columnName != null) { + internalNameAlias = NameAlias.Builder(columnName).build() + } + } + + constructor(table: Class<*>?, columnName: String, aliasName: String) : this(table, NameAlias.builder(columnName).`as`(aliasName).build()) {} + + override fun withTable(): Property { + return withTable(NameAlias.Builder(FlowManager.getTableName(table!!)).build()) + } + + override fun getNameAlias(): NameAlias { + return internalNameAlias + } + + override val query: String + get() = nameAlias.query + + override fun getCursorKey(): String = nameAlias.query + + override fun toString(): String = nameAlias.toString() + + override fun `is`(conditional: IConditional): Operator<*> = operator.`is`(conditional) + + override fun eq(conditional: IConditional): Operator<*> = operator.eq(conditional) + + override fun isNot(conditional: IConditional): Operator<*> = operator.isNot(conditional) + + override fun notEq(conditional: IConditional): Operator<*> = operator.notEq(conditional) + + override fun like(conditional: IConditional): Operator<*> = operator.like(conditional) + + override fun glob(conditional: IConditional): Operator<*> = operator.glob(conditional) + + override fun like(value: String): Operator = operator.like(value) + + override fun notLike(value: String): Operator = operator.notLike(value) + + override fun glob(value: String): Operator = operator.glob(value) + + override fun greaterThan(conditional: IConditional): Operator<*> = + operator.greaterThan(conditional) + + override fun greaterThanOrEq(conditional: IConditional): Operator<*> = + operator.greaterThanOrEq(conditional) + + override fun lessThan(conditional: IConditional): Operator<*> = operator.lessThan(conditional) + + override fun lessThanOrEq(conditional: IConditional): Operator<*> = + operator.lessThanOrEq(conditional) + + override fun between(conditional: IConditional): Operator.Between<*> = + operator.between(conditional) + + override fun `in`(firstConditional: IConditional, vararg conditionals: IConditional): Operator.In<*> = + operator.`in`(firstConditional, *conditionals) + + override fun notIn(firstConditional: IConditional, vararg conditionals: IConditional): Operator.In<*> = + operator.notIn(firstConditional, *conditionals) + + override fun `is`(baseModelQueriable: BaseModelQueriable<*>): Operator<*> = + operator.`is`(baseModelQueriable) + + override fun isNull(): Operator<*> = operator.isNull + + override fun eq(baseModelQueriable: BaseModelQueriable<*>): Operator<*> = + operator.eq(baseModelQueriable) + + override fun isNot(baseModelQueriable: BaseModelQueriable<*>): Operator<*> = + operator.isNot(baseModelQueriable) + + override fun isNotNull(): Operator<*> = operator.isNotNull + + override fun notEq(baseModelQueriable: BaseModelQueriable<*>): Operator<*> = + operator.notEq(baseModelQueriable) + + override fun like(baseModelQueriable: BaseModelQueriable<*>): Operator<*> = + operator.like(baseModelQueriable) + + override fun notLike(conditional: IConditional): Operator<*> = operator.notLike(conditional) + + override fun notLike(baseModelQueriable: BaseModelQueriable<*>): Operator<*> = + operator.notLike(baseModelQueriable) + + override fun glob(baseModelQueriable: BaseModelQueriable<*>): Operator<*> = + operator.glob(baseModelQueriable) + + override fun greaterThan(baseModelQueriable: BaseModelQueriable<*>): Operator<*> = + operator.greaterThan(baseModelQueriable) + + override fun greaterThanOrEq(baseModelQueriable: BaseModelQueriable<*>): Operator<*> = + operator.greaterThanOrEq(baseModelQueriable) + + override fun lessThan(baseModelQueriable: BaseModelQueriable<*>): Operator<*> = + operator.lessThan(baseModelQueriable) + + override fun lessThanOrEq(baseModelQueriable: BaseModelQueriable<*>): Operator<*> = + operator.lessThanOrEq(baseModelQueriable) + + override fun between(baseModelQueriable: BaseModelQueriable<*>): Operator.Between<*> = + operator.between(baseModelQueriable) + + override fun `in`(firstBaseModelQueriable: BaseModelQueriable<*>, + vararg baseModelQueriables: BaseModelQueriable<*>): Operator.In<*> { + return operator.`in`(firstBaseModelQueriable, *baseModelQueriables) + } + + override fun notIn(firstBaseModelQueriable: BaseModelQueriable<*>, + vararg baseModelQueriables: BaseModelQueriable<*>): Operator.In<*> { + return operator.notIn(firstBaseModelQueriable, *baseModelQueriables) + } + + override fun concatenate(conditional: IConditional): Operator<*> = + operator.concatenate(conditional) + + override fun plus(value: BaseModelQueriable<*>): Operator<*> = operator.plus(value) + + override fun minus(value: BaseModelQueriable<*>): Operator<*> = operator.minus(value) + + override fun div(value: BaseModelQueriable<*>): Operator<*> = operator.div(value) + + override fun times(value: BaseModelQueriable<*>): Operator<*> = operator.times(value) + + override fun rem(value: BaseModelQueriable<*>): Operator<*> = operator.rem(value) + + override fun getTable(): Class<*> { + return table!! + } + + override fun plus(iProperty: IProperty<*>): Property { + return Property(table, NameAlias.joinNames(Operator.Operation.PLUS, + internalNameAlias.fullName(), iProperty.toString())) + } + + override fun minus(iProperty: IProperty<*>): Property { + return Property(table, NameAlias.joinNames(Operator.Operation.MINUS, + internalNameAlias.fullName(), iProperty.toString())) + } + + override fun div(iProperty: IProperty<*>): Property { + return Property(table, NameAlias.joinNames(Operator.Operation.DIVISION, + internalNameAlias.fullName(), iProperty.toString())) + } + + override fun times(iProperty: IProperty<*>): Property { + return Property(table, NameAlias.joinNames(Operator.Operation.MULTIPLY, + internalNameAlias.fullName(), iProperty.toString())) + } + + override fun rem(iProperty: IProperty<*>): Property { + return Property(table, NameAlias.joinNames(Operator.Operation.MOD, + internalNameAlias.fullName(), iProperty.toString())) + } + + override fun concatenate(iProperty: IProperty<*>): Property { + return Property(table, NameAlias.joinNames(Operator.Operation.CONCATENATE, + internalNameAlias.fullName(), iProperty.toString())) + } + + override fun `as`(aliasName: String): Property { + return Property(table, nameAlias + .newBuilder() + .`as`(aliasName) + .build()) + } + + override fun distinct(): Property = Property(table, distinctAliasName) + + override fun withTable(tableNameAlias: NameAlias): Property { + return Property(table, nameAlias + .newBuilder() + .withTable(tableNameAlias.query) + .build()) + } + + override fun `is`(value: T?): Operator = operator.`is`(value) + + override fun eq(value: T?): Operator = operator.eq(value) + + override fun isNot(value: T?): Operator = operator.isNot(value) + + override fun notEq(value: T?): Operator = operator.notEq(value) + + override fun greaterThan(value: T): Operator = operator.greaterThan(value) + + override fun greaterThanOrEq(value: T): Operator = operator.greaterThanOrEq(value) + + override fun lessThan(value: T): Operator = operator.lessThan(value) + + override fun lessThanOrEq(value: T): Operator = operator.lessThanOrEq(value) + + override fun between(value: T): Operator.Between = operator.between(value) + + override fun `in`(firstValue: T, vararg values: T): Operator.In = + operator.`in`(firstValue, *values) + + override fun notIn(firstValue: T, vararg values: T): Operator.In = + operator.notIn(firstValue, *values) + + override fun `in`(values: Collection): Operator.In = operator.`in`(values) + + override fun notIn(values: Collection): Operator.In = operator.notIn(values) + + override fun concatenate(value: T?): Operator = operator.concatenate(value) + + override fun plus(value: T): Operator = operator.plus(value) + + override fun minus(value: T): Operator = operator.minus(value) + + override fun div(value: T): Operator = operator.div(value) + + override fun times(value: T): Operator = operator.times(value) + + override fun rem(value: T): Operator = operator.rem(value) + + override fun asc(): OrderBy = OrderBy.fromProperty(this).ascending() + + override fun desc(): OrderBy = OrderBy.fromProperty(this).descending() + + companion object { + + @JvmStatic + val ALL_PROPERTY = Property(null, NameAlias.rawBuilder("*").build()) + + @JvmStatic + val WILDCARD: Property<*> = Property(null, NameAlias.rawBuilder("?").build()) + + @JvmStatic + fun allProperty(table: Class<*>): Property { + return Property(table, NameAlias.rawBuilder("*").build()).withTable() + } + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/PropertyFactory.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/PropertyFactory.java deleted file mode 100644 index 6b6457b5d..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/PropertyFactory.java +++ /dev/null @@ -1,142 +0,0 @@ -package com.raizlabs.android.dbflow.sql.language.property; - -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.sql.language.NameAlias; -import com.raizlabs.android.dbflow.sql.language.Operator; -import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable; - -/** - * Description: Provides some useful methods for creating {@link IProperty} from non-property types. - */ -public class PropertyFactory { - - /** - * Converts a char into a {@link Property} as its value represented by string. - * - * @param c the char to convert. - * @return A new property. - */ - @NonNull - public static Property from(char c) { - return new Property<>(null, NameAlias.rawBuilder("'" + c + "'") - .build()); - } - - /** - * Converts a int into a {@link Property} as its value represented by string. - * - * @param i the int to convert. - * @return A new property. - */ - @NonNull - public static Property from(int i) { - return new Property<>(null, NameAlias.rawBuilder(i + "") - .build()); - } - - /** - * Converts a double into a {@link Property} as its value represented by string. - * - * @param d the double to convert. - * @return A new property. - */ - @NonNull - public static Property from(double d) { - return new Property<>(null, NameAlias.rawBuilder(d + "") - .build()); - } - - /** - * Converts a long into a {@link Property} as its value represented by string. - * - * @param l the long to convert. - * @return A new property. - */ - @NonNull - public static Property from(long l) { - return new Property<>(null, NameAlias.rawBuilder(l + "") - .build()); - } - - /** - * Converts a float into a {@link Property} as its value represented by string. - * - * @param f the float to convert. - * @return A new property. - */ - @NonNull - public static Property from(float f) { - return new Property<>(null, NameAlias.rawBuilder(f + "") - .build()); - } - - /** - * Converts a short into a {@link Property} as its value represented by string. - * - * @param s the short to convert. - * @return A new property. - */ - @NonNull - public static Property from(short s) { - return new Property<>(null, NameAlias.rawBuilder(s + "") - .build()); - } - - /** - * Converts a byte into a {@link Property} as its value represented by string. - * - * @param b the byte to convert. - * @return A new property. - */ - @NonNull - public static Property from(byte b) { - return new Property<>(null, NameAlias.rawBuilder(b + "") - .build()); - } - - /** - * Creates a new type-parameterized {@link Property} to be used as its value represented by a string - * using {@link Operator#convertValueToString(Object)}. - *

- * It will not convert a String column name - * into a property, rather it assumes its database value represented by the String. - * - * @param type The object with value to use. - * @param The parameter of its type. - * @return A new property with its type. - */ - @NonNull - public static Property from(@Nullable T type) { - return new Property<>(null, NameAlias.rawBuilder( - Operator.convertValueToString(type)) - .build()); - } - - /** - * Creates a new {@link Property} that is used to allow selects in a query. - * - * @param queriable The queriable to use and evaulated into a query. - * @param The model class of the query. - * @return A new property that is a query. - */ - @NonNull - public static Property from(@NonNull ModelQueriable queriable) { - return from(queriable.getTable(), "(" + String.valueOf(queriable.getQuery()).trim() + ")"); - } - - /** - * Creates a new type-parameterized {@link Property} to be used as its value represented by the string passed in. - * - * @param type The type to return. - * @param stringRepresentation The string representation of the object you wish to use. - * @param The parameter of its type. - * @return A new property with its type. - */ - @NonNull - public static Property from(@Nullable Class type, @Nullable String stringRepresentation) { - return new Property<>(null, NameAlias.rawBuilder(stringRepresentation) - .build()); - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/PropertyFactory.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/PropertyFactory.kt new file mode 100644 index 000000000..fade08749 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/PropertyFactory.kt @@ -0,0 +1,139 @@ +package com.raizlabs.android.dbflow.sql.language.property + +import com.raizlabs.android.dbflow.sql.language.NameAlias +import com.raizlabs.android.dbflow.sql.language.Operator +import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable + +/** + * Description: Provides some useful methods for creating [IProperty] from non-property types. + */ +object PropertyFactory { + + /** + * Converts a char into a [Property] as its value represented by string. + * + * @param c the char to convert. + * @return A new property. + */ + @JvmStatic + fun from(c: Char): Property { + return Property(null, NameAlias.rawBuilder("'$c'") + .build()) + } + + /** + * Converts a int into a [Property] as its value represented by string. + * + * @param i the int to convert. + * @return A new property. + */ + @JvmStatic + fun from(i: Int): Property { + return Property(null, NameAlias.rawBuilder(i.toString() + "") + .build()) + } + + /** + * Converts a double into a [Property] as its value represented by string. + * + * @param d the double to convert. + * @return A new property. + */ + @JvmStatic + fun from(d: Double): Property { + return Property(null, NameAlias.rawBuilder(d.toString() + "") + .build()) + } + + /** + * Converts a long into a [Property] as its value represented by string. + * + * @param l the long to convert. + * @return A new property. + */ + @JvmStatic + fun from(l: Long): Property { + return Property(null, NameAlias.rawBuilder(l.toString() + "") + .build()) + } + + /** + * Converts a float into a [Property] as its value represented by string. + * + * @param f the float to convert. + * @return A new property. + */ + @JvmStatic + fun from(f: Float): Property { + return Property(null, NameAlias.rawBuilder(f.toString() + "") + .build()) + } + + /** + * Converts a short into a [Property] as its value represented by string. + * + * @param s the short to convert. + * @return A new property. + */ + @JvmStatic + fun from(s: Short): Property { + return Property(null, NameAlias.rawBuilder(s.toString() + "") + .build()) + } + + /** + * Converts a byte into a [Property] as its value represented by string. + * + * @param b the byte to convert. + * @return A new property. + */ + @JvmStatic + fun from(b: Byte): Property { + return Property(null, NameAlias.rawBuilder(b.toString() + "") + .build()) + } + + /** + * Creates a new type-parameterized [Property] to be used as its value represented by a string + * using [Operator.convertValueToString]. + * + * + * It will not convert a String column name + * into a property, rather it assumes its database value represented by the String. + * + * @param type The object with value to use. + * @param The parameter of its type. + * @return A new property with its type. + */ + @JvmStatic + fun from(type: T?): Property { + return Property(null, NameAlias.rawBuilder( + Operator.convertValueToString(type)) + .build()) + } + + /** + * Creates a new [Property] that is used to allow selects in a query. + * + * @param queriable The queriable to use and evaulated into a query. + * @param The model class of the query. + * @return A new property that is a query. + */ + @JvmStatic + fun from(queriable: ModelQueriable): Property { + return from(queriable.table, "(${queriable.query.trim { it <= ' ' }})") + } + + /** + * Creates a new type-parameterized [Property] to be used as its value represented by the string passed in. + * + * @param stringRepresentation The string representation of the object you wish to use. + * @param The parameter of its type. + * @return A new property with its type. + */ + @JvmStatic + fun from(table: Class, stringRepresentation: String?): Property { + return Property(null, NameAlias.rawBuilder(stringRepresentation) + .build()) + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/TypeConvertedProperty.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/TypeConvertedProperty.java deleted file mode 100644 index 0fa7eca83..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/TypeConvertedProperty.java +++ /dev/null @@ -1,84 +0,0 @@ -package com.raizlabs.android.dbflow.sql.language.property; - -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.converter.TypeConverter; -import com.raizlabs.android.dbflow.sql.language.NameAlias; -import com.raizlabs.android.dbflow.sql.language.Operator; -import com.raizlabs.android.dbflow.structure.ModelAdapter; - -import static com.raizlabs.android.dbflow.sql.language.Operator.op; - -/** - * Description: Provides convenience methods for {@link TypeConverter} when constructing queries. - * - * @author Andrew Grosner (fuzz) - */ - -public class TypeConvertedProperty extends Property { - - /** - * Generated by the compiler, looks up the type converter based on {@link ModelAdapter} when needed. - * This is so we can properly retrieve the type converter at any time. - */ - public interface TypeConverterGetter { - - TypeConverter getTypeConverter(Class modelClass); - } - - private TypeConvertedProperty databaseProperty; - - private boolean convertToDB; - - private final TypeConverterGetter getter; - - public TypeConvertedProperty(Class table, NameAlias nameAlias, - boolean convertToDB, - TypeConverterGetter getter) { - super(table, nameAlias); - this.convertToDB = convertToDB; - this.getter = getter; - } - - public TypeConvertedProperty(Class table, String columnName, - boolean convertToDB, - TypeConverterGetter getter) { - super(table, columnName); - this.convertToDB = convertToDB; - this.getter = getter; - } - - @NonNull - @Override - protected Operator getCondition() { - return op(getNameAlias(), getter.getTypeConverter(table), convertToDB); - } - - /** - * @return A new {@link Property} that corresponds to the inverted type of the {@link TypeConvertedProperty}. - * Provides a convenience for supplying type converted methods within the DataClass of the {@link TypeConverter} - */ - @NonNull - public Property invertProperty() { - if (databaseProperty == null) { - databaseProperty = new TypeConvertedProperty<>(table, nameAlias, - !convertToDB, new TypeConverterGetter() { - @Override - public TypeConverter getTypeConverter(Class modelClass) { - return getter.getTypeConverter(modelClass); - } - }); - } - return databaseProperty; - } - - @NonNull - @Override - public Property withTable(@NonNull NameAlias tableNameAlias) { - NameAlias nameAlias = this.getNameAlias() - .newBuilder() - .withTable(tableNameAlias.getQuery()) - .build(); - return new TypeConvertedProperty<>(this.getTable(), nameAlias, this.convertToDB, this.getter); - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/TypeConvertedProperty.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/TypeConvertedProperty.kt new file mode 100644 index 000000000..2ebbb9620 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/TypeConvertedProperty.kt @@ -0,0 +1,72 @@ +package com.raizlabs.android.dbflow.sql.language.property + +import com.raizlabs.android.dbflow.converter.TypeConverter +import com.raizlabs.android.dbflow.sql.language.NameAlias +import com.raizlabs.android.dbflow.sql.language.Operator +import com.raizlabs.android.dbflow.sql.language.Operator.op +import com.raizlabs.android.dbflow.structure.ModelAdapter + +/** + * Description: Provides convenience methods for [TypeConverter] when constructing queries. + * + * @author Andrew Grosner (fuzz) + */ + +class TypeConvertedProperty : Property { + + private var databaseProperty: TypeConvertedProperty? = null + + private var convertToDB: Boolean = false + + private val getter: TypeConverterGetter + + override val operator: Operator + get() = op(nameAlias, getter.getTypeConverter(getTable()), convertToDB) + + /** + * Generated by the compiler, looks up the type converter based on [ModelAdapter] when needed. + * This is so we can properly retrieve the type converter at any time. + */ + interface TypeConverterGetter { + + fun getTypeConverter(modelClass: Class<*>): TypeConverter<*, *> + } + + constructor(table: Class<*>, nameAlias: NameAlias, + convertToDB: Boolean, + getter: TypeConverterGetter) : super(table, nameAlias) { + this.convertToDB = convertToDB + this.getter = getter + } + + constructor(table: Class<*>, columnName: String, + convertToDB: Boolean, + getter: TypeConverterGetter) : super(table, columnName) { + this.convertToDB = convertToDB + this.getter = getter + } + + /** + * @return A new [Property] that corresponds to the inverted type of the [TypeConvertedProperty]. + * Provides a convenience for supplying type converted methods within the DataClass of the [TypeConverter] + */ + fun invertProperty(): Property { + if (databaseProperty == null) { + databaseProperty = TypeConvertedProperty(getTable(), nameAlias, + !convertToDB, object : TypeConverterGetter { + override fun getTypeConverter(modelClass: Class<*>): TypeConverter<*, *> { + return getter.getTypeConverter(modelClass) + } + }) + } + return databaseProperty!! + } + + override fun withTable(tableNameAlias: NameAlias): Property { + val nameAlias = this.nameAlias + .newBuilder() + .withTable(tableNameAlias.query) + .build() + return TypeConvertedProperty(this.getTable(), nameAlias, this.convertToDB, this.getter) + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/WrapperProperty.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/WrapperProperty.java deleted file mode 100644 index e7e3dba35..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/WrapperProperty.java +++ /dev/null @@ -1,36 +0,0 @@ -package com.raizlabs.android.dbflow.sql.language.property; - -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.sql.language.NameAlias; - -/** - * Description: Provides convenience for types that are represented in different ways in the DB. - * - * @author Andrew Grosner (fuzz) - */ -public class WrapperProperty extends Property { - - private WrapperProperty databaseProperty; - - public WrapperProperty(@NonNull Class table, @NonNull NameAlias nameAlias) { - super(table, nameAlias); - } - - public WrapperProperty(@NonNull Class table, @NonNull String columnName) { - super(table, columnName); - } - - /** - * @return A new {@link Property} that corresponds to the inverted type of the {@link WrapperProperty}. Convenience - * for types that have different DB representations. - */ - @SuppressWarnings("ConstantConditions") - @NonNull - public Property invertProperty() { - if (databaseProperty == null) { - databaseProperty = new WrapperProperty<>(table, nameAlias); - } - return databaseProperty; - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/WrapperProperty.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/WrapperProperty.kt new file mode 100644 index 000000000..24b0dfefd --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/WrapperProperty.kt @@ -0,0 +1,28 @@ +package com.raizlabs.android.dbflow.sql.language.property + +import com.raizlabs.android.dbflow.sql.language.NameAlias + +/** + * Description: Provides convenience for types that are represented in different ways in the DB. + * + * @author Andrew Grosner (fuzz) + */ +class WrapperProperty : Property { + + private var databaseProperty: WrapperProperty? = null + + constructor(table: Class<*>, nameAlias: NameAlias) : super(table, nameAlias) + + constructor(table: Class<*>, columnName: String) : super(table, columnName) + + /** + * @return A new [Property] that corresponds to the inverted type of the [WrapperProperty]. Convenience + * for types that have different DB representations. + */ + fun invertProperty(): Property { + if (databaseProperty == null) { + databaseProperty = WrapperProperty(getTable(), nameAlias) + } + return databaseProperty!! + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/AlterTableMigration.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/AlterTableMigration.java deleted file mode 100644 index 75d17f6de..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/AlterTableMigration.java +++ /dev/null @@ -1,192 +0,0 @@ -package com.raizlabs.android.dbflow.sql.migration; - -import android.database.Cursor; -import android.support.annotation.CallSuper; -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.config.FlowManager; -import com.raizlabs.android.dbflow.sql.QueryBuilder; -import com.raizlabs.android.dbflow.sql.SQLiteType; -import com.raizlabs.android.dbflow.sql.language.SQLite; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; - -import java.util.ArrayList; -import java.util.List; - -/** - * Description: Provides a very nice way to alter a single table quickly and easily. - */ -public class AlterTableMigration extends BaseMigration { - - /** - * The table to ALTER - */ - private final Class table; - - /** - * The query we use - */ - private QueryBuilder query; - - /** - * The query to rename the table with - */ - private QueryBuilder renameQuery; - - /** - * The columns to ALTER within a table - */ - private List columnDefinitions; - - private List columnNames; - - /** - * The old name of the table before renaming it - */ - private String oldTableName; - - public AlterTableMigration(Class table) { - this.table = table; - } - - @Override - public final void migrate(@NonNull DatabaseWrapper database) { - // "ALTER TABLE " - String sql = getAlterTableQueryBuilder().getQuery(); - String tableName = FlowManager.getTableName(table); - - // "{oldName} RENAME TO {newName}" - // Since the structure has been updated already, the manager knows only the new name. - if (renameQuery != null) { - String renameQuery = new QueryBuilder(sql).appendQuotedIfNeeded(oldTableName) - .append(this.renameQuery.getQuery()) - .append(tableName) - .toString(); - database.execSQL(renameQuery); - } - - // We have column definitions to add here - // ADD COLUMN columnName {type} - if (columnDefinitions != null) { - - Cursor cursorToCheckColumnFor = SQLite.select().from(table).limit(0).query(database); - if (cursorToCheckColumnFor != null) { - try { - sql = new QueryBuilder(sql).append(tableName).toString(); - for (int i = 0; i < columnDefinitions.size(); i++) { - QueryBuilder columnDefinition = columnDefinitions.get(i); - String columnName = QueryBuilder.stripQuotes(columnNames.get(i)); - if (cursorToCheckColumnFor.getColumnIndex(columnName) == -1) { - database.execSQL(sql + " ADD COLUMN " + columnDefinition.getQuery()); - } - } - } finally { - cursorToCheckColumnFor.close(); - } - } - } - } - - @CallSuper - @Override - public void onPostMigrate() { - // cleanup and make fields eligible for garbage collection - query = null; - renameQuery = null; - columnDefinitions = null; - columnNames = null; - } - - /** - * Call this to rename a table to a new name, such as changing either the {@link com.raizlabs.android.dbflow.structure.Model} class name - * or by changing the name through a {@link com.raizlabs.android.dbflow.annotation.Table} - * - * @param oldName The new name to call the table. - * @return This instance - */ - public AlterTableMigration renameFrom(@NonNull String oldName) { - oldTableName = oldName; - renameQuery = new QueryBuilder().append(" RENAME").appendSpaceSeparated("TO"); - return this; - } - - /** - * Add a column to the DB. This does not necessarily need to be reflected in the {@link TModel}, - * but it is recommended. - * - * @param sqLiteType The type of column represented in the DB. - * @param columnName The name of the column to add. Use the "_Table" class for the specified table. - * @return This instance - */ - public AlterTableMigration addColumn(@NonNull SQLiteType sqLiteType, @NonNull String columnName) { - if (columnDefinitions == null) { - columnDefinitions = new ArrayList<>(); - columnNames = new ArrayList<>(); - } - - QueryBuilder queryBuilder = new QueryBuilder() - .append(QueryBuilder.quoteIfNeeded(columnName)).appendSpace().appendSQLiteType(sqLiteType); - columnDefinitions.add(queryBuilder); - columnNames.add(columnName); - - return this; - } - - /** - * Add a column to the DB. This does not necessarily need to be reflected in the {@link TModel}, - * but it is recommended. - * - * @param sqLiteType The type of column that pertains to an {@link SQLiteType} - * @param columnName The name of the column to add. Use the "$Table" class for the specified table. - * @param referenceClause The clause of the references that this foreign key points to. - * @return This instance - */ - public AlterTableMigration addForeignKeyColumn(SQLiteType sqLiteType, String columnName, String referenceClause) { - if (columnDefinitions == null) { - columnDefinitions = new ArrayList<>(); - columnNames = new ArrayList<>(); - } - - QueryBuilder queryBuilder = new QueryBuilder() - .append(QueryBuilder.quoteIfNeeded(columnName)).appendSpace().appendSQLiteType(sqLiteType) - .appendSpace().append("REFERENCES ").append(referenceClause); - columnDefinitions.add(queryBuilder); - columnNames.add(columnName); - - return this; - } - - /** - * @return The query that renames the table. - */ - public String getRenameQuery() { - QueryBuilder queryBuilder = new QueryBuilder(getAlterTableQueryBuilder().getQuery()).appendQuotedIfNeeded(oldTableName) - .append(renameQuery).append(FlowManager.getTableName(table)); - return queryBuilder.getQuery(); - } - - /** - * @return A List of column definitions that add op to a table in the DB. - */ - public List getColumnDefinitions() { - String sql = new QueryBuilder(getAlterTableQueryBuilder()).append(FlowManager.getTableName(table)).toString(); - List columnDefinitions = new ArrayList<>(); - - if (this.columnDefinitions != null) { - for (QueryBuilder columnDefinition : this.columnDefinitions) { - QueryBuilder queryBuilder = new QueryBuilder(sql).appendSpaceSeparated("ADD COLUMN").append( - columnDefinition.getQuery()); - columnDefinitions.add(queryBuilder.getQuery()); - } - } - - return columnDefinitions; - } - - public QueryBuilder getAlterTableQueryBuilder() { - if (query == null) { - query = new QueryBuilder().append("ALTER").appendSpaceSeparated("TABLE"); - } - return query; - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/AlterTableMigration.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/AlterTableMigration.kt new file mode 100644 index 000000000..98b6bc361 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/AlterTableMigration.kt @@ -0,0 +1,143 @@ +package com.raizlabs.android.dbflow.sql.migration + +import android.support.annotation.CallSuper +import com.raizlabs.android.dbflow.config.FlowManager +import com.raizlabs.android.dbflow.sql.QueryBuilder +import com.raizlabs.android.dbflow.sql.SQLiteType +import com.raizlabs.android.dbflow.sql.language.SQLite +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper + +/** + * Description: Provides a very nice way to alter a single table quickly and easily. + */ +class AlterTableMigration( + /** + * The table to ALTER + */ + private val table: Class) : BaseMigration() { + + /** + * The query we use + */ + private val query by lazy { QueryBuilder().append("ALTER").appendSpaceSeparated("TABLE") } + + /** + * The query to rename the table with + */ + private var renameQuery: QueryBuilder? = null + + /** + * The columns to ALTER within a table + */ + private val internalColumnDefinitions: MutableList by lazy { mutableListOf() } + + private val columnNames: MutableList by lazy { arrayListOf() } + + /** + * The old name of the table before renaming it + */ + private var oldTableName: String? = null + + val alterTableQueryBuilder: QueryBuilder + get() = query + + override fun migrate(database: DatabaseWrapper) { + // "ALTER TABLE " + var sql = alterTableQueryBuilder.query + val tableName = FlowManager.getTableName(table) + + // "{oldName} RENAME TO {newName}" + // Since the structure has been updated already, the manager knows only the new name. + if (renameQuery != null) { + val renameQuery = QueryBuilder(sql).appendQuotedIfNeeded(oldTableName) + .append(this.renameQuery!!.query) + .append(tableName) + .toString() + database.execSQL(renameQuery) + } + + // We have column definitions to add here + // ADD COLUMN columnName {type} + if (internalColumnDefinitions.isNotEmpty()) { + SQLite.select().from(table).limit(0).query(database)?.use { cursor -> + sql = QueryBuilder(sql).append(tableName).toString() + for (i in internalColumnDefinitions.indices) { + val columnDefinition = internalColumnDefinitions[i] + val columnName = QueryBuilder.stripQuotes(columnNames!![i]) + if (cursor.getColumnIndex(columnName) == -1) { + database.execSQL("$sql ADD COLUMN ${columnDefinition.query}") + } + } + } + } + } + + @CallSuper + override fun onPostMigrate() { + // cleanup and make fields eligible for garbage collection + renameQuery = null + internalColumnDefinitions.clear() + columnNames.clear() + } + + /** + * Call this to rename a table to a new name, such as changing either the [com.raizlabs.android.dbflow.structure.Model] class name + * or by changing the name through a [com.raizlabs.android.dbflow.annotation.Table] + * + * @param oldName The new name to call the table. + * @return This instance + */ + fun renameFrom(oldName: String) = apply { + oldTableName = oldName + renameQuery = QueryBuilder().append(" RENAME").appendSpaceSeparated("TO") + } + + /** + * Add a column to the DB. This does not necessarily need to be reflected in the [TModel], + * but it is recommended. + * + * @param sqLiteType The type of column represented in the DB. + * @param columnName The name of the column to add. Use the "_Table" class for the specified table. + * @return This instance + */ + fun addColumn(sqLiteType: SQLiteType, columnName: String) = apply { + val queryBuilder = QueryBuilder() + .append(QueryBuilder.quoteIfNeeded(columnName)).appendSpace().appendSQLiteType(sqLiteType) + internalColumnDefinitions.add(queryBuilder) + columnNames.add(columnName) + } + + /** + * Add a column to the DB. This does not necessarily need to be reflected in the [TModel], + * but it is recommended. + * + * @param sqLiteType The type of column that pertains to an [SQLiteType] + * @param columnName The name of the column to add. Use the "$Table" class for the specified table. + * @param referenceClause The clause of the references that this foreign key points to. + * @return This instance + */ + fun addForeignKeyColumn(sqLiteType: SQLiteType, columnName: String, referenceClause: String) = apply { + val queryBuilder = QueryBuilder() + .append(QueryBuilder.quoteIfNeeded(columnName)).appendSpace().appendSQLiteType(sqLiteType) + .appendSpace().append("REFERENCES ").append(referenceClause) + internalColumnDefinitions.add(queryBuilder) + columnNames.add(columnName) + } + + /** + * @return The query that renames the table. + */ + fun getRenameQuery(): String { + val queryBuilder = QueryBuilder(alterTableQueryBuilder.query).appendQuotedIfNeeded(oldTableName) + .append(renameQuery).append(FlowManager.getTableName(table)) + return queryBuilder.query + } + + /** + * @return A List of column definitions that add op to a table in the DB. + */ + fun getColumnDefinitions(): List { + val sql = QueryBuilder(alterTableQueryBuilder).append(FlowManager.getTableName(table)).toString() + return internalColumnDefinitions.map { QueryBuilder(sql).appendSpaceSeparated("ADD COLUMN").append(it.query).query } + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/BaseMigration.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/BaseMigration.java deleted file mode 100644 index d2a6ff687..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/BaseMigration.java +++ /dev/null @@ -1,26 +0,0 @@ -package com.raizlabs.android.dbflow.sql.migration; - -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; - -/** - * Description: Provides the base implementation of {@link com.raizlabs.android.dbflow.sql.migration.Migration} with - * only {@link Migration#migrate(DatabaseWrapper)} needing to be implemented. - */ -public abstract class BaseMigration implements Migration { - - - @Override - public void onPreMigrate() { - - } - - @Override - public abstract void migrate(@NonNull DatabaseWrapper database); - - @Override - public void onPostMigrate() { - - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/BaseMigration.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/BaseMigration.kt new file mode 100644 index 000000000..393c077f9 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/BaseMigration.kt @@ -0,0 +1,21 @@ +package com.raizlabs.android.dbflow.sql.migration + +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper + +/** + * Description: Provides the base implementation of [com.raizlabs.android.dbflow.sql.migration.Migration] with + * only [Migration.migrate] needing to be implemented. + */ +abstract class BaseMigration : Migration { + + + override fun onPreMigrate() { + + } + + abstract override fun migrate(database: DatabaseWrapper) + + override fun onPostMigrate() { + + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/IndexMigration.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/IndexMigration.java deleted file mode 100644 index 668a05152..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/IndexMigration.java +++ /dev/null @@ -1,91 +0,0 @@ -package com.raizlabs.android.dbflow.sql.migration; - -import android.support.annotation.CallSuper; -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.sql.language.Index; -import com.raizlabs.android.dbflow.sql.language.property.IProperty; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; - -/** - * Description: Defines and enables an Index structurally through a migration. - */ -public abstract class IndexMigration extends BaseMigration { - - /** - * The table to index on - */ - private Class onTable; - - /** - * The underlying index object. - */ - private Index index; - - public IndexMigration(@NonNull Class onTable) { - this.onTable = onTable; - } - - @NonNull - public abstract String getName(); - - @CallSuper - @Override - public void onPreMigrate() { - index = getIndex(); - } - - @Override - public final void migrate(@NonNull DatabaseWrapper database) { - database.execSQL(getIndex().getQuery()); - } - - @CallSuper - @Override - public void onPostMigrate() { - onTable = null; - index = null; - } - - /** - * Adds a column to the underlying INDEX - * - * @param property The name of the column to add to the Index - * @return This migration - */ - @NonNull - public IndexMigration addColumn(IProperty property) { - getIndex().and(property); - return this; - } - - /** - * Sets the INDEX to UNIQUE - * - * @return This migration. - */ - @NonNull - public IndexMigration unique() { - getIndex().unique(true); - return this; - } - - /** - * @return The index object based on the contents of this migration. - */ - @NonNull - public Index getIndex() { - if (index == null) { - index = new Index(getName()).on(onTable); - } - return index; - } - - /** - * @return the query backing this migration. - */ - @NonNull - public String getIndexQuery() { - return getIndex().getQuery(); - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/IndexMigration.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/IndexMigration.kt new file mode 100644 index 000000000..45fa78f28 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/IndexMigration.kt @@ -0,0 +1,52 @@ +package com.raizlabs.android.dbflow.sql.migration + +import com.raizlabs.android.dbflow.sql.language.Index +import com.raizlabs.android.dbflow.sql.language.property.IProperty +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper + +/** + * Description: Defines and enables an Index structurally through a migration. + */ +abstract class IndexMigration( + /** + * The table to index on + */ + private var onTable: Class) : BaseMigration() { + + /** + * The underlying index object. + */ + val index: Index by lazy { Index(name).on(onTable) } + + abstract val name: String + + /** + * @return the query backing this migration. + */ + val indexQuery: String + get() = index.query + + override fun migrate(database: DatabaseWrapper) { + database.execSQL(index.query) + } + + /** + * Adds a column to the underlying INDEX + * + * @param property The name of the column to add to the Index + * @return This migration + */ + fun addColumn(property: IProperty<*>) = apply { + index.and(property) + } + + /** + * Sets the INDEX to UNIQUE + * + * @return This migration. + */ + fun unique() = apply { + index.unique(true) + } + +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/IndexPropertyMigration.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/IndexPropertyMigration.java deleted file mode 100644 index 6a7a7ab68..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/IndexPropertyMigration.java +++ /dev/null @@ -1,31 +0,0 @@ -package com.raizlabs.android.dbflow.sql.migration; - -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.sql.language.property.IndexProperty; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; - -/** - * Description: Allows you to specify if and when an {@link IndexProperty} gets used or created. - */ -public abstract class IndexPropertyMigration extends BaseMigration { - - @NonNull - public abstract IndexProperty getIndexProperty(); - - /** - * @return true if create the index, false to drop the index. - */ - public boolean shouldCreate() { - return true; - } - - @Override - public void migrate(@NonNull DatabaseWrapper database) { - if (shouldCreate()) { - getIndexProperty().createIfNotExists(database); - } else { - getIndexProperty().drop(database); - } - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/IndexPropertyMigration.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/IndexPropertyMigration.kt new file mode 100644 index 000000000..e93010c72 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/IndexPropertyMigration.kt @@ -0,0 +1,24 @@ +package com.raizlabs.android.dbflow.sql.migration + +import com.raizlabs.android.dbflow.sql.language.property.IndexProperty +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper + +/** + * Description: Allows you to specify if and when an [IndexProperty] gets used or created. + */ +abstract class IndexPropertyMigration( + /** + * @return true if create the index, false to drop the index. + */ + open val shouldCreate: Boolean = true) : BaseMigration() { + + abstract val indexProperty: IndexProperty<*> + + override fun migrate(database: DatabaseWrapper) { + if (shouldCreate) { + indexProperty.createIfNotExists(database) + } else { + indexProperty.drop(database) + } + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/Migration.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/Migration.kt similarity index 58% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/Migration.java rename to dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/Migration.kt index 3b4980d0a..93081760c 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/Migration.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/Migration.kt @@ -1,29 +1,27 @@ -package com.raizlabs.android.dbflow.sql.migration; +package com.raizlabs.android.dbflow.sql.migration -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper /** - * Description: Called when the Database is migrating. We can perform custom migrations here. A {@link com.raizlabs.android.dbflow.annotation.Migration} + * Description: Called when the Database is migrating. We can perform custom migrations here. A [com.raizlabs.android.dbflow.annotation.Migration] * is required for registering this class to automatically be called in an upgrade of the DB. */ -public interface Migration { +interface Migration { /** - * Called before we migrate data. Instantiate migration data before releasing it in {@link #onPostMigrate()} + * Called before we migrate data. Instantiate migration data before releasing it in [.onPostMigrate] */ - void onPreMigrate(); + fun onPreMigrate() /** * Perform your migrations here * * @param database The database to operate on */ - void migrate(@NonNull DatabaseWrapper database); + fun migrate(database: DatabaseWrapper) /** * Called after the migration completes. Release migration data here. */ - void onPostMigrate(); + fun onPostMigrate() } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/UpdateTableMigration.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/UpdateTableMigration.java deleted file mode 100644 index 5d4824444..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/UpdateTableMigration.java +++ /dev/null @@ -1,92 +0,0 @@ -package com.raizlabs.android.dbflow.sql.migration; - -import android.support.annotation.CallSuper; -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.sql.language.BaseQueriable; -import com.raizlabs.android.dbflow.sql.language.OperatorGroup; -import com.raizlabs.android.dbflow.sql.language.SQLOperator; -import com.raizlabs.android.dbflow.sql.language.SQLite; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; - -/** - * Description: Provides a simple way to update a table's field or fields quickly in a migration. - * It ties an SQLite {@link com.raizlabs.android.dbflow.sql.language.Update} - * to migrations whenever we want to batch update tables in a structured manner. - */ -public class UpdateTableMigration extends BaseMigration { - - /** - * The table to update - */ - private final Class table; - - /** - * Builds the conditions for the WHERE part of our query - */ - @Nullable - private OperatorGroup whereOperatorGroup; - - /** - * The conditions to use to set fields in the update query - */ - @Nullable - private OperatorGroup setOperatorGroup; - - /** - * Creates an update migration. - * - * @param table The table to update - */ - public UpdateTableMigration(@NonNull Class table) { - this.table = table; - } - - /** - * This will append a condition to this migration. It will execute each of these in succession with the order - * that this is called. - * - * @param conditions The conditions to append - */ - @NonNull - public UpdateTableMigration set(SQLOperator... conditions) { - if (setOperatorGroup == null) { - setOperatorGroup = OperatorGroup.nonGroupingClause(); - } - - setOperatorGroup.andAll(conditions); - return this; - } - - @NonNull - public UpdateTableMigration where(SQLOperator... conditions) { - if (whereOperatorGroup == null) { - whereOperatorGroup = OperatorGroup.nonGroupingClause(); - } - - whereOperatorGroup.andAll(conditions); - return this; - } - - @Override - public final void migrate(@NonNull DatabaseWrapper database) { - getUpdateStatement().execute(database); - } - - @CallSuper - @Override - public void onPostMigrate() { - // make fields eligible for GC - setOperatorGroup = null; - whereOperatorGroup = null; - } - - @NonNull - public BaseQueriable getUpdateStatement() { - return SQLite.update(table) - .set(setOperatorGroup) - .where(whereOperatorGroup); - } - -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/UpdateTableMigration.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/UpdateTableMigration.kt new file mode 100644 index 000000000..679a786fa --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/UpdateTableMigration.kt @@ -0,0 +1,58 @@ +package com.raizlabs.android.dbflow.sql.migration + +import com.raizlabs.android.dbflow.sql.language.BaseQueriable +import com.raizlabs.android.dbflow.sql.language.OperatorGroup +import com.raizlabs.android.dbflow.sql.language.SQLOperator +import com.raizlabs.android.dbflow.sql.language.SQLite +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper + +/** + * Description: Provides a simple way to update a table's field or fields quickly in a migration. + * It ties an SQLite [com.raizlabs.android.dbflow.sql.language.Update] + * to migrations whenever we want to batch update tables in a structured manner. + */ +open class UpdateTableMigration +/** + * Creates an update migration. + * + * @param table The table to update + */ +( + /** + * The table to update + */ + private val table: Class) : BaseMigration() { + + /** + * Builds the conditions for the WHERE part of our query + */ + private val whereOperatorGroup: OperatorGroup by lazy { OperatorGroup.nonGroupingClause() } + + /** + * The conditions to use to set fields in the update query + */ + private val setOperatorGroup: OperatorGroup by lazy { OperatorGroup.nonGroupingClause() } + + val updateStatement: BaseQueriable + get() = SQLite.update(table) + .set(setOperatorGroup) + .where(whereOperatorGroup) + + /** + * This will append a condition to this migration. It will execute each of these in succession with the order + * that this is called. + * + * @param conditions The conditions to append + */ + fun set(vararg conditions: SQLOperator) = apply { + setOperatorGroup.andAll(*conditions) + } + + fun where(vararg conditions: SQLOperator) = apply { + whereOperatorGroup.andAll(*conditions) + } + + override fun migrate(database: DatabaseWrapper) { + updateStatement.execute(database) + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/AsyncQuery.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/AsyncQuery.java deleted file mode 100644 index b44cd8fd6..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/AsyncQuery.java +++ /dev/null @@ -1,73 +0,0 @@ -package com.raizlabs.android.dbflow.sql.queriable; - -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.sql.BaseAsyncObject; -import com.raizlabs.android.dbflow.structure.database.transaction.QueryTransaction; -import com.raizlabs.android.dbflow.structure.database.transaction.QueryTransaction.QueryResultCallback; -import com.raizlabs.android.dbflow.structure.database.transaction.QueryTransaction.QueryResultListCallback; -import com.raizlabs.android.dbflow.structure.database.transaction.QueryTransaction.QueryResultSingleCallback; - -/** - * Description: Adds async methods to a {@link ModelQueriable} - */ -public class AsyncQuery extends BaseAsyncObject> { - - private final ModelQueriable modelQueriable; - private QueryResultCallback queryResultCallback; - private QueryResultListCallback queryResultListCallback; - private QueryResultSingleCallback queryResultSingleCallback; - - /** - * Constructs an instance of this async query. - * - * @param queriable The queriable object to use to query data. - */ - public AsyncQuery(@NonNull ModelQueriable queriable) { - super(queriable.getTable()); - this.modelQueriable = queriable; - } - - /** - * @param queryResultCallback Called when query is executed and has a result. - */ - public AsyncQuery queryResultCallback(@NonNull QueryResultCallback queryResultCallback) { - this.queryResultCallback = queryResultCallback; - return this; - } - - /** - * @param queryResultSingleCallback Called when query is executed and has a result. - */ - public AsyncQuery querySingleResultCallback(@NonNull QueryResultSingleCallback queryResultSingleCallback) { - this.queryResultSingleCallback = queryResultSingleCallback; - return this; - } - - /** - * @param queryResultListCallback Called when query is executed and has a result. - */ - public AsyncQuery queryListResultCallback(@NonNull QueryResultListCallback queryResultListCallback) { - this.queryResultListCallback = queryResultListCallback; - return this; - } - - /** - * Runs the specified query in the background. - */ - public void execute() { - executeTransaction(new QueryTransaction.Builder<>(modelQueriable) - .queryResult(queryResultCallback) - .queryListResult(queryResultListCallback) - .querySingleResult(queryResultSingleCallback) - .build()); - } - - /** - * @return The table this Query is associated with. - */ - public Class getTable() { - return modelQueriable.getTable(); - } - -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/AsyncQuery.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/AsyncQuery.kt new file mode 100644 index 000000000..9ffbd7689 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/AsyncQuery.kt @@ -0,0 +1,60 @@ +package com.raizlabs.android.dbflow.sql.queriable + +import com.raizlabs.android.dbflow.sql.BaseAsyncObject +import com.raizlabs.android.dbflow.structure.database.transaction.QueryTransaction +import com.raizlabs.android.dbflow.structure.database.transaction.QueryTransaction.* + +/** + * Description: Adds async methods to a [ModelQueriable] + */ +class AsyncQuery +/** + * Constructs an instance of this async query. + * + * @param queriable The queriable object to use to query data. + */ +(private val modelQueriable: ModelQueriable) : BaseAsyncObject>(modelQueriable.table) { + + private var queryResultCallback: QueryResultCallback? = null + private var queryResultListCallback: QueryResultListCallback? = null + private var queryResultSingleCallback: QueryResultSingleCallback? = null + + /** + * @param queryResultCallback Called when query is executed and has a result. + */ + fun queryResultCallback(queryResultCallback: QueryResultCallback) = apply { + this.queryResultCallback = queryResultCallback + } + + /** + * @param queryResultSingleCallback Called when query is executed and has a result. + */ + fun querySingleResultCallback(queryResultSingleCallback: QueryResultSingleCallback) = apply { + this.queryResultSingleCallback = queryResultSingleCallback + } + + /** + * @param queryResultListCallback Called when query is executed and has a result. + */ + fun queryListResultCallback(queryResultListCallback: QueryResultListCallback) = apply { + this.queryResultListCallback = queryResultListCallback + } + + /** + * Runs the specified query in the background. + */ + fun execute() { + executeTransaction(QueryTransaction.Builder(modelQueriable) + .queryResult(queryResultCallback) + .queryListResult(queryResultListCallback) + .querySingleResult(queryResultSingleCallback) + .build()) + } + + /** + * @return The table this Query is associated with. + */ + override val table: Class + get() = modelQueriable.table + +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/CacheableListModelLoader.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/CacheableListModelLoader.java deleted file mode 100644 index 99a7c07f6..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/CacheableListModelLoader.java +++ /dev/null @@ -1,80 +0,0 @@ -package com.raizlabs.android.dbflow.sql.queriable; - -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.annotation.Table; -import com.raizlabs.android.dbflow.structure.ModelAdapter; -import com.raizlabs.android.dbflow.structure.cache.ModelCache; -import com.raizlabs.android.dbflow.structure.database.FlowCursor; - -import java.util.ArrayList; -import java.util.List; - -/** - * Description: Loads a {@link List} of {@link TModel} with {@link Table#cachingEnabled()} true. - */ -public class CacheableListModelLoader extends ListModelLoader { - - private ModelAdapter modelAdapter; - private ModelCache modelCache; - - public CacheableListModelLoader(@NonNull Class modelClass) { - super(modelClass); - } - - @NonNull - public ModelCache getModelCache() { - if (modelCache == null) { - modelCache = modelAdapter.getModelCache(); - if (modelCache == null) { - throw new IllegalArgumentException("ModelCache specified in convertToCacheableList() must not be null."); - } - } - return modelCache; - } - - @NonNull - @SuppressWarnings("unchecked") - public ModelAdapter getModelAdapter() { - if (modelAdapter == null) { - if (!(getInstanceAdapter() instanceof ModelAdapter)) { - throw new IllegalArgumentException("A non-Table type was used."); - } - modelAdapter = (ModelAdapter) getInstanceAdapter(); - if (!modelAdapter.cachingEnabled()) { - throw new IllegalArgumentException("You cannot call this method for a table that has no caching id. Either" + - "use one Primary Key or use the MultiCacheKeyConverter"); - } - } - return modelAdapter; - } - - @NonNull - @SuppressWarnings("unchecked") - @Override - public List convertToData(@NonNull FlowCursor cursor, @Nullable List data) { - if (data == null) { - data = new ArrayList<>(); - } - Object[] cacheValues = new Object[getModelAdapter().getCachingColumns().length]; - // Ensure that we aren't iterating over this cursor concurrently from different threads - if (cursor.moveToFirst()) { - do { - Object[] values = getModelAdapter().getCachingColumnValuesFromCursor(cacheValues, cursor); - TModel model = getModelCache().get(getModelAdapter().getCachingId(values)); - if (model != null) { - getModelAdapter().reloadRelationships(model, cursor); - data.add(model); - } else { - model = getModelAdapter().newInstance(); - getModelAdapter().loadFromCursor(cursor, model); - getModelCache().addModel(getModelAdapter().getCachingId(values), model); - data.add(model); - } - } while (cursor.moveToNext()); - } - return data; - } - -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/CacheableListModelLoader.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/CacheableListModelLoader.kt new file mode 100644 index 000000000..1fcd79f60 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/CacheableListModelLoader.kt @@ -0,0 +1,51 @@ +package com.raizlabs.android.dbflow.sql.queriable + +import com.raizlabs.android.dbflow.annotation.Table +import com.raizlabs.android.dbflow.structure.ModelAdapter +import com.raizlabs.android.dbflow.structure.cache.ModelCache +import com.raizlabs.android.dbflow.structure.database.FlowCursor + +/** + * Description: Loads a [List] of [TModel] with [Table.cachingEnabled] true. + */ +open class CacheableListModelLoader(modelClass: Class) + : ListModelLoader(modelClass) { + + val modelAdapter: ModelAdapter by lazy { + if (instanceAdapter !is ModelAdapter<*>) { + throw IllegalArgumentException("A non-Table type was used.") + } + val modelAdapter = instanceAdapter as ModelAdapter + if (!modelAdapter.cachingEnabled()) { + throw IllegalArgumentException("You cannot call this method for a table that has no caching id. Either" + "use one Primary Key or use the MultiCacheKeyConverter") + } + return@lazy modelAdapter + } + + val modelCache: ModelCache by lazy { + modelAdapter.modelCache ?: throw IllegalArgumentException("ModelCache specified in convertToCacheableList() must not be null.") + } + + override fun convertToData(cursor: FlowCursor, data: MutableList?): MutableList { + val _data = data ?: arrayListOf() + val cacheValues = arrayOfNulls(modelAdapter.cachingColumns.size) + // Ensure that we aren't iterating over this cursor concurrently from different threads + if (cursor.moveToFirst()) { + do { + val values = modelAdapter.getCachingColumnValuesFromCursor(cacheValues, cursor) + var model: TModel? = modelCache.get(modelAdapter.getCachingId(values)) + if (model != null) { + modelAdapter.reloadRelationships(model, cursor) + _data.add(model) + } else { + model = modelAdapter.newInstance() + modelAdapter.loadFromCursor(cursor, model!!) + modelCache.addModel(modelAdapter.getCachingId(values), model) + _data.add(model) + } + } while (cursor.moveToNext()) + } + return _data + } + +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/CacheableModelLoader.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/CacheableModelLoader.java deleted file mode 100644 index cfe9744f8..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/CacheableModelLoader.java +++ /dev/null @@ -1,77 +0,0 @@ -package com.raizlabs.android.dbflow.sql.queriable; - -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.annotation.Table; -import com.raizlabs.android.dbflow.structure.ModelAdapter; -import com.raizlabs.android.dbflow.structure.cache.ModelCache; -import com.raizlabs.android.dbflow.structure.database.FlowCursor; - -/** - * Description: Loads model data that is backed by a {@link ModelCache}. Used when {@link Table#cachingEnabled()} - * is true. - */ -public class CacheableModelLoader extends SingleModelLoader { - - private ModelAdapter modelAdapter; - private ModelCache modelCache; - - public CacheableModelLoader(@NonNull Class modelClass) { - super(modelClass); - } - - @NonNull - @SuppressWarnings("unchecked") - public ModelAdapter getModelAdapter() { - if (modelAdapter == null) { - if (!(getInstanceAdapter() instanceof ModelAdapter)) { - throw new IllegalArgumentException("A non-Table type was used."); - } - modelAdapter = (ModelAdapter) getInstanceAdapter(); - if (!modelAdapter.cachingEnabled()) { - throw new IllegalArgumentException("You cannot call this method for a table that has no caching id. Either" + - "use one Primary Key or use the MultiCacheKeyConverter"); - } - } - return modelAdapter; - } - - @NonNull - public ModelCache getModelCache() { - if (modelCache == null) { - modelCache = getModelAdapter().getModelCache(); - } - return modelCache; - } - - /** - * Converts data by loading from cache based on its sequence of caching ids. Will reuse the passed - * {@link TModel} if it's not found in the cache and non-null. - * - * @return A model from cache. - */ - @Nullable - @Override - public TModel convertToData(@NonNull FlowCursor cursor, @Nullable TModel data, boolean moveToFirst) { - if (!moveToFirst || cursor.moveToFirst()) { - Object[] values = getModelAdapter().getCachingColumnValuesFromCursor( - new Object[getModelAdapter().getCachingColumns().length], cursor); - TModel model = getModelCache().get(getModelAdapter().getCachingId(values)); - if (model == null) { - if (data == null) { - model = getModelAdapter().newInstance(); - } else { - model = data; - } - getModelAdapter().loadFromCursor(cursor, model); - getModelCache().addModel(getModelAdapter().getCachingId(values), model); - } else { - getModelAdapter().reloadRelationships(model, cursor); - } - return model; - } else { - return null; - } - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/CacheableModelLoader.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/CacheableModelLoader.kt new file mode 100644 index 000000000..f74f4cdcb --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/CacheableModelLoader.kt @@ -0,0 +1,52 @@ +package com.raizlabs.android.dbflow.sql.queriable + +import com.raizlabs.android.dbflow.annotation.Table +import com.raizlabs.android.dbflow.structure.ModelAdapter +import com.raizlabs.android.dbflow.structure.cache.ModelCache +import com.raizlabs.android.dbflow.structure.database.FlowCursor + +/** + * Description: Loads model data that is backed by a [ModelCache]. Used when [Table.cachingEnabled] + * is true. + */ +open class CacheableModelLoader(modelClass: Class) + : SingleModelLoader(modelClass) { + + val modelAdapter by lazy { + if (instanceAdapter !is ModelAdapter<*>) { + throw IllegalArgumentException("A non-Table type was used.") + } + val modelAdapter = instanceAdapter as ModelAdapter + if (!modelAdapter.cachingEnabled()) { + throw IllegalArgumentException("You cannot call this method for a table that has no caching id. Either" + "use one Primary Key or use the MultiCacheKeyConverter") + } + return@lazy modelAdapter + } + + val modelCache: ModelCache by lazy { modelAdapter.modelCache } + + /** + * Converts data by loading from cache based on its sequence of caching ids. Will reuse the passed + * [TModel] if it's not found in the cache and non-null. + * + * @return A model from cache. + */ + override fun convertToData(cursor: FlowCursor, data: TModel?, moveToFirst: Boolean): TModel? { + if (!moveToFirst || cursor.moveToFirst()) { + val values = modelAdapter.getCachingColumnValuesFromCursor( + arrayOfNulls(modelAdapter.cachingColumns.size), cursor) + var model: TModel? = modelCache.get(modelAdapter.getCachingId(values)) + if (model == null) { + model = (data ?: modelAdapter.newInstance()).apply { + modelAdapter.loadFromCursor(cursor, this) + modelCache.addModel(modelAdapter.getCachingId(values), this) + } + } else { + modelAdapter.reloadRelationships(model, cursor) + } + return model + } else { + return null + } + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ListModelLoader.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ListModelLoader.java deleted file mode 100644 index 296bdacfc..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ListModelLoader.java +++ /dev/null @@ -1,83 +0,0 @@ -package com.raizlabs.android.dbflow.sql.queriable; - -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; -import com.raizlabs.android.dbflow.structure.database.FlowCursor; - -import java.util.ArrayList; -import java.util.List; - -/** - * Description: Loads a {@link List} of {@link TModel}. - */ -@SuppressWarnings("ConstantConditions") -public class ListModelLoader extends ModelLoader> { - - public ListModelLoader(@NonNull Class modelClass) { - super(modelClass); - } - - @NonNull - @Override - public List load(String query) { - return super.load(query); - } - - @NonNull - @Override - public List load(String query, @Nullable List data) { - return super.load(query, data); - } - - @NonNull - @Override - public List load(@NonNull DatabaseWrapper databaseWrapper, String query) { - return super.load(databaseWrapper, query); - } - - @NonNull - @Override - public List load(@NonNull DatabaseWrapper databaseWrapper, String query, - @Nullable List data) { - return super.load(databaseWrapper, query, data); - } - - @NonNull - @Override - public List load(@Nullable FlowCursor cursor) { - return super.load(cursor); - } - - @NonNull - @Override - public List load(@Nullable FlowCursor cursor, @Nullable List data) { - if (data == null) { - data = new ArrayList<>(); - } else { - data.clear(); - } - return super.load(cursor, data); - } - - @SuppressWarnings("unchecked") - @Override - @NonNull - public List convertToData(@NonNull FlowCursor cursor, @Nullable List data) { - if (data == null) { - data = new ArrayList<>(); - } else { - data.clear(); - } - - if (cursor.moveToFirst()) { - do { - TModel model = getInstanceAdapter().newInstance(); - getInstanceAdapter().loadFromCursor(cursor, model); - data.add(model); - } while (cursor.moveToNext()); - } - return data; - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ListModelLoader.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ListModelLoader.kt new file mode 100644 index 000000000..29c237166 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ListModelLoader.kt @@ -0,0 +1,38 @@ +package com.raizlabs.android.dbflow.sql.queriable + +import com.raizlabs.android.dbflow.structure.database.FlowCursor + +/** + * Description: Loads a [List] of [TModel]. + */ +open class ListModelLoader(modelClass: Class) + : ModelLoader>(modelClass) { + + override fun load(cursor: FlowCursor?, data: MutableList?): MutableList? { + var _data = data + if (_data == null) { + _data = arrayListOf() + } else { + _data.clear() + } + return super.load(cursor, _data) + } + + override fun convertToData(cursor: FlowCursor, data: MutableList?): MutableList { + var _data = data + if (_data == null) { + _data = arrayListOf() + } else { + _data.clear() + } + + if (cursor.moveToFirst()) { + do { + val model = instanceAdapter.newInstance() + instanceAdapter.loadFromCursor(cursor, model) + _data.add(model) + } while (cursor.moveToNext()) + } + return _data + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ModelLoader.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ModelLoader.java deleted file mode 100644 index 3d79d59d2..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ModelLoader.java +++ /dev/null @@ -1,110 +0,0 @@ -package com.raizlabs.android.dbflow.sql.queriable; - -import android.database.Cursor; -import android.database.sqlite.SQLiteDatabase; -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.config.DatabaseDefinition; -import com.raizlabs.android.dbflow.config.FlowManager; -import com.raizlabs.android.dbflow.structure.InstanceAdapter; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; -import com.raizlabs.android.dbflow.structure.database.FlowCursor; - -/** - * Description: Represents how models load from DB. It will query a {@link SQLiteDatabase} - * and query for a {@link Cursor}. Then the cursor is used to convert itself into an object. - */ -public abstract class ModelLoader { - - private final Class modelClass; - private DatabaseDefinition databaseDefinition; - private InstanceAdapter instanceAdapter; - - public ModelLoader(@NonNull Class modelClass) { - this.modelClass = modelClass; - } - - /** - * Loads the data from a query and returns it as a {@link TReturn}. - * - * @param query The query to call. - * @return The data loaded from the database. - */ - @Nullable - public TReturn load(@NonNull String query) { - return load(getDatabaseDefinition().getWritableDatabase(), query); - } - - @Nullable - public TReturn load(@NonNull String query, @Nullable TReturn data) { - return load(getDatabaseDefinition().getWritableDatabase(), query, data); - } - - /** - * Loads the data from a query and returns it as a {@link TReturn}. - * - * @param databaseWrapper A custom database wrapper object to use. - * @param query The query to call. - * @return The data loaded from the database. - */ - @Nullable - public TReturn load(@NonNull DatabaseWrapper databaseWrapper, @NonNull String query) { - return load(databaseWrapper, query, null); - } - - @Nullable - public TReturn load(@NonNull DatabaseWrapper databaseWrapper, @NonNull String query, - @Nullable TReturn data) { - final FlowCursor cursor = databaseWrapper.rawQuery(query, null); - return load(cursor, data); - } - - @Nullable - public TReturn load(@Nullable FlowCursor cursor) { - return load(cursor, null); - } - - @Nullable - public TReturn load(@Nullable FlowCursor cursor, @Nullable TReturn data) { - if (cursor != null) { - try { - data = convertToData(cursor, data); - } finally { - cursor.close(); - } - } - return data; - } - - @NonNull - public Class getModelClass() { - return modelClass; - } - - @NonNull - public InstanceAdapter getInstanceAdapter() { - if (instanceAdapter == null) { - instanceAdapter = FlowManager.getInstanceAdapter(modelClass); - } - return instanceAdapter; - } - - @NonNull - public DatabaseDefinition getDatabaseDefinition() { - if (databaseDefinition == null) { - databaseDefinition = FlowManager.getDatabaseForTable(modelClass); - } - return databaseDefinition; - } - - /** - * Specify how to convert the {@link Cursor} data into a {@link TReturn}. Can be null. - * - * @param cursor The cursor resulting from a query passed into {@link #load(String)} - * @param data The data (if not null) that we can reuse without need to create new object. - * @return A new (or reused) instance that represents the {@link Cursor}. - */ - @Nullable - public abstract TReturn convertToData(@NonNull final FlowCursor cursor, @Nullable TReturn data); -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ModelLoader.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ModelLoader.kt new file mode 100644 index 000000000..2c1f4c33c --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ModelLoader.kt @@ -0,0 +1,67 @@ +package com.raizlabs.android.dbflow.sql.queriable + +import android.database.Cursor +import android.database.sqlite.SQLiteDatabase + +import com.raizlabs.android.dbflow.config.DatabaseDefinition +import com.raizlabs.android.dbflow.config.FlowManager +import com.raizlabs.android.dbflow.structure.InstanceAdapter +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.structure.database.FlowCursor + +/** + * Description: Represents how models load from DB. It will query a [SQLiteDatabase] + * and query for a [Cursor]. Then the cursor is used to convert itself into an object. + */ +abstract class ModelLoader(val modelClass: Class) { + + val databaseDefinition: DatabaseDefinition by lazy { FlowManager.getDatabaseForTable(modelClass) } + val instanceAdapter: InstanceAdapter by lazy { FlowManager.getInstanceAdapter(modelClass) } + + /** + * Loads the data from a query and returns it as a [TReturn]. + * + * @param query The query to call. + * @return The data loaded from the database. + */ + open fun load(query: String): TReturn? { + return load(databaseDefinition.writableDatabase, query) + } + + open fun load(query: String, data: TReturn?): TReturn? { + return load(databaseDefinition.writableDatabase, query, data) + } + + /** + * Loads the data from a query and returns it as a [TReturn]. + * + * @param databaseWrapper A custom database wrapper object to use. + * @param query The query to call. + * @return The data loaded from the database. + */ + open fun load(databaseWrapper: DatabaseWrapper, query: String): TReturn? { + return load(databaseWrapper, query, null) + } + + open fun load(databaseWrapper: DatabaseWrapper, query: String, + data: TReturn?): TReturn? { + return load(databaseWrapper.rawQuery(query, null), data) + } + + open fun load(cursor: FlowCursor?): TReturn? = load(cursor, null) + + open fun load(cursor: FlowCursor?, data: TReturn?): TReturn? { + var _data = data + cursor?.use { _data = convertToData(it, _data) } + return _data + } + + /** + * Specify how to convert the [Cursor] data into a [TReturn]. Can be null. + * + * @param cursor The cursor resulting from a query passed into [.load] + * @param data The data (if not null) that we can reuse without need to create new object. + * @return A new (or reused) instance that represents the [Cursor]. + */ + abstract fun convertToData(cursor: FlowCursor, data: TReturn?): TReturn? +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ModelQueriable.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ModelQueriable.java deleted file mode 100644 index e40edf87b..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ModelQueriable.java +++ /dev/null @@ -1,110 +0,0 @@ -package com.raizlabs.android.dbflow.sql.queriable; - -import android.database.Cursor; -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.list.FlowCursorList; -import com.raizlabs.android.dbflow.list.FlowQueryList; -import com.raizlabs.android.dbflow.sql.language.CursorResult; -import com.raizlabs.android.dbflow.sql.language.From; -import com.raizlabs.android.dbflow.sql.language.Where; -import com.raizlabs.android.dbflow.structure.BaseQueryModel; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; - -import java.util.List; - -/** - * Description: An interface for query objects to enable you to query from the database in a structured way. - * Examples of such statements are: {@link From}, {@link Where}, {@link StringQuery} - */ -public interface ModelQueriable extends Queriable { - - /** - * @return A wrapper class around {@link Cursor} that allows you to convert its data into results. - */ - @NonNull - CursorResult queryResults(); - - /** - * @return a list of model converted items - */ - @NonNull - List queryList(); - - /** - * Allows you to specify a DB, useful for migrations. - * - * @return a list of model converted items - */ - @NonNull - List queryList(@NonNull DatabaseWrapper wrapper); - - /** - * @return Single model, the first of potentially many results - */ - @Nullable - TModel querySingle(); - - /** - * Allows you to specify a DB, useful for migrations. - * - * @return Single model, the first of potentially many results - */ - @Nullable - TModel querySingle(@NonNull DatabaseWrapper wrapper); - - /** - * @return the table that this query comes from. - */ - @NonNull - Class getTable(); - - /** - * @return A cursor-backed list that handles conversion, retrieval, and caching of lists. Can - * cache models dynamically by setting {@link FlowCursorList#setCacheModels(boolean)} to true. - */ - @NonNull - FlowCursorList cursorList(); - - /** - * @return A cursor-backed {@link List} that handles conversion, retrieval, caching, content changes, - * and more. - */ - @NonNull - FlowQueryList flowQueryList(); - - /** - * @return an async version of this query to run. - */ - @NonNull - AsyncQuery async(); - - /** - * Returns a {@link List} based on the custom {@link TQueryModel} you pass in. - * - * @param queryModelClass The query model class to use. - * @param The class that extends {@link BaseQueryModel} - * @return A list of custom models that are not tied to a table. - */ - @NonNull - List queryCustomList(@NonNull Class queryModelClass); - - /** - * Returns a single {@link TQueryModel} from this query. - * - * @param queryModelClass The class to use. - * @param The class that extends {@link BaseQueryModel} - * @return A single model from the query. - */ - @Nullable - TQueryModel queryCustomSingle(@NonNull Class queryModelClass); - - /** - * Disables caching on this query for the object retrieved from DB (if caching enabled). If - * caching is not enabled, this method is ignored. This also disables caching in a {@link FlowCursorList} - * or {@link FlowQueryList} if you {@link #flowQueryList()} or {@link #cursorList()} - */ - @NonNull - ModelQueriable disableCaching(); -} \ No newline at end of file diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ModelQueriable.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ModelQueriable.kt new file mode 100644 index 000000000..70aaa2709 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ModelQueriable.kt @@ -0,0 +1,94 @@ +package com.raizlabs.android.dbflow.sql.queriable + +import android.database.Cursor + +import com.raizlabs.android.dbflow.list.FlowCursorList +import com.raizlabs.android.dbflow.list.FlowQueryList +import com.raizlabs.android.dbflow.sql.language.CursorResult +import com.raizlabs.android.dbflow.sql.language.From +import com.raizlabs.android.dbflow.sql.language.Where +import com.raizlabs.android.dbflow.structure.BaseQueryModel +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper + +/** + * Description: An interface for query objects to enable you to query from the database in a structured way. + * Examples of such statements are: [From], [Where], [StringQuery] + */ +interface ModelQueriable : Queriable { + + /** + * @return the table that this query comes from. + */ + val table: Class + + /** + * @return A wrapper class around [Cursor] that allows you to convert its data into results. + */ + fun queryResults(): CursorResult + + /** + * @return a list of model converted items + */ + fun queryList(): List + + /** + * Allows you to specify a DB, useful for migrations. + * + * @return a list of model converted items + */ + fun queryList(wrapper: DatabaseWrapper): List + + /** + * @return Single model, the first of potentially many results + */ + fun querySingle(): TModel? + + /** + * Allows you to specify a DB, useful for migrations. + * + * @return Single model, the first of potentially many results + */ + fun querySingle(wrapper: DatabaseWrapper): TModel? + + /** + * @return A cursor-backed list that handles conversion, retrieval, and caching of lists. Can + * cache models dynamically by setting [FlowCursorList.setCacheModels] to true. + */ + fun cursorList(): FlowCursorList + + /** + * @return A cursor-backed [List] that handles conversion, retrieval, caching, content changes, + * and more. + */ + fun flowQueryList(): FlowQueryList + + /** + * @return an async version of this query to run. + */ + fun async(): AsyncQuery + + /** + * Returns a [List] based on the custom [TQueryModel] you pass in. + * + * @param queryModelClass The query model class to use. + * @param The class that extends [BaseQueryModel] + * @return A list of custom models that are not tied to a table. + */ + fun queryCustomList(queryModelClass: Class): List + + /** + * Returns a single [TQueryModel] from this query. + * + * @param queryModelClass The class to use. + * @param The class that extends [BaseQueryModel] + * @return A single model from the query. + */ + fun queryCustomSingle(queryModelClass: Class): TQueryModel? + + /** + * Disables caching on this query for the object retrieved from DB (if caching enabled). If + * caching is not enabled, this method is ignored. This also disables caching in a [FlowCursorList] + * or [FlowQueryList] if you [.flowQueryList] or [.cursorList] + */ + fun disableCaching(): ModelQueriable +} \ No newline at end of file diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/Queriable.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/Queriable.java deleted file mode 100644 index e6d70f665..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/Queriable.java +++ /dev/null @@ -1,127 +0,0 @@ -package com.raizlabs.android.dbflow.sql.queriable; - -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.sql.Query; -import com.raizlabs.android.dbflow.sql.language.Delete; -import com.raizlabs.android.dbflow.sql.language.Insert; -import com.raizlabs.android.dbflow.sql.language.Set; -import com.raizlabs.android.dbflow.structure.BaseModel; -import com.raizlabs.android.dbflow.structure.Model; -import com.raizlabs.android.dbflow.structure.database.DatabaseStatement; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; -import com.raizlabs.android.dbflow.structure.database.FlowCursor; - -/** - * Description: The most basic interface that some of the classes such as {@link Insert}, {@link ModelQueriable}, - * {@link Set}, and more implement for convenience. - */ -public interface Queriable extends Query { - - /** - * @return A cursor from the DB based on this query - */ - @Nullable - FlowCursor query(); - - /** - * Allows you to pass in a {@link DatabaseWrapper} manually. - * - * @param databaseWrapper The wrapper to pass in. - * @return A cursor from the DB based on this query - */ - @Nullable - FlowCursor query(@NonNull DatabaseWrapper databaseWrapper); - - - /** - * @return A new {@link DatabaseStatement} from this query. - */ - @NonNull - DatabaseStatement compileStatement(); - - /** - * @param databaseWrapper The wrapper to use. - * @return A new {@link DatabaseStatement} from this query with database specified. - */ - @NonNull - DatabaseStatement compileStatement(@NonNull DatabaseWrapper databaseWrapper); - - /** - * @return the count of the results of the query. - * @deprecated use {@link #longValue()} - */ - @Deprecated - long count(); - - /** - * @return the long value of the results of query. - */ - long longValue(); - - /** - * @return the long value of the results of query. - */ - long longValue(DatabaseWrapper databaseWrapper); - - /** - * Allows you to pass in a {@link DatabaseWrapper} manually. - * - * @return the count of the results of the query. - * @deprecated use {@link #longValue(DatabaseWrapper)} - */ - @Deprecated - long count(@NonNull DatabaseWrapper databaseWrapper); - - /** - * @return This may return the number of rows affected from a {@link Set} or {@link Delete} statement. - * If not, returns {@link Model#INVALID_ROW_ID} - */ - long executeUpdateDelete(@NonNull DatabaseWrapper databaseWrapper); - - /** - * @return This may return the number of rows affected from a {@link Set} or {@link Delete} statement. - * If not, returns {@link Model#INVALID_ROW_ID} - */ - long executeUpdateDelete(); - - /** - * @return This may return the number of rows affected from a {@link Insert} statement. - * If not, returns {@link Model#INVALID_ROW_ID} - */ - long executeInsert(); - - /** - * @return This may return the number of rows affected from a {@link Insert} statement. - * If not, returns {@link Model#INVALID_ROW_ID} - */ - long executeInsert(@NonNull DatabaseWrapper databaseWrapper); - - /** - * @return True if this query has data. It will run a {@link #count()} greater than 0. - */ - boolean hasData(); - - /** - * Allows you to pass in a {@link DatabaseWrapper} manually. - * - * @return True if this query has data. It will run a {@link #count()} greater than 0. - */ - boolean hasData(@NonNull DatabaseWrapper databaseWrapper); - - /** - * Will not return a result, rather simply will execute a SQL statement. Use this for non-SELECT statements or when - * you're not interested in the result. - */ - void execute(); - - /** - * Will not return a result, rather simply will execute a SQL statement. Use this for non-SELECT statements or when - * you're not interested in the result. - */ - void execute(@NonNull DatabaseWrapper databaseWrapper); - - @NonNull - BaseModel.Action getPrimaryAction(); -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/Queriable.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/Queriable.kt new file mode 100644 index 000000000..00f9837d1 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/Queriable.kt @@ -0,0 +1,117 @@ +package com.raizlabs.android.dbflow.sql.queriable + +import com.raizlabs.android.dbflow.sql.Query +import com.raizlabs.android.dbflow.sql.language.Delete +import com.raizlabs.android.dbflow.sql.language.Insert +import com.raizlabs.android.dbflow.sql.language.Set +import com.raizlabs.android.dbflow.structure.BaseModel +import com.raizlabs.android.dbflow.structure.Model +import com.raizlabs.android.dbflow.structure.database.DatabaseStatement +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.structure.database.FlowCursor + +/** + * Description: The most basic interface that some of the classes such as [Insert], [ModelQueriable], + * [Set], and more implement for convenience. + */ +interface Queriable : Query { + + val primaryAction: BaseModel.Action + + /** + * @return A cursor from the DB based on this query + */ + fun query(): FlowCursor? + + /** + * Allows you to pass in a [DatabaseWrapper] manually. + * + * @param databaseWrapper The wrapper to pass in. + * @return A cursor from the DB based on this query + */ + fun query(databaseWrapper: DatabaseWrapper): FlowCursor? + + + /** + * @return A new [DatabaseStatement] from this query. + */ + fun compileStatement(): DatabaseStatement + + /** + * @param databaseWrapper The wrapper to use. + * @return A new [DatabaseStatement] from this query with database specified. + */ + fun compileStatement(databaseWrapper: DatabaseWrapper): DatabaseStatement + + /** + * @return the count of the results of the query. + */ + @Deprecated("use {@link #longValue()}") + fun count(): Long + + /** + * @return the long value of the results of query. + */ + fun longValue(): Long + + /** + * @return the long value of the results of query. + */ + fun longValue(databaseWrapper: DatabaseWrapper): Long + + /** + * Allows you to pass in a [DatabaseWrapper] manually. + * + * @return the count of the results of the query. + */ + @Deprecated("use {@link #longValue(DatabaseWrapper)}") + fun count(databaseWrapper: DatabaseWrapper): Long + + /** + * @return This may return the number of rows affected from a [Set] or [Delete] statement. + * If not, returns [Model.INVALID_ROW_ID] + */ + fun executeUpdateDelete(databaseWrapper: DatabaseWrapper): Long + + /** + * @return This may return the number of rows affected from a [Set] or [Delete] statement. + * If not, returns [Model.INVALID_ROW_ID] + */ + fun executeUpdateDelete(): Long + + /** + * @return This may return the number of rows affected from a [Insert] statement. + * If not, returns [Model.INVALID_ROW_ID] + */ + fun executeInsert(): Long + + /** + * @return This may return the number of rows affected from a [Insert] statement. + * If not, returns [Model.INVALID_ROW_ID] + */ + fun executeInsert(databaseWrapper: DatabaseWrapper): Long + + /** + * @return True if this query has data. It will run a [.count] greater than 0. + */ + fun hasData(): Boolean + + /** + * Allows you to pass in a [DatabaseWrapper] manually. + * + * @return True if this query has data. It will run a [.count] greater than 0. + */ + fun hasData(databaseWrapper: DatabaseWrapper): Boolean + + /** + * Will not return a result, rather simply will execute a SQL statement. Use this for non-SELECT statements or when + * you're not interested in the result. + */ + fun execute() + + /** + * Will not return a result, rather simply will execute a SQL statement. Use this for non-SELECT statements or when + * you're not interested in the result. + */ + fun execute(databaseWrapper: DatabaseWrapper) +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleKeyCacheableListModelLoader.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleKeyCacheableListModelLoader.java deleted file mode 100644 index d6614275e..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleKeyCacheableListModelLoader.java +++ /dev/null @@ -1,47 +0,0 @@ -package com.raizlabs.android.dbflow.sql.queriable; - -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.structure.database.FlowCursor; - -import java.util.ArrayList; -import java.util.List; - -/** - * Description: - */ -public class SingleKeyCacheableListModelLoader extends CacheableListModelLoader { - - public SingleKeyCacheableListModelLoader(@NonNull Class tModelClass) { - super(tModelClass); - } - - @NonNull - @SuppressWarnings("unchecked") - @Override - public List convertToData(@NonNull FlowCursor cursor, @Nullable List data) { - if (data == null) { - data = new ArrayList<>(); - } - Object cacheValue; - // Ensure that we aren't iterating over this cursor concurrently from different threads - if (cursor.moveToFirst()) { - do { - cacheValue = getModelAdapter().getCachingColumnValueFromCursor(cursor); - TModel model = getModelCache().get(cacheValue); - if (model != null) { - getModelAdapter().reloadRelationships(model, cursor); - data.add(model); - } else { - model = getModelAdapter().newInstance(); - getModelAdapter().loadFromCursor(cursor, model); - getModelCache().addModel(cacheValue, model); - data.add(model); - } - } while (cursor.moveToNext()); - } - return data; - } - -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleKeyCacheableListModelLoader.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleKeyCacheableListModelLoader.kt new file mode 100644 index 000000000..c97769db0 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleKeyCacheableListModelLoader.kt @@ -0,0 +1,32 @@ +package com.raizlabs.android.dbflow.sql.queriable + +import com.raizlabs.android.dbflow.structure.database.FlowCursor + +/** + * Description: + */ +class SingleKeyCacheableListModelLoader(tModelClass: Class) + : CacheableListModelLoader(tModelClass) { + + override fun convertToData(cursor: FlowCursor, data: MutableList?): MutableList { + val _data = data ?: arrayListOf() + var cacheValue: Any + // Ensure that we aren't iterating over this cursor concurrently from different threads + if (cursor.moveToFirst()) { + do { + cacheValue = modelAdapter.getCachingColumnValueFromCursor(cursor) + var model: TModel? = modelCache.get(cacheValue) + if (model != null) { + modelAdapter.reloadRelationships(model, cursor) + } else { + model = modelAdapter.newInstance() + modelAdapter.loadFromCursor(cursor, model!!) + modelCache.addModel(cacheValue, model) + } + _data.add(model) + } while (cursor.moveToNext()) + } + return _data + } + +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleKeyCacheableModelLoader.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleKeyCacheableModelLoader.java deleted file mode 100644 index 4bb81e459..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleKeyCacheableModelLoader.java +++ /dev/null @@ -1,48 +0,0 @@ -package com.raizlabs.android.dbflow.sql.queriable; - -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.structure.Model; -import com.raizlabs.android.dbflow.structure.database.FlowCursor; - -/** - * Description: More optimized version of {@link CacheableModelLoader} which assumes that the {@link Model} - * only utilizes a single primary key. - */ -public class SingleKeyCacheableModelLoader extends CacheableModelLoader { - - public SingleKeyCacheableModelLoader(@NonNull Class modelClass) { - super(modelClass); - } - - /** - * Converts data by loading from cache based on its sequence of caching ids. Will reuse the passed - * {@link TModel} if it's not found in the cache and non-null. - * - * @return A model from cache. - */ - @Nullable - @Override - public TModel convertToData(@NonNull FlowCursor cursor, @Nullable TModel data, - boolean moveToFirst) { - if (!moveToFirst || cursor.moveToFirst()) { - Object value = getModelAdapter().getCachingColumnValueFromCursor(cursor); - TModel model = getModelCache().get(value); - if (model == null) { - if (data == null) { - model = getModelAdapter().newInstance(); - } else { - model = data; - } - getModelAdapter().loadFromCursor(cursor, model); - getModelCache().addModel(value, model); - } else { - getModelAdapter().reloadRelationships(model, cursor); - } - return model; - } else { - return null; - } - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleKeyCacheableModelLoader.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleKeyCacheableModelLoader.kt new file mode 100644 index 000000000..f641635e8 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleKeyCacheableModelLoader.kt @@ -0,0 +1,37 @@ +package com.raizlabs.android.dbflow.sql.queriable + +import com.raizlabs.android.dbflow.structure.Model +import com.raizlabs.android.dbflow.structure.database.FlowCursor + +/** + * Description: More optimized version of [CacheableModelLoader] which assumes that the [Model] + * only utilizes a single primary key. + */ +class SingleKeyCacheableModelLoader(modelClass: Class) + : CacheableModelLoader(modelClass) { + + /** + * Converts data by loading from cache based on its sequence of caching ids. Will reuse the passed + * [TModel] if it's not found in the cache and non-null. + * + * @return A model from cache. + */ + override fun convertToData(cursor: FlowCursor, data: TModel?, + moveToFirst: Boolean): TModel? { + if (!moveToFirst || cursor.moveToFirst()) { + val value = modelAdapter.getCachingColumnValueFromCursor(cursor) + var model: TModel? = modelCache.get(value) + if (model == null) { + model = (data ?: modelAdapter.newInstance()).apply { + modelAdapter.loadFromCursor(cursor, this) + modelCache.addModel(value, this) + } + } else { + modelAdapter.reloadRelationships(model, cursor) + } + return model + } else { + return null + } + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleModelLoader.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleModelLoader.java deleted file mode 100644 index e1e4cabe4..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleModelLoader.java +++ /dev/null @@ -1,34 +0,0 @@ -package com.raizlabs.android.dbflow.sql.queriable; - -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.structure.database.FlowCursor; - -/** - * Description: Responsible for loading data into a single object. - */ -public class SingleModelLoader extends ModelLoader { - - public SingleModelLoader(Class modelClass) { - super(modelClass); - } - - @SuppressWarnings("unchecked") - @Nullable - public TModel convertToData(@NonNull final FlowCursor cursor, @Nullable TModel data, - boolean moveToFirst) { - if (!moveToFirst || cursor.moveToFirst()) { - if (data == null) { - data = getInstanceAdapter().newInstance(); - } - getInstanceAdapter().loadFromCursor(cursor, data); - } - return data; - } - - @Override - public TModel convertToData(@NonNull final FlowCursor cursor, @Nullable TModel data) { - return convertToData(cursor, data, true); - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleModelLoader.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleModelLoader.kt new file mode 100644 index 000000000..ba1fc80b4 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleModelLoader.kt @@ -0,0 +1,26 @@ +package com.raizlabs.android.dbflow.sql.queriable + +import com.raizlabs.android.dbflow.structure.database.FlowCursor + +/** + * Description: Responsible for loading data into a single object. + */ +open class SingleModelLoader(modelClass: Class) + : ModelLoader(modelClass) { + + open fun convertToData(cursor: FlowCursor, data: TModel?, + moveToFirst: Boolean): TModel? { + var _data = data + if (!moveToFirst || cursor.moveToFirst()) { + if (_data == null) { + _data = instanceAdapter.newInstance() + } + instanceAdapter.loadFromCursor(cursor, _data!!) + } + return _data + } + + override fun convertToData(cursor: FlowCursor, data: TModel?): TModel? { + return convertToData(cursor, data, true) + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/StringQuery.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/StringQuery.java deleted file mode 100644 index 230dd0c44..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/StringQuery.java +++ /dev/null @@ -1,68 +0,0 @@ -package com.raizlabs.android.dbflow.sql.queriable; - -import android.database.sqlite.SQLiteDatabase; -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.config.FlowManager; -import com.raizlabs.android.dbflow.sql.Query; -import com.raizlabs.android.dbflow.sql.language.BaseModelQueriable; -import com.raizlabs.android.dbflow.sql.language.Delete; -import com.raizlabs.android.dbflow.structure.BaseModel; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; -import com.raizlabs.android.dbflow.structure.database.FlowCursor; - -/** - * Description: Provides a very basic query mechanism for strings. Allows you to easily perform custom SQL query string - * code where this library does not provide. It only runs a - * {@link SQLiteDatabase#rawQuery(String, String[])}. - */ -public class StringQuery extends BaseModelQueriable implements Query, ModelQueriable { - - /** - * The full SQLite query to use - */ - private final String query; - private String[] args; - - /** - * Creates an instance of this class - * - * @param table The table to use - * @param sql The sql statement to query the DB with. Does not work with {@link Delete}, - * this must be done with {@link SQLiteDatabase#execSQL(String)} - */ - public StringQuery(@NonNull Class table, @NonNull String sql) { - super(table); - query = sql; - } - - @Override - public String getQuery() { - return query; - } - - @Override - public FlowCursor query() { - return query(FlowManager.getDatabaseForTable(getTable()).getWritableDatabase()); - } - - @Override - public FlowCursor query(@NonNull DatabaseWrapper databaseWrapper) { - return databaseWrapper.rawQuery(query, args); - } - - /** - * Set selection arguments to execute on this raw query. - */ - @NonNull - public StringQuery setSelectionArgs(@NonNull String[] args) { - this.args = args; - return this; - } - - @NonNull - @Override - public BaseModel.Action getPrimaryAction() { - return BaseModel.Action.CHANGE; // we don't explicitly know the change, but something changed. - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/StringQuery.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/StringQuery.kt new file mode 100644 index 000000000..9f008397b --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/StringQuery.kt @@ -0,0 +1,51 @@ +package com.raizlabs.android.dbflow.sql.queriable + +import android.database.sqlite.SQLiteDatabase + +import com.raizlabs.android.dbflow.config.FlowManager +import com.raizlabs.android.dbflow.sql.Query +import com.raizlabs.android.dbflow.sql.language.BaseModelQueriable +import com.raizlabs.android.dbflow.sql.language.Delete +import com.raizlabs.android.dbflow.structure.BaseModel +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.structure.database.FlowCursor + +/** + * Description: Provides a very basic query mechanism for strings. Allows you to easily perform custom SQL query string + * code where this library does not provide. It only runs a + * [SQLiteDatabase.rawQuery]. + */ +class StringQuery +/** + * Creates an instance of this class + * + * @param table The table to use + * @param sql The sql statement to query the DB with. Does not work with [Delete], + * this must be done with [SQLiteDatabase.execSQL] + */ +(table: Class, + /** + * The full SQLite query to use + */ + override val query: String) : BaseModelQueriable(table), Query, ModelQueriable { + private var args: Array? = null + + override// we don't explicitly know the change, but something changed. + val primaryAction: BaseModel.Action + get() = BaseModel.Action.CHANGE + + override fun query(): FlowCursor? { + return query(FlowManager.getDatabaseForTable(table).writableDatabase) + } + + override fun query(databaseWrapper: DatabaseWrapper): FlowCursor? { + return databaseWrapper.rawQuery(query, args) + } + + /** + * Set selection arguments to execute on this raw query. + */ + fun setSelectionArgs(args: Array) = apply { + this.args = args + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/AutoIncrementModelSaver.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/AutoIncrementModelSaver.java index 43d7c1dd6..27e022702 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/AutoIncrementModelSaver.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/AutoIncrementModelSaver.java @@ -35,7 +35,7 @@ public synchronized long insert(@NonNull TModel model, @NonNull DatabaseWrapper id = insertStatement.executeInsert(); if (id > INSERT_FAILED) { getModelAdapter().updateAutoIncrement(model, id); - NotifyDistributor.get().notifyModelChanged(model, getModelAdapter(), BaseModel.Action.INSERT); + NotifyDistributor.Companion.get().notifyModelChanged(model, getModelAdapter(), BaseModel.Action.INSERT); } } finally { // since we generate an insert every time, we can safely close the statement here. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ModelSaver.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ModelSaver.java index ac35a8319..1b30f0ede 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ModelSaver.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ModelSaver.java @@ -52,7 +52,7 @@ public synchronized boolean save(@NonNull TModel model, } if (exists) { - NotifyDistributor.get().notifyModelChanged(model, modelAdapter, BaseModel.Action.SAVE); + NotifyDistributor.Companion.get().notifyModelChanged(model, modelAdapter, BaseModel.Action.SAVE); } // return successful store into db. @@ -82,7 +82,7 @@ public synchronized boolean update(@NonNull TModel model, @NonNull DatabaseWrapp modelAdapter.bindToUpdateStatement(databaseStatement, model); boolean successful = databaseStatement.executeUpdateDelete() != 0; if (successful) { - NotifyDistributor.get().notifyModelChanged(model, modelAdapter, BaseModel.Action.UPDATE); + NotifyDistributor.Companion.get().notifyModelChanged(model, modelAdapter, BaseModel.Action.UPDATE); } return successful; } @@ -114,7 +114,7 @@ public synchronized long insert(@NonNull TModel model, long id = insertStatement.executeInsert(); if (id > INSERT_FAILED) { modelAdapter.updateAutoIncrement(model, id); - NotifyDistributor.get().notifyModelChanged(model, modelAdapter, BaseModel.Action.INSERT); + NotifyDistributor.Companion.get().notifyModelChanged(model, modelAdapter, BaseModel.Action.INSERT); } return id; } @@ -145,7 +145,7 @@ public synchronized boolean delete(@NonNull TModel model, boolean success = deleteStatement.executeUpdateDelete() != 0; if (success) { - NotifyDistributor.get().notifyModelChanged(model, modelAdapter, BaseModel.Action.DELETE); + NotifyDistributor.Companion.get().notifyModelChanged(model, modelAdapter, BaseModel.Action.DELETE); } modelAdapter.updateAutoIncrement(model, 0); return success; @@ -183,7 +183,7 @@ public synchronized boolean save(@NonNull TModel model, } if (exists) { - NotifyDistributor.get().notifyModelChanged(model, modelAdapter, BaseModel.Action.SAVE); + NotifyDistributor.Companion.get().notifyModelChanged(model, modelAdapter, BaseModel.Action.SAVE); } // return successful store into db. @@ -204,7 +204,7 @@ public synchronized boolean update(@NonNull TModel model, modelAdapter.getPrimaryConditionClause(model).getQuery(), null, ConflictAction.getSQLiteDatabaseAlgorithmInt(modelAdapter.getUpdateOnConflictAction())) != 0; if (successful) { - NotifyDistributor.get().notifyModelChanged(model, modelAdapter, BaseModel.Action.UPDATE); + NotifyDistributor.Companion.get().notifyModelChanged(model, modelAdapter, BaseModel.Action.UPDATE); } return successful; } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseStatementWrapper.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseStatementWrapper.java index 1eac49388..9427d2179 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseStatementWrapper.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseStatementWrapper.java @@ -26,7 +26,7 @@ public DatabaseStatementWrapper(@NonNull DatabaseStatement databaseStatement, public long executeUpdateDelete() { long affected = databaseStatement.executeUpdateDelete(); if (affected > 0) { - NotifyDistributor.get().notifyTableChanged(modelQueriable.getTable(), + NotifyDistributor.Companion.get().notifyTableChanged(modelQueriable.getTable(), modelQueriable.getPrimaryAction()); } return affected; @@ -57,7 +57,7 @@ public String simpleQueryForString() { public long executeInsert() { long affected = databaseStatement.executeInsert(); if (affected > 0) { - NotifyDistributor.get().notifyTableChanged(modelQueriable.getTable(), + NotifyDistributor.Companion.get().notifyTableChanged(modelQueriable.getTable(), modelQueriable.getPrimaryAction()); } return affected; From adbe52cc81a9f474b8f8880d8ceb0d77859d06dd Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sun, 22 Oct 2017 22:06:37 -0400 Subject: [PATCH 053/234] [5.0] convert more dbflow packages to kotlin. --- .../sql/saveable/AutoIncrementModelSaver.java | 58 --- .../sql/saveable/AutoIncrementModelSaver.kt | 54 +++ .../sql/saveable/CacheableListModelSaver.java | 103 ------ .../sql/saveable/CacheableListModelSaver.kt | 90 +++++ .../dbflow/sql/saveable/ListModelSaver.java | 108 ------ .../dbflow/sql/saveable/ListModelSaver.kt | 94 +++++ .../dbflow/sql/saveable/ModelSaver.java | 212 ----------- .../android/dbflow/sql/saveable/ModelSaver.kt | 203 +++++++++++ ...verter.java => IMultiKeyCacheConverter.kt} | 13 +- .../dbflow/structure/cache/LruCache.java | 338 ------------------ .../dbflow/structure/cache/ModelCache.java | 61 ---- .../dbflow/structure/cache/ModelCache.kt | 50 +++ .../dbflow/structure/cache/ModelLruCache.java | 76 ---- .../dbflow/structure/cache/ModelLruCache.kt | 65 ++++ .../structure/cache/SimpleMapCache.java | 60 ---- .../dbflow/structure/cache/SimpleMapCache.kt | 45 +++ .../cache/SparseArrayBasedCache.java | 81 ----- .../structure/cache/SparseArrayBasedCache.kt | 67 ++++ 18 files changed, 673 insertions(+), 1105 deletions(-) delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/AutoIncrementModelSaver.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/AutoIncrementModelSaver.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/CacheableListModelSaver.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/CacheableListModelSaver.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ListModelSaver.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ListModelSaver.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ModelSaver.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ModelSaver.kt rename dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/{IMultiKeyCacheConverter.java => IMultiKeyCacheConverter.kt} (54%) delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/LruCache.java delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/ModelCache.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/ModelCache.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/ModelLruCache.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/ModelLruCache.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/SimpleMapCache.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/SimpleMapCache.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/SparseArrayBasedCache.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/SparseArrayBasedCache.kt diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/AutoIncrementModelSaver.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/AutoIncrementModelSaver.java deleted file mode 100644 index 27e022702..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/AutoIncrementModelSaver.java +++ /dev/null @@ -1,58 +0,0 @@ -package com.raizlabs.android.dbflow.sql.saveable; - -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.config.FlowLog; -import com.raizlabs.android.dbflow.runtime.NotifyDistributor; -import com.raizlabs.android.dbflow.structure.BaseModel; -import com.raizlabs.android.dbflow.structure.database.DatabaseStatement; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; - -/** - * Description: Used to properly handle autoincrementing fields. - */ -public class AutoIncrementModelSaver extends ModelSaver { - - @Override - public synchronized long insert(@NonNull TModel model) { - return insert(model, getWritableDatabase()); - } - - @Override - public synchronized long insert(@NonNull TModel model, @NonNull DatabaseWrapper wrapper) { - final boolean hasAutoIncrement = getModelAdapter().hasAutoIncrement(model); - DatabaseStatement insertStatement = hasAutoIncrement - ? getModelAdapter().getCompiledStatement(wrapper) - : getModelAdapter().getInsertStatement(wrapper); - long id; - try { - getModelAdapter().saveForeignKeys(model, wrapper); - if (hasAutoIncrement) { - getModelAdapter().bindToStatement(insertStatement, model); - } else { - getModelAdapter().bindToInsertStatement(insertStatement, model); - } - id = insertStatement.executeInsert(); - if (id > INSERT_FAILED) { - getModelAdapter().updateAutoIncrement(model, id); - NotifyDistributor.Companion.get().notifyModelChanged(model, getModelAdapter(), BaseModel.Action.INSERT); - } - } finally { - // since we generate an insert every time, we can safely close the statement here. - insertStatement.close(); - } - return id; - } - - @Override - public synchronized long insert(@NonNull TModel model, - @NonNull DatabaseStatement insertStatement, - @NonNull DatabaseWrapper wrapper) { - if (!getModelAdapter().hasAutoIncrement(model)) { - return super.insert(model, insertStatement, wrapper); - } else { - FlowLog.log(FlowLog.Level.W, "Ignoring insert statement " + insertStatement + " since an autoincrement column specified in the insert."); - return insert(model, wrapper); - } - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/AutoIncrementModelSaver.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/AutoIncrementModelSaver.kt new file mode 100644 index 000000000..d1779b20a --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/AutoIncrementModelSaver.kt @@ -0,0 +1,54 @@ +package com.raizlabs.android.dbflow.sql.saveable + +import com.raizlabs.android.dbflow.config.FlowLog +import com.raizlabs.android.dbflow.runtime.NotifyDistributor +import com.raizlabs.android.dbflow.structure.BaseModel +import com.raizlabs.android.dbflow.structure.database.DatabaseStatement +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper + +/** + * Description: Used to properly handle autoincrementing fields. + */ +class AutoIncrementModelSaver : ModelSaver() { + + @Synchronized override fun insert(model: TModel): Long { + return insert(model, writableDatabase) + } + + @Synchronized override fun insert(model: TModel, wrapper: DatabaseWrapper): Long { + val hasAutoIncrement = modelAdapter.hasAutoIncrement(model) + val insertStatement = when { + hasAutoIncrement -> modelAdapter.getCompiledStatement(wrapper) + else -> modelAdapter.getInsertStatement(wrapper) + } + val id: Long + try { + modelAdapter.saveForeignKeys(model, wrapper) + if (hasAutoIncrement) { + modelAdapter.bindToStatement(insertStatement, model) + } else { + modelAdapter.bindToInsertStatement(insertStatement, model) + } + id = insertStatement.executeInsert() + if (id > ModelSaver.INSERT_FAILED) { + modelAdapter.updateAutoIncrement(model, id) + NotifyDistributor.get().notifyModelChanged(model, modelAdapter, BaseModel.Action.INSERT) + } + } finally { + // since we generate an insert every time, we can safely close the statement here. + insertStatement.close() + } + return id + } + + @Synchronized override fun insert(model: TModel, + insertStatement: DatabaseStatement, + wrapper: DatabaseWrapper): Long { + return if (!modelAdapter.hasAutoIncrement(model)) { + super.insert(model, insertStatement, wrapper) + } else { + FlowLog.log(FlowLog.Level.W, "Ignoring insert statement $insertStatement since an autoincrement column specified in the insert.") + insert(model, wrapper) + } + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/CacheableListModelSaver.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/CacheableListModelSaver.java deleted file mode 100644 index c44478cd9..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/CacheableListModelSaver.java +++ /dev/null @@ -1,103 +0,0 @@ -package com.raizlabs.android.dbflow.sql.saveable; - -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.structure.ModelAdapter; -import com.raizlabs.android.dbflow.structure.database.DatabaseStatement; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; - -import java.util.Collection; - -/** - * Description: Used for model caching, enables caching models when saving in list. - */ -public class CacheableListModelSaver - extends ListModelSaver { - - public CacheableListModelSaver(@NonNull ModelSaver modelSaver) { - super(modelSaver); - } - - @Override - public synchronized void saveAll(@NonNull Collection tableCollection, - @NonNull DatabaseWrapper wrapper) { - // skip if empty. - if (tableCollection.isEmpty()) { - return; - } - - ModelSaver modelSaver = getModelSaver(); - ModelAdapter modelAdapter = modelSaver.getModelAdapter(); - DatabaseStatement statement = modelAdapter.getInsertStatement(wrapper); - DatabaseStatement updateStatement = modelAdapter.getUpdateStatement(wrapper); - try { - for (TModel model : tableCollection) { - if (modelSaver.save(model, wrapper, statement, updateStatement)) { - modelAdapter.storeModelInCache(model); - } - } - } finally { - updateStatement.close(); - statement.close(); - } - } - - @Override - public synchronized void insertAll(@NonNull Collection tableCollection, - @NonNull DatabaseWrapper wrapper) { - // skip if empty. - if (tableCollection.isEmpty()) { - return; - } - - ModelSaver modelSaver = getModelSaver(); - ModelAdapter modelAdapter = modelSaver.getModelAdapter(); - DatabaseStatement statement = modelAdapter.getInsertStatement(wrapper); - try { - for (TModel model : tableCollection) { - if (modelSaver.insert(model, statement, wrapper) > 0) { - modelAdapter.storeModelInCache(model); - } - } - } finally { - statement.close(); - } - } - - @Override - public synchronized void updateAll(@NonNull Collection tableCollection, - @NonNull DatabaseWrapper wrapper) { - // skip if empty. - if (tableCollection.isEmpty()) { - return; - } - ModelSaver modelSaver = getModelSaver(); - ModelAdapter modelAdapter = modelSaver.getModelAdapter(); - DatabaseStatement statement = modelAdapter.getUpdateStatement(wrapper); - try { - for (TModel model : tableCollection) { - if (modelSaver.update(model, wrapper, statement)) { - modelAdapter.storeModelInCache(model); - } - } - } finally { - statement.close(); - } - } - - @Override - public synchronized void deleteAll(@NonNull Collection tableCollection, - @NonNull DatabaseWrapper wrapper) { - // skip if empty. - if (tableCollection.isEmpty()) { - return; - } - - ModelSaver modelSaver = getModelSaver(); - for (TModel model : tableCollection) { - if (modelSaver.delete(model, wrapper)) { - getModelSaver().getModelAdapter().removeModelFromCache(model); - } - } - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/CacheableListModelSaver.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/CacheableListModelSaver.kt new file mode 100644 index 000000000..7d404ffa1 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/CacheableListModelSaver.kt @@ -0,0 +1,90 @@ +package com.raizlabs.android.dbflow.sql.saveable + +import com.raizlabs.android.dbflow.structure.ModelAdapter +import com.raizlabs.android.dbflow.structure.database.DatabaseStatement +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper + +/** + * Description: Used for model caching, enables caching models when saving in list. + */ +class CacheableListModelSaver(modelSaver: ModelSaver) : ListModelSaver(modelSaver) { + + @Synchronized override fun saveAll(tableCollection: Collection, + wrapper: DatabaseWrapper) { + // skip if empty. + if (tableCollection.isEmpty()) { + return + } + + val modelSaver = modelSaver + val modelAdapter = modelSaver.modelAdapter + val statement = modelAdapter.getInsertStatement(wrapper) + val updateStatement = modelAdapter.getUpdateStatement(wrapper) + try { + for (model in tableCollection) { + if (modelSaver.save(model, wrapper, statement, updateStatement)) { + modelAdapter.storeModelInCache(model) + } + } + } finally { + updateStatement.close() + statement.close() + } + } + + @Synchronized override fun insertAll(tableCollection: Collection, + wrapper: DatabaseWrapper) { + // skip if empty. + if (tableCollection.isEmpty()) { + return + } + + val modelSaver = modelSaver + val modelAdapter = modelSaver.modelAdapter + val statement = modelAdapter.getInsertStatement(wrapper) + try { + for (model in tableCollection) { + if (modelSaver.insert(model, statement, wrapper) > 0) { + modelAdapter.storeModelInCache(model) + } + } + } finally { + statement.close() + } + } + + @Synchronized override fun updateAll(tableCollection: Collection, + wrapper: DatabaseWrapper) { + // skip if empty. + if (tableCollection.isEmpty()) { + return + } + val modelSaver = modelSaver + val modelAdapter = modelSaver.modelAdapter + val statement = modelAdapter.getUpdateStatement(wrapper) + try { + for (model in tableCollection) { + if (modelSaver.update(model, wrapper, statement)) { + modelAdapter.storeModelInCache(model) + } + } + } finally { + statement.close() + } + } + + @Synchronized override fun deleteAll(tableCollection: Collection, + wrapper: DatabaseWrapper) { + // skip if empty. + if (tableCollection.isEmpty()) { + return + } + + val modelSaver = modelSaver + for (model in tableCollection) { + if (modelSaver.delete(model, wrapper)) { + modelSaver.modelAdapter.removeModelFromCache(model) + } + } + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ListModelSaver.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ListModelSaver.java deleted file mode 100644 index 2c10e30cd..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ListModelSaver.java +++ /dev/null @@ -1,108 +0,0 @@ -package com.raizlabs.android.dbflow.sql.saveable; - -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.structure.database.DatabaseStatement; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; - -import java.util.Collection; - -public class ListModelSaver { - - private final ModelSaver modelSaver; - - public ListModelSaver(@NonNull ModelSaver modelSaver) { - this.modelSaver = modelSaver; - } - - public synchronized void saveAll(@NonNull Collection tableCollection) { - saveAll(tableCollection, modelSaver.getWritableDatabase()); - } - - public synchronized void saveAll(@NonNull Collection tableCollection, - @NonNull DatabaseWrapper wrapper) { - // skip if empty. - if (tableCollection.isEmpty()) { - return; - } - - DatabaseStatement statement = modelSaver.getModelAdapter().getInsertStatement(wrapper); - DatabaseStatement updateStatement = modelSaver.getModelAdapter().getUpdateStatement(wrapper); - try { - for (TModel model : tableCollection) { - modelSaver.save(model, wrapper, statement, updateStatement); - } - } finally { - statement.close(); - updateStatement.close(); - } - } - - public synchronized void insertAll(@NonNull Collection tableCollection) { - insertAll(tableCollection, modelSaver.getWritableDatabase()); - } - - public synchronized void insertAll(@NonNull Collection tableCollection, - @NonNull DatabaseWrapper wrapper) { - // skip if empty. - if (tableCollection.isEmpty()) { - return; - } - - DatabaseStatement statement = modelSaver.getModelAdapter().getInsertStatement(wrapper); - try { - for (TModel model : tableCollection) { - modelSaver.insert(model, statement, wrapper); - } - } finally { - statement.close(); - } - } - - public synchronized void updateAll(@NonNull Collection tableCollection) { - updateAll(tableCollection, modelSaver.getWritableDatabase()); - } - - public synchronized void updateAll(@NonNull Collection tableCollection, - @NonNull DatabaseWrapper wrapper) { - // skip if empty. - if (tableCollection.isEmpty()) { - return; - } - - DatabaseStatement updateStatement = modelSaver.getModelAdapter().getUpdateStatement(wrapper); - try { - for (TModel model : tableCollection) { - modelSaver.update(model, wrapper, updateStatement); - } - } finally { - updateStatement.close(); - } - } - - public synchronized void deleteAll(@NonNull Collection tableCollection) { - deleteAll(tableCollection, modelSaver.getWritableDatabase()); - } - - public synchronized void deleteAll(@NonNull Collection tableCollection, - @NonNull DatabaseWrapper wrapper) { - // skip if empty. - if (tableCollection.isEmpty()) { - return; - } - - DatabaseStatement deleteStatement = modelSaver.getModelAdapter().getDeleteStatement(wrapper); - try { - for (TModel model : tableCollection) { - modelSaver.delete(model, deleteStatement, wrapper); - } - } finally { - deleteStatement.close(); - } - } - - @NonNull - public ModelSaver getModelSaver() { - return modelSaver; - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ListModelSaver.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ListModelSaver.kt new file mode 100644 index 000000000..f4c24dd26 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ListModelSaver.kt @@ -0,0 +1,94 @@ +package com.raizlabs.android.dbflow.sql.saveable + +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper + +open class ListModelSaver(val modelSaver: ModelSaver) { + + @Synchronized + fun saveAll(tableCollection: Collection) { + saveAll(tableCollection, modelSaver.writableDatabase) + } + + @Synchronized + fun saveAll(tableCollection: Collection, + wrapper: DatabaseWrapper) { + // skip if empty. + if (tableCollection.isEmpty()) { + return + } + + val statement = modelSaver.modelAdapter.getInsertStatement(wrapper) + val updateStatement = modelSaver.modelAdapter.getUpdateStatement(wrapper) + try { + for (model in tableCollection) { + modelSaver.save(model, wrapper, statement, updateStatement) + } + } finally { + statement.close() + updateStatement.close() + } + } + + @Synchronized + fun insertAll(tableCollection: Collection) { + insertAll(tableCollection, modelSaver.writableDatabase) + } + + @Synchronized + fun insertAll(tableCollection: Collection, + wrapper: DatabaseWrapper) { + // skip if empty. + if (tableCollection.isEmpty()) { + return + } + + val statement = modelSaver.modelAdapter.getInsertStatement(wrapper) + try { + tableCollection.forEach { modelSaver.insert(it, statement, wrapper) } + } finally { + statement.close() + } + } + + @Synchronized + fun updateAll(tableCollection: Collection) { + updateAll(tableCollection, modelSaver.writableDatabase) + } + + @Synchronized + fun updateAll(tableCollection: Collection, + wrapper: DatabaseWrapper) { + // skip if empty. + if (tableCollection.isEmpty()) { + return + } + + val updateStatement = modelSaver.modelAdapter.getUpdateStatement(wrapper) + try { + tableCollection.forEach { modelSaver.update(it, wrapper, updateStatement) } + } finally { + updateStatement.close() + } + } + + @Synchronized + fun deleteAll(tableCollection: Collection) { + deleteAll(tableCollection, modelSaver.writableDatabase) + } + + @Synchronized + fun deleteAll(tableCollection: Collection, + wrapper: DatabaseWrapper) { + // skip if empty. + if (tableCollection.isEmpty()) { + return + } + + val deleteStatement = modelSaver.modelAdapter.getDeleteStatement(wrapper) + try { + tableCollection.forEach { modelSaver.delete(it, deleteStatement, wrapper) } + } finally { + deleteStatement.close() + } + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ModelSaver.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ModelSaver.java deleted file mode 100644 index 1b30f0ede..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ModelSaver.java +++ /dev/null @@ -1,212 +0,0 @@ -package com.raizlabs.android.dbflow.sql.saveable; - -import android.content.ContentValues; -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.annotation.ConflictAction; -import com.raizlabs.android.dbflow.config.FlowManager; -import com.raizlabs.android.dbflow.runtime.NotifyDistributor; -import com.raizlabs.android.dbflow.structure.BaseModel; -import com.raizlabs.android.dbflow.structure.ModelAdapter; -import com.raizlabs.android.dbflow.structure.database.DatabaseStatement; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; - -/** - * Description: Defines how models get saved into the DB. It will bind values to {@link DatabaseStatement} - * for all CRUD operations as they are wildly faster and more efficient than {@link ContentValues}. - */ -public class ModelSaver { - - public static final int INSERT_FAILED = -1; - - private ModelAdapter modelAdapter; - - public void setModelAdapter(@NonNull ModelAdapter modelAdapter) { - this.modelAdapter = modelAdapter; - } - - public synchronized boolean save(@NonNull TModel model) { - return save(model, getWritableDatabase(), modelAdapter.getInsertStatement(), - modelAdapter.getUpdateStatement()); - } - - public synchronized boolean save(@NonNull TModel model, - @NonNull DatabaseWrapper wrapper) { - return save(model, wrapper, modelAdapter.getInsertStatement(wrapper), - modelAdapter.getUpdateStatement(wrapper)); - } - - @SuppressWarnings("unchecked") - public synchronized boolean save(@NonNull TModel model, - @NonNull DatabaseWrapper wrapper, - @NonNull DatabaseStatement insertStatement, - @NonNull DatabaseStatement updateStatement) { - boolean exists = modelAdapter.exists(model, wrapper); - - if (exists) { - exists = update(model, wrapper, updateStatement); - } - - if (!exists) { - exists = insert(model, insertStatement, wrapper) > INSERT_FAILED; - } - - if (exists) { - NotifyDistributor.Companion.get().notifyModelChanged(model, modelAdapter, BaseModel.Action.SAVE); - } - - // return successful store into db. - return exists; - } - - public synchronized boolean update(@NonNull TModel model) { - return update(model, getWritableDatabase(), modelAdapter.getUpdateStatement()); - } - - public synchronized boolean update(@NonNull TModel model, @NonNull DatabaseWrapper wrapper) { - DatabaseStatement updateStatement = modelAdapter.getUpdateStatement(wrapper); - boolean success = false; - try { - success = update(model, wrapper, updateStatement); - } finally { - // since we generate an insert every time, we can safely close the statement here. - updateStatement.close(); - } - return success; - } - - @SuppressWarnings("unchecked") - public synchronized boolean update(@NonNull TModel model, @NonNull DatabaseWrapper wrapper, - @NonNull DatabaseStatement databaseStatement) { - modelAdapter.saveForeignKeys(model, wrapper); - modelAdapter.bindToUpdateStatement(databaseStatement, model); - boolean successful = databaseStatement.executeUpdateDelete() != 0; - if (successful) { - NotifyDistributor.Companion.get().notifyModelChanged(model, modelAdapter, BaseModel.Action.UPDATE); - } - return successful; - } - - @SuppressWarnings("unchecked") - public synchronized long insert(@NonNull TModel model) { - return insert(model, modelAdapter.getInsertStatement(), getWritableDatabase()); - } - - @SuppressWarnings("unchecked") - public synchronized long insert(@NonNull TModel model, @NonNull DatabaseWrapper wrapper) { - DatabaseStatement insertStatement = modelAdapter.getInsertStatement(wrapper); - long result = 0; - try { - result = insert(model, insertStatement, wrapper); - } finally { - // since we generate an insert every time, we can safely close the statement here. - insertStatement.close(); - } - return result; - } - - @SuppressWarnings("unchecked") - public synchronized long insert(@NonNull TModel model, - @NonNull DatabaseStatement insertStatement, - @NonNull DatabaseWrapper wrapper) { - modelAdapter.saveForeignKeys(model, wrapper); - modelAdapter.bindToInsertStatement(insertStatement, model); - long id = insertStatement.executeInsert(); - if (id > INSERT_FAILED) { - modelAdapter.updateAutoIncrement(model, id); - NotifyDistributor.Companion.get().notifyModelChanged(model, modelAdapter, BaseModel.Action.INSERT); - } - return id; - } - - public synchronized boolean delete(@NonNull TModel model) { - return delete(model, modelAdapter.getDeleteStatement(), getWritableDatabase()); - } - - @SuppressWarnings("unchecked") - public synchronized boolean delete(@NonNull TModel model, @NonNull DatabaseWrapper wrapper) { - DatabaseStatement deleteStatement = modelAdapter.getDeleteStatement(wrapper); - boolean success = false; - try { - success = delete(model, deleteStatement, wrapper); - } finally { - // since we generate an insert every time, we can safely close the statement here. - deleteStatement.close(); - } - return success; - } - - @SuppressWarnings("unchecked") - public synchronized boolean delete(@NonNull TModel model, - @NonNull DatabaseStatement deleteStatement, - @NonNull DatabaseWrapper wrapper) { - modelAdapter.deleteForeignKeys(model, wrapper); - modelAdapter.bindToDeleteStatement(deleteStatement, model); - - boolean success = deleteStatement.executeUpdateDelete() != 0; - if (success) { - NotifyDistributor.Companion.get().notifyModelChanged(model, modelAdapter, BaseModel.Action.DELETE); - } - modelAdapter.updateAutoIncrement(model, 0); - return success; - } - - @NonNull - protected DatabaseWrapper getWritableDatabase() { - return FlowManager.getDatabaseForTable(modelAdapter.getModelClass()).getWritableDatabase(); - } - - @NonNull - public ModelAdapter getModelAdapter() { - return modelAdapter; - } - - /** - * Legacy save method. Uses {@link ContentValues} vs. the faster {@link DatabaseStatement} for updates. - * - * @see #save(Object, DatabaseWrapper, DatabaseStatement, DatabaseStatement) - */ - @Deprecated - @SuppressWarnings({"unchecked", "deprecation"}) - public synchronized boolean save(@NonNull TModel model, - @NonNull DatabaseWrapper wrapper, - @NonNull DatabaseStatement insertStatement, - @NonNull ContentValues contentValues) { - boolean exists = modelAdapter.exists(model, wrapper); - - if (exists) { - exists = update(model, wrapper, contentValues); - } - - if (!exists) { - exists = insert(model, insertStatement, wrapper) > INSERT_FAILED; - } - - if (exists) { - NotifyDistributor.Companion.get().notifyModelChanged(model, modelAdapter, BaseModel.Action.SAVE); - } - - // return successful store into db. - return exists; - } - - /** - * @see #update(Object, DatabaseWrapper, DatabaseStatement) - */ - @Deprecated - @SuppressWarnings("unchecked") - public synchronized boolean update(@NonNull TModel model, - @NonNull DatabaseWrapper wrapper, - @NonNull ContentValues contentValues) { - modelAdapter.saveForeignKeys(model, wrapper); - modelAdapter.bindToContentValues(contentValues, model); - boolean successful = wrapper.updateWithOnConflict(modelAdapter.getTableName(), contentValues, - modelAdapter.getPrimaryConditionClause(model).getQuery(), null, - ConflictAction.getSQLiteDatabaseAlgorithmInt(modelAdapter.getUpdateOnConflictAction())) != 0; - if (successful) { - NotifyDistributor.Companion.get().notifyModelChanged(model, modelAdapter, BaseModel.Action.UPDATE); - } - return successful; - } -} - diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ModelSaver.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ModelSaver.kt new file mode 100644 index 000000000..358c844ed --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ModelSaver.kt @@ -0,0 +1,203 @@ +package com.raizlabs.android.dbflow.sql.saveable + +import android.content.ContentValues + +import com.raizlabs.android.dbflow.annotation.ConflictAction +import com.raizlabs.android.dbflow.config.FlowManager +import com.raizlabs.android.dbflow.runtime.NotifyDistributor +import com.raizlabs.android.dbflow.structure.BaseModel +import com.raizlabs.android.dbflow.structure.ModelAdapter +import com.raizlabs.android.dbflow.structure.database.DatabaseStatement +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper + +/** + * Description: Defines how models get saved into the DB. It will bind values to [DatabaseStatement] + * for all CRUD operations as they are wildly faster and more efficient than [ContentValues]. + */ +open class ModelSaver { + + lateinit var modelAdapter: ModelAdapter + + protected val writableDatabase: DatabaseWrapper + get() = FlowManager.getDatabaseForTable(modelAdapter.modelClass).writableDatabase + + @Synchronized + fun save(model: TModel): Boolean { + return save(model, writableDatabase, modelAdapter.insertStatement, + modelAdapter.updateStatement) + } + + @Synchronized + fun save(model: TModel, + wrapper: DatabaseWrapper): Boolean { + return save(model, wrapper, modelAdapter.getInsertStatement(wrapper), + modelAdapter.getUpdateStatement(wrapper)) + } + + @Synchronized + fun save(model: TModel, + wrapper: DatabaseWrapper, + insertStatement: DatabaseStatement, + updateStatement: DatabaseStatement): Boolean { + var exists = modelAdapter.exists(model, wrapper) + + if (exists) { + exists = update(model, wrapper, updateStatement) + } + + if (!exists) { + exists = insert(model, insertStatement, wrapper) > INSERT_FAILED + } + + if (exists) { + NotifyDistributor.get().notifyModelChanged(model, modelAdapter, BaseModel.Action.SAVE) + } + + // return successful store into db. + return exists + } + + @Synchronized + fun update(model: TModel): Boolean { + return update(model, writableDatabase, modelAdapter.updateStatement) + } + + @Synchronized + fun update(model: TModel, wrapper: DatabaseWrapper): Boolean { + val updateStatement = modelAdapter.getUpdateStatement(wrapper) + var success = false + try { + success = update(model, wrapper, updateStatement) + } finally { + // since we generate an insert every time, we can safely close the statement here. + updateStatement.close() + } + return success + } + + @Synchronized + fun update(model: TModel, wrapper: DatabaseWrapper, + databaseStatement: DatabaseStatement): Boolean { + modelAdapter.saveForeignKeys(model, wrapper) + modelAdapter.bindToUpdateStatement(databaseStatement, model) + val successful = databaseStatement.executeUpdateDelete() != 0L + if (successful) { + NotifyDistributor.get().notifyModelChanged(model, modelAdapter, BaseModel.Action.UPDATE) + } + return successful + } + + @Synchronized open fun insert(model: TModel): Long { + return insert(model, modelAdapter.insertStatement, writableDatabase) + } + + @Synchronized open fun insert(model: TModel, wrapper: DatabaseWrapper): Long { + val insertStatement = modelAdapter.getInsertStatement(wrapper) + var result: Long = 0 + try { + result = insert(model, insertStatement, wrapper) + } finally { + // since we generate an insert every time, we can safely close the statement here. + insertStatement.close() + } + return result + } + + @Synchronized open fun insert(model: TModel, + insertStatement: DatabaseStatement, + wrapper: DatabaseWrapper): Long { + modelAdapter.saveForeignKeys(model, wrapper) + modelAdapter.bindToInsertStatement(insertStatement, model) + val id = insertStatement.executeInsert() + if (id > INSERT_FAILED) { + modelAdapter.updateAutoIncrement(model, id) + NotifyDistributor.get().notifyModelChanged(model, modelAdapter, BaseModel.Action.INSERT) + } + return id + } + + @Synchronized + fun delete(model: TModel): Boolean { + return delete(model, modelAdapter.deleteStatement, writableDatabase) + } + + @Synchronized + fun delete(model: TModel, wrapper: DatabaseWrapper): Boolean { + val deleteStatement = modelAdapter.getDeleteStatement(wrapper) + var success = false + try { + success = delete(model, deleteStatement, wrapper) + } finally { + // since we generate an insert every time, we can safely close the statement here. + deleteStatement.close() + } + return success + } + + @Synchronized + fun delete(model: TModel, + deleteStatement: DatabaseStatement, + wrapper: DatabaseWrapper): Boolean { + modelAdapter.deleteForeignKeys(model, wrapper) + modelAdapter.bindToDeleteStatement(deleteStatement, model) + + val success = deleteStatement.executeUpdateDelete() != 0L + if (success) { + NotifyDistributor.get().notifyModelChanged(model, modelAdapter, BaseModel.Action.DELETE) + } + modelAdapter.updateAutoIncrement(model, 0) + return success + } + + /** + * Legacy save method. Uses [ContentValues] vs. the faster [DatabaseStatement] for updates. + * + * @see .save + */ + @Deprecated("") + @Synchronized + fun save(model: TModel, + wrapper: DatabaseWrapper, + insertStatement: DatabaseStatement, + contentValues: ContentValues): Boolean { + var exists = modelAdapter.exists(model, wrapper) + + if (exists) { + exists = update(model, wrapper, contentValues) + } + + if (!exists) { + exists = insert(model, insertStatement, wrapper) > INSERT_FAILED + } + + if (exists) { + NotifyDistributor.get().notifyModelChanged(model, modelAdapter, BaseModel.Action.SAVE) + } + + // return successful store into db. + return exists + } + + /** + * @see .update + */ + @Deprecated("") + @Synchronized + fun update(model: TModel, wrapper: DatabaseWrapper, contentValues: ContentValues): Boolean { + modelAdapter.saveForeignKeys(model, wrapper) + modelAdapter.bindToContentValues(contentValues, model) + val successful = wrapper.updateWithOnConflict(modelAdapter.tableName, contentValues, + modelAdapter.getPrimaryConditionClause(model).query, null, + ConflictAction.getSQLiteDatabaseAlgorithmInt(modelAdapter.updateOnConflictAction)) != 0L + if (successful) { + NotifyDistributor.get().notifyModelChanged(model, modelAdapter, BaseModel.Action.UPDATE) + } + return successful + } + + companion object { + + val INSERT_FAILED = -1 + } +} + diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/IMultiKeyCacheConverter.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/IMultiKeyCacheConverter.kt similarity index 54% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/IMultiKeyCacheConverter.java rename to dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/IMultiKeyCacheConverter.kt index afc294e1e..c0ceafdf4 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/IMultiKeyCacheConverter.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/IMultiKeyCacheConverter.kt @@ -1,15 +1,13 @@ -package com.raizlabs.android.dbflow.structure.cache; +package com.raizlabs.android.dbflow.structure.cache -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.structure.Model; +import com.raizlabs.android.dbflow.structure.Model /** - * Description: This interface allows for {@link Model} to have multiple primary keys in a cache. This + * Description: This interface allows for [Model] to have multiple primary keys in a cache. This * interface "zips" the complex primary keys into one "representative" key. Also this can be used to * override the default caching key and provide a custom key. */ -public interface IMultiKeyCacheConverter { +interface IMultiKeyCacheConverter { /** * Converts the array of values into a singular representative key. The values are in order @@ -18,6 +16,5 @@ public interface IMultiKeyCacheConverter { * @param values The values to convert into a singular key. * @return The non-null */ - @NonNull - CacheKeyType getCachingKey(@NonNull Object[] values); + fun getCachingKey(values: Array): CacheKeyType } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/LruCache.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/LruCache.java deleted file mode 100644 index be531cd68..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/LruCache.java +++ /dev/null @@ -1,338 +0,0 @@ -package com.raizlabs.android.dbflow.structure.cache; - -/* - * Copyright (C) 2011 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -import java.util.LinkedHashMap; -import java.util.Locale; -import java.util.Map; - -/** - * Static library version of {@link android.util.LruCache}. Used to write apps that run on API levels prior to 12. When - * running on API level 12 or above, this implementation is still used; it does not try to switch to the framework's - * implementation. See the framework SDK documentation for a class overview. - * - * @see {@link android.util.LruCache} - * @deprecated - */ -@Deprecated -public class LruCache { - private final LinkedHashMap map; - - /** - * Size of this cache in units. Not necessarily the number of elements. - */ - private int size; - - private int maxSize; - - private int putCount; - - private int createCount; - - private int evictionCount; - - private int hitCount; - - private int missCount; - - /** - * @param maxSize for caches that do not override {@link #sizeOf}, this is the maximum number of entries in the - * cache. For all other caches, this is the maximum sum of the sizes of the entries in this cache. - */ - public LruCache(int maxSize) { - if (maxSize <= 0) { - throw new IllegalArgumentException("maxSize <= 0"); - } - this.maxSize = maxSize; - this.map = new LinkedHashMap<>(0, 0.75f, true); - } - - /** - * Sets the size of the cache. - * - * @param maxSize The new maximum size. - */ - public void resize(int maxSize) { - if (maxSize <= 0) { - throw new IllegalArgumentException("maxSize <= 0"); - } - - synchronized (this) { - this.maxSize = maxSize; - } - trimToSize(maxSize); - } - - /** - * Returns the value for {@code key} if it exists in the cache or can be created by {@code #create}. If a value was - * returned, it is moved to the head of the queue. This returns null if a value is not cached and cannot be - * created. - */ - public final V get(K key) { - if (key == null) { - throw new NullPointerException("key == null"); - } - - V mapValue; - synchronized (this) { - mapValue = map.get(key); - if (mapValue != null) { - hitCount++; - return mapValue; - } - missCount++; - } - - /* - * Attempt to create a value. This may take a long time, and the map - * may be different when create() returns. If a conflicting value was - * added to the map while create() was working, we leave that value in - * the map and release the created value. - */ - - V createdValue = create(key); - if (createdValue == null) { - return null; - } - - synchronized (this) { - createCount++; - mapValue = map.put(key, createdValue); - - if (mapValue != null) { - // There was a conflict so undo that last put - map.put(key, mapValue); - } else { - size += safeSizeOf(key, createdValue); - } - } - - if (mapValue != null) { - entryRemoved(false, key, createdValue, mapValue); - return mapValue; - } else { - trimToSize(maxSize); - return createdValue; - } - } - - /** - * Caches {@code value} for {@code key}. The value is moved to the head of the queue. - * - * @return the previous value mapped by {@code key}. - */ - public final V put(K key, V value) { - if (key == null || value == null) { - throw new NullPointerException("key == null || value == null"); - } - - V previous; - synchronized (this) { - putCount++; - size += safeSizeOf(key, value); - previous = map.put(key, value); - if (previous != null) { - size -= safeSizeOf(key, previous); - } - } - - if (previous != null) { - entryRemoved(false, key, previous, value); - } - - trimToSize(maxSize); - return previous; - } - - /** - * Remove the eldest entries until the total of remaining entries is at or below the requested size. - * - * @param maxSize the maximum size of the cache before returning. May be -1 to evict even 0-sized elements. - */ - public void trimToSize(int maxSize) { - while (true) { - K key; - V value; - synchronized (this) { - if (size < 0 || (map.isEmpty() && size != 0)) { - throw new IllegalStateException(getClass().getName() + ".sizeOf() is reporting inconsistent results!"); - } - - if (size <= maxSize || map.isEmpty()) { - break; - } - - Map.Entry toEvict = map.entrySet().iterator().next(); - key = toEvict.getKey(); - value = toEvict.getValue(); - map.remove(key); - size -= safeSizeOf(key, value); - evictionCount++; - } - - entryRemoved(true, key, value, null); - } - } - - /** - * Removes the entry for {@code key} if it exists. - * - * @return the previous value mapped by {@code key}. - */ - public final V remove(K key) { - if (key == null) { - throw new NullPointerException("key == null"); - } - - V previous; - synchronized (this) { - previous = map.remove(key); - if (previous != null) { - size -= safeSizeOf(key, previous); - } - } - - if (previous != null) { - entryRemoved(false, key, previous, null); - } - - return previous; - } - - /** - * Called for entries that have been evicted or removed. This method is invoked when a value is evicted to make - * space, removed by a call to {@link #remove}, or replaced by a call to {@link #put}. The default implementation - * does nothing. - *

The method is called without synchronization: other threads may access the cache while this method is - * executing. - * - * @param evicted true if the entry is being removed to make space, false if the removal was caused by a {@link - * #put} or {@link #remove}. - * @param newValue the new value for {@code key}, if it exists. If non-null, this removal was caused by a {@link - * #put}. Otherwise it was caused by an eviction or a {@link #remove}. - */ - protected void entryRemoved(boolean evicted, K key, V oldValue, V newValue) { - } - - /** - * Called after a cache miss to compute a value for the corresponding key. Returns the computed value or null if no - * value can be computed. The default implementation returns null. - *

The method is called without synchronization: other threads may access the cache while this method is - * executing. - *

If a value for {@code key} exists in the cache when this method returns, the created value will be released - * with {@link #entryRemoved} and discarded. This can occur when multiple threads request the same key at the same - * time (causing multiple values to be created), or when one thread calls {@link #put} while another is creating a - * value for the same key. - */ - protected V create(K key) { - return null; - } - - private int safeSizeOf(K key, V value) { - int result = sizeOf(key, value); - if (result < 0) { - throw new IllegalStateException("Negative size: " + key + "=" + value); - } - return result; - } - - /** - * Returns the size of the entry for {@code key} and {@code value} in user-defined units. The default - * implementation returns 1 so that size is the number of entries and max size is the maximum number of entries. - *

- *

An entry's size must not change while it is in the cache. - */ - protected int sizeOf(K key, V value) { - return 1; - } - - /** - * Clear the cache, calling {@link #entryRemoved} on each removed entry. - */ - public final void evictAll() { - trimToSize(-1); // -1 will evict 0-sized elements - } - - /** - * For caches that do not override {@link #sizeOf}, this returns the number of entries in the cache. For all other - * caches, this returns the sum of the sizes of the entries in this cache. - */ - public synchronized final int size() { - return size; - } - - /** - * For caches that do not override {@link #sizeOf}, this returns the maximum number of entries in the cache. For all - * other caches, this returns the maximum sum of the sizes of the entries in this cache. - */ - public synchronized final int maxSize() { - return maxSize; - } - - /** - * Returns the number of times {@link #get} returned a value that was already present in the cache. - */ - public synchronized final int hitCount() { - return hitCount; - } - - /** - * Returns the number of times {@link #get} returned null or required a new value to be created. - */ - public synchronized final int missCount() { - return missCount; - } - - /** - * Returns the number of times {@link #create(Object)} returned a value. - */ - public synchronized final int createCount() { - return createCount; - } - - /** - * Returns the number of times {@link #put} was called. - */ - public synchronized final int putCount() { - return putCount; - } - - /** - * Returns the number of values that have been evicted. - */ - public synchronized final int evictionCount() { - return evictionCount; - } - - /** - * Returns a copy of the current contents of the cache, ordered from least recently accessed to most recently - * accessed. - */ - public synchronized final Map snapshot() { - return new LinkedHashMap<>(map); - } - - @Override - public synchronized final String toString() { - int accesses = hitCount + missCount; - int hitPercent = accesses != 0 ? (100 * hitCount / accesses) : 0; - return String.format(Locale.getDefault(), - "LruCache[maxSize=%d,hits=%d,misses=%d,hitRate=%d%%]", maxSize, - hitCount, missCount, hitPercent); - } -} - diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/ModelCache.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/ModelCache.java deleted file mode 100644 index 1bf321a05..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/ModelCache.java +++ /dev/null @@ -1,61 +0,0 @@ -package com.raizlabs.android.dbflow.structure.cache; - -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -/** - * Description: A generic cache for models that is implemented or can be implemented to your liking. - */ -public abstract class ModelCache { - - private CacheClass cache; - - /** - * Constructs new instance with a cache - * - * @param cache The arbitrary underlying cache class. - */ - public ModelCache(@NonNull CacheClass cache) { - this.cache = cache; - } - - /** - * Adds a model to this cache. - * - * @param id The id of the model to use. - * @param model The model to add - */ - public abstract void addModel(@Nullable Object id, @NonNull TModel model); - - /** - * Removes a model from this cache. - * - * @param id The id of the model to remove. - */ - public abstract TModel removeModel(@NonNull Object id); - - /** - * Clears out all models from this cache. - */ - public abstract void clear(); - - /** - * @param id The id of the model to retrieve. - * @return a model for the specified id. May be null. - */ - public abstract TModel get(@Nullable Object id); - - /** - * Sets a new size for the underlying cache (if applicable) and may destroy the cache. - * - * @param size The size of cache to set to - */ - public abstract void setCacheSize(int size); - - /** - * @return The cache that's backing this cache. - */ - public CacheClass getCache() { - return cache; - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/ModelCache.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/ModelCache.kt new file mode 100644 index 000000000..7511e526c --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/ModelCache.kt @@ -0,0 +1,50 @@ +package com.raizlabs.android.dbflow.structure.cache + +/** + * Description: A generic cache for models that is implemented or can be implemented to your liking. + */ +abstract class ModelCache +/** + * Constructs new instance with a cache + * + * @param cache The arbitrary underlying cache class. + */ +( + /** + * @return The cache that's backing this cache. + */ + val cache: CacheClass) { + + /** + * Adds a model to this cache. + * + * @param id The id of the model to use. + * @param model The model to add + */ + abstract fun addModel(id: Any?, model: TModel) + + /** + * Removes a model from this cache. + * + * @param id The id of the model to remove. + */ + abstract fun removeModel(id: Any): TModel? + + /** + * Clears out all models from this cache. + */ + abstract fun clear() + + /** + * @param id The id of the model to retrieve. + * @return a model for the specified id. May be null. + */ + abstract operator fun get(id: Any?): TModel? + + /** + * Sets a new size for the underlying cache (if applicable) and may destroy the cache. + * + * @param size The size of cache to set to + */ + abstract fun setCacheSize(size: Int) +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/ModelLruCache.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/ModelLruCache.java deleted file mode 100644 index e7b72b431..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/ModelLruCache.java +++ /dev/null @@ -1,76 +0,0 @@ -package com.raizlabs.android.dbflow.structure.cache; - -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.annotation.Table; - -/** - * Description: Provides an {@link com.raizlabs.android.dbflow.structure.cache.LruCache} under its hood - * and provides synchronization mechanisms. - */ -public class ModelLruCache extends ModelCache> { - - /** - * @param size The size, if less than or equal to 0 we set it to {@link Table#DEFAULT_CACHE_SIZE}. - */ - public static ModelLruCache newInstance(int size) { - if (size <= 0) { - size = Table.DEFAULT_CACHE_SIZE; - } - return new ModelLruCache<>(size); - } - - protected ModelLruCache(int size) { - super(new LruCache(size)); - } - - @Override - public void addModel(@Nullable Object id, @NonNull TModel model) { - if (id instanceof Number) { - synchronized (getCache()) { - Number number = ((Number) id); - getCache().put(number.longValue(), model); - } - } else { - throw new IllegalArgumentException("A ModelLruCache must use an id that can cast to" + - "a Number to convert it into a long"); - } - } - - @Override - public TModel removeModel(@NonNull Object id) { - TModel model; - if (id instanceof Number) { - synchronized (getCache()) { - model = getCache().remove(((Number) id).longValue()); - } - } else { - throw new IllegalArgumentException("A ModelLruCache uses an id that can cast to" + - "a Number to convert it into a long"); - } - return model; - } - - @Override - public void clear() { - synchronized (getCache()) { - getCache().evictAll(); - } - } - - @Override - public void setCacheSize(int size) { - getCache().resize(size); - } - - @Override - public TModel get(@Nullable Object id) { - if (id instanceof Number) { - return getCache().get(((Number) id).longValue()); - } else { - throw new IllegalArgumentException("A ModelLruCache must use an id that can cast to" + - "a Number to convert it into a long"); - } - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/ModelLruCache.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/ModelLruCache.kt new file mode 100644 index 000000000..d7e0683ae --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/ModelLruCache.kt @@ -0,0 +1,65 @@ +package com.raizlabs.android.dbflow.structure.cache + +import android.util.LruCache + +import com.raizlabs.android.dbflow.annotation.Table + +/** + * Description: Provides an [android.util.LruCache] under its hood + * and provides synchronization mechanisms. + */ +class ModelLruCache(size: Int) + : ModelCache>(LruCache(size)) { + + override fun addModel(id: Any?, model: TModel) { + if (id is Number) { + synchronized(cache) { + cache.put(id.toLong(), model) + } + } else { + throw IllegalArgumentException("A ModelLruCache must use an id that can cast to" + "a Number to convert it into a long") + } + } + + override fun removeModel(id: Any): TModel? { + if (id is Number) { + synchronized(cache) { + return cache.remove(id.toLong()) + } + } else { + throw IllegalArgumentException("A ModelLruCache uses an id that can cast to" + "a Number to convert it into a long") + } + } + + override fun clear() { + synchronized(cache) { + cache.evictAll() + } + } + + override fun setCacheSize(size: Int) { + cache.resize(size) + } + + override fun get(id: Any?): TModel? { + return if (id is Number) { + cache.get(id.toLong()) + } else { + throw IllegalArgumentException("A ModelLruCache must use an id that can cast to" + "a Number to convert it into a long") + } + } + + companion object { + + /** + * @param size The size, if less than or equal to 0 we set it to [Table.DEFAULT_CACHE_SIZE]. + */ + fun newInstance(size: Int): ModelLruCache { + var _size = size + if (_size <= 0) { + _size = Table.DEFAULT_CACHE_SIZE + } + return ModelLruCache(_size) + } + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/SimpleMapCache.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/SimpleMapCache.java deleted file mode 100644 index 59bbdeb5e..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/SimpleMapCache.java +++ /dev/null @@ -1,60 +0,0 @@ -package com.raizlabs.android.dbflow.structure.cache; - -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.config.FlowLog; -import com.raizlabs.android.dbflow.structure.Model; - -import java.util.HashMap; -import java.util.Map; - -/** - * Description: A simple implementation that keeps {@link Model} you interact with in memory. - */ -public class SimpleMapCache extends ModelCache> { - - /** - * Constructs new instance with a {@link HashMap} with the specified capacity. - * - * @param capacity The capacity to use on the hashmap. - */ - public SimpleMapCache(int capacity) { - super(new HashMap(capacity)); - } - - /** - * Constructs new instance with a cache - * - * @param cache The arbitrary underlying cache class. - */ - public SimpleMapCache(@NonNull Map cache) { - super(cache); - } - - @Override - public void addModel(@Nullable Object id, @NonNull TModel model) { - getCache().put(id, model); - } - - @Override - public TModel removeModel(@NonNull Object id) { - return getCache().remove(id); - } - - @Override - public void clear() { - getCache().clear(); - } - - @Override - public TModel get(@Nullable Object id) { - return getCache().get(id); - } - - @Override - public void setCacheSize(int size) { - FlowLog.log(FlowLog.Level.I, "The cache size for " + SimpleMapCache.class.getSimpleName() + - " is not re-configurable."); - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/SimpleMapCache.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/SimpleMapCache.kt new file mode 100644 index 000000000..a1df046ec --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/SimpleMapCache.kt @@ -0,0 +1,45 @@ +package com.raizlabs.android.dbflow.structure.cache + +import com.raizlabs.android.dbflow.config.FlowLog +import com.raizlabs.android.dbflow.structure.Model +import java.util.* + +/** + * Description: A simple implementation that keeps [Model] you interact with in memory. + */ +class SimpleMapCache : ModelCache> { + + /** + * Constructs new instance with a [HashMap] with the specified capacity. + * + * @param capacity The capacity to use on the hashmap. + */ + constructor(capacity: Int) : super(HashMap(capacity)) + + /** + * Constructs new instance with a cache + * + * @param cache The arbitrary underlying cache class. + */ + constructor(cache: MutableMap) : super(cache) + + override fun addModel(id: Any?, model: TModel) { + cache.put(id, model) + } + + override fun removeModel(id: Any): TModel? { + return cache.remove(id) + } + + override fun clear() { + cache.clear() + } + + override fun get(id: Any?): TModel? { + return cache.get(id) + } + + override fun setCacheSize(size: Int) { + FlowLog.log(FlowLog.Level.W, "The cache size for ${SimpleMapCache::class.java.simpleName} is not re-configurable.") + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/SparseArrayBasedCache.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/SparseArrayBasedCache.java deleted file mode 100644 index 4db00dca0..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/SparseArrayBasedCache.java +++ /dev/null @@ -1,81 +0,0 @@ -package com.raizlabs.android.dbflow.structure.cache; - -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; -import android.util.SparseArray; - -import com.raizlabs.android.dbflow.config.FlowLog; - -/** - * Description: A cache backed by a {@link android.util.SparseArray} - */ -public class SparseArrayBasedCache extends ModelCache> { - - /** - * Constructs new instance with a {@link android.util.SparseArray} cache - */ - public SparseArrayBasedCache() { - super(new SparseArray()); - } - - /** - * Constructs new instance with a {@link android.util.SparseArray} cache - * - * @param initialCapacity The initial capacity of the sparse array - */ - public SparseArrayBasedCache(int initialCapacity) { - super(new SparseArray(initialCapacity)); - } - - /** - * Constructs new instance with the specified {@link java.util.List} - * - * @param sparseArray The sparse array to use. - */ - public SparseArrayBasedCache(@NonNull SparseArray sparseArray) { - super(sparseArray); - } - - @Override - public void addModel(@Nullable Object id, @NonNull TModel model) { - if (id instanceof Number) { - synchronized (getCache()) { - getCache().put(((Number) id).intValue(), model); - } - } else { - throw new IllegalArgumentException("A SparseArrayBasedCache must use an id that can cast to " + - "a Number to convert it into a int"); - } - } - - @Override - public TModel removeModel(@NonNull Object id) { - TModel model = get(id); - synchronized (getCache()) { - getCache().remove(((Number) id).intValue()); - } - return model; - } - - @Override - public void clear() { - synchronized (getCache()) { - getCache().clear(); - } - } - - @Override - public void setCacheSize(int size) { - FlowLog.log(FlowLog.Level.I, "The cache size for " + SparseArrayBasedCache.class.getSimpleName() + " is not re-configurable."); - } - - @Override - public TModel get(@Nullable Object id) { - if (id instanceof Number) { - return getCache().get(((Number) id).intValue()); - } else { - throw new IllegalArgumentException("A SparseArrayBasedCache uses an id that can cast to " + - "a Number to convert it into a int"); - } - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/SparseArrayBasedCache.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/SparseArrayBasedCache.kt new file mode 100644 index 000000000..c38ae669a --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/SparseArrayBasedCache.kt @@ -0,0 +1,67 @@ +package com.raizlabs.android.dbflow.structure.cache + +import android.util.SparseArray + +import com.raizlabs.android.dbflow.config.FlowLog + +/** + * Description: A cache backed by a [android.util.SparseArray] + */ +class SparseArrayBasedCache : ModelCache> { + + /** + * Constructs new instance with a [android.util.SparseArray] cache + */ + constructor() : super(SparseArray()) {} + + /** + * Constructs new instance with a [android.util.SparseArray] cache + * + * @param initialCapacity The initial capacity of the sparse array + */ + constructor(initialCapacity: Int) : super(SparseArray(initialCapacity)) {} + + /** + * Constructs new instance with the specified [java.util.List] + * + * @param sparseArray The sparse array to use. + */ + constructor(sparseArray: SparseArray) : super(sparseArray) {} + + override fun addModel(id: Any?, model: TModel) { + if (id is Number) { + synchronized(cache) { + cache.put(id.toInt(), model) + } + } else { + throw IllegalArgumentException("A SparseArrayBasedCache must use an id that can cast to " + "a Number to convert it into a int") + } + } + + override fun removeModel(id: Any): TModel? { + val model = get(id) + synchronized(cache) { + cache.remove((id as Number).toInt()) + } + return model + } + + override fun clear() { + synchronized(cache) { + cache.clear() + } + } + + override fun setCacheSize(size: Int) { + FlowLog.log(FlowLog.Level.I, "The cache size for ${SparseArrayBasedCache::class.java.simpleName} is not re-configurable.") + } + + override fun get(id: Any?): TModel? { + return if (id is Number) { + cache.get(id.toInt()) + } else { + throw IllegalArgumentException("A SparseArrayBasedCache uses an id that can cast to " + + "a Number to convert it into a int") + } + } +} From 1c28fe6ed5591aeb754083365532daee987e3d64 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Wed, 22 Nov 2017 17:40:52 -0500 Subject: [PATCH 054/234] [5.0] convert more of the sql language package to kotlin. update to latest build tools. --- build.gradle | 4 +- dbflow-core/build.gradle | 13 +- .../dbflow/config/ConfigIntegrationTest.kt | 4 +- .../android/dbflow/models/issue/Issue.java | 2 +- .../android/dbflow/models/issue/SubIssue.java | 2 +- .../dbflow/models/java/JavaModelView.java | 2 +- .../android/dbflow/config/DatabaseConfig.kt | 2 +- .../dbflow/config/DatabaseDefinition.kt | 14 +- .../android/dbflow/config/TableConfig.java | 103 --- .../android/dbflow/config/TableConfig.kt | 66 ++ .../android/dbflow/list/FlowQueryList.kt | 2 +- .../dbflow/runtime/FlowContentObserver.java | 2 +- .../raizlabs/android/dbflow/sql/SqlUtils.java | 4 +- .../sql/language/BaseModelQueriable.java | 168 ---- .../dbflow/sql/language/BaseModelQueriable.kt | 97 ++ .../dbflow/sql/language/BaseOperator.java | 6 +- .../dbflow/sql/language/BaseQueriable.java | 163 ---- .../dbflow/sql/language/BaseQueriable.kt | 100 ++ .../sql/language/BaseTransformable.java | 114 --- .../dbflow/sql/language/BaseTransformable.kt | 64 ++ .../android/dbflow/sql/language/Case.java | 134 --- .../android/dbflow/sql/language/Case.kt | 106 +++ .../dbflow/sql/language/CaseCondition.java | 75 -- .../dbflow/sql/language/CaseCondition.kt | 71 ++ .../dbflow/sql/language/CompletedTrigger.java | 67 -- .../dbflow/sql/language/CompletedTrigger.kt | 58 ++ .../dbflow/sql/language/CursorResult.java | 166 ---- .../dbflow/sql/language/CursorResult.kt | 132 +++ .../android/dbflow/sql/language/Delete.java | 54 -- .../android/dbflow/sql/language/Delete.kt | 48 + .../sql/language/ExistenceOperator.java | 67 -- .../dbflow/sql/language/ExistenceOperator.kt | 41 + .../android/dbflow/sql/language/From.java | 249 ----- .../android/dbflow/sql/language/From.kt | 200 ++++ .../dbflow/sql/language/IConditional.kt | 4 +- .../android/dbflow/sql/language/Index.java | 166 ---- .../android/dbflow/sql/language/Index.kt | 122 +++ .../dbflow/sql/language/IndexedBy.java | 49 - .../android/dbflow/sql/language/IndexedBy.kt | 35 + .../android/dbflow/sql/language/Insert.java | 332 ------- .../android/dbflow/sql/language/Insert.kt | 272 ++++++ .../android/dbflow/sql/language/Join.java | 188 ---- .../android/dbflow/sql/language/Join.kt | 172 ++++ .../android/dbflow/sql/language/Method.java | 287 ------ .../android/dbflow/sql/language/Method.kt | 220 +++++ .../dbflow/sql/language/NameAlias.java | 308 ------- .../android/dbflow/sql/language/NameAlias.kt | 240 +++++ .../android/dbflow/sql/language/Operator.java | 866 ------------------ .../android/dbflow/sql/language/Operator.kt | 626 +++++++++++++ .../dbflow/sql/language/OperatorGroup.java | 241 ----- .../dbflow/sql/language/OperatorGroup.kt | 192 ++++ .../android/dbflow/sql/language/OrderBy.java | 91 -- .../android/dbflow/sql/language/OrderBy.kt | 73 ++ .../dbflow/sql/language/SQLOperator.kt | 2 +- .../android/dbflow/sql/language/SQLite.java | 131 --- .../android/dbflow/sql/language/SQLite.kt | 107 +++ .../android/dbflow/sql/language/Select.java | 107 --- .../android/dbflow/sql/language/Select.kt | 98 ++ .../android/dbflow/sql/language/Set.java | 64 -- .../android/dbflow/sql/language/Set.kt | 42 + .../dbflow/sql/language/Transformable.java | 41 - .../dbflow/sql/language/Transformable.kt | 28 + .../android/dbflow/sql/language/Trigger.java | 148 --- .../android/dbflow/sql/language/Trigger.kt | 127 +++ .../dbflow/sql/language/TriggerMethod.java | 98 -- .../dbflow/sql/language/TriggerMethod.kt | 84 ++ .../sql/language/UnSafeStringOperator.java | 76 -- .../sql/language/UnSafeStringOperator.kt | 51 ++ .../android/dbflow/sql/language/Update.java | 111 --- .../android/dbflow/sql/language/Update.kt | 79 ++ .../android/dbflow/sql/language/Where.java | 264 ------ .../android/dbflow/sql/language/Where.kt | 203 ++++ .../sql/language/property/IProperty.java | 24 +- .../dbflow/sql/language/property/Property.kt | 39 +- .../dbflow/sql/queriable/ModelQueriable.kt | 12 +- .../android/dbflow/sql/queriable/Queriable.kt | 14 - .../dbflow/structure/ModelAdapter.java | 4 +- .../dbflow/structure/RetrievalAdapter.java | 18 +- 78 files changed, 3835 insertions(+), 5021 deletions(-) delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/config/TableConfig.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/config/TableConfig.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseModelQueriable.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseModelQueriable.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseQueriable.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseQueriable.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseTransformable.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseTransformable.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Case.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Case.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CaseCondition.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CaseCondition.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CompletedTrigger.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CompletedTrigger.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CursorResult.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CursorResult.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Delete.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Delete.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/ExistenceOperator.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/ExistenceOperator.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/From.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/From.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Index.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Index.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IndexedBy.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IndexedBy.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Insert.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Insert.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Join.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Join.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Method.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Method.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/NameAlias.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/NameAlias.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Operator.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Operator.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/OperatorGroup.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/OperatorGroup.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/OrderBy.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/OrderBy.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/SQLite.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/SQLite.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Select.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Select.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Set.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Set.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Transformable.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Transformable.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Trigger.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Trigger.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/TriggerMethod.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/TriggerMethod.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/UnSafeStringOperator.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/UnSafeStringOperator.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Update.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Update.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Where.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Where.kt diff --git a/build.gradle b/build.gradle index d1d25895c..38276b36e 100644 --- a/build.gradle +++ b/build.gradle @@ -1,11 +1,11 @@ buildscript { - ext.kotlin_version = '1.1.51' + ext.kotlin_version = '1.1.60' repositories { jcenter() google() } dependencies { - classpath 'com.android.tools.build:gradle:3.0.0-rc2' + classpath 'com.android.tools.build:gradle:3.0.0' classpath 'com.github.dcendents:android-maven-gradle-plugin:1.5' classpath 'com.getkeepsafe.dexcount:dexcount-gradle-plugin:0.7.3' classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version" diff --git a/dbflow-core/build.gradle b/dbflow-core/build.gradle index 8a3deae9b..88f43508f 100644 --- a/dbflow-core/build.gradle +++ b/dbflow-core/build.gradle @@ -1,8 +1,19 @@ apply plugin: 'java' +apply plugin: 'kotlin' project.ext.artifactId = bt_name targetCompatibility = JavaVersion.VERSION_1_7 sourceCompatibility = JavaVersion.VERSION_1_7 -apply from: '../java-artifacts.gradle' \ No newline at end of file +dependencies { + compile "org.jetbrains.kotlin:kotlin-stdlib-jre8:$kotlin_version" +} + +apply from: '../java-artifacts.gradle' + +compileKotlin { + kotlinOptions { + jvmTarget = "1.7" + } +} \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/config/ConfigIntegrationTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/config/ConfigIntegrationTest.kt index b7711d9cf..ee440b3eb 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/config/ConfigIntegrationTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/config/ConfigIntegrationTest.kt @@ -65,8 +65,8 @@ class ConfigIntegrationTest : BaseUnitTest() { val config = databaseConfig.tableConfigMap[SimpleModel::class.java] as TableConfig assertNotNull(config) - assertEquals(config.listModelLoader(), customListModelLoader) - assertEquals(config.singleModelLoader(), singleModelLoader) + assertEquals(config.listModelLoader, customListModelLoader) + assertEquals(config.singleModelLoader, singleModelLoader) val modelAdapter = FlowManager.getModelAdapter(SimpleModel::class.java) assertEquals(modelAdapter.listModelLoader, customListModelLoader) diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/Issue.java b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/Issue.java index 61d6663d6..8c5b9d44f 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/Issue.java +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/Issue.java @@ -24,7 +24,7 @@ public class Issue extends BaseModel { @OneToMany(methods = {OneToMany.Method.SAVE, OneToMany.Method.DELETE}, variableName = "subIssueList") public List getDbSubIssueList() { if (subIssueList == null || subIssueList.isEmpty()) { - subIssueList = SQLite.select() + subIssueList = SQLite.INSTANCE.select() .from(SubIssue.class) .where(SubIssue_Table.owningIssueId.eq(id)) .queryList(); diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/SubIssue.java b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/SubIssue.java index 1841d4750..e7a979d49 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/SubIssue.java +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/SubIssue.java @@ -31,7 +31,7 @@ public List getDbPageList() { pageList = new ArrayList<>(); } if (pageList.isEmpty()) { - pageList = SQLite.select() + pageList = SQLite.INSTANCE.select() .from(Page.class) .where(Page_Table.owningIssueId.eq(owningIssueId), Page_Table.subIssue_id.eq(id)) .queryList(); diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/java/JavaModelView.java b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/java/JavaModelView.java index 7e2f2860c..ba0e31884 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/java/JavaModelView.java +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/java/JavaModelView.java @@ -21,6 +21,6 @@ public class JavaModelView { Integer firstName; private static Query getQuery() { - return SQLite.select(Author_Table.first_name.as("firstName"), Author_Table.id.as("id")); + return SQLite.INSTANCE.select(Author_Table.first_name.as("firstName"), Author_Table.id.as("id")); } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.kt index fac7dce98..2599a83cd 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.kt @@ -84,7 +84,7 @@ class DatabaseConfig( } fun addTableConfig(tableConfig: TableConfig<*>) = apply { - tableConfigMap.put(tableConfig.tableClass(), tableConfig) + tableConfigMap.put(tableConfig.tableClass, tableConfig) } fun modelNotifier(modelNotifier: ModelNotifier) = apply { diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.kt index 7d889a796..f96e0a93a 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.kt @@ -168,17 +168,17 @@ abstract class DatabaseDefinition { // initialize configuration if exists. val tableConfigCollection = databaseConfig.tableConfigMap.values for (tableConfig in tableConfigCollection) { - val modelAdapter = modelAdapters[tableConfig.tableClass()] ?: continue - if (tableConfig.listModelLoader() != null) { - modelAdapter.setListModelLoader(tableConfig.listModelLoader()) + val modelAdapter = modelAdapters[tableConfig.tableClass] ?: continue + if (tableConfig.listModelLoader != null) { + modelAdapter.listModelLoader = tableConfig.listModelLoader } - if (tableConfig.singleModelLoader() != null) { - modelAdapter.setSingleModelLoader(tableConfig.singleModelLoader()) + if (tableConfig.singleModelLoader != null) { + modelAdapter.singleModelLoader = tableConfig.singleModelLoader } - if (tableConfig.modelSaver() != null) { - modelAdapter.setModelSaver(tableConfig.modelSaver()) + if (tableConfig.modelSaver != null) { + modelAdapter.modelSaver = tableConfig.modelSaver } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/TableConfig.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/TableConfig.java deleted file mode 100644 index c01aefa7c..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/TableConfig.java +++ /dev/null @@ -1,103 +0,0 @@ -package com.raizlabs.android.dbflow.config; - -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.sql.queriable.ListModelLoader; -import com.raizlabs.android.dbflow.sql.queriable.SingleModelLoader; -import com.raizlabs.android.dbflow.sql.saveable.ModelSaver; -import com.raizlabs.android.dbflow.structure.ModelAdapter; - -import java.util.List; - -/** - * Description: Represents certain table configuration options. This allows you to easily specify - * certain configuration options for a table. - */ -public final class TableConfig { - - public static TableConfig.Builder builder(Class tableClass) { - return new TableConfig.Builder<>(tableClass); - } - - private final Class tableClass; - private final ModelSaver modelSaver; - private final SingleModelLoader singleModelLoader; - private final ListModelLoader listModelLoader; - - TableConfig(Builder builder) { - tableClass = builder.tableClass; - modelSaver = builder.modelAdapterModelSaver; - singleModelLoader = builder.singleModelLoader; - listModelLoader = builder.listModelLoader; - } - - @NonNull - public Class tableClass() { - return tableClass; - } - - @Nullable - public ModelSaver modelSaver() { - return modelSaver; - } - - @Nullable - public ListModelLoader listModelLoader() { - return listModelLoader; - } - - @Nullable - public SingleModelLoader singleModelLoader() { - return singleModelLoader; - } - - public static final class Builder { - - final Class tableClass; - ModelSaver modelAdapterModelSaver; - SingleModelLoader singleModelLoader; - ListModelLoader listModelLoader; - - public Builder(@NonNull Class tableClass) { - this.tableClass = tableClass; - } - - /** - * Define how the {@link ModelAdapter} saves data into the DB from its associated {@link TModel}. This - * will override the default. - */ - @NonNull - public Builder modelAdapterModelSaver(@NonNull ModelSaver modelSaver) { - this.modelAdapterModelSaver = modelSaver; - return this; - } - - /** - * Define how the table loads single models. This will override the default. - */ - @NonNull - public Builder singleModelLoader(@NonNull SingleModelLoader singleModelLoader) { - this.singleModelLoader = singleModelLoader; - return this; - } - - /** - * Define how the table loads a {@link List} of items. This will override the default. - */ - @NonNull - public Builder listModelLoader(@NonNull ListModelLoader listModelLoader) { - this.listModelLoader = listModelLoader; - return this; - } - - /** - * @return A new {@link TableConfig}. Subsequent calls to this method produce a new instance - * of {@link TableConfig}. - */ - @NonNull - public TableConfig build() { - return new TableConfig<>(this); - } - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/TableConfig.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/TableConfig.kt new file mode 100644 index 000000000..aa6217167 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/TableConfig.kt @@ -0,0 +1,66 @@ +package com.raizlabs.android.dbflow.config + +import com.raizlabs.android.dbflow.sql.queriable.ListModelLoader +import com.raizlabs.android.dbflow.sql.queriable.SingleModelLoader +import com.raizlabs.android.dbflow.sql.saveable.ModelSaver +import com.raizlabs.android.dbflow.structure.ModelAdapter + +/** + * Description: Represents certain table configuration options. This allows you to easily specify + * certain configuration options for a table. + */ +class TableConfig(val tableClass: Class? = null, + val modelSaver: ModelSaver? = null, + val singleModelLoader: SingleModelLoader? = null, + val listModelLoader: ListModelLoader? = null) { + + internal constructor(builder: Builder) : this( + tableClass = builder.tableClass, + modelSaver = builder.modelAdapterModelSaver, + singleModelLoader = builder.singleModelLoader, + listModelLoader = builder.listModelLoader + ) + + /** + * Table builder for java consumers. use [TableConfig] directly if calling from Kotlin. + */ + class Builder(internal val tableClass: Class) { + internal var modelAdapterModelSaver: ModelSaver? = null + internal var singleModelLoader: SingleModelLoader? = null + internal var listModelLoader: ListModelLoader? = null + + /** + * Define how the [ModelAdapter] saves data into the DB from its associated [TModel]. This + * will override the default. + */ + fun modelAdapterModelSaver(modelSaver: ModelSaver) = apply { + this.modelAdapterModelSaver = modelSaver + } + + /** + * Define how the table loads single models. This will override the default. + */ + fun singleModelLoader(singleModelLoader: SingleModelLoader) = apply { + this.singleModelLoader = singleModelLoader + } + + /** + * Define how the table loads a [List] of items. This will override the default. + */ + fun listModelLoader(listModelLoader: ListModelLoader) = apply { + this.listModelLoader = listModelLoader + } + + /** + * @return A new [TableConfig]. Subsequent calls to this method produce a new instance + * of [TableConfig]. + */ + fun build(): TableConfig<*> = TableConfig(this) + } + + companion object { + + fun builder(tableClass: Class): TableConfig.Builder = + TableConfig.Builder(tableClass) + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowQueryList.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowQueryList.kt index 1a4285c5a..bd46fb04a 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowQueryList.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowQueryList.kt @@ -289,7 +289,7 @@ class FlowQueryList( } /** - * If true, when an operation occurs when we call endTransactionAndNotify, we refresh content. + * If true, when an operation occurs whenever we call endTransactionAndNotify, we refresh content. */ fun changeInTransaction(changeInTransaction: Boolean) = apply { this.changeInTransaction = changeInTransaction diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/FlowContentObserver.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/FlowContentObserver.java index 06aa336e4..4853d4e5c 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/FlowContentObserver.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/FlowContentObserver.java @@ -265,7 +265,7 @@ private void onChange(boolean selfChanges, Uri uri, boolean calledInternally) { for (String key : queryNames) { param = Uri.decode(uri.getQueryParameter(key)); columnName = Uri.decode(key); - columnsChanged[index] = Operator.op(new NameAlias.Builder(columnName).build()) + columnsChanged[index] = Operator.Companion.op(new NameAlias.Builder(columnName).build()) .eq(param); index++; } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/SqlUtils.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/SqlUtils.java index 3293cef7d..999dc847b 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/SqlUtils.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/SqlUtils.java @@ -130,7 +130,7 @@ public static Uri getNotificationUri(@NonNull Class modelClass, @Nullable Object notifyValue) { Operator operator = null; if (StringUtils.isNotNullOrEmpty(notifyKey)) { - operator = Operator.op(new NameAlias.Builder(notifyKey).build()).value(notifyValue); + operator = Operator.Companion.op(new NameAlias.Builder(notifyKey).build()).value(notifyValue); } return getNotificationUri(modelClass, action, new SQLOperator[]{operator}); } @@ -185,7 +185,7 @@ public static void addContentValues(@NonNull ContentValues contentValues, @NonNu for (Map.Entry entry : entries) { String key = entry.getKey(); - operatorGroup.and(Operator.op(new NameAlias.Builder(key).build()) + operatorGroup.and(Operator.Companion.op(new NameAlias.Builder(key).build()) .is(contentValues.get(key))); } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseModelQueriable.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseModelQueriable.java deleted file mode 100644 index cc1f12dfa..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseModelQueriable.java +++ /dev/null @@ -1,168 +0,0 @@ -package com.raizlabs.android.dbflow.sql.language; - -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.config.FlowLog; -import com.raizlabs.android.dbflow.config.FlowManager; -import com.raizlabs.android.dbflow.list.FlowCursorList; -import com.raizlabs.android.dbflow.list.FlowQueryList; -import com.raizlabs.android.dbflow.runtime.NotifyDistributor; -import com.raizlabs.android.dbflow.sql.Query; -import com.raizlabs.android.dbflow.sql.SqlUtils; -import com.raizlabs.android.dbflow.sql.queriable.AsyncQuery; -import com.raizlabs.android.dbflow.sql.queriable.ListModelLoader; -import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable; -import com.raizlabs.android.dbflow.sql.queriable.SingleModelLoader; -import com.raizlabs.android.dbflow.structure.InstanceAdapter; -import com.raizlabs.android.dbflow.structure.QueryModelAdapter; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; - -import java.util.List; - -/** - * Description: Provides a base implementation of {@link ModelQueriable} to simplify a lot of code. It provides the - * default implementation for convenience. - */ -public abstract class BaseModelQueriable extends BaseQueriable - implements ModelQueriable, Query { - - private InstanceAdapter retrievalAdapter; - - private boolean cachingEnabled = true; - - /** - * Constructs new instance of this class and is meant for subclasses only. - * - * @param table the table that belongs to this query. - */ - protected BaseModelQueriable(Class table) { - super(table); - } - - private InstanceAdapter getRetrievalAdapter() { - if (retrievalAdapter == null) { - retrievalAdapter = FlowManager.getInstanceAdapter(getTable()); - } - return retrievalAdapter; - } - - @NonNull - @Override - public CursorResult queryResults() { - return new CursorResult<>(getRetrievalAdapter().getModelClass(), query()); - } - - @NonNull - @Override - public List queryList() { - String query = getQuery(); - FlowLog.log(FlowLog.Level.V, "Executing query: " + query); - return getListModelLoader().load(query); - } - - @Nullable - @Override - public TModel querySingle() { - String query = getQuery(); - FlowLog.log(FlowLog.Level.V, "Executing query: " + query); - return getSingleModelLoader().load(query); - } - - @Override - public TModel querySingle(@NonNull DatabaseWrapper wrapper) { - String query = getQuery(); - FlowLog.log(FlowLog.Level.V, "Executing query: " + query); - return getSingleModelLoader().load(wrapper, query); - } - - @NonNull - @Override - public List queryList(@NonNull DatabaseWrapper wrapper) { - String query = getQuery(); - FlowLog.log(FlowLog.Level.V, "Executing query: " + query); - return getListModelLoader().load(wrapper, query); - } - - @NonNull - @Override - public FlowCursorList cursorList() { - return new FlowCursorList.Builder<>(getTable()) - .cacheModels(cachingEnabled) - .modelQueriable(this).build(); - } - - @NonNull - @Override - public FlowQueryList flowQueryList() { - return new FlowQueryList.Builder<>(getTable()) - .cacheModels(cachingEnabled) - .modelQueriable(this) - .build(); - } - - @Override - public long executeUpdateDelete() { - return executeUpdateDelete(FlowManager.getWritableDatabaseForTable(getTable())); - } - - @Override - public long executeUpdateDelete(@NonNull DatabaseWrapper databaseWrapper) { - long affected = databaseWrapper.compileStatement(getQuery()).executeUpdateDelete(); - - // only notify for affected. - if (affected > 0) { - NotifyDistributor.Companion.get().notifyTableChanged(getTable(), getPrimaryAction()); - } - return affected; - } - - @NonNull - @Override - public AsyncQuery async() { - return new AsyncQuery<>(this); - } - - @NonNull - @Override - public List queryCustomList(@NonNull Class queryModelClass) { - String query = getQuery(); - FlowLog.log(FlowLog.Level.V, "Executing query: " + query); - QueryModelAdapter adapter = FlowManager.getQueryModelAdapter(queryModelClass); - return cachingEnabled - ? adapter.getListModelLoader().load(query) - : adapter.getNonCacheableListModelLoader().load(query); - } - - @Nullable - @Override - public QueryClass queryCustomSingle(@NonNull Class queryModelClass) { - String query = getQuery(); - FlowLog.log(FlowLog.Level.V, "Executing query: " + query); - QueryModelAdapter adapter = FlowManager.getQueryModelAdapter(queryModelClass); - return cachingEnabled - ? adapter.getSingleModelLoader().load(query) - : adapter.getNonCacheableSingleModelLoader().load(query); - } - - @NonNull - @Override - public ModelQueriable disableCaching() { - cachingEnabled = false; - return this; - } - - private ListModelLoader getListModelLoader() { - return cachingEnabled - ? getRetrievalAdapter().getListModelLoader() - : getRetrievalAdapter().getNonCacheableListModelLoader(); - } - - private SingleModelLoader getSingleModelLoader() { - return cachingEnabled - ? getRetrievalAdapter().getSingleModelLoader() - : getRetrievalAdapter().getNonCacheableSingleModelLoader(); - } - - -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseModelQueriable.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseModelQueriable.kt new file mode 100644 index 000000000..a00a8627d --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseModelQueriable.kt @@ -0,0 +1,97 @@ +package com.raizlabs.android.dbflow.sql.language + +import com.raizlabs.android.dbflow.config.FlowLog +import com.raizlabs.android.dbflow.config.FlowManager +import com.raizlabs.android.dbflow.list.FlowCursorList +import com.raizlabs.android.dbflow.list.FlowQueryList +import com.raizlabs.android.dbflow.runtime.NotifyDistributor +import com.raizlabs.android.dbflow.sql.Query +import com.raizlabs.android.dbflow.sql.queriable.AsyncQuery +import com.raizlabs.android.dbflow.sql.queriable.ListModelLoader +import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable +import com.raizlabs.android.dbflow.sql.queriable.SingleModelLoader +import com.raizlabs.android.dbflow.structure.InstanceAdapter +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper + +/** + * Description: Provides a base implementation of [ModelQueriable] to simplify a lot of code. It provides the + * default implementation for convenience. + */ +abstract class BaseModelQueriable +/** + * Constructs new instance of this class and is meant for subclasses only. + * + * @param table the table that belongs to this query. + */ +protected constructor(table: Class) + : BaseQueriable(table), ModelQueriable, Query { + + private val retrievalAdapter: InstanceAdapter by lazy { FlowManager.getInstanceAdapter(table) } + + private val listModelLoader: ListModelLoader + get() = retrievalAdapter.listModelLoader + + private val singleModelLoader: SingleModelLoader + get() = retrievalAdapter.singleModelLoader + + override fun queryResults(): CursorResult = CursorResult(retrievalAdapter.modelClass, query()) + + override fun queryList(): MutableList { + val query = query + FlowLog.log(FlowLog.Level.V, "Executing query: " + query) + return listModelLoader.load(query)!! + } + + override fun querySingle(): TModel? { + val query = query + FlowLog.log(FlowLog.Level.V, "Executing query: " + query) + return singleModelLoader.load(query) + } + + override fun querySingle(wrapper: DatabaseWrapper): TModel? { + val query = query + FlowLog.log(FlowLog.Level.V, "Executing query: " + query) + return singleModelLoader.load(wrapper, query) + } + + override fun queryList(wrapper: DatabaseWrapper): MutableList { + val query = query + FlowLog.log(FlowLog.Level.V, "Executing query: " + query) + return listModelLoader.load(wrapper, query)!! + } + + override fun cursorList(): FlowCursorList = FlowCursorList.Builder(this).build() + + override fun flowQueryList(): FlowQueryList = + FlowQueryList.Builder(modelQueriable = this).build() + + override fun executeUpdateDelete(): Long = + executeUpdateDelete(FlowManager.getWritableDatabaseForTable(table)) + + override fun executeUpdateDelete(databaseWrapper: DatabaseWrapper): Long { + val affected = databaseWrapper.compileStatement(query).executeUpdateDelete() + + // only notify for affected. + if (affected > 0) { + NotifyDistributor.get().notifyTableChanged(table, primaryAction) + } + return affected + } + + override fun async(): AsyncQuery = AsyncQuery(this) + + override fun queryCustomList(queryModelClass: Class): MutableList { + val query = query + FlowLog.log(FlowLog.Level.V, "Executing query: " + query) + val adapter = FlowManager.getQueryModelAdapter(queryModelClass) + return adapter.listModelLoader.load(query)!! + } + + override fun queryCustomSingle(queryModelClass: Class): QueryClass? { + val query = query + FlowLog.log(FlowLog.Level.V, "Executing query: " + query) + val adapter = FlowManager.getQueryModelAdapter(queryModelClass) + return adapter.singleModelLoader.load(query) + } + +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseOperator.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseOperator.java index 5b7535e63..2d3144f48 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseOperator.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseOperator.java @@ -85,7 +85,7 @@ public static String convertValueToString(@Nullable Object value, stringVal = "X" + DatabaseUtils.sqlEscapeString(SqlUtils.byteArrayToHexString(bytes)); } else { stringVal = String.valueOf(value); - if (!stringVal.equals(Operator.Operation.EMPTY_PARAM)) { + if (!stringVal.equals(Operator.Operation.INSTANCE.getEMPTY_PARAM())) { stringVal = DatabaseUtils.sqlEscapeString(stringVal); } } @@ -180,7 +180,7 @@ public static String joinArguments(@NonNull CharSequence delimiter, @NonNull Ite /** * The column name */ - @NonNull + @Nullable protected NameAlias nameAlias; /** @@ -198,7 +198,7 @@ public static String joinArguments(@NonNull CharSequence delimiter, @NonNull Ite */ protected boolean isValueSet; - BaseOperator(@NonNull NameAlias nameAlias) { + BaseOperator(@Nullable NameAlias nameAlias) { this.nameAlias = nameAlias; } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseQueriable.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseQueriable.java deleted file mode 100644 index 935043700..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseQueriable.java +++ /dev/null @@ -1,163 +0,0 @@ -package com.raizlabs.android.dbflow.sql.language; - -import android.database.Cursor; -import android.database.sqlite.SQLiteDoneException; -import android.database.sqlite.SQLiteStatement; -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.config.FlowLog; -import com.raizlabs.android.dbflow.config.FlowManager; -import com.raizlabs.android.dbflow.runtime.NotifyDistributor; -import com.raizlabs.android.dbflow.sql.SqlUtils; -import com.raizlabs.android.dbflow.sql.queriable.Queriable; -import com.raizlabs.android.dbflow.structure.BaseModel; -import com.raizlabs.android.dbflow.structure.database.DatabaseStatement; -import com.raizlabs.android.dbflow.structure.database.DatabaseStatementWrapper; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; -import com.raizlabs.android.dbflow.structure.database.FlowCursor; - -/** - * Description: Base implementation of something that can be queried from the database. - */ -public abstract class BaseQueriable implements Queriable, Actionable { - - - private final Class table; - - protected BaseQueriable(Class table) { - this.table = table; - } - - /** - * @return The table associated with this INSERT - */ - @NonNull - public Class getTable() { - return table; - } - - /** - * Execute a statement that returns a 1 by 1 table with a numeric value. - * For example, SELECT COUNT(*) FROM table. - * Please see {@link SQLiteStatement#simpleQueryForLong()}. - *

- * catches a {@link SQLiteDoneException} if result is not found and returns 0. The error can safely be ignored. - */ - @Override - public long count(@NonNull DatabaseWrapper databaseWrapper) { - return longValue(databaseWrapper); - } - - /** - * Execute a statement that returns a 1 by 1 table with a numeric value. - * For example, SELECT COUNT(*) FROM table. - * Please see {@link SQLiteStatement#simpleQueryForLong()}. - */ - @Override - public long count() { - return longValue(); - } - - @Override - public long longValue() { - return longValue(FlowManager.getWritableDatabaseForTable(table)); - } - - @Override - public long longValue(DatabaseWrapper databaseWrapper) { - try { - String query = getQuery(); - FlowLog.log(FlowLog.Level.V, "Executing query: " + query); - return SqlUtils.longForQuery(databaseWrapper, query); - } catch (SQLiteDoneException sde) { - // catch exception here, log it but return 0; - FlowLog.logWarning(sde); - } - return 0; - } - - @Override - public boolean hasData() { - return count() > 0; - } - - @Override - public boolean hasData(@NonNull DatabaseWrapper databaseWrapper) { - return count(databaseWrapper) > 0; - } - - @Override - public FlowCursor query() { - query(FlowManager.getWritableDatabaseForTable(table)); - return null; - } - - @Override - public FlowCursor query(@NonNull DatabaseWrapper databaseWrapper) { - if (getPrimaryAction().equals(BaseModel.Action.INSERT)) { - // inserting, let's compile and insert - DatabaseStatement databaseStatement = compileStatement(databaseWrapper); - databaseStatement.executeInsert(); - databaseStatement.close(); - } else { - String query = getQuery(); - FlowLog.log(FlowLog.Level.V, "Executing query: " + query); - databaseWrapper.execSQL(query); - } - return null; - } - - @Override - public long executeInsert() { - return executeInsert(FlowManager.getWritableDatabaseForTable(table)); - } - - @Override - public long executeInsert(@NonNull DatabaseWrapper databaseWrapper) { - return compileStatement().executeInsert(); - } - - @Override - public void execute() { - Cursor cursor = query(); - if (cursor != null) { - cursor.close(); - } else { - // we dont query, we're executing something here. - NotifyDistributor.Companion.get().notifyTableChanged(getTable(), getPrimaryAction()); - } - } - - @Override - public void execute(@NonNull DatabaseWrapper databaseWrapper) { - Cursor cursor = query(databaseWrapper); - if (cursor != null) { - cursor.close(); - } else { - // we dont query, we're executing something here. - NotifyDistributor.Companion.get().notifyTableChanged(getTable(), getPrimaryAction()); - } - } - - @NonNull - @Override - public DatabaseStatement compileStatement() { - return compileStatement(FlowManager.getWritableDatabaseForTable(table)); - } - - @NonNull - @Override - public DatabaseStatement compileStatement(@NonNull DatabaseWrapper databaseWrapper) { - String query = getQuery(); - FlowLog.log(FlowLog.Level.V, "Compiling Query Into Statement: " + query); - return new DatabaseStatementWrapper<>(databaseWrapper.compileStatement(query), this); - } - - @Override - public String toString() { - return getQuery(); - } - - @NonNull - public abstract BaseModel.Action getPrimaryAction(); -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseQueriable.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseQueriable.kt new file mode 100644 index 000000000..6178dd259 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseQueriable.kt @@ -0,0 +1,100 @@ +package com.raizlabs.android.dbflow.sql.language + +import android.database.sqlite.SQLiteDoneException +import com.raizlabs.android.dbflow.config.FlowLog +import com.raizlabs.android.dbflow.config.FlowManager +import com.raizlabs.android.dbflow.runtime.NotifyDistributor +import com.raizlabs.android.dbflow.sql.SqlUtils +import com.raizlabs.android.dbflow.sql.queriable.Queriable +import com.raizlabs.android.dbflow.structure.BaseModel +import com.raizlabs.android.dbflow.structure.database.DatabaseStatement +import com.raizlabs.android.dbflow.structure.database.DatabaseStatementWrapper +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.structure.database.FlowCursor + +/** + * Description: Base implementation of something that can be queried from the database. + */ +abstract class BaseQueriable protected constructor( + /** + * @return The table associated with this INSERT + */ + val table: Class) : Queriable, Actionable { + + abstract override val primaryAction: BaseModel.Action + + override fun longValue(): Long = longValue(FlowManager.getWritableDatabaseForTable(table)) + + override fun longValue(databaseWrapper: DatabaseWrapper): Long { + try { + val query = query + FlowLog.log(FlowLog.Level.V, "Executing query: " + query) + return SqlUtils.longForQuery(databaseWrapper, query) + } catch (sde: SQLiteDoneException) { + // catch exception here, log it but return 0; + FlowLog.logWarning(sde) + } + + return 0 + } + + override fun hasData(): Boolean = longValue() > 0 + + override fun hasData(databaseWrapper: DatabaseWrapper): Boolean = longValue(databaseWrapper) > 0 + + override fun query(): FlowCursor? { + query(FlowManager.getWritableDatabaseForTable(table)) + return null + } + + override fun query(databaseWrapper: DatabaseWrapper): FlowCursor? { + if (primaryAction == BaseModel.Action.INSERT) { + // inserting, let's compile and insert + val databaseStatement = compileStatement(databaseWrapper) + databaseStatement.executeInsert() + databaseStatement.close() + } else { + val query = query + FlowLog.log(FlowLog.Level.V, "Executing query: " + query) + databaseWrapper.execSQL(query) + } + return null + } + + override fun executeInsert(): Long = + executeInsert(FlowManager.getWritableDatabaseForTable(table)) + + override fun executeInsert(databaseWrapper: DatabaseWrapper): Long = + compileStatement().executeInsert() + + override fun execute() { + val cursor = query() + if (cursor != null) { + cursor.close() + } else { + // we dont query, we're executing something here. + NotifyDistributor.get().notifyTableChanged(table, primaryAction) + } + } + + override fun execute(databaseWrapper: DatabaseWrapper) { + val cursor = query(databaseWrapper) + if (cursor != null) { + cursor.close() + } else { + // we dont query, we're executing something here. + NotifyDistributor.get().notifyTableChanged(table, primaryAction) + } + } + + override fun compileStatement(): DatabaseStatement = + compileStatement(FlowManager.getWritableDatabaseForTable(table)) + + override fun compileStatement(databaseWrapper: DatabaseWrapper): DatabaseStatement { + val query = query + FlowLog.log(FlowLog.Level.V, "Compiling Query Into Statement: " + query) + return DatabaseStatementWrapper(databaseWrapper.compileStatement(query), this) + } + + override fun toString(): String = query +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseTransformable.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseTransformable.java deleted file mode 100644 index ea768bf70..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseTransformable.java +++ /dev/null @@ -1,114 +0,0 @@ -package com.raizlabs.android.dbflow.sql.language; - -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.sql.language.property.IProperty; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; -import com.raizlabs.android.dbflow.structure.database.FlowCursor; - -import java.util.List; - -/** - * Description: Combines basic transformations and query ops into a base class. - */ -public abstract class BaseTransformable extends BaseModelQueriable implements Transformable, - WhereBase { - - /** - * Constructs new instance of this class and is meant for subclasses only. - * - * @param table the table that belongs to this query. - */ - protected BaseTransformable(Class table) { - super(table); - } - - @NonNull - public Where where(@NonNull SQLOperator... conditions) { - return new Where<>(this, conditions); - } - - @Override - public FlowCursor query() { - return where().query(); - } - - @Override - public FlowCursor query(@NonNull DatabaseWrapper databaseWrapper) { - return where().query(databaseWrapper); - } - - @NonNull - @Override - public Where groupBy(NameAlias... nameAliases) { - return where().groupBy(nameAliases); - } - - @NonNull - @Override - public Where groupBy(IProperty... properties) { - return where().groupBy(properties); - } - - @NonNull - @Override - public Where orderBy(@NonNull NameAlias nameAlias, boolean ascending) { - return where().orderBy(nameAlias, ascending); - } - - @NonNull - @Override - public Where orderBy(@NonNull IProperty property, boolean ascending) { - return where().orderBy(property, ascending); - } - - @NonNull - @Override - public Where orderByAll(@NonNull List orderBies) { - return where().orderByAll(orderBies); - } - - @NonNull - @Override - public Where orderBy(@NonNull OrderBy orderBy) { - return where().orderBy(orderBy); - } - - @NonNull - @Override - public Where limit(int count) { - return where().limit(count); - } - - @NonNull - @Override - public Where offset(int offset) { - return where().offset(offset); - } - - @NonNull - @Override - public Where having(SQLOperator... conditions) { - return where().having(conditions); - } - - @NonNull - @Override - public List queryList() { - checkSelect("query"); - return super.queryList(); - } - - @Override - public TModel querySingle() { - checkSelect("query"); - limit(1); - return super.querySingle(); - } - - private void checkSelect(String methodName) { - if (!(getQueryBuilderBase() instanceof Select)) { - throw new IllegalArgumentException("Please use " + methodName + "(). The beginning is not a Select"); - } - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseTransformable.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseTransformable.kt new file mode 100644 index 000000000..bd73465e0 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseTransformable.kt @@ -0,0 +1,64 @@ +package com.raizlabs.android.dbflow.sql.language + +import com.raizlabs.android.dbflow.sql.language.property.IProperty +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.structure.database.FlowCursor + +/** + * Description: Combines basic transformations and query ops into a base class. + */ +abstract class BaseTransformable +/** + * Constructs new instance of this class and is meant for subclasses only. + * + * @param table the table that belongs to this query. + */ +protected constructor(table: Class) + : BaseModelQueriable(table), Transformable, WhereBase { + + fun where(vararg conditions: SQLOperator): Where = Where(this, *conditions) + + override fun query(): FlowCursor? = where().query() + + override fun query(databaseWrapper: DatabaseWrapper): FlowCursor? = + where().query(databaseWrapper) + + override fun groupBy(vararg nameAliases: NameAlias): Where = + where().groupBy(*nameAliases) + + override fun groupBy(vararg properties: IProperty<*>): Where = + where().groupBy(*properties) + + override fun orderBy(nameAlias: NameAlias, ascending: Boolean): Where = + where().orderBy(nameAlias, ascending) + + override fun orderBy(property: IProperty<*>, ascending: Boolean): Where = + where().orderBy(property, ascending) + + override fun orderByAll(orderBies: List): Where = where().orderByAll(orderBies) + + override fun orderBy(orderBy: OrderBy): Where = where().orderBy(orderBy) + + override fun limit(count: Int): Where = where().limit(count) + + override fun offset(offset: Int): Where = where().offset(offset) + + override fun having(vararg conditions: SQLOperator): Where = where().having(*conditions) + + override fun queryList(): MutableList { + checkSelect("query") + return super.queryList() + } + + override fun querySingle(): TModel? { + checkSelect("query") + limit(1) + return super.querySingle() + } + + private fun checkSelect(methodName: String) { + if (queryBuilderBase !is Select) { + throw IllegalArgumentException("Please use $methodName(). The beginning is not a Select") + } + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Case.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Case.java deleted file mode 100644 index f18a31924..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Case.java +++ /dev/null @@ -1,134 +0,0 @@ -package com.raizlabs.android.dbflow.sql.language; - -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.sql.Query; -import com.raizlabs.android.dbflow.sql.QueryBuilder; -import com.raizlabs.android.dbflow.sql.language.property.IProperty; -import com.raizlabs.android.dbflow.sql.language.property.Property; - -import java.util.ArrayList; -import java.util.List; - -/** - * Description: Represents a SQLITE CASE argument. - */ -public class Case implements Query { - - private IProperty caseColumn; - private List> caseConditions = new ArrayList<>(); - private String columnName; - private TReturn elseValue; - private boolean elseSpecified = false; - - // when true, only WHEN value is supported. Not WHEN condition - private boolean efficientCase = false; - - private boolean endSpecified = false; - - Case() { - } - - Case(IProperty caseColumn) { - this.caseColumn = caseColumn; - if (caseColumn != null) { - efficientCase = true; - } - } - - @NonNull - public CaseCondition when(@NonNull SQLOperator sqlOperator) { - if (efficientCase) { - throw new IllegalStateException("When using the efficient CASE method," + - "you must pass in value only, not condition."); - } - CaseCondition caseCondition = new CaseCondition<>(this, sqlOperator); - caseConditions.add(caseCondition); - return caseCondition; - } - - @NonNull - public CaseCondition when(@Nullable TReturn whenValue) { - if (!efficientCase) { - throw new IllegalStateException("When not using the efficient CASE method, " + - "you must pass in the SQLOperator as a parameter"); - } - CaseCondition caseCondition = new CaseCondition<>(this, whenValue); - caseConditions.add(caseCondition); - return caseCondition; - } - - @NonNull - public CaseCondition when(@NonNull IProperty property) { - if (!efficientCase) { - throw new IllegalStateException("When not using the efficient CASE method, " + - "you must pass in the SQLOperator as a parameter"); - } - CaseCondition caseCondition = new CaseCondition<>(this, property); - caseConditions.add(caseCondition); - return caseCondition; - } - - /** - * Default case here. If not specified, value will be NULL. - */ - @NonNull - public Case _else(@Nullable TReturn elseValue) { - this.elseValue = elseValue; - elseSpecified = true; // ensure its set especially if null specified. - return this; - } - - /** - * @param columnName The name of the case that we return in a column. - * @return The case completed as a property. - */ - @NonNull - public Property> end(@Nullable String columnName) { - endSpecified = true; - if (columnName != null) { - this.columnName = QueryBuilder.quoteIfNeeded(columnName); - } - return new Property<>(null, NameAlias.rawBuilder(getQuery()) - .build()); - } - - /** - * @return The case completed as a property. - */ - @NonNull - public Property> end() { - return end(null); - } - - /** - * @return The case complete as an operator. - */ - @NonNull - public Operator endAsOperator() { - return Operator.op(end().getNameAlias()); - } - - boolean isEfficientCase() { - return efficientCase; - } - - @Override - public String getQuery() { - QueryBuilder queryBuilder = new QueryBuilder(" CASE"); - if (isEfficientCase()) { - queryBuilder.append(" " + BaseOperator.convertValueToString(caseColumn, false)); - } - - queryBuilder.append(QueryBuilder.join("", caseConditions)); - - if (elseSpecified) { - queryBuilder.append(" ELSE ").append(BaseOperator.convertValueToString(elseValue, false)); - } - if (endSpecified) { - queryBuilder.append(" END " + (columnName != null ? columnName : "")); - } - return queryBuilder.getQuery(); - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Case.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Case.kt new file mode 100644 index 000000000..2836b4763 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Case.kt @@ -0,0 +1,106 @@ +package com.raizlabs.android.dbflow.sql.language + +import com.raizlabs.android.dbflow.sql.Query +import com.raizlabs.android.dbflow.sql.QueryBuilder +import com.raizlabs.android.dbflow.sql.language.property.IProperty +import com.raizlabs.android.dbflow.sql.language.property.Property + +/** + * Description: Represents a SQLITE CASE argument. + */ +class Case(private val caseColumn: IProperty<*>? = null) : Query { + + private val caseConditions = arrayListOf>() + private var columnName: String? = null + private var elseValue: TReturn? = null + private var elseSpecified = false + + // when true, only WHEN value is supported. Not WHEN condition + internal var isEfficientCase = false + private set + + private var endSpecified = false + + override val query: String + get() { + val queryBuilder = QueryBuilder(" CASE") + if (isEfficientCase) { + queryBuilder.append(" " + BaseOperator.convertValueToString(caseColumn, false)!!) + } + + queryBuilder.append(QueryBuilder.join("", caseConditions)) + + if (elseSpecified) { + queryBuilder.append(" ELSE ").append(BaseOperator.convertValueToString(elseValue, false)) + } + if (endSpecified) { + queryBuilder.append(" END " + if (columnName != null) columnName else "") + } + return queryBuilder.query + } + + internal constructor() : this(null) + + init { + if (caseColumn != null) { + isEfficientCase = true + } + } + + fun `when`(sqlOperator: SQLOperator): CaseCondition { + if (isEfficientCase) { + throw IllegalStateException("When using the efficient CASE method," + "you must pass in value only, not condition.") + } + val caseCondition = CaseCondition(this, sqlOperator) + caseConditions.add(caseCondition) + return caseCondition + } + + fun `when`(whenValue: TReturn?): CaseCondition { + if (!isEfficientCase) { + throw IllegalStateException("When not using the efficient CASE method, " + "you must pass in the SQLOperator as a parameter") + } + val caseCondition = CaseCondition(this, whenValue) + caseConditions.add(caseCondition) + return caseCondition + } + + fun `when`(property: IProperty<*>): CaseCondition { + if (!isEfficientCase) { + throw IllegalStateException("When not using the efficient CASE method, " + "you must pass in the SQLOperator as a parameter") + } + val caseCondition = CaseCondition(this, property) + caseConditions.add(caseCondition) + return caseCondition + } + + /** + * Default case here. If not specified, value will be NULL. + */ + fun _else(elseValue: TReturn?) = apply { + this.elseValue = elseValue + elseSpecified = true // ensure its set especially if null specified. + } + + /** + * @param columnName The name of the case that we return in a column. + * @return The case completed as a property. + */ + @JvmOverloads + fun end(columnName: String? = null): Property> { + endSpecified = true + if (columnName != null) { + this.columnName = QueryBuilder.quoteIfNeeded(columnName) + } + return Property(null, NameAlias.rawBuilder(query) + .build()) + } + + /** + * @return The case complete as an operator. + */ + fun endAsOperator(): Operator = Operator.op(end().nameAlias) +} +/** + * @return The case completed as a property. + */ diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CaseCondition.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CaseCondition.java deleted file mode 100644 index 400fa818f..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CaseCondition.java +++ /dev/null @@ -1,75 +0,0 @@ -package com.raizlabs.android.dbflow.sql.language; - -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.sql.Query; -import com.raizlabs.android.dbflow.sql.QueryBuilder; -import com.raizlabs.android.dbflow.sql.language.property.IProperty; - -import static com.raizlabs.android.dbflow.sql.language.BaseOperator.convertValueToString; - -/** - * Description: Represents an individual condition inside a CASE. - */ -public class CaseCondition implements Query { - - private final Case caze; - private TReturn whenValue; - private SQLOperator sqlOperator; - private TReturn thenValue; - private IProperty property; - private IProperty thenProperty; - private boolean isThenPropertySet; - - CaseCondition(Case caze, @NonNull SQLOperator sqlOperator) { - this.caze = caze; - this.sqlOperator = sqlOperator; - } - - CaseCondition(Case caze, TReturn whenValue) { - this.caze = caze; - this.whenValue = whenValue; - } - - CaseCondition(Case caze, @NonNull IProperty property) { - this.caze = caze; - this.property = property; - } - - /** - * THEN part of this query, the value that gets set on column if condition is true. - */ - @NonNull - public Case then(@Nullable TReturn value) { - thenValue = value; - return caze; - } - - @NonNull - public Case then(@NonNull IProperty value) { - thenProperty = value; - // in case values are null in some sense. - isThenPropertySet = true; - return caze; - } - - @Override - public String getQuery() { - QueryBuilder queryBuilder = new QueryBuilder(" WHEN "); - if (caze.isEfficientCase()) { - queryBuilder.append(convertValueToString(property != null ? property : whenValue, false)); - } else { - sqlOperator.appendConditionToQuery(queryBuilder); - } - queryBuilder.append(" THEN ") - .append(convertValueToString(isThenPropertySet ? - thenProperty : thenValue, false)); - return queryBuilder.getQuery(); - } - - @Override - public String toString() { - return getQuery(); - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CaseCondition.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CaseCondition.kt new file mode 100644 index 000000000..f45bcf491 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CaseCondition.kt @@ -0,0 +1,71 @@ +package com.raizlabs.android.dbflow.sql.language + +import com.raizlabs.android.dbflow.sql.Query +import com.raizlabs.android.dbflow.sql.QueryBuilder +import com.raizlabs.android.dbflow.sql.language.BaseOperator.convertValueToString +import com.raizlabs.android.dbflow.sql.language.property.IProperty + +/** + * Description: Represents an individual condition inside a CASE. + */ +class CaseCondition : Query { + + private val caze: Case + private val whenValue: TReturn? + private val sqlOperator: SQLOperator? + private var thenValue: TReturn? = null + private val property: IProperty<*>? + private var thenProperty: IProperty<*>? = null + private var isThenPropertySet: Boolean = false + + override val query: String + get() { + val queryBuilder = QueryBuilder(" WHEN ") + if (caze.isEfficientCase) { + queryBuilder.append(convertValueToString(property ?: whenValue, false)) + } else { + sqlOperator?.appendConditionToQuery(queryBuilder) + } + queryBuilder.append(" THEN ") + .append(convertValueToString(if (isThenPropertySet) + thenProperty + else + thenValue, false)) + return queryBuilder.query + } + + internal constructor(caze: Case, sqlOperator: SQLOperator) { + this.caze = caze + this.sqlOperator = sqlOperator + this.whenValue = null + this.property = null + } + + internal constructor(caze: Case, whenValue: TReturn) { + this.caze = caze + this.whenValue = whenValue + this.sqlOperator = null + this.property = null + } + + internal constructor(caze: Case, property: IProperty<*>) { + this.caze = caze + this.property = property + this.whenValue = null + this.sqlOperator = null + } + + /** + * THEN part of this query, the value that gets set on column if condition is true. + */ + fun then(value: TReturn?): Case = caze.apply { thenValue = value } + + fun then(value: IProperty<*>): Case = caze.apply { + thenProperty = value + + // in case values are null in some sense. + isThenPropertySet = true + } + + override fun toString(): String = query +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CompletedTrigger.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CompletedTrigger.java deleted file mode 100644 index 135ff6c3d..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CompletedTrigger.java +++ /dev/null @@ -1,67 +0,0 @@ -package com.raizlabs.android.dbflow.sql.language; - -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.config.DatabaseDefinition; -import com.raizlabs.android.dbflow.config.FlowManager; -import com.raizlabs.android.dbflow.sql.Query; -import com.raizlabs.android.dbflow.sql.QueryBuilder; -import com.raizlabs.android.dbflow.sql.SqlUtils; - -import java.util.ArrayList; -import java.util.List; - -/** - * Description: The last piece of a TRIGGER statement, this class contains the BEGIN...END and the logic in between. - */ -public class CompletedTrigger implements Query { - - /** - * The first pieces of this TRIGGER statement - */ - private TriggerMethod triggerMethod; - - /** - * The query to run between the BEGIN and END of this statement - */ - private final List triggerLogicQuery = new ArrayList<>(); - - CompletedTrigger(TriggerMethod triggerMethod, Query triggerLogicQuery) { - this.triggerMethod = triggerMethod; - this.triggerLogicQuery.add(triggerLogicQuery); - } - - /** - * Appends the nextStatement to this query as another line to be executed by trigger. - */ - @NonNull - public CompletedTrigger and(@NonNull Query nextStatement) { - this.triggerLogicQuery.add(nextStatement); - return this; - } - - @Override - public String getQuery() { - QueryBuilder queryBuilder = new QueryBuilder(triggerMethod.getQuery()); - queryBuilder.append("\nBEGIN") - .append("\n").append(QueryBuilder.join(";\n", triggerLogicQuery)).append(";") - .append("\nEND"); - return queryBuilder.getQuery(); - } - - - /** - * Turns on this trigger - */ - public void enable() { - DatabaseDefinition databaseDefinition = FlowManager.getDatabaseForTable(triggerMethod.onTable); - databaseDefinition.getWritableDatabase().execSQL(getQuery()); - } - - /** - * Disables this trigger - */ - public void disable() { - SqlUtils.dropTrigger(triggerMethod.onTable, triggerMethod.trigger.triggerName); - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CompletedTrigger.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CompletedTrigger.kt new file mode 100644 index 000000000..28347a2aa --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CompletedTrigger.kt @@ -0,0 +1,58 @@ +package com.raizlabs.android.dbflow.sql.language + +import com.raizlabs.android.dbflow.config.FlowManager +import com.raizlabs.android.dbflow.sql.Query +import com.raizlabs.android.dbflow.sql.QueryBuilder +import com.raizlabs.android.dbflow.sql.SqlUtils +import java.util.* + +/** + * Description: The last piece of a TRIGGER statement, this class contains the BEGIN...END and the logic in between. + */ +class CompletedTrigger internal constructor( + /** + * The first pieces of this TRIGGER statement + */ + private val triggerMethod: TriggerMethod, triggerLogicQuery: Query) : Query { + + /** + * The query to run between the BEGIN and END of this statement + */ + private val triggerLogicQuery = ArrayList() + + override val query: String + get() { + val queryBuilder = QueryBuilder(triggerMethod.query) + queryBuilder.append("\nBEGIN") + .append("\n").append(QueryBuilder.join(";\n", triggerLogicQuery)).append(";") + .append("\nEND") + return queryBuilder.query + } + + init { + this.triggerLogicQuery.add(triggerLogicQuery) + } + + /** + * Appends the nextStatement to this query as another line to be executed by trigger. + */ + fun and(nextStatement: Query) = apply { + this.triggerLogicQuery.add(nextStatement) + } + + + /** + * Turns on this trigger + */ + fun enable() { + val databaseDefinition = FlowManager.getDatabaseForTable(triggerMethod.onTable) + databaseDefinition.writableDatabase.execSQL(query) + } + + /** + * Disables this trigger + */ + fun disable() { + SqlUtils.dropTrigger(triggerMethod.onTable, triggerMethod.trigger.name) + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CursorResult.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CursorResult.java deleted file mode 100644 index 27ff0ce74..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CursorResult.java +++ /dev/null @@ -1,166 +0,0 @@ -package com.raizlabs.android.dbflow.sql.language; - -import android.database.Cursor; -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.config.FlowManager; -import com.raizlabs.android.dbflow.list.FlowCursorIterator; -import com.raizlabs.android.dbflow.list.IFlowCursorIterator; -import com.raizlabs.android.dbflow.structure.InstanceAdapter; -import com.raizlabs.android.dbflow.structure.database.FlowCursor; - -import java.util.ArrayList; -import java.util.List; - -/** - * Description: A class that contains a {@link Cursor} and handy methods for retrieving data from it. - * You must close this object post use via {@link #close()}. - */ -public class CursorResult implements IFlowCursorIterator { - - private final InstanceAdapter retrievalAdapter; - - @Nullable - private FlowCursor cursor; - - @SuppressWarnings("unchecked") - CursorResult(Class modelClass, @Nullable Cursor cursor) { - if (cursor != null) { - this.cursor = FlowCursor.from(cursor); - } - retrievalAdapter = FlowManager.getInstanceAdapter(modelClass); - } - - /** - * Swaps the current cursor and will close existing one. - */ - public void swapCursor(@Nullable FlowCursor cursor) { - if (this.cursor != null) { - if (!this.cursor.isClosed()) { - this.cursor.close(); - } - } - this.cursor = cursor; - } - - /** - * @return A {@link List} of items from this object. You must call {@link #close()} when finished. - */ - @NonNull - public List toList() { - return cursor != null - ? retrievalAdapter.getListModelLoader().convertToData(cursor, null) - : new ArrayList(); - } - - /** - * @return Converts the {@link Cursor} to a {@link List} of {@link TModel} and then closes it. - */ - @NonNull - public List toListClose() { - final List list = cursor != null - ? retrievalAdapter.getListModelLoader().load(cursor) - : new ArrayList(); - close(); - return list; - } - - /** - * @return A {@link List} of items from this object. You must call {@link #close()} when finished. - */ - @NonNull - public List toCustomList(@NonNull Class customClass) { - return cursor != null ? FlowManager.getQueryModelAdapter(customClass) - .getListModelLoader().convertToData(cursor, null) : new ArrayList(); - } - - /** - * @return Converts the {@link Cursor} to a {@link List} of {@link TModel} and then closes it. - */ - @NonNull - public List toCustomListClose(@NonNull Class customClass) { - final List customList = cursor != null ? FlowManager.getQueryModelAdapter(customClass) - .getListModelLoader().load(cursor) : new ArrayList(); - close(); - return customList; - } - - /** - * @return The first {@link TModel} of items from the contained {@link Cursor}. You must call {@link #close()} when finished. - */ - @Nullable - public TModel toModel() { - return cursor != null ? retrievalAdapter.getSingleModelLoader().convertToData(cursor, null) : null; - } - - /** - * @return Converts the {@link Cursor} into the first {@link TModel} from the cursor and then closes it. - */ - @Nullable - public TModel toModelClose() { - final TModel model = cursor != null ? retrievalAdapter.getSingleModelLoader().load(cursor) : null; - close(); - return model; - } - - /** - * @return The first {@link TModel} of items from the contained {@link Cursor}. You must call {@link #close()} when finished. - */ - @Nullable - public TCustom toCustomModel(@NonNull Class customClass) { - return cursor != null ? FlowManager.getQueryModelAdapter(customClass) - .getSingleModelLoader().convertToData(cursor, null) : null; - } - - /** - * @return Converts the {@link Cursor} to a {@link TModel} and then closes it. - */ - @Nullable - public TCustom toCustomModelClose(@NonNull Class customClass) { - final TCustom customList = cursor != null ? FlowManager.getQueryModelAdapter(customClass) - .getSingleModelLoader().load(cursor) : null; - close(); - return customList; - } - - @Nullable - @Override - public TModel getItem(long position) { - TModel model = null; - if (cursor != null && cursor.moveToPosition((int) position)) { - model = retrievalAdapter.getSingleModelLoader().convertToData(cursor, null, false); - } - return model; - } - - @NonNull - @Override - public FlowCursorIterator iterator() { - return new FlowCursorIterator<>(this); - } - - @NonNull - @Override - public FlowCursorIterator iterator(int startingLocation, long limit) { - return new FlowCursorIterator<>(this, startingLocation, limit); - } - - @Override - public long getCount() { - return cursor == null ? 0 : cursor.getCount(); - } - - @Override - @Nullable - public Cursor cursor() { - return cursor; - } - - @Override - public void close() { - if (cursor != null) { - cursor.close(); - } - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CursorResult.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CursorResult.kt new file mode 100644 index 000000000..1e76ab716 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CursorResult.kt @@ -0,0 +1,132 @@ +package com.raizlabs.android.dbflow.sql.language + +import android.database.Cursor +import com.raizlabs.android.dbflow.config.FlowManager +import com.raizlabs.android.dbflow.list.FlowCursorIterator +import com.raizlabs.android.dbflow.list.IFlowCursorIterator +import com.raizlabs.android.dbflow.structure.InstanceAdapter +import com.raizlabs.android.dbflow.structure.database.FlowCursor + +/** + * Description: A class that contains a [Cursor] and handy methods for retrieving data from it. + * You must close this object post use via [.close]. + */ +class CursorResult internal constructor(modelClass: Class, cursor: Cursor?) + : IFlowCursorIterator { + + private val retrievalAdapter: InstanceAdapter + + private var cursor: FlowCursor? = null + + override val count: Long + get() = cursor?.count?.toLong() ?: 0 + + init { + if (cursor != null) { + this.cursor = FlowCursor.from(cursor) + } + retrievalAdapter = FlowManager.getInstanceAdapter(modelClass) + } + + /** + * Swaps the current cursor and will close existing one. + */ + fun swapCursor(cursor: FlowCursor?) { + this.cursor?.let { _cursor -> + if (!_cursor.isClosed) { + _cursor.close() + } + } + this.cursor = cursor + } + + /** + * @return A [List] of items from this object. You must call [.close] when finished. + */ + fun toList(): List = cursor?.let { cursor -> + retrievalAdapter.listModelLoader.convertToData(cursor, null) + } ?: arrayListOf() + + /** + * @return Converts the [Cursor] to a [List] of [TModel] and then closes it. + */ + fun toListClose(): List { + val list = retrievalAdapter.listModelLoader.load(cursor) ?: arrayListOf() + close() + return list + } + + /** + * @return A [List] of items from this object. You must call [.close] when finished. + */ + fun toCustomList(customClass: Class): List { + return cursor?.let { cursor -> + return@let FlowManager.getQueryModelAdapter(customClass) + .listModelLoader.convertToData(cursor, null) + } ?: arrayListOf() + } + + /** + * @return Converts the [Cursor] to a [List] of [TModel] and then closes it. + */ + fun toCustomListClose(customClass: Class): List { + val customList = FlowManager.getQueryModelAdapter(customClass).listModelLoader.load(cursor) ?: arrayListOf() + close() + return customList + } + + /** + * @return The first [TModel] of items from the contained [Cursor]. You must call [.close] when finished. + */ + fun toModel(): TModel? = cursor?.let { cursor -> retrievalAdapter.singleModelLoader.convertToData(cursor, null) } + + /** + * @return Converts the [Cursor] into the first [TModel] from the cursor and then closes it. + */ + fun toModelClose(): TModel? { + val model = retrievalAdapter.singleModelLoader.load(cursor) + close() + return model + } + + /** + * @return The first [TModel] of items from the contained [Cursor]. You must call [.close] when finished. + */ + fun toCustomModel(customClass: Class): TCustom? { + return if (cursor != null) + FlowManager.getQueryModelAdapter(customClass) + .singleModelLoader.convertToData(cursor!!, null) + else + null + } + + /** + * @return Converts the [Cursor] to a [TModel] and then closes it. + */ + fun toCustomModelClose(customClass: Class): TCustom? { + val customList = FlowManager.getQueryModelAdapter(customClass).singleModelLoader.load(cursor) + close() + return customList + } + + override fun getItem(position: Long): TModel { + var model: TModel? = null + cursor?.let { cursor -> + if (cursor.moveToPosition(position.toInt())) { + model = retrievalAdapter.singleModelLoader.convertToData(cursor, null, false) + } + } + return model!! + } + + override fun iterator(): FlowCursorIterator = FlowCursorIterator(this) + + override fun iterator(startingLocation: Int, limit: Long): FlowCursorIterator = + FlowCursorIterator(this, startingLocation, limit) + + override fun cursor(): Cursor? = cursor + + override fun close() { + cursor?.close() + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Delete.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Delete.java deleted file mode 100644 index 5e2048d21..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Delete.java +++ /dev/null @@ -1,54 +0,0 @@ -package com.raizlabs.android.dbflow.sql.language; - -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.sql.Query; -import com.raizlabs.android.dbflow.sql.QueryBuilder; - -/** - * Description: Constructs the beginning of a SQL DELETE query - */ -public class Delete implements Query { - - /** - * Deletes the specified table - * - * @param table The table to delete - * @param conditions The list of conditions to use to delete from the specified table - * @param The class that implements {@link com.raizlabs.android.dbflow.structure.Model} - */ - public static void table(@NonNull Class table, SQLOperator... conditions) { - new Delete().from(table).where(conditions).executeUpdateDelete(); - } - - /** - * Deletes the list of tables specified. - * WARNING: this will completely clear all rows from each table. - * - * @param tables The list of tables to wipe. - */ - public static void tables(Class... tables) { - for (Class modelClass : tables) { - table(modelClass); - } - } - - /** - * Returns the new SQL FROM statement wrapper - * - * @param table The table we want to run this query from - * @param The table class - * @return - */ - @NonNull - public From from(@NonNull Class table) { - return new From<>(this, table); - } - - @Override - public String getQuery() { - return new QueryBuilder() - .append("DELETE") - .appendSpace().getQuery(); - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Delete.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Delete.kt new file mode 100644 index 000000000..ffc59cea6 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Delete.kt @@ -0,0 +1,48 @@ +package com.raizlabs.android.dbflow.sql.language + +import com.raizlabs.android.dbflow.sql.Query +import com.raizlabs.android.dbflow.sql.QueryBuilder + +/** + * Description: Constructs the beginning of a SQL DELETE query + */ +class Delete : Query { + + override val query: String + get() = QueryBuilder() + .append("DELETE") + .appendSpace().query + + /** + * Returns the new SQL FROM statement wrapper + * + * @param table The table we want to run this query from + * @param The table class + * @return + **/ + fun from(table: Class): From = From(this, table) + + companion object { + + /** + * Deletes the specified table + * + * @param table The table to delete + * @param conditions The list of conditions to use to delete from the specified table + * @param The class that implements [com.raizlabs.android.dbflow.structure.Model] + */ + fun table(table: Class, vararg conditions: SQLOperator) { + Delete().from(table).where(*conditions).executeUpdateDelete() + } + + /** + * Deletes the list of tables specified. + * WARNING: this will completely clear all rows from each table. + * + * @param tables The list of tables to wipe. + */ + fun tables(vararg tables: Class<*>) { + tables.forEach { table(it) } + } + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/ExistenceOperator.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/ExistenceOperator.java deleted file mode 100644 index ae5786307..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/ExistenceOperator.java +++ /dev/null @@ -1,67 +0,0 @@ -package com.raizlabs.android.dbflow.sql.language; - -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.sql.Query; -import com.raizlabs.android.dbflow.sql.QueryBuilder; - -/** - * Description: The condition that represents EXISTS in a SQL statement. - */ -public class ExistenceOperator implements SQLOperator, Query { - - private Where innerWhere; - - @Override - public void appendConditionToQuery(@NonNull QueryBuilder queryBuilder) { - queryBuilder.appendQualifier("EXISTS", "(" + innerWhere.getQuery().trim() + ")"); - } - - @NonNull - @Override - public String columnName() { - throw new RuntimeException("Method not valid for ExistenceOperator"); - } - - @Nullable - @Override - public String separator() { - throw new RuntimeException("Method not valid for ExistenceOperator"); - } - - @NonNull - @Override - public SQLOperator separator(@NonNull String separator) { - // not used. - throw new RuntimeException("Method not valid for ExistenceOperator"); - } - - @Override - public boolean hasSeparator() { - return false; - } - - @NonNull - @Override - public String operation() { - return ""; - } - - @Override - public Object value() { - return innerWhere; - } - - public ExistenceOperator where(@NonNull Where where) { - this.innerWhere = where; - return this; - } - - @Override - public String getQuery() { - QueryBuilder queryBuilder = new QueryBuilder(); - appendConditionToQuery(queryBuilder); - return queryBuilder.getQuery(); - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/ExistenceOperator.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/ExistenceOperator.kt new file mode 100644 index 000000000..d12a75bb9 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/ExistenceOperator.kt @@ -0,0 +1,41 @@ +package com.raizlabs.android.dbflow.sql.language + +import com.raizlabs.android.dbflow.sql.Query +import com.raizlabs.android.dbflow.sql.QueryBuilder + +/** + * Description: The condition that represents EXISTS in a SQL statement. + */ +class ExistenceOperator(private val innerWhere: Where<*>) : SQLOperator, Query { + + override val query: String + get() { + val queryBuilder = QueryBuilder() + appendConditionToQuery(queryBuilder) + return queryBuilder.query + } + + override fun appendConditionToQuery(queryBuilder: QueryBuilder) { + queryBuilder.appendQualifier("EXISTS", "(" + innerWhere.query.trim({ it <= ' ' }) + ")") + } + + override fun columnName(): String { + throw RuntimeException("Method not valid for ExistenceOperator") + } + + override fun separator(): String? { + throw RuntimeException("Method not valid for ExistenceOperator") + } + + override fun separator(separator: String): SQLOperator { + // not used. + throw RuntimeException("Method not valid for ExistenceOperator") + } + + override fun hasSeparator(): Boolean = false + + override fun operation(): String = "" + + override fun value(): Any? = innerWhere + +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/From.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/From.java deleted file mode 100644 index 57a60389c..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/From.java +++ /dev/null @@ -1,249 +0,0 @@ -package com.raizlabs.android.dbflow.sql.language; - -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.config.FlowManager; -import com.raizlabs.android.dbflow.sql.Query; -import com.raizlabs.android.dbflow.sql.QueryBuilder; -import com.raizlabs.android.dbflow.sql.language.Join.JoinType; -import com.raizlabs.android.dbflow.sql.language.property.IndexProperty; -import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable; -import com.raizlabs.android.dbflow.structure.BaseModel; - -import java.util.ArrayList; -import java.util.LinkedHashSet; -import java.util.List; - -/** - * Description: The SQL FROM query wrapper that must have a {@link Query} base. - */ -public class From extends BaseTransformable { - - /** - * The base such as {@link Delete}, {@link Select} and more! - */ - @NonNull - private Query queryBase; - - /** - * An alias for the table - */ - @Nullable - private NameAlias tableAlias; - - /** - * Enables the SQL JOIN statement - */ - @NonNull - private final List joins = new ArrayList<>(); - - private NameAlias getTableAlias() { - if (tableAlias == null) { - tableAlias = new NameAlias.Builder(FlowManager.getTableName(getTable())).build(); - } - return tableAlias; - } - - /** - * The SQL from statement constructed. - * - * @param querybase The base query we append this query to - * @param table The table this corresponds to - */ - public From(@NonNull Query querybase, @NonNull Class table) { - super(table); - queryBase = querybase; - } - - /** - * Set an alias to the table name of this {@link From}. - */ - @NonNull - public From as(String alias) { - tableAlias = getTableAlias() - .newBuilder() - .as(alias) - .build(); - return this; - } - - /** - * Adds a join on a specific table for this query - * - * @param table The table this corresponds to - * @param joinType The type of join to use - */ - @NonNull - public Join join(Class table, @NonNull JoinType joinType) { - Join join = new Join<>(this, table, joinType); - joins.add(join); - return join; - } - - /** - * Adds a join on a specific table for this query. - * - * @param modelQueriable A query we construct the {@link Join} from. - * @param joinType The type of join to use. - */ - @NonNull - public Join - join(ModelQueriable modelQueriable, @NonNull JoinType joinType) { - Join join = new Join<>(this, joinType, modelQueriable); - joins.add(join); - return join; - } - - /** - * Adds a {@link JoinType#CROSS} join on a specific table for this query. - * - * @param table The table to join on. - * @param The class of the join table. - */ - @NonNull - public Join crossJoin(Class table) { - return join(table, JoinType.CROSS); - } - - /** - * Adds a {@link JoinType#CROSS} join on a specific table for this query. - * - * @param modelQueriable The query to join on. - * @param The class of the join table. - */ - @NonNull - public Join crossJoin(ModelQueriable modelQueriable) { - return join(modelQueriable, JoinType.CROSS); - } - - /** - * Adds a {@link JoinType#INNER} join on a specific table for this query. - * - * @param table The table to join on. - * @param The class of the join table. - */ - @NonNull - public Join innerJoin(Class table) { - return join(table, JoinType.INNER); - } - - /** - * Adds a {@link JoinType#INNER} join on a specific table for this query. - * - * @param modelQueriable The query to join on. - * @param The class of the join table. - */ - @NonNull - public Join innerJoin(ModelQueriable modelQueriable) { - return join(modelQueriable, JoinType.INNER); - } - - /** - * Adds a {@link JoinType#LEFT_OUTER} join on a specific table for this query. - * - * @param table The table to join on. - * @param The class of the join table. - */ - @NonNull - public Join leftOuterJoin(Class table) { - return join(table, JoinType.LEFT_OUTER); - } - - /** - * Adds a {@link JoinType#LEFT_OUTER} join on a specific table for this query. - * - * @param modelQueriable The query to join on. - * @param The class of the join table. - */ - @NonNull - public Join leftOuterJoin(ModelQueriable modelQueriable) { - return join(modelQueriable, JoinType.LEFT_OUTER); - } - - - /** - * Adds a {@link JoinType#NATURAL} join on a specific table for this query. - * - * @param table The table to join on. - * @param The class of the join table. - */ - @NonNull - public Join naturalJoin(Class table) { - return join(table, JoinType.NATURAL); - } - - /** - * Adds a {@link JoinType#NATURAL} join on a specific table for this query. - * - * @param modelQueriable The query to join on. - * @param The class of the join table. - */ - @NonNull - public Join naturalJoin(ModelQueriable modelQueriable) { - return join(modelQueriable, JoinType.NATURAL); - } - - /** - * Begins an INDEXED BY piece of this query with the specified name. - * - * @param indexProperty The index property generated. - */ - @NonNull - public IndexedBy indexedBy(IndexProperty indexProperty) { - return new IndexedBy<>(indexProperty, this); - } - - @NonNull - @Override - public BaseModel.Action getPrimaryAction() { - return (queryBase instanceof Delete) ? BaseModel.Action.DELETE : BaseModel.Action.CHANGE; - } - - @Override - public String getQuery() { - QueryBuilder queryBuilder = new QueryBuilder() - .append(queryBase.getQuery()); - if (!(queryBase instanceof Update)) { - queryBuilder.append("FROM "); - } - - queryBuilder.append(getTableAlias()); - - if (queryBase instanceof Select) { - if (!joins.isEmpty()) { - queryBuilder.appendSpace(); - } - for (Join join : joins) { - queryBuilder.append(join.getQuery()); - } - } else { - queryBuilder.appendSpace(); - } - - return queryBuilder.getQuery(); - } - - /** - * @return The base query, usually a {@link Delete}, {@link Select}, or {@link Update} - */ - @NonNull - @Override - public Query getQueryBuilderBase() { - return queryBase; - } - - /** - * @return A list of {@link Class} that represents tables represented in this query. For every - * {@link Join} on another table, this adds another {@link Class}. - */ - @NonNull - public java.util.Set> getAssociatedTables() { - java.util.Set> tables = new LinkedHashSet<>(); - tables.add(getTable()); - for (Join join : joins) { - tables.add(join.getTable()); - } - return tables; - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/From.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/From.kt new file mode 100644 index 000000000..dd3206eeb --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/From.kt @@ -0,0 +1,200 @@ +package com.raizlabs.android.dbflow.sql.language + +import com.raizlabs.android.dbflow.config.FlowManager +import com.raizlabs.android.dbflow.sql.Query +import com.raizlabs.android.dbflow.sql.QueryBuilder +import com.raizlabs.android.dbflow.sql.language.Join.JoinType +import com.raizlabs.android.dbflow.sql.language.property.IndexProperty +import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable +import com.raizlabs.android.dbflow.structure.BaseModel +import java.util.* +import kotlin.collections.Set as KSet + +/** + * Description: The SQL FROM query wrapper that must have a [Query] base. + */ +class From +/** + * The SQL from statement constructed. + * + * @param querybase The base query we append this query to + * @param table The table this corresponds to + */ +( + /** + * The base such as [Delete], [Select] and more! + */ + /** + * @return The base query, usually a [Delete], [Select], or [Update] + */ + override val queryBuilderBase: Query, table: Class) : BaseTransformable(table) { + + /** + * An alias for the table + */ + private var tableAlias: NameAlias? = null + + /** + * Enables the SQL JOIN statement + */ + private val joins = ArrayList>() + + override val primaryAction: BaseModel.Action + get() = if (queryBuilderBase is Delete) BaseModel.Action.DELETE else BaseModel.Action.CHANGE + + override val query: String + get() { + val queryBuilder = QueryBuilder() + .append(queryBuilderBase.query) + if (queryBuilderBase !is Update<*>) { + queryBuilder.append("FROM ") + } + + queryBuilder.append(getTableAlias()) + + if (queryBuilderBase is Select) { + if (!joins.isEmpty()) { + queryBuilder.appendSpace() + } + for (join in joins) { + queryBuilder.append(join.query) + } + } else { + queryBuilder.appendSpace() + } + + return queryBuilder.query + } + + /** + * @return A list of [Class] that represents tables represented in this query. For every + * [Join] on another table, this adds another [Class]. + */ + val associatedTables: KSet> + get() { + val tables = linkedSetOf>(table) + joins.mapTo(tables) { it.table } + return tables + } + + private fun getTableAlias(): NameAlias { + if (tableAlias == null) { + tableAlias = NameAlias.Builder(FlowManager.getTableName(table)).build() + } + return tableAlias!! + } + + /** + * Set an alias to the table name of this [From]. + */ + fun `as`(alias: String): From { + tableAlias = getTableAlias() + .newBuilder() + .`as`(alias) + .build() + return this + } + + /** + * Adds a join on a specific table for this query + * + * @param table The table this corresponds to + * @param joinType The type of join to use + */ + fun join(table: Class, joinType: JoinType): Join { + val join = Join(this, table, joinType) + joins.add(join) + return join + } + + /** + * Adds a join on a specific table for this query. + * + * @param modelQueriable A query we construct the [Join] from. + * @param joinType The type of join to use. + */ + fun join(modelQueriable: ModelQueriable, joinType: JoinType): Join { + val join = Join(this, joinType, modelQueriable) + joins.add(join) + return join + } + + /** + * Adds a [JoinType.CROSS] join on a specific table for this query. + * + * @param table The table to join on. + * @param The class of the join table. + */ + fun crossJoin(table: Class): Join = join(table, JoinType.CROSS) + + /** + * Adds a [JoinType.CROSS] join on a specific table for this query. + * + * @param modelQueriable The query to join on. + * @param The class of the join table. + */ + fun crossJoin(modelQueriable: ModelQueriable): Join = + join(modelQueriable, JoinType.CROSS) + + /** + * Adds a [JoinType.INNER] join on a specific table for this query. + * + * @param table The table to join on. + * @param The class of the join table. + */ + fun innerJoin(table: Class): Join = join(table, JoinType.INNER) + + /** + * Adds a [JoinType.INNER] join on a specific table for this query. + * + * @param modelQueriable The query to join on. + * @param The class of the join table. + */ + fun innerJoin(modelQueriable: ModelQueriable): Join = + join(modelQueriable, JoinType.INNER) + + /** + * Adds a [JoinType.LEFT_OUTER] join on a specific table for this query. + * + * @param table The table to join on. + * @param The class of the join table. + */ + fun leftOuterJoin(table: Class): Join = + join(table, JoinType.LEFT_OUTER) + + /** + * Adds a [JoinType.LEFT_OUTER] join on a specific table for this query. + * + * @param modelQueriable The query to join on. + * @param The class of the join table. + */ + fun leftOuterJoin(modelQueriable: ModelQueriable): Join = + join(modelQueriable, JoinType.LEFT_OUTER) + + + /** + * Adds a [JoinType.NATURAL] join on a specific table for this query. + * + * @param table The table to join on. + * @param The class of the join table. + */ + fun naturalJoin(table: Class): Join = + join(table, JoinType.NATURAL) + + /** + * Adds a [JoinType.NATURAL] join on a specific table for this query. + * + * @param modelQueriable The query to join on. + * @param The class of the join table. + */ + fun naturalJoin(modelQueriable: ModelQueriable): Join = + join(modelQueriable, JoinType.NATURAL) + + /** + * Begins an INDEXED BY piece of this query with the specified name. + * + * @param indexProperty The index property generated. + */ + fun indexedBy(indexProperty: IndexProperty): IndexedBy = + IndexedBy(indexProperty, this) +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IConditional.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IConditional.kt index 36e133d03..af8ee9131 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IConditional.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IConditional.kt @@ -8,9 +8,9 @@ import com.raizlabs.android.dbflow.sql.Query */ interface IConditional : Query { - val isNull: Operator<*> + fun isNull(): Operator<*> - val isNotNull: Operator<*> + fun isNotNull(): Operator<*> fun `is`(conditional: IConditional): Operator<*> diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Index.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Index.java deleted file mode 100644 index c79f5e476..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Index.java +++ /dev/null @@ -1,166 +0,0 @@ -package com.raizlabs.android.dbflow.sql.language; - -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.config.FlowManager; -import com.raizlabs.android.dbflow.sql.Query; -import com.raizlabs.android.dbflow.sql.QueryBuilder; -import com.raizlabs.android.dbflow.sql.SqlUtils; -import com.raizlabs.android.dbflow.sql.language.property.IProperty; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; - -import java.util.ArrayList; -import java.util.List; - -/** - * Description: an INDEX class that enables you to index a specific column from a table. This enables - * faster retrieval on tables, while increasing the database file size. So enable/disable these as necessary. - */ -public class Index implements Query { - - @NonNull - private final String indexName; - - @NonNull - private Class table; - private List columns; - private boolean isUnique = false; - - /** - * Creates a new index with the specified name - * - * @param indexName The name of this index. - */ - public Index(@NonNull String indexName) { - this.indexName = indexName; - columns = new ArrayList<>(); - } - - /** - * If true, will append the UNIQUE statement to this trigger. - * - * @param unique true if unique. If created again, a {@link android.database.SQLException} is thrown. - * @return This instance. - */ - @NonNull - public Index unique(boolean unique) { - isUnique = unique; - return this; - } - - /** - * The table to execute this Index on. - * - * @param table The table to execute index on. - * @param properties The properties to create an index for. - * @return This instance. - */ - @NonNull - public Index on(@NonNull Class table, IProperty... properties) { - this.table = table; - for (IProperty property : properties) { - and(property); - } - return this; - } - - /** - * The table to execute this Index on. - * - * @param table The table to execute index on. - * @param columns The columns to create an index for. - * @return This instance. - */ - @NonNull - public Index on(@NonNull Class table, @NonNull NameAlias firstAlias, NameAlias... columns) { - this.table = table; - and(firstAlias); - for (NameAlias column : columns) { - and(column); - } - return this; - } - - /** - * Appends a column to this index list. - * - * @param property The name of the column. If already exists, this op will not be added - * @return This instance. - */ - @NonNull - public Index and(@NonNull IProperty property) { - if (!columns.contains(property.getNameAlias())) { - columns.add(property.getNameAlias()); - } - return this; - } - - /** - * Appends a column to this index list. - * - * @param columnName The name of the column. If already exists, this op will not be added - * @return This instance. - */ - @NonNull - public Index and(@NonNull NameAlias columnName) { - if (!columns.contains(columnName)) { - columns.add(columnName); - } - return this; - } - - /** - * @return The name of this index. - */ - @NonNull - public String getIndexName() { - return indexName; - } - - /** - * @return The table this INDEX belongs to. - */ - @NonNull - public Class getTable() { - return table; - } - - /** - * @return true if the index is unique - */ - public boolean isUnique() { - return isUnique; - } - - public void enable(@NonNull DatabaseWrapper databaseWrapper) { - if (table == null) { - throw new IllegalStateException("Please call on() to set a table to use this index on."); - } else if (columns == null || columns.isEmpty()) { - throw new IllegalStateException("There should be at least one column in this index"); - } - databaseWrapper.execSQL(getQuery()); - } - - public void enable() { - enable(FlowManager.getDatabaseForTable(table).getWritableDatabase()); - } - - public void disable() { - SqlUtils.dropIndex(FlowManager.getDatabaseForTable(table).getWritableDatabase(), indexName); - } - - public void disable(DatabaseWrapper databaseWrapper) { - SqlUtils.dropIndex(databaseWrapper, indexName); - } - - @Override - @SuppressWarnings("unchecked") - public String getQuery() { - return new QueryBuilder("CREATE ") - .append(isUnique ? "UNIQUE " : "") - .append("INDEX IF NOT EXISTS ") - .appendQuotedIfNeeded(indexName) - .append(" ON ").append(FlowManager.getTableName(table)) - .append("(").appendList(columns).append(")").getQuery(); - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Index.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Index.kt new file mode 100644 index 000000000..543bb9e0d --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Index.kt @@ -0,0 +1,122 @@ +package com.raizlabs.android.dbflow.sql.language + +import com.raizlabs.android.dbflow.config.FlowManager +import com.raizlabs.android.dbflow.sql.Query +import com.raizlabs.android.dbflow.sql.QueryBuilder +import com.raizlabs.android.dbflow.sql.SqlUtils +import com.raizlabs.android.dbflow.sql.language.property.IProperty +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper + +/** + * Description: an INDEX class that enables you to index a specific column from a table. This enables + * faster retrieval on tables, while increasing the database file size. So enable/disable these as necessary. + */ +class Index +/** + * Creates a new index with the specified name + * + * @param indexName The name of this index. + */ +( + /** + * @return The name of this index. + */ + val indexName: String) : Query { + + /** + * @return The table this INDEX belongs to. + */ + var table: Class? = null + private set + private val columns: MutableList = arrayListOf() + /** + * @return true if the index is unique + */ + var isUnique = false + private set + + override val query: String + get() = QueryBuilder("CREATE ") + .append(if (isUnique) "UNIQUE " else "") + .append("INDEX IF NOT EXISTS ") + .appendQuotedIfNeeded(indexName) + .append(" ON ").append(FlowManager.getTableName(table!!)) + .append("(").appendList(columns).append(")").query + + /** + * If true, will append the UNIQUE statement to this trigger. + * + * @param unique true if unique. If created again, a [android.database.SQLException] is thrown. + * @return This instance. + */ + fun unique(unique: Boolean) = apply { + isUnique = unique + } + + /** + * The table to execute this Index on. + * + * @param table The table to execute index on. + * @param properties The properties to create an index for. + * @return This instance. + */ + fun on(table: Class, vararg properties: IProperty<*>) = apply { + this.table = table + properties.forEach { and(it) } + } + + /** + * The table to execute this Index on. + * + * @param table The table to execute index on. + * @param columns The columns to create an index for. + * @return This instance. + */ + fun on(table: Class, firstAlias: NameAlias, vararg columns: NameAlias) = apply { + this.table = table + and(firstAlias) + columns.forEach { and(it) } + } + + /** + * Appends a column to this index list. + * + * @param property The name of the column. If already exists, this op will not be added + * @return This instance. + */ + fun and(property: IProperty<*>) = apply { + if (!columns.contains(property.nameAlias)) { + columns.add(property.nameAlias) + } + } + + /** + * Appends a column to this index list. + * + * @param columnName The name of the column. If already exists, this op will not be added + * @return This instance. + */ + fun and(columnName: NameAlias) = apply { + if (!columns.contains(columnName)) { + columns.add(columnName) + } + } + + @JvmOverloads + fun enable(databaseWrapper: DatabaseWrapper = FlowManager.getDatabaseForTable(table!!).writableDatabase) { + if (table == null) { + throw IllegalStateException("Please call on() to set a table to use this index on.") + } else if (columns.isEmpty()) { + throw IllegalStateException("There should be at least one column in this index") + } + databaseWrapper.execSQL(query) + } + + fun disable() { + SqlUtils.dropIndex(FlowManager.getDatabaseForTable(table!!).writableDatabase, indexName) + } + + fun disable(databaseWrapper: DatabaseWrapper) { + SqlUtils.dropIndex(databaseWrapper, indexName) + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IndexedBy.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IndexedBy.java deleted file mode 100644 index b585984da..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IndexedBy.java +++ /dev/null @@ -1,49 +0,0 @@ -package com.raizlabs.android.dbflow.sql.language; - -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.sql.Query; -import com.raizlabs.android.dbflow.sql.QueryBuilder; -import com.raizlabs.android.dbflow.sql.language.property.IndexProperty; -import com.raizlabs.android.dbflow.structure.BaseModel; - -/** - * Description: The INDEXED BY part of a SELECT/UPDATE/DELETE - */ -public class IndexedBy extends BaseTransformable { - - private final IndexProperty indexProperty; - - private final WhereBase whereBase; - - /** - * Creates the INDEXED BY part of the clause. - * - * @param indexProperty The index property generated. - * @param whereBase The base piece of this query - */ - public IndexedBy(IndexProperty indexProperty, WhereBase whereBase) { - super(whereBase.getTable()); - this.indexProperty = indexProperty; - this.whereBase = whereBase; - } - - @NonNull - @Override - public Query getQueryBuilderBase() { - return whereBase.getQueryBuilderBase(); - } - - @Override - public String getQuery() { - QueryBuilder queryBuilder = new QueryBuilder(whereBase.getQuery()) - .append(" INDEXED BY ").append(QueryBuilder.quoteIfNeeded(indexProperty.getIndexName())).appendSpace(); - return queryBuilder.getQuery(); - } - - @NonNull - @Override - public BaseModel.Action getPrimaryAction() { - return whereBase.getPrimaryAction(); - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IndexedBy.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IndexedBy.kt new file mode 100644 index 000000000..c4dd231aa --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IndexedBy.kt @@ -0,0 +1,35 @@ +package com.raizlabs.android.dbflow.sql.language + +import com.raizlabs.android.dbflow.sql.Query +import com.raizlabs.android.dbflow.sql.QueryBuilder +import com.raizlabs.android.dbflow.sql.language.property.IndexProperty +import com.raizlabs.android.dbflow.structure.BaseModel + +/** + * Description: The INDEXED BY part of a SELECT/UPDATE/DELETE + */ +class IndexedBy +/** + * Creates the INDEXED BY part of the clause. + * + * @param indexProperty The index property generated. + * @param whereBase The base piece of this query + */ +(private val indexProperty: IndexProperty, private val whereBase: WhereBase) + : BaseTransformable(whereBase.table) { + + override val queryBuilderBase: Query + get() = whereBase.queryBuilderBase + + override val query: String + get() { + val queryBuilder = QueryBuilder(whereBase.query) + .append(" INDEXED BY ") + .append(QueryBuilder.quoteIfNeeded(indexProperty.indexName)) + .appendSpace() + return queryBuilder.query + } + + override val primaryAction: BaseModel.Action + get() = whereBase.primaryAction +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Insert.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Insert.java deleted file mode 100644 index 8a3ffd590..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Insert.java +++ /dev/null @@ -1,332 +0,0 @@ -package com.raizlabs.android.dbflow.sql.language; - -import android.content.ContentValues; -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.annotation.ConflictAction; -import com.raizlabs.android.dbflow.config.FlowManager; -import com.raizlabs.android.dbflow.sql.Query; -import com.raizlabs.android.dbflow.sql.QueryBuilder; -import com.raizlabs.android.dbflow.sql.language.property.IProperty; -import com.raizlabs.android.dbflow.structure.BaseModel; -import com.raizlabs.android.dbflow.structure.ModelAdapter; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collection; -import java.util.List; -import java.util.Map; - -/** - * Description: The SQLite INSERT command - */ -public class Insert extends BaseQueriable implements Query { - - - /** - * The columns to specify in this query (optional) - */ - private IProperty[] columns; - - /** - * The values to specify in this query - */ - private List> valuesList; - - /** - * The conflict algorithm to use to resolve inserts. - */ - private ConflictAction conflictAction = ConflictAction.NONE; - - private From selectFrom; - - /** - * Constructs a new INSERT command - * - * @param table The table to insert into - */ - public Insert(@NonNull Class table) { - super(table); - } - - /** - * The optional columns to specify. If specified, the values length must correspond to these columns, and - * each column has a 1-1 relationship to the values. - * - * @param columns The columns to use - */ - @NonNull - public Insert columns(@NonNull String... columns) { - this.columns = new IProperty[columns.length]; - ModelAdapter modelClassModelAdapter = FlowManager.getModelAdapter(getTable()); - for (int i = 0; i < columns.length; i++) { - String column = columns[i]; - this.columns[i] = modelClassModelAdapter.getProperty(column); - } - return this; - } - - @NonNull - public Insert columns(@NonNull IProperty... properties) { - this.columns = new IProperty[properties.length]; - for (int i = 0; i < properties.length; i++) { - columns[i] = properties[i]; - } - return this; - } - - @NonNull - public Insert columns(@NonNull List properties) { - return columns(properties.toArray(new IProperty[properties.size()])); - } - - /** - * @return Appends a list of columns to this INSERT statement from the associated {@link TModel}. - */ - @NonNull - public Insert asColumns() { - columns(FlowManager.getModelAdapter(getTable()).getAllColumnProperties()); - return this; - } - - /** - * @return Appends a list of columns to this INSERT and ? as the values. - */ - @NonNull - public Insert asColumnValues() { - asColumns(); - if (columns != null) { - List values = new ArrayList<>(); - for (int i = 0; i < columns.length; i++) { - values.add("?"); - } - valuesList.add(values); - } - return this; - } - - /** - * The required values to specify. It must be non-empty and match the length of the columns when - * a set of columns are specified. - * - * @param values The non type-converted values - */ - @NonNull - public Insert values(@Nullable Object... values) { - if (this.valuesList == null) { - this.valuesList = new ArrayList<>(); - } - this.valuesList.add(Arrays.asList(values)); - return this; - } - - /** - * The required values to specify. It must be non-empty and match the length of the columns when - * a set of columns are specified. - * - * @param values The non type-converted values - */ - @NonNull - public Insert values(@NonNull Collection values) { - if (this.valuesList == null) { - this.valuesList = new ArrayList<>(); - } - this.valuesList.add(values); - return this; - } - - /** - * Uses the {@link Operator} pairs to fill this insert query. - * - * @param conditions The conditions that we use to fill the columns and values of this INSERT - */ - @NonNull - public Insert columnValues(@NonNull SQLOperator... conditions) { - - String[] columns = new String[conditions.length]; - Object[] values = new Object[conditions.length]; - - for (int i = 0; i < conditions.length; i++) { - SQLOperator condition = conditions[i]; - columns[i] = condition.columnName(); - values[i] = condition.value(); - } - - return columns(columns).values(values); - } - - /** - * Uses the {@link Operator} pairs to fill this insert query. - * - * @param operatorGroup The OperatorGroup to use - */ - @NonNull - public Insert columnValues(@NonNull OperatorGroup operatorGroup) { - - int size = operatorGroup.size(); - String[] columns = new String[size]; - Object[] values = new Object[size]; - - for (int i = 0; i < size; i++) { - SQLOperator condition = operatorGroup.getConditions().get(i); - columns[i] = condition.columnName(); - values[i] = condition.value(); - } - - return columns(columns).values(values); - } - - @NonNull - public Insert columnValues(@NonNull ContentValues contentValues) { - java.util.Set> entries = contentValues.valueSet(); - int count = 0; - String[] columns = new String[contentValues.size()]; - Object[] values = new Object[contentValues.size()]; - for (Map.Entry entry : entries) { - String key = entry.getKey(); - columns[count] = key; - values[count] = contentValues.get(key); - count++; - } - - return columns(columns).values(values); - } - - /** - * Appends the specified {@link From}, which comes from a {@link Select} statement. - * - * @param selectFrom The from that is continuation of {@link Select}. - */ - @NonNull - public Insert select(@NonNull From selectFrom) { - this.selectFrom = selectFrom; - return this; - } - - - /** - * Specifies the optional OR method to use for this insert query - * - * @param action The conflict action to use - * @return - */ - @NonNull - public Insert or(@NonNull ConflictAction action) { - conflictAction = action; - return this; - } - - /** - * Specifies OR REPLACE, which will either insert if row does not exist, or replace the value if it does. - * - * @return - */ - @NonNull - public Insert orReplace() { - return or(ConflictAction.REPLACE); - } - - /** - * Specifies OR ROLLBACK, which will cancel the current transaction or ABORT the current statement. - * - * @return - */ - @NonNull - public Insert orRollback() { - return or(ConflictAction.ROLLBACK); - } - - /** - * Specifies OR ABORT, which will cancel the current INSERT, but all other operations will be preserved in - * the current transaction. - * - * @return - */ - @NonNull - public Insert orAbort() { - return or(ConflictAction.ABORT); - } - - /** - * Specifies OR FAIL, which does not back out of the previous statements. Anything else in the current - * transaction will fail. - * - * @return - */ - @NonNull - public Insert orFail() { - return or(ConflictAction.FAIL); - } - - /** - * Specifies OR IGNORE, which ignores any kind of error and proceeds as normal. - * - * @return - */ - @NonNull - public Insert orIgnore() { - return or(ConflictAction.IGNORE); - } - - @Override - public long executeUpdateDelete(@NonNull DatabaseWrapper databaseWrapper) { - throw new IllegalStateException("Cannot call executeUpdateDelete() from an Insert"); - } - - @Override - public long executeUpdateDelete() { - throw new IllegalStateException("Cannot call executeUpdateDelete() from an Insert"); - } - - @Override - public String getQuery() { - QueryBuilder queryBuilder = new QueryBuilder("INSERT "); - if (conflictAction != null && !conflictAction.equals(ConflictAction.NONE)) { - queryBuilder.append("OR").appendSpaceSeparated(conflictAction); - } - queryBuilder.append("INTO") - .appendSpace() - .append(FlowManager.getTableName(getTable())); - - if (columns != null) { - queryBuilder.append("(") - .appendArray((Object[]) columns) - .append(")"); - } - - // append FROM, which overrides values - if (selectFrom != null) { - queryBuilder.appendSpace().append(selectFrom.getQuery()); - } else { - if (valuesList == null || valuesList.size() < 1) { - throw new IllegalStateException("The insert of " + FlowManager.getTableName(getTable()) + " should have" + - "at least one value specified for the insert"); - } else if (columns != null) { - for (Collection values : valuesList) { - if (values.size() != columns.length) { - throw new IllegalStateException("The Insert of " + FlowManager.getTableName(getTable()) + " when specifying" + - "columns needs to have the same amount of values and columns"); - } - } - } - - queryBuilder.append(" VALUES("); - for (int i = 0; i < valuesList.size(); i++) { - if (i > 0) { - queryBuilder.append(",("); - } - queryBuilder.append(BaseOperator.joinArguments(", ", valuesList.get(i))).append(")"); - } - } - - return queryBuilder.getQuery(); - } - - @NonNull - @Override - public BaseModel.Action getPrimaryAction() { - return BaseModel.Action.INSERT; - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Insert.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Insert.kt new file mode 100644 index 000000000..bd4e786c0 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Insert.kt @@ -0,0 +1,272 @@ +package com.raizlabs.android.dbflow.sql.language + +import android.content.ContentValues +import com.raizlabs.android.dbflow.annotation.ConflictAction +import com.raizlabs.android.dbflow.config.FlowManager +import com.raizlabs.android.dbflow.sql.Query +import com.raizlabs.android.dbflow.sql.QueryBuilder +import com.raizlabs.android.dbflow.sql.language.property.IProperty +import com.raizlabs.android.dbflow.structure.BaseModel +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper + +/** + * Description: The SQLite INSERT command + */ +class Insert +/** + * Constructs a new INSERT command + * + * @param table The table to insert into + */ +(table: Class) : BaseQueriable(table), Query { + + + /** + * The columns to specify in this query (optional) + */ + private var columns: List>? = null + + /** + * The values to specify in this query + */ + private var valuesList: MutableList> = arrayListOf() + + /** + * The conflict algorithm to use to resolve inserts. + */ + private var conflictAction: ConflictAction? = ConflictAction.NONE + + private var selectFrom: From<*>? = null + + override// append FROM, which overrides values + val query: String + get() { + val queryBuilder = QueryBuilder("INSERT ") + if (conflictAction != null && conflictAction != ConflictAction.NONE) { + queryBuilder.append("OR").appendSpaceSeparated(conflictAction) + } + queryBuilder.append("INTO") + .appendSpace() + .append(FlowManager.getTableName(table)) + + if (columns != null) { + queryBuilder.append("(") + .appendArray(columns?.toTypedArray()) + .append(")") + } + if (selectFrom != null) { + queryBuilder.appendSpace().append(selectFrom!!.query) + } else { + if (valuesList.size < 1) { + throw IllegalStateException("The insert of " + FlowManager.getTableName(table) + " should have" + + "at least one value specified for the insert") + } else columns?.let { columns -> + valuesList.asSequence() + .filter { it.size != columns.size } + .forEach { + throw IllegalStateException( + """The Insert of ${FlowManager.getTableName(table)} + |when specifyingcolumns needs to have the same amount + |of values and columns""".trimMargin()) + } + } + + queryBuilder.append(" VALUES(") + valuesList.forEachIndexed { i, valuesList -> + if (i > 0) { + queryBuilder.append(",(") + } + queryBuilder.append(BaseOperator.joinArguments(", ", valuesList[i])).append(")") + } + } + + return queryBuilder.query + } + + override val primaryAction: BaseModel.Action + get() = BaseModel.Action.INSERT + + /** + * The optional columns to specify. If specified, the values length must correspond to these columns, and + * each column has a 1-1 relationship to the values. + * + * @param columns The columns to use + */ + fun columns(vararg columns: String) = apply { + val modelClassModelAdapter = FlowManager.getModelAdapter(table) + this.columns = columns.map { modelClassModelAdapter.getProperty(it) } + } + + fun columns(vararg properties: IProperty<*>) = apply { + this.columns = properties.toList() + } + + fun columns(properties: List>) = apply { + this.columns = properties + } + + /** + * @return Appends a list of columns to this INSERT statement from the associated [TModel]. + */ + fun asColumns() = apply { + columns(*FlowManager.getModelAdapter(table).allColumnProperties) + } + + /** + * @return Appends a list of columns to this INSERT and ? as the values. + */ + fun asColumnValues() = apply { + asColumns() + if (columns != null) { + val values = arrayListOf() + for (i in columns!!.indices) { + values.add("?") + } + valuesList.add(values) + } + } + + /** + * The required values to specify. It must be non-empty and match the length of the columns when + * a set of columns are specified. + * + * @param values The non type-converted values + */ + fun values(vararg values: Any) = apply { + valuesList.add(values.toMutableList()) + } + + /** + * The required values to specify. It must be non-empty and match the length of the columns when + * a set of columns are specified. + * + * @param values The non type-converted values + */ + fun values(values: Collection) = apply { + valuesList.add(values.toMutableList()) + } + + /** + * Uses the [Operator] pairs to fill this insert query. + * + * @param conditions The conditions that we use to fill the columns and values of this INSERT + */ + fun columnValues(vararg conditions: SQLOperator) = apply { + val columns = arrayListOf() + val values = arrayListOf() + + for (i in conditions.indices) { + val condition = conditions[i] + columns += condition.columnName() + values += condition.value() + } + + return columns(*columns.toTypedArray()).values(values) + } + + /** + * Uses the [Operator] pairs to fill this insert query. + * + * @param operatorGroup The OperatorGroup to use + */ + fun columnValues(operatorGroup: OperatorGroup) = apply { + val size = operatorGroup.size + val columns = arrayListOf() + val values = arrayListOf() + + for (i in 0 until size) { + val condition = operatorGroup.conditions[i] + columns += condition.columnName() + values += condition.value() + } + + return columns(*columns.toTypedArray()).values(values) + } + + fun columnValues(contentValues: ContentValues) = apply { + val entries = contentValues.valueSet() + val columns = arrayListOf() + val values = arrayListOf() + for ((key) in entries) { + columns += key + values += contentValues.get(key) + } + + return columns(*columns.toTypedArray()).values(values) + } + + /** + * Appends the specified [From], which comes from a [Select] statement. + * + * @param selectFrom The from that is continuation of [Select]. + */ + fun select(selectFrom: From<*>) = apply { + this.selectFrom = selectFrom + } + + + /** + * Specifies the optional OR method to use for this insert query + * + * @param action The conflict action to use + * @return + */ + fun or(action: ConflictAction) = apply { + conflictAction = action + } + + /** + * Specifies OR REPLACE, which will either insert if row does not exist, or replace the value if it does. + * + * @return + */ + fun orReplace() = apply { + return or(ConflictAction.REPLACE) + } + + /** + * Specifies OR ROLLBACK, which will cancel the current transaction or ABORT the current statement. + * + * @return + */ + fun orRollback() = apply { + return or(ConflictAction.ROLLBACK) + } + + /** + * Specifies OR ABORT, which will cancel the current INSERT, but all other operations will be preserved in + * the current transaction. + * + * @return + */ + fun orAbort() = apply { + return or(ConflictAction.ABORT) + } + + /** + * Specifies OR FAIL, which does not back out of the previous statements. Anything else in the current + * transaction will fail. + * + * @return + */ + fun orFail() = apply { + return or(ConflictAction.FAIL) + } + + /** + * Specifies OR IGNORE, which ignores any kind of error and proceeds as normal. + * + * @return + */ + fun orIgnore() = apply { + return or(ConflictAction.IGNORE) + } + + override fun executeUpdateDelete(databaseWrapper: DatabaseWrapper): Long { + throw IllegalStateException("Cannot call executeUpdateDelete() from an Insert") + } + + override fun executeUpdateDelete(): Long { + throw IllegalStateException("Cannot call executeUpdateDelete() from an Insert") + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Join.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Join.java deleted file mode 100644 index d714a33dc..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Join.java +++ /dev/null @@ -1,188 +0,0 @@ -package com.raizlabs.android.dbflow.sql.language; - -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.config.FlowManager; -import com.raizlabs.android.dbflow.sql.Query; -import com.raizlabs.android.dbflow.sql.QueryBuilder; -import com.raizlabs.android.dbflow.sql.language.property.IProperty; -import com.raizlabs.android.dbflow.sql.language.property.PropertyFactory; -import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable; - -import java.util.ArrayList; -import java.util.Collections; -import java.util.List; - -/** - * Description: Specifies a SQLite JOIN statement - */ -public class Join implements Query { - - /** - * The specific type of JOIN that is used. - */ - public enum JoinType { - - /** - * an extension of the INNER JOIN. Though SQL standard defines three types of OUTER JOINs: LEFT, RIGHT, - * and FULL but SQLite only supports the LEFT OUTER JOIN. - *

- * The OUTER JOINs have a condition that is identical to INNER JOINs, expressed using an ON, USING, or NATURAL keyword. - * The initial results table is calculated the same way. Once the primary JOIN is calculated, - * an OUTER join will take any unjoined rows from one or both tables, pad them out with NULLs, - * and append them to the resulting table. - */ - LEFT_OUTER, - - /** - * creates a new result table by combining column values of two tables (table1 and table2) based upon the join-predicate. - * The query compares each row of table1 with each row of table2 to find all pairs of rows which satisfy the join-predicate. - * When the join-predicate is satisfied, column values for each matched pair of rows of A and B are combined into a result row - */ - INNER, - - /** - * matches every row of the first table with every row of the second table. If the input tables - * have x and y columns, respectively, the resulting table will have x*y columns. - * Because CROSS JOINs have the potential to generate extremely large tables, - * care must be taken to only use them when appropriate. - */ - CROSS, - - /** - * a join that performs the same task as an INNER or LEFT JOIN, in which the ON or USING - * clause refers to all columns that the tables to be joined have in common. - */ - NATURAL - } - - private final Class table; - /** - * The type of JOIN to use - */ - private JoinType type; - - /** - * The FROM statement that prefixes this statement. - */ - private From from; - - /** - * The alias to name the JOIN - */ - private NameAlias alias; - - /** - * The ON conditions - */ - private OperatorGroup onGroup; - - /** - * What columns to use. - */ - private List using = new ArrayList<>(); - - public Join(@NonNull From from, @NonNull Class table, @NonNull JoinType joinType) { - this.from = from; - this.table = table; - type = joinType; - alias = new NameAlias.Builder(FlowManager.getTableName(table)).build(); - } - - public Join(@NonNull From from, @NonNull JoinType joinType, - @NonNull ModelQueriable modelQueriable) { - table = modelQueriable.getTable(); - this.from = from; - type = joinType; - alias = PropertyFactory.INSTANCE.from(modelQueriable).getNameAlias(); - } - - /** - * Specifies if the JOIN has a name it should be called. - * - * @param alias The name to give it - * @return This instance - */ - @NonNull - public Join as(@NonNull String alias) { - this.alias = this.alias - .newBuilder() - .as(alias) - .build(); - return this; - } - - /** - * Specify the conditions that the JOIN is on - * - * @param onConditions The conditions it is on - * @return The FROM that this JOIN came from - */ - @NonNull - public From on(SQLOperator... onConditions) { - checkNatural(); - onGroup = OperatorGroup.nonGroupingClause(); - onGroup.andAll(onConditions); - return from; - } - - /** - * The USING statement of the JOIN - * - * @param columns THe columns to use - * @return The FROM that this JOIN came from - */ - @NonNull - public From using(IProperty... columns) { - checkNatural(); - Collections.addAll(using, columns); - return from; - } - - /** - * @return End this {@link Join}. Used for {@link Join.JoinType#NATURAL} - */ - public From end() { - return from; - } - - @SuppressWarnings("unchecked") - @Override - public String getQuery() { - QueryBuilder queryBuilder = new QueryBuilder(); - - queryBuilder.append(type.name().replace("_", " ")).appendSpace(); - - queryBuilder.append("JOIN") - .appendSpace() - .append(alias.getFullQuery()) - .appendSpace(); - - // natural joins do no have on or using clauses. - if (!JoinType.NATURAL.equals(type)) { - if (onGroup != null) { - queryBuilder.append("ON") - .appendSpace() - .append(onGroup.getQuery()) - .appendSpace(); - } else if (!using.isEmpty()) { - queryBuilder.append("USING (") - .appendList(using) - .append(")").appendSpace(); - } - } - return queryBuilder.getQuery(); - } - - @NonNull - public Class getTable() { - return table; - } - - private void checkNatural() { - if (JoinType.NATURAL.equals(type)) { - throw new IllegalArgumentException("Cannot specify a clause for this join if its NATURAL." + - " Specifying a clause would have no effect. Call end() to continue the query."); - } - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Join.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Join.kt new file mode 100644 index 000000000..aec3e7c65 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Join.kt @@ -0,0 +1,172 @@ +package com.raizlabs.android.dbflow.sql.language + +import com.raizlabs.android.dbflow.config.FlowManager +import com.raizlabs.android.dbflow.sql.Query +import com.raizlabs.android.dbflow.sql.QueryBuilder +import com.raizlabs.android.dbflow.sql.language.property.IProperty +import com.raizlabs.android.dbflow.sql.language.property.PropertyFactory +import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable +import java.util.* + +/** + * Description: Specifies a SQLite JOIN statement + */ +class Join : Query { + + val table: Class + + /** + * The type of JOIN to use + */ + private var type: JoinType + + /** + * The FROM statement that prefixes this statement. + */ + private var from: From + + /** + * The alias to name the JOIN + */ + private var alias: NameAlias + + /** + * The ON conditions + */ + private var onGroup: OperatorGroup? = null + + /** + * What columns to use. + */ + private val using = ArrayList>() + + override// natural joins do no have on or using clauses. + val query: String + get() { + val queryBuilder = QueryBuilder() + + queryBuilder.append(type.name.replace("_", " ")).appendSpace() + + queryBuilder.append("JOIN") + .appendSpace() + .append(alias!!.fullQuery) + .appendSpace() + if (JoinType.NATURAL != type) { + onGroup?.let { onGroup -> + queryBuilder.append("ON") + .appendSpace() + .append(onGroup.query) + .appendSpace() + } ?: if (!using.isEmpty()) { + queryBuilder.append("USING (") + .appendList(using) + .append(")").appendSpace() + } + } + return queryBuilder.query + } + + /** + * The specific type of JOIN that is used. + */ + enum class JoinType { + + /** + * an extension of the INNER JOIN. Though SQL standard defines three types of OUTER JOINs: LEFT, RIGHT, + * and FULL but SQLite only supports the LEFT OUTER JOIN. + * + * + * The OUTER JOINs have a condition that is identical to INNER JOINs, expressed using an ON, USING, or NATURAL keyword. + * The initial results table is calculated the same way. Once the primary JOIN is calculated, + * an OUTER join will take any unjoined rows from one or both tables, pad them out with NULLs, + * and append them to the resulting table. + */ + LEFT_OUTER, + + /** + * creates a new result table by combining column values of two tables (table1 and table2) based upon the join-predicate. + * The query compares each row of table1 with each row of table2 to find all pairs of rows which satisfy the join-predicate. + * When the join-predicate is satisfied, column values for each matched pair of rows of A and B are combined into a result row + */ + INNER, + + /** + * matches every row of the first table with every row of the second table. If the input tables + * have x and y columns, respectively, the resulting table will have x*y columns. + * Because CROSS JOINs have the potential to generate extremely large tables, + * care must be taken to only use them when appropriate. + */ + CROSS, + + /** + * a join that performs the same task as an INNER or LEFT JOIN, in which the ON or USING + * clause refers to all columns that the tables to be joined have in common. + */ + NATURAL + } + + constructor(from: From, table: Class, joinType: JoinType) { + this.from = from + this.table = table + type = joinType + alias = NameAlias.Builder(FlowManager.getTableName(table)).build() + } + + constructor(from: From, joinType: JoinType, + modelQueriable: ModelQueriable) { + table = modelQueriable.table + this.from = from + type = joinType + alias = PropertyFactory.from(modelQueriable).nameAlias + } + + /** + * Specifies if the JOIN has a name it should be called. + * + * @param alias The name to give it + * @return This instance + */ + fun `as`(alias: String) = apply { + this.alias = this.alias + .newBuilder() + .`as`(alias) + .build() + } + + /** + * Specify the conditions that the JOIN is on + * + * @param onConditions The conditions it is on + * @return The FROM that this JOIN came from + */ + fun on(vararg onConditions: SQLOperator): From { + checkNatural() + onGroup = OperatorGroup.nonGroupingClause().apply { + andAll(*onConditions) + } + return from + } + + /** + * The USING statement of the JOIN + * + * @param columns THe columns to use + * @return The FROM that this JOIN came from + */ + fun using(vararg columns: IProperty<*>): From { + checkNatural() + using.addAll(columns) + return from + } + + /** + * @return End this [Join]. Used for [Join.JoinType.NATURAL] + */ + fun end(): From = from + + private fun checkNatural() { + if (JoinType.NATURAL == type) { + throw IllegalArgumentException("Cannot specify a clause for this join if its NATURAL." + " Specifying a clause would have no effect. Call end() to continue the query.") + } + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Method.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Method.java deleted file mode 100644 index 9aa05b9da..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Method.java +++ /dev/null @@ -1,287 +0,0 @@ -package com.raizlabs.android.dbflow.sql.language; - -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.sql.SQLiteType; -import com.raizlabs.android.dbflow.sql.language.property.IProperty; -import com.raizlabs.android.dbflow.sql.language.property.Property; -import com.raizlabs.android.dbflow.sql.language.property.PropertyFactory; - -import java.util.ArrayList; -import java.util.List; - -/** - * Represents SQLite methods on columns. These act as {@link Property} so we can use them in complex - * scenarios. - */ -public class Method extends Property { - - /** - * @param properties Set of properties that the method acts on. - * @return The average value of all properties within this group. The result is always a float from this statement - * as long as there is at least one non-NULL input. The result may be NULL if there are no non-NULL columns. - */ - @NonNull - public static Method avg(IProperty... properties) { - return new Method("AVG", properties); - } - - /** - * @param properties Set of properties that the method acts on. - * @return A count of the number of times that specified properties are not NULL in a group. Leaving - * the properties empty returns COUNT(*), which is the total number of rows in the query. - */ - @NonNull - public static Method count(IProperty... properties) { - return new Method("COUNT", properties); - } - - /** - * @param properties Set of properties that the method acts on. - * @return A string which is the concatenation of all non-NULL values of the properties. - */ - @NonNull - public static Method group_concat(IProperty... properties) { - return new Method("GROUP_CONCAT", properties); - } - - /** - * @param properties Set of properties that the method acts on. - * @return The method that represents the max of the specified columns/properties. - */ - @NonNull - public static Method max(IProperty... properties) { - return new Method("MAX", properties); - } - - /** - * @param properties Set of properties that the method acts on. - * @return The method that represents the min of the specified columns/properties. - */ - @NonNull - public static Method min(IProperty... properties) { - return new Method("MIN", properties); - } - - /** - * @param properties Set of properties that the method acts on. - * @return The method that represents the sum of the specified columns/properties. - */ - @NonNull - public static Method sum(IProperty... properties) { - return new Method("SUM", properties); - } - - /** - * @param properties Set of properties that the method acts on. - * @return The method that represents the total of the specified columns/properties. - */ - @NonNull - public static Method total(IProperty... properties) { - return new Method("TOTAL", properties); - } - - /** - * @param property The property to cast. - * @return A new CAST object. To complete use the {@link Cast#as(SQLiteType)} method. - */ - @NonNull - public static Cast cast(@NonNull IProperty property) { - return new Cast(property); - } - - @NonNull - public static Method replace(@NonNull IProperty property, String findString, String replacement) { - return new Method("REPLACE", property, PropertyFactory.INSTANCE.from(findString), PropertyFactory.INSTANCE.from(replacement)); - } - - /** - * SQLite standard "strftime()" method. See SQLite documentation on this method. - */ - public static Method strftime(@NonNull String formatString, - @NonNull String timeString, String... modifiers) { - List propertyList = new ArrayList<>(); - propertyList.add(PropertyFactory.INSTANCE.from(formatString)); - propertyList.add(PropertyFactory.INSTANCE.from(timeString)); - for (String modifier : modifiers) { - propertyList.add(PropertyFactory.INSTANCE.from(modifier)); - } - return new Method("strftime", propertyList.toArray(new IProperty[propertyList.size()])); - } - - /** - * Sqlite "datetime" method. See SQLite documentation on this method. - */ - public static Method datetime(long timeStamp, String... modifiers) { - List propertyList = new ArrayList<>(); - propertyList.add(PropertyFactory.INSTANCE.from(timeStamp)); - for (String modifier : modifiers) { - propertyList.add(PropertyFactory.INSTANCE.from(modifier)); - } - return new Method("datetime", propertyList.toArray(new IProperty[propertyList.size()])); - } - - /** - * Sqlite "date" method. See SQLite documentation on this method. - */ - public static Method date(@NonNull String timeString, - String... modifiers) { - List propertyList = new ArrayList<>(); - propertyList.add(PropertyFactory.INSTANCE.from(timeString)); - for (String modifier : modifiers) { - propertyList.add(PropertyFactory.INSTANCE.from(modifier)); - } - return new Method("date", propertyList.toArray(new IProperty[propertyList.size()])); - } - - /** - * @return Constructs using the "IFNULL" method in SQLite. It will pick the first non null - * value and set that. If both are NULL then it will use NULL. - */ - public static Method ifNull(@NonNull IProperty first, - @NonNull IProperty secondIfFirstNull) { - return new Method("IFNULL", first, secondIfFirstNull); - } - - /** - * @return Constructs using the "NULLIF" method in SQLite. If both expressions are equal, then - * NULL is set into the DB. - */ - public static Method nullIf(@NonNull IProperty first, - @NonNull IProperty second) { - return new Method("NULLIF", first, second); - } - - private final List propertyList = new ArrayList<>(); - private List operationsList = new ArrayList<>(); - private final IProperty methodProperty; - - public Method(IProperty... properties) { - this(null, properties); - } - - @SuppressWarnings("unchecked") - public Method(String methodName, IProperty... properties) { - super(null, (String) null); - - methodProperty = new Property<>(null, NameAlias.rawBuilder(methodName).build()); - - if (properties.length == 0) { - propertyList.add(Property.Companion.getALL_PROPERTY()); - } else { - for (IProperty property : properties) { - addProperty(property); - } - } - } - - @NonNull - @Override - public Method plus(@NonNull IProperty property) { - return append(property, " " + Operator.Operation.PLUS); - } - - @NonNull - @Override - public Method minus(@NonNull IProperty property) { - return append(property, " " + Operator.Operation.MINUS); - } - - @NonNull - @Override - public Property div(@NonNull IProperty property) { - return append(property, " " + Operator.Operation.DIVISION); - } - - @Override - public Property times(@NonNull IProperty property) { - return append(property, " " + Operator.Operation.MULTIPLY); - } - - @NonNull - @Override - public Property rem(@NonNull IProperty property) { - return append(property, " " + Operator.Operation.MOD); - } - - /** - * Allows adding a property to the {@link Method}. Will remove the {@link Property#ALL_PROPERTY} - * if it exists as first item. - * - * @param property The property to add. - */ - public Method addProperty(@NonNull IProperty property) { - return append(property, ","); - } - - /** - * Appends a property with the specified operation that separates it. The operation will appear before - * the property specified. - */ - public Method append(IProperty property, String operation) { - // remove all property since its not needed when we specify a property. - if (propertyList.size() == 1 && propertyList.get(0) == Property.Companion.getALL_PROPERTY()) { - propertyList.remove(0); - } - propertyList.add(property); - operationsList.add(operation); - return this; - } - - @NonNull - protected List getPropertyList() { - return propertyList; - } - - @NonNull - @Override - public NameAlias getNameAlias() { - if (getNameAlias() == null) { - String query = methodProperty.getQuery(); - if (query == null) { - query = ""; - } - query += "("; - List propertyList = getPropertyList(); - for (int i = 0; i < propertyList.size(); i++) { - IProperty property = propertyList.get(i); - if (i > 0) { - query += operationsList.get(i) + " "; - } - query += property.toString(); - - } - query += ")"; - getNameAlias(NameAlias.rawBuilder(query) - .build()); - } - return getNameAlias(); - } - - /** - * Represents the SQLite CAST operator. - */ - public static class Cast { - - private final IProperty property; - - private Cast(@NonNull IProperty property) { - this.property = property; - } - - /** - * @param sqLiteType The type of column to cast it to. - * @return A new {@link Method} that represents the statement. - */ - public IProperty as(SQLiteType sqLiteType) { - //noinspection unchecked - IProperty newProperty = new Property(property.getTable(), - property.getNameAlias() - .newBuilder() - .shouldAddIdentifierToAliasName(false) - .as(sqLiteType.name()) - .build()); - return new Method("CAST", newProperty); - } - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Method.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Method.kt new file mode 100644 index 000000000..13a3640bb --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Method.kt @@ -0,0 +1,220 @@ +package com.raizlabs.android.dbflow.sql.language + + +import com.raizlabs.android.dbflow.sql.SQLiteType +import com.raizlabs.android.dbflow.sql.language.property.IProperty +import com.raizlabs.android.dbflow.sql.language.property.Property +import com.raizlabs.android.dbflow.sql.language.property.PropertyFactory +import java.util.* + +/** + * Represents SQLite methods on columns. These act as [Property] so we can use them in complex + * scenarios. + */ +class Method(methodName: String, vararg properties: IProperty<*>) : Property(null, null as String?) { + + private val propertyList = ArrayList>() + private val operationsList = ArrayList() + private val methodProperty: IProperty<*> + private var nameAlias: NameAlias? = null + + constructor(vararg properties: IProperty<*>) : this("", *properties) + + init { + methodProperty = Property(null, NameAlias.rawBuilder(methodName).build()) + + if (properties.isEmpty()) { + propertyList.add(Property.ALL_PROPERTY) + } else { + properties.forEach { addProperty(it) } + } + } + + override fun plus(property: IProperty<*>): Method = + append(property, " " + Operator.Operation.PLUS) + + override fun minus(property: IProperty<*>): Method = + append(property, " " + Operator.Operation.MINUS) + + override fun div(property: IProperty<*>): Property = + append(property, " " + Operator.Operation.DIVISION) + + override fun times(property: IProperty<*>): Property = + append(property, " " + Operator.Operation.MULTIPLY) + + override fun rem(property: IProperty<*>): Property = + append(property, " " + Operator.Operation.MOD) + + /** + * Allows adding a property to the [Method]. Will remove the [Property.ALL_PROPERTY] + * if it exists as first item. + * + * @param property The property to add. + */ + fun addProperty(property: IProperty<*>): Method = append(property, ",") + + /** + * Appends a property with the specified operation that separates it. The operation will appear before + * the property specified. + */ + fun append(property: IProperty<*>, operation: String): Method { + // remove all property since its not needed when we specify a property. + if (propertyList.size == 1 && propertyList[0] === Property.ALL_PROPERTY) { + propertyList.removeAt(0) + } + propertyList.add(property) + operationsList.add(operation) + return this + } + + protected fun getPropertyList(): List> = propertyList + + override fun getNameAlias(): NameAlias { + if (this.nameAlias == null) { + var query: String? = methodProperty.query + if (query == null) { + query = "" + } + query += "(" + val propertyList = getPropertyList() + for (i in propertyList.indices) { + val property = propertyList[i] + if (i > 0) { + query += operationsList[i] + " " + } + query += property.toString() + + } + query += ")" + this.nameAlias = NameAlias.rawBuilder(query).build() + } + return this.nameAlias!! + } + + /** + * Represents the SQLite CAST operator. + */ + class Cast internal constructor(private val property: IProperty<*>) { + + /** + * @param sqLiteType The type of column to cast it to. + * @return A new [Method] that represents the statement. + */ + fun `as`(sqLiteType: SQLiteType): IProperty<*> { + + val newProperty = Property(property.table, + property.nameAlias + .newBuilder() + .shouldAddIdentifierToAliasName(false) + .`as`(sqLiteType.name) + .build()) + return Method("CAST", newProperty) + } + } + +} + +/** + * @param properties Set of properties that the method acts on. + * @return The average value of all properties within this group. The result is always a float from this statement + * as long as there is at least one non-NULL input. The result may be NULL if there are no non-NULL columns. + */ +fun avg(vararg properties: IProperty<*>): Method = Method("AVG", *properties) + +/** + * @param properties Set of properties that the method acts on. + * @return A count of the number of times that specified properties are not NULL in a group. Leaving + * the properties empty returns COUNT(*), which is the total number of rows in the query. + */ +fun count(vararg properties: IProperty<*>): Method = Method("COUNT", *properties) + +/** + * @param properties Set of properties that the method acts on. + * @return A string which is the concatenation of all non-NULL values of the properties. + */ +fun group_concat(vararg properties: IProperty<*>): Method = + Method("GROUP_CONCAT", *properties) + +/** + * @param properties Set of properties that the method acts on. + * @return The method that represents the max of the specified columns/properties. + */ +fun max(vararg properties: IProperty<*>): Method = Method("MAX", *properties) + +/** + * @param properties Set of properties that the method acts on. + * @return The method that represents the min of the specified columns/properties. + */ +fun min(vararg properties: IProperty<*>): Method = Method("MIN", *properties) + +/** + * @param properties Set of properties that the method acts on. + * @return The method that represents the sum of the specified columns/properties. + */ +fun sum(vararg properties: IProperty<*>): Method = Method("SUM", *properties) + +/** + * @param properties Set of properties that the method acts on. + * @return The method that represents the total of the specified columns/properties. + */ +fun total(vararg properties: IProperty<*>): Method = Method("TOTAL", *properties) + +/** + * @param property The property to cast. + * @return A new CAST object. To complete use the [Cast. as] method. + */ +fun cast(property: IProperty<*>): Method.Cast = Method.Cast(property) + +fun replace(property: IProperty<*>, findString: String, replacement: String): Method = + Method("REPLACE", property, PropertyFactory.from(findString), PropertyFactory.from(replacement)) + +/** + * SQLite standard "strftime()" method. See SQLite documentation on this method. + */ +fun strftime(formatString: String, + timeString: String, vararg modifiers: String): Method { + val propertyList = ArrayList>() + propertyList.add(PropertyFactory.from(formatString)) + propertyList.add(PropertyFactory.from(timeString)) + for (modifier in modifiers) { + propertyList.add(PropertyFactory.from(modifier)) + } + return Method("strftime", *propertyList.toTypedArray()) +} + +/** + * Sqlite "datetime" method. See SQLite documentation on this method. + */ +fun datetime(timeStamp: Long, vararg modifiers: String): Method { + val propertyList = arrayListOf>() + propertyList.add(PropertyFactory.from(timeStamp)) + modifiers.mapTo(propertyList) { PropertyFactory.from(it) } + return Method("datetime", *propertyList.toTypedArray()) +} + +/** + * Sqlite "date" method. See SQLite documentation on this method. + */ +fun date(timeString: String, + vararg modifiers: String): Method { + val propertyList = ArrayList>() + propertyList.add(PropertyFactory.from(timeString)) + for (modifier in modifiers) { + propertyList.add(PropertyFactory.from(modifier)) + } + return Method("date", *propertyList.toTypedArray()) +} + +/** + * @return Constructs using the "IFNULL" method in SQLite. It will pick the first non null + * value and set that. If both are NULL then it will use NULL. + */ +fun ifNull(first: IProperty<*>, + secondIfFirstNull: IProperty<*>): Method = Method("IFNULL", first, secondIfFirstNull) + +/** + * @return Constructs using the "NULLIF" method in SQLite. If both expressions are equal, then + * NULL is set into the DB. + */ +fun nullIf(first: IProperty<*>, + second: IProperty<*>): Method = Method("NULLIF", first, second) \ No newline at end of file diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/NameAlias.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/NameAlias.java deleted file mode 100644 index c45b5e4da..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/NameAlias.java +++ /dev/null @@ -1,308 +0,0 @@ -package com.raizlabs.android.dbflow.sql.language; - -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.StringUtils; -import com.raizlabs.android.dbflow.sql.Query; -import com.raizlabs.android.dbflow.sql.QueryBuilder; - -/** - * Description: Rewritten from the ground up, this class makes it easier to build an alias. - */ -public class NameAlias implements Query { - - /** - * Combines any number of names into a single {@link NameAlias} separated by some operation. - * - * @param operation The operation to separate into. - * @param names The names to join. - * @return The new namealias object. - */ - @NonNull - public static NameAlias joinNames(@NonNull String operation, String... names) { - String newName = ""; - for (int i = 0; i < names.length; i++) { - if (i > 0) { - newName += " " + operation + " "; - } - newName += names[i]; - } - return rawBuilder(newName).build(); - } - - @NonNull - public static Builder builder(String name) { - return new Builder(name); - } - - /** - * @param name The raw name of this alias. - * @return A new instance without adding identifier `` to any part of the query. - */ - @NonNull - public static Builder rawBuilder(String name) { - return new Builder(name) - .shouldStripIdentifier(false) - .shouldAddIdentifierToName(false); - } - - @NonNull - public static NameAlias of(String name) { - return NameAlias.builder(name).build(); - } - - @NonNull - public static NameAlias of(String name, String aliasName) { - return NameAlias.builder(name).as(aliasName).build(); - } - - @NonNull - public static NameAlias ofTable(String tableName, String name) { - return NameAlias.builder(name).withTable(tableName).build(); - } - - private final String name; - private final String aliasName; - private final String tableName; - private final String keyword; - private final boolean shouldStripIdentifier; - private final boolean shouldStripAliasName; - private final boolean shouldAddIdentifierToQuery; - private final boolean shouldAddIdentifierToAliasName; - - private NameAlias(Builder builder) { - if (builder.shouldStripIdentifier) { - name = QueryBuilder.stripQuotes(builder.name); - } else { - name = builder.name; - } - keyword = builder.keyword; - if (builder.shouldStripAliasName) { - aliasName = QueryBuilder.stripQuotes(builder.aliasName); - } else { - aliasName = builder.aliasName; - } - if (StringUtils.isNotNullOrEmpty(builder.tableName)) { - tableName = QueryBuilder.quoteIfNeeded(builder.tableName); - } else { - tableName = null; - } - shouldStripIdentifier = builder.shouldStripIdentifier; - shouldStripAliasName = builder.shouldStripAliasName; - shouldAddIdentifierToQuery = builder.shouldAddIdentifierToQuery; - shouldAddIdentifierToAliasName = builder.shouldAddIdentifierToAliasName; - } - - /** - * @return The real column name. - */ - public String name() { - return (StringUtils.isNotNullOrEmpty(name) && shouldAddIdentifierToQuery) ? - QueryBuilder.quoteIfNeeded(name) : name; - } - - /** - * @return The name, stripped from identifier syntax completely. - */ - public String nameRaw() { - return shouldStripIdentifier ? name : QueryBuilder.stripQuotes(name); - } - - /** - * @return The name used as part of the AS query. - */ - public String aliasName() { - return (StringUtils.isNotNullOrEmpty(aliasName) && shouldAddIdentifierToAliasName) ? - QueryBuilder.quoteIfNeeded(aliasName) : aliasName; - } - - /** - * @return The alias name, stripped from identifier syntax completely. - */ - public String aliasNameRaw() { - return shouldStripAliasName ? aliasName : QueryBuilder.stripQuotes(aliasName); - } - - /** - * @return the table name of this query, if specified. - */ - public String tableName() { - return tableName; - } - - /** - * @return The keyword that prefixes this alias. - */ - public String keyword() { - return keyword; - } - - /** - * @return true if the name was stripped from identifier, false if not. - */ - public boolean shouldStripIdentifier() { - return shouldStripIdentifier; - } - - /** - * @return true if the alias was stripped from identifier, false if not. - */ - public boolean shouldStripAliasName() { - return shouldStripAliasName; - } - - /** - * @return The `{tableName}`.`{name}`. If {@link #tableName()} specified. - */ - public String fullName() { - return (StringUtils.isNotNullOrEmpty(tableName) ? (tableName() + ".") : "") + name(); - } - - /** - * @return The name used in queries. If an alias is specified, use that, otherwise use the name - * of the property with a table name (if specified). - */ - @Override - public String getQuery() { - if (StringUtils.isNotNullOrEmpty(aliasName)) { - return aliasName(); - } else if (StringUtils.isNotNullOrEmpty(name)) { - return fullName(); - } else { - return ""; - } - } - - /** - * @return The value used as a key. Uses either the {@link #aliasNameRaw()} - * or the {@link #nameRaw()}, depending on what's specified. - */ - public String getNameAsKey() { - if (StringUtils.isNotNullOrEmpty(aliasName)) { - return aliasNameRaw(); - } else { - return nameRaw(); - } - } - - @Override - public String toString() { - return getFullQuery(); - } - - /** - * @return The full query that represents itself with `{tableName}`.`{name}` AS `{aliasName}` - */ - public String getFullQuery() { - String query = fullName(); - if (StringUtils.isNotNullOrEmpty(aliasName)) { - query += " AS " + aliasName(); - } - if (StringUtils.isNotNullOrEmpty(keyword)) { - query = keyword + " " + query; - } - return query; - } - - /** - * @return Constructs a builder as a new instance that can be modified without fear. - */ - public Builder newBuilder() { - return new Builder(name) - .keyword(keyword) - .as(aliasName) - .shouldStripAliasName(shouldStripAliasName) - .shouldStripIdentifier(shouldStripIdentifier) - .shouldAddIdentifierToName(shouldAddIdentifierToQuery) - .shouldAddIdentifierToAliasName(shouldAddIdentifierToAliasName) - .withTable(tableName); - } - - - public static class Builder { - - private final String name; - private String aliasName; - private String tableName; - private boolean shouldStripIdentifier = true; - private boolean shouldStripAliasName = true; - private boolean shouldAddIdentifierToQuery = true; - private boolean shouldAddIdentifierToAliasName = true; - private String keyword; - - public Builder(String name) { - this.name = name; - } - - /** - * Appends a DISTINCT that prefixes this alias class. - */ - public Builder distinct() { - return keyword("DISTINCT"); - } - - /** - * Appends a keyword that prefixes this alias class. - */ - public Builder keyword(String keyword) { - this.keyword = keyword; - return this; - } - - /** - * Provide an alias that is used `{name}` AS `{aliasName}` - */ - public Builder as(String aliasName) { - this.aliasName = aliasName; - return this; - } - - /** - * Provide a table-name prefix as such: `{tableName}`.`{name}` - */ - public Builder withTable(String tableName) { - this.tableName = tableName; - return this; - } - - /** - * @param shouldStripIdentifier If true, we normalize the identifier {@link #name} from any - * ticks around the name. If false, we leave it as such. - */ - public Builder shouldStripIdentifier(boolean shouldStripIdentifier) { - this.shouldStripIdentifier = shouldStripIdentifier; - return this; - } - - /** - * @param shouldStripAliasName If true, we normalize the identifier {@link #aliasName} from any - * ticks around the name. If false, we leave it as such. - */ - public Builder shouldStripAliasName(boolean shouldStripAliasName) { - this.shouldStripAliasName = shouldStripAliasName; - return this; - } - - /** - * @param shouldAddIdentifierToName If true (default), we add the identifier to the name: `{name}` - */ - public Builder shouldAddIdentifierToName(boolean shouldAddIdentifierToName) { - this.shouldAddIdentifierToQuery = shouldAddIdentifierToName; - return this; - } - - /** - * @param shouldAddIdentifierToAliasName If true (default), we add an identifier to the alias - * name. `{aliasName}` - */ - public Builder shouldAddIdentifierToAliasName(boolean shouldAddIdentifierToAliasName) { - this.shouldAddIdentifierToAliasName = shouldAddIdentifierToAliasName; - return this; - } - - public NameAlias build() { - return new NameAlias(this); - } - - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/NameAlias.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/NameAlias.kt new file mode 100644 index 000000000..4184178d8 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/NameAlias.kt @@ -0,0 +1,240 @@ +package com.raizlabs.android.dbflow.sql.language + +import com.raizlabs.android.dbflow.StringUtils +import com.raizlabs.android.dbflow.sql.Query +import com.raizlabs.android.dbflow.sql.QueryBuilder + +/** + * Description: Rewritten from the ground up, this class makes it easier to build an alias. + */ +class NameAlias(private val name: String, + private val aliasName: String? = null, + private val tableName: String? = null, + private val keyword: String? = null, + private val shouldStripIdentifier: Boolean = true, + private val shouldStripAliasName: Boolean = true, + private val shouldAddIdentifierToQuery: Boolean = true, + private val shouldAddIdentifierToAliasName: Boolean = true) : Query { + + /** + * @return The name used in queries. If an alias is specified, use that, otherwise use the name + * of the property with a table name (if specified). + */ + override val query: String + get() = when { + StringUtils.isNotNullOrEmpty(aliasName) -> aliasName!! + StringUtils.isNotNullOrEmpty(name) -> fullName() + else -> "" + } + + /** + * @return The value used as a key. Uses either the [.aliasNameRaw] + * or the [.nameRaw], depending on what's specified. + */ + val nameAsKey: String? + get() = if (StringUtils.isNotNullOrEmpty(aliasName)) { + aliasNameRaw() + } else { + nameRaw() + } + + /** + * @return The full query that represents itself with `{tableName}`.`{name}` AS `{aliasName}` + */ + val fullQuery: String + get() { + var query = fullName() + if (StringUtils.isNotNullOrEmpty(aliasName)) { + query += " AS ${aliasName()}" + } + if (StringUtils.isNotNullOrEmpty(keyword)) { + query = "$keyword $query" + } + return query + } + + private constructor(builder: Builder) : this( + name = if (builder.shouldStripIdentifier) { + QueryBuilder.stripQuotes(builder.name) + } else { + builder.name + }, + keyword = builder.keyword, + aliasName = if (builder.shouldStripAliasName) { + QueryBuilder.stripQuotes(builder.aliasName) + } else { + builder.aliasName + }, + tableName = if (StringUtils.isNotNullOrEmpty(builder.tableName)) { + QueryBuilder.quoteIfNeeded(builder.tableName) + } else { + null + }, + shouldStripIdentifier = builder.shouldStripIdentifier, + shouldStripAliasName = builder.shouldStripAliasName, + shouldAddIdentifierToQuery = builder.shouldAddIdentifierToQuery, + shouldAddIdentifierToAliasName = builder.shouldAddIdentifierToAliasName) + + /** + * @return The real column name. + */ + fun name(): String? { + return if (StringUtils.isNotNullOrEmpty(name) && shouldAddIdentifierToQuery) + QueryBuilder.quoteIfNeeded(name) + else name + } + + /** + * @return The name, stripped from identifier syntax completely. + */ + fun nameRaw(): String = if (shouldStripIdentifier) name else QueryBuilder.stripQuotes(name) + + /** + * @return The name used as part of the AS query. + */ + fun aliasName(): String? { + return if (StringUtils.isNotNullOrEmpty(aliasName) && shouldAddIdentifierToAliasName) + QueryBuilder.quoteIfNeeded(aliasName) + else aliasName + } + + /** + * @return The alias name, stripped from identifier syntax completely. + */ + fun aliasNameRaw(): String? = + if (shouldStripAliasName) aliasName else QueryBuilder.stripQuotes(aliasName) + + /** + * @return The `{tableName}`.`{name}`. If [.tableName] specified. + */ + fun fullName(): String = + (if (StringUtils.isNotNullOrEmpty(tableName)) "$tableName." else "") + name + + override fun toString(): String = fullQuery + + /** + * @return Constructs a builder as a new instance that can be modified without fear. + */ + fun newBuilder(): Builder { + return Builder(name) + .keyword(keyword) + .`as`(aliasName) + .shouldStripAliasName(shouldStripAliasName) + .shouldStripIdentifier(shouldStripIdentifier) + .shouldAddIdentifierToName(shouldAddIdentifierToQuery) + .shouldAddIdentifierToAliasName(shouldAddIdentifierToAliasName) + .withTable(tableName) + } + + + class Builder(internal val name: String) { + internal var aliasName: String? = null + internal var tableName: String? = null + internal var shouldStripIdentifier = true + internal var shouldStripAliasName = true + internal var shouldAddIdentifierToQuery = true + internal var shouldAddIdentifierToAliasName = true + internal var keyword: String? = null + + /** + * Appends a DISTINCT that prefixes this alias class. + */ + fun distinct(): Builder = keyword("DISTINCT") + + /** + * Appends a keyword that prefixes this alias class. + */ + fun keyword(keyword: String?) = apply { + this.keyword = keyword + } + + /** + * Provide an alias that is used `{name}` AS `{aliasName}` + */ + fun `as`(aliasName: String?) = apply { + this.aliasName = aliasName + } + + /** + * Provide a table-name prefix as such: `{tableName}`.`{name}` + */ + fun withTable(tableName: String?) = apply { + this.tableName = tableName + } + + /** + * @param shouldStripIdentifier If true, we normalize the identifier [.name] from any + * ticks around the name. If false, we leave it as such. + */ + fun shouldStripIdentifier(shouldStripIdentifier: Boolean) = apply { + this.shouldStripIdentifier = shouldStripIdentifier + } + + /** + * @param shouldStripAliasName If true, we normalize the identifier [.aliasName] from any + * ticks around the name. If false, we leave it as such. + */ + fun shouldStripAliasName(shouldStripAliasName: Boolean) = apply { + this.shouldStripAliasName = shouldStripAliasName + } + + /** + * @param shouldAddIdentifierToName If true (default), we add the identifier to the name: `{name}` + */ + fun shouldAddIdentifierToName(shouldAddIdentifierToName: Boolean) = apply { + this.shouldAddIdentifierToQuery = shouldAddIdentifierToName + } + + /** + * @param shouldAddIdentifierToAliasName If true (default), we add an identifier to the alias + * name. `{aliasName}` + */ + fun shouldAddIdentifierToAliasName(shouldAddIdentifierToAliasName: Boolean) = apply { + this.shouldAddIdentifierToAliasName = shouldAddIdentifierToAliasName + } + + fun build(): NameAlias = NameAlias(this) + + } + + companion object { + + /** + * Combines any number of names into a single [NameAlias] separated by some operation. + * + * @param operation The operation to separate into. + * @param names The names to join. + * @return The new namealias object. + */ + fun joinNames(operation: String, vararg names: String): NameAlias { + var newName = "" + for (i in names.indices) { + if (i > 0) { + newName += " $operation " + } + newName += names[i] + } + return rawBuilder(newName).build() + } + + fun builder(name: String): Builder = Builder(name) + + /** + * @param name The raw name of this alias. + * @return A new instance without adding identifier `` to any part of the query. + */ + fun rawBuilder(name: String): Builder { + return Builder(name) + .shouldStripIdentifier(false) + .shouldAddIdentifierToName(false) + } + + fun of(name: String): NameAlias = NameAlias.builder(name).build() + + fun of(name: String, aliasName: String): NameAlias = + NameAlias.builder(name).`as`(aliasName).build() + + fun ofTable(tableName: String, name: String): NameAlias = + NameAlias.builder(name).withTable(tableName).build() + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Operator.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Operator.java deleted file mode 100644 index 6f1a0862d..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Operator.java +++ /dev/null @@ -1,866 +0,0 @@ -package com.raizlabs.android.dbflow.sql.language; - -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.annotation.Collate; -import com.raizlabs.android.dbflow.config.FlowLog; -import com.raizlabs.android.dbflow.config.FlowManager; -import com.raizlabs.android.dbflow.converter.TypeConverter; -import com.raizlabs.android.dbflow.sql.Query; -import com.raizlabs.android.dbflow.sql.QueryBuilder; -import com.raizlabs.android.dbflow.sql.language.property.Property; - -import java.util.ArrayList; -import java.util.Collection; -import java.util.Collections; -import java.util.List; - -/** - * Description: The class that contains a column name, Operator, and value. - * This class is mostly reserved for internal use at this point. Using this class directly should be avoided - * and use the generated {@link Property} instead. - */ -public class Operator extends BaseOperator implements IOperator { - - - private TypeConverter typeConverter; - private boolean convertToDB; - - public static String convertValueToString(Object value) { - return BaseOperator.convertValueToString(value, false); - } - - @NonNull - public static Operator op(NameAlias column) { - return new Operator<>(column); - } - - @NonNull - public static Operator op(NameAlias alias, TypeConverter typeConverter, boolean convertToDB) { - return new Operator<>(alias, typeConverter, convertToDB); - } - - /** - * Creates a new instance - * - * @param nameAlias The name of the column in the DB - */ - Operator(NameAlias nameAlias) { - super(nameAlias); - } - - Operator(NameAlias alias, TypeConverter typeConverter, boolean convertToDB) { - super(alias); - this.typeConverter = typeConverter; - this.convertToDB = convertToDB; - } - - Operator(Operator operator) { - super(operator.nameAlias); - this.typeConverter = operator.typeConverter; - this.convertToDB = operator.convertToDB; - this.value = operator.value; - } - - @Override - public void appendConditionToQuery(@NonNull QueryBuilder queryBuilder) { - queryBuilder.append(columnName()).append(operation()); - - // Do not use value for certain operators - // If is raw, we do not want to convert the value to a string. - if (isValueSet) { - queryBuilder.append(convertObjectToString(value(), true)); - } - - if (postArgument() != null) { - queryBuilder.appendSpace().append(postArgument()); - } - } - - @NonNull - @Override - public Operator is(@Nullable T value) { - operation = Operation.EQUALS; - return value(value); - } - - @NonNull - @Override - public Operator eq(@Nullable T value) { - return is(value); - } - - @NonNull - @Override - public Operator isNot(@Nullable T value) { - operation = Operation.NOT_EQUALS; - return value(value); - } - - @NonNull - @Override - public Operator notEq(@Nullable T value) { - return isNot(value); - } - - /** - * Uses the LIKE operation. Case insensitive comparisons. - * - * @param value Uses sqlite LIKE regex to match rows. - * It must be a string to escape it properly. - * There are two wildcards: % and _ - * % represents [0,many) numbers or characters. - * The _ represents a single number or character. - * @return This condition - */ - @NonNull - @Override - public Operator like(@NonNull String value) { - operation = String.format(" %1s ", Operation.LIKE); - return value(value); - } - - /** - * Uses the NOT LIKE operation. Case insensitive comparisons. - * - * @param value Uses sqlite LIKE regex to inversely match rows. - * It must be a string to escape it properly. - * There are two wildcards: % and _ - * % represents [0,many) numbers or characters. - * The _ represents a single number or character. - * @return This condition - */ - @NonNull - @Override - public Operator notLike(@NonNull String value) { - operation = String.format(" %1s ", Operation.NOT_LIKE); - return value(value); - } - - /** - * Uses the GLOB operation. Similar to LIKE except it uses case sensitive comparisons. - * - * @param value Uses sqlite GLOB regex to match rows. - * It must be a string to escape it properly. - * There are two wildcards: * and ? - * * represents [0,many) numbers or characters. - * The ? represents a single number or character - * @return This condition - */ - @NonNull - @Override - public Operator glob(@NonNull String value) { - operation = String.format(" %1s ", Operation.GLOB); - return value(value); - } - - /** - * The value of the parameter - * - * @param value The value of the column in the DB - * @return This condition - */ - public Operator value(@Nullable Object value) { - this.value = value; - isValueSet = true; - return this; - } - - @NonNull - @Override - public Operator greaterThan(@NonNull T value) { - operation = Operation.GREATER_THAN; - return value(value); - } - - @NonNull - @Override - public Operator greaterThanOrEq(@NonNull T value) { - operation = Operation.GREATER_THAN_OR_EQUALS; - return value(value); - } - - @NonNull - @Override - public Operator lessThan(@NonNull T value) { - operation = Operation.LESS_THAN; - return value(value); - } - - @NonNull - @Override - public Operator lessThanOrEq(@NonNull T value) { - operation = Operation.LESS_THAN_OR_EQUALS; - return value(value); - } - - @NonNull - @Override - public Operator plus(@NonNull T value) { - return assignValueOp(value, Operation.PLUS); - } - - @NonNull - @Override - public Operator minus(@NonNull T value) { - return assignValueOp(value, Operation.MINUS); - } - - @NonNull - @Override - public Operator div(@NonNull T value) { - return assignValueOp(value, Operation.DIVISION); - } - - @Override - public Operator times(@NonNull T value) { - return assignValueOp(value, Operation.MULTIPLY); - } - - @NonNull - @Override - public Operator rem(@NonNull T value) { - return assignValueOp(value, Operation.MOD); - } - - /** - * Add a custom operation to this argument - * - * @param operation The SQLite operator - * @return This condition - */ - @NonNull - public Operator operation(String operation) { - this.operation = operation; - return this; - } - - /** - * Adds a COLLATE to the end of this condition - * - * @param collation The SQLite collate function - * @return This condition. - */ - @NonNull - public Operator collate(@NonNull String collation) { - postArg = "COLLATE " + collation; - return this; - } - - /** - * Adds a COLLATE to the end of this condition using the {@link com.raizlabs.android.dbflow.annotation.Collate} enum. - * - * @param collation The SQLite collate function - * @return This condition. - */ - @NonNull - public Operator collate(@NonNull Collate collation) { - if (collation.equals(Collate.NONE)) { - postArg = null; - } else { - collate(collation.name()); - } - - return this; - } - - /** - * Appends an optional SQL string to the end of this condition - */ - @NonNull - public Operator postfix(@NonNull String postfix) { - postArg = postfix; - return this; - } - - @NonNull - @Override - public Operator isNull() { - operation = String.format(" %1s ", Operation.IS_NULL); - return this; - } - - @NonNull - @Override - public Operator isNotNull() { - operation = String.format(" %1s ", Operation.IS_NOT_NULL); - return this; - } - - /** - * Optional separator when chaining this Operator within a {@link OperatorGroup} - * - * @param separator The separator to use - * @return This instance - */ - @NonNull - @Override - public Operator separator(@NonNull String separator) { - this.separator = separator; - return this; - } - - @NonNull - @Override - public Operator is(@NonNull IConditional conditional) { - return assignValueOp(conditional, Operation.EQUALS); - } - - @NonNull - @Override - public Operator eq(@NonNull IConditional conditional) { - return assignValueOp(conditional, Operation.EQUALS); - } - - @NonNull - @Override - public Operator isNot(@NonNull IConditional conditional) { - return assignValueOp(conditional, Operation.NOT_EQUALS); - } - - @NonNull - @Override - public Operator notEq(@NonNull IConditional conditional) { - return assignValueOp(conditional, Operation.NOT_EQUALS); - } - - @NonNull - @Override - public Operator like(@NonNull IConditional conditional) { - return like(conditional.getQuery()); - } - - @NonNull - @Override - public Operator glob(@NonNull IConditional conditional) { - return glob(conditional.getQuery()); - } - - @NonNull - @Override - public Operator greaterThan(@NonNull IConditional conditional) { - return assignValueOp(conditional, Operation.GREATER_THAN); - } - - @NonNull - @Override - public Operator greaterThanOrEq(@NonNull IConditional conditional) { - return assignValueOp(conditional, Operation.GREATER_THAN_OR_EQUALS); - } - - @NonNull - @Override - public Operator lessThan(@NonNull IConditional conditional) { - return assignValueOp(conditional, Operation.LESS_THAN); - } - - @NonNull - @Override - public Operator lessThanOrEq(@NonNull IConditional conditional) { - return assignValueOp(conditional, Operation.LESS_THAN_OR_EQUALS); - } - - @NonNull - @SuppressWarnings("unchecked") - @Override - public Between between(@NonNull IConditional conditional) { - return new Between(this, conditional); - } - - @NonNull - @SuppressWarnings("unchecked") - @Override - public In in(@NonNull IConditional firstConditional, @NonNull IConditional... conditionals) { - return new In(this, firstConditional, true, conditionals); - } - - @NonNull - @SuppressWarnings("unchecked") - @Override - public In notIn(@NonNull IConditional firstConditional, @NonNull IConditional... conditionals) { - return new In(this, firstConditional, false, conditionals); - } - - @NonNull - @SuppressWarnings("unchecked") - @Override - public In notIn(@NonNull BaseModelQueriable firstBaseModelQueriable, @NonNull BaseModelQueriable[] baseModelQueriables) { - return new In(this, firstBaseModelQueriable, false, (Object[]) baseModelQueriables); - } - - @NonNull - @Override - public Operator is(@NonNull BaseModelQueriable baseModelQueriable) { - return assignValueOp(baseModelQueriable, Operation.EQUALS); - } - - @NonNull - @Override - public Operator eq(@NonNull BaseModelQueriable baseModelQueriable) { - return assignValueOp(baseModelQueriable, Operation.EQUALS); - } - - @NonNull - @Override - public Operator isNot(@NonNull BaseModelQueriable baseModelQueriable) { - return assignValueOp(baseModelQueriable, Operation.NOT_EQUALS); - } - - @NonNull - @Override - public Operator notEq(@NonNull BaseModelQueriable baseModelQueriable) { - return assignValueOp(baseModelQueriable, Operation.NOT_EQUALS); - } - - @NonNull - @Override - public Operator like(@NonNull BaseModelQueriable baseModelQueriable) { - return assignValueOp(baseModelQueriable, Operation.LIKE); - } - - @NonNull - @Override - public Operator notLike(@NonNull IConditional conditional) { - return assignValueOp(conditional, Operation.NOT_LIKE); - } - - @NonNull - @Override - public Operator notLike(@NonNull BaseModelQueriable baseModelQueriable) { - return assignValueOp(baseModelQueriable, Operation.NOT_LIKE); - } - - @NonNull - @Override - public Operator glob(@NonNull BaseModelQueriable baseModelQueriable) { - return assignValueOp(baseModelQueriable, Operation.GLOB); - } - - @NonNull - @Override - public Operator greaterThan(@NonNull BaseModelQueriable baseModelQueriable) { - return assignValueOp(baseModelQueriable, Operation.GREATER_THAN); - } - - @NonNull - @Override - public Operator greaterThanOrEq(@NonNull BaseModelQueriable baseModelQueriable) { - return assignValueOp(baseModelQueriable, Operation.GREATER_THAN_OR_EQUALS); - } - - @NonNull - @Override - public Operator lessThan(@NonNull BaseModelQueriable baseModelQueriable) { - return assignValueOp(baseModelQueriable, Operation.LESS_THAN); - } - - @NonNull - @Override - public Operator lessThanOrEq(@NonNull BaseModelQueriable baseModelQueriable) { - return assignValueOp(baseModelQueriable, Operation.LESS_THAN_OR_EQUALS); - } - - @NonNull - public Operator plus(IConditional value) { - return assignValueOp(value, Operation.PLUS); - } - - @NonNull - public Operator minus(IConditional value) { - return assignValueOp(value, Operation.MINUS); - } - - @NonNull - public Operator div(IConditional value) { - return assignValueOp(value, Operation.DIVISION); - } - - @NonNull - public Operator times(IConditional value) { - return assignValueOp(value, Operation.MULTIPLY); - } - - @NonNull - public Operator rem(IConditional value) { - return assignValueOp(value, Operation.MOD); - } - - @NonNull - @Override - public Operator plus(@NonNull BaseModelQueriable value) { - return assignValueOp(value, Operation.PLUS); - } - - @NonNull - @Override - public Operator minus(@NonNull BaseModelQueriable value) { - return assignValueOp(value, Operation.MINUS); - } - - @NonNull - @Override - public Operator div(@NonNull BaseModelQueriable value) { - return assignValueOp(value, Operation.DIVISION); - } - - @NonNull - @Override - public Operator times(@NonNull BaseModelQueriable value) { - return assignValueOp(value, Operation.MULTIPLY); - } - - @NonNull - @Override - public Operator rem(@NonNull BaseModelQueriable value) { - return assignValueOp(value, Operation.MOD); - } - - @NonNull - @SuppressWarnings("unchecked") - @Override - public Between between(@NonNull BaseModelQueriable baseModelQueriable) { - return new Between(this, baseModelQueriable); - } - - @NonNull - @SuppressWarnings("unchecked") - @Override - public In in(@NonNull BaseModelQueriable firstBaseModelQueriable, @NonNull BaseModelQueriable... baseModelQueriables) { - return new In(this, firstBaseModelQueriable, true, baseModelQueriables); - } - - @Override - public String getQuery() { - QueryBuilder queryBuilder = new QueryBuilder(); - appendConditionToQuery(queryBuilder); - return queryBuilder.getQuery(); - } - - @NonNull - @SuppressWarnings("unchecked") - @Override - public Operator concatenate(@Nullable Object value) { - operation = new QueryBuilder(Operation.EQUALS).append(columnName()).toString(); - - TypeConverter typeConverter = this.typeConverter; - if (typeConverter == null && value != null) { - typeConverter = FlowManager.getTypeConverterForClass(value.getClass()); - } - if (typeConverter != null && convertToDB) { - value = typeConverter.getDBValue(value); - } - if (value instanceof String || value instanceof IOperator - || value instanceof Character) { - operation = String.format("%1s %1s ", operation, Operation.CONCATENATE); - } else if (value instanceof Number) { - operation = String.format("%1s %1s ", operation, Operation.PLUS); - } else { - throw new IllegalArgumentException( - String.format("Cannot concatenate the %1s", value != null ? value.getClass() : "null")); - } - this.value = value; - isValueSet = true; - return this; - } - - @NonNull - @Override - public Operator concatenate(@NonNull IConditional conditional) { - return concatenate((Object) conditional); - } - - /** - * Turns this condition into a SQL BETWEEN operation - * - * @param value The value of the first argument of the BETWEEN clause - * @return Between operator - */ - @NonNull - @Override - public Between between(@NonNull T value) { - return new Between<>(this, value); - } - - @NonNull - @SafeVarargs - @Override - public final In in(@NonNull T firstArgument, T... arguments) { - return new In<>(this, firstArgument, true, arguments); - } - - @NonNull - @SafeVarargs - @Override - public final In notIn(@NonNull T firstArgument, T... arguments) { - return new In<>(this, firstArgument, false, arguments); - } - - @NonNull - @Override - public In in(@NonNull Collection values) { - return new In<>(this, values, true); - } - - @NonNull - @Override - public In notIn(@NonNull Collection values) { - return new In<>(this, values, false); - } - - @SuppressWarnings("unchecked") - @Override - public String convertObjectToString(Object object, boolean appendInnerParenthesis) { - if (typeConverter != null) { - Object converted = object; - try { - converted = convertToDB ? typeConverter.getDBValue(object) : object; - } catch (ClassCastException c) { - // if object type is not valid converted type, just use type as is here. - FlowLog.log(FlowLog.Level.W, c); - } - return BaseOperator.convertValueToString(converted, appendInnerParenthesis, false); - } else { - return super.convertObjectToString(object, appendInnerParenthesis); - } - } - - private Operator assignValueOp(Object value, String operation) { - this.operation = operation; - return value(value); - } - - /** - * Static constants that define condition operations - */ - public static class Operation { - - /** - * Equals comparison - */ - public static final String EQUALS = "="; - - /** - * Not-equals comparison - */ - public static final String NOT_EQUALS = "!="; - - /** - * String concatenation - */ - public static final String CONCATENATE = "||"; - - /** - * Number addition - */ - public static final String PLUS = "+"; - - /** - * Number subtraction - */ - public static final String MINUS = "-"; - - public static final String DIVISION = "/"; - - public static final String MULTIPLY = "*"; - - public static final String MOD = "%"; - - /** - * If something is LIKE another (a case insensitive search). - * There are two wildcards: % and _ - * % represents [0,many) numbers or characters. - * The _ represents a single number or character. - */ - public static final String LIKE = "LIKE"; - - /** - * If something is NOT LIKE another (a case insensitive search). - * There are two wildcards: % and _ - * % represents [0,many) numbers or characters. - * The _ represents a single number or character. - */ - public static final String NOT_LIKE = "NOT LIKE"; - - /** - * If something is case sensitive like another. - * It must be a string to escape it properly. - * There are two wildcards: * and ? - * * represents [0,many) numbers or characters. - * The ? represents a single number or character - */ - public static final String GLOB = "GLOB"; - - /** - * Greater than some value comparison - */ - public static final String GREATER_THAN = ">"; - - /** - * Greater than or equals to some value comparison - */ - public static final String GREATER_THAN_OR_EQUALS = ">="; - - /** - * Less than some value comparison - */ - public static final String LESS_THAN = "<"; - - /** - * Less than or equals to some value comparison - */ - public static final String LESS_THAN_OR_EQUALS = "<="; - - /** - * Between comparison. A simplification of X<Y AND Y<Z to Y BETWEEN X AND Z - */ - public static final String BETWEEN = "BETWEEN"; - - /** - * AND comparison separator - */ - public static final String AND = "AND"; - - /** - * OR comparison separator - */ - public static final String OR = "OR"; - - /** - * An empty value for the condition. - */ - public static final String EMPTY_PARAM = "?"; - - /** - * Special operation that specify if the column is not null for a specified row. Use of this as - * an operator will ignore the value of the {@link Operator} for it. - */ - public static final String IS_NOT_NULL = "IS NOT NULL"; - - /** - * Special operation that specify if the column is null for a specified row. Use of this as - * an operator will ignore the value of the {@link Operator} for it. - */ - public static final String IS_NULL = "IS NULL"; - - /** - * The SQLite IN command that will select rows that are contained in a list of values. - * EX: SELECT * from Table where column IN ('first', 'second', etc) - */ - public static final String IN = "IN"; - - /** - * The reverse of the {@link #IN} command that selects rows that are not contained - * in a list of values specified. - */ - public static final String NOT_IN = "NOT IN"; - } - - /** - * The SQL BETWEEN operator that contains two values instead of the normal 1. - */ - public static class Between extends BaseOperator implements Query { - - @Nullable - private T secondValue; - - /** - * Creates a new instance - * - * @param operator - * @param value The value of the first argument of the BETWEEN clause - */ - private Between(Operator operator, T value) { - super(operator.nameAlias); - this.operation = String.format(" %1s ", Operation.BETWEEN); - this.value = value; - isValueSet = true; - this.postArg = operator.postArgument(); - } - - @NonNull - public Between and(@Nullable T secondValue) { - this.secondValue = secondValue; - return this; - } - - @Nullable - public T secondValue() { - return secondValue; - } - - @Override - public void appendConditionToQuery(@NonNull QueryBuilder queryBuilder) { - queryBuilder.append(columnName()).append(operation()) - .append(convertObjectToString(value(), true)) - .appendSpaceSeparated(Operation.AND) - .append(convertObjectToString(secondValue(), true)) - .appendSpace().appendOptional(postArgument()); - } - - @Override - public String getQuery() { - QueryBuilder builder = new QueryBuilder(); - appendConditionToQuery(builder); - return builder.getQuery(); - } - } - - /** - * The SQL IN and NOT IN operator that specifies a list of values to SELECT rows from. - * EX: SELECT * FROM myTable WHERE columnName IN ('column1','column2','etc') - */ - public static class In extends BaseOperator implements Query { - - private List inArguments = new ArrayList<>(); - - /** - * Creates a new instance - * - * @param operator The operator object to pass in. We only use the column name here. - * @param firstArgument The first value in the IN query as one is required. - * @param isIn if this is an {@link Operator.Operation#IN} - * statement or a {@link Operator.Operation#NOT_IN} - */ - @SafeVarargs - private In(Operator operator, T firstArgument, boolean isIn, T... arguments) { - super(operator.columnAlias()); - inArguments.add(firstArgument); - Collections.addAll(inArguments, arguments); - operation = String.format(" %1s ", isIn ? Operation.IN : Operation.NOT_IN); - } - - private In(Operator operator, Collection args, boolean isIn) { - super(operator.columnAlias()); - inArguments.addAll(args); - operation = String.format(" %1s ", isIn ? Operation.IN : Operation.NOT_IN); - } - - /** - * Appends another value to this In statement - * - * @param argument The non-type converted value of the object. The value will be converted - * in a {@link OperatorGroup}. - * @return - */ - @NonNull - public In and(@Nullable T argument) { - inArguments.add(argument); - return this; - } - - @Override - public void appendConditionToQuery(@NonNull QueryBuilder queryBuilder) { - queryBuilder.append(columnName()).append(operation()) - .append("(").append(OperatorGroup.joinArguments(",", inArguments, this)).append(")"); - } - - @Override - public String getQuery() { - QueryBuilder builder = new QueryBuilder(); - appendConditionToQuery(builder); - return builder.getQuery(); - } - } - -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Operator.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Operator.kt new file mode 100644 index 000000000..2999cdafb --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Operator.kt @@ -0,0 +1,626 @@ +package com.raizlabs.android.dbflow.sql.language + +import com.raizlabs.android.dbflow.annotation.Collate +import com.raizlabs.android.dbflow.config.FlowLog +import com.raizlabs.android.dbflow.config.FlowManager +import com.raizlabs.android.dbflow.converter.TypeConverter +import com.raizlabs.android.dbflow.sql.Query +import com.raizlabs.android.dbflow.sql.QueryBuilder +import com.raizlabs.android.dbflow.sql.language.property.Property +import java.util.* + +/** + * Description: The class that contains a column name, Operator, and value. + * This class is mostly reserved for internal use at this point. Using this class directly should be avoided + * and use the generated [Property] instead. + */ +class Operator : BaseOperator, IOperator { + + private var typeConverter: TypeConverter<*, *>? = null + private var convertToDB: Boolean = false + + override val query: String + get() { + val queryBuilder = QueryBuilder() + appendConditionToQuery(queryBuilder) + return queryBuilder.query + } + + /** + * Creates a new instance + * + * @param nameAlias The name of the column in the DB + */ + internal constructor(nameAlias: NameAlias) : super(nameAlias) + + internal constructor(alias: NameAlias, typeConverter: TypeConverter<*, *>, convertToDB: Boolean) : super(alias) { + this.typeConverter = typeConverter + this.convertToDB = convertToDB + } + + internal constructor(operator: Operator<*>) : super(operator.nameAlias) { + this.typeConverter = operator.typeConverter + this.convertToDB = operator.convertToDB + this.value = operator.value + } + + override fun appendConditionToQuery(queryBuilder: QueryBuilder) { + queryBuilder.append(columnName()).append(operation()) + + // Do not use value for certain operators + // If is raw, we do not want to convert the value to a string. + if (isValueSet) { + queryBuilder.append(convertObjectToString(value(), true)) + } + + if (postArgument() != null) { + queryBuilder.appendSpace().append(postArgument()) + } + } + + override fun isNull() = apply { + operation = " ${Operation.IS_NULL} " + } + + override fun isNotNull() = apply { + operation = " ${Operation.IS_NOT_NULL} " + } + + override fun `is`(value: T?): Operator { + operation = Operation.EQUALS + return value(value) + } + + override fun eq(value: T?): Operator = `is`(value) + + override fun isNot(value: T?): Operator { + operation = Operation.NOT_EQUALS + return value(value) + } + + override fun notEq(value: T?): Operator = isNot(value) + + /** + * Uses the LIKE operation. Case insensitive comparisons. + * + * @param value Uses sqlite LIKE regex to match rows. + * It must be a string to escape it properly. + * There are two wildcards: % and _ + * % represents [0,many) numbers or characters. + * The _ represents a single number or character. + * @return This condition + */ + override fun like(value: String): Operator { + operation = String.format(" %1s ", Operation.LIKE) + return value(value) + } + + /** + * Uses the NOT LIKE operation. Case insensitive comparisons. + * + * @param value Uses sqlite LIKE regex to inversely match rows. + * It must be a string to escape it properly. + * There are two wildcards: % and _ + * % represents [0,many) numbers or characters. + * The _ represents a single number or character. + * @return This condition + */ + override fun notLike(value: String): Operator { + operation = String.format(" %1s ", Operation.NOT_LIKE) + return value(value) + } + + /** + * Uses the GLOB operation. Similar to LIKE except it uses case sensitive comparisons. + * + * @param value Uses sqlite GLOB regex to match rows. + * It must be a string to escape it properly. + * There are two wildcards: * and ? + * * represents [0,many) numbers or characters. + * The ? represents a single number or character + * @return This condition + */ + override fun glob(value: String): Operator { + operation = String.format(" %1s ", Operation.GLOB) + return value(value) + } + + /** + * The value of the parameter + * + * @param value The value of the column in the DB + * @return This condition + */ + fun value(value: Any?) = apply { + this.value = value + isValueSet = true + } + + override fun greaterThan(value: T): Operator { + operation = Operation.GREATER_THAN + return value(value) + } + + override fun greaterThanOrEq(value: T): Operator { + operation = Operation.GREATER_THAN_OR_EQUALS + return value(value) + } + + override fun lessThan(value: T): Operator { + operation = Operation.LESS_THAN + return value(value) + } + + override fun lessThanOrEq(value: T): Operator { + operation = Operation.LESS_THAN_OR_EQUALS + return value(value) + } + + override fun plus(value: T): Operator = assignValueOp(value, Operation.PLUS) + + override fun minus(value: T): Operator = assignValueOp(value, Operation.MINUS) + + override fun div(value: T): Operator = assignValueOp(value, Operation.DIVISION) + + override fun times(value: T): Operator = assignValueOp(value, Operation.MULTIPLY) + + override fun rem(value: T): Operator = assignValueOp(value, Operation.MOD) + + /** + * Add a custom operation to this argument + * + * @param operation The SQLite operator + * @return This condition + */ + fun operation(operation: String) = apply { + this.operation = operation + } + + /** + * Adds a COLLATE to the end of this condition + * + * @param collation The SQLite collate function + * @return This condition. + */ + fun collate(collation: String) = apply { + postArg = "COLLATE " + collation + } + + /** + * Adds a COLLATE to the end of this condition using the [com.raizlabs.android.dbflow.annotation.Collate] enum. + * + * @param collation The SQLite collate function + * @return This condition. + */ + fun collate(collation: Collate) = apply { + if (collation == Collate.NONE) { + postArg = null + } else { + collate(collation.name) + } + } + + /** + * Appends an optional SQL string to the end of this condition + */ + fun postfix(postfix: String) = apply { + postArg = postfix + } + + /** + * Optional separator when chaining this Operator within a [OperatorGroup] + * + * @param separator The separator to use + * @return This instance + */ + override fun separator(separator: String) = apply { + this.separator = separator + } + + override fun `is`(conditional: IConditional): Operator<*> = + assignValueOp(conditional, Operation.EQUALS) + + override fun eq(conditional: IConditional): Operator<*> = + assignValueOp(conditional, Operation.EQUALS) + + override fun isNot(conditional: IConditional): Operator<*> = + assignValueOp(conditional, Operation.NOT_EQUALS) + + override fun notEq(conditional: IConditional): Operator<*> = + assignValueOp(conditional, Operation.NOT_EQUALS) + + override fun like(conditional: IConditional): Operator = like(conditional.query) + + override fun glob(conditional: IConditional): Operator = glob(conditional.query) + + override fun greaterThan(conditional: IConditional): Operator = + assignValueOp(conditional, Operation.GREATER_THAN) + + override fun greaterThanOrEq(conditional: IConditional): Operator = + assignValueOp(conditional, Operation.GREATER_THAN_OR_EQUALS) + + override fun lessThan(conditional: IConditional): Operator = + assignValueOp(conditional, Operation.LESS_THAN) + + override fun lessThanOrEq(conditional: IConditional): Operator = + assignValueOp(conditional, Operation.LESS_THAN_OR_EQUALS) + + override fun between(conditional: IConditional): Between<*> = Between(this, conditional) + + override fun `in`(firstConditional: IConditional, vararg conditionals: IConditional): In<*> = + In(this, firstConditional, true, *conditionals) + + override fun notIn(firstConditional: IConditional, vararg conditionals: IConditional): In<*> = + In(this, firstConditional, false, *conditionals) + + override fun notIn(firstBaseModelQueriable: BaseModelQueriable<*>, + vararg baseModelQueriables: BaseModelQueriable<*>): In<*> = + In(this, firstBaseModelQueriable, false, *baseModelQueriables) + + override fun `is`(baseModelQueriable: BaseModelQueriable<*>): Operator<*> = + assignValueOp(baseModelQueriable, Operation.EQUALS) + + override fun eq(baseModelQueriable: BaseModelQueriable<*>): Operator<*> = + assignValueOp(baseModelQueriable, Operation.EQUALS) + + override fun isNot(baseModelQueriable: BaseModelQueriable<*>): Operator<*> = + assignValueOp(baseModelQueriable, Operation.NOT_EQUALS) + + override fun notEq(baseModelQueriable: BaseModelQueriable<*>): Operator<*> = + assignValueOp(baseModelQueriable, Operation.NOT_EQUALS) + + override fun like(baseModelQueriable: BaseModelQueriable<*>): Operator = + assignValueOp(baseModelQueriable, Operation.LIKE) + + override fun notLike(conditional: IConditional): Operator<*> = + assignValueOp(conditional, Operation.NOT_LIKE) + + override fun notLike(baseModelQueriable: BaseModelQueriable<*>): Operator<*> = + assignValueOp(baseModelQueriable, Operation.NOT_LIKE) + + override fun glob(baseModelQueriable: BaseModelQueriable<*>): Operator = + assignValueOp(baseModelQueriable, Operation.GLOB) + + override fun greaterThan(baseModelQueriable: BaseModelQueriable<*>): Operator = + assignValueOp(baseModelQueriable, Operation.GREATER_THAN) + + override fun greaterThanOrEq(baseModelQueriable: BaseModelQueriable<*>): Operator = + assignValueOp(baseModelQueriable, Operation.GREATER_THAN_OR_EQUALS) + + override fun lessThan(baseModelQueriable: BaseModelQueriable<*>): Operator = + assignValueOp(baseModelQueriable, Operation.LESS_THAN) + + override fun lessThanOrEq(baseModelQueriable: BaseModelQueriable<*>): Operator = + assignValueOp(baseModelQueriable, Operation.LESS_THAN_OR_EQUALS) + + operator fun plus(value: IConditional): Operator<*> = assignValueOp(value, Operation.PLUS) + + operator fun minus(value: IConditional): Operator<*> = assignValueOp(value, Operation.MINUS) + + operator fun div(value: IConditional): Operator<*> = assignValueOp(value, Operation.DIVISION) + + operator fun times(value: IConditional): Operator<*> = assignValueOp(value, Operation.MULTIPLY) + + operator fun rem(value: IConditional): Operator<*> = assignValueOp(value, Operation.MOD) + + override fun plus(value: BaseModelQueriable<*>): Operator<*> = + assignValueOp(value, Operation.PLUS) + + override fun minus(value: BaseModelQueriable<*>): Operator<*> = + assignValueOp(value, Operation.MINUS) + + override fun div(value: BaseModelQueriable<*>): Operator<*> = + assignValueOp(value, Operation.DIVISION) + + override fun times(value: BaseModelQueriable<*>): Operator<*> = + assignValueOp(value, Operation.MULTIPLY) + + override fun rem(value: BaseModelQueriable<*>): Operator<*> = + assignValueOp(value, Operation.MOD) + + override fun between(baseModelQueriable: BaseModelQueriable<*>): Between<*> = + Between(this, baseModelQueriable) + + override fun `in`(firstBaseModelQueriable: BaseModelQueriable<*>, vararg baseModelQueriables: BaseModelQueriable<*>): In<*> = + In>(this, firstBaseModelQueriable, true, *baseModelQueriables) + + override fun concatenate(value: T?): Operator { + var _value = value + operation = QueryBuilder(Operation.EQUALS).append(columnName()).toString() + + var typeConverter: TypeConverter<*, *>? = this.typeConverter + if (typeConverter == null && _value != null) { + typeConverter = FlowManager.getTypeConverterForClass(_value.javaClass) + } + if (typeConverter != null && convertToDB) { + _value = typeConverter.getDBValue(_value) + } + operation = when (_value) { + is String, is IOperator<*>, is Char -> "$operation ${Operation.CONCATENATE} " + is Number -> "$operation ${Operation.PLUS} " + else -> throw IllegalArgumentException( + "Cannot concatenate the ${if (_value != null) _value.javaClass else "null"}" + } + this.value = _value + isValueSet = true + return this + } + + override fun concatenate(conditional: IConditional): Operator = + concatenate(conditional as Any) + + /** + * Turns this condition into a SQL BETWEEN operation + * + * @param value The value of the first argument of the BETWEEN clause + * @return Between operator + */ + override fun between(value: T): Between = Between(this, value) + + @SafeVarargs + override fun `in`(firstValue: T, vararg values: T): In = + In(this, firstValue, true, *values) + + @SafeVarargs + override fun notIn(firstValue: T, vararg values: T): In = + In(this, firstValue, false, *values) + + override fun `in`(values: Collection): In = In(this, values, true) + + override fun notIn(values: Collection): In = In(this, values, false) + + override fun convertObjectToString(`object`: Any?, appendInnerParenthesis: Boolean): String? { + if (typeConverter != null) { + var converted = `object` + try { + converted = if (convertToDB) typeConverter!!.getDBValue(`object`) else `object` + } catch (c: ClassCastException) { + // if object type is not valid converted type, just use type as is here. + FlowLog.log(FlowLog.Level.W, c) + } + + return BaseOperator.convertValueToString(converted, appendInnerParenthesis, false) + } else { + return super.convertObjectToString(`object`, appendInnerParenthesis) + } + } + + private fun assignValueOp(value: Any?, operation: String): Operator { + this.operation = operation + return value(value) + } + + /** + * Static constants that define condition operations + */ + object Operation { + + /** + * Equals comparison + */ + val EQUALS = "=" + + /** + * Not-equals comparison + */ + val NOT_EQUALS = "!=" + + /** + * String concatenation + */ + val CONCATENATE = "||" + + /** + * Number addition + */ + val PLUS = "+" + + /** + * Number subtraction + */ + val MINUS = "-" + + val DIVISION = "/" + + val MULTIPLY = "*" + + val MOD = "%" + + /** + * If something is LIKE another (a case insensitive search). + * There are two wildcards: % and _ + * % represents [0,many) numbers or characters. + * The _ represents a single number or character. + */ + val LIKE = "LIKE" + + /** + * If something is NOT LIKE another (a case insensitive search). + * There are two wildcards: % and _ + * % represents [0,many) numbers or characters. + * The _ represents a single number or character. + */ + val NOT_LIKE = "NOT LIKE" + + /** + * If something is case sensitive like another. + * It must be a string to escape it properly. + * There are two wildcards: * and ? + * * represents [0,many) numbers or characters. + * The ? represents a single number or character + */ + val GLOB = "GLOB" + + /** + * Greater than some value comparison + */ + val GREATER_THAN = ">" + + /** + * Greater than or equals to some value comparison + */ + val GREATER_THAN_OR_EQUALS = ">=" + + /** + * Less than some value comparison + */ + val LESS_THAN = "<" + + /** + * Less than or equals to some value comparison + */ + val LESS_THAN_OR_EQUALS = "<=" + + /** + * Between comparison. A simplification of X<Y AND Y<Z to Y BETWEEN X AND Z + */ + val BETWEEN = "BETWEEN" + + /** + * AND comparison separator + */ + val AND = "AND" + + /** + * OR comparison separator + */ + val OR = "OR" + + /** + * An empty value for the condition. + */ + val EMPTY_PARAM = "?" + + /** + * Special operation that specify if the column is not null for a specified row. Use of this as + * an operator will ignore the value of the [Operator] for it. + */ + val IS_NOT_NULL = "IS NOT NULL" + + /** + * Special operation that specify if the column is null for a specified row. Use of this as + * an operator will ignore the value of the [Operator] for it. + */ + val IS_NULL = "IS NULL" + + /** + * The SQLite IN command that will select rows that are contained in a list of values. + * EX: SELECT * from Table where column IN ('first', 'second', etc) + */ + val IN = "IN" + + /** + * The reverse of the [.IN] command that selects rows that are not contained + * in a list of values specified. + */ + val NOT_IN = "NOT IN" + } + + /** + * The SQL BETWEEN operator that contains two values instead of the normal 1. + */ + class Between + /** + * Creates a new instance + * + * @param operator + * @param value The value of the first argument of the BETWEEN clause + */ + internal constructor(operator: Operator, value: T) : BaseOperator(operator.nameAlias), Query { + + private var secondValue: T? = null + + override val query: String + get() { + val builder = QueryBuilder() + appendConditionToQuery(builder) + return builder.query + } + + init { + this.operation = " ${Operation.BETWEEN} " + this.value = value + isValueSet = true + this.postArg = operator.postArgument() + } + + fun and(secondValue: T?) = apply { + this.secondValue = secondValue + } + + fun secondValue(): T? = secondValue + + override fun appendConditionToQuery(queryBuilder: QueryBuilder) { + queryBuilder.append(columnName()).append(operation()) + .append(convertObjectToString(value(), true)) + .appendSpaceSeparated(Operation.AND) + .append(convertObjectToString(secondValue(), true)) + .appendSpace().appendOptional(postArgument()) + } + } + + /** + * The SQL IN and NOT IN operator that specifies a list of values to SELECT rows from. + * EX: SELECT * FROM myTable WHERE columnName IN ('column1','column2','etc') + */ + class In : BaseOperator, Query { + + private val inArguments = ArrayList() + + override val query: String + get() { + val builder = QueryBuilder() + appendConditionToQuery(builder) + return builder.query + } + + /** + * Creates a new instance + * + * @param operator The operator object to pass in. We only use the column name here. + * @param firstArgument The first value in the IN query as one is required. + * @param isIn if this is an [Operator.Operation.IN] + * statement or a [Operator.Operation.NOT_IN] + */ + @SafeVarargs + internal constructor(operator: Operator, firstArgument: T?, isIn: Boolean, vararg arguments: T?) : super(operator.columnAlias()) { + inArguments.add(firstArgument) + Collections.addAll(inArguments, *arguments) + operation = " ${if (isIn) Operation.IN else Operation.NOT_IN} " + } + + internal constructor(operator: Operator, args: Collection, isIn: Boolean) : super(operator.columnAlias()) { + inArguments.addAll(args) + operation = " ${if (isIn) Operation.IN else Operation.NOT_IN} " + } + + /** + * Appends another value to this In statement + * + * @param argument The non-type converted value of the object. The value will be converted + * in a [OperatorGroup]. + * @return + */ + fun and(argument: T?): In { + inArguments.add(argument) + return this + } + + override fun appendConditionToQuery(queryBuilder: QueryBuilder) { + queryBuilder.append(columnName()).append(operation()) + .append("(").append(BaseOperator.joinArguments(",", inArguments, this)).append(")") + } + } + + companion object { + + fun convertValueToString(value: Any): String? = + BaseOperator.convertValueToString(value, false) + + fun op(column: NameAlias): Operator = Operator(column) + + fun op(alias: NameAlias, typeConverter: TypeConverter<*, *>, convertToDB: Boolean): Operator = + Operator(alias, typeConverter, convertToDB) + } + +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/OperatorGroup.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/OperatorGroup.java deleted file mode 100644 index 11280ecf2..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/OperatorGroup.java +++ /dev/null @@ -1,241 +0,0 @@ -package com.raizlabs.android.dbflow.sql.language; - -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.sql.Query; -import com.raizlabs.android.dbflow.sql.QueryBuilder; -import com.raizlabs.android.dbflow.sql.language.Operator.Operation; - -import java.util.ArrayList; -import java.util.Collection; -import java.util.Iterator; -import java.util.List; - -/** - * Allows combining of {@link SQLOperator} into one condition. - */ -public class OperatorGroup extends BaseOperator implements Query, Iterable { - - /** - * @return Starts an arbitrary clause of conditions to use. - */ - @NonNull - public static OperatorGroup clause() { - return new OperatorGroup(); - } - - /** - * @return Starts an arbitrary clause of conditions to use with first param as conditions separated by AND. - */ - @NonNull - public static OperatorGroup clause(SQLOperator... condition) { - return new OperatorGroup().andAll(condition); - } - - /** - * @return Starts an arbitrary clause of conditions to use, that when included in other {@link SQLOperator}, - * does not append parenthesis to group it. - */ - public static OperatorGroup nonGroupingClause() { - return new OperatorGroup().setUseParenthesis(false); - } - - /** - * @return Starts an arbitrary clause of conditions (without parenthesis) to use with first param as conditions separated by AND. - */ - public static OperatorGroup nonGroupingClause(SQLOperator... condition) { - return new OperatorGroup().setUseParenthesis(false).andAll(condition); - } - - @NonNull - private final List conditionsList = new ArrayList<>(); - - private QueryBuilder query; - private boolean isChanged; - private boolean allCommaSeparated; - private boolean useParenthesis = true; - - protected OperatorGroup(NameAlias columnName) { - super(columnName); - - // default is AND - separator = Operation.AND; - } - - protected OperatorGroup() { - this(null); - } - - /** - * Will ignore all separators for the group and make them separated by comma. This is useful - * in {@link Set} statements. - * - * @param allCommaSeparated All become comma separated. - * @return This instance. - */ - @NonNull - public OperatorGroup setAllCommaSeparated(boolean allCommaSeparated) { - this.allCommaSeparated = allCommaSeparated; - isChanged = true; - return this; - } - - /** - * Sets whether we use paranthesis when grouping this within other {@link SQLOperator}. The default - * is true, but if no conditions exist there are no paranthesis anyways. - * - * @param useParenthesis true if we use them, false if not. - */ - @NonNull - public OperatorGroup setUseParenthesis(boolean useParenthesis) { - this.useParenthesis = useParenthesis; - isChanged = true; - return this; - } - - /** - * Appends the {@link SQLOperator} with an {@link Operation#OR} - * - * @param sqlOperator The condition to append. - * @return This instance. - */ - @NonNull - public OperatorGroup or(SQLOperator sqlOperator) { - return operator(Operation.OR, sqlOperator); - } - - /** - * Appends the {@link SQLOperator} with an {@link Operation#AND} - */ - @NonNull - public OperatorGroup and(SQLOperator sqlOperator) { - return operator(Operation.AND, sqlOperator); - } - - /** - * Applies the {@link Operation#AND} to all of the passed - * {@link SQLOperator}. - */ - @NonNull - public OperatorGroup andAll(SQLOperator... sqlOperators) { - for (SQLOperator sqlOperator : sqlOperators) { - and(sqlOperator); - } - return this; - } - - /** - * Applies the {@link Operation#AND} to all of the passed - * {@link SQLOperator}. - */ - @NonNull - public OperatorGroup andAll(Collection sqlOperators) { - for (SQLOperator sqlOperator : sqlOperators) { - and(sqlOperator); - } - return this; - } - - /** - * Applies the {@link Operation#AND} to all of the passed - * {@link SQLOperator}. - */ - @NonNull - public OperatorGroup orAll(SQLOperator... sqlOperators) { - for (SQLOperator sqlOperator : sqlOperators) { - or(sqlOperator); - } - return this; - } - - /** - * Applies the {@link Operation#AND} to all of the passed - * {@link SQLOperator}. - */ - @NonNull - public OperatorGroup orAll(Collection sqlOperators) { - for (SQLOperator sqlOperator : sqlOperators) { - or(sqlOperator); - } - return this; - } - - /** - * Appends the {@link SQLOperator} with the specified operator string. - */ - @NonNull - private OperatorGroup operator(String operator, @Nullable SQLOperator sqlOperator) { - if (sqlOperator != null) { - setPreviousSeparator(operator); - conditionsList.add(sqlOperator); - isChanged = true; - } - return this; - } - - @Override - public void appendConditionToQuery(@NonNull QueryBuilder queryBuilder) { - int conditionListSize = conditionsList.size(); - if (useParenthesis && conditionListSize > 0) { - queryBuilder.append("("); - } - for (int i = 0; i < conditionListSize; i++) { - SQLOperator condition = conditionsList.get(i); - condition.appendConditionToQuery(queryBuilder); - if (!allCommaSeparated && condition.hasSeparator() && i < conditionListSize - 1) { - queryBuilder.appendSpaceSeparated(condition.separator()); - } else if (i < conditionListSize - 1) { - queryBuilder.append(", "); - } - } - if (useParenthesis && conditionListSize > 0) { - queryBuilder.append(")"); - } - } - - /** - * Sets the last condition to use the separator specified - * - * @param separator AND, OR, etc. - */ - private void setPreviousSeparator(String separator) { - if (conditionsList.size() > 0) { - // set previous to use OR separator - conditionsList.get(conditionsList.size() - 1).separator(separator); - } - } - - @Override - public String getQuery() { - if (isChanged) { - query = getQuerySafe(); - } - return query == null ? "" : query.toString(); - } - - @Override - public String toString() { - return getQuerySafe().toString(); - } - - public int size() { - return conditionsList.size(); - } - - @NonNull - public List getConditions() { - return conditionsList; - } - - @Override - public Iterator iterator() { - return conditionsList.iterator(); - } - - private QueryBuilder getQuerySafe() { - QueryBuilder query = new QueryBuilder(); - appendConditionToQuery(query); - return query; - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/OperatorGroup.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/OperatorGroup.kt new file mode 100644 index 000000000..79545ef9c --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/OperatorGroup.kt @@ -0,0 +1,192 @@ +package com.raizlabs.android.dbflow.sql.language + +import com.raizlabs.android.dbflow.sql.Query +import com.raizlabs.android.dbflow.sql.QueryBuilder +import com.raizlabs.android.dbflow.sql.language.Operator.Operation +import java.util.* + +/** + * Allows combining of [SQLOperator] into one condition. + */ +class OperatorGroup +@JvmOverloads +constructor(columnName: NameAlias? = null) : BaseOperator(columnName), Query, Iterable { + + private val conditionsList = ArrayList() + + private var internalQuery: QueryBuilder? = null + private var isChanged: Boolean = false + private var allCommaSeparated: Boolean = false + private var useParenthesis = true + + val conditions: List + get() = conditionsList + + private val querySafe: QueryBuilder + get() { + val query = QueryBuilder() + appendConditionToQuery(query) + return query + } + + init { + + // default is AND + separator = Operation.AND + } + + /** + * Will ignore all separators for the group and make them separated by comma. This is useful + * in [Set] statements. + * + * @param allCommaSeparated All become comma separated. + * @return This instance. + */ + fun setAllCommaSeparated(allCommaSeparated: Boolean) = apply { + this.allCommaSeparated = allCommaSeparated + isChanged = true + } + + /** + * Sets whether we use paranthesis when grouping this within other [SQLOperator]. The default + * is true, but if no conditions exist there are no paranthesis anyways. + * + * @param useParenthesis true if we use them, false if not. + */ + fun setUseParenthesis(useParenthesis: Boolean) = apply { + this.useParenthesis = useParenthesis + isChanged = true + } + + /** + * Appends the [SQLOperator] with an [Operation.OR] + * + * @param sqlOperator The condition to append. + * @return This instance. + */ + fun or(sqlOperator: SQLOperator): OperatorGroup = operator(Operation.OR, sqlOperator) + + /** + * Appends the [SQLOperator] with an [Operation.AND] + */ + fun and(sqlOperator: SQLOperator): OperatorGroup = operator(Operation.AND, sqlOperator) + + /** + * Applies the [Operation.AND] to all of the passed + * [SQLOperator]. + */ + fun andAll(vararg sqlOperators: SQLOperator) = apply { + sqlOperators.forEach { and(it) } + } + + /** + * Applies the [Operation.AND] to all of the passed + * [SQLOperator]. + */ + fun andAll(sqlOperators: Collection) = apply { + sqlOperators.forEach { and(it) } + } + + /** + * Applies the [Operation.AND] to all of the passed + * [SQLOperator]. + */ + fun orAll(vararg sqlOperators: SQLOperator) = apply { + sqlOperators.forEach { or(it) } + } + + /** + * Applies the [Operation.AND] to all of the passed + * [SQLOperator]. + */ + fun orAll(sqlOperators: Collection) = apply { + sqlOperators.forEach { or(it) } + } + + /** + * Appends the [SQLOperator] with the specified operator string. + */ + private fun operator(operator: String, sqlOperator: SQLOperator?) = apply { + if (sqlOperator != null) { + setPreviousSeparator(operator) + conditionsList.add(sqlOperator) + isChanged = true + } + } + + override fun appendConditionToQuery(queryBuilder: QueryBuilder) { + val conditionListSize = conditionsList.size + if (useParenthesis && conditionListSize > 0) { + queryBuilder.append("(") + } + for (i in 0 until conditionListSize) { + val condition = conditionsList[i] + condition.appendConditionToQuery(queryBuilder) + if (!allCommaSeparated && condition.hasSeparator() && i < conditionListSize - 1) { + queryBuilder.appendSpaceSeparated(condition.separator()) + } else if (i < conditionListSize - 1) { + queryBuilder.append(", ") + } + } + if (useParenthesis && conditionListSize > 0) { + queryBuilder.append(")") + } + } + + /** + * Sets the last condition to use the separator specified + * + * @param separator AND, OR, etc. + */ + private fun setPreviousSeparator(separator: String) { + if (conditionsList.size > 0) { + // set previous to use OR separator + conditionsList[conditionsList.size - 1].separator(separator) + } + } + + override val query: String + get() { + if (isChanged) { + internalQuery = querySafe + } + return if (internalQuery == null) "" else internalQuery.toString() + } + + override fun toString(): String = querySafe.toString() + + val size: Int + get() = conditionsList.size + + override fun iterator(): Iterator = conditionsList.iterator() + + companion object { + + /** + * @return Starts an arbitrary clause of conditions to use. + */ + @JvmStatic + fun clause(): OperatorGroup = OperatorGroup() + + /** + * @return Starts an arbitrary clause of conditions to use with first param as conditions separated by AND. + */ + @JvmStatic + fun clause(vararg condition: SQLOperator): OperatorGroup = + OperatorGroup().andAll(*condition) + + /** + * @return Starts an arbitrary clause of conditions to use, that when included in other [SQLOperator], + * does not append parenthesis to group it. + */ + @JvmStatic + fun nonGroupingClause(): OperatorGroup = OperatorGroup().setUseParenthesis(false) + + /** + * @return Starts an arbitrary clause of conditions (without parenthesis) to use with first param as conditions separated by AND. + */ + @JvmStatic + fun nonGroupingClause(vararg condition: SQLOperator): OperatorGroup = + OperatorGroup().setUseParenthesis(false).andAll(*condition) + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/OrderBy.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/OrderBy.java deleted file mode 100644 index 6b21c0f1a..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/OrderBy.java +++ /dev/null @@ -1,91 +0,0 @@ -package com.raizlabs.android.dbflow.sql.language; - -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.annotation.Collate; -import com.raizlabs.android.dbflow.sql.Query; -import com.raizlabs.android.dbflow.sql.language.property.IProperty; - -/** - * Description: Class that represents a SQL order-by. - */ -public class OrderBy implements Query { - - public static final String ASCENDING = "ASC"; - - public static final String DESCENDING = "DESC"; - - private NameAlias column; - - private boolean isAscending; - - private Collate collation; - private String orderByString; - - @NonNull - public static OrderBy fromProperty(@NonNull IProperty property) { - return new OrderBy(property.getNameAlias()); - } - - @NonNull - public static OrderBy fromNameAlias(@NonNull NameAlias nameAlias) { - return new OrderBy(nameAlias); - } - - @NonNull - public static OrderBy fromString(@NonNull String orderByString) { - return new OrderBy(orderByString); - } - - OrderBy(NameAlias column) { - this.column = column; - } - - OrderBy(NameAlias column, boolean isAscending) { - this(column); - this.isAscending = isAscending; - } - - OrderBy(String orderByString) { - this.orderByString = orderByString; - } - - @NonNull - public OrderBy ascending() { - isAscending = true; - return this; - } - - @NonNull - public OrderBy descending() { - isAscending = false; - return this; - } - - @NonNull - public OrderBy collate(Collate collate) { - this.collation = collate; - return this; - } - - @Override - public String getQuery() { - if (orderByString == null) { - StringBuilder query = new StringBuilder() - .append(column) - .append(" "); - if (collation != null) { - query.append("COLLATE").append(" ").append(collation).append(" "); - } - query.append(isAscending ? ASCENDING : DESCENDING); - return query.toString(); - } else { - return orderByString; - } - } - - @Override - public String toString() { - return getQuery(); - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/OrderBy.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/OrderBy.kt new file mode 100644 index 000000000..39084905e --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/OrderBy.kt @@ -0,0 +1,73 @@ +package com.raizlabs.android.dbflow.sql.language + +import com.raizlabs.android.dbflow.annotation.Collate +import com.raizlabs.android.dbflow.sql.Query +import com.raizlabs.android.dbflow.sql.language.property.IProperty + +/** + * Description: Class that represents a SQL order-by. + */ +class OrderBy +@JvmOverloads +constructor(private val column: NameAlias? = null, + private var isAscending: Boolean = false) : Query { + + private var collation: Collate? = null + private var orderByString: String? + + override val query: String + get() { + if (orderByString == null) { + val query = StringBuilder() + .append(column) + .append(" ") + if (collation != null) { + query.append("COLLATE").append(" ").append(collation).append(" ") + } + query.append(if (isAscending) ASCENDING else DESCENDING) + return query.toString() + } else { + return orderByString!! + } + } + + internal constructor(orderByString: String) : this(column = null) { + this.orderByString = orderByString + } + + init { + this.orderByString = null + } + + fun ascending() = apply { + isAscending = true + } + + fun descending() = apply { + isAscending = false + } + + fun collate(collate: Collate) = apply { + this.collation = collate + } + + override fun toString(): String = query + + companion object { + + @JvmField + val ASCENDING = "ASC" + + @JvmField + val DESCENDING = "DESC" + + @JvmStatic + fun fromProperty(property: IProperty<*>): OrderBy = OrderBy(property.nameAlias) + + @JvmStatic + fun fromNameAlias(nameAlias: NameAlias): OrderBy = OrderBy(nameAlias) + + @JvmStatic + fun fromString(orderByString: String): OrderBy = OrderBy(orderByString) + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/SQLOperator.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/SQLOperator.kt index c2369ebf6..50a025fc8 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/SQLOperator.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/SQLOperator.kt @@ -12,7 +12,7 @@ interface SQLOperator { * * @param queryBuilder The builder to append to. */ - fun appendConditionToQuery(queryBuilder: QueryBuilder<*>) + fun appendConditionToQuery(queryBuilder: QueryBuilder) /** * The name of the column. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/SQLite.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/SQLite.java deleted file mode 100644 index e0be50892..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/SQLite.java +++ /dev/null @@ -1,131 +0,0 @@ -package com.raizlabs.android.dbflow.sql.language; - -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.sql.language.property.IProperty; -import com.raizlabs.android.dbflow.sql.language.property.Property; -import com.raizlabs.android.dbflow.structure.Model; - -/** - * Description: The main entry point into SQLite queries. - */ -public class SQLite { - - /** - * @param properties The properties/columns to SELECT. - * @return A beginning of the SELECT statement. - */ - @NonNull - public static Select select(IProperty... properties) { - return new Select(properties); - } - - /** - * Starts a new SELECT COUNT(property1, property2, propertyn) (if properties specified) or - * SELECT COUNT(*). - * - * @param properties Optional, if specified returns the count of non-null ROWs from a specific single/group of columns. - * @return A new select statement SELECT COUNT(expression) - */ - @NonNull - public static Select selectCountOf(IProperty... properties) { - return new Select(Method.count(properties)); - } - - /** - * @param table The tablet to update. - * @param The class that implements {@link Model}. - * @return A new UPDATE statement. - */ - @NonNull - public static Update update(@NonNull Class table) { - return new Update<>(table); - } - - /** - * @param table The table to insert. - * @param The class that implements {@link Model}. - * @return A new INSERT statement. - */ - @NonNull - public static Insert insert(@NonNull Class table) { - return new Insert<>(table); - } - - /** - * @return Begins a DELETE statement. - */ - @NonNull - public static Delete delete() { - return new Delete(); - } - - /** - * Starts a DELETE statement on the specified table. - * - * @param table The table to delete from. - * @param The class that implements {@link Model}. - * @return A {@link From} with specified DELETE on table. - */ - @NonNull - public static From delete(@NonNull Class table) { - return delete().from(table); - } - - /** - * Starts an INDEX statement on specified table. - * - * @param name The name of the index. - * @param The class that implements {@link Model}. - * @return A new INDEX statement. - */ - @NonNull - public static Index index(@NonNull String name) { - return new Index<>(name); - } - - /** - * Starts a TRIGGER statement. - * - * @param name The name of the trigger. - * @return A new TRIGGER statement. - */ - @NonNull - public static Trigger createTrigger(@NonNull String name) { - return Trigger.create(name); - } - - /** - * Starts a CASE statement. - * - * @param operator The condition to check for in the WHEN. - * @return A new {@link CaseCondition}. - */ - @NonNull - public static CaseCondition caseWhen(@NonNull SQLOperator operator) { - return new Case().when(operator); - } - - /** - * Starts an efficient CASE statement. The value passed here is only evaulated once. A non-efficient - * case statement will evaluate all of its {@link SQLOperator}. - * - * @param caseColumn The value - */ - @NonNull - public static Case _case(@NonNull Property caseColumn) { - return new Case<>(caseColumn); - } - - /** - * Starts an efficient CASE statement. The value passed here is only evaulated once. A non-efficient - * case statement will evaluate all of its {@link SQLOperator}. - * - * @param caseColumn The value - */ - @NonNull - public static Case _case(@NonNull IProperty caseColumn) { - return new Case<>(caseColumn); - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/SQLite.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/SQLite.kt new file mode 100644 index 000000000..66595f06f --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/SQLite.kt @@ -0,0 +1,107 @@ +package com.raizlabs.android.dbflow.sql.language + +import com.raizlabs.android.dbflow.sql.language.property.IProperty +import com.raizlabs.android.dbflow.sql.language.property.Property +import com.raizlabs.android.dbflow.structure.Model + +/** + * Description: The main entry point into SQLite queries. + */ +object SQLite { + + /** + * @param properties The properties/columns to SELECT. + * @return A beginning of the SELECT statement. + */ + @JvmStatic + fun select(vararg properties: IProperty<*>): Select = Select(*properties) + + /** + * Starts a new SELECT COUNT(property1, property2, propertyn) (if properties specified) or + * SELECT COUNT(*). + * + * @param properties Optional, if specified returns the count of non-null ROWs from a specific single/group of columns. + * @return A new select statement SELECT COUNT(expression) + */ + @JvmStatic + fun selectCountOf(vararg properties: IProperty<*>): Select = Select(count(*properties)) + + /** + * @param table The tablet to update. + * @param The class that implements [Model]. + * @return A new UPDATE statement. + */ + @JvmStatic + fun update(table: Class): Update = Update(table) + + /** + * @param table The table to insert. + * @param The class that implements [Model]. + * @return A new INSERT statement. + */ + @JvmStatic + fun insert(table: Class): Insert = Insert(table) + + /** + * @return Begins a DELETE statement. + */ + @JvmStatic + fun delete(): Delete = Delete() + + /** + * Starts a DELETE statement on the specified table. + * + * @param table The table to delete from. + * @param The class that implements [Model]. + * @return A [From] with specified DELETE on table. + */ + @JvmStatic + fun delete(table: Class): From = delete().from(table) + + /** + * Starts an INDEX statement on specified table. + * + * @param name The name of the index. + * @param The class that implements [Model]. + * @return A new INDEX statement. + */ + @JvmStatic + fun index(name: String): Index = Index(name) + + /** + * Starts a TRIGGER statement. + * + * @param name The name of the trigger. + * @return A new TRIGGER statement. + */ + @JvmStatic + fun createTrigger(name: String): Trigger = Trigger.create(name) + + /** + * Starts a CASE statement. + * + * @param operator The condition to check for in the WHEN. + * @return A new [CaseCondition]. + */ + @JvmStatic + fun caseWhen(operator: SQLOperator): CaseCondition = + Case().`when`(operator) + + /** + * Starts an efficient CASE statement. The value passed here is only evaulated once. A non-efficient + * case statement will evaluate all of its [SQLOperator]. + * + * @param caseColumn The value + */ + @JvmStatic + fun _case(caseColumn: Property): Case = Case(caseColumn) + + /** + * Starts an efficient CASE statement. The value passed here is only evaulated once. A non-efficient + * case statement will evaluate all of its [SQLOperator]. + * + * @param caseColumn The value + */ + @JvmStatic + fun _case(caseColumn: IProperty<*>): Case = Case(caseColumn) +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Select.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Select.java deleted file mode 100644 index 18477eb51..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Select.java +++ /dev/null @@ -1,107 +0,0 @@ -package com.raizlabs.android.dbflow.sql.language; - -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.sql.Query; -import com.raizlabs.android.dbflow.sql.QueryBuilder; -import com.raizlabs.android.dbflow.sql.language.property.IProperty; -import com.raizlabs.android.dbflow.sql.language.property.Property; - -import java.util.ArrayList; -import java.util.Collections; -import java.util.List; - -/** - * Description: A SQL SELECT statement generator. It generates the SELECT part of the statement. - */ -public class Select implements Query { - - /** - * Default does not include the qualifier - */ - public static final int NONE = -1; - /** - * The select qualifier to append to the SELECT statement - */ - private int mSelectQualifier = NONE; - /** - * SELECT DISTINCT call - */ - public static final int DISTINCT = 0; - /** - * SELECT ALL call - */ - public static final int ALL = 1; - - private final List propertyList = new ArrayList<>(); - - /** - * Creates this instance with the specified columns from the specified {@link com.raizlabs.android.dbflow.config.FlowManager} - * - * @param properties The properties to select from. - */ - public Select(IProperty... properties) { - Collections.addAll(propertyList, properties); - - if (propertyList.isEmpty()) { - propertyList.add(Property.Companion.getALL_PROPERTY()); - } - } - - /** - * Passes this statement to the {@link From} - * - * @param table The model table to run this query on - * @param The class that implements {@link com.raizlabs.android.dbflow.structure.Model} - * @return the From part of this query - */ - @NonNull - public From from(@NonNull Class table) { - return new From<>(this, table); - } - - /** - * appends {@link #DISTINCT} to the query - * - * @return - */ - @NonNull - public Select distinct() { - return selectQualifier(DISTINCT); - } - - @NonNull - public String toString() { - return getQuery(); - } - - @Override - public String getQuery() { - QueryBuilder queryBuilder = new QueryBuilder("SELECT "); - - if (mSelectQualifier != NONE) { - if (mSelectQualifier == DISTINCT) { - queryBuilder.append("DISTINCT"); - } else if (mSelectQualifier == ALL) { - queryBuilder.append("ALL"); - } - queryBuilder.appendSpace(); - } - - queryBuilder.append(QueryBuilder.join(",", propertyList)); - queryBuilder.appendSpace(); - return queryBuilder.getQuery(); - } - - - /** - * Helper method to pick the correct qualifier for a SELECT query - * - * @param qualifierInt Can be {@link #ALL}, {@link #NONE}, or {@link #DISTINCT} - * @return - */ - private Select selectQualifier(int qualifierInt) { - mSelectQualifier = qualifierInt; - return this; - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Select.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Select.kt new file mode 100644 index 000000000..00032c323 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Select.kt @@ -0,0 +1,98 @@ +package com.raizlabs.android.dbflow.sql.language + +import com.raizlabs.android.dbflow.sql.Query +import com.raizlabs.android.dbflow.sql.QueryBuilder +import com.raizlabs.android.dbflow.sql.language.property.IProperty +import com.raizlabs.android.dbflow.sql.language.property.Property +import java.util.* + +/** + * Description: A SQL SELECT statement generator. It generates the SELECT part of the statement. + */ +class Select +/** + * Creates this instance with the specified columns from the specified [com.raizlabs.android.dbflow.config.FlowManager] + * + * @param properties The properties to select from. + */ +(vararg properties: IProperty<*>) : Query { + /** + * The select qualifier to append to the SELECT statement + */ + private var selectQualifier = NONE + + private val propertyList = ArrayList>() + + override val query: String + get() { + val queryBuilder = QueryBuilder("SELECT ") + + if (selectQualifier != NONE) { + if (selectQualifier == DISTINCT) { + queryBuilder.append("DISTINCT") + } else if (selectQualifier == ALL) { + queryBuilder.append("ALL") + } + queryBuilder.appendSpace() + } + + queryBuilder.append(QueryBuilder.join(",", propertyList)) + queryBuilder.appendSpace() + return queryBuilder.query + } + + init { + propertyList.addAll(properties.toList()) + if (propertyList.isEmpty()) { + propertyList.add(Property.ALL_PROPERTY) + } + } + + /** + * Passes this statement to the [From] + * + * @param table The model table to run this query on + * @param The class that implements [com.raizlabs.android.dbflow.structure.Model] + * @return the From part of this query + */ + fun from(table: Class): From = From(this, table) + + /** + * appends [.DISTINCT] to the query + * + * @return + */ + fun distinct(): Select = selectQualifier(DISTINCT) + + override fun toString(): String = query + + + /** + * Helper method to pick the correct qualifier for a SELECT query + * + * @param qualifierInt Can be [.ALL], [.NONE], or [.DISTINCT] + * @return + */ + private fun selectQualifier(qualifierInt: Int) = apply { + selectQualifier = qualifierInt + } + + companion object { + + /** + * Default does not include the qualifier + */ + @JvmField + val NONE = -1 + /** + * SELECT DISTINCT call + */ + @JvmField + val DISTINCT = 0 + /** + * SELECT ALL call + */ + @JvmField + val ALL = 1 + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Set.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Set.java deleted file mode 100644 index f685e0959..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Set.java +++ /dev/null @@ -1,64 +0,0 @@ -package com.raizlabs.android.dbflow.sql.language; - -import android.content.ContentValues; -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.sql.Query; -import com.raizlabs.android.dbflow.sql.QueryBuilder; -import com.raizlabs.android.dbflow.sql.SqlUtils; -import com.raizlabs.android.dbflow.structure.BaseModel; - -/** - * Description: Used to specify the SET part of an {@link com.raizlabs.android.dbflow.sql.language.Update} query. - */ -public class Set extends BaseTransformable implements WhereBase { - - private OperatorGroup operatorGroup; - - private Query update; - - public Set(@NonNull Query update, @NonNull Class table) { - super(table); - this.update = update; - operatorGroup = OperatorGroup.nonGroupingClause().setAllCommaSeparated(true); - } - - /** - * Specifies a varg of conditions to append to this SET - * - * @param conditions The varg of conditions - * @return This instance. - */ - @NonNull - public Set conditions(SQLOperator... conditions) { - operatorGroup.andAll(conditions); - return this; - } - - @NonNull - public Set conditionValues(@NonNull ContentValues contentValues) { - SqlUtils.addContentValues(contentValues, operatorGroup); - return this; - } - - @Override - public String getQuery() { - QueryBuilder queryBuilder = - new QueryBuilder(update.getQuery()) - .append("SET ") - .append(operatorGroup.getQuery()).appendSpace(); - return queryBuilder.getQuery(); - } - - @NonNull - @Override - public Query getQueryBuilderBase() { - return update; - } - - @NonNull - @Override - public BaseModel.Action getPrimaryAction() { - return BaseModel.Action.UPDATE; - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Set.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Set.kt new file mode 100644 index 000000000..9746cf3cf --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Set.kt @@ -0,0 +1,42 @@ +package com.raizlabs.android.dbflow.sql.language + +import android.content.ContentValues + +import com.raizlabs.android.dbflow.sql.Query +import com.raizlabs.android.dbflow.sql.QueryBuilder +import com.raizlabs.android.dbflow.sql.SqlUtils +import com.raizlabs.android.dbflow.structure.BaseModel + +/** + * Description: Used to specify the SET part of an [com.raizlabs.android.dbflow.sql.language.Update] query. + */ +class Set(override val queryBuilderBase: Query, table: Class) + : BaseTransformable(table), WhereBase { + + private val operatorGroup: OperatorGroup = OperatorGroup.nonGroupingClause().setAllCommaSeparated(true) + + override val query: String + get() { + val queryBuilder = QueryBuilder(queryBuilderBase.query) + .append("SET ") + .append(operatorGroup.query).appendSpace() + return queryBuilder.query + } + + override val primaryAction: BaseModel.Action + get() = BaseModel.Action.UPDATE + + /** + * Specifies a varg of conditions to append to this SET + * + * @param conditions The varg of conditions + * @return This instance. + */ + fun conditions(vararg conditions: SQLOperator) = apply { + operatorGroup.andAll(*conditions) + } + + fun conditionValues(contentValues: ContentValues) = apply { + SqlUtils.addContentValues(contentValues, operatorGroup) + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Transformable.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Transformable.java deleted file mode 100644 index 298e411b1..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Transformable.java +++ /dev/null @@ -1,41 +0,0 @@ -package com.raizlabs.android.dbflow.sql.language; - -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.sql.language.property.IProperty; - -import java.util.List; - -/** - * Description: Provides a standard set of methods for ending a SQLite query method. These include - * groupby, orderby, having, limit and offset. - */ -public interface Transformable { - - @NonNull - Where groupBy(NameAlias... nameAliases); - - @NonNull - Where groupBy(IProperty... properties); - - @NonNull - Where orderBy(@NonNull NameAlias nameAlias, boolean ascending); - - @NonNull - Where orderBy(@NonNull IProperty property, boolean ascending); - - @NonNull - Where orderBy(@NonNull OrderBy orderBy); - - @NonNull - Where limit(int count); - - @NonNull - Where offset(int offset); - - @NonNull - Where having(SQLOperator... conditions); - - @NonNull - Where orderByAll(@NonNull List orderBies); -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Transformable.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Transformable.kt new file mode 100644 index 000000000..56faf88e7 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Transformable.kt @@ -0,0 +1,28 @@ +package com.raizlabs.android.dbflow.sql.language + +import com.raizlabs.android.dbflow.sql.language.property.IProperty + +/** + * Description: Provides a standard set of methods for ending a SQLite query method. These include + * groupby, orderby, having, limit and offset. + */ +interface Transformable { + + fun groupBy(vararg nameAliases: NameAlias): Where + + fun groupBy(vararg properties: IProperty<*>): Where + + fun orderBy(nameAlias: NameAlias, ascending: Boolean): Where + + fun orderBy(property: IProperty<*>, ascending: Boolean): Where + + fun orderBy(orderBy: OrderBy): Where + + fun limit(count: Int): Where + + fun offset(offset: Int): Where + + fun having(vararg conditions: SQLOperator): Where + + fun orderByAll(orderBies: List): Where +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Trigger.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Trigger.java deleted file mode 100644 index f264fddcf..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Trigger.java +++ /dev/null @@ -1,148 +0,0 @@ -package com.raizlabs.android.dbflow.sql.language; - -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.sql.Query; -import com.raizlabs.android.dbflow.sql.QueryBuilder; -import com.raizlabs.android.dbflow.sql.language.property.IProperty; - -/** - * Description: Describes an easy way to create a SQLite TRIGGER - */ -public class Trigger implements Query { - - /** - * Specifies that we should do this TRIGGER before some event - */ - public static final String BEFORE = "BEFORE"; - - /** - * Specifies that we should do this TRIGGER after some event - */ - public static final String AFTER = "AFTER"; - - /** - * Specifies that we should do this TRIGGER instead of the specified events - */ - public static final String INSTEAD_OF = "INSTEAD OF"; - - /** - * The name in the DB - */ - final String triggerName; - - /** - * If it's {@link #BEFORE}, {@link #AFTER}, or {@link #INSTEAD_OF} - */ - String beforeOrAfter; - - boolean temporary; - - /** - * @param triggerName The name of the trigger to use. - * @return A new trigger. - */ - @NonNull - public static Trigger create(@NonNull String triggerName) { - return new Trigger(triggerName); - } - - /** - * Creates a trigger with the specified trigger name. You need to complete - * the trigger using - * - * @param triggerName What we should call this trigger - */ - private Trigger(@NonNull String triggerName) { - this.triggerName = triggerName; - } - - /** - * Sets the trigger as temporary. - */ - @NonNull - public Trigger temporary() { - this.temporary = true; - return this; - } - - /** - * Specifies AFTER eventName - */ - @NonNull - public Trigger after() { - beforeOrAfter = AFTER; - return this; - } - - /** - * Specifies BEFORE eventName - */ - @NonNull - public Trigger before() { - beforeOrAfter = BEFORE; - return this; - } - - /** - * Specifies INSTEAD OF eventName - */ - @NonNull - public Trigger insteadOf() { - beforeOrAfter = INSTEAD_OF; - return this; - } - - /** - * Starts a DELETE ON command - * - * @param onTable The table ON - */ - @NonNull - public TriggerMethod deleteOn(@NonNull Class onTable) { - return new TriggerMethod<>(this, TriggerMethod.DELETE, onTable); - } - - /** - * Starts a INSERT ON command - * - * @param onTable The table ON - */ - @NonNull - public TriggerMethod insertOn(@NonNull Class onTable) { - return new TriggerMethod<>(this, TriggerMethod.INSERT, onTable); - } - - /** - * Starts an UPDATE ON command - * - * @param onTable The table ON - * @param properties if empty, will not execute an OF command. If you specify columns, - * the UPDATE OF column1, column2,... will be used. - */ - @NonNull - public TriggerMethod updateOn(@NonNull Class onTable, IProperty... properties) { - return new TriggerMethod<>(this, TriggerMethod.UPDATE, onTable, properties); - } - - /** - * @return The name of this TRIGGER - */ - @NonNull - public String getName() { - return triggerName; - } - - @Override - public String getQuery() { - QueryBuilder queryBuilder = new QueryBuilder("CREATE "); - if (temporary) { - queryBuilder.append("TEMP "); - } - queryBuilder.append("TRIGGER IF NOT EXISTS ") - .appendQuotedIfNeeded(triggerName).appendSpace() - .appendOptional(beforeOrAfter + " "); - - return queryBuilder.getQuery(); - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Trigger.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Trigger.kt new file mode 100644 index 000000000..6bb398386 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Trigger.kt @@ -0,0 +1,127 @@ +package com.raizlabs.android.dbflow.sql.language + +import com.raizlabs.android.dbflow.sql.Query +import com.raizlabs.android.dbflow.sql.QueryBuilder +import com.raizlabs.android.dbflow.sql.language.property.IProperty + +/** + * Description: Describes an easy way to create a SQLite TRIGGER + */ +class Trigger +/** + * Creates a trigger with the specified trigger name. You need to complete + * the trigger using + * + * @param triggerName What we should call this trigger + */ +private constructor( + /** + * The name in the DB + */ + /** + * @return The name of this TRIGGER + */ + val name: String) : Query { + + /** + * If it's [.BEFORE], [.AFTER], or [.INSTEAD_OF] + */ + private var beforeOrAfter: String = "" + + private var temporary: Boolean = false + + override val query: String + get() { + val queryBuilder = QueryBuilder("CREATE ") + if (temporary) { + queryBuilder.append("TEMP ") + } + queryBuilder.append("TRIGGER IF NOT EXISTS ") + .appendQuotedIfNeeded(name).appendSpace() + .appendOptional(beforeOrAfter + " ") + + return queryBuilder.query + } + + /** + * Sets the trigger as temporary. + */ + fun temporary() = apply { + this.temporary = true + } + + /** + * Specifies AFTER eventName + */ + fun after() = apply { + beforeOrAfter = AFTER + } + + /** + * Specifies BEFORE eventName + */ + fun before() = apply { + beforeOrAfter = BEFORE + } + + /** + * Specifies INSTEAD OF eventName + */ + fun insteadOf() = apply { + beforeOrAfter = INSTEAD_OF + } + + /** + * Starts a DELETE ON command + * + * @param onTable The table ON + */ + fun deleteOn(onTable: Class): TriggerMethod = + TriggerMethod(this, TriggerMethod.DELETE, onTable) + + /** + * Starts a INSERT ON command + * + * @param onTable The table ON + */ + fun insertOn(onTable: Class): TriggerMethod = + TriggerMethod(this, TriggerMethod.INSERT, onTable) + + /** + * Starts an UPDATE ON command + * + * @param onTable The table ON + * @param properties if empty, will not execute an OF command. If you specify columns, + * the UPDATE OF column1, column2,... will be used. + */ + fun updateOn(onTable: Class, vararg properties: IProperty<*>): TriggerMethod = + TriggerMethod(this, TriggerMethod.UPDATE, onTable, *properties) + + companion object { + + /** + * Specifies that we should do this TRIGGER before some event + */ + @JvmField + val BEFORE = "BEFORE" + + /** + * Specifies that we should do this TRIGGER after some event + */ + @JvmField + val AFTER = "AFTER" + + /** + * Specifies that we should do this TRIGGER instead of the specified events + */ + @JvmField + val INSTEAD_OF = "INSTEAD OF" + + /** + * @param triggerName The name of the trigger to use. + * @return A new trigger. + */ + @JvmStatic + fun create(triggerName: String) = Trigger(triggerName) + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/TriggerMethod.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/TriggerMethod.java deleted file mode 100644 index 270045074..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/TriggerMethod.java +++ /dev/null @@ -1,98 +0,0 @@ -package com.raizlabs.android.dbflow.sql.language; - -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.config.FlowManager; -import com.raizlabs.android.dbflow.sql.Query; -import com.raizlabs.android.dbflow.sql.QueryBuilder; -import com.raizlabs.android.dbflow.sql.language.property.IProperty; - -/** - * Description: Describes the method that the trigger uses. - */ -public class TriggerMethod implements Query { - - public static final String DELETE = "DELETE"; - public static final String INSERT = "INSERT"; - public static final String UPDATE = "UPDATE"; - - final Trigger trigger; - private IProperty[] properties; - private final String methodName; - - /** - * The table we're operating on. - */ - Class onTable; - boolean forEachRow = false; - private SQLOperator whenCondition; - - TriggerMethod(Trigger trigger, String methodName, Class onTable, IProperty... properties) { - this.trigger = trigger; - this.methodName = methodName; - this.onTable = onTable; - if (properties != null && properties.length > 0 && properties[0] != null) { - if (!methodName.equals(UPDATE)) { - throw new IllegalArgumentException("An Trigger OF can only be used with an UPDATE method"); - } - this.properties = properties; - } - } - - @NonNull - public TriggerMethod forEachRow() { - forEachRow = true; - return this; - } - - /** - * Appends a WHEN condition after the ON name and before BEGIN...END - * - * @param condition The condition for the trigger - * @return - */ - @NonNull - public TriggerMethod when(@NonNull SQLOperator condition) { - whenCondition = condition; - return this; - } - - /** - * Specify the logic that gets executed for this trigger. Supported statements include: - * {@link Update}, INSERT, {@link Delete}, - * and {@link Select} - * - * @param triggerLogicQuery The query to run for the BEGIN..END of the trigger - * @return This trigger - */ - @NonNull - public CompletedTrigger begin(@NonNull Query triggerLogicQuery) { - return new CompletedTrigger<>(this, triggerLogicQuery); - } - - @Override - public String getQuery() { - QueryBuilder queryBuilder - = new QueryBuilder(trigger.getQuery()) - .append(methodName); - if (properties != null && properties.length > 0) { - queryBuilder.appendSpaceSeparated("OF") - .appendArray((Object[]) properties); - } - queryBuilder.appendSpaceSeparated("ON").append(FlowManager.getTableName(onTable)); - - if (forEachRow) { - queryBuilder.appendSpaceSeparated("FOR EACH ROW"); - } - - if (whenCondition != null) { - queryBuilder.append(" WHEN "); - whenCondition.appendConditionToQuery(queryBuilder); - queryBuilder.appendSpace(); - } - - queryBuilder.appendSpace(); - - return queryBuilder.getQuery(); - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/TriggerMethod.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/TriggerMethod.kt new file mode 100644 index 000000000..3dd72ee05 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/TriggerMethod.kt @@ -0,0 +1,84 @@ +package com.raizlabs.android.dbflow.sql.language + +import com.raizlabs.android.dbflow.config.FlowManager +import com.raizlabs.android.dbflow.sql.Query +import com.raizlabs.android.dbflow.sql.QueryBuilder +import com.raizlabs.android.dbflow.sql.language.property.IProperty + +/** + * Description: Describes the method that the trigger uses. + */ +class TriggerMethod +internal constructor(private val trigger: Trigger, private val methodName: String, + private var onTable: Class, vararg properties: IProperty<*>) : Query { + private var properties: List> = arrayListOf() + private var forEachRow = false + private var whenCondition: SQLOperator? = null + + override val query: String + get() { + val queryBuilder = QueryBuilder(trigger.query) + .append(methodName) + if (properties.isNotEmpty()) { + queryBuilder.appendSpaceSeparated("OF") + .appendArray(properties.toTypedArray()) + } + queryBuilder.appendSpaceSeparated("ON").append(FlowManager.getTableName(onTable)) + + if (forEachRow) { + queryBuilder.appendSpaceSeparated("FOR EACH ROW") + } + + if (whenCondition != null) { + queryBuilder.append(" WHEN ") + whenCondition!!.appendConditionToQuery(queryBuilder) + queryBuilder.appendSpace() + } + + queryBuilder.appendSpace() + + return queryBuilder.query + } + + init { + if (properties.isNotEmpty() && properties.getOrNull(0) != null) { + if (methodName != UPDATE) { + throw IllegalArgumentException("An Trigger OF can only be used with an UPDATE method") + } + this.properties = properties.toList() + } + } + + fun forEachRow() = apply { + forEachRow = true + } + + /** + * Appends a WHEN condition after the ON name and before BEGIN...END + * + * @param condition The condition for the trigger + * @return + */ + @JvmName("when") + fun whenever(condition: SQLOperator) = apply { + whenCondition = condition + } + + /** + * Specify the logic that gets executed for this trigger. Supported statements include: + * [Update], INSERT, [Delete], + * and [Select] + * + * @param triggerLogicQuery The query to run for the BEGIN..END of the trigger + * @return This trigger + */ + fun begin(triggerLogicQuery: Query): CompletedTrigger = + CompletedTrigger(this, triggerLogicQuery) + + companion object { + + val DELETE = "DELETE" + val INSERT = "INSERT" + val UPDATE = "UPDATE" + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/UnSafeStringOperator.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/UnSafeStringOperator.java deleted file mode 100644 index f9d225000..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/UnSafeStringOperator.java +++ /dev/null @@ -1,76 +0,0 @@ -package com.raizlabs.android.dbflow.sql.language; - -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.StringUtils; -import com.raizlabs.android.dbflow.sql.Query; -import com.raizlabs.android.dbflow.sql.QueryBuilder; - -/** - * Description: This class will use a String to describe its condition. - * Not recommended for normal queries, but can be used as a fall-back. - */ -public class UnSafeStringOperator implements SQLOperator, Query { - - private final String conditionString; - private String separator = ""; - - public UnSafeStringOperator(String selection, String[] selectionArgs) { - String newSelection = selection; - // replace question marks in order - if (newSelection != null) { - for (String selectionArg : selectionArgs) { - newSelection = newSelection.replaceFirst("\\?", selectionArg); - } - } - this.conditionString = newSelection; - } - - @Override - public void appendConditionToQuery(@NonNull QueryBuilder queryBuilder) { - queryBuilder.append(conditionString); - } - - @NonNull - @Override - public String columnName() { - return ""; - } - - @Nullable - @Override - public String separator() { - return separator; - } - - @NonNull - @Override - public SQLOperator separator(@NonNull String separator) { - this.separator = separator; - return this; - } - - @Override - public boolean hasSeparator() { - return StringUtils.isNotNullOrEmpty(separator); - } - - @NonNull - @Override - public String operation() { - return ""; - } - - @Override - public Object value() { - return ""; - } - - @Override - public String getQuery() { - QueryBuilder queryBuilder = new QueryBuilder(); - appendConditionToQuery(queryBuilder); - return queryBuilder.getQuery(); - } -} \ No newline at end of file diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/UnSafeStringOperator.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/UnSafeStringOperator.kt new file mode 100644 index 000000000..f780c9a30 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/UnSafeStringOperator.kt @@ -0,0 +1,51 @@ +package com.raizlabs.android.dbflow.sql.language + +import com.raizlabs.android.dbflow.StringUtils +import com.raizlabs.android.dbflow.sql.Query +import com.raizlabs.android.dbflow.sql.QueryBuilder + +/** + * Description: This class will use a String to describe its condition. + * Not recommended for normal queries, but can be used as a fall-back. + */ +class UnSafeStringOperator(selection: String, selectionArgs: Array) : SQLOperator, Query { + + private val conditionString: String? + private var separator = "" + + override val query: String + get() { + val queryBuilder = QueryBuilder() + appendConditionToQuery(queryBuilder) + return queryBuilder.query + } + + init { + var newSelection: String? = selection + // replace question marks in order + if (newSelection != null) { + for (selectionArg in selectionArgs) { + newSelection = newSelection?.replaceFirst("\\?".toRegex(), selectionArg) + } + } + this.conditionString = newSelection + } + + override fun appendConditionToQuery(queryBuilder: QueryBuilder) { + queryBuilder.append(conditionString) + } + + override fun columnName(): String = "" + + override fun separator(): String? = separator + + override fun separator(separator: String) = apply { + this.separator = separator + } + + override fun hasSeparator(): Boolean = StringUtils.isNotNullOrEmpty(separator) + + override fun operation(): String = "" + + override fun value(): Any? = "" +} \ No newline at end of file diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Update.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Update.java deleted file mode 100644 index ea1764d3e..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Update.java +++ /dev/null @@ -1,111 +0,0 @@ -package com.raizlabs.android.dbflow.sql.language; - -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.annotation.ConflictAction; -import com.raizlabs.android.dbflow.config.FlowManager; -import com.raizlabs.android.dbflow.sql.Query; -import com.raizlabs.android.dbflow.sql.QueryBuilder; - -/** - * Description: The SQLite UPDATE query. Will update rows in the DB. - */ -public class Update implements Query { - - /** - * The conflict action to resolve updates. - */ - private ConflictAction conflictAction = ConflictAction.NONE; - - private final Class table; - - /** - * Constructs new instace of an UPDATE query with the specified table. - * - * @param table The table to use. - */ - public Update(Class table) { - this.table = table; - } - - @NonNull - public Update conflictAction(@NonNull ConflictAction conflictAction) { - this.conflictAction = conflictAction; - return this; - } - - @NonNull - public Update or(@NonNull ConflictAction conflictAction) { - return conflictAction(conflictAction); - } - - /** - * @return This instance. - * @see ConflictAction#ROLLBACK - */ - @NonNull - public Update orRollback() { - return conflictAction(ConflictAction.ROLLBACK); - } - - /** - * @return This instance. - * @see ConflictAction#ABORT - */ - @NonNull - public Update orAbort() { - return conflictAction(ConflictAction.ABORT); - } - - /** - * @return This instance. - * @see ConflictAction#REPLACE - */ - @NonNull - public Update orReplace() { - return conflictAction(ConflictAction.REPLACE); - } - - /** - * @return This instance. - * @see ConflictAction#FAIL - */ - @NonNull - public Update orFail() { - return conflictAction(ConflictAction.FAIL); - } - - /** - * @return This instance. - * @see ConflictAction#IGNORE - */ - @NonNull - public Update orIgnore() { - return conflictAction(ConflictAction.IGNORE); - } - - /** - * Begins a SET piece of the SQL query - * - * @param conditions The array of conditions that define this SET statement - * @return A SET query piece of this statement - */ - @NonNull - public Set set(SQLOperator... conditions) { - return new Set<>(this, table).conditions(conditions); - } - - @Override - public String getQuery() { - QueryBuilder queryBuilder = new QueryBuilder("UPDATE "); - if (conflictAction != null && !conflictAction.equals(ConflictAction.NONE)) { - queryBuilder.append("OR").appendSpaceSeparated(conflictAction.name()); - } - queryBuilder.append(FlowManager.getTableName(table)).appendSpace(); - return queryBuilder.getQuery(); - } - - public Class getTable() { - return table; - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Update.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Update.kt new file mode 100644 index 000000000..516d10f52 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Update.kt @@ -0,0 +1,79 @@ +package com.raizlabs.android.dbflow.sql.language + +import com.raizlabs.android.dbflow.annotation.ConflictAction +import com.raizlabs.android.dbflow.config.FlowManager +import com.raizlabs.android.dbflow.sql.Query +import com.raizlabs.android.dbflow.sql.QueryBuilder + +/** + * Description: The SQLite UPDATE query. Will update rows in the DB. + */ +class Update +/** + * Constructs new instace of an UPDATE query with the specified table. + * + * @param table The table to use. + */ +internal constructor(val table: Class) : Query { + + /** + * The conflict action to resolve updates. + */ + private var conflictAction: ConflictAction? = ConflictAction.NONE + + override val query: String + get() { + val queryBuilder = QueryBuilder("UPDATE ") + conflictAction?.let { conflictAction -> + if (conflictAction != ConflictAction.NONE) { + queryBuilder.append("OR").appendSpaceSeparated(conflictAction.name) + } + } + queryBuilder.append(FlowManager.getTableName(table)).appendSpace() + return queryBuilder.query + } + + fun conflictAction(conflictAction: ConflictAction) = apply { + this.conflictAction = conflictAction + } + + fun or(conflictAction: ConflictAction) = conflictAction(conflictAction) + + /** + * @return This instance. + * @see ConflictAction.ROLLBACK + */ + fun orRollback() = conflictAction(ConflictAction.ROLLBACK) + + /** + * @return This instance. + * @see ConflictAction.ABORT + */ + fun orAbort() = conflictAction(ConflictAction.ABORT) + + /** + * @return This instance. + * @see ConflictAction.REPLACE + */ + fun orReplace() = conflictAction(ConflictAction.REPLACE) + + /** + * @return This instance. + * @see ConflictAction.FAIL + */ + fun orFail() = conflictAction(ConflictAction.FAIL) + + /** + * @return This instance. + * @see ConflictAction.IGNORE + */ + fun orIgnore() = conflictAction(ConflictAction.IGNORE) + + /** + * Begins a SET piece of the SQL query + * + * @param conditions The array of conditions that define this SET statement + * @return A SET query piece of this statement + */ + fun set(vararg conditions: SQLOperator): Set = Set(this, table).conditions(*conditions) +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Where.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Where.java deleted file mode 100644 index 6c73082f4..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Where.java +++ /dev/null @@ -1,264 +0,0 @@ -package com.raizlabs.android.dbflow.sql.language; - -import android.database.Cursor; -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.annotation.provider.ContentProvider; -import com.raizlabs.android.dbflow.config.FlowManager; -import com.raizlabs.android.dbflow.sql.QueryBuilder; -import com.raizlabs.android.dbflow.sql.language.property.IProperty; -import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable; -import com.raizlabs.android.dbflow.structure.BaseModel; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; -import com.raizlabs.android.dbflow.structure.database.FlowCursor; - -import java.util.ArrayList; -import java.util.Collections; -import java.util.List; - -/** - * Description: Defines the SQL WHERE statement of the query. - */ -public class Where extends BaseModelQueriable implements ModelQueriable, - Transformable { - - private static final int VALUE_UNSET = -1; - - /** - * The first chunk of the SQL statement before this query. - */ - private final WhereBase whereBase; - - /** - * Helps to build the where statement easily - */ - private OperatorGroup operatorGroup; - - private final List groupByList = new ArrayList<>(); - - private final List orderByList = new ArrayList<>(); - - /** - * The SQL HAVING statement - */ - private OperatorGroup havingGroup; - - private int limit = VALUE_UNSET; - private int offset = VALUE_UNSET; - - /** - * Constructs this class with the specified {@link com.raizlabs.android.dbflow.config.FlowManager} - * and {@link From} chunk - * - * @param whereBase The FROM or SET statement chunk - */ - public Where(@NonNull WhereBase whereBase, SQLOperator... conditions) { - super(whereBase.getTable()); - this.whereBase = whereBase; - operatorGroup = OperatorGroup.nonGroupingClause(); - havingGroup = OperatorGroup.nonGroupingClause(); - - operatorGroup.andAll(conditions); - } - - /** - * Joins the {@link SQLOperator} by the prefix of "AND" (unless its the first condition). - */ - @NonNull - public Where and(@NonNull SQLOperator condition) { - operatorGroup.and(condition); - return this; - } - - /** - * Joins the {@link SQLOperator} by the prefix of "OR" (unless its the first condition). - */ - @NonNull - public Where or(@NonNull SQLOperator condition) { - operatorGroup.or(condition); - return this; - } - - /** - * Joins all of the {@link SQLOperator} by the prefix of "AND" (unless its the first condition). - */ - @NonNull - public Where andAll(@NonNull List conditions) { - operatorGroup.andAll(conditions); - return this; - } - - /** - * Joins all of the {@link SQLOperator} by the prefix of "AND" (unless its the first condition). - */ - @NonNull - public Where andAll(SQLOperator... conditions) { - operatorGroup.andAll(conditions); - return this; - } - - @NonNull - public Where groupBy(NameAlias... columns) { - Collections.addAll(groupByList, columns); - return this; - } - - @NonNull - public Where groupBy(IProperty... properties) { - for (IProperty property : properties) { - groupByList.add(property.getNameAlias()); - } - return this; - } - - /** - * Defines a SQL HAVING statement without the HAVING. - * - * @param conditions The array of {@link SQLOperator} - * @return - */ - @NonNull - public Where having(SQLOperator... conditions) { - havingGroup.andAll(conditions); - return this; - } - - @NonNull - public Where orderBy(@NonNull NameAlias nameAlias, boolean ascending) { - orderByList.add(new OrderBy(nameAlias, ascending)); - return this; - } - - @NonNull - public Where orderBy(@NonNull IProperty property, boolean ascending) { - orderByList.add(new OrderBy(property.getNameAlias(), ascending)); - return this; - } - - @NonNull - public Where orderBy(@NonNull OrderBy orderBy) { - orderByList.add(orderBy); - return this; - } - - /** - * For use in {@link ContentProvider} generation. Appends all ORDER BY here. - * - * @param orderBies The order by. - * @return this instance. - */ - @NonNull - public Where orderByAll(@NonNull List orderBies) { - orderByList.addAll(orderBies); - return this; - } - - @NonNull - public Where limit(int count) { - this.limit = count; - return this; - } - - @NonNull - public Where offset(int offset) { - this.offset = offset; - return this; - } - - /** - * Specify that we use an EXISTS statement for this Where class. - * - * @param where The query to use in the EXISTS clause. Such as SELECT * FROM `MyTable` WHERE ... etc. - * @return This where with an EXISTS clause. - */ - @NonNull - public Where exists(@NonNull Where where) { - operatorGroup.and(new ExistenceOperator() - .where(where)); - return this; - } - - @NonNull - @Override - public BaseModel.Action getPrimaryAction() { - return whereBase.getPrimaryAction(); - } - - @Override - public String getQuery() { - String fromQuery = whereBase.getQuery().trim(); - QueryBuilder queryBuilder = new QueryBuilder().append(fromQuery).appendSpace() - .appendQualifier("WHERE", operatorGroup.getQuery()) - .appendQualifier("GROUP BY", QueryBuilder.join(",", groupByList)) - .appendQualifier("HAVING", havingGroup.getQuery()) - .appendQualifier("ORDER BY", QueryBuilder.join(",", orderByList)); - - if (limit > VALUE_UNSET) { - queryBuilder.appendQualifier("LIMIT", String.valueOf(limit)); - } - if (offset > VALUE_UNSET) { - queryBuilder.appendQualifier("OFFSET", String.valueOf(offset)); - } - - return queryBuilder.getQuery(); - } - - /** - * @return the result of the query as a {@link Cursor}. - */ - @Override - public FlowCursor query(@NonNull DatabaseWrapper wrapper) { - // Query the sql here - FlowCursor cursor; - if (whereBase.getQueryBuilderBase() instanceof Select) { - cursor = wrapper.rawQuery(getQuery(), null); - } else { - cursor = super.query(wrapper); - } - - return cursor; - } - - @Override - public FlowCursor query() { - return query(FlowManager.getDatabaseForTable(getTable()).getWritableDatabase()); - } - - /** - * Queries for all of the results this statement returns from a DB cursor in the form of the {@link TModel} - * - * @return All of the entries in the DB converted into {@link TModel} - */ - @NonNull - @Override - public List queryList() { - checkSelect("query"); - return super.queryList(); - } - - /** - * Queries and returns only the first {@link TModel} result from the DB. Will enforce a limit of 1 item - * returned from the database. - * - * @return The first result of this query. Note: this query forces a limit of 1 from the database. - */ - @Override - public TModel querySingle() { - checkSelect("query"); - limit(1); - return super.querySingle(); - } - - @NonNull - public WhereBase getWhereBase() { - return whereBase; - } - - private void checkSelect(String methodName) { - if (!(whereBase.getQueryBuilderBase() instanceof Select)) { - throw new IllegalArgumentException("Please use " + methodName + "(). The beginning is not a ISelect"); - } - } - - -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Where.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Where.kt new file mode 100644 index 000000000..9e8872183 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Where.kt @@ -0,0 +1,203 @@ +package com.raizlabs.android.dbflow.sql.language + +import android.database.Cursor +import com.raizlabs.android.dbflow.annotation.provider.ContentProvider +import com.raizlabs.android.dbflow.config.FlowManager +import com.raizlabs.android.dbflow.sql.QueryBuilder +import com.raizlabs.android.dbflow.sql.language.property.IProperty +import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable +import com.raizlabs.android.dbflow.structure.BaseModel +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.structure.database.FlowCursor +import java.util.* + +/** + * Description: Defines the SQL WHERE statement of the query. + */ +class Where +/** + * Constructs this class with the specified [com.raizlabs.android.dbflow.config.FlowManager] + * and [From] chunk + * + * @param whereBase The FROM or SET statement chunk + */ +( + /** + * The first chunk of the SQL statement before this query. + */ + val whereBase: WhereBase, vararg conditions: SQLOperator) + : BaseModelQueriable(whereBase.table), ModelQueriable, Transformable { + + /** + * Helps to build the where statement easily + */ + private val operatorGroup: OperatorGroup = OperatorGroup.nonGroupingClause() + + private val groupByList = ArrayList() + + private val orderByList = ArrayList() + + /** + * The SQL HAVING statement + */ + private val havingGroup: OperatorGroup = OperatorGroup.nonGroupingClause() + + private var limit = VALUE_UNSET + private var offset = VALUE_UNSET + + override val primaryAction: BaseModel.Action + get() = whereBase.primaryAction + + override val query: String + get() { + val fromQuery = whereBase.query.trim { it <= ' ' } + val queryBuilder = QueryBuilder().append(fromQuery).appendSpace() + .appendQualifier("WHERE", operatorGroup.query) + .appendQualifier("GROUP BY", QueryBuilder.join(",", groupByList)) + .appendQualifier("HAVING", havingGroup.query) + .appendQualifier("ORDER BY", QueryBuilder.join(",", orderByList)) + + if (limit > VALUE_UNSET) { + queryBuilder.appendQualifier("LIMIT", limit.toString()) + } + if (offset > VALUE_UNSET) { + queryBuilder.appendQualifier("OFFSET", offset.toString()) + } + + return queryBuilder.query + } + + init { + operatorGroup.andAll(*conditions) + } + + /** + * Joins the [SQLOperator] by the prefix of "AND" (unless its the first condition). + */ + fun and(condition: SQLOperator) = apply { + operatorGroup.and(condition) + } + + /** + * Joins the [SQLOperator] by the prefix of "OR" (unless its the first condition). + */ + fun or(condition: SQLOperator) = apply { + operatorGroup.or(condition) + } + + /** + * Joins all of the [SQLOperator] by the prefix of "AND" (unless its the first condition). + */ + fun andAll(conditions: List) = apply { + operatorGroup.andAll(conditions) + } + + /** + * Joins all of the [SQLOperator] by the prefix of "AND" (unless its the first condition). + */ + fun andAll(vararg conditions: SQLOperator) = apply { + operatorGroup.andAll(*conditions) + } + + override fun groupBy(vararg nameAliases: NameAlias) = apply { + groupByList.addAll(nameAliases.toList()) + } + + override fun groupBy(vararg properties: IProperty<*>) = apply { + properties.mapTo(groupByList) { it.nameAlias } + } + + /** + * Defines a SQL HAVING statement without the HAVING. + * + * @param conditions The array of [SQLOperator] + * @return + */ + override fun having(vararg conditions: SQLOperator) = apply { + havingGroup.andAll(*conditions) + } + + override fun orderBy(nameAlias: NameAlias, ascending: Boolean) = apply { + orderByList.add(OrderBy(nameAlias, ascending)) + } + + override fun orderBy(property: IProperty<*>, ascending: Boolean) = apply { + orderByList.add(OrderBy(property.nameAlias, ascending)) + } + + override fun orderBy(orderBy: OrderBy) = apply { + orderByList.add(orderBy) + } + + /** + * For use in [ContentProvider] generation. Appends all ORDER BY here. + * + * @param orderBies The order by. + * @return this instance. + */ + override fun orderByAll(orderBies: List) = apply { + orderByList.addAll(orderBies) + } + + override fun limit(count: Int) = apply { + this.limit = count + } + + override fun offset(offset: Int) = apply { + this.offset = offset + } + + /** + * Specify that we use an EXISTS statement for this Where class. + * + * @param where The query to use in the EXISTS clause. Such as SELECT * FROM `MyTable` WHERE ... etc. + * @return This where with an EXISTS clause. + */ + fun exists(where: Where<*>) = apply { + operatorGroup.and(ExistenceOperator(where)) + } + + /** + * @return the result of the query as a [Cursor]. + */ + override fun query(databaseWrapper: DatabaseWrapper): FlowCursor? =// Query the sql here + when { + whereBase.queryBuilderBase is Select -> databaseWrapper.rawQuery(query, null) + else -> super.query(databaseWrapper) + } + + override fun query(): FlowCursor? = query(FlowManager.getDatabaseForTable(table).writableDatabase) + + /** + * Queries for all of the results this statement returns from a DB cursor in the form of the [TModel] + * + * @return All of the entries in the DB converted into [TModel] + */ + override fun queryList(): MutableList { + checkSelect("query") + return super.queryList() + } + + /** + * Queries and returns only the first [TModel] result from the DB. Will enforce a limit of 1 item + * returned from the database. + * + * @return The first result of this query. Note: this query forces a limit of 1 from the database. + */ + override fun querySingle(): TModel? { + checkSelect("query") + limit(1) + return super.querySingle() + } + + private fun checkSelect(methodName: String) { + if (whereBase.queryBuilderBase !is Select) { + throw IllegalArgumentException("Please use $methodName(). The beginning is not a ISelect") + } + } + + companion object { + + private val VALUE_UNSET = -1 + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/IProperty.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/IProperty.java index 7ffc60677..59119f80c 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/IProperty.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/IProperty.java @@ -24,55 +24,55 @@ public interface IProperty

extends Query { /** * Adds another property and returns as a new property. i.e p1 + p2 * - * @param iProperty the property to add. + * @param property the property to add. * @return A new instance. */ @NonNull - P plus(@NonNull IProperty iProperty); + P plus(@NonNull IProperty property); /** * Subtracts another property and returns as a new property. i.e p1 - p2 * - * @param iProperty the property to subtract. + * @param property the property to subtract. * @return A new instance. */ @NonNull - P minus(@NonNull IProperty iProperty); + P minus(@NonNull IProperty property); /** * Divides another property and returns as a new property. i.e p1 / p2 * - * @param iProperty the property to divide. + * @param property the property to divide. * @return A new instance. */ @NonNull - P div(@NonNull IProperty iProperty); + P div(@NonNull IProperty property); /** * Multiplies another property and returns as a new property. i.e p1 * p2 * - * @param iProperty the property to multiply. + * @param property the property to multiply. * @return A new instance. */ - P times(@NonNull IProperty iProperty); + P times(@NonNull IProperty property); /** * Modulous another property and returns as a new property. i.e p1 % p2 * - * @param iProperty the property to calculate remainder of. + * @param property the property to calculate remainder of. * @return A new instance. */ @NonNull - P rem(@NonNull IProperty iProperty); + P rem(@NonNull IProperty property); /** * Concats another property and returns as a new propert.y i.e. p1 || p2 * - * @param iProperty The property to concatenate. + * @param property The property to concatenate. * @return A new instance. */ @NonNull - P concatenate(@NonNull IProperty iProperty); + P concatenate(@NonNull IProperty property); /** * @return Appends DISTINCT to the property name. This is handy in {@link Method} queries. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/Property.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/Property.kt index b0680c39f..89fc03863 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/Property.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/Property.kt @@ -56,15 +56,12 @@ open class Property : IProperty>, IConditional, IOperator { } } - constructor(table: Class<*>?, columnName: String, aliasName: String) : this(table, NameAlias.builder(columnName).`as`(aliasName).build()) {} + constructor(table: Class<*>?, columnName: String, aliasName: String) : this(table, NameAlias.builder(columnName).`as`(aliasName).build()) - override fun withTable(): Property { - return withTable(NameAlias.Builder(FlowManager.getTableName(table!!)).build()) - } + override fun withTable(): Property = + withTable(NameAlias.Builder(FlowManager.getTableName(table!!)).build()) - override fun getNameAlias(): NameAlias { - return internalNameAlias - } + override fun getNameAlias(): NameAlias = internalNameAlias override val query: String get() = nameAlias.query @@ -114,7 +111,7 @@ open class Property : IProperty>, IConditional, IOperator { override fun `is`(baseModelQueriable: BaseModelQueriable<*>): Operator<*> = operator.`is`(baseModelQueriable) - override fun isNull(): Operator<*> = operator.isNull + override fun isNull(): Operator<*> = operator.isNull() override fun eq(baseModelQueriable: BaseModelQueriable<*>): Operator<*> = operator.eq(baseModelQueriable) @@ -122,7 +119,7 @@ open class Property : IProperty>, IConditional, IOperator { override fun isNot(baseModelQueriable: BaseModelQueriable<*>): Operator<*> = operator.isNot(baseModelQueriable) - override fun isNotNull(): Operator<*> = operator.isNotNull + override fun isNotNull(): Operator<*> = operator.isNotNull() override fun notEq(baseModelQueriable: BaseModelQueriable<*>): Operator<*> = operator.notEq(baseModelQueriable) @@ -180,34 +177,34 @@ open class Property : IProperty>, IConditional, IOperator { return table!! } - override fun plus(iProperty: IProperty<*>): Property { + override fun plus(property: IProperty<*>): Property { return Property(table, NameAlias.joinNames(Operator.Operation.PLUS, - internalNameAlias.fullName(), iProperty.toString())) + internalNameAlias.fullName(), property.toString())) } - override fun minus(iProperty: IProperty<*>): Property { + override fun minus(property: IProperty<*>): Property { return Property(table, NameAlias.joinNames(Operator.Operation.MINUS, - internalNameAlias.fullName(), iProperty.toString())) + internalNameAlias.fullName(), property.toString())) } - override fun div(iProperty: IProperty<*>): Property { + override fun div(property: IProperty<*>): Property { return Property(table, NameAlias.joinNames(Operator.Operation.DIVISION, - internalNameAlias.fullName(), iProperty.toString())) + internalNameAlias.fullName(), property.toString())) } - override fun times(iProperty: IProperty<*>): Property { + override fun times(property: IProperty<*>): Property { return Property(table, NameAlias.joinNames(Operator.Operation.MULTIPLY, - internalNameAlias.fullName(), iProperty.toString())) + internalNameAlias.fullName(), property.toString())) } - override fun rem(iProperty: IProperty<*>): Property { + override fun rem(property: IProperty<*>): Property { return Property(table, NameAlias.joinNames(Operator.Operation.MOD, - internalNameAlias.fullName(), iProperty.toString())) + internalNameAlias.fullName(), property.toString())) } - override fun concatenate(iProperty: IProperty<*>): Property { + override fun concatenate(property: IProperty<*>): Property { return Property(table, NameAlias.joinNames(Operator.Operation.CONCATENATE, - internalNameAlias.fullName(), iProperty.toString())) + internalNameAlias.fullName(), property.toString())) } override fun `as`(aliasName: String): Property { diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ModelQueriable.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ModelQueriable.kt index 70aaa2709..067068d6d 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ModelQueriable.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ModelQueriable.kt @@ -29,14 +29,14 @@ interface ModelQueriable : Queriable { /** * @return a list of model converted items */ - fun queryList(): List + fun queryList(): MutableList /** * Allows you to specify a DB, useful for migrations. * * @return a list of model converted items */ - fun queryList(wrapper: DatabaseWrapper): List + fun queryList(wrapper: DatabaseWrapper): MutableList /** * @return Single model, the first of potentially many results @@ -74,7 +74,7 @@ interface ModelQueriable : Queriable { * @param The class that extends [BaseQueryModel] * @return A list of custom models that are not tied to a table. */ - fun queryCustomList(queryModelClass: Class): List + fun queryCustomList(queryModelClass: Class): MutableList /** * Returns a single [TQueryModel] from this query. @@ -85,10 +85,4 @@ interface ModelQueriable : Queriable { */ fun queryCustomSingle(queryModelClass: Class): TQueryModel? - /** - * Disables caching on this query for the object retrieved from DB (if caching enabled). If - * caching is not enabled, this method is ignored. This also disables caching in a [FlowCursorList] - * or [FlowQueryList] if you [.flowQueryList] or [.cursorList] - */ - fun disableCaching(): ModelQueriable } \ No newline at end of file diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/Queriable.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/Queriable.kt index 00f9837d1..bd4d2b538 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/Queriable.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/Queriable.kt @@ -43,12 +43,6 @@ interface Queriable : Query { */ fun compileStatement(databaseWrapper: DatabaseWrapper): DatabaseStatement - /** - * @return the count of the results of the query. - */ - @Deprecated("use {@link #longValue()}") - fun count(): Long - /** * @return the long value of the results of query. */ @@ -59,14 +53,6 @@ interface Queriable : Query { */ fun longValue(databaseWrapper: DatabaseWrapper): Long - /** - * Allows you to pass in a [DatabaseWrapper] manually. - * - * @return the count of the results of the query. - */ - @Deprecated("use {@link #longValue(DatabaseWrapper)}") - fun count(databaseWrapper: DatabaseWrapper): Long - /** * @return This may return the number of rows affected from a [Set] or [Delete] statement. * If not, returns [Model.INVALID_ROW_ID] diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelAdapter.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelAdapter.java index a8d81cfb4..b73e845bc 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelAdapter.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelAdapter.java @@ -43,8 +43,8 @@ public abstract class ModelAdapter extends InstanceAdapter public ModelAdapter(@NonNull DatabaseDefinition databaseDefinition) { super(databaseDefinition); - if (getTableConfig() != null && getTableConfig().modelSaver() != null) { - modelSaver = getTableConfig().modelSaver(); + if (getTableConfig() != null && getTableConfig().getModelSaver() != null) { + modelSaver = getTableConfig().getModelSaver(); modelSaver.setModelAdapter(this); } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/RetrievalAdapter.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/RetrievalAdapter.java index 83a853814..1eafe3dc9 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/RetrievalAdapter.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/RetrievalAdapter.java @@ -29,16 +29,16 @@ public abstract class RetrievalAdapter { public RetrievalAdapter(@NonNull DatabaseDefinition databaseDefinition) { DatabaseConfig databaseConfig = FlowManager.getConfig() - .getConfigForDatabase(databaseDefinition.getAssociatedDatabaseClassFile()); + .getConfigForDatabase(databaseDefinition.getAssociatedDatabaseClassFile()); if (databaseConfig != null) { tableConfig = databaseConfig.getTableConfigForTable(getModelClass()); if (tableConfig != null) { - if (tableConfig.singleModelLoader() != null) { - singleModelLoader = tableConfig.singleModelLoader(); + if (tableConfig.getSingleModelLoader() != null) { + singleModelLoader = tableConfig.getSingleModelLoader(); } - if (tableConfig.listModelLoader() != null) { - listModelLoader = tableConfig.listModelLoader(); + if (tableConfig.getListModelLoader() != null) { + listModelLoader = tableConfig.getListModelLoader(); } } } @@ -56,10 +56,10 @@ public void load(@NonNull TModel model) { */ public void load(@NonNull TModel model, DatabaseWrapper databaseWrapper) { getNonCacheableSingleModelLoader().load(databaseWrapper, - SQLite.select() - .from(getModelClass()) - .where(getPrimaryConditionClause(model)).getQuery(), - model); + SQLite.INSTANCE.select() + .from(getModelClass()) + .where(getPrimaryConditionClause(model)).getQuery(), + model); } /** From 5292f614e0834ec1787e1bf3fa82024beed49851 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Wed, 22 Nov 2017 17:59:48 -0500 Subject: [PATCH 055/234] [5.0] move core to kotlin. --- dbflow-core/build.gradle | 6 +- .../raizlabs/android/dbflow/StringUtils.java | 21 ---- .../raizlabs/android/dbflow/StringUtils.kt | 21 ++++ .../annotation/{Collate.java => Collate.kt} | 4 +- .../android/dbflow/annotation/Column.java | 58 --------- .../android/dbflow/annotation/Column.kt | 46 +++++++ .../dbflow/annotation/ColumnIgnore.java | 14 --- .../android/dbflow/annotation/ColumnIgnore.kt | 8 ++ .../android/dbflow/annotation/ColumnMap.java | 22 ---- .../android/dbflow/annotation/ColumnMap.kt | 15 +++ .../dbflow/annotation/ColumnMapReference.java | 30 ----- .../dbflow/annotation/ColumnMapReference.kt | 21 ++++ ...{ConflictAction.java => ConflictAction.kt} | 38 +++--- .../android/dbflow/annotation/Database.java | 82 ------------ .../android/dbflow/annotation/Database.kt | 58 +++++++++ .../android/dbflow/annotation/ForeignKey.java | 76 ----------- .../android/dbflow/annotation/ForeignKey.kt | 64 ++++++++++ ...eignKeyAction.java => ForeignKeyAction.kt} | 8 +- .../annotation/ForeignKeyReference.java | 31 ----- .../dbflow/annotation/ForeignKeyReference.kt | 25 ++++ .../android/dbflow/annotation/Index.java | 20 --- .../android/dbflow/annotation/Index.kt | 13 ++ .../android/dbflow/annotation/IndexGroup.java | 32 ----- .../android/dbflow/annotation/IndexGroup.kt | 24 ++++ .../dbflow/annotation/InheritedColumn.java | 30 ----- .../dbflow/annotation/InheritedColumn.kt | 21 ++++ .../annotation/InheritedPrimaryKey.java | 30 ----- .../dbflow/annotation/InheritedPrimaryKey.kt | 21 ++++ .../android/dbflow/annotation/ManyToMany.java | 52 -------- .../android/dbflow/annotation/ManyToMany.kt | 42 +++++++ .../android/dbflow/annotation/Migration.java | 33 ----- .../android/dbflow/annotation/Migration.kt | 25 ++++ .../dbflow/annotation/ModelCacheField.java | 14 --- .../dbflow/annotation/ModelCacheField.kt | 8 ++ .../android/dbflow/annotation/ModelView.java | 42 ------- .../android/dbflow/annotation/ModelView.kt | 32 +++++ .../dbflow/annotation/ModelViewQuery.java | 18 --- .../dbflow/annotation/ModelViewQuery.kt | 12 ++ .../dbflow/annotation/MultiCacheField.java | 15 --- .../dbflow/annotation/MultiCacheField.kt | 9 ++ .../dbflow/annotation/MultipleManyToMany.java | 16 --- .../dbflow/annotation/MultipleManyToMany.kt | 8 ++ .../android/dbflow/annotation/NotNull.java | 22 ---- .../android/dbflow/annotation/NotNull.kt | 14 +++ .../android/dbflow/annotation/OneToMany.java | 68 ---------- .../android/dbflow/annotation/OneToMany.kt | 56 +++++++++ .../android/dbflow/annotation/PrimaryKey.java | 31 ----- .../android/dbflow/annotation/PrimaryKey.kt | 22 ++++ .../android/dbflow/annotation/QueryModel.java | 26 ---- .../android/dbflow/annotation/QueryModel.kt | 20 +++ .../android/dbflow/annotation/Table.java | 111 ---------------- .../android/dbflow/annotation/Table.kt | 90 +++++++++++++ .../dbflow/annotation/TypeConverter.java | 22 ---- .../dbflow/annotation/TypeConverter.kt | 17 +++ .../android/dbflow/annotation/Unique.java | 33 ----- .../android/dbflow/annotation/Unique.kt | 24 ++++ .../dbflow/annotation/UniqueGroup.java | 24 ---- .../android/dbflow/annotation/UniqueGroup.kt | 16 +++ .../annotation/provider/ContentProvider.java | 29 ----- .../annotation/provider/ContentProvider.kt | 22 ++++ .../annotation/provider/ContentUri.java | 77 ------------ .../dbflow/annotation/provider/ContentUri.kt | 63 ++++++++++ .../dbflow/annotation/provider/Notify.java | 33 ----- .../dbflow/annotation/provider/Notify.kt | 25 ++++ .../annotation/provider/TableEndpoint.java | 24 ---- .../annotation/provider/TableEndpoint.kt | 18 +++ .../dbflow/converter/BigDecimalConverter.java | 18 --- .../dbflow/converter/BigIntegerConverter.java | 18 --- .../dbflow/converter/BooleanConverter.java | 16 --- .../dbflow/converter/CalendarConverter.java | 28 ----- .../dbflow/converter/CharConverter.java | 17 --- .../dbflow/converter/DateConverter.java | 20 --- .../dbflow/converter/SqlDateConverter.java | 23 ---- .../dbflow/converter/TypeConverter.java | 26 ---- .../dbflow/converter/TypeConverters.kt | 119 ++++++++++++++++++ .../dbflow/converter/UUIDConverter.java | 24 ---- .../raizlabs/android/dbflow/data/Blob.java | 32 ----- .../com/raizlabs/android/dbflow/data/Blob.kt | 12 ++ .../android/dbflow/sql/QueryBuilder.java | 2 +- .../android/dbflow/sql/SQLiteType.java | 72 ----------- .../raizlabs/android/dbflow/sql/SQLiteType.kt | 70 +++++++++++ dbflow-rx/build.gradle | 4 +- dbflow-rx2/build.gradle | 4 +- dbflow/build.gradle | 4 +- .../android/dbflow/config/DatabaseConfig.kt | 9 +- .../raizlabs/android/dbflow/sql/SqlUtils.java | 2 +- .../dbflow/structure/ModelAdapter.java | 2 +- 87 files changed, 1100 insertions(+), 1474 deletions(-) delete mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/StringUtils.java create mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/StringUtils.kt rename dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/{Collate.java => Collate.kt} (91%) delete mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Column.java create mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Column.kt delete mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ColumnIgnore.java create mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ColumnIgnore.kt delete mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ColumnMap.java create mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ColumnMap.kt delete mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ColumnMapReference.java create mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ColumnMapReference.kt rename dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/{ConflictAction.java => ConflictAction.kt} (83%) delete mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Database.java create mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Database.kt delete mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ForeignKey.java create mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ForeignKey.kt rename dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/{ForeignKeyAction.java => ForeignKeyAction.kt} (85%) delete mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ForeignKeyReference.java create mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ForeignKeyReference.kt delete mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Index.java create mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Index.kt delete mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/IndexGroup.java create mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/IndexGroup.kt delete mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/InheritedColumn.java create mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/InheritedColumn.kt delete mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/InheritedPrimaryKey.java create mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/InheritedPrimaryKey.kt delete mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ManyToMany.java create mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ManyToMany.kt delete mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Migration.java create mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Migration.kt delete mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ModelCacheField.java create mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ModelCacheField.kt delete mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ModelView.java create mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ModelView.kt delete mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ModelViewQuery.java create mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ModelViewQuery.kt delete mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/MultiCacheField.java create mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/MultiCacheField.kt delete mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/MultipleManyToMany.java create mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/MultipleManyToMany.kt delete mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/NotNull.java create mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/NotNull.kt delete mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/OneToMany.java create mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/OneToMany.kt delete mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/PrimaryKey.java create mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/PrimaryKey.kt delete mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/QueryModel.java create mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/QueryModel.kt delete mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Table.java create mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Table.kt delete mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/TypeConverter.java create mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/TypeConverter.kt delete mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Unique.java create mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Unique.kt delete mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/UniqueGroup.java create mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/UniqueGroup.kt delete mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/ContentProvider.java create mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/ContentProvider.kt delete mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/ContentUri.java create mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/ContentUri.kt delete mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/Notify.java create mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/Notify.kt delete mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/TableEndpoint.java create mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/TableEndpoint.kt delete mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/converter/BigDecimalConverter.java delete mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/converter/BigIntegerConverter.java delete mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/converter/BooleanConverter.java delete mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/converter/CalendarConverter.java delete mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/converter/CharConverter.java delete mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/converter/DateConverter.java delete mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/converter/SqlDateConverter.java delete mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/converter/TypeConverter.java create mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/converter/TypeConverters.kt delete mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/converter/UUIDConverter.java delete mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/data/Blob.java create mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/data/Blob.kt delete mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/sql/SQLiteType.java create mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/sql/SQLiteType.kt diff --git a/dbflow-core/build.gradle b/dbflow-core/build.gradle index 88f43508f..c113e4469 100644 --- a/dbflow-core/build.gradle +++ b/dbflow-core/build.gradle @@ -3,8 +3,8 @@ apply plugin: 'kotlin' project.ext.artifactId = bt_name -targetCompatibility = JavaVersion.VERSION_1_7 -sourceCompatibility = JavaVersion.VERSION_1_7 +targetCompatibility = JavaVersion.VERSION_1_8 +sourceCompatibility = JavaVersion.VERSION_1_8 dependencies { compile "org.jetbrains.kotlin:kotlin-stdlib-jre8:$kotlin_version" @@ -14,6 +14,6 @@ apply from: '../java-artifacts.gradle' compileKotlin { kotlinOptions { - jvmTarget = "1.7" + jvmTarget = "1.6" } } \ No newline at end of file diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/StringUtils.java b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/StringUtils.java deleted file mode 100644 index 5079697fb..000000000 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/StringUtils.java +++ /dev/null @@ -1,21 +0,0 @@ -package com.raizlabs.android.dbflow; - -/** - * Description: Provides handy method for strings - */ -public class StringUtils { - - /** - * @return true if the string is not null, empty string "", or the length is greater than 0 - */ - public static boolean isNotNullOrEmpty(String inString) { - return inString != null && !inString.equals("") && inString.length() > 0; - } - - /** - * @return true if the string is null, empty string "", or the length is less than equal to 0 - */ - public static boolean isNullOrEmpty(String inString) { - return inString == null || inString.equals("") || inString.length() <= 0; - } -} diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/StringUtils.kt b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/StringUtils.kt new file mode 100644 index 000000000..e32be2b76 --- /dev/null +++ b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/StringUtils.kt @@ -0,0 +1,21 @@ +package com.raizlabs.android.dbflow + +/** + * Description: Provides handy method for strings + */ +object StringUtils { + + /** + * @return true if the string is not null, empty string "", or the length is greater than 0 + */ + @JvmStatic + fun isNotNullOrEmpty(inString: String?): Boolean = + inString != null && inString != "" && inString.isNotEmpty() + + /** + * @return true if the string is null, empty string "", or the length is less than equal to 0 + */ + @JvmStatic + fun isNullOrEmpty(inString: String?): Boolean = + inString == null || inString == "" || inString.isEmpty() +} diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Collate.java b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Collate.kt similarity index 91% rename from dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Collate.java rename to dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Collate.kt index c55e2ffaa..0355502d7 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Collate.java +++ b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Collate.kt @@ -1,9 +1,9 @@ -package com.raizlabs.android.dbflow.annotation; +package com.raizlabs.android.dbflow.annotation /** * Represents a SQL Collate method for comparing string columns. */ -public enum Collate { +enum class Collate { /** * Tells the table creation and condition that we wont use collation diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Column.java b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Column.java deleted file mode 100644 index e5b88f9cd..000000000 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Column.java +++ /dev/null @@ -1,58 +0,0 @@ -package com.raizlabs.android.dbflow.annotation; - -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; - -/** - * Description: Marks a field as corresponding to a column in the DB. - * When adding new columns or changing names, you need to define a new {@link Migration}. - */ -@Retention(RetentionPolicy.SOURCE) -@Target(ElementType.FIELD) -public @interface Column { - - /** - * @return The name of the column. The default is the field name. - */ - String name() default ""; - - /** - * @return An optional column length - */ - int length() default -1; - - /** - * @return Marks the field as having a specified collation to use in it's creation. - */ - Collate collate() default Collate.NONE; - - /** - * @return Adds a default value for this column when saving. This is a string representation - * of the value. - * Note this will place it in when saving - * to the DB because we cannot know the intention of missing data from a query. - */ - String defaultValue() default ""; - - /** - * @return If private, by default this is get{Name}() for "name". To define a custom one, this method specifies the name - * of the method only, and not any specific params. So for "getAnotherName()" you would use "AnotherName" as the param. - */ - String getterName() default ""; - - /** - * @return If private, by default this is set{Name}() for "name". To define a custom one, this method specifies the name - * of the method only, and not any specific params. So for "setAnotherName(String name)" you would use "AnotherName" as the param. - * The params must align exactly to an expected setter, otherwise a compile error ensues. - */ - String setterName() default ""; - - /** - * @return A custom type converter that's only used for this field. It will be created and used in - * the Adapter associated with this table. - */ - Class typeConverter() default com.raizlabs.android.dbflow.converter.TypeConverter.class; - -} diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Column.kt b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Column.kt new file mode 100644 index 000000000..d64c81863 --- /dev/null +++ b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Column.kt @@ -0,0 +1,46 @@ +package com.raizlabs.android.dbflow.annotation + +import kotlin.reflect.KClass + +/** + * Description: Marks a field as corresponding to a column in the DB. + * When adding new columns or changing names, you need to define a new [Migration]. + */ +@Retention(AnnotationRetention.SOURCE) +@Target(AnnotationTarget.FIELD) +annotation class Column( + /** + * @return The name of the column. The default is the field name. + */ + val name: String = "", + /** + * @return An optional column length + */ + val length: Int = -1, + /** + * @return Marks the field as having a specified collation to use in it's creation. + */ + val collate: Collate = Collate.NONE, + /** + * @return Adds a default value for this column when saving. This is a string representation + * of the value. + * Note this will place it in when saving + * to the DB because we cannot know the intention of missing data from a query. + */ + val defaultValue: String = "", + /** + * @return If private, by default this is get{Name}() for "name". To define a custom one, this method specifies the name + * of the method only, and not any specific params. So for "getAnotherName()" you would use "AnotherName" as the param. + */ + val getterName: String = "", + /** + * @return If private, by default this is set{Name}() for "name". To define a custom one, this method specifies the name + * of the method only, and not any specific params. So for "setAnotherName(String name)" you would use "AnotherName" as the param. + * The params must align exactly to an expected setter, otherwise a compile error ensues. + */ + val setterName: String = "", + /** + * @return A custom type converter that's only used for this field. It will be created and used in + * the Adapter associated with this table. + */ + val typeConverter: KClass> = com.raizlabs.android.dbflow.converter.TypeConverter::class) diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ColumnIgnore.java b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ColumnIgnore.java deleted file mode 100644 index 100771bdd..000000000 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ColumnIgnore.java +++ /dev/null @@ -1,14 +0,0 @@ -package com.raizlabs.android.dbflow.annotation; - -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; - -/** - * Description: An annotation used to ignore a column in the {@link Table#allFields()} instance. - */ -@Retention(RetentionPolicy.CLASS) -@Target(ElementType.FIELD) -public @interface ColumnIgnore { -} diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ColumnIgnore.kt b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ColumnIgnore.kt new file mode 100644 index 000000000..29d4ed5f9 --- /dev/null +++ b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ColumnIgnore.kt @@ -0,0 +1,8 @@ +package com.raizlabs.android.dbflow.annotation + +/** + * Description: An annotation used to ignore a column in the [Table.allFields] instance. + */ +@Retention(AnnotationRetention.SOURCE) +@Target(AnnotationTarget.FIELD) +annotation class ColumnIgnore diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ColumnMap.java b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ColumnMap.java deleted file mode 100644 index 95524fca7..000000000 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ColumnMap.java +++ /dev/null @@ -1,22 +0,0 @@ -package com.raizlabs.android.dbflow.annotation; - -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; - -/** - * Description: Maps an arbitrary object and its corresponding fields into a set of columns. It is similar - * to {@link ForeignKey} except it's not represented in the DB hierarchy. - */ -@Retention(RetentionPolicy.CLASS) -@Target(ElementType.FIELD) -public @interface ColumnMap { - - /** - * Defines explicit references for a composite {@link ColumnMap} definition. - * - * @return override explicit usage of all fields and provide custom references. - */ - ColumnMapReference[] references() default {}; -} diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ColumnMap.kt b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ColumnMap.kt new file mode 100644 index 000000000..27089ba35 --- /dev/null +++ b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ColumnMap.kt @@ -0,0 +1,15 @@ +package com.raizlabs.android.dbflow.annotation + +/** + * Description: Maps an arbitrary object and its corresponding fields into a set of columns. It is similar + * to [ForeignKey] except it's not represented in the DB hierarchy. + */ +@Retention(AnnotationRetention.BINARY) +@Target(AnnotationTarget.FIELD) +annotation class ColumnMap( + /** + * Defines explicit references for a composite [ColumnMap] definition. + * + * @return override explicit usage of all fields and provide custom references. + */ + val references: Array = arrayOf()) diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ColumnMapReference.java b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ColumnMapReference.java deleted file mode 100644 index c944d5be4..000000000 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ColumnMapReference.java +++ /dev/null @@ -1,30 +0,0 @@ -package com.raizlabs.android.dbflow.annotation; - -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; - -/** - * Description: Allows a {@link ColumnMap} to specify a reference override for its fields. Anything not - * defined here will not be used. - */ -@Retention(RetentionPolicy.CLASS) -@Target(ElementType.FIELD) -public @interface ColumnMapReference { - - /** - * @return The local column name that will be referenced in the DB - */ - String columnName(); - - /** - * @return The column name in the referenced table - */ - String columnMapFieldName(); - - /** - * @return Specify the {@link NotNull} annotation here and it will get pasted into the reference definition. - */ - NotNull notNull() default @NotNull(onNullConflict = ConflictAction.NONE); -} diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ColumnMapReference.kt b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ColumnMapReference.kt new file mode 100644 index 000000000..de882d401 --- /dev/null +++ b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ColumnMapReference.kt @@ -0,0 +1,21 @@ +package com.raizlabs.android.dbflow.annotation + +/** + * Description: Allows a [ColumnMap] to specify a reference override for its fields. Anything not + * defined here will not be used. + */ +@Retention(AnnotationRetention.BINARY) +@Target(AnnotationTarget.FIELD) +annotation class ColumnMapReference( + /** + * @return The local column name that will be referenced in the DB + */ + val columnName: String, + /** + * @return The column name in the referenced table + */ + val columnMapFieldName: String, + /** + * @return Specify the [NotNull] annotation here and it will get pasted into the reference definition. + */ + val notNull: NotNull = NotNull(onNullConflict = ConflictAction.NONE)) diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ConflictAction.java b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ConflictAction.kt similarity index 83% rename from dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ConflictAction.java rename to dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ConflictAction.kt index 2d4e1e6ee..6081639c1 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ConflictAction.java +++ b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ConflictAction.kt @@ -1,10 +1,10 @@ -package com.raizlabs.android.dbflow.annotation; +package com.raizlabs.android.dbflow.annotation /** - * This is how to resolve null or unique conflicts with a field marked as {@link NotNull} - * or {@link Unique} + * This is how to resolve null or unique conflicts with a field marked as [NotNull] + * or [Unique] */ -public enum ConflictAction { +enum class ConflictAction { /** * Do nothing and do not specify any algorithm. @@ -15,7 +15,7 @@ public enum ConflictAction { * When an applicable constraint violation occurs, the ROLLBACK resolution algorithm aborts the * current SQL statement with an SQLITE_CONSTRAINT error and rolls back the current transaction. * If no transaction is active (other than the implied transaction that is created on every command) - * then the ROLLBACK resolution algorithm works the same as the {@link #ABORT} algorithm. + * then the ROLLBACK resolution algorithm works the same as the [.ABORT] algorithm. */ ROLLBACK, @@ -60,20 +60,18 @@ public enum ConflictAction { */ REPLACE; - public static int getSQLiteDatabaseAlgorithmInt(ConflictAction conflictAction) { - switch (conflictAction) { - case ROLLBACK: - return 1; - case ABORT: - return 2; - case FAIL: - return 3; - case IGNORE: - return 4; - case REPLACE: - return 5; - default: - return 0; - } + + companion object { + + @JvmStatic + fun getSQLiteDatabaseAlgorithmInt(conflictAction: ConflictAction) = + when (conflictAction) { + ROLLBACK -> 1 + ABORT -> 2 + FAIL -> 3 + IGNORE -> 4 + REPLACE -> 5 + else -> 0 + } } } diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Database.java b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Database.java deleted file mode 100644 index 293edacb0..000000000 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Database.java +++ /dev/null @@ -1,82 +0,0 @@ -package com.raizlabs.android.dbflow.annotation; - -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; - -/** - * Description: Creates a new database to use in the application. - *

- * If we specify one DB, then all models do not need to specify a DB. As soon as we specify two, then each - * model needs to define what DB it points to. - *

- *

- * Models will specify which DB it belongs to, - * but they currently can only belong to one DB. - *

- */ -@Target(ElementType.TYPE) -@Retention(RetentionPolicy.SOURCE) -public @interface Database { - - /** - * @return The current version of the DB. Increment it to trigger a DB update. - */ - int version(); - - /** - * @deprecated use DatabaseConfig.databaseName() to change the name. - */ - @Deprecated - String name() default ""; - - /** - * @deprecated use DatabaseConfig.extension() to change the extension. - */ - @Deprecated - String databaseExtension() default ""; - - /** - * @deprecated use DatabaseConfig.inMemoryBuilder() instead. - */ - @Deprecated - boolean inMemory() default false; - - /** - * @return If true, SQLite will throw exceptions when {@link ForeignKey} constraints are not respected. - * Default is false and will not throw exceptions. - */ - boolean foreignKeyConstraintsEnforced() default false; - - /** - * @return Checks for consistency in the DB, if true it will recopy over the prepackage database. - */ - boolean consistencyCheckEnabled() default false; - - /** - * @return Keeps a backup for whenever the database integrity fails a "PRAGMA quick_check(1)" that will - * replace the corrupted DB - */ - boolean backupEnabled() default false; - - /** - * @return Global default insert conflict that can be applied to any table when it leaves - * its {@link ConflictAction} as NONE. - */ - ConflictAction insertConflict() default ConflictAction.NONE; - - /** - * @return Global update conflict that can be applied to any table when it leaves its - * {@link ConflictAction} as NONE - */ - ConflictAction updateConflict() default ConflictAction.NONE; - - /** - * @return Marks all generated classes within this database with this character. For example - * "TestTable" becomes "TestTable$Table" for a "$" separator. - * @deprecated Generated class files will become '_' only in next major release. - */ - @Deprecated - String generatedClassSeparator() default "_"; -} diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Database.kt b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Database.kt new file mode 100644 index 000000000..91f585bf8 --- /dev/null +++ b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Database.kt @@ -0,0 +1,58 @@ +package com.raizlabs.android.dbflow.annotation + +/** + * Description: Creates a new database to use in the application. + * + * + * If we specify one DB, then all models do not need to specify a DB. As soon as we specify two, then each + * model needs to define what DB it points to. + * + * + * + * Models will specify which DB it belongs to, + * but they currently can only belong to one DB. + * + */ +@Target(AnnotationTarget.CLASS, AnnotationTarget.FILE) +@Retention(AnnotationRetention.SOURCE) +annotation class Database( + /** + * @return The current version of the DB. Increment it to trigger a DB update. + */ + val version: Int, + @Deprecated("use DatabaseConfig.databaseName() to change the name.") + val name: String = "", + @Deprecated("use DatabaseConfig.extension() to change the extension.") + val databaseExtension: String = "", + @Deprecated("use DatabaseConfig.inMemoryBuilder() instead.") + val inMemory: Boolean = false, + /** + * @return If true, SQLite will throw exceptions when [ForeignKey] constraints are not respected. + * Default is false and will not throw exceptions. + */ + val foreignKeyConstraintsEnforced: Boolean = false, + /** + * @return Checks for consistency in the DB, if true it will recopy over the prepackage database. + */ + val consistencyCheckEnabled: Boolean = false, + /** + * @return Keeps a backup for whenever the database integrity fails a "PRAGMA quick_check(1)" that will + * replace the corrupted DB + */ + val backupEnabled: Boolean = false, + /** + * @return Global default insert conflict that can be applied to any table when it leaves + * its [ConflictAction] as NONE. + */ + val insertConflict: ConflictAction = ConflictAction.NONE, + /** + * @return Global update conflict that can be applied to any table when it leaves its + * [ConflictAction] as NONE + */ + val updateConflict: ConflictAction = ConflictAction.NONE, + /** + * @return Marks all generated classes within this database with this character. For example + * "TestTable" becomes "TestTable$Table" for a "$" separator. + */ + @Deprecated("Generated class files will become '_' only in next major release.") + val generatedClassSeparator: String = "_") diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ForeignKey.java b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ForeignKey.java deleted file mode 100644 index fb82d308c..000000000 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ForeignKey.java +++ /dev/null @@ -1,76 +0,0 @@ -package com.raizlabs.android.dbflow.annotation; - -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; - -/** - * Description: - */ -@Retention(RetentionPolicy.SOURCE) -@Target(ElementType.FIELD) -public @interface ForeignKey { - - /** - * Defines explicit references for a composite {@link ForeignKey} definition. This is no longer required - * as the library will auto-generate references for you based on the other table's primary keys. - * - * @return the set of explicit references if you wish to have different values than default generated. - */ - ForeignKeyReference[] references() default {}; - - /** - * @return Default false. When this column is a {@link ForeignKey} and table object, - * returning true will save the model before adding the fields to save as a foreign key. - * If false, we expect the field to not change and must save the model manually outside - * of the ModelAdapter before saving the child class. - */ - boolean saveForeignKeyModel() default false; - - /** - * @return Default false. When this column is a {@link ForeignKey} and table object, - * returning true will delte the model before deleting its enclosing child class. - * If false, we expect the field to not change and must delete the model manually outside - * of the ModelAdapter before saving the child class. - */ - boolean deleteForeignKeyModel() default false; - - /** - * @return Replaces legacy ForeignKeyContainer, this method instructs the code generator to only - * populate the model with the {@link ForeignKeyReference} defined in this field. This skips - * the Select retrieval convenience. - */ - boolean stubbedRelationship() default false; - - /** - * @return If true, during a transaction, FK constraints are not violated immediately until the resulting transaction commits. - * This is useful for out of order foreign key operations. - * @see Deferred Foreign Key Constraints - */ - boolean deferred() default false; - - /** - * @return an optional table class that this reference points to. It's only used if the field - * is NOT a Model class. - */ - Class tableClass() default Object.class; - - /** - * Defines {@link ForeignKeyAction} action to be performed - * on delete of referenced record. Defaults to {@link ForeignKeyAction#NO_ACTION}. Used only when - * columnType is {@link ForeignKey}. - * - * @return {@link ForeignKeyAction} - */ - ForeignKeyAction onDelete() default ForeignKeyAction.NO_ACTION; - - /** - * Defines {@link ForeignKeyAction} action to be performed - * on update of referenced record. Defaults to {@link ForeignKeyAction#NO_ACTION}. Used only when - * columnType is {@link ForeignKey}. - * - * @return {@link ForeignKeyAction} - */ - ForeignKeyAction onUpdate() default ForeignKeyAction.NO_ACTION; -} diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ForeignKey.kt b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ForeignKey.kt new file mode 100644 index 000000000..fd658eb05 --- /dev/null +++ b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ForeignKey.kt @@ -0,0 +1,64 @@ +package com.raizlabs.android.dbflow.annotation + +import kotlin.reflect.KClass + +/** + * Description: + */ +@Retention(AnnotationRetention.SOURCE) +@Target(AnnotationTarget.FIELD) +annotation class ForeignKey( + /** + * Defines explicit references for a composite [ForeignKey] definition. This is no longer required + * as the library will auto-generate references for you based on the other table's primary keys. + * + * @return the set of explicit references if you wish to have different values than default generated. + */ + val references: Array = arrayOf(), + /** + * @return Default false. When this column is a [ForeignKey] and table object, + * returning true will save the model before adding the fields to save as a foreign key. + * If false, we expect the field to not change and must save the model manually outside + * of the ModelAdapter before saving the child class. + */ + val saveForeignKeyModel: Boolean = false, + /** + * @return Default false. When this column is a [ForeignKey] and table object, + * returning true will delte the model before deleting its enclosing child class. + * If false, we expect the field to not change and must delete the model manually outside + * of the ModelAdapter before saving the child class. + */ + val deleteForeignKeyModel: Boolean = false, + /** + * @return Replaces legacy ForeignKeyContainer, this method instructs the code generator to only + * populate the model with the [ForeignKeyReference] defined in this field. This skips + * the Select retrieval convenience. + */ + val stubbedRelationship: Boolean = false, + /** + * @return If true, during a transaction, FK constraints are not violated immediately until the resulting transaction commits. + * This is useful for out of order foreign key operations. + * @see [Deferred Foreign Key Constraints](http://www.sqlite.org/foreignkeys.html.fk_deferred) + */ + val deferred: Boolean = false, + /** + * @return an optional table class that this reference points to. It's only used if the field + * is NOT a Model class. + */ + val tableClass: KClass<*> = Any::class, + /** + * Defines [ForeignKeyAction] action to be performed + * on delete of referenced record. Defaults to [ForeignKeyAction.NO_ACTION]. Used only when + * columnType is [ForeignKey]. + * + * @return [ForeignKeyAction] + */ + val onDelete: ForeignKeyAction = ForeignKeyAction.NO_ACTION, + /** + * Defines [ForeignKeyAction] action to be performed + * on update of referenced record. Defaults to [ForeignKeyAction.NO_ACTION]. Used only when + * columnType is [ForeignKey]. + * + * @return [ForeignKeyAction] + */ + val onUpdate: ForeignKeyAction = ForeignKeyAction.NO_ACTION) diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ForeignKeyAction.java b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ForeignKeyAction.kt similarity index 85% rename from dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ForeignKeyAction.java rename to dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ForeignKeyAction.kt index b982d3930..25fd567c2 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ForeignKeyAction.java +++ b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ForeignKeyAction.kt @@ -1,9 +1,9 @@ -package com.raizlabs.android.dbflow.annotation; +package com.raizlabs.android.dbflow.annotation /** * Actions associated with on update and on delete */ -public enum ForeignKeyAction { +enum class ForeignKeyAction { /** * When a parent key is modified or deleted from the database, no special action is taken */ @@ -20,7 +20,7 @@ public enum ForeignKeyAction { */ SET_NULL, /** - * The "SET DEFAULT" actions are similar to {@link ForeignKeyAction#SET_NULL}, except that each of the child key + * The "SET DEFAULT" actions are similar to [ForeignKeyAction.SET_NULL], except that each of the child key * columns is set to contain the columns default value instead of NULL */ SET_DEFAULT, @@ -30,5 +30,5 @@ public enum ForeignKeyAction { * the deleted parent row is also deleted. For an "ON UPDATE CASCADE" action, it means that the values * stored in each dependent child key are modified to match the new parent key values. */ - CASCADE, + CASCADE } diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ForeignKeyReference.java b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ForeignKeyReference.java deleted file mode 100644 index 7cb343b33..000000000 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ForeignKeyReference.java +++ /dev/null @@ -1,31 +0,0 @@ -package com.raizlabs.android.dbflow.annotation; - -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; - -/** - * Description: Used inside of {@link ForeignKey#references()}, describes the - * local column name, type, and referencing table column name. - *

- * Note: the type of the local column must match the - * column type of the referenced column. By using a field as a Model object, - * you will need to ensure the same types are used. - */ -@Retention(RetentionPolicy.SOURCE) -public @interface ForeignKeyReference { - - /** - * @return The local column name that will be referenced in the DB - */ - String columnName(); - - /** - * @return The column name in the referenced table - */ - String foreignKeyColumnName(); - - /** - * @return Specify the {@link NotNull} annotation here and it will get pasted into the reference definition. - */ - NotNull notNull() default @NotNull(onNullConflict = ConflictAction.NONE); -} diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ForeignKeyReference.kt b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ForeignKeyReference.kt new file mode 100644 index 000000000..46dfeb117 --- /dev/null +++ b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ForeignKeyReference.kt @@ -0,0 +1,25 @@ +package com.raizlabs.android.dbflow.annotation + +/** + * Description: Used inside of [ForeignKey.references], describes the + * local column name, type, and referencing table column name. + * + * + * Note: the type of the local column must match the + * column type of the referenced column. By using a field as a Model object, + * you will need to ensure the same types are used. + */ +@Retention(AnnotationRetention.SOURCE) +annotation class ForeignKeyReference( + /** + * @return The local column name that will be referenced in the DB + */ + val columnName: String, + /** + * @return The column name in the referenced table + */ + val foreignKeyColumnName: String, + /** + * @return Specify the [NotNull] annotation here and it will get pasted into the reference definition. + */ + val notNull: NotNull = NotNull(onNullConflict = ConflictAction.NONE)) diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Index.java b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Index.java deleted file mode 100644 index 7939773e1..000000000 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Index.java +++ /dev/null @@ -1,20 +0,0 @@ -package com.raizlabs.android.dbflow.annotation; - -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; - -/** - * Description: Creates an index for a specified {@link Column}. A single column can belong to multiple - * indexes within the same table if you wish. - */ -@Retention(RetentionPolicy.SOURCE) -@Target(ElementType.FIELD) -public @interface Index { - - /** - * @return The set of index groups that this index belongs to. - */ - int[] indexGroups() default {}; -} diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Index.kt b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Index.kt new file mode 100644 index 000000000..ef56efb24 --- /dev/null +++ b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Index.kt @@ -0,0 +1,13 @@ +package com.raizlabs.android.dbflow.annotation + +/** + * Description: Creates an index for a specified [Column]. A single column can belong to multiple + * indexes within the same table if you wish. + */ +@Retention(AnnotationRetention.SOURCE) +@Target(AnnotationTarget.FIELD) +annotation class Index( + /** + * @return The set of index groups that this index belongs to. + */ + val indexGroups: IntArray = intArrayOf()) diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/IndexGroup.java b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/IndexGroup.java deleted file mode 100644 index b4eb07548..000000000 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/IndexGroup.java +++ /dev/null @@ -1,32 +0,0 @@ -package com.raizlabs.android.dbflow.annotation; - -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; - -/** - * Description: - */ -@Target(ElementType.ANNOTATION_TYPE) -@Retention(RetentionPolicy.SOURCE) -public @interface IndexGroup { - - int GENERIC = -1; - - /** - * @return The number that each contained {@link Index} points to, so they can be combined into a single index. - * If {@link #GENERIC}, this will assume a generic index that covers the whole table. - */ - int number() default GENERIC; - - /** - * @return The name of this index. It must be unique from other {@link IndexGroup}. - */ - String name(); - - /** - * @return If true, this will disallow duplicate values to be inserted into the table. - */ - boolean unique() default false; -} diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/IndexGroup.kt b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/IndexGroup.kt new file mode 100644 index 000000000..260eedfbb --- /dev/null +++ b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/IndexGroup.kt @@ -0,0 +1,24 @@ +package com.raizlabs.android.dbflow.annotation + +const val GENERIC = -1 + +/** + * Description: + */ +@Target(AnnotationTarget.ANNOTATION_CLASS) +@Retention(AnnotationRetention.SOURCE) +annotation class IndexGroup( + /** + * @return The number that each contained [Index] points to, so they can be combined into a single index. + * If [.GENERIC], this will assume a generic index that covers the whole table. + */ + val number: Int = GENERIC, + /** + * @return The name of this index. It must be unique from other [IndexGroup]. + */ + val name: String, + /** + * @return If true, this will disallow duplicate values to be inserted into the table. + */ + val unique: Boolean = false) + diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/InheritedColumn.java b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/InheritedColumn.java deleted file mode 100644 index 158ec83ec..000000000 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/InheritedColumn.java +++ /dev/null @@ -1,30 +0,0 @@ -package com.raizlabs.android.dbflow.annotation; - -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; - -/** - * Description: Allows {@link Table} to inherit fields from other objects to make it part of the DB table. - */ -@Target(ElementType.ANNOTATION_TYPE) -@Retention(RetentionPolicy.SOURCE) -public @interface InheritedColumn { - - /** - * @return The column annotation as if it was part of the class - */ - Column column(); - - /** - * @return The field name that an inherited column uses. It must match exactly case-by-case to the field you're referencing. - * If the field is private, the {@link Column} allows you to define getter and setters for it. - */ - String fieldName(); - - /** - * @return If specified other than {@link ConflictAction#NONE}, then we assume {@link NotNull}. - */ - ConflictAction nonNullConflict() default ConflictAction.NONE; -} diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/InheritedColumn.kt b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/InheritedColumn.kt new file mode 100644 index 000000000..d46f64d34 --- /dev/null +++ b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/InheritedColumn.kt @@ -0,0 +1,21 @@ +package com.raizlabs.android.dbflow.annotation + +/** + * Description: Allows [Table] to inherit fields from other objects to make it part of the DB table. + */ +@Target(AnnotationTarget.ANNOTATION_CLASS) +@Retention(AnnotationRetention.SOURCE) +annotation class InheritedColumn( + /** + * @return The column annotation as if it was part of the class + */ + val column: Column, + /** + * @return The field name that an inherited column uses. It must match exactly case-by-case to the field you're referencing. + * If the field is private, the [Column] allows you to define getter and setters for it. + */ + val fieldName: String, + /** + * @return If specified other than [ConflictAction.NONE], then we assume [NotNull]. + */ + val nonNullConflict: ConflictAction = ConflictAction.NONE) diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/InheritedPrimaryKey.java b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/InheritedPrimaryKey.java deleted file mode 100644 index 954e992e1..000000000 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/InheritedPrimaryKey.java +++ /dev/null @@ -1,30 +0,0 @@ -package com.raizlabs.android.dbflow.annotation; - -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; - -/** - * Description: Allows you to specify a non-Column to be inherited and used as a {@link PrimaryKey} - */ -@Target(ElementType.ANNOTATION_TYPE) -@Retention(RetentionPolicy.SOURCE) -public @interface InheritedPrimaryKey { - - /** - * @return The primary key annotation as if it was part of the class - */ - PrimaryKey primaryKey(); - - /** - * @return The column annotation as if it was part of the class - */ - Column column(); - - /** - * @return The field name that an inherited column uses. It must match exactly case-by-case to the field you're referencing. - * If the field is private, the {@link PrimaryKey} allows you to define getter and setters for it. - */ - String fieldName(); -} diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/InheritedPrimaryKey.kt b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/InheritedPrimaryKey.kt new file mode 100644 index 000000000..a35ae914c --- /dev/null +++ b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/InheritedPrimaryKey.kt @@ -0,0 +1,21 @@ +package com.raizlabs.android.dbflow.annotation + +/** + * Description: Allows you to specify a non-Column to be inherited and used as a [PrimaryKey] + */ +@Target(AnnotationTarget.ANNOTATION_CLASS) +@Retention(AnnotationRetention.SOURCE) +annotation class InheritedPrimaryKey( + /** + * @return The primary key annotation as if it was part of the class + */ + val primaryKey: PrimaryKey, + /** + * @return The column annotation as if it was part of the class + */ + val column: Column, + /** + * @return The field name that an inherited column uses. It must match exactly case-by-case to the field you're referencing. + * If the field is private, the [PrimaryKey] allows you to define getter and setters for it. + */ + val fieldName: String) diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ManyToMany.java b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ManyToMany.java deleted file mode 100644 index 731c7ca2a..000000000 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ManyToMany.java +++ /dev/null @@ -1,52 +0,0 @@ -package com.raizlabs.android.dbflow.annotation; - -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; - -/** - * Description: Builds a many-to-many relationship with another {@link Table}. Only one table needs to specify - * the annotation and its assumed that they use primary keys only. The generated - * class will contain an auto-incrementing primary key by default. - */ -@Retention(RetentionPolicy.SOURCE) -@Target(ElementType.TYPE) -public @interface ManyToMany { - - /** - * @return The other table class by which this will get merged. - */ - Class referencedTable(); - - /** - * @return A name that we use as the column name for the referenced table in the - * generated ManyToMany table class. - */ - String referencedTableColumnName() default ""; - - /** - * @return A name that we use as the column name for this specific table's name. - */ - String thisTableColumnName() default ""; - - /** - * @return By default, we generate an auto-incrementing {@link Long} {@link PrimaryKey}. - * If false, all {@link PrimaryKey} of the corresponding tables will be placed as {@link ForeignKey} and {@link PrimaryKey} - * of the generated table instead of using an autoincrementing Long {@link PrimaryKey}. - */ - boolean generateAutoIncrement() default true; - - /** - * @return by default, we append {selfTable}{generatedClassSeparator}{referencedTable} or "User_Follower", - * for example. If you want different name, change this. - */ - String generatedTableClassName() default ""; - - /** - * @return by default the Models referenced here are not saved prior to saving this - * object for obvious efficiency reasons. - * @see ForeignKey#saveForeignKeyModel() - */ - boolean saveForeignKeyModels() default false; -} diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ManyToMany.kt b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ManyToMany.kt new file mode 100644 index 000000000..e0438964c --- /dev/null +++ b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ManyToMany.kt @@ -0,0 +1,42 @@ +package com.raizlabs.android.dbflow.annotation + +import kotlin.reflect.KClass + +/** + * Description: Builds a many-to-many relationship with another [Table]. Only one table needs to specify + * the annotation and its assumed that they use primary keys only. The generated + * class will contain an auto-incrementing primary key by default. + */ +@Retention(AnnotationRetention.SOURCE) +@Target(AnnotationTarget.CLASS, AnnotationTarget.FILE) +annotation class ManyToMany( + /** + * @return The other table class by which this will get merged. + */ + val referencedTable: KClass<*>, + /** + * @return A name that we use as the column name for the referenced table in the + * generated ManyToMany table class. + */ + val referencedTableColumnName: String = "", + /** + * @return A name that we use as the column name for this specific table's name. + */ + val thisTableColumnName: String = "", + /** + * @return By default, we generate an auto-incrementing [Long] [PrimaryKey]. + * If false, all [PrimaryKey] of the corresponding tables will be placed as [ForeignKey] and [PrimaryKey] + * of the generated table instead of using an autoincrementing Long [PrimaryKey]. + */ + val generateAutoIncrement: Boolean = true, + /** + * @return by default, we append {selfTable}{generatedClassSeparator}{referencedTable} or "User_Follower", + * for example. If you want different name, change this. + */ + val generatedTableClassName: String = "", + /** + * @return by default the Models referenced here are not saved prior to saving this + * object for obvious efficiency reasons. + * @see ForeignKey.saveForeignKeyModel + */ + val saveForeignKeyModels: Boolean = false) diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Migration.java b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Migration.java deleted file mode 100644 index 56af5bfad..000000000 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Migration.java +++ /dev/null @@ -1,33 +0,0 @@ -package com.raizlabs.android.dbflow.annotation; - -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; - -/** - * Description: Marks a Migration class to be included in DB construction. The class using this annotation - * must implement the Migration interface. - */ -@Retention(RetentionPolicy.SOURCE) -@Target(ElementType.TYPE) -public @interface Migration { - - /** - * @return The version the migration will trigger at. - */ - int version(); - - /** - * @return Specify the database class that this migration belongs to. - */ - Class database(); - - /** - * @return If number greater than -1, the migrations from the same {@link #version()} get ordered from - * highest to lowest. if they are the same priority, there is no telling which one is executed first. The - * annotation processor will process in order it finds the classes. - */ - int priority() default -1; - -} diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Migration.kt b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Migration.kt new file mode 100644 index 000000000..ea3eb548b --- /dev/null +++ b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Migration.kt @@ -0,0 +1,25 @@ +package com.raizlabs.android.dbflow.annotation + +import kotlin.reflect.KClass + +/** + * Description: Marks a Migration class to be included in DB construction. The class using this annotation + * must implement the Migration interface. + */ +@Retention(AnnotationRetention.SOURCE) +@Target(AnnotationTarget.CLASS, AnnotationTarget.FILE) +annotation class Migration( + /** + * @return The version the migration will trigger at. + */ + val version: Int, + /** + * @return Specify the database class that this migration belongs to. + */ + val database: KClass<*>, + /** + * @return If number greater than -1, the migrations from the same [.version] get ordered from + * highest to lowest. if they are the same priority, there is no telling which one is executed first. The + * annotation processor will process in order it finds the classes. + */ + val priority: Int = -1) diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ModelCacheField.java b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ModelCacheField.java deleted file mode 100644 index 9bd97db3f..000000000 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ModelCacheField.java +++ /dev/null @@ -1,14 +0,0 @@ -package com.raizlabs.android.dbflow.annotation; - -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; - -/** - * Description: marks a single field as a ModelCache creator that is used in the corresponding ModelAdapter. - */ -@Target(ElementType.FIELD) -@Retention(RetentionPolicy.SOURCE) -public @interface ModelCacheField { -} diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ModelCacheField.kt b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ModelCacheField.kt new file mode 100644 index 000000000..ea03091fa --- /dev/null +++ b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ModelCacheField.kt @@ -0,0 +1,8 @@ +package com.raizlabs.android.dbflow.annotation + +/** + * Description: marks a single field as a ModelCache creator that is used in the corresponding ModelAdapter. + */ +@Target(AnnotationTarget.FIELD) +@Retention(AnnotationRetention.SOURCE) +annotation class ModelCacheField diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ModelView.java b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ModelView.java deleted file mode 100644 index 67e43f24b..000000000 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ModelView.java +++ /dev/null @@ -1,42 +0,0 @@ -package com.raizlabs.android.dbflow.annotation; - -import com.raizlabs.android.dbflow.sql.Query; - -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; - -/** - * Author: andrewgrosner - * Description: Marks a class as being an SQL VIEW definition. It must extend BaseModelView and have - * a single public, static, final field that is annotated with {@link ModelViewQuery} and be a {@link Query}. - */ -@Retention(RetentionPolicy.SOURCE) -@Target(ElementType.TYPE) -public @interface ModelView { - - /** - * @return The name of this view. Default is the class name. - */ - String name() default ""; - - /** - * @return The class of the database this corresponds to. - */ - Class database(); - - - /** - * @return When true, all public, package-private , non-static, and non-final fields of the reference class are considered as {@link com.raizlabs.android.dbflow.annotation.Column} . - * The only required annotated field becomes The {@link PrimaryKey} - * or {@link PrimaryKey#autoincrement()}. - */ - boolean allFields() default false; - - /** - * @return The higher the number, the order by which the creation of this class gets called. - * Useful for creating ones that depend on another {@link ModelView}. - */ - int priority() default 0; -} diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ModelView.kt b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ModelView.kt new file mode 100644 index 000000000..0ea30e1c3 --- /dev/null +++ b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ModelView.kt @@ -0,0 +1,32 @@ +package com.raizlabs.android.dbflow.annotation + +import com.raizlabs.android.dbflow.sql.Query +import kotlin.reflect.KClass + +/** + * Author: andrewgrosner + * Description: Marks a class as being an SQL VIEW definition. It must extend BaseModelView and have + * a single public, static, final field that is annotated with [ModelViewQuery] and be a [Query]. + */ +@Retention(AnnotationRetention.SOURCE) +@Target(AnnotationTarget.CLASS, AnnotationTarget.FILE) +annotation class ModelView( + /** + * @return The name of this view. Default is the class name. + */ + val name: String = "", + /** + * @return The class of the database this corresponds to. + */ + val database: KClass<*>, + /** + * @return When true, all public, package-private , non-static, and non-final fields of the reference class are considered as [com.raizlabs.android.dbflow.annotation.Column] . + * The only required annotated field becomes The [PrimaryKey] + * or [PrimaryKey.autoincrement]. + */ + val allFields: Boolean = false, + /** + * @return The higher the number, the order by which the creation of this class gets called. + * Useful for creating ones that depend on another [ModelView]. + */ + val priority: Int = 0) diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ModelViewQuery.java b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ModelViewQuery.java deleted file mode 100644 index 351d4d7ec..000000000 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ModelViewQuery.java +++ /dev/null @@ -1,18 +0,0 @@ -package com.raizlabs.android.dbflow.annotation; - -import com.raizlabs.android.dbflow.sql.Query; - -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; - -/** - * Description: Represents a field that is a {@link Query}. This is only meant to be used as a query - * reference in {@link ModelView}. This is so the annotation processor knows how to access the query of - * the view. - */ -@Target(ElementType.FIELD) -@Retention(RetentionPolicy.SOURCE) -public @interface ModelViewQuery { -} diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ModelViewQuery.kt b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ModelViewQuery.kt new file mode 100644 index 000000000..241a7c678 --- /dev/null +++ b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ModelViewQuery.kt @@ -0,0 +1,12 @@ +package com.raizlabs.android.dbflow.annotation + +import com.raizlabs.android.dbflow.sql.Query + +/** + * Description: Represents a field that is a [Query]. This is only meant to be used as a query + * reference in [ModelView]. This is so the annotation processor knows how to access the query of + * the view. + */ +@Target(AnnotationTarget.FIELD) +@Retention(AnnotationRetention.SOURCE) +annotation class ModelViewQuery diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/MultiCacheField.java b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/MultiCacheField.java deleted file mode 100644 index 31006644d..000000000 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/MultiCacheField.java +++ /dev/null @@ -1,15 +0,0 @@ -package com.raizlabs.android.dbflow.annotation; - -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; - -/** - * Description: Marks a field as the IMultiKeyCacheModel that we use to convert multiple fields into - * a single key for caching. - */ -@Target(ElementType.FIELD) -@Retention(RetentionPolicy.SOURCE) -public @interface MultiCacheField { -} diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/MultiCacheField.kt b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/MultiCacheField.kt new file mode 100644 index 000000000..aecb61bbe --- /dev/null +++ b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/MultiCacheField.kt @@ -0,0 +1,9 @@ +package com.raizlabs.android.dbflow.annotation + +/** + * Description: Marks a field as the IMultiKeyCacheModel that we use to convert multiple fields into + * a single key for caching. + */ +@Target(AnnotationTarget.FIELD) +@Retention(AnnotationRetention.SOURCE) +annotation class MultiCacheField diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/MultipleManyToMany.java b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/MultipleManyToMany.java deleted file mode 100644 index d57b2acee..000000000 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/MultipleManyToMany.java +++ /dev/null @@ -1,16 +0,0 @@ -package com.raizlabs.android.dbflow.annotation; - -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; - -/** - * Description: Provides ability to add multiple {@link ManyToMany} annotations at once. - */ -@Retention(RetentionPolicy.SOURCE) -@Target(ElementType.TYPE) -public @interface MultipleManyToMany { - - ManyToMany[] value(); -} diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/MultipleManyToMany.kt b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/MultipleManyToMany.kt new file mode 100644 index 000000000..c9423cfc7 --- /dev/null +++ b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/MultipleManyToMany.kt @@ -0,0 +1,8 @@ +package com.raizlabs.android.dbflow.annotation + +/** + * Description: Provides ability to add multiple [ManyToMany] annotations at once. + */ +@Retention(AnnotationRetention.SOURCE) +@Target(AnnotationTarget.CLASS, AnnotationTarget.FILE) +annotation class MultipleManyToMany(vararg val value: ManyToMany) diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/NotNull.java b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/NotNull.java deleted file mode 100644 index 982af7fb6..000000000 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/NotNull.java +++ /dev/null @@ -1,22 +0,0 @@ -package com.raizlabs.android.dbflow.annotation; - -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; - -/** - * Description: Specifies that a {@link Column} is not null. - */ -@Target(ElementType.FIELD) -@Retention(RetentionPolicy.SOURCE) -public @interface NotNull { - - /** - * Defines how to handle conflicts for not null column - * - * @return a {@link com.raizlabs.android.dbflow.annotation.ConflictAction} enum - */ - ConflictAction onNullConflict() default ConflictAction.FAIL; - -} diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/NotNull.kt b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/NotNull.kt new file mode 100644 index 000000000..10aa945f7 --- /dev/null +++ b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/NotNull.kt @@ -0,0 +1,14 @@ +package com.raizlabs.android.dbflow.annotation + +/** + * Description: Specifies that a [Column] is not null. + */ +@Target(AnnotationTarget.FIELD) +@Retention(AnnotationRetention.SOURCE) +annotation class NotNull( + /** + * Defines how to handle conflicts for not null column + * + * @return a [com.raizlabs.android.dbflow.annotation.ConflictAction] enum + */ + val onNullConflict: ConflictAction = ConflictAction.FAIL) diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/OneToMany.java b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/OneToMany.java deleted file mode 100644 index 175a8cadf..000000000 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/OneToMany.java +++ /dev/null @@ -1,68 +0,0 @@ -package com.raizlabs.android.dbflow.annotation; - -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; -import java.util.List; - -/** - * Description: Describes a 1-many relationship. It applies to some method that returns a {@link List} of Model objects. - * This annotation can handle loading, deleting, and saving when the current data changes. By default it will call the - * associated method when the containing class operates. - */ -@Target(ElementType.METHOD) -@Retention(RetentionPolicy.SOURCE) -public @interface OneToMany { - - /** - * The method to apply the OneToMany to. - */ - enum Method { - - /** - * Load this relationship when the parent model loads from the database. This is called before the OnLoadFromCursor - * method, but after other columns load. - */ - LOAD, - - /** - * Inserts code to delete the results returned from the List relationship when the parent model is deleted. - */ - DELETE, - - /** - * Inserts code to save the list of models when the parent model is saved. - */ - SAVE, - - /** - * Shorthand to support all options. - */ - ALL - } - - /** - * @return The methods you wish to call it from. By default it's loaded out of the DB. - */ - Method[] methods() default Method.LOAD; - - /** - * @return The name of the list variable to use. If is left blank, we will remove the "get" and then decapitalize the remaining name. - */ - String variableName() default ""; - - /** - * @return If true, the underlying variable that we use is private, requiring us to provide - * a setter for it. - * @deprecated has no effect on the visibility of the call since we now autodetect visibility. - */ - @Deprecated - boolean isVariablePrivate() default false; - - /** - * @return If true, the code generated for this relationship done as efficiently as possible. - * It will not work on nested relationships, caching, and other code that requires overriding of BaseModel or Model operations. - */ - boolean efficientMethods() default true; -} diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/OneToMany.kt b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/OneToMany.kt new file mode 100644 index 000000000..e86e0d68e --- /dev/null +++ b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/OneToMany.kt @@ -0,0 +1,56 @@ +package com.raizlabs.android.dbflow.annotation + +/** + * Description: Describes a 1-many relationship. It applies to some method that returns a [List] of Model objects. + * This annotation can handle loading, deleting, and saving when the current data changes. By default it will call the + * associated method when the containing class operates. + */ +@Target(AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER) +@Retention(AnnotationRetention.SOURCE) +annotation class OneToMany( + /** + * @return The methods you wish to call it from. By default it's loaded out of the DB. + */ + val methods: Array = arrayOf(Method.LOAD), + /** + * @return The name of the list variable to use. If is left blank, we will remove the "get" and then decapitalize the remaining name. + */ + val variableName: String = "", + /** + * @return If true, the underlying variable that we use is private, requiring us to provide + * a setter for it. + */ + @Deprecated("has no effect on the visibility of the call since we now autodetect visibility.") + val isVariablePrivate: Boolean = false, + /** + * @return If true, the code generated for this relationship done as efficiently as possible. + * It will not work on nested relationships, caching, and other code that requires overriding of BaseModel or Model operations. + */ + val efficientMethods: Boolean = true) + +/** + * The method to apply the OneToMany to. + */ +enum class Method { + + /** + * Load this relationship when the parent model loads from the database. This is called before the OnLoadFromCursor + * method, but after other columns load. + */ + LOAD, + + /** + * Inserts code to delete the results returned from the List relationship when the parent model is deleted. + */ + DELETE, + + /** + * Inserts code to save the list of models when the parent model is saved. + */ + SAVE, + + /** + * Shorthand to support all options. + */ + ALL +} \ No newline at end of file diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/PrimaryKey.java b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/PrimaryKey.java deleted file mode 100644 index 2d2521412..000000000 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/PrimaryKey.java +++ /dev/null @@ -1,31 +0,0 @@ -package com.raizlabs.android.dbflow.annotation; - -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; - -/** - * Description: - */ -@Retention(RetentionPolicy.SOURCE) -@Target(ElementType.FIELD) -public @interface PrimaryKey { - - /** - * Specifies if the column is autoincrementing or not - */ - boolean autoincrement() default false; - - /** - * Specifies the column to be treated as a ROWID but is not an {@link #autoincrement()}. This - * overrides {@link #autoincrement()} and is mutually exclusive. - */ - boolean rowID() default false; - - /** - * @return When true, we simple do {columnName} > 0 when checking for it's existence if {@link #autoincrement()} - * is true. If not, we do a full database SELECT exists. - */ - boolean quickCheckAutoIncrement() default false; -} diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/PrimaryKey.kt b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/PrimaryKey.kt new file mode 100644 index 000000000..6ce96e18c --- /dev/null +++ b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/PrimaryKey.kt @@ -0,0 +1,22 @@ +package com.raizlabs.android.dbflow.annotation + +/** + * Description: + */ +@Retention(AnnotationRetention.SOURCE) +@Target(AnnotationTarget.FIELD) +annotation class PrimaryKey( + /** + * Specifies if the column is autoincrementing or not + */ + val autoincrement: Boolean = false, + /** + * Specifies the column to be treated as a ROWID but is not an [.autoincrement]. This + * overrides [.autoincrement] and is mutually exclusive. + */ + val rowID: Boolean = false, + /** + * @return When true, we simple do {columnName} > 0 when checking for it's existence if [.autoincrement] + * is true. If not, we do a full database SELECT exists. + */ + val quickCheckAutoIncrement: Boolean = false) diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/QueryModel.java b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/QueryModel.java deleted file mode 100644 index d7295582e..000000000 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/QueryModel.java +++ /dev/null @@ -1,26 +0,0 @@ -package com.raizlabs.android.dbflow.annotation; - -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; - -/** - * Description: Marks a Model class as NOT a {@link Table}, but generates code for retrieving data from a - * generic query - */ -@Retention(RetentionPolicy.SOURCE) -@Target(ElementType.TYPE) -public @interface QueryModel { - - /** - * @return Specify the class of the database to use. - */ - Class database(); - - /** - * @return If true, all accessible, non-static, and non-final fields are treated as valid fields. - * @see Table#allFields() - */ - boolean allFields() default false; -} diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/QueryModel.kt b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/QueryModel.kt new file mode 100644 index 000000000..3c23c3cb6 --- /dev/null +++ b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/QueryModel.kt @@ -0,0 +1,20 @@ +package com.raizlabs.android.dbflow.annotation + +import kotlin.reflect.KClass + +/** + * Description: Marks a Model class as NOT a [Table], but generates code for retrieving data from a + * generic query + */ +@Retention(AnnotationRetention.SOURCE) +@Target(AnnotationTarget.CLASS, AnnotationTarget.FILE) +annotation class QueryModel( + /** + * @return Specify the class of the database to use. + */ + val database: KClass<*>, + /** + * @return If true, all accessible, non-static, and non-final fields are treated as valid fields. + * @see Table.allFields + */ + val allFields: Boolean = false) diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Table.java b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Table.java deleted file mode 100644 index 106e37aed..000000000 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Table.java +++ /dev/null @@ -1,111 +0,0 @@ -package com.raizlabs.android.dbflow.annotation; - -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; - -/** - * Author: andrewgrosner - * Description: Marks a class as being a table for only ONE DB. It must implement the Model interface and all fields MUST be package private. - * This will generate a $Table and $Adapter class. The $Table class generates static final column name variables to reference in queries. - * The $Adapter class defines how to retrieve and store this object as well as other methods for acting on model objects in the database. - */ -@Retention(RetentionPolicy.SOURCE) -@Target(ElementType.TYPE) -public @interface Table { - - int DEFAULT_CACHE_SIZE = 25; - - /** - * @return Specifies a different name for the table than the name of the Model class. - */ - String name() default ""; - - /** - * @return Specify the database class that this table belongs to. It must have the {@link Database} annotation. - */ - Class database(); - - /** - * @return Specify the general conflict algorithm used by this table when updating records. - */ - ConflictAction updateConflict() default ConflictAction.NONE; - - /** - * @return Specify the general insert conflict algorithm used by this table. - */ - ConflictAction insertConflict() default ConflictAction.NONE; - - /** - * @return An optional {@link ConflictAction} that we append to creation for conflict handling in PK. - */ - ConflictAction primaryKeyConflict() default ConflictAction.NONE; - - /** - * @return When true, all public, package-private , non-static, and non-final fields of the reference class are considered as {@link com.raizlabs.android.dbflow.annotation.Column} . - * The only required annotated field becomes The {@link PrimaryKey} - * or {@link PrimaryKey#autoincrement()}. - */ - boolean allFields() default false; - - /** - * @return If true, all private boolean fields will use "is" instead of "get" for its getter and - * "set" without the "is" if it starts with "is" - */ - boolean useBooleanGetterSetters() default true; - - /** - * @return If true, caching mechanism is enabled. This works for single primary key tables. For - * multi-primary key tables, IMultiKeyCacheModel interface is required to specify the caching key. - */ - boolean cachingEnabled() default false; - - /** - * @return If true, we throw away checks for column indexing and simply assume that the cursor returns - * all our columns in order. This may provide a slight performance boost. - */ - boolean orderedCursorLookUp() default false; - - /** - * @return When true, we reassign the corresponding Model's fields to default values when loading - * from cursor. If false, we assign values only if present in Cursor. - */ - boolean assignDefaultValuesFromCursor() default true; - - /** - * @return When false, this table gets generated and associated with database, however it will not immediately - * get created upon startup. This is useful for keeping around legacy tables for migrations. - */ - boolean createWithDatabase() default true; - - /** - * @return The cache size for this Table. - */ - int cacheSize() default 25; - - /** - * @return Declares a set of UNIQUE columns with the corresponding {@link ConflictAction}. A {@link Column} - * will point to this group using {@link Unique#uniqueGroups()} - */ - UniqueGroup[] uniqueColumnGroups() default {}; - - /** - * @return The set of INDEX clauses that specific columns can define to belong to, using the {@link Index} annotation. - * The generated Index properties belong to the corresponding property class to this table. - */ - IndexGroup[] indexGroups() default {}; - - /** - * @return A set of inherited accessible fields not necessarily defined as columns in the super class of this table. - * Each must be accessible via: public, package private, or protected or getter/setters. - */ - InheritedColumn[] inheritedColumns() default {}; - - /** - * @return A set of inherited accessible fields not necessarily defined as columns in the super class of this table. - * Each must be accessible via: public, package private, or protected or getter/setters. - */ - InheritedPrimaryKey[] inheritedPrimaryKeys() default {}; - -} diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Table.kt b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Table.kt new file mode 100644 index 000000000..be2495fef --- /dev/null +++ b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Table.kt @@ -0,0 +1,90 @@ +package com.raizlabs.android.dbflow.annotation + +import kotlin.reflect.KClass + +val DEFAULT_CACHE_SIZE = 25 + +/** + * Author: andrewgrosner + * Description: Marks a class as being a table for only ONE DB. It must implement the Model interface and all fields MUST be package private. + * This will generate a $Table and $Adapter class. The $Table class generates static final column name variables to reference in queries. + * The $Adapter class defines how to retrieve and store this object as well as other methods for acting on model objects in the database. + */ +@Retention(AnnotationRetention.SOURCE) +@Target(AnnotationTarget.CLASS, AnnotationTarget.FILE) +annotation class Table( + /** + * @return Specifies a different name for the table than the name of the Model class. + */ + val name: String = "", + /** + * @return Specify the database class that this table belongs to. It must have the [Database] annotation. + */ + val database: KClass<*>, + /** + * @return Specify the general conflict algorithm used by this table when updating records. + */ + val updateConflict: ConflictAction = ConflictAction.NONE, + /** + * @return Specify the general insert conflict algorithm used by this table. + */ + val insertConflict: ConflictAction = ConflictAction.NONE, + /** + * @return An optional [ConflictAction] that we append to creation for conflict handling in PK. + */ + val primaryKeyConflict: ConflictAction = ConflictAction.NONE, + /** + * @return When true, all public, package-private , non-static, and non-final fields of the reference class are considered as [com.raizlabs.android.dbflow.annotation.Column] . + * The only required annotated field becomes The [PrimaryKey] + * or [PrimaryKey.autoincrement]. + */ + val allFields: Boolean = false, + /** + * @return If true, all private boolean fields will use "is" instead of "get" for its getter and + * "set" without the "is" if it starts with "is" + */ + val useBooleanGetterSetters: Boolean = true, + /** + * @return If true, caching mechanism is enabled. This works for single primary key tables. For + * multi-primary key tables, IMultiKeyCacheModel interface is required to specify the caching key. + */ + val cachingEnabled: Boolean = false, + /** + * @return If true, we throw away checks for column indexing and simply assume that the cursor returns + * all our columns in order. This may provide a slight performance boost. + */ + val orderedCursorLookUp: Boolean = false, + /** + * @return When true, we reassign the corresponding Model's fields to default values when loading + * from cursor. If false, we assign values only if present in Cursor. + */ + val assignDefaultValuesFromCursor: Boolean = true, + /** + * @return When false, this table gets generated and associated with database, however it will not immediately + * get created upon startup. This is useful for keeping around legacy tables for migrations. + */ + val createWithDatabase: Boolean = true, + /** + * @return The cache size for this Table. + */ + val cacheSize: Int = 25, + /** + * @return Declares a set of UNIQUE columns with the corresponding [ConflictAction]. A [Column] + * will point to this group using [Unique.uniqueGroups] + */ + val uniqueColumnGroups: Array = arrayOf(), + /** + * @return The set of INDEX clauses that specific columns can define to belong to, using the [Index] annotation. + * The generated Index properties belong to the corresponding property class to this table. + */ + val indexGroups: Array = arrayOf(), + /** + * @return A set of inherited accessible fields not necessarily defined as columns in the super class of this table. + * Each must be accessible via: public, package private, or protected or getter/setters. + */ + val inheritedColumns: Array = arrayOf(), + /** + * @return A set of inherited accessible fields not necessarily defined as columns in the super class of this table. + * Each must be accessible via: public, package private, or protected or getter/setters. + */ + val inheritedPrimaryKeys: Array = arrayOf()) diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/TypeConverter.java b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/TypeConverter.java deleted file mode 100644 index a99bfaa57..000000000 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/TypeConverter.java +++ /dev/null @@ -1,22 +0,0 @@ -package com.raizlabs.android.dbflow.annotation; - -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; - -/** - * Author: andrewgrosner - * Description: Marks a class as being a TypeConverter. A type converter will turn a non-model, non-SQLiteTyped class into - * a valid database type. - */ -@Retention(RetentionPolicy.CLASS) -@Target(ElementType.TYPE) -public @interface TypeConverter { - - /** - * @return Specify a set of subclasses by which the {@link TypeConverter} registers for. For - * each one, this will create a new instance of the converter. - */ - Class[] allowedSubtypes() default {}; -} diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/TypeConverter.kt b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/TypeConverter.kt new file mode 100644 index 000000000..8f33e3f78 --- /dev/null +++ b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/TypeConverter.kt @@ -0,0 +1,17 @@ +package com.raizlabs.android.dbflow.annotation + +import kotlin.reflect.KClass + +/** + * Author: andrewgrosner + * Description: Marks a class as being a TypeConverter. A type converter will turn a non-model, non-SQLiteTyped class into + * a valid database type. + */ +@Retention(AnnotationRetention.BINARY) +@Target(AnnotationTarget.CLASS, AnnotationTarget.FILE) +annotation class TypeConverter( + /** + * @return Specify a set of subclasses by which the [TypeConverter] registers for. For + * each one, this will create a new instance of the converter. + */ + val allowedSubtypes: Array> = arrayOf()) diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Unique.java b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Unique.java deleted file mode 100644 index 35e762e79..000000000 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Unique.java +++ /dev/null @@ -1,33 +0,0 @@ -package com.raizlabs.android.dbflow.annotation; - -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; - -/** - * Description: Marks the field as unique, meaning its value cannot be repeated. It is, however, - * NOT a primary key. - */ -@Retention(RetentionPolicy.SOURCE) -@Target(ElementType.FIELD) -public @interface Unique { - - /** - * @return if field is unique. If false, we expect {@link #uniqueGroups()} to be specified.` - */ - boolean unique() default true; - - /** - * @return Marks a unique field as part of a unique group. For every unique number entered, - * it will generate a UNIQUE() column statement. - */ - int[] uniqueGroups() default {}; - - /** - * Defines how to handle conflicts for a unique column - * - * @return a {@link com.raizlabs.android.dbflow.annotation.ConflictAction} enum - */ - ConflictAction onUniqueConflict() default ConflictAction.FAIL; -} diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Unique.kt b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Unique.kt new file mode 100644 index 000000000..1d204159f --- /dev/null +++ b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Unique.kt @@ -0,0 +1,24 @@ +package com.raizlabs.android.dbflow.annotation + +/** + * Description: Marks the field as unique, meaning its value cannot be repeated. It is, however, + * NOT a primary key. + */ +@Retention(AnnotationRetention.BINARY) +@Target(AnnotationTarget.FIELD) +annotation class Unique( + /** + * @return if field is unique. If false, we expect [.uniqueGroups] to be specified.` + */ + val unique: Boolean = true, + /** + * @return Marks a unique field as part of a unique group. For every unique number entered, + * it will generate a UNIQUE() column statement. + */ + val uniqueGroups: IntArray = intArrayOf(), + /** + * Defines how to handle conflicts for a unique column + * + * @return a [ConflictAction] enum + */ + val onUniqueConflict: ConflictAction = ConflictAction.FAIL) diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/UniqueGroup.java b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/UniqueGroup.java deleted file mode 100644 index b307ed387..000000000 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/UniqueGroup.java +++ /dev/null @@ -1,24 +0,0 @@ -package com.raizlabs.android.dbflow.annotation; - -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; - -/** - * Description: - */ -@Target(ElementType.ANNOTATION_TYPE) -@Retention(RetentionPolicy.SOURCE) -public @interface UniqueGroup { - - /** - * @return The number that columns point to to use this group - */ - int groupNumber(); - - /** - * @return The conflict action that this group takes. - */ - ConflictAction uniqueConflict() default ConflictAction.FAIL; -} diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/UniqueGroup.kt b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/UniqueGroup.kt new file mode 100644 index 000000000..2240efa86 --- /dev/null +++ b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/UniqueGroup.kt @@ -0,0 +1,16 @@ +package com.raizlabs.android.dbflow.annotation + +/** + * Description: + */ +@Target(AnnotationTarget.ANNOTATION_CLASS) +@Retention(AnnotationRetention.SOURCE) +annotation class UniqueGroup( + /** + * @return The number that columns point to to use this group + */ + val groupNumber: Int, + /** + * @return The conflict action that this group takes. + */ + val uniqueConflict: ConflictAction = ConflictAction.FAIL) diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/ContentProvider.java b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/ContentProvider.java deleted file mode 100644 index e3a8548dd..000000000 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/ContentProvider.java +++ /dev/null @@ -1,29 +0,0 @@ -package com.raizlabs.android.dbflow.annotation.provider; - -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; - -/** - * Description: Defines a Content Provider that gets generated. - */ -@Target(ElementType.TYPE) -@Retention(RetentionPolicy.SOURCE) -public @interface ContentProvider { - - /** - * @return The authority URI for this provider. - */ - String authority(); - - /** - * @return The class of the database this belongs to - */ - Class database(); - - /** - * @return The base content uri String to use for all paths - */ - String baseContentUri() default ""; -} diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/ContentProvider.kt b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/ContentProvider.kt new file mode 100644 index 000000000..c31eb701a --- /dev/null +++ b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/ContentProvider.kt @@ -0,0 +1,22 @@ +package com.raizlabs.android.dbflow.annotation.provider + +import kotlin.reflect.KClass + +/** + * Description: Defines a Content Provider that gets generated. + */ +@Target(AnnotationTarget.CLASS, AnnotationTarget.FILE) +@Retention(AnnotationRetention.SOURCE) +annotation class ContentProvider( + /** + * @return The authority URI for this provider. + */ + val authority: String, + /** + * @return The class of the database this belongs to + */ + val database: KClass<*>, + /** + * @return The base content uri String to use for all paths + */ + val baseContentUri: String = "") diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/ContentUri.java b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/ContentUri.java deleted file mode 100644 index 1b12491e2..000000000 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/ContentUri.java +++ /dev/null @@ -1,77 +0,0 @@ -package com.raizlabs.android.dbflow.annotation.provider; - -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; - -/** - * Description: Defines the URI for a content provider. - */ -@Target({ElementType.FIELD, ElementType.METHOD}) -@Retention(RetentionPolicy.SOURCE) -public @interface ContentUri { - - /** - * Provides some handy constants for defining a {@link #type()} - */ - class ContentType { - - public static final String VND_MULTIPLE = "vnd.android.cursor.dir/"; - - public static final String VND_SINGLE = "vnd.android.cursor.item/"; - } - - /** - * Defines the path segment that we use when we specify "#" in the path. - */ - @interface PathSegment { - - /** - * @return The number segment this corresponds to. - */ - int segment(); - - /** - * @return The column name that this segment will use. - */ - String column(); - } - - /** - * @return the path of this ContentUri. ex: notes/#, notes/1, etc. Must be unique within a {@link TableEndpoint} - */ - String path(); - - /** - * @return The type of content that this uri is associated with. Ex: {@link ContentType#VND_SINGLE} - */ - String type(); - - /** - * @return If the path defines "#", then we use these numbers to find them in the same order as - * where column. - */ - PathSegment[] segments() default {}; - - /** - * @return false if you wish to not allow queries from the specified URI. - */ - boolean queryEnabled() default true; - - /** - * @return false if you wish to prevent inserts. - */ - boolean insertEnabled() default true; - - /** - * @return false if you wish to prevent deletion. - */ - boolean deleteEnabled() default true; - - /** - * @return false if you wish to prevent updates. - */ - boolean updateEnabled() default true; - -} diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/ContentUri.kt b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/ContentUri.kt new file mode 100644 index 000000000..f7825c594 --- /dev/null +++ b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/ContentUri.kt @@ -0,0 +1,63 @@ +package com.raizlabs.android.dbflow.annotation.provider + +/** + * Description: Defines the URI for a content provider. + */ +@Target(AnnotationTarget.FIELD, AnnotationTarget.FUNCTION, + AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER) +@Retention(AnnotationRetention.SOURCE) +annotation class ContentUri( + /** + * @return the path of this ContentUri. ex: notes/#, notes/1, etc. Must be unique within a [TableEndpoint] + */ + val path: String, + /** + * @return The type of content that this uri is associated with. Ex: [ContentType.VND_SINGLE] + */ + val type: String, + /** + * @return If the path defines "#", then we use these numbers to find them in the same order as + * where column. + */ + val segments: Array = arrayOf(), + /** + * @return false if you wish to not allow queries from the specified URI. + */ + val queryEnabled: Boolean = true, + /** + * @return false if you wish to prevent inserts. + */ + val insertEnabled: Boolean = true, + /** + * @return false if you wish to prevent deletion. + */ + val deleteEnabled: Boolean = true, + /** + * @return false if you wish to prevent updates. + */ + val updateEnabled: Boolean = true) + +/** + * Provides some handy constants for defining a [.type] + */ +object ContentType { + + @JvmField + val VND_MULTIPLE = "vnd.android.cursor.dir/" + + @JvmField + val VND_SINGLE = "vnd.android.cursor.item/" +} + +/** + * Defines the path segment that we use when we specify "#" in the path. + */ +annotation class PathSegment( + /** + * @return The number segment this corresponds to. + */ + val segment: Int, + /** + * @return The column name that this segment will use. + */ + val column: String) \ No newline at end of file diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/Notify.java b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/Notify.java deleted file mode 100644 index e678d8dae..000000000 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/Notify.java +++ /dev/null @@ -1,33 +0,0 @@ -package com.raizlabs.android.dbflow.annotation.provider; - -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; - -/** - * Description: Annotates a method part of {@link com.raizlabs.android.dbflow.annotation.provider.TableEndpoint} - * that gets called back when changed. The method must return a Uri or an array of Uri[] to notify changed on - * the content provider. - */ -@Retention(RetentionPolicy.SOURCE) -@Target(ElementType.METHOD) -public @interface Notify { - - enum Method { - INSERT, - UPDATE, - DELETE - } - - /** - * @return The {@link com.raizlabs.android.dbflow.annotation.provider.Notify.Method} notify - */ - Method method(); - - /** - * @return Registers itself for the following paths. If a specific path is called for the specified - * method, the method this annotation corresponds to will be called. - */ - String[] paths() default {}; -} diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/Notify.kt b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/Notify.kt new file mode 100644 index 000000000..c216976ca --- /dev/null +++ b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/Notify.kt @@ -0,0 +1,25 @@ +package com.raizlabs.android.dbflow.annotation.provider + +/** + * Description: Annotates a method part of [com.raizlabs.android.dbflow.annotation.provider.TableEndpoint] + * that gets called back when changed. The method must return a Uri or an array of Uri[] to notify changed on + * the content provider. + */ +@Retention(AnnotationRetention.SOURCE) +@Target(AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER) +annotation class Notify( + /** + * @return The [com.raizlabs.android.dbflow.annotation.provider.Notify.Method] notify + */ + val method: Method, + /** + * @return Registers itself for the following paths. If a specific path is called for the specified + * method, the method this annotation corresponds to will be called. + */ + val paths: Array = arrayOf()) + +enum class Method { + INSERT, + UPDATE, + DELETE +} \ No newline at end of file diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/TableEndpoint.java b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/TableEndpoint.java deleted file mode 100644 index 7251708f0..000000000 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/TableEndpoint.java +++ /dev/null @@ -1,24 +0,0 @@ -package com.raizlabs.android.dbflow.annotation.provider; - -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; - -/** - * Description: Defines an endpoint that gets placed inside of a {@link com.raizlabs.android.dbflow.annotation.provider.ContentProvider} - */ -@Target(ElementType.TYPE) -@Retention(RetentionPolicy.SOURCE) -public @interface TableEndpoint { - - /** - * @return The name of the table this endpoint corresponds to. - */ - String name(); - - /** - * @return When placed in a top-level class, this is required to connect it to a provider. - */ - Class contentProvider(); -} diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/TableEndpoint.kt b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/TableEndpoint.kt new file mode 100644 index 000000000..7ae3cfcc3 --- /dev/null +++ b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/TableEndpoint.kt @@ -0,0 +1,18 @@ +package com.raizlabs.android.dbflow.annotation.provider + +import kotlin.reflect.KClass + +/** + * Description: Defines an endpoint that gets placed inside of a [ContentProvider] + */ +@Target(AnnotationTarget.CLASS, AnnotationTarget.FILE) +@Retention(AnnotationRetention.SOURCE) +annotation class TableEndpoint( + /** + * @return The name of the table this endpoint corresponds to. + */ + val name: String, + /** + * @return When placed in a top-level class, this is required to connect it to a provider. + */ + val contentProvider: KClass<*>) diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/converter/BigDecimalConverter.java b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/converter/BigDecimalConverter.java deleted file mode 100644 index f06249e92..000000000 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/converter/BigDecimalConverter.java +++ /dev/null @@ -1,18 +0,0 @@ -package com.raizlabs.android.dbflow.converter; - -import java.math.BigDecimal; - -/** - * Description: Defines how we store and retrieve a {@link java.math.BigDecimal} - */ -public class BigDecimalConverter extends TypeConverter { - @Override - public String getDBValue(BigDecimal model) { - return model == null ? null : model.toString(); - } - - @Override - public BigDecimal getModelValue(String data) { - return data == null ? null : new BigDecimal(data); - } -} diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/converter/BigIntegerConverter.java b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/converter/BigIntegerConverter.java deleted file mode 100644 index 85826246b..000000000 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/converter/BigIntegerConverter.java +++ /dev/null @@ -1,18 +0,0 @@ -package com.raizlabs.android.dbflow.converter; - -import java.math.BigInteger; - -/** - * Description: Defines how we store and retrieve a {@link java.math.BigInteger} - */ -public class BigIntegerConverter extends TypeConverter { - @Override - public String getDBValue(BigInteger model) { - return model == null ? null : model.toString(); - } - - @Override - public BigInteger getModelValue(String data) { - return data == null ? null : new BigInteger(data); - } -} diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/converter/BooleanConverter.java b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/converter/BooleanConverter.java deleted file mode 100644 index d44a0c34e..000000000 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/converter/BooleanConverter.java +++ /dev/null @@ -1,16 +0,0 @@ -package com.raizlabs.android.dbflow.converter; - -/** - * Description: Converts a boolean object into an Integer for database storage. - */ -public class BooleanConverter extends TypeConverter { - @Override - public Integer getDBValue(Boolean model) { - return model == null ? null : model ? 1 : 0; - } - - @Override - public Boolean getModelValue(Integer data) { - return data == null ? null : data == 1; - } -} diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/converter/CalendarConverter.java b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/converter/CalendarConverter.java deleted file mode 100644 index 2832262c2..000000000 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/converter/CalendarConverter.java +++ /dev/null @@ -1,28 +0,0 @@ -package com.raizlabs.android.dbflow.converter; - -import java.util.Calendar; -import java.util.GregorianCalendar; - -/** - * Author: andrewgrosner - * Description: Defines how we store and retrieve a {@link java.util.Calendar} - */ -@com.raizlabs.android.dbflow.annotation.TypeConverter(allowedSubtypes = {GregorianCalendar.class}) -public class CalendarConverter extends TypeConverter { - - @Override - public Long getDBValue(Calendar model) { - return model == null ? null : model.getTimeInMillis(); - } - - @Override - public Calendar getModelValue(Long data) { - if (data != null) { - Calendar calendar = Calendar.getInstance(); - calendar.setTimeInMillis(data); - return calendar; - } else { - return null; - } - } -} diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/converter/CharConverter.java b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/converter/CharConverter.java deleted file mode 100644 index f7bf81692..000000000 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/converter/CharConverter.java +++ /dev/null @@ -1,17 +0,0 @@ -package com.raizlabs.android.dbflow.converter; - -/** - * Description: Converts a {@link Character} into a {@link String} for database storage. - */ -public class CharConverter extends TypeConverter { - - @Override - public String getDBValue(Character model) { - return model != null ? new String(new char[]{model}) : null; - } - - @Override - public Character getModelValue(String data) { - return data != null ? data.charAt(0) : null; - } -} diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/converter/DateConverter.java b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/converter/DateConverter.java deleted file mode 100644 index 43475b1e0..000000000 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/converter/DateConverter.java +++ /dev/null @@ -1,20 +0,0 @@ -package com.raizlabs.android.dbflow.converter; - -import java.util.Date; - -/** - * Author: andrewgrosner - * Description: Defines how we store and retrieve a {@link java.util.Date} - */ -public class DateConverter extends TypeConverter { - - @Override - public Long getDBValue(Date model) { - return model == null ? null : model.getTime(); - } - - @Override - public Date getModelValue(Long data) { - return data == null ? null : new Date(data); - } -} diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/converter/SqlDateConverter.java b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/converter/SqlDateConverter.java deleted file mode 100644 index b1fa0a7b0..000000000 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/converter/SqlDateConverter.java +++ /dev/null @@ -1,23 +0,0 @@ -package com.raizlabs.android.dbflow.converter; - -import java.sql.Date; -import java.sql.Time; -import java.sql.Timestamp; - -/** - * Author: andrewgrosner - * Description: Defines how we store and retrieve a {@link java.sql.Date} - */ -@com.raizlabs.android.dbflow.annotation.TypeConverter(allowedSubtypes = {Time.class, Timestamp.class}) -public class SqlDateConverter extends TypeConverter { - - @Override - public Long getDBValue(Date model) { - return model == null ? null : model.getTime(); - } - - @Override - public Date getModelValue(Long data) { - return data == null ? null : new Date(data); - } -} diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/converter/TypeConverter.java b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/converter/TypeConverter.java deleted file mode 100644 index f755ae0b1..000000000 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/converter/TypeConverter.java +++ /dev/null @@ -1,26 +0,0 @@ -package com.raizlabs.android.dbflow.converter; - -/** - * Author: andrewgrosner - * Description: This class is responsible for converting the stored database value into the field value in - * a Model. - */ -@com.raizlabs.android.dbflow.annotation.TypeConverter -public abstract class TypeConverter { - - /** - * Converts the ModelClass into a DataClass - * - * @param model this will be called upon syncing - * @return The DataClass value that converts into a SQLite type - */ - public abstract DataClass getDBValue(ModelClass model); - - /** - * Converts a DataClass from the DB into a ModelClass - * - * @param data This will be called when the model is loaded from the DB - * @return The ModelClass value that gets set in a Model that holds the data class. - */ - public abstract ModelClass getModelValue(DataClass data); -} diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/converter/TypeConverters.kt b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/converter/TypeConverters.kt new file mode 100644 index 000000000..a1d2b1fef --- /dev/null +++ b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/converter/TypeConverters.kt @@ -0,0 +1,119 @@ +package com.raizlabs.android.dbflow.converter + +import java.math.BigDecimal +import java.math.BigInteger +import java.sql.Time +import java.sql.Timestamp +import java.util.* + +/** + * Author: andrewgrosner + * Description: This class is responsible for converting the stored database value into the field value in + * a Model. + */ +@com.raizlabs.android.dbflow.annotation.TypeConverter +abstract class TypeConverter { + + /** + * Converts the ModelClass into a DataClass + * + * @param model this will be called upon syncing + * @return The DataClass value that converts into a SQLite type + */ + abstract fun getDBValue(model: ModelClass?): DataClass? + + /** + * Converts a DataClass from the DB into a ModelClass + * + * @param data This will be called when the model is loaded from the DB + * @return The ModelClass value that gets set in a Model that holds the data class. + */ + abstract fun getModelValue(data: DataClass?): ModelClass? +} + +/** + * Description: Defines how we store and retrieve a [java.math.BigDecimal] + */ +class BigDecimalConverter : TypeConverter() { + override fun getDBValue(model: BigDecimal?): String? = model?.toString() + + override fun getModelValue(data: String?): BigDecimal? = if (data == null) null else BigDecimal(data) +} + +/** + * Description: Defines how we store and retrieve a [java.math.BigInteger] + */ +class BigIntegerConverter : TypeConverter() { + override fun getDBValue(model: BigInteger?): String? = model?.toString() + + override fun getModelValue(data: String?): BigInteger? = if (data == null) null else BigInteger(data) +} + +/** + * Description: Converts a boolean object into an Integer for database storage. + */ +class BooleanConverter : TypeConverter() { + override fun getDBValue(model: Boolean?): Int? = if (model == null) null else if (model) 1 else 0 + + override fun getModelValue(data: Int?): Boolean? = if (data == null) null else data == 1 +} + +/** + * Description: Defines how we store and retrieve a [java.util.Calendar] + */ +@com.raizlabs.android.dbflow.annotation.TypeConverter(allowedSubtypes = arrayOf(GregorianCalendar::class)) +class CalendarConverter : TypeConverter() { + + override fun getDBValue(model: Calendar?): Long? = model?.timeInMillis + + override fun getModelValue(data: Long?): Calendar? = + if (data != null) Calendar.getInstance().apply { timeInMillis = data } else null +} + +/** + * Description: Converts a [Character] into a [String] for database storage. + */ +class CharConverter : TypeConverter() { + + override fun getDBValue(model: Char?): String? = + if (model != null) String(charArrayOf(model)) else null + + override fun getModelValue(data: String?): Char? = if (data != null) data[0] else null +} + +/** + * Description: Defines how we store and retrieve a [java.util.Date] + */ +class DateConverter : TypeConverter() { + + override fun getDBValue(model: Date?): Long? = model?.time + + override fun getModelValue(data: Long?): Date? = if (data == null) null else Date(data) +} + +/** + * Description: Defines how we store and retrieve a [java.sql.Date] + */ +@com.raizlabs.android.dbflow.annotation.TypeConverter(allowedSubtypes = arrayOf(Time::class, Timestamp::class)) +class SqlDateConverter : TypeConverter() { + + override fun getDBValue(model: java.sql.Date?): Long? = model?.time + + override fun getModelValue(data: Long?): java.sql.Date? = if (data == null) null else java.sql.Date(data) +} + +/** + * Description: Responsible for converting a [UUID] to a [String]. + * + * @author Andrew Grosner (fuzz) + */ +class UUIDConverter : TypeConverter() { + + override fun getDBValue(model: UUID?): String? = model?.toString() + + override fun getModelValue(data: String?): UUID? { + return if (data == null) { + null + } else UUID.fromString(data) + } +} \ No newline at end of file diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/converter/UUIDConverter.java b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/converter/UUIDConverter.java deleted file mode 100644 index dc26fbe3d..000000000 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/converter/UUIDConverter.java +++ /dev/null @@ -1,24 +0,0 @@ -package com.raizlabs.android.dbflow.converter; - -import java.util.UUID; - -/** - * Description: Responsible for converting a {@link UUID} to a {@link String}. - * - * @author Andrew Grosner (fuzz) - */ -public class UUIDConverter extends TypeConverter { - - @Override - public String getDBValue(UUID model) { - return model != null ? model.toString() : null; - } - - @Override - public UUID getModelValue(String data) { - if (data == null) { - return null; - } - return UUID.fromString(data); - } -} diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/data/Blob.java b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/data/Blob.java deleted file mode 100644 index b879b7ef1..000000000 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/data/Blob.java +++ /dev/null @@ -1,32 +0,0 @@ -package com.raizlabs.android.dbflow.data; - -/** - * Description: Provides a way to support blob format data. - */ -public class Blob { - - private byte[] blob; - - public Blob() { - } - - public Blob(byte[] blob) { - this.blob = blob; - } - - /** - * Sets the underlying blob data. - * - * @param blob The set of bytes to use. - */ - public void setBlob(byte[] blob) { - this.blob = blob; - } - - /** - * @return The blob data. - */ - public byte[] getBlob() { - return blob; - } -} diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/data/Blob.kt b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/data/Blob.kt new file mode 100644 index 000000000..732f1b49d --- /dev/null +++ b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/data/Blob.kt @@ -0,0 +1,12 @@ +package com.raizlabs.android.dbflow.data + +/** + * Description: Provides a way to support blob format data. + */ +class Blob @JvmOverloads constructor( + /** + * Sets the underlying blob data. + * + * @param blob The set of bytes to use. + */ + var blob: ByteArray? = null) diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/sql/QueryBuilder.java b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/sql/QueryBuilder.java index 47e5856a5..b695463c0 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/sql/QueryBuilder.java +++ b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/sql/QueryBuilder.java @@ -97,7 +97,7 @@ public QueryBuilder appendOptional(Object object) { * @return This instance */ public QueryBuilder appendType(String type) { - return appendSQLiteType(SQLiteType.get(type)); + return appendSQLiteType(SQLiteType.Companion.get(type)); } /** diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/sql/SQLiteType.java b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/sql/SQLiteType.java deleted file mode 100644 index be56fa2af..000000000 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/sql/SQLiteType.java +++ /dev/null @@ -1,72 +0,0 @@ -package com.raizlabs.android.dbflow.sql; - -import com.raizlabs.android.dbflow.data.Blob; - -import java.util.HashMap; -import java.util.Map; - -/** - * Description: Represents a type that SQLite understands. - */ -public enum SQLiteType { - - /** - * Represents an integer number in the DB. - */ - INTEGER, - - /** - * Represents a floating-point, precise number. - */ - REAL, - - /** - * Represents text. - */ - TEXT, - - /** - * A column defined by {@link byte[]} data. Usually reserved for images or larger pieces of content. - */ - BLOB; - - private static final Map sTypeMap = new HashMap() { - { - put(byte.class.getName(), SQLiteType.INTEGER); - put(short.class.getName(), SQLiteType.INTEGER); - put(int.class.getName(), SQLiteType.INTEGER); - put(long.class.getName(), SQLiteType.INTEGER); - put(float.class.getName(), SQLiteType.REAL); - put(double.class.getName(), SQLiteType.REAL); - put(boolean.class.getName(), SQLiteType.INTEGER); - put(char.class.getName(), SQLiteType.TEXT); - put(byte[].class.getName(), SQLiteType.BLOB); - put(Byte.class.getName(), SQLiteType.INTEGER); - put(Short.class.getName(), SQLiteType.INTEGER); - put(Integer.class.getName(), SQLiteType.INTEGER); - put(Long.class.getName(), SQLiteType.INTEGER); - put(Float.class.getName(), SQLiteType.REAL); - put(Double.class.getName(), SQLiteType.REAL); - put(Boolean.class.getName(), SQLiteType.INTEGER); - put(Character.class.getName(), SQLiteType.TEXT); - put(CharSequence.class.getName(), SQLiteType.TEXT); - put(String.class.getName(), SQLiteType.TEXT); - put(Byte[].class.getName(), SQLiteType.BLOB); - put(Blob.class.getName(), SQLiteType.BLOB); - } - }; - - /** - * Returns the {@link SQLiteType} for this class - * - * @param className The fully qualified class name - * @return The type from the class name - */ - public static SQLiteType get(String className) { - return sTypeMap.get(className); - } - - public static boolean containsClass(String className) { - return sTypeMap.containsKey(className); - } -} diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/sql/SQLiteType.kt b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/sql/SQLiteType.kt new file mode 100644 index 000000000..1515734e0 --- /dev/null +++ b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/sql/SQLiteType.kt @@ -0,0 +1,70 @@ +package com.raizlabs.android.dbflow.sql + +import com.raizlabs.android.dbflow.data.Blob +import java.util.* + +/** + * Description: Represents a type that SQLite understands. + */ +enum class SQLiteType { + + /** + * Represents an integer number in the DB. + */ + INTEGER, + + /** + * Represents a floating-point, precise number. + */ + REAL, + + /** + * Represents text. + */ + TEXT, + + /** + * A column defined by [byte[]] data. Usually reserved for images or larger pieces of content. + */ + BLOB; + + + companion object { + + private val sTypeMap = object : HashMap() { + init { + put(Byte::class.javaPrimitiveType!!.name, SQLiteType.INTEGER) + put(Short::class.javaPrimitiveType!!.name, SQLiteType.INTEGER) + put(Int::class.javaPrimitiveType!!.name, SQLiteType.INTEGER) + put(Long::class.javaPrimitiveType!!.name, SQLiteType.INTEGER) + put(Float::class.javaPrimitiveType!!.name, SQLiteType.REAL) + put(Double::class.javaPrimitiveType!!.name, SQLiteType.REAL) + put(Boolean::class.javaPrimitiveType!!.name, SQLiteType.INTEGER) + put(Char::class.javaPrimitiveType!!.name, SQLiteType.TEXT) + put(ByteArray::class.java.name, SQLiteType.BLOB) + put(Byte::class.java.name, SQLiteType.INTEGER) + put(Short::class.java.name, SQLiteType.INTEGER) + put(Int::class.java.name, SQLiteType.INTEGER) + put(Long::class.java.name, SQLiteType.INTEGER) + put(Float::class.java.name, SQLiteType.REAL) + put(Double::class.java.name, SQLiteType.REAL) + put(Boolean::class.java.name, SQLiteType.INTEGER) + put(Char::class.java.name, SQLiteType.TEXT) + put(CharSequence::class.java.name, SQLiteType.TEXT) + put(String::class.java.name, SQLiteType.TEXT) + put(Array::class.java.name, SQLiteType.BLOB) + put(Blob::class.java.name, SQLiteType.BLOB) + } + } + + /** + * Returns the [SQLiteType] for this class + * + * @param className The fully qualified class name + * @return The type from the class name + */ + operator fun get(className: String): SQLiteType? = sTypeMap[className] + + fun containsClass(className: String): Boolean = sTypeMap.containsKey(className) + } +} diff --git a/dbflow-rx/build.gradle b/dbflow-rx/build.gradle index ef9aeeb3a..0ba3716bd 100644 --- a/dbflow-rx/build.gradle +++ b/dbflow-rx/build.gradle @@ -12,8 +12,8 @@ android { } compileOptions { - sourceCompatibility JavaVersion.VERSION_1_7 - targetCompatibility JavaVersion.VERSION_1_7 + sourceCompatibility JavaVersion.VERSION_1_8 + targetCompatibility JavaVersion.VERSION_1_8 } } diff --git a/dbflow-rx2/build.gradle b/dbflow-rx2/build.gradle index 1fb162c01..311006990 100644 --- a/dbflow-rx2/build.gradle +++ b/dbflow-rx2/build.gradle @@ -12,8 +12,8 @@ android { } compileOptions { - sourceCompatibility JavaVersion.VERSION_1_7 - targetCompatibility JavaVersion.VERSION_1_7 + sourceCompatibility JavaVersion.VERSION_1_8 + targetCompatibility JavaVersion.VERSION_1_8 } } diff --git a/dbflow/build.gradle b/dbflow/build.gradle index e05d7ae7b..421ae2fdd 100644 --- a/dbflow/build.gradle +++ b/dbflow/build.gradle @@ -18,8 +18,8 @@ android { } compileOptions { - sourceCompatibility JavaVersion.VERSION_1_7 - targetCompatibility JavaVersion.VERSION_1_7 + sourceCompatibility JavaVersion.VERSION_1_8 + targetCompatibility JavaVersion.VERSION_1_8 } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.kt index 2599a83cd..c4fb4b977 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.kt @@ -125,13 +125,10 @@ class DatabaseConfig( companion object { @JvmStatic - fun builder(database: Class<*>): DatabaseConfig.Builder { - return DatabaseConfig.Builder(database) - } + fun builder(database: Class<*>): DatabaseConfig.Builder = DatabaseConfig.Builder(database) @JvmStatic - fun inMemoryBuilder(database: Class<*>): DatabaseConfig.Builder { - return DatabaseConfig.Builder(database).inMemory() - } + fun inMemoryBuilder(database: Class<*>): DatabaseConfig.Builder = + DatabaseConfig.Builder(database).inMemory() } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/SqlUtils.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/SqlUtils.java index 999dc847b..57c90a32b 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/SqlUtils.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/SqlUtils.java @@ -129,7 +129,7 @@ public static Uri getNotificationUri(@NonNull Class modelClass, @NonNull String notifyKey, @Nullable Object notifyValue) { Operator operator = null; - if (StringUtils.isNotNullOrEmpty(notifyKey)) { + if (StringUtils.INSTANCE.isNotNullOrEmpty(notifyKey)) { operator = Operator.Companion.op(new NameAlias.Builder(notifyKey).build()).value(notifyValue); } return getNotificationUri(modelClass, action, new SQLOperator[]{operator}); diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelAdapter.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelAdapter.java index b73e845bc..169e9c6e4 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelAdapter.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelAdapter.java @@ -480,7 +480,7 @@ public boolean cachingEnabled() { } public int getCacheSize() { - return Table.DEFAULT_CACHE_SIZE; + return Table.Companion.getDEFAULT_CACHE_SIZE(); } public IMultiKeyCacheConverter getCacheConverter() { From 66f14f241ff2247a6467eb69ec7d1f97b47fd9eb Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Thu, 23 Nov 2017 10:48:15 -0500 Subject: [PATCH 056/234] [5.0] move kotlin extensions into main dbflow project. working on fixing tests. --- .../android/dbflow/annotation/IndexGroup.kt | 6 +- .../android/dbflow/annotation/OneToMany.kt | 7 +- .../dbflow/annotation/provider/ContentUri.kt | 6 +- .../dbflow/annotation/provider/Notify.kt | 4 +- .../kotlinextensions/DatabaseExtensions.kt | 103 ---- .../kotlinextensions/FlowListExtensions.kt | 9 - .../kotlinextensions/ModelExtensions.kt | 16 - .../kotlinextensions/NameAliasExtensions.kt | 9 - .../kotlinextensions/OperatorExtensions.kt | 40 -- .../kotlinextensions/PropertyExtensions.kt | 41 -- .../PropertyMethodExtensions.kt | 124 ---- .../kotlinextensions/QueryExtensions.kt | 266 -------- .../processor/definition/ContentProvider.kt | 155 ++--- .../processor/definition/NotifyDefinition.kt | 5 +- .../definition/OneToManyDefinition.kt | 21 +- .../processor/definition/TableDefinition.kt | 3 +- .../definition/TableEndpointDefinition.kt | 3 +- .../definition/column/ColumnDefinition.kt | 4 +- .../rx/kotlinextensions/QueryExtensions.kt | 5 - .../dbflow/rx/language/RXModelQueriable.java | 8 - .../rx/language/RXModelQueriableImpl.java | 13 +- .../dbflow/rx/language/RXQueriable.java | 16 - .../dbflow/rx/language/RXQueriableImpl.java | 22 - .../rx2/kotlinextensions/QueryExtensions.kt | 5 - .../dbflow/rx2/language/RXModelQueriable.java | 8 - .../rx2/language/RXModelQueriableImpl.java | 13 +- .../dbflow/rx2/language/RXQueriable.java | 16 - .../dbflow/rx2/language/RXQueriableImpl.java | 22 - .../dbflow/sqlcipher/SQLCipherDatabase.java | 4 +- .../dbflow/sqlcipher/SQLCipherOpenHelper.java | 2 +- .../dbflow/DBFlowInstrumentedTestRule.kt | 17 +- .../contentobserver/ContentObserverTest.kt | 12 +- .../dbflow/prepackaged/PrepackagedDBTest.kt | 6 +- .../android/dbflow/sqlcipher/CipherTest.kt | 8 +- .../contentprovider/ContentProviderObjects.kt | 31 +- .../contentprovider/ContentProviderTests.kt | 6 +- .../contentprovider/TestContentProvider.kt | 10 +- .../FastStoreModelTransactionTest.kt | 4 +- .../dbflow/list/FlowCursorIteratorTest.kt | 4 +- .../android/dbflow/list/FlowCursorListTest.kt | 4 +- .../android/dbflow/list/FlowQueryListTest.kt | 4 +- .../dbflow/models/AutoIncrementTest.kt | 1 - .../dbflow/models/CachingModelsTest.kt | 4 +- .../dbflow/models/DontCreateModelTest.kt | 4 +- .../android/dbflow/models/ModelViews.kt | 2 +- .../dbflow/models/OneToManyModelTest.kt | 5 +- .../android/dbflow/models/OneToManyModels.kt | 12 +- .../dbflow/models/ParentChildCachingTest.kt | 4 +- .../android/dbflow/models/QueryModelTest.kt | 2 +- .../android/dbflow/models/issue/Issue.java | 3 +- .../android/dbflow/models/issue/SubIssue.java | 9 +- .../dbflow/runtime/DirectNotifierTest.kt | 7 +- .../rx/language/CursorResultSubscriberTest.kt | 4 +- .../dbflow/rx/language/RXQueryTests.kt | 7 +- .../android/dbflow/sql/language/CaseTest.kt | 3 - .../dbflow/sql/language/CursorResultTest.kt | 2 - .../android/dbflow/sql/language/DeleteTest.kt | 3 - .../sql/language/ExistenceOperatorTest.kt | 3 - .../android/dbflow/sql/language/FromTest.kt | 3 - .../android/dbflow/sql/language/IndexTest.kt | 1 - .../dbflow/sql/language/IndexedByTest.kt | 2 - .../android/dbflow/sql/language/InsertTest.kt | 5 +- .../android/dbflow/sql/language/JoinTest.kt | 2 - .../dbflow/sql/language/NameAliasTest.kt | 1 - .../dbflow/sql/language/OperatorGroupTest.kt | 2 - .../dbflow/sql/language/OperatorTest.kt | 3 - .../android/dbflow/sql/language/SelectTest.kt | 1 - .../dbflow/sql/language/TriggerTest.kt | 5 - .../sql/language/UnsafeStringOperatorTest.kt | 3 - .../android/dbflow/sql/language/UpdateTest.kt | 2 - .../android/dbflow/sql/language/WhereTest.kt | 6 - .../language/property/PropertyFactoryTest.kt | 4 +- .../dbflow/sql/queriable/AsyncQueryTest.kt | 4 +- dbflow/build.gradle | 2 +- .../android/dbflow/config/DatabaseConfig.kt | 5 +- .../dbflow/config/DatabaseDefinition.kt | 57 +- .../android/dbflow/config/DatabaseHolder.kt | 19 +- .../raizlabs/android/dbflow/config/FlowLog.kt | 16 +- .../android/dbflow/config/FlowManager.kt | 86 ++- .../android/dbflow/config/TableConfig.kt | 29 +- .../android/dbflow/list/FlowCursorIterator.kt | 4 +- .../android/dbflow/list/FlowCursorList.kt | 52 +- .../android/dbflow/list/FlowQueryList.kt | 68 +-- .../dbflow/list/IFlowCursorIterator.kt | 4 +- .../dbflow/runtime/ContentResolverNotifier.kt | 25 +- .../dbflow/runtime/DBBatchSaveQueue.kt | 25 +- .../dbflow/runtime/NotifyDistributor.kt | 10 +- .../android/dbflow/sql/BaseAsyncObject.kt | 8 +- .../dbflow/sql/language/BaseModelQueriable.kt | 6 +- .../dbflow/sql/language/BaseOperator.java | 269 --------- .../dbflow/sql/language/BaseOperator.kt | 230 +++++++ .../dbflow/sql/language/BaseQueriable.kt | 2 +- .../dbflow/sql/language/BaseTransformable.kt | 2 +- .../dbflow/sql/language/CaseCondition.kt | 7 +- .../dbflow/sql/language/CursorResult.kt | 53 +- .../android/dbflow/sql/language/Delete.kt | 18 +- .../android/dbflow/sql/language/From.kt | 22 +- .../dbflow/sql/language/IConditional.kt | 71 +++ .../android/dbflow/sql/language/IOperator.kt | 2 +- .../android/dbflow/sql/language/IndexedBy.kt | 2 +- .../android/dbflow/sql/language/Insert.kt | 32 +- .../android/dbflow/sql/language/Join.kt | 15 +- .../android/dbflow/sql/language/NameAlias.kt | 5 + .../android/dbflow/sql/language/Operator.kt | 82 ++- .../dbflow/sql/language/OperatorGroup.kt | 10 + .../android/dbflow/sql/language/OrderBy.kt | 2 + .../dbflow/sql/language/QueryExtensions.kt | 55 ++ .../android/dbflow/sql/language/SQLite.kt | 16 +- .../android/dbflow/sql/language/Select.kt | 6 +- .../android/dbflow/sql/language/Set.kt | 4 +- .../dbflow/sql/language/Transformable.kt | 15 +- .../android/dbflow/sql/language/Trigger.kt | 13 + .../dbflow/sql/language/TriggerMethod.kt | 4 +- .../android/dbflow/sql/language/Update.kt | 11 +- .../android/dbflow/sql/language/Where.kt | 16 +- .../dbflow/sql/language/property/Property.kt | 48 +- .../sql/language/property/PropertyFactory.kt | 45 +- .../property/TypeConvertedProperty.kt | 10 +- .../sql/migration/AlterTableMigration.kt | 8 +- .../sql/migration/UpdateTableMigration.kt | 6 +- .../dbflow/sql/queriable/AsyncQuery.kt | 40 +- .../sql/queriable/CacheableListModelLoader.kt | 18 +- .../sql/queriable/CacheableModelLoader.kt | 14 +- .../dbflow/sql/queriable/ListModelLoader.kt | 10 +- .../dbflow/sql/queriable/ModelLoader.kt | 2 +- .../dbflow/sql/queriable/ModelQueriable.kt | 44 +- .../android/dbflow/sql/queriable/Queriable.kt | 9 + .../SingleKeyCacheableListModelLoader.kt | 10 +- .../SingleKeyCacheableModelLoader.kt | 12 +- .../dbflow/sql/queriable/SingleModelLoader.kt | 10 +- .../dbflow/sql/queriable/StringQuery.kt | 6 +- .../sql/saveable/AutoIncrementModelSaver.kt | 10 +- .../sql/saveable/CacheableListModelSaver.kt | 12 +- .../dbflow/sql/saveable/ListModelSaver.kt | 26 +- .../android/dbflow/sql/saveable/ModelSaver.kt | 48 +- .../android/dbflow/structure/AsyncModel.java | 169 ------ .../android/dbflow/structure/AsyncModel.kt | 118 ++++ .../android/dbflow/structure/BaseModel.java | 128 ---- .../android/dbflow/structure/BaseModel.kt | 91 +++ .../dbflow/structure/BaseModelView.java | 13 - .../android/dbflow/structure/BaseModelView.kt | 12 + .../dbflow/structure/BaseQueryModel.java | 24 - .../dbflow/structure/BaseQueryModel.kt | 19 + .../dbflow/structure/InstanceAdapter.java | 24 - .../dbflow/structure/InstanceAdapter.kt | 16 + .../dbflow/structure/InternalAdapter.java | 221 ------- .../dbflow/structure/InternalAdapter.kt | 215 +++++++ .../structure/InvalidDBConfiguration.java | 15 - .../structure/InvalidDBConfiguration.kt | 11 + .../android/dbflow/structure/Model.java | 77 --- .../android/dbflow/structure/Model.kt | 92 +++ .../dbflow/structure/ModelAdapter.java | 567 ------------------ .../android/dbflow/structure/ModelAdapter.kt | 444 ++++++++++++++ .../dbflow/structure/ModelViewAdapter.java | 26 - .../dbflow/structure/ModelViewAdapter.kt | 20 + .../dbflow/structure/NoModificationModel.java | 51 -- .../dbflow/structure/NoModificationModel.kt | 31 + .../android/dbflow/structure/OneToMany.kt | 7 +- .../dbflow/structure/QueryModelAdapter.java | 35 -- .../dbflow/structure/QueryModelAdapter.kt | 26 + .../{ReadOnlyModel.java => ReadOnlyModel.kt} | 22 +- .../dbflow/structure/RetrievalAdapter.java | 178 ------ .../dbflow/structure/RetrievalAdapter.kt | 146 +++++ .../dbflow/structure/cache/ModelLruCache.kt | 7 +- .../dbflow/structure/cache/SimpleMapCache.kt | 8 +- .../structure/database/AndroidDatabase.java | 103 ---- .../structure/database/AndroidDatabase.kt | 75 +++ .../database/AndroidDatabaseStatement.java | 110 ---- .../database/AndroidDatabaseStatement.kt | 81 +++ .../database/BaseDatabaseHelper.java | 233 ------- .../structure/database/BaseDatabaseHelper.kt | 217 +++++++ .../database/BaseDatabaseStatement.java | 60 -- .../database/BaseDatabaseStatement.kt | 52 ++ .../database/ContentValueExtensions.kt | 24 + .../database/DatabaseHelperDelegate.java | 316 ---------- .../database/DatabaseHelperDelegate.kt | 299 +++++++++ ...istener.java => DatabaseHelperListener.kt} | 16 +- .../structure/database/DatabaseStatement.java | 47 -- .../structure/database/DatabaseStatement.kt | 44 ++ .../database/DatabaseStatementWrapper.java | 90 --- .../database/DatabaseStatementWrapper.kt | 67 +++ .../structure/database/DatabaseWrapper.java | 45 -- .../structure/database/DatabaseWrapper.kt | 40 ++ .../dbflow/structure/database/FlowCursor.java | 293 --------- .../dbflow/structure/database/FlowCursor.kt | 255 ++++++++ .../database/FlowSQLiteOpenHelper.java | 173 ------ .../database/FlowSQLiteOpenHelper.kt | 142 +++++ .../dbflow/structure/database/OpenHelper.java | 26 - .../dbflow/structure/database/OpenHelper.kt | 21 + .../DefaultTransactionManager.java | 23 - .../transaction/DefaultTransactionManager.kt | 19 + .../transaction/DefaultTransactionQueue.java | 125 ---- .../transaction/DefaultTransactionQueue.kt | 112 ++++ .../FastStoreModelTransaction.java | 145 ----- .../transaction/FastStoreModelTransaction.kt | 127 ++++ .../{ITransaction.java => ITransaction.kt} | 12 +- ...sactionQueue.java => ITransactionQueue.kt} | 18 +- .../transaction/PriorityTransactionQueue.java | 173 ------ .../transaction/PriorityTransactionQueue.kt | 146 +++++ .../PriorityTransactionWrapper.java | 87 --- .../transaction/PriorityTransactionWrapper.kt | 69 +++ .../transaction/ProcessModelTransaction.java | 166 ----- .../transaction/ProcessModelTransaction.kt | 183 ++++++ .../transaction/QueryTransaction.java | 183 ------ .../database/transaction/QueryTransaction.kt | 155 +++++ .../database/transaction/Transaction.java | 262 -------- .../database/transaction/Transaction.kt | 220 +++++++ .../transaction/TransactionWrapper.java | 31 - .../transaction/TransactionWrapper.kt | 24 + .../listener/ContentValuesListener.java | 41 -- .../listener/ContentValuesListener.kt | 42 ++ .../listener/LoadFromCursorListener.java | 20 - .../listener/LoadFromCursorListener.kt | 19 + .../listener/SQLiteStatementListener.java | 41 -- .../listener/SQLiteStatementListener.kt | 39 ++ .../structure/provider/BaseProviderModel.java | 84 --- .../structure/provider/BaseProviderModel.kt | 66 ++ .../provider/BaseSyncableProviderModel.java | 62 -- .../provider/BaseSyncableProviderModel.kt | 51 ++ .../structure/provider/ContentUtils.java | 296 --------- .../dbflow/structure/provider/ContentUtils.kt | 295 +++++++++ .../structure/provider/ModelProvider.java | 52 -- .../structure/provider/ModelProvider.kt | 50 ++ 223 files changed, 5477 insertions(+), 6552 deletions(-) delete mode 100644 dbflow-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/kotlinextensions/DatabaseExtensions.kt delete mode 100644 dbflow-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/kotlinextensions/FlowListExtensions.kt delete mode 100644 dbflow-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/kotlinextensions/ModelExtensions.kt delete mode 100644 dbflow-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/kotlinextensions/NameAliasExtensions.kt delete mode 100644 dbflow-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/kotlinextensions/OperatorExtensions.kt delete mode 100644 dbflow-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/kotlinextensions/PropertyExtensions.kt delete mode 100644 dbflow-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/kotlinextensions/PropertyMethodExtensions.kt delete mode 100644 dbflow-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/kotlinextensions/QueryExtensions.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseOperator.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseOperator.kt create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/QueryExtensions.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/AsyncModel.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/AsyncModel.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseModel.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseModel.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseModelView.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseModelView.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseQueryModel.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseQueryModel.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/InstanceAdapter.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/InstanceAdapter.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/InternalAdapter.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/InternalAdapter.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/InvalidDBConfiguration.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/InvalidDBConfiguration.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/Model.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/Model.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelAdapter.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelAdapter.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelViewAdapter.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelViewAdapter.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/NoModificationModel.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/NoModificationModel.kt rename dbflow-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/kotlinextensions/OneToManyExtensions.kt => dbflow/src/main/java/com/raizlabs/android/dbflow/structure/OneToMany.kt (85%) delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/QueryModelAdapter.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/QueryModelAdapter.kt rename dbflow/src/main/java/com/raizlabs/android/dbflow/structure/{ReadOnlyModel.java => ReadOnlyModel.kt} (56%) delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/RetrievalAdapter.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/RetrievalAdapter.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/AndroidDatabase.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/AndroidDatabase.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/AndroidDatabaseStatement.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/AndroidDatabaseStatement.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/BaseDatabaseHelper.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/BaseDatabaseHelper.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/BaseDatabaseStatement.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/BaseDatabaseStatement.kt create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/ContentValueExtensions.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseHelperDelegate.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseHelperDelegate.kt rename dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/{DatabaseHelperListener.java => DatabaseHelperListener.kt} (59%) delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseStatement.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseStatement.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseStatementWrapper.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseStatementWrapper.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseWrapper.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseWrapper.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/FlowCursor.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/FlowCursor.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/FlowSQLiteOpenHelper.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/FlowSQLiteOpenHelper.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/OpenHelper.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/OpenHelper.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/DefaultTransactionManager.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/DefaultTransactionManager.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/DefaultTransactionQueue.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/DefaultTransactionQueue.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/FastStoreModelTransaction.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/FastStoreModelTransaction.kt rename dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/{ITransaction.java => ITransaction.kt} (64%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/{ITransactionQueue.java => ITransactionQueue.kt} (62%) delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/PriorityTransactionQueue.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/PriorityTransactionQueue.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/PriorityTransactionWrapper.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/PriorityTransactionWrapper.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ProcessModelTransaction.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ProcessModelTransaction.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/QueryTransaction.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/QueryTransaction.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Transaction.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Transaction.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/TransactionWrapper.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/TransactionWrapper.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/listener/ContentValuesListener.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/listener/ContentValuesListener.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/listener/LoadFromCursorListener.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/listener/LoadFromCursorListener.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/listener/SQLiteStatementListener.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/listener/SQLiteStatementListener.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/BaseProviderModel.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/BaseProviderModel.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/BaseSyncableProviderModel.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/BaseSyncableProviderModel.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/ContentUtils.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/ContentUtils.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/ModelProvider.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/ModelProvider.kt diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/IndexGroup.kt b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/IndexGroup.kt index 260eedfbb..f919fd575 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/IndexGroup.kt +++ b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/IndexGroup.kt @@ -1,6 +1,6 @@ package com.raizlabs.android.dbflow.annotation -const val GENERIC = -1 +const val INDEX_GENERIC = -1 /** * Description: @@ -10,9 +10,9 @@ const val GENERIC = -1 annotation class IndexGroup( /** * @return The number that each contained [Index] points to, so they can be combined into a single index. - * If [.GENERIC], this will assume a generic index that covers the whole table. + * If [.INDEX_GENERIC], this will assume a generic index that covers the whole table. */ - val number: Int = GENERIC, + val number: Int = INDEX_GENERIC, /** * @return The name of this index. It must be unique from other [IndexGroup]. */ diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/OneToMany.kt b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/OneToMany.kt index e86e0d68e..ed2e97a56 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/OneToMany.kt +++ b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/OneToMany.kt @@ -11,7 +11,7 @@ annotation class OneToMany( /** * @return The methods you wish to call it from. By default it's loaded out of the DB. */ - val methods: Array = arrayOf(Method.LOAD), + val oneToManyMethods: Array = arrayOf(OneToManyMethod.LOAD), /** * @return The name of the list variable to use. If is left blank, we will remove the "get" and then decapitalize the remaining name. */ @@ -31,7 +31,7 @@ annotation class OneToMany( /** * The method to apply the OneToMany to. */ -enum class Method { +enum class OneToManyMethod { /** * Load this relationship when the parent model loads from the database. This is called before the OnLoadFromCursor @@ -53,4 +53,5 @@ enum class Method { * Shorthand to support all options. */ ALL -} \ No newline at end of file +} + diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/ContentUri.kt b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/ContentUri.kt index f7825c594..419349677 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/ContentUri.kt +++ b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/ContentUri.kt @@ -42,11 +42,9 @@ annotation class ContentUri( */ object ContentType { - @JvmField - val VND_MULTIPLE = "vnd.android.cursor.dir/" + const val VND_MULTIPLE = "vnd.android.cursor.dir/" - @JvmField - val VND_SINGLE = "vnd.android.cursor.item/" + const val VND_SINGLE = "vnd.android.cursor.item/" } /** diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/Notify.kt b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/Notify.kt index c216976ca..97840717d 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/Notify.kt +++ b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/Notify.kt @@ -11,14 +11,14 @@ annotation class Notify( /** * @return The [com.raizlabs.android.dbflow.annotation.provider.Notify.Method] notify */ - val method: Method, + val notifyMethod: NotifyMethod, /** * @return Registers itself for the following paths. If a specific path is called for the specified * method, the method this annotation corresponds to will be called. */ val paths: Array = arrayOf()) -enum class Method { +enum class NotifyMethod { INSERT, UPDATE, DELETE diff --git a/dbflow-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/kotlinextensions/DatabaseExtensions.kt b/dbflow-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/kotlinextensions/DatabaseExtensions.kt deleted file mode 100644 index 5c37b9ed4..000000000 --- a/dbflow-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/kotlinextensions/DatabaseExtensions.kt +++ /dev/null @@ -1,103 +0,0 @@ -package com.raizlabs.android.dbflow.kotlinextensions - -import android.content.ContentValues -import com.raizlabs.android.dbflow.config.DatabaseDefinition -import com.raizlabs.android.dbflow.config.FlowManager.* -import com.raizlabs.android.dbflow.structure.Model -import com.raizlabs.android.dbflow.structure.ModelAdapter -import com.raizlabs.android.dbflow.structure.ModelViewAdapter -import com.raizlabs.android.dbflow.structure.QueryModelAdapter -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper -import com.raizlabs.android.dbflow.structure.database.transaction.FastStoreModelTransaction.* -import com.raizlabs.android.dbflow.structure.database.transaction.ProcessModelTransaction -import com.raizlabs.android.dbflow.structure.database.transaction.ProcessModelTransaction.ProcessModel -import com.raizlabs.android.dbflow.structure.database.transaction.Transaction - -typealias ProcessFunction = (T, DatabaseWrapper) -> Unit - -/** - * Easily get access to its [DatabaseDefinition] directly. - */ -inline fun database() = getDatabase(T::class.java) - -inline fun writableDatabaseForTable() = getWritableDatabaseForTable(T::class.java) - -/** - * Easily get access to its [DatabaseDefinition] directly. - */ -inline fun databaseForTable() = getDatabaseForTable(T::class.java) - -/** - * Easily get its table name. - */ -inline fun tableName() = getTableName(T::class.java) - -/** - * Easily get its [ModelAdapter]. - */ -inline fun modelAdapter() = getModelAdapter(T::class.java) - -/** - * Easily get its [QueryModelAdapter]. - */ -inline fun queryModelAdapter() = getQueryModelAdapter(T::class.java) - -/** - * Easily get its [ModelViewAdapter] - */ -inline fun modelViewAdapter() = getModelViewAdapter(T::class.java) - -/** - * Enables a collection of T objects to easily operate on them within a synchronous database transaction. - */ -inline fun Collection.processInTransaction( - crossinline processFunction: ProcessFunction) { - databaseForTable().executeTransaction { db -> forEach { processFunction(it, db) } } -} - -/** - * Places the [Collection] of items on the [ITransactionQueue]. Use the [processFunction] to perform - * an action on each individual [Model]. This happens on a non-UI thread. - */ -inline fun Collection.processInTransactionAsync( - crossinline processFunction: ProcessFunction, - success: Transaction.Success? = null, - error: Transaction.Error? = null, - processListener: ProcessModelTransaction.OnModelProcessListener? = null) { - databaseForTable().beginTransactionAsync( - this.processTransaction(processFunction) - .processListener(processListener).build()) - .success(success).error(error).execute() -} - -inline fun Collection.processTransaction( - crossinline processFunction: ProcessFunction): ProcessModelTransaction.Builder { - return ProcessModelTransaction.Builder(ProcessModel { model, wrapper -> processFunction(model, wrapper) }).addAll(this) -} - -inline fun Collection.fastSave() = saveBuilder(modelAdapter()).addAll(this) - -inline fun Collection.fastInsert() = insertBuilder(modelAdapter()).addAll(this) - -inline fun Collection.fastUpdate() = updateBuilder(modelAdapter()).addAll(this) - -operator fun ContentValues.set(key: String, value: String?) = put(key, value) - -operator fun ContentValues.set(key: String, value: Byte?) = put(key, value) - -operator fun ContentValues.set(key: String, value: Short?) = put(key, value) - -operator fun ContentValues.set(key: String, value: Int?) = put(key, value) - -operator fun ContentValues.set(key: String, value: Long?) = put(key, value) - -operator fun ContentValues.set(key: String, value: Float?) = put(key, value) - -operator fun ContentValues.set(key: String, value: Double?) = put(key, value) - -operator fun ContentValues.set(key: String, value: Boolean?) = put(key, value) - -operator fun ContentValues.set(key: String, value: ByteArray?) = put(key, value) - - - diff --git a/dbflow-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/kotlinextensions/FlowListExtensions.kt b/dbflow-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/kotlinextensions/FlowListExtensions.kt deleted file mode 100644 index 406affaea..000000000 --- a/dbflow-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/kotlinextensions/FlowListExtensions.kt +++ /dev/null @@ -1,9 +0,0 @@ -package com.raizlabs.android.dbflow.kotlinextensions - -import com.raizlabs.android.dbflow.list.IFlowCursorIterator - -operator fun IFlowCursorIterator.get(i: Long): TModel = this.getItem(i) ?: throw IndexOutOfBoundsException("Could not find item at index $i from the cursor.") - -operator fun IFlowCursorIterator.get(i: Int): TModel = this.getItem(i.toLong()) ?: throw IndexOutOfBoundsException("Could not find item at index $i from the cursor.") - - diff --git a/dbflow-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/kotlinextensions/ModelExtensions.kt b/dbflow-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/kotlinextensions/ModelExtensions.kt deleted file mode 100644 index d136fe9b5..000000000 --- a/dbflow-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/kotlinextensions/ModelExtensions.kt +++ /dev/null @@ -1,16 +0,0 @@ -package com.raizlabs.android.dbflow.kotlinextensions - -import com.raizlabs.android.dbflow.structure.AsyncModel -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper - -inline fun T.save(databaseWrapper: DatabaseWrapper = writableDatabaseForTable()) = modelAdapter().save(this, databaseWrapper) - -inline fun T.insert(databaseWrapper: DatabaseWrapper = writableDatabaseForTable()) = modelAdapter().insert(this, databaseWrapper) - -inline fun T.update(databaseWrapper: DatabaseWrapper = writableDatabaseForTable()) = modelAdapter().update(this, databaseWrapper) - -inline fun T.delete(databaseWrapper: DatabaseWrapper = writableDatabaseForTable()) = modelAdapter().delete(this, databaseWrapper) - -inline fun T.exists(databaseWrapper: DatabaseWrapper = writableDatabaseForTable()) = modelAdapter().exists(this, databaseWrapper) - -inline fun T.async() = AsyncModel(this) \ No newline at end of file diff --git a/dbflow-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/kotlinextensions/NameAliasExtensions.kt b/dbflow-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/kotlinextensions/NameAliasExtensions.kt deleted file mode 100644 index 915e4917b..000000000 --- a/dbflow-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/kotlinextensions/NameAliasExtensions.kt +++ /dev/null @@ -1,9 +0,0 @@ -package com.raizlabs.android.dbflow.kotlinextensions - -import com.raizlabs.android.dbflow.sql.language.NameAlias - -val String.nameAlias - get() = NameAlias.of(this) - -fun String.`as`(alias: String? = null) = NameAlias.of(this, alias) - diff --git a/dbflow-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/kotlinextensions/OperatorExtensions.kt b/dbflow-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/kotlinextensions/OperatorExtensions.kt deleted file mode 100644 index aeadca011..000000000 --- a/dbflow-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/kotlinextensions/OperatorExtensions.kt +++ /dev/null @@ -1,40 +0,0 @@ -package com.raizlabs.android.dbflow.kotlinextensions - -import com.raizlabs.android.dbflow.annotation.Collate -import com.raizlabs.android.dbflow.sql.language.NameAlias -import com.raizlabs.android.dbflow.sql.language.Operator -import com.raizlabs.android.dbflow.sql.language.OperatorGroup -import com.raizlabs.android.dbflow.sql.language.OperatorGroup.clause -import com.raizlabs.android.dbflow.sql.language.SQLOperator - -fun SQLOperator.clause() = OperatorGroup.clause(this) - -fun NameAlias.op() = Operator.op(this) - -fun String.op(): Operator = nameAlias.op() - -infix fun Operator.collate(collation: Collate) = collate(collation) - -infix fun Operator.collate(collation: String) = collate(collation) - -infix fun Operator.postfix(collation: String) = postfix(collation) - -infix fun Operator.Between.and(value: T?) = and(value) - -infix fun Operator.In.and(value: T?) = and(value) - -infix fun Operator.and(sqlOperator: SQLOperator) = clause(this).and(sqlOperator) - -infix fun Operator.or(sqlOperator: SQLOperator) = clause(this).or(sqlOperator) - -infix fun Operator.andAll(sqlOperator: Collection) = clause(this).andAll(sqlOperator) - -infix fun Operator.orAll(sqlOperator: Collection) = clause(this).orAll(sqlOperator) - -infix fun OperatorGroup.and(sqlOperator: SQLOperator) = and(sqlOperator) - -infix fun OperatorGroup.or(sqlOperator: SQLOperator) = or(sqlOperator) - -infix fun OperatorGroup.and(sqlOperator: OperatorGroup) = clause().and(sqlOperator) - -infix fun OperatorGroup.or(sqlOperator: OperatorGroup) = clause().or(sqlOperator) diff --git a/dbflow-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/kotlinextensions/PropertyExtensions.kt b/dbflow-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/kotlinextensions/PropertyExtensions.kt deleted file mode 100644 index 59b4f4162..000000000 --- a/dbflow-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/kotlinextensions/PropertyExtensions.kt +++ /dev/null @@ -1,41 +0,0 @@ -package com.raizlabs.android.dbflow.kotlinextensions - -import com.raizlabs.android.dbflow.sql.language.property.Property -import com.raizlabs.android.dbflow.sql.language.property.PropertyFactory.from -import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable -import kotlin.reflect.KClass - -/** - * Description: Provides some very nice Property class extensions. - */ - -val Int.property - get() = from(this) - -val Char.property - get() = from(this) - -val Double.property - get() = from(this) - -val Long.property - get() = from(this) - -val Float.property - get() = from(this) - -val Short.property - get() = from(this) - -val Byte.property - get() = from(this) - -val T?.property - get() = from(this) - -val ModelQueriable.property - get() = from(this) - -inline fun propertyString(stringRepresentation: String?) = from(T::class.java, stringRepresentation) - -inline fun KClass.allProperty() = Property.allProperty(this.java) \ No newline at end of file diff --git a/dbflow-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/kotlinextensions/PropertyMethodExtensions.kt b/dbflow-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/kotlinextensions/PropertyMethodExtensions.kt deleted file mode 100644 index 31b3d8bff..000000000 --- a/dbflow-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/kotlinextensions/PropertyMethodExtensions.kt +++ /dev/null @@ -1,124 +0,0 @@ -package com.raizlabs.android.dbflow.kotlinextensions - -import com.raizlabs.android.dbflow.sql.language.BaseModelQueriable -import com.raizlabs.android.dbflow.sql.language.IConditional -import com.raizlabs.android.dbflow.sql.language.Operator -import com.raizlabs.android.dbflow.sql.language.Operator.Between -import com.raizlabs.android.dbflow.sql.language.property.Property - -/** - * Description: Provides property methods in via infix functions. - */ - -infix fun Property.eq(value: T?) = this.eq(value) - -infix fun Property.`is`(value: T?) = this.`is`(value) - -infix fun Property.isNot(value: T?) = this.isNot(value) - -infix fun Property.notEq(value: T?) = this.notEq(value) - -infix fun Property.like(value: String) = this.like(value) - -infix fun Property.glob(value: String) = this.glob(value) - -infix fun Property.greaterThan(value: T) = this.greaterThan(value) - -infix fun Property.greaterThanOrEq(value: T) = this.greaterThanOrEq(value) - -infix fun Property.lessThan(value: T) = this.lessThan(value) - -infix fun Property.lessThanOrEq(value: T) = this.lessThanOrEq(value) - -infix fun Property.between(value: T) = this.between(value) - -infix fun Property.`in`(values: Array): Operator.In { - return when (values.size) { - 1 -> `in`(values[0]) - else -> this.`in`(values[0], *values.sliceArray(IntRange(1, values.size))) - } -} - -infix fun Property.notIn(values: Array): Operator.In { - return when (values.size) { - 1 -> notIn(values[0]) - else -> this.notIn(values[0], *values.sliceArray(IntRange(1, values.size))) - } -} - -infix fun Property.`in`(values: Collection) = this.`in`(values) - -infix fun Property.notIn(values: Collection) = this.notIn(values) - -infix fun Property.concatenate(value: T) = this.concatenate(value) - -infix fun IConditional.eq(value: IConditional): Operator<*> = this.eq(value) - -infix fun IConditional.`is`(conditional: IConditional): Operator<*> = this.`is`(conditional) - -infix fun IConditional.isNot(conditional: IConditional): Operator<*> = this.isNot(conditional) - -infix fun IConditional.notEq(conditional: IConditional): Operator<*> = this.notEq(conditional) - -infix fun IConditional.like(conditional: IConditional): Operator<*> = this.like(conditional) - -infix fun IConditional.glob(conditional: IConditional): Operator<*> = this.glob(conditional) - -infix fun IConditional.like(value: String): Operator<*> = this.like(value) - -infix fun IConditional.glob(value: String): Operator<*> = this.glob(value) - -infix fun IConditional.greaterThan(conditional: IConditional): Operator<*> = this.greaterThan(conditional) - -infix fun IConditional.greaterThanOrEq(conditional: IConditional): Operator<*> = this.greaterThanOrEq(conditional) - -infix fun IConditional.lessThan(conditional: IConditional): Operator<*> = this.lessThan(conditional) - -infix fun IConditional.lessThanOrEq(conditional: IConditional): Operator<*> = this.lessThanOrEq(conditional) - -infix fun IConditional.between(conditional: IConditional): Between<*> = this.between(conditional) - -infix fun IConditional.`in`(values: Array): Operator.In<*> { - return when (values.size) { - 1 -> `in`(values[0]) - else -> this.`in`(values[0], *values.sliceArray(IntRange(1, values.size))) - } -} - -infix fun IConditional.notIn(values: Array): Operator.In<*> { - return when (values.size) { - 1 -> notIn(values[0]) - else -> this.notIn(values[0], *values.sliceArray(IntRange(1, values.size))) - } -} - -infix fun IConditional.`is`(baseModelQueriable: BaseModelQueriable): Operator<*> = this.`is`(baseModelQueriable) - -infix fun IConditional.eq(baseModelQueriable: BaseModelQueriable): Operator<*> = this.eq(baseModelQueriable) - -infix fun IConditional.isNot(baseModelQueriable: BaseModelQueriable): Operator<*> = this.isNot(baseModelQueriable) -infix fun IConditional.notEq(baseModelQueriable: BaseModelQueriable): Operator<*> = this.notEq(baseModelQueriable) -infix fun IConditional.like(baseModelQueriable: BaseModelQueriable): Operator<*> = this.like(baseModelQueriable) -infix fun IConditional.glob(baseModelQueriable: BaseModelQueriable): Operator<*> = this.glob(baseModelQueriable) -infix fun IConditional.greaterThan(baseModelQueriable: BaseModelQueriable): Operator<*> = this.greaterThan(baseModelQueriable) -infix fun IConditional.greaterThanOrEq(baseModelQueriable: BaseModelQueriable): Operator<*> = this.greaterThanOrEq(baseModelQueriable) -infix fun IConditional.lessThan(baseModelQueriable: BaseModelQueriable): Operator<*> = this.lessThan(baseModelQueriable) -infix fun IConditional.lessThanOrEq(baseModelQueriable: BaseModelQueriable): Operator<*> = this.lessThanOrEq(baseModelQueriable) -infix fun IConditional.between(baseModelQueriable: BaseModelQueriable): Between<*> = this.between(baseModelQueriable) - -infix fun IConditional.`in`(values: Array>): Operator.In<*> { - return when (values.size) { - 1 -> `in`(values[0]) - else -> this.`in`(values[0], *values.sliceArray(IntRange(1, values.size))) - } -} - -infix fun IConditional.notIn(values: Array>): Operator.In<*> { - return when (values.size) { - 1 -> notIn(values[0]) - else -> this.notIn(values[0], *values.sliceArray(IntRange(1, values.size))) - } -} - -infix fun IConditional.concatenate(conditional: IConditional): Operator<*> = this.concatenate(conditional) - diff --git a/dbflow-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/kotlinextensions/QueryExtensions.kt b/dbflow-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/kotlinextensions/QueryExtensions.kt deleted file mode 100644 index a4a84ee10..000000000 --- a/dbflow-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/kotlinextensions/QueryExtensions.kt +++ /dev/null @@ -1,266 +0,0 @@ -package com.raizlabs.android.dbflow.kotlinextensions - -import com.raizlabs.android.dbflow.annotation.Collate -import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.sql.language.BaseModelQueriable -import com.raizlabs.android.dbflow.sql.language.Case -import com.raizlabs.android.dbflow.sql.language.CaseCondition -import com.raizlabs.android.dbflow.sql.language.CompletedTrigger -import com.raizlabs.android.dbflow.sql.language.CursorResult -import com.raizlabs.android.dbflow.sql.language.From -import com.raizlabs.android.dbflow.sql.language.Index -import com.raizlabs.android.dbflow.sql.language.Insert -import com.raizlabs.android.dbflow.sql.language.Join -import com.raizlabs.android.dbflow.sql.language.NameAlias -import com.raizlabs.android.dbflow.sql.language.OrderBy -import com.raizlabs.android.dbflow.sql.language.SQLOperator -import com.raizlabs.android.dbflow.sql.language.SQLite -import com.raizlabs.android.dbflow.sql.language.Select -import com.raizlabs.android.dbflow.sql.language.Set -import com.raizlabs.android.dbflow.sql.language.Transformable -import com.raizlabs.android.dbflow.sql.language.Trigger -import com.raizlabs.android.dbflow.sql.language.TriggerMethod -import com.raizlabs.android.dbflow.sql.language.Update -import com.raizlabs.android.dbflow.sql.language.Where -import com.raizlabs.android.dbflow.sql.language.property.IProperty -import com.raizlabs.android.dbflow.sql.queriable.AsyncQuery -import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable -import com.raizlabs.android.dbflow.sql.queriable.Queriable -import com.raizlabs.android.dbflow.structure.AsyncModel -import com.raizlabs.android.dbflow.structure.Model -import com.raizlabs.android.dbflow.structure.database.transaction.QueryTransaction -import kotlin.reflect.KClass - -/** - * Description: A file containing extensions for adding query syntactic sugar. - */ - -inline val select: Select - get() = SQLite.select() - -inline fun Select.from() = from(T::class.java) - -fun delete(modelClass: KClass) = SQLite.delete(modelClass.java) - -infix fun Select.from(modelClass: KClass) = from(modelClass.java) - -infix fun From.whereExists(where: Where) = where().exists(where) - -infix fun From.where(sqlOperator: SQLOperator) = where(sqlOperator) - -infix fun From.`as`(alias: String) = `as`(alias) - -infix fun Set.where(sqlOperator: SQLOperator) = where(sqlOperator) - -infix fun Where.and(sqlOperator: SQLOperator) = and(sqlOperator) - -infix fun Where.or(sqlOperator: SQLOperator) = or(sqlOperator) - -infix fun Case.`when`(sqlOperator: SQLOperator) = `when`(sqlOperator) - -infix fun Case.`when`(property: IProperty<*>) = `when`(property) - -infix fun Case.`when`(value: T?) = `when`(value) - -infix fun CaseCondition.then(value: T?) = then(value) - -infix fun CaseCondition.then(property: IProperty<*>) = then(property) - -infix fun Case.`else`(value: T?) = _else(value) - -infix fun Case.end(columnName: String) = end(columnName) - -fun case(caseColumn: IProperty<*>) = SQLite._case(caseColumn) - -fun caseWhen(operator: SQLOperator) = SQLite.caseWhen(operator) - -inline fun insert() = Insert(T::class.java) - -inline fun indexOn(indexName: String, vararg property: IProperty<*>) = Index(indexName).on(T::class.java, *property) - -inline fun indexOn(indexName: String, firstNameAlias: NameAlias, vararg arrayOfNameAlias: NameAlias) = Index(indexName).on(T::class.java, firstNameAlias, *arrayOfNameAlias) - -// queriable extensions - -inline val Queriable.count - get() = count() - -inline val Queriable.cursor - get() = query() - -inline val Queriable.hasData - get() = hasData() - -inline val Queriable.statement - get() = compileStatement() - -inline val ModelQueriable.list - get() = queryList() - -inline val ModelQueriable.result - get() = querySingle() - -inline val ModelQueriable.cursorResult - get() = queryResults() - -inline val ModelQueriable.flowQueryList - get() = flowQueryList() - -inline val ModelQueriable.cursorList - get() = cursorList() - -// cursor result extensions -inline fun CursorResult<*>.toCustomList() = toCustomList(T::class.java) - -inline fun CursorResult<*>.toCustomListClose() = toCustomListClose(T::class.java) - -inline fun CursorResult<*>.toCustomModel() = toCustomModel(T::class.java) - -inline fun CursorResult<*>.toCustomModelClose() = toCustomModelClose(T::class.java) - -// async extensions - -inline val ModelQueriable.async - get() = async() - -infix inline fun AsyncQuery.list(crossinline callback: (QueryTransaction<*>, MutableList) -> Unit) - = queryListResultCallback { queryTransaction, mutableList -> callback(queryTransaction, mutableList) } - .execute() - -infix inline fun AsyncQuery.result(crossinline callback: (QueryTransaction<*>, T?) -> Unit) - = querySingleResultCallback { queryTransaction, model -> callback(queryTransaction, model) } - .execute() - -infix inline fun AsyncQuery.cursorResult(crossinline callback: (QueryTransaction<*>, CursorResult) -> Unit) - = queryResultCallback { queryTransaction, cursorResult -> callback(queryTransaction, cursorResult) } - .execute() - -inline val Model.async - get() = async() - -infix inline fun AsyncModel.insert(crossinline listener: (T) -> Unit) = withListener { listener(it) }.insert() - -infix inline fun AsyncModel.update(crossinline listener: (T) -> Unit) = withListener { listener(it) }.update() - -infix inline fun AsyncModel.delete(crossinline listener: (T) -> Unit) = withListener { listener(it) }.delete() - -infix inline fun AsyncModel.save(crossinline listener: (T) -> Unit) = withListener { listener(it) }.save() - -// Transformable methods - -infix fun Transformable.groupBy(nameAlias: NameAlias): Where = groupBy(nameAlias) - -infix fun Transformable.groupBy(property: IProperty<*>): Where = groupBy(property) - -infix fun Transformable.orderBy(orderBy: OrderBy): Where = orderBy(orderBy) - -infix fun Transformable.limit(limit: Int): Where = limit(limit) - -infix fun Transformable.offset(offset: Int): Where = offset(offset) - -infix fun Transformable.having(sqlOperator: SQLOperator): Where = having(sqlOperator) - -infix fun OrderBy.collate(collate: Collate) = collate(collate) - -// join - -infix fun From.innerJoin(joinTable: KClass): Join = join(joinTable.java, Join.JoinType.INNER) - -infix fun From.crossJoin(joinTable: KClass): Join = join(joinTable.java, Join.JoinType.CROSS) - -infix fun From.leftOuterJoin(joinTable: KClass): Join = join(joinTable.java, Join.JoinType.LEFT_OUTER) - -infix fun From.naturalJoin(joinTable: KClass): Join = join(joinTable.java, Join.JoinType.NATURAL) - -infix fun Join.on(sqlOperator: SQLOperator): From = on(sqlOperator) - -infix fun Join.using(property: IProperty<*>): From = using(property) - -// update methods - -inline fun update() = SQLite.update(T::class.java) - -infix fun Update.set(sqlOperator: SQLOperator) = set(sqlOperator) - -// delete - -inline fun delete() = SQLite.delete(T::class.java) - -inline fun delete(deleteClause: From.() -> BaseModelQueriable) - = deleteClause(SQLite.delete(T::class.java)) - -// insert methods - -fun insert(modelClass: KClass) = SQLite.insert(modelClass.java) - -infix fun Insert.orReplace(into: Array, *>>) = orReplace().columnValues(*into) - -infix fun Insert.orRollback(into: Array, *>>) = orRollback().columnValues(*into) - -infix fun Insert.orAbort(into: Array, *>>) = orAbort().columnValues(*into) - -infix fun Insert.orFail(into: Array, *>>) = orFail().columnValues(*into) - -infix fun Insert.orIgnore(into: Array, *>>) = orIgnore().columnValues(*into) - -infix fun Insert.select(from: From<*>): Insert = select(from) - -fun columnValues(vararg pairs: Pair, *>): Array, *>> = pairs - -fun Insert.columnValues(vararg pairs: Pair, *>): Insert { - val columns: MutableList> = java.util.ArrayList() - val values = java.util.ArrayList() - pairs.forEach { - columns.add(it.first) - values.add(it.second) - } - this.columns(columns).values(values) - return this -} - -// Trigger -fun createTrigger(name: String) = Trigger.create(name) - -infix fun Trigger.deleteOn(kClass: KClass) = deleteOn(kClass.java) - -infix fun Trigger.insertOn(kClass: KClass) = insertOn(kClass.java) - -infix fun Trigger.updateOn(kClass: KClass) = updateOn(kClass.java) - -infix fun TriggerMethod.begin(triggerStatement: Query) = begin(triggerStatement) - -infix fun CompletedTrigger.and(nextStatement: Query) = and(nextStatement) - -// DSL - -fun select(vararg property: IProperty>, - init: Select.() -> BaseModelQueriable): BaseModelQueriable { - val select = SQLite.select(*property) - return init(select) -} - -fun select(init: Select.() -> BaseModelQueriable) = init(SQLite.select()) - -inline fun Select.from(fromClause: From.() -> Where) = fromClause(from(T::class.java)) - -inline fun From.where(sqlOperatorClause: () -> SQLOperator) = where(sqlOperatorClause()) - -inline fun Set.where(sqlOperatorClause: () -> SQLOperator) = where(sqlOperatorClause()) - -inline fun Where.and(sqlOperatorClause: () -> SQLOperator) = and(sqlOperatorClause()) - -inline fun Where.or(sqlOperatorClause: () -> SQLOperator) = or(sqlOperatorClause()) - -inline fun From.join(joinType: Join.JoinType, - function: Join.() -> Unit): Where { - function(join(TJoin::class.java, joinType)) - return where() -} - -inline fun insert(insertMethod: Insert.() -> Unit) = SQLite.insert(T::class.java).apply { insertMethod(this) } - -inline infix fun Join.on(operatorFunction: () -> Array) = on(*operatorFunction()) - -inline fun update(setMethod: Update.() -> BaseModelQueriable) = setMethod(SQLite.update(T::class.java)) - -inline fun Update.set(setClause: Set.() -> Where) = setClause(set()) \ No newline at end of file diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/ContentProvider.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/ContentProvider.kt index b66d3245b..bb44f81d3 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/ContentProvider.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/ContentProvider.kt @@ -16,7 +16,8 @@ import com.grosner.kpoet.public import com.grosner.kpoet.statement import com.raizlabs.android.dbflow.annotation.provider.ContentProvider import com.raizlabs.android.dbflow.annotation.provider.ContentUri -import com.raizlabs.android.dbflow.annotation.provider.Notify +import com.raizlabs.android.dbflow.annotation.provider.NotifyMethod +import com.raizlabs.android.dbflow.annotation.provider.PathSegment import com.raizlabs.android.dbflow.annotation.provider.TableEndpoint import com.raizlabs.android.dbflow.processor.ClassNames import com.raizlabs.android.dbflow.processor.ProcessorManager @@ -40,9 +41,9 @@ import javax.lang.model.type.MirroredTypeException internal fun appendDefault(code: CodeBlock.Builder) { code.beginControlFlow("default:") - .addStatement("throw new \$T(\$S + \$L)", - ClassName.get(IllegalArgumentException::class.java), "Unknown URI", Constants.PARAM_URI) - .endControlFlow() + .addStatement("throw new \$T(\$S + \$L)", + ClassName.get(IllegalArgumentException::class.java), "Unknown URI", Constants.PARAM_URI) + .endControlFlow() } object Constants { @@ -58,7 +59,7 @@ object Constants { internal fun ContentUriDefinition.getSegmentsPreparation() = code { if (segments.isNotEmpty()) { statement("\$T segments = uri.getPathSegments()", - parameterized(List::class)) + parameterized(List::class)) } this } @@ -72,7 +73,7 @@ internal fun ContentUriDefinition.getSelectionAndSelectionArgs(): CodeBlock { } else { val selectionBuilder = CodeBlock.builder().add("\$T.concatenateWhere(selection, \"", ClassNames.DATABASE_UTILS) val selectionArgsBuilder = CodeBlock.builder().add("\$T.appendSelectionArgs(selectionArgs, new \$T[] {", - ClassNames.DATABASE_UTILS, String::class.java) + ClassNames.DATABASE_UTILS, String::class.java) var isFirst = true for (segment in segments) { if (!isFirst) { @@ -109,12 +110,12 @@ class DeleteMethod(private val contentProviderDefinition: ContentProviderDefinit case(uriDefinition.name.L) { add(uriDefinition.getSegmentsPreparation()) add("long count = \$T.getDatabase(\$T.class).getWritableDatabase().delete(\$S, ", - ClassNames.FLOW_MANAGER, contentProviderDefinition.databaseTypeName, - it.tableName) + ClassNames.FLOW_MANAGER, contentProviderDefinition.databaseTypeName, + it.tableName) add(uriDefinition.getSelectionAndSelectionArgs()) add(");\n") - NotifyMethod(it, uriDefinition, Notify.Method.DELETE).addCode(this) + NotifyMethod(it, uriDefinition, NotifyMethod.DELETE).addCode(this) `return`("(int) count") } @@ -127,12 +128,12 @@ class DeleteMethod(private val contentProviderDefinition: ContentProviderDefinit code.endControlFlow() return MethodSpec.methodBuilder("delete") - .addAnnotation(Override::class.java) - .addModifiers(Modifier.PUBLIC, Modifier.FINAL) - .addParameter(ClassNames.URI, PARAM_URI) - .addParameter(ClassName.get(String::class.java), PARAM_SELECTION) - .addParameter(ArrayTypeName.of(String::class.java), PARAM_SELECTION_ARGS) - .addCode(code.build()).returns(TypeName.INT).build() + .addAnnotation(Override::class.java) + .addModifiers(Modifier.PUBLIC, Modifier.FINAL) + .addParameter(ClassNames.URI, PARAM_URI) + .addParameter(ClassName.get(String::class.java), PARAM_SELECTION) + .addParameter(ArrayTypeName.of(String::class.java), PARAM_SELECTION_ARGS) + .addCode(code.build()).returns(TypeName.INT).build() } companion object { @@ -161,16 +162,16 @@ class InsertMethod(private val contentProviderDefinition: ContentProviderDefinit code.apply { beginControlFlow("case \$L:", uriDefinition.name) addStatement("\$T adapter = \$T.getModelAdapter(\$T.getTableClassForName(\$T.class, \$S))", - ClassNames.MODEL_ADAPTER, ClassNames.FLOW_MANAGER, ClassNames.FLOW_MANAGER, - contentProviderDefinition.databaseTypeName, it.tableName) + ClassNames.MODEL_ADAPTER, ClassNames.FLOW_MANAGER, ClassNames.FLOW_MANAGER, + contentProviderDefinition.databaseTypeName, it.tableName) add("final long id = FlowManager.getDatabase(\$T.class).getWritableDatabase()", - contentProviderDefinition.databaseTypeName).add( - ".insertWithOnConflict(\$S, null, values, " + - "\$T.getSQLiteDatabaseAlgorithmInt(adapter.getInsertOnConflictAction()));\n", it.tableName, - ClassNames.CONFLICT_ACTION) + contentProviderDefinition.databaseTypeName).add( + ".insertWithOnConflict(\$S, null, values, " + + "\$T.getSQLiteDatabaseAlgorithmInt(adapter.getInsertOnConflictAction()));\n", it.tableName, + ClassNames.CONFLICT_ACTION) - NotifyMethod(it, uriDefinition, Notify.Method.INSERT).addCode(this) + NotifyMethod(it, uriDefinition, NotifyMethod.INSERT).addCode(this) if (!isBulk) { addStatement("return \$T.withAppendedId(\$L, id)", ClassNames.CONTENT_URIS, Constants.PARAM_URI) @@ -186,10 +187,10 @@ class InsertMethod(private val contentProviderDefinition: ContentProviderDefinit appendDefault(code) code.endControlFlow() return MethodSpec.methodBuilder(if (isBulk) "bulkInsert" else "insert") - .addAnnotation(Override::class.java).addParameter(ClassNames.URI, Constants.PARAM_URI) - .addParameter(ClassNames.CONTENT_VALUES, Constants.PARAM_CONTENT_VALUES) - .addModifiers(if (isBulk) Modifier.PROTECTED else Modifier.PUBLIC, Modifier.FINAL) - .addCode(code.build()).returns(if (isBulk) TypeName.INT else ClassNames.URI).build() + .addAnnotation(Override::class.java).addParameter(ClassNames.URI, Constants.PARAM_URI) + .addParameter(ClassNames.CONTENT_VALUES, Constants.PARAM_CONTENT_VALUES) + .addModifiers(if (isBulk) Modifier.PROTECTED else Modifier.PUBLIC, Modifier.FINAL) + .addCode(code.build()).returns(if (isBulk) TypeName.INT else ClassNames.URI).build() } } @@ -198,28 +199,28 @@ class InsertMethod(private val contentProviderDefinition: ContentProviderDefinit * Description: */ class NotifyMethod(private val tableEndpointDefinition: TableEndpointDefinition, - private val uriDefinition: ContentUriDefinition, private val method: Notify.Method) : CodeAdder { + private val uriDefinition: ContentUriDefinition, private val notifyMethod: NotifyMethod) : CodeAdder { override fun addCode(code: CodeBlock.Builder): CodeBlock.Builder { var hasListener = false val notifyDefinitionMap = tableEndpointDefinition.notifyDefinitionPathMap[uriDefinition.path] if (notifyDefinitionMap != null) { - val notifyDefinitionList = notifyDefinitionMap[method] + val notifyDefinitionList = notifyDefinitionMap[notifyMethod] if (notifyDefinitionList != null) { for (i in notifyDefinitionList.indices) { val notifyDefinition = notifyDefinitionList[i] if (notifyDefinition.returnsArray) { code.addStatement("\$T[] notifyUris\$L = \$L.\$L(\$L)", ClassNames.URI, - notifyDefinition.methodName, notifyDefinition.parent, - notifyDefinition.methodName, notifyDefinition.params) + notifyDefinition.methodName, notifyDefinition.parent, + notifyDefinition.methodName, notifyDefinition.params) code.beginControlFlow("for (\$T notifyUri: notifyUris\$L)", ClassNames.URI, notifyDefinition.methodName) } else { code.addStatement("\$T notifyUri\$L = \$L.\$L(\$L)", ClassNames.URI, - notifyDefinition.methodName, notifyDefinition.parent, - notifyDefinition.methodName, notifyDefinition.params) + notifyDefinition.methodName, notifyDefinition.parent, + notifyDefinition.methodName, notifyDefinition.params) } code.addStatement("getContext().getContentResolver().notifyChange(notifyUri\$L, null)", - if (notifyDefinition.returnsArray) "" else notifyDefinition.methodName) + if (notifyDefinition.returnsArray) "" else notifyDefinition.methodName) if (notifyDefinition.returnsArray) { code.endControlFlow() } @@ -231,7 +232,7 @@ class NotifyMethod(private val tableEndpointDefinition: TableEndpointDefinition, if (!hasListener) { - val isUpdateDelete = method == Notify.Method.UPDATE || method == Notify.Method.DELETE + val isUpdateDelete = notifyMethod == NotifyMethod.UPDATE || notifyMethod == NotifyMethod.DELETE if (isUpdateDelete) { code.beginControlFlow("if (count > 0)") } @@ -255,14 +256,14 @@ class QueryMethod(private val contentProviderDefinition: ContentProviderDefiniti override val methodSpec: MethodSpec? get() { val method = MethodSpec.methodBuilder("query") - .addAnnotation(Override::class.java) - .addModifiers(Modifier.PUBLIC, Modifier.FINAL) - .addParameter(ClassNames.URI, "uri") - .addParameter(ArrayTypeName.of(String::class.java), "projection") - .addParameter(ClassName.get(String::class.java), "selection") - .addParameter(ArrayTypeName.of(String::class.java), "selectionArgs") - .addParameter(ClassName.get(String::class.java), "sortOrder") - .returns(ClassNames.CURSOR) + .addAnnotation(Override::class.java) + .addModifiers(Modifier.PUBLIC, Modifier.FINAL) + .addParameter(ClassNames.URI, "uri") + .addParameter(ArrayTypeName.of(String::class.java), "projection") + .addParameter(ClassName.get(String::class.java), "selection") + .addParameter(ArrayTypeName.of(String::class.java), "selectionArgs") + .addParameter(ClassName.get(String::class.java), "sortOrder") + .returns(ClassNames.CURSOR) method.addStatement("\$L cursor = null", ClassNames.CURSOR) method.beginControlFlow("switch(\$L.match(uri))", ContentProviderDefinition.URI_MATCHER) @@ -273,8 +274,8 @@ class QueryMethod(private val contentProviderDefinition: ContentProviderDefiniti beginControlFlow("case \$L:", uriDefinition.name) addCode(uriDefinition.getSegmentsPreparation()) addCode("cursor = \$T.getDatabase(\$T.class).getWritableDatabase().query(\$S, projection, ", - ClassNames.FLOW_MANAGER, contentProviderDefinition.databaseTypeName, - tableEndpointDefinition.tableName) + ClassNames.FLOW_MANAGER, contentProviderDefinition.databaseTypeName, + tableEndpointDefinition.tableName) addCode(uriDefinition.getSelectionAndSelectionArgs()) addCode(", null, null, sortOrder);\n") addStatement("break") @@ -303,13 +304,13 @@ class UpdateMethod(private val contentProviderDefinition: ContentProviderDefinit override val methodSpec: MethodSpec? get() { val method = MethodSpec.methodBuilder("update") - .addAnnotation(Override::class.java) - .addModifiers(Modifier.PUBLIC) - .addParameter(ClassNames.URI, Constants.PARAM_URI) - .addParameter(ClassNames.CONTENT_VALUES, Constants.PARAM_CONTENT_VALUES) - .addParameter(ClassName.get(String::class.java), "selection") - .addParameter(ArrayTypeName.of(String::class.java), "selectionArgs") - .returns(TypeName.INT) + .addAnnotation(Override::class.java) + .addModifiers(Modifier.PUBLIC) + .addParameter(ClassNames.URI, Constants.PARAM_URI) + .addParameter(ClassNames.CONTENT_VALUES, Constants.PARAM_CONTENT_VALUES) + .addParameter(ClassName.get(String::class.java), "selection") + .addParameter(ArrayTypeName.of(String::class.java), "selectionArgs") + .returns(TypeName.INT) method.beginControlFlow("switch(MATCHER.match(\$L))", Constants.PARAM_URI) for (tableEndpointDefinition in contentProviderDefinition.endpointDefinitions) { @@ -318,23 +319,23 @@ class UpdateMethod(private val contentProviderDefinition: ContentProviderDefinit method.apply { beginControlFlow("case \$L:", uriDefinition.name) addStatement("\$T adapter = \$T.getModelAdapter(\$T.getTableClassForName(\$T.class, \$S))", - ClassNames.MODEL_ADAPTER, ClassNames.FLOW_MANAGER, ClassNames.FLOW_MANAGER, - contentProviderDefinition.databaseTypeName, - tableEndpointDefinition.tableName) + ClassNames.MODEL_ADAPTER, ClassNames.FLOW_MANAGER, ClassNames.FLOW_MANAGER, + contentProviderDefinition.databaseTypeName, + tableEndpointDefinition.tableName) addCode(uriDefinition.getSegmentsPreparation()) addCode( - "long count = \$T.getDatabase(\$T.class).getWritableDatabase().updateWithOnConflict(\$S, \$L, ", - ClassNames.FLOW_MANAGER, contentProviderDefinition.databaseTypeName, - tableEndpointDefinition.tableName, - Constants.PARAM_CONTENT_VALUES) + "long count = \$T.getDatabase(\$T.class).getWritableDatabase().updateWithOnConflict(\$S, \$L, ", + ClassNames.FLOW_MANAGER, contentProviderDefinition.databaseTypeName, + tableEndpointDefinition.tableName, + Constants.PARAM_CONTENT_VALUES) addCode(uriDefinition.getSelectionAndSelectionArgs()) addCode( - ", \$T.getSQLiteDatabaseAlgorithmInt(adapter.getUpdateOnConflictAction()));\n", - ClassNames.CONFLICT_ACTION) + ", \$T.getSQLiteDatabaseAlgorithmInt(adapter.getUpdateOnConflictAction()));\n", + ClassNames.CONFLICT_ACTION) val code = CodeBlock.builder() NotifyMethod(tableEndpointDefinition, uriDefinition, - Notify.Method.UPDATE).addCode(code) + NotifyMethod.UPDATE).addCode(code) addCode(code.build()) addStatement("return (int) count") @@ -368,10 +369,10 @@ class ContentProviderDefinition(typeElement: Element, processorManager: Processo var endpointDefinitions = arrayListOf() private val methods: Array = arrayOf(QueryMethod(this, manager), - InsertMethod(this, false), - InsertMethod(this, true), - DeleteMethod(this, manager), - UpdateMethod(this, manager)) + InsertMethod(this, false), + InsertMethod(this, true), + DeleteMethod(this, manager), + UpdateMethod(this, manager)) init { @@ -424,10 +425,10 @@ class ContentProviderDefinition(typeElement: Element, processorManager: Processo `override fun`(TypeName.BOOLEAN, "onCreate") { modifiers(public, final) addStatement("final \$T $AUTHORITY = \$L", String::class.java, - if (authority.contains("R.string.")) - "getContext().getString($authority)" - else - "\"$authority\"") + if (authority.contains("R.string.")) + "getContext().getString($authority)" + else + "\"$authority\"") for (endpointDefinition in endpointDefinitions) { endpointDefinition.contentUriDefinitions.forEach { @@ -436,7 +437,7 @@ class ContentProviderDefinition(typeElement: Element, processorManager: Processo path = "\"" + it.path + "\"" } else { path = CodeBlock.builder().add("\$L.\$L.getPath()", it.elementClassName, - it.name).build().toString() + it.name).build().toString() } addStatement("\$L.addURI(\$L, \$L, \$L)", URI_MATCHER, AUTHORITY, path, it.name) } @@ -456,12 +457,12 @@ class ContentProviderDefinition(typeElement: Element, processorManager: Processo statement("\$T type = null", ClassName.get(String::class.java)) controlFlow("switch(\$L.match(uri))", URI_MATCHER) { endpointDefinitions.flatMap { it.contentUriDefinitions } - .forEach { uri -> - controlFlow("case \$L:", uri.name) { - statement("type = \$S", uri.type) - `break`() + .forEach { uri -> + controlFlow("case \$L:", uri.name) { + statement("type = \$S", uri.type) + `break`() + } } - } appendDefault(this) } `return`("type") @@ -470,7 +471,7 @@ class ContentProviderDefinition(typeElement: Element, processorManager: Processo } methods.mapNotNull { it.methodSpec } - .forEach { typeBuilder.addMethod(it) } + .forEach { typeBuilder.addMethod(it) } } companion object { @@ -501,7 +502,7 @@ class ContentUriDefinition(typeElement: Element, processorManager: ProcessorMana var updateEnabled = false - var segments = arrayOf() + var segments = arrayOf() init { typeElement.annotation()?.let { contentUri -> diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/NotifyDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/NotifyDefinition.kt index dff447d93..46c2f83d9 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/NotifyDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/NotifyDefinition.kt @@ -1,6 +1,7 @@ package com.raizlabs.android.dbflow.processor.definition import com.raizlabs.android.dbflow.annotation.provider.Notify +import com.raizlabs.android.dbflow.annotation.provider.NotifyMethod import com.raizlabs.android.dbflow.processor.ClassNames import com.raizlabs.android.dbflow.processor.ProcessorManager import com.raizlabs.android.dbflow.processor.utils.annotation @@ -16,7 +17,7 @@ class NotifyDefinition(typeElement: Element, processorManager: ProcessorManager) : BaseDefinition(typeElement, processorManager) { var paths = arrayOf() - var method = Notify.Method.DELETE + var method = NotifyMethod.DELETE val parent = (typeElement.enclosingElement as TypeElement).qualifiedName.toString() val methodName = typeElement.simpleName.toString() var params: String @@ -27,7 +28,7 @@ class NotifyDefinition(typeElement: Element, processorManager: ProcessorManager) typeElement.annotation()?.let { notify -> paths = notify.paths - method = notify.method + method = notify.notifyMethod } val executableElement = typeElement as ExecutableElement diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/OneToManyDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/OneToManyDefinition.kt index 90cf24ffa..515414a53 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/OneToManyDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/OneToManyDefinition.kt @@ -6,6 +6,7 @@ import com.grosner.kpoet.end import com.grosner.kpoet.statement import com.grosner.kpoet.typeName import com.raizlabs.android.dbflow.annotation.OneToMany +import com.raizlabs.android.dbflow.annotation.OneToManyMethod import com.raizlabs.android.dbflow.processor.ClassNames import com.raizlabs.android.dbflow.processor.ProcessorManager import com.raizlabs.android.dbflow.processor.definition.column.ColumnAccessor @@ -43,19 +44,19 @@ class OneToManyDefinition(executableElement: ExecutableElement, private var _variableName: String - var methods = mutableListOf() + var methods = mutableListOf() val isLoad - get() = isAll || methods.contains(OneToMany.Method.LOAD) + get() = isAll || methods.contains(OneToManyMethod.LOAD) val isAll - get() = methods.contains(OneToMany.Method.ALL) + get() = methods.contains(OneToManyMethod.ALL) val isDelete: Boolean - get() = isAll || methods.contains(OneToMany.Method.DELETE) + get() = isAll || methods.contains(OneToManyMethod.DELETE) val isSave: Boolean - get() = isAll || methods.contains(OneToMany.Method.SAVE) + get() = isAll || methods.contains(OneToManyMethod.SAVE) var referencedTableType: TypeName? = null var hasWrapper = false @@ -90,7 +91,7 @@ class OneToManyDefinition(executableElement: ExecutableElement, // check on setter. if setter exists, we can reference it safely since a getter has already been defined. if (!parentElements.any { it.simpleString == privateAccessor.setterNameElement }) { manager.logError(OneToManyDefinition::class, - "@OneToMany definition $elementName Cannot find referenced variable $_variableName.") + "@OneToMany definition $elementName Cannot find referenced variable $_variableName.") } else { isVariablePrivate = true } @@ -98,7 +99,7 @@ class OneToManyDefinition(executableElement: ExecutableElement, isVariablePrivate = referencedElement.modifiers.contains(Modifier.PRIVATE) } - methods.addAll(oneToMany.methods) + methods.addAll(oneToMany.oneToManyMethods) val parameters = executableElement.parameters if (parameters.isNotEmpty()) { @@ -143,7 +144,7 @@ class OneToManyDefinition(executableElement: ExecutableElement, fun writeWrapperStatement(method: MethodSpec.Builder) { method.statement("\$T ${ModelUtils.wrapper} = \$T.getWritableDatabaseForTable(\$T.class)", - ClassNames.DATABASE_WRAPPER, ClassNames.FLOW_MANAGER, referencedTableType) + ClassNames.DATABASE_WRAPPER, ClassNames.FLOW_MANAGER, referencedTableType) } /** @@ -184,8 +185,8 @@ class OneToManyDefinition(executableElement: ExecutableElement, // need to load adapter for non-model classes if (!extendsModel || efficientCodeMethods) { statement("\$T adapter = \$T.getModelAdapter(\$T.class)", - ParameterizedTypeName.get(ClassNames.MODEL_ADAPTER, referencedTableType), - ClassNames.FLOW_MANAGER, referencedTableType) + ParameterizedTypeName.get(ClassNames.MODEL_ADAPTER, referencedTableType), + ClassNames.FLOW_MANAGER, referencedTableType) } if (efficientCodeMethods) { diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/TableDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/TableDefinition.kt index 9efa374ba..182ddc996 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/TableDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/TableDefinition.kt @@ -18,6 +18,7 @@ import com.grosner.kpoet.switch import com.raizlabs.android.dbflow.annotation.Column import com.raizlabs.android.dbflow.annotation.ColumnMap import com.raizlabs.android.dbflow.annotation.ConflictAction +import com.raizlabs.android.dbflow.annotation.DEFAULT_CACHE_SIZE import com.raizlabs.android.dbflow.annotation.ForeignKey import com.raizlabs.android.dbflow.annotation.InheritedColumn import com.raizlabs.android.dbflow.annotation.InheritedPrimaryKey @@ -595,7 +596,7 @@ class TableDefinition(manager: ProcessorManager, element: TypeElement) : BaseTab `return`("new String[]{${primaryColumns.joinToString { QueryBuilder.quoteIfNeeded(it.columnName).S }}}") } - if (cacheSize != Table.DEFAULT_CACHE_SIZE) { + if (cacheSize != DEFAULT_CACHE_SIZE) { `override fun`(TypeName.INT, "getCacheSize") { modifiers(public, final) `return`(cacheSize.L) diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/TableEndpointDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/TableEndpointDefinition.kt index 02030f7c2..901146204 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/TableEndpointDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/TableEndpointDefinition.kt @@ -2,6 +2,7 @@ package com.raizlabs.android.dbflow.processor.definition import com.raizlabs.android.dbflow.annotation.provider.ContentUri import com.raizlabs.android.dbflow.annotation.provider.Notify +import com.raizlabs.android.dbflow.annotation.provider.NotifyMethod import com.raizlabs.android.dbflow.annotation.provider.TableEndpoint import com.raizlabs.android.dbflow.processor.ProcessorManager import com.raizlabs.android.dbflow.processor.utils.annotation @@ -24,7 +25,7 @@ class TableEndpointDefinition(typeElement: Element, processorManager: ProcessorM */ internal var pathValidationMap: Map = mutableMapOf() - var notifyDefinitionPathMap: MutableMap>> + var notifyDefinitionPathMap: MutableMap>> = mutableMapOf() var tableName: String? = null diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ColumnDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ColumnDefinition.kt index 1fb2ee096..6deb4ac8a 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ColumnDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ColumnDefinition.kt @@ -4,8 +4,8 @@ import com.grosner.kpoet.code import com.raizlabs.android.dbflow.annotation.Collate import com.raizlabs.android.dbflow.annotation.Column import com.raizlabs.android.dbflow.annotation.ConflictAction +import com.raizlabs.android.dbflow.annotation.INDEX_GENERIC import com.raizlabs.android.dbflow.annotation.Index -import com.raizlabs.android.dbflow.annotation.IndexGroup import com.raizlabs.android.dbflow.annotation.NotNull import com.raizlabs.android.dbflow.annotation.PrimaryKey import com.raizlabs.android.dbflow.annotation.Unique @@ -212,7 +212,7 @@ constructor(processorManager: ProcessorManager, element: Element, element.annotation()?.let { index -> // empty index, we assume generic if (index.indexGroups.isEmpty()) { - indexGroups.add(IndexGroup.GENERIC) + indexGroups.add(INDEX_GENERIC) } else { index.indexGroups.forEach { indexGroups.add(it) } } diff --git a/dbflow-rx-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/rx/kotlinextensions/QueryExtensions.kt b/dbflow-rx-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/rx/kotlinextensions/QueryExtensions.kt index bf3591ffb..f9d144a8f 100644 --- a/dbflow-rx-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/rx/kotlinextensions/QueryExtensions.kt +++ b/dbflow-rx-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/rx/kotlinextensions/QueryExtensions.kt @@ -21,9 +21,6 @@ inline fun Queriable.rx() = RXSQLite.rx(T::class.java, this) // queriable extensions -inline val RXQueriable.count - get() = count() - inline val RXQueriable.cursor get() = query() @@ -83,5 +80,3 @@ infix inline fun RXQueriable.statement(crossinline func: (DatabaseStatement) -> infix inline fun RXQueriable.hasData(crossinline func: (Boolean) -> Unit): Subscription = hasData.subscribe { func(it) } infix inline fun RXQueriable.cursor(crossinline func: (Cursor) -> Unit): Subscription = cursor.subscribe { func(it) } - -infix inline fun RXQueriable.count(crossinline func: (Long) -> Unit): Subscription = count.subscribe { func(it) } \ No newline at end of file diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXModelQueriable.java b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXModelQueriable.java index e168ec708..ae39d35ce 100644 --- a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXModelQueriable.java +++ b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXModelQueriable.java @@ -89,14 +89,6 @@ public interface RXModelQueriable extends RXQueriable { @NonNull Single queryCustomSingle(Class queryModelClass); - /** - * Disables caching on this query for the object retrieved from DB (if caching enabled). If - * caching is not enabled, this method is ignored. This also disables caching in a {@link FlowCursorList} - * or {@link FlowQueryList} if you {@link #flowQueryList()} or {@link #cursorList()} - */ - @NonNull - RXModelQueriable disableCaching(); - /** * @return A new {@link Observable} that observes when the {@link TModel} table changes. * This can also be multiple tables, given if it results from a {@link Join} (one for each join table). diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXModelQueriableImpl.java b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXModelQueriableImpl.java index c88955951..724786959 100644 --- a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXModelQueriableImpl.java +++ b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXModelQueriableImpl.java @@ -126,7 +126,7 @@ public FlowQueryList call() throws Exception { @NonNull @Override public Single> queryCustomList( - final Class tQueryModelClass) { + final Class tQueryModelClass) { return fromCallable(new Callable>() { @Override public List call() throws Exception { @@ -138,7 +138,7 @@ public List call() throws Exception { @NonNull @Override public Single queryCustomSingle( - final Class tQueryModelClass) { + final Class tQueryModelClass) { return fromCallable(new Callable() { @Override public TQueryModel call() throws Exception { @@ -147,17 +147,10 @@ public TQueryModel call() throws Exception { }); } - @NonNull - @Override - public RXModelQueriable disableCaching() { - getInnerModelQueriable().disableCaching(); - return this; - } - @NonNull @Override public Observable> observeOnTableChanges() { return Observable.create(new TableChangeListenerEmitter<>(getInnerModelQueriable()), - Emitter.BackpressureMode.LATEST); + Emitter.BackpressureMode.LATEST); } } diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXQueriable.java b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXQueriable.java index 4c86a2e77..ce97de927 100644 --- a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXQueriable.java +++ b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXQueriable.java @@ -47,13 +47,6 @@ public interface RXQueriable { @NonNull Single compileStatement(DatabaseWrapper databaseWrapper); - /** - * @return the count of the results of the query. - * @deprecated use {@link #longValue()} - */ - @NonNull - Single count(); - /** * @return the long value of this query. **/ @@ -66,15 +59,6 @@ public interface RXQueriable { @NonNull Single longValue(DatabaseWrapper databaseWrapper); - /** - * Allows you to pass in a {@link DatabaseWrapper} manually. - * - * @return the count of the results of the query. - * @deprecated use {@link #longValue(DatabaseWrapper)} - */ - @NonNull - Single count(DatabaseWrapper databaseWrapper); - /** * @return This may return the number of rows affected from a {@link Insert} statement. * If not, returns {@link Model#INVALID_ROW_ID} diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXQueriableImpl.java b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXQueriableImpl.java index e50e73f12..cb51f5f9e 100644 --- a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXQueriableImpl.java +++ b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXQueriableImpl.java @@ -76,28 +76,6 @@ public DatabaseStatement call() throws Exception { }); } - @NonNull - @Override - public Single count() { - return fromCallable(new Callable() { - @Override - public Long call() throws Exception { - return getInnerQueriable().count(); - } - }); - } - - @NonNull - @Override - public Single count(final DatabaseWrapper databaseWrapper) { - return fromCallable(new Callable() { - @Override - public Long call() throws Exception { - return getInnerQueriable().count(databaseWrapper); - } - }); - } - @NonNull @Override public Single longValue() { diff --git a/dbflow-rx2-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/rx2/kotlinextensions/QueryExtensions.kt b/dbflow-rx2-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/rx2/kotlinextensions/QueryExtensions.kt index a4d2e3bbb..26af93c30 100644 --- a/dbflow-rx2-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/rx2/kotlinextensions/QueryExtensions.kt +++ b/dbflow-rx2-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/rx2/kotlinextensions/QueryExtensions.kt @@ -18,9 +18,6 @@ inline fun Queriable.rx() = RXSQLite.rx(T::class.java, this) // queriable extensions -inline val RXQueriable.count - get() = count() - inline val RXQueriable.cursor get() = query() @@ -80,5 +77,3 @@ infix inline fun RXQueriable.statement(crossinline func: (DatabaseStatement) -> infix inline fun RXQueriable.hasData(crossinline func: (Boolean) -> Unit): Disposable = hasData.subscribe { hasData -> func(hasData) } infix inline fun RXQueriable.cursor(crossinline func: (Cursor) -> Unit): Disposable = cursor.subscribe { cursor -> func(cursor) } - -infix inline fun RXQueriable.count(crossinline func: (Long) -> Unit): Disposable = count.subscribe { count -> func(count) } \ No newline at end of file diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXModelQueriable.java b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXModelQueriable.java index 278c2b16c..1c760a05c 100644 --- a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXModelQueriable.java +++ b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXModelQueriable.java @@ -91,14 +91,6 @@ public interface RXModelQueriable extends RXQueriable { @NonNull Maybe queryCustomSingle(Class queryModelClass); - /** - * Disables caching on this query for the object retrieved from DB (if caching enabled). If - * caching is not enabled, this method is ignored. This also disables caching in a {@link FlowCursorList} - * or {@link FlowQueryList} if you {@link #flowQueryList()} or {@link #cursorList()} - */ - @NonNull - RXModelQueriable disableCaching(); - /** * @return A new {@link Observable} that observes when the {@link TModel} table changes. * This can also be multiple tables, given if it results from a {@link Join} (one for each join table). diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXModelQueriableImpl.java b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXModelQueriableImpl.java index a24105a2d..edf88c1d7 100644 --- a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXModelQueriableImpl.java +++ b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXModelQueriableImpl.java @@ -127,7 +127,7 @@ public FlowQueryList call() throws Exception { @NonNull @Override public Single> queryCustomList( - final Class tQueryModelClass) { + final Class tQueryModelClass) { return fromCallable(new Callable>() { @Override public List call() throws Exception { @@ -139,7 +139,7 @@ public List call() throws Exception { @NonNull @Override public Maybe queryCustomSingle( - final Class tQueryModelClass) { + final Class tQueryModelClass) { return Maybe.fromCallable(new Callable() { @Override public TQueryModel call() throws Exception { @@ -148,17 +148,10 @@ public TQueryModel call() throws Exception { }); } - @NonNull - @Override - public RXModelQueriable disableCaching() { - getInnerModelQueriable().disableCaching(); - return this; - } - @NonNull @Override public Flowable> observeOnTableChanges() { return Flowable.create(new TableChangeOnSubscribe<>(getInnerModelQueriable()), - BackpressureStrategy.LATEST); + BackpressureStrategy.LATEST); } } diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXQueriable.java b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXQueriable.java index e2c121101..55e07880c 100644 --- a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXQueriable.java +++ b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXQueriable.java @@ -49,22 +49,6 @@ public interface RXQueriable { @NonNull Single compileStatement(DatabaseWrapper databaseWrapper); - /** - * @return the count of the results of the query. - * @deprecated use {@link #longValue()} - */ - @NonNull - Single count(); - - /** - * Allows you to pass in a {@link DatabaseWrapper} manually. - * - * @return the count of the results of the query. - * @deprecated use {@link #longValue(DatabaseWrapper)} - */ - @NonNull - Single count(DatabaseWrapper databaseWrapper); - /** * @return the long value of this query. **/ diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXQueriableImpl.java b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXQueriableImpl.java index a33c8acf9..125ab09dd 100644 --- a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXQueriableImpl.java +++ b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXQueriableImpl.java @@ -79,28 +79,6 @@ public DatabaseStatement call() throws Exception { }); } - @NonNull - @Override - public Single count() { - return fromCallable(new Callable() { - @Override - public Long call() throws Exception { - return getInnerQueriable().count(); - } - }); - } - - @NonNull - @Override - public Single count(final DatabaseWrapper databaseWrapper) { - return fromCallable(new Callable() { - @Override - public Long call() throws Exception { - return getInnerQueriable().count(databaseWrapper); - } - }); - } - @NonNull @Override public Single longValue() { diff --git a/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherDatabase.java b/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherDatabase.java index eb78f63ef..64e45401d 100644 --- a/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherDatabase.java +++ b/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherDatabase.java @@ -63,7 +63,7 @@ public SQLiteDatabase getDatabase() { @NonNull @Override public FlowCursor rawQuery(@NonNull String query, @Nullable String[] selectionArgs) { - return FlowCursor.from(database.rawQuery(query, selectionArgs)); + return FlowCursor.Companion.from(database.rawQuery(query, selectionArgs)); } @Override @@ -85,7 +85,7 @@ public FlowCursor query(@NonNull String tableName, @Nullable String groupBy, @Nullable String having, @Nullable String orderBy) { - return FlowCursor.from(database.query(tableName, columns, selection, selectionArgs, groupBy, having, orderBy)); + return FlowCursor.Companion.from(database.query(tableName, columns, selection, selectionArgs, groupBy, having, orderBy)); } @Override diff --git a/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherOpenHelper.java b/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherOpenHelper.java index 8465cb8c0..47d32bf64 100644 --- a/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherOpenHelper.java +++ b/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherOpenHelper.java @@ -32,7 +32,7 @@ public SQLCipherOpenHelper(DatabaseDefinition databaseDefinition, DatabaseHelper OpenHelper backupHelper = null; if (databaseDefinition.backupEnabled()) { // Temp database mirrors existing - backupHelper = new BackupHelper(FlowManager.getContext(), DatabaseHelperDelegate.getTempDbFileName(databaseDefinition), + backupHelper = new BackupHelper(FlowManager.getContext(), DatabaseHelperDelegate.Companion.getTempDbFileName(databaseDefinition), databaseDefinition.getDatabaseVersion(), databaseDefinition); } diff --git a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/DBFlowInstrumentedTestRule.kt b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/DBFlowInstrumentedTestRule.kt index 3ddedd217..362b1da22 100644 --- a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/DBFlowInstrumentedTestRule.kt +++ b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/DBFlowInstrumentedTestRule.kt @@ -1,6 +1,7 @@ package com.raizlabs.android.dbflow import com.raizlabs.android.dbflow.config.DatabaseConfig +import com.raizlabs.android.dbflow.config.DatabaseDefinition import com.raizlabs.android.dbflow.config.FlowConfig import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.prepackaged.PrepackagedDB @@ -16,13 +17,17 @@ class DBFlowInstrumentedTestRule : TestRule { @Throws(Throwable::class) override fun evaluate() { FlowManager.init(FlowConfig.Builder(DemoApp.context) - .addDatabaseConfig(DatabaseConfig.Builder(AppDatabase::class.java) - .transactionManagerCreator(::ImmediateTransactionManager) + .addDatabaseConfig(DatabaseConfig.Builder(AppDatabase::class.java) + .transactionManagerCreator( + object : DatabaseConfig.TransactionManagerCreator { + override fun createManager(databaseDefinition: DatabaseDefinition) + = ImmediateTransactionManager(databaseDefinition) + }) + .build()) + .addDatabaseConfig(DatabaseConfig.builder(PrepackagedDB::class.java) + .databaseName("prepackaged") + .build()) .build()) - .addDatabaseConfig(DatabaseConfig.builder(PrepackagedDB::class.java) - .databaseName("prepackaged") - .build()) - .build()) try { base.evaluate() } finally { diff --git a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/contentobserver/ContentObserverTest.kt b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/contentobserver/ContentObserverTest.kt index aaf231ac4..18ad24eda 100644 --- a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/contentobserver/ContentObserverTest.kt +++ b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/contentobserver/ContentObserverTest.kt @@ -6,15 +6,15 @@ import com.raizlabs.android.dbflow.DemoApp import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.contentobserver.User_Table.id import com.raizlabs.android.dbflow.contentobserver.User_Table.name -import com.raizlabs.android.dbflow.kotlinextensions.delete -import com.raizlabs.android.dbflow.kotlinextensions.insert -import com.raizlabs.android.dbflow.kotlinextensions.save -import com.raizlabs.android.dbflow.kotlinextensions.update import com.raizlabs.android.dbflow.runtime.FlowContentObserver import com.raizlabs.android.dbflow.sql.SqlUtils import com.raizlabs.android.dbflow.sql.language.Delete import com.raizlabs.android.dbflow.sql.language.SQLOperator import com.raizlabs.android.dbflow.structure.BaseModel +import com.raizlabs.android.dbflow.structure.delete +import com.raizlabs.android.dbflow.structure.insert +import com.raizlabs.android.dbflow.structure.save +import com.raizlabs.android.dbflow.structure.update import org.junit.Assert.assertEquals import org.junit.Assert.assertTrue import org.junit.Before @@ -34,9 +34,9 @@ class ContentObserverTest : BaseInstrumentedUnitTest() { @Test fun testSpecificUris() { val conditionGroup = FlowManager.getModelAdapter(User::class.java) - .getPrimaryConditionClause(user) + .getPrimaryConditionClause(user) val uri = SqlUtils.getNotificationUri(User::class.java, BaseModel.Action.DELETE, - conditionGroup.conditions.toTypedArray()) + conditionGroup.conditions.toTypedArray()) assertEquals(uri.authority, FlowManager.getTableName(User::class.java)) assertEquals(uri.fragment, BaseModel.Action.DELETE.name) diff --git a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/prepackaged/PrepackagedDBTest.kt b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/prepackaged/PrepackagedDBTest.kt index d31d543e3..cf9d362b4 100644 --- a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/prepackaged/PrepackagedDBTest.kt +++ b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/prepackaged/PrepackagedDBTest.kt @@ -1,9 +1,9 @@ package com.raizlabs.android.dbflow.prepackaged import com.raizlabs.android.dbflow.BaseInstrumentedUnitTest -import com.raizlabs.android.dbflow.kotlinextensions.from -import com.raizlabs.android.dbflow.kotlinextensions.list -import com.raizlabs.android.dbflow.kotlinextensions.select +import com.raizlabs.android.dbflow.sql.language.from +import com.raizlabs.android.dbflow.sql.language.select +import com.raizlabs.android.dbflow.sql.queriable.list import org.junit.Assert.assertTrue import org.junit.Test diff --git a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/sqlcipher/CipherTest.kt b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/sqlcipher/CipherTest.kt index 1a7231511..4fd129a52 100644 --- a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/sqlcipher/CipherTest.kt +++ b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/sqlcipher/CipherTest.kt @@ -1,11 +1,11 @@ package com.raizlabs.android.dbflow.sqlcipher import com.raizlabs.android.dbflow.BaseInstrumentedUnitTest -import com.raizlabs.android.dbflow.kotlinextensions.from -import com.raizlabs.android.dbflow.kotlinextensions.result -import com.raizlabs.android.dbflow.kotlinextensions.select -import com.raizlabs.android.dbflow.kotlinextensions.where import com.raizlabs.android.dbflow.sql.language.Delete +import com.raizlabs.android.dbflow.sql.language.from +import com.raizlabs.android.dbflow.sql.language.select +import com.raizlabs.android.dbflow.sql.language.where +import com.raizlabs.android.dbflow.sql.queriable.result import org.junit.Assert.assertTrue import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/contentprovider/ContentProviderObjects.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/contentprovider/ContentProviderObjects.kt index ccdedc49b..ba7eac6ab 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/contentprovider/ContentProviderObjects.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/contentprovider/ContentProviderObjects.kt @@ -7,6 +7,7 @@ import com.raizlabs.android.dbflow.annotation.ForeignKeyReference import com.raizlabs.android.dbflow.annotation.PrimaryKey import com.raizlabs.android.dbflow.annotation.Table import com.raizlabs.android.dbflow.annotation.provider.ContentProvider +import com.raizlabs.android.dbflow.annotation.provider.ContentType import com.raizlabs.android.dbflow.annotation.provider.ContentUri import com.raizlabs.android.dbflow.annotation.provider.TableEndpoint import com.raizlabs.android.dbflow.structure.provider.BaseProviderModel @@ -18,7 +19,7 @@ import com.raizlabs.android.dbflow.structure.provider.ContentUtils * Description: */ @ContentProvider(authority = ContentDatabase.AUTHORITY, database = ContentDatabase::class, - baseContentUri = ContentDatabase.BASE_CONTENT_URI) + baseContentUri = ContentDatabase.BASE_CONTENT_URI) @Database(version = ContentDatabase.VERSION) object ContentDatabase { @@ -39,19 +40,19 @@ class ContentProviderModel(@PrimaryKey(autoincrement = true) @Column var title: String? = null) : BaseProviderModel() { - override fun getDeleteUri() = TestContentProvider.ContentProviderModel.CONTENT_URI + override val deleteUri get() = TestContentProvider.ContentProviderModel.CONTENT_URI - override fun getInsertUri() = TestContentProvider.ContentProviderModel.CONTENT_URI + override val insertUri get() = TestContentProvider.ContentProviderModel.CONTENT_URI - override fun getUpdateUri() = TestContentProvider.ContentProviderModel.CONTENT_URI + override val updateUri get() = TestContentProvider.ContentProviderModel.CONTENT_URI - override fun getQueryUri() = TestContentProvider.ContentProviderModel.CONTENT_URI + override val queryUri get() = TestContentProvider.ContentProviderModel.CONTENT_URI companion object { const val NAME = "ContentProviderModel" - @ContentUri(path = NAME, type = ContentUri.ContentType.VND_MULTIPLE + NAME) + @ContentUri(path = NAME, type = "${ContentType.VND_MULTIPLE}$NAME") val CONTENT_URI = ContentUtils.buildUriWithAuthority(ContentDatabase.AUTHORITY) } } @@ -61,7 +62,7 @@ class NoteModel(@PrimaryKey(autoincrement = true) var id: Long = 0, @ForeignKey(references = arrayOf(ForeignKeyReference(columnName = "providerModel", - foreignKeyColumnName = "id"))) + foreignKeyColumnName = "id"))) var contentProviderModel: ContentProviderModel? = null, @Column @@ -70,13 +71,13 @@ class NoteModel(@PrimaryKey(autoincrement = true) @Column var isOpen: Boolean = false) : BaseProviderModel() { - override fun getDeleteUri() = TestContentProvider.NoteModel.CONTENT_URI + override val deleteUri get() = TestContentProvider.NoteModel.CONTENT_URI - override fun getInsertUri() = TestContentProvider.NoteModel.CONTENT_URI + override val insertUri get() = TestContentProvider.NoteModel.CONTENT_URI - override fun getUpdateUri() = TestContentProvider.NoteModel.CONTENT_URI + override val updateUri get() = TestContentProvider.NoteModel.CONTENT_URI - override fun getQueryUri() = TestContentProvider.NoteModel.CONTENT_URI + override val queryUri get() = TestContentProvider.NoteModel.CONTENT_URI } @Table(database = ContentDatabase::class) @@ -85,11 +86,11 @@ class TestSyncableModel(@PrimaryKey(autoincrement = true) @Column var name: String? = null) : BaseSyncableProviderModel() { - override fun getDeleteUri() = TestContentProvider.TestSyncableModel.CONTENT_URI + override val deleteUri get() = TestContentProvider.TestSyncableModel.CONTENT_URI - override fun getInsertUri() = TestContentProvider.TestSyncableModel.CONTENT_URI + override val insertUri get() = TestContentProvider.TestSyncableModel.CONTENT_URI - override fun getUpdateUri() = TestContentProvider.TestSyncableModel.CONTENT_URI + override val updateUri get() = TestContentProvider.TestSyncableModel.CONTENT_URI - override fun getQueryUri() = TestContentProvider.TestSyncableModel.CONTENT_URI + override val queryUri get() = TestContentProvider.TestSyncableModel.CONTENT_URI } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/contentprovider/ContentProviderTests.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/contentprovider/ContentProviderTests.kt index a35431650..6edb73d41 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/contentprovider/ContentProviderTests.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/contentprovider/ContentProviderTests.kt @@ -3,10 +3,10 @@ package com.raizlabs.android.dbflow.contentprovider import android.content.ContentResolver import android.content.pm.ProviderInfo import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.kotlinextensions.from +import com.raizlabs.android.dbflow.sql.language.from import com.raizlabs.android.dbflow.kotlinextensions.result -import com.raizlabs.android.dbflow.kotlinextensions.select -import com.raizlabs.android.dbflow.kotlinextensions.where +import com.raizlabs.android.dbflow.sql.language.select +import com.raizlabs.android.dbflow.sql.language.where import com.raizlabs.android.dbflow.sql.language.Delete import com.raizlabs.android.dbflow.structure.provider.ContentUtils import org.junit.Assert.assertEquals diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/contentprovider/TestContentProvider.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/contentprovider/TestContentProvider.kt index ef7b2c6b1..c7cdd3aeb 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/contentprovider/TestContentProvider.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/contentprovider/TestContentProvider.kt @@ -44,7 +44,7 @@ object TestContentProvider { } @JvmStatic - @Notify(method = Notify.Method.INSERT, paths = arrayOf(ContentProviderModel.ENDPOINT + "/#")) + @Notify(notifyMethod = Notify.Method.INSERT, paths = arrayOf(ContentProviderModel.ENDPOINT + "/#")) fun onInsert(contentValues: ContentValues): Array { val id = contentValues.getAsLong("id")!! return arrayOf(withId(id)) @@ -85,21 +85,21 @@ object TestContentProvider { } @JvmStatic - @Notify(method = Notify.Method.INSERT, paths = arrayOf(ENDPOINT)) + @Notify(notifyMethod = Notify.Method.INSERT, paths = arrayOf(ENDPOINT)) fun onInsert(contentValues: ContentValues): Array { val listId = contentValues.getAsLong(SqlUtils.getContentValuesKey(contentValues, "providerModel"))!! return arrayOf(ContentProviderModel.withId(listId), fromList(listId)) } @JvmStatic - @Notify(method = Notify.Method.INSERT, paths = arrayOf(ENDPOINT)) + @Notify(notifyMethod = Notify.Method.INSERT, paths = arrayOf(ENDPOINT)) fun onInsert2(contentValues: ContentValues): Uri { val listId = contentValues.getAsLong(SqlUtils.getContentValuesKey(contentValues, "providerModel"))!! return fromList(listId) } @JvmStatic - @Notify(method = Notify.Method.UPDATE, paths = arrayOf(ENDPOINT + "/#")) + @Notify(notifyMethod = Notify.Method.UPDATE, paths = arrayOf(ENDPOINT + "/#")) fun onUpdate(context: Context, uri: Uri): Array { val noteId = java.lang.Long.valueOf(uri.pathSegments[1])!! val c = context.contentResolver.query(uri, arrayOf("noteModel"), null, null, null) @@ -111,7 +111,7 @@ object TestContentProvider { } @JvmStatic - @Notify(method = Notify.Method.DELETE, paths = arrayOf(ENDPOINT + "/#")) + @Notify(notifyMethod = Notify.Method.DELETE, paths = arrayOf(ENDPOINT + "/#")) fun onDelete(context: Context, uri: Uri): Array { val noteId = java.lang.Long.valueOf(uri.pathSegments[1])!! val c = context.contentResolver.query(uri, null, null, null, null) diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/FastStoreModelTransactionTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/FastStoreModelTransactionTest.kt index ec50b25b7..71c9fae02 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/FastStoreModelTransactionTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/FastStoreModelTransactionTest.kt @@ -6,9 +6,9 @@ import com.raizlabs.android.dbflow.kotlinextensions.database import com.raizlabs.android.dbflow.kotlinextensions.fastInsert import com.raizlabs.android.dbflow.kotlinextensions.fastSave import com.raizlabs.android.dbflow.kotlinextensions.fastUpdate -import com.raizlabs.android.dbflow.kotlinextensions.from +import com.raizlabs.android.dbflow.sql.language.from import com.raizlabs.android.dbflow.kotlinextensions.list -import com.raizlabs.android.dbflow.kotlinextensions.select +import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.TwoColumnModel import org.junit.Assert.assertEquals diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorIteratorTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorIteratorTest.kt index db50dcab2..daff07b47 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorIteratorTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorIteratorTest.kt @@ -1,9 +1,9 @@ package com.raizlabs.android.dbflow.list import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.kotlinextensions.from +import com.raizlabs.android.dbflow.sql.language.from import com.raizlabs.android.dbflow.kotlinextensions.save -import com.raizlabs.android.dbflow.kotlinextensions.select +import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.models.SimpleModel import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorListTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorListTest.kt index eef5f1279..bc47de5aa 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorListTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorListTest.kt @@ -5,10 +5,10 @@ import com.nhaarman.mockito_kotlin.times import com.nhaarman.mockito_kotlin.verify import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.kotlinextensions.cursor -import com.raizlabs.android.dbflow.kotlinextensions.from +import com.raizlabs.android.dbflow.sql.language.from import com.raizlabs.android.dbflow.kotlinextensions.get import com.raizlabs.android.dbflow.kotlinextensions.save -import com.raizlabs.android.dbflow.kotlinextensions.select +import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.structure.cache.SimpleMapCache import org.junit.Assert.assertEquals diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowQueryListTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowQueryListTest.kt index 03bd7969d..b931e8a1b 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowQueryListTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowQueryListTest.kt @@ -4,8 +4,8 @@ import com.nhaarman.mockito_kotlin.argumentCaptor import com.nhaarman.mockito_kotlin.mock import com.nhaarman.mockito_kotlin.verify import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.kotlinextensions.from -import com.raizlabs.android.dbflow.kotlinextensions.select +import com.raizlabs.android.dbflow.sql.language.from +import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.structure.cache.SimpleMapCache import com.raizlabs.android.dbflow.structure.database.transaction.Transaction diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/AutoIncrementTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/AutoIncrementTest.kt index 5e1e18ece..839ed4ab4 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/AutoIncrementTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/AutoIncrementTest.kt @@ -4,7 +4,6 @@ import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.TestDatabase import com.raizlabs.android.dbflow.annotation.PrimaryKey import com.raizlabs.android.dbflow.annotation.Table -import com.raizlabs.android.dbflow.kotlinextensions.insert import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/CachingModelsTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/CachingModelsTest.kt index a8a4484d5..d94185f7d 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/CachingModelsTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/CachingModelsTest.kt @@ -1,11 +1,11 @@ package com.raizlabs.android.dbflow.models import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.kotlinextensions.from +import com.raizlabs.android.dbflow.sql.language.from import com.raizlabs.android.dbflow.kotlinextensions.list import com.raizlabs.android.dbflow.kotlinextensions.result import com.raizlabs.android.dbflow.kotlinextensions.save -import com.raizlabs.android.dbflow.kotlinextensions.select +import com.raizlabs.android.dbflow.sql.language.select import org.junit.Assert.assertEquals import org.junit.Assert.assertNotEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/DontCreateModelTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/DontCreateModelTest.kt index 22edf3655..f3bff4622 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/DontCreateModelTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/DontCreateModelTest.kt @@ -3,9 +3,9 @@ package com.raizlabs.android.dbflow.models import android.database.sqlite.SQLiteException import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.assertThrowsException -import com.raizlabs.android.dbflow.kotlinextensions.from +import com.raizlabs.android.dbflow.sql.language.from import com.raizlabs.android.dbflow.kotlinextensions.list -import com.raizlabs.android.dbflow.kotlinextensions.select +import com.raizlabs.android.dbflow.sql.language.select import org.junit.Test /** diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ModelViews.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ModelViews.kt index 2fa430801..64cd61bea 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ModelViews.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ModelViews.kt @@ -5,7 +5,7 @@ import com.raizlabs.android.dbflow.annotation.Column import com.raizlabs.android.dbflow.annotation.ColumnMap import com.raizlabs.android.dbflow.annotation.ModelView import com.raizlabs.android.dbflow.annotation.ModelViewQuery -import com.raizlabs.android.dbflow.kotlinextensions.from +import com.raizlabs.android.dbflow.sql.language.from import com.raizlabs.android.dbflow.kotlinextensions.property import com.raizlabs.android.dbflow.models.Author_Table.first_name import com.raizlabs.android.dbflow.models.Author_Table.id diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModelTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModelTest.kt index 188869dc6..dc72531ea 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModelTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModelTest.kt @@ -1,13 +1,12 @@ package com.raizlabs.android.dbflow.models import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.kotlinextensions.delete import com.raizlabs.android.dbflow.kotlinextensions.exists -import com.raizlabs.android.dbflow.kotlinextensions.from +import com.raizlabs.android.dbflow.sql.language.from import com.raizlabs.android.dbflow.kotlinextensions.list import com.raizlabs.android.dbflow.kotlinextensions.result import com.raizlabs.android.dbflow.kotlinextensions.save -import com.raizlabs.android.dbflow.kotlinextensions.select +import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.kotlinextensions.writableDatabaseForTable import org.junit.Assert.assertFalse import org.junit.Assert.assertNotNull diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModels.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModels.kt index 18864840b..1bb0d72f0 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModels.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModels.kt @@ -4,10 +4,10 @@ import com.raizlabs.android.dbflow.TestDatabase import com.raizlabs.android.dbflow.annotation.OneToMany import com.raizlabs.android.dbflow.annotation.PrimaryKey import com.raizlabs.android.dbflow.annotation.Table -import com.raizlabs.android.dbflow.kotlinextensions.from +import com.raizlabs.android.dbflow.sql.language.from import com.raizlabs.android.dbflow.kotlinextensions.oneToMany -import com.raizlabs.android.dbflow.kotlinextensions.select -import com.raizlabs.android.dbflow.kotlinextensions.where +import com.raizlabs.android.dbflow.sql.language.select +import com.raizlabs.android.dbflow.sql.language.where import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id import com.raizlabs.android.dbflow.structure.BaseModel @@ -18,10 +18,10 @@ class OneToManyModel(@PrimaryKey var name: String? = null) { var models: List? = null - @get:OneToMany(methods = arrayOf(OneToMany.Method.ALL)) + @get:OneToMany(oneToManyMethods = arrayOf(OneToMany.Method.ALL)) var simpleModels by oneToMany { select from OneToManyBaseModel::class } - @OneToMany(methods = arrayOf(OneToMany.Method.ALL), isVariablePrivate = true, + @OneToMany(oneToManyMethods = arrayOf(OneToMany.Method.ALL), isVariablePrivate = true, variableName = "orders", efficientMethods = false) fun getRelatedOrders(): List { var localOrders = orders @@ -33,7 +33,7 @@ class OneToManyModel(@PrimaryKey var name: String? = null) { return localOrders } - @OneToMany(methods = arrayOf(OneToMany.Method.DELETE), isVariablePrivate = true, + @OneToMany(oneToManyMethods = arrayOf(OneToMany.Method.DELETE), isVariablePrivate = true, variableName = "models") fun getRelatedModels(): List { var localModels = models diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ParentChildCachingTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ParentChildCachingTest.kt index 66771bcff..66a96cbea 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ParentChildCachingTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ParentChildCachingTest.kt @@ -1,9 +1,9 @@ package com.raizlabs.android.dbflow.models import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.kotlinextensions.from +import com.raizlabs.android.dbflow.sql.language.from import com.raizlabs.android.dbflow.kotlinextensions.result -import com.raizlabs.android.dbflow.kotlinextensions.select +import com.raizlabs.android.dbflow.sql.language.select import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/QueryModelTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/QueryModelTest.kt index dcee6a3be..325a28cb7 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/QueryModelTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/QueryModelTest.kt @@ -3,7 +3,7 @@ package com.raizlabs.android.dbflow.models import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.kotlinextensions.eq import com.raizlabs.android.dbflow.kotlinextensions.exists -import com.raizlabs.android.dbflow.kotlinextensions.from +import com.raizlabs.android.dbflow.sql.language.from import com.raizlabs.android.dbflow.kotlinextensions.innerJoin import com.raizlabs.android.dbflow.kotlinextensions.on import com.raizlabs.android.dbflow.kotlinextensions.save diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/Issue.java b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/Issue.java index 8c5b9d44f..837bd2908 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/Issue.java +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/Issue.java @@ -2,6 +2,7 @@ import com.raizlabs.android.dbflow.TestDatabase; import com.raizlabs.android.dbflow.annotation.OneToMany; +import com.raizlabs.android.dbflow.annotation.OneToManyMethod; import com.raizlabs.android.dbflow.annotation.PrimaryKey; import com.raizlabs.android.dbflow.annotation.Table; import com.raizlabs.android.dbflow.sql.language.SQLite; @@ -21,7 +22,7 @@ public class Issue extends BaseModel { List subIssueList; - @OneToMany(methods = {OneToMany.Method.SAVE, OneToMany.Method.DELETE}, variableName = "subIssueList") + @OneToMany(oneToManyMethods = {OneToManyMethod.SAVE, OneToManyMethod.DELETE}, variableName = "subIssueList") public List getDbSubIssueList() { if (subIssueList == null || subIssueList.isEmpty()) { subIssueList = SQLite.INSTANCE.select() diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/SubIssue.java b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/SubIssue.java index e7a979d49..dc7c1e32f 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/SubIssue.java +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/SubIssue.java @@ -2,6 +2,7 @@ import com.raizlabs.android.dbflow.TestDatabase; import com.raizlabs.android.dbflow.annotation.OneToMany; +import com.raizlabs.android.dbflow.annotation.OneToManyMethod; import com.raizlabs.android.dbflow.annotation.PrimaryKey; import com.raizlabs.android.dbflow.annotation.Table; import com.raizlabs.android.dbflow.sql.language.SQLite; @@ -25,16 +26,16 @@ public class SubIssue extends BaseModel { List pageList; - @OneToMany(methods = {OneToMany.Method.SAVE, OneToMany.Method.DELETE}, variableName = "pageList") + @OneToMany(oneToManyMethods = {OneToManyMethod.SAVE, OneToManyMethod.DELETE}, variableName = "pageList") public List getDbPageList() { if (pageList == null) { pageList = new ArrayList<>(); } if (pageList.isEmpty()) { pageList = SQLite.INSTANCE.select() - .from(Page.class) - .where(Page_Table.owningIssueId.eq(owningIssueId), Page_Table.subIssue_id.eq(id)) - .queryList(); + .from(Page.class) + .where(Page_Table.owningIssueId.eq(owningIssueId), Page_Table.subIssue_id.eq(id)) + .queryList(); } return pageList; } diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/runtime/DirectNotifierTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/runtime/DirectNotifierTest.kt index 34834cca5..0896ab41d 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/runtime/DirectNotifierTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/runtime/DirectNotifierTest.kt @@ -9,11 +9,8 @@ import com.raizlabs.android.dbflow.TestDatabase import com.raizlabs.android.dbflow.config.DatabaseConfig import com.raizlabs.android.dbflow.config.FlowConfig import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.kotlinextensions.columnValues -import com.raizlabs.android.dbflow.kotlinextensions.delete -import com.raizlabs.android.dbflow.kotlinextensions.insert -import com.raizlabs.android.dbflow.kotlinextensions.save -import com.raizlabs.android.dbflow.kotlinextensions.set +import com.raizlabs.android.dbflow.sql.language.delete +import com.raizlabs.android.dbflow.sql.language.insert import com.raizlabs.android.dbflow.kotlinextensions.update import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriberTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriberTest.kt index 0c81a6caf..508b93d9b 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriberTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriberTest.kt @@ -1,9 +1,9 @@ package com.raizlabs.android.dbflow.rx.language import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.kotlinextensions.from +import com.raizlabs.android.dbflow.sql.language.from import com.raizlabs.android.dbflow.kotlinextensions.save -import com.raizlabs.android.dbflow.kotlinextensions.select +import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.rx.kotlinextensions.rx import org.junit.Assert.assertEquals diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/RXQueryTests.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/RXQueryTests.kt index c3c1ef240..db2b8e9d2 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/RXQueryTests.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/RXQueryTests.kt @@ -2,14 +2,13 @@ package com.raizlabs.android.dbflow.rx.language import android.database.Cursor import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.kotlinextensions.from -import com.raizlabs.android.dbflow.kotlinextensions.insert +import com.raizlabs.android.dbflow.sql.language.from +import com.raizlabs.android.dbflow.sql.language.insert import com.raizlabs.android.dbflow.kotlinextensions.save -import com.raizlabs.android.dbflow.kotlinextensions.select +import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table.name import com.raizlabs.android.dbflow.rx.kotlinextensions.rx -import com.raizlabs.android.dbflow.rx.kotlinextensions.rxBaseQueriable import com.raizlabs.android.dbflow.sql.language.SQLite.selectCountOf import com.raizlabs.android.dbflow.sql.language.property.Property import com.raizlabs.android.dbflow.structure.database.DatabaseStatement diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CaseTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CaseTest.kt index 1b29e968e..c5f7f5084 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CaseTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CaseTest.kt @@ -1,9 +1,6 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.kotlinextensions.`else` -import com.raizlabs.android.dbflow.kotlinextensions.case -import com.raizlabs.android.dbflow.kotlinextensions.caseWhen import com.raizlabs.android.dbflow.kotlinextensions.propertyString import com.raizlabs.android.dbflow.models.SimpleModel_Table import org.junit.Assert.assertEquals diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CursorResultTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CursorResultTest.kt index b695dc7d4..06aa227c6 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CursorResultTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CursorResultTest.kt @@ -3,9 +3,7 @@ package com.raizlabs.android.dbflow.sql.language import android.database.StaleDataException import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.kotlinextensions.cursorResult -import com.raizlabs.android.dbflow.kotlinextensions.from import com.raizlabs.android.dbflow.kotlinextensions.save -import com.raizlabs.android.dbflow.kotlinextensions.select import com.raizlabs.android.dbflow.kotlinextensions.toCustomList import com.raizlabs.android.dbflow.kotlinextensions.toCustomListClose import com.raizlabs.android.dbflow.kotlinextensions.toCustomModel diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/DeleteTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/DeleteTest.kt index b416ddf67..7a77af991 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/DeleteTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/DeleteTest.kt @@ -1,11 +1,8 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.kotlinextensions.delete -import com.raizlabs.android.dbflow.kotlinextensions.from import com.raizlabs.android.dbflow.kotlinextensions.list import com.raizlabs.android.dbflow.kotlinextensions.save -import com.raizlabs.android.dbflow.kotlinextensions.select import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table import org.junit.Assert.assertEquals diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/ExistenceOperatorTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/ExistenceOperatorTest.kt index f4e410180..8dc8cbc27 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/ExistenceOperatorTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/ExistenceOperatorTest.kt @@ -1,9 +1,6 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.kotlinextensions.from -import com.raizlabs.android.dbflow.kotlinextensions.select -import com.raizlabs.android.dbflow.kotlinextensions.where import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table import org.junit.Assert.assertEquals diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/FromTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/FromTest.kt index 512c160be..2fda66327 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/FromTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/FromTest.kt @@ -1,11 +1,8 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.kotlinextensions.`as` -import com.raizlabs.android.dbflow.kotlinextensions.from import com.raizlabs.android.dbflow.kotlinextensions.innerJoin import com.raizlabs.android.dbflow.kotlinextensions.on -import com.raizlabs.android.dbflow.kotlinextensions.select import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table.name import com.raizlabs.android.dbflow.models.TwoColumnModel diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexTest.kt index 0dc98776b..94a01b3c8 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexTest.kt @@ -1,7 +1,6 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.kotlinextensions.indexOn import com.raizlabs.android.dbflow.kotlinextensions.nameAlias import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexedByTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexedByTest.kt index 77a6a74fc..f2aab60e2 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexedByTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexedByTest.kt @@ -1,8 +1,6 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.kotlinextensions.from -import com.raizlabs.android.dbflow.kotlinextensions.select import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table import com.raizlabs.android.dbflow.sql.language.property.IndexProperty diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/InsertTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/InsertTest.kt index 21178f025..9f36c1163 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/InsertTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/InsertTest.kt @@ -2,10 +2,7 @@ package com.raizlabs.android.dbflow.sql.language import android.content.ContentValues import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.kotlinextensions.from -import com.raizlabs.android.dbflow.kotlinextensions.insert -import com.raizlabs.android.dbflow.kotlinextensions.select -import com.raizlabs.android.dbflow.kotlinextensions.set +import com.raizlabs.android.dbflow.structure.database.set import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.TwoColumnModel import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/JoinTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/JoinTest.kt index be2acea20..b7d6f8919 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/JoinTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/JoinTest.kt @@ -2,12 +2,10 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.kotlinextensions.crossJoin -import com.raizlabs.android.dbflow.kotlinextensions.from import com.raizlabs.android.dbflow.kotlinextensions.innerJoin import com.raizlabs.android.dbflow.kotlinextensions.leftOuterJoin import com.raizlabs.android.dbflow.kotlinextensions.naturalJoin import com.raizlabs.android.dbflow.kotlinextensions.on -import com.raizlabs.android.dbflow.kotlinextensions.select import com.raizlabs.android.dbflow.kotlinextensions.using import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/NameAliasTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/NameAliasTest.kt index 8b9854071..1c31f5cba 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/NameAliasTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/NameAliasTest.kt @@ -1,7 +1,6 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.kotlinextensions.`as` import com.raizlabs.android.dbflow.kotlinextensions.nameAlias import org.junit.Assert.assertEquals import org.junit.Assert.assertFalse diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OperatorGroupTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OperatorGroupTest.kt index 128a0d018..63810d910 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OperatorGroupTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OperatorGroupTest.kt @@ -2,9 +2,7 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.assertEquals -import com.raizlabs.android.dbflow.kotlinextensions.and import com.raizlabs.android.dbflow.kotlinextensions.andAll -import com.raizlabs.android.dbflow.kotlinextensions.or import com.raizlabs.android.dbflow.kotlinextensions.orAll import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.name diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OperatorTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OperatorTest.kt index b557c1d1f..58b83036e 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OperatorTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OperatorTest.kt @@ -3,12 +3,9 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.annotation.Collate import com.raizlabs.android.dbflow.assertEquals -import com.raizlabs.android.dbflow.kotlinextensions.and import com.raizlabs.android.dbflow.kotlinextensions.between import com.raizlabs.android.dbflow.kotlinextensions.collate -import com.raizlabs.android.dbflow.kotlinextensions.from import com.raizlabs.android.dbflow.kotlinextensions.op -import com.raizlabs.android.dbflow.kotlinextensions.select import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/SelectTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/SelectTest.kt index cd9f72d48..8ed426f37 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/SelectTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/SelectTest.kt @@ -2,7 +2,6 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.assertEquals -import com.raizlabs.android.dbflow.kotlinextensions.from import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.TwoColumnModel import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/TriggerTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/TriggerTest.kt index 7a108451d..51315bc3f 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/TriggerTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/TriggerTest.kt @@ -2,18 +2,13 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.assertEquals -import com.raizlabs.android.dbflow.kotlinextensions.and import com.raizlabs.android.dbflow.kotlinextensions.begin import com.raizlabs.android.dbflow.kotlinextensions.columnValues import com.raizlabs.android.dbflow.kotlinextensions.createTrigger import com.raizlabs.android.dbflow.kotlinextensions.eq -import com.raizlabs.android.dbflow.kotlinextensions.from -import com.raizlabs.android.dbflow.kotlinextensions.insert import com.raizlabs.android.dbflow.kotlinextensions.insertOn import com.raizlabs.android.dbflow.kotlinextensions.property -import com.raizlabs.android.dbflow.kotlinextensions.select import com.raizlabs.android.dbflow.kotlinextensions.updateOn -import com.raizlabs.android.dbflow.kotlinextensions.where import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table.name import com.raizlabs.android.dbflow.models.TwoColumnModel diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UnsafeStringOperatorTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UnsafeStringOperatorTest.kt index fd3998184..9c121a7a7 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UnsafeStringOperatorTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UnsafeStringOperatorTest.kt @@ -2,9 +2,6 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.assertEquals -import com.raizlabs.android.dbflow.kotlinextensions.from -import com.raizlabs.android.dbflow.kotlinextensions.select -import com.raizlabs.android.dbflow.kotlinextensions.where import com.raizlabs.android.dbflow.models.SimpleModel import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UpdateTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UpdateTest.kt index fb7e0c46a..d6704575e 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UpdateTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UpdateTest.kt @@ -3,8 +3,6 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.annotation.ConflictAction import com.raizlabs.android.dbflow.assertEquals -import com.raizlabs.android.dbflow.kotlinextensions.eq -import com.raizlabs.android.dbflow.kotlinextensions.set import com.raizlabs.android.dbflow.kotlinextensions.update import com.raizlabs.android.dbflow.models.NumberModel import com.raizlabs.android.dbflow.models.NumberModel_Table.id diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/WhereTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/WhereTest.kt index d6b053ebd..e264545da 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/WhereTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/WhereTest.kt @@ -2,21 +2,15 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.assertEquals -import com.raizlabs.android.dbflow.kotlinextensions.and -import com.raizlabs.android.dbflow.kotlinextensions.from import com.raizlabs.android.dbflow.kotlinextensions.groupBy import com.raizlabs.android.dbflow.kotlinextensions.having import com.raizlabs.android.dbflow.kotlinextensions.limit import com.raizlabs.android.dbflow.kotlinextensions.list import com.raizlabs.android.dbflow.kotlinextensions.nameAlias import com.raizlabs.android.dbflow.kotlinextensions.offset -import com.raizlabs.android.dbflow.kotlinextensions.or import com.raizlabs.android.dbflow.kotlinextensions.orderBy import com.raizlabs.android.dbflow.kotlinextensions.result -import com.raizlabs.android.dbflow.kotlinextensions.select import com.raizlabs.android.dbflow.kotlinextensions.update -import com.raizlabs.android.dbflow.kotlinextensions.where -import com.raizlabs.android.dbflow.kotlinextensions.whereExists import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table.name import com.raizlabs.android.dbflow.models.TwoColumnModel diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/PropertyFactoryTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/PropertyFactoryTest.kt index 7476f9c6f..74fcd95e2 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/PropertyFactoryTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/PropertyFactoryTest.kt @@ -1,10 +1,10 @@ package com.raizlabs.android.dbflow.sql.language.property import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.kotlinextensions.from +import com.raizlabs.android.dbflow.sql.language.from import com.raizlabs.android.dbflow.kotlinextensions.property import com.raizlabs.android.dbflow.kotlinextensions.propertyString -import com.raizlabs.android.dbflow.kotlinextensions.select +import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.models.SimpleModel import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/queriable/AsyncQueryTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/queriable/AsyncQueryTest.kt index 10925cc4f..2bdbd98eb 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/queriable/AsyncQueryTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/queriable/AsyncQueryTest.kt @@ -3,11 +3,11 @@ package com.raizlabs.android.dbflow.sql.queriable import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.kotlinextensions.async import com.raizlabs.android.dbflow.kotlinextensions.cursorResult -import com.raizlabs.android.dbflow.kotlinextensions.from +import com.raizlabs.android.dbflow.sql.language.from import com.raizlabs.android.dbflow.kotlinextensions.list import com.raizlabs.android.dbflow.kotlinextensions.result import com.raizlabs.android.dbflow.kotlinextensions.save -import com.raizlabs.android.dbflow.kotlinextensions.select +import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.sql.language.CursorResult import org.junit.Assert.assertEquals diff --git a/dbflow/build.gradle b/dbflow/build.gradle index 421ae2fdd..256de16f2 100644 --- a/dbflow/build.gradle +++ b/dbflow/build.gradle @@ -26,7 +26,7 @@ android { dependencies { api project("${dbflow_project_prefix}dbflow-core") - api "com.android.support:support-annotations:26.1.0" + api "com.android.support:support-annotations:27.0.1" compile "org.jetbrains.kotlin:kotlin-stdlib-jre7:$kotlin_version" } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.kt index c4fb4b977..365b273c6 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.kt @@ -57,9 +57,8 @@ class DatabaseConfig( }) @Suppress("UNCHECKED_CAST") - fun getTableConfigForTable(modelClass: Class): TableConfig? { - return tableConfigMap[modelClass] as TableConfig? - } + fun getTableConfigForTable(modelClass: Class): TableConfig? = + tableConfigMap[modelClass] as TableConfig? /** * Build compatibility class for Java. Use the [DatabaseConfig] class directly if Kotlin consumer. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.kt index f96e0a93a..c78420c4c 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.kt @@ -8,6 +8,9 @@ import com.raizlabs.android.dbflow.runtime.BaseTransactionManager import com.raizlabs.android.dbflow.runtime.ContentResolverNotifier import com.raizlabs.android.dbflow.runtime.ModelNotifier import com.raizlabs.android.dbflow.sql.migration.Migration +import com.raizlabs.android.dbflow.sql.queriable.ListModelLoader +import com.raizlabs.android.dbflow.sql.queriable.SingleModelLoader +import com.raizlabs.android.dbflow.sql.saveable.ModelSaver import com.raizlabs.android.dbflow.structure.BaseModelView import com.raizlabs.android.dbflow.structure.ModelAdapter import com.raizlabs.android.dbflow.structure.ModelViewAdapter @@ -83,7 +86,7 @@ abstract class DatabaseDefinition { * @return The list of [QueryModelAdapter]. Internal method for creating query models in the DB. */ val modelQueryAdapters: List> - get() = ArrayList(queryModelAdapterMap.values) + get() = queryModelAdapterMap.values.toList() /** * @return The map of migrations to DB version @@ -162,25 +165,17 @@ abstract class DatabaseDefinition { /** * Applies a database configuration object to this class. */ + @Suppress("UNCHECKED_CAST") internal fun applyDatabaseConfig(databaseConfig: DatabaseConfig?) { this.databaseConfig = databaseConfig if (databaseConfig != null) { // initialize configuration if exists. val tableConfigCollection = databaseConfig.tableConfigMap.values for (tableConfig in tableConfigCollection) { - val modelAdapter = modelAdapters[tableConfig.tableClass] ?: continue - if (tableConfig.listModelLoader != null) { - modelAdapter.listModelLoader = tableConfig.listModelLoader - } - - if (tableConfig.singleModelLoader != null) { - modelAdapter.singleModelLoader = tableConfig.singleModelLoader - } - - if (tableConfig.modelSaver != null) { - modelAdapter.modelSaver = tableConfig.modelSaver - } - + val modelAdapter: ModelAdapter = modelAdapters[tableConfig.tableClass] as ModelAdapter? ?: continue + tableConfig.listModelLoader?.let { modelAdapter.listModelLoader = it as ListModelLoader } + tableConfig.singleModelLoader?.let { modelAdapter.singleModelLoader = it as SingleModelLoader } + tableConfig.modelSaver?.let { modelAdapter.modelSaver = it as ModelSaver } } helperListener = databaseConfig.helperListener } @@ -191,18 +186,18 @@ abstract class DatabaseDefinition { } } - protected fun addModelAdapter(modelAdapter: ModelAdapter, holder: DatabaseHolder) { + protected fun addModelAdapter(modelAdapter: ModelAdapter, holder: DatabaseHolder) { holder.putDatabaseForTable(modelAdapter.modelClass, this) modelTableNames.put(modelAdapter.tableName, modelAdapter.modelClass) modelAdapters.put(modelAdapter.modelClass, modelAdapter) } - protected fun addModelViewAdapter(modelViewAdapter: ModelViewAdapter, holder: DatabaseHolder) { + protected fun addModelViewAdapter(modelViewAdapter: ModelViewAdapter, holder: DatabaseHolder) { holder.putDatabaseForTable(modelViewAdapter.modelClass, this) modelViewAdapterMap.put(modelViewAdapter.modelClass, modelViewAdapter) } - protected fun addQueryModelAdapter(queryModelAdapter: QueryModelAdapter, holder: DatabaseHolder) { + protected fun addQueryModelAdapter(queryModelAdapter: QueryModelAdapter, holder: DatabaseHolder) { holder.putDatabaseForTable(queryModelAdapter.modelClass, this) queryModelAdapterMap.put(queryModelAdapter.modelClass, queryModelAdapter) } @@ -231,7 +226,7 @@ abstract class DatabaseDefinition { * @param table The model that exists in this database. * @return The ModelAdapter for the table. */ - fun getModelAdapterForTable(table: Class): ModelAdapter? { + fun getModelAdapterForTable(table: Class): ModelAdapter? { @Suppress("UNCHECKED_CAST") return modelAdapters[table] as ModelAdapter? } @@ -241,31 +236,27 @@ abstract class DatabaseDefinition { * @return The associated [ModelAdapter] within this database for the specified table name. * If the Model is missing the [Table] annotation, this will return null. */ - fun getModelClassForName(tableName: String): Class<*>? { - return modelTableNames[tableName] - } + fun getModelClassForName(tableName: String): Class<*>? = modelTableNames[tableName] /** * @param table the VIEW class to retrieve the ModelViewAdapter from. * @return the associated [ModelViewAdapter] for the specified table. */ @Suppress("UNCHECKED_CAST") - fun getModelViewAdapterForTable(table: Class): ModelViewAdapter? { - return modelViewAdapterMap[table] as ModelViewAdapter? - } + fun getModelViewAdapterForTable(table: Class): ModelViewAdapter? = + modelViewAdapterMap[table] as ModelViewAdapter? /** * @param queryModel The [QueryModel] class * @return The adapter that corresponds to the specified class. */ @Suppress("UNCHECKED_CAST") - fun getQueryModelAdapterForQueryClass(queryModel: Class): QueryModelAdapter? { - return queryModelAdapterMap[queryModel] as QueryModelAdapter? - } + fun getQueryModelAdapterForQueryClass(queryModel: Class): QueryModelAdapter? = + queryModelAdapterMap[queryModel] as QueryModelAdapter? fun getModelNotifier(): ModelNotifier { if (modelNotifier == null) { - val config = FlowManager.getConfig().getDatabaseConfigMap()[associatedDatabaseClassFile] + val config = FlowManager.getConfig().databaseConfigMap[associatedDatabaseClassFile] modelNotifier = if (config?.modelNotifier == null) { ContentResolverNotifier() } else { @@ -275,9 +266,8 @@ abstract class DatabaseDefinition { return modelNotifier!! } - fun beginTransactionAsync(transaction: ITransaction): Transaction.Builder { - return Transaction.Builder(transaction, this) - } + fun beginTransactionAsync(transaction: ITransaction): Transaction.Builder = + Transaction.Builder(transaction, this) fun executeTransaction(transaction: ITransaction) { val database = writableDatabase @@ -290,6 +280,11 @@ abstract class DatabaseDefinition { } } + inline fun executeTransaction(crossinline transaction: (DatabaseWrapper) -> Unit) + = executeTransaction(object : ITransaction { + override fun execute(databaseWrapper: DatabaseWrapper) = transaction(databaseWrapper) + }) + /** * @return True if the [Database.consistencyCheckEnabled] annotation is true. */ diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseHolder.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseHolder.kt index 32da5e366..9b7041b36 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseHolder.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseHolder.kt @@ -12,6 +12,8 @@ abstract class DatabaseHolder { val databaseDefinitionMap: MutableMap, DatabaseDefinition> = HashMap() val databaseNameMap: MutableMap = HashMap() val databaseClassLookupMap: MutableMap, DatabaseDefinition> = HashMap() + + @JvmField val typeConverters: MutableMap, TypeConverter<*, *>> = HashMap() val databaseDefinitions: List @@ -21,29 +23,22 @@ abstract class DatabaseHolder { * @param clazz The model value class to get a [com.raizlabs.android.dbflow.converter.TypeConverter] * @return Type converter for the specified model value. */ - fun getTypeConverterForClass(clazz: Class<*>): TypeConverter<*, *>? { - return typeConverters[clazz] - } + fun getTypeConverterForClass(clazz: Class<*>): TypeConverter<*, *>? = typeConverters[clazz] /** * @param table The model class * @return The database that the table belongs in */ - fun getDatabaseForTable(table: Class<*>): DatabaseDefinition? { - return databaseDefinitionMap[table] - } + fun getDatabaseForTable(table: Class<*>): DatabaseDefinition? = databaseDefinitionMap[table] - fun getDatabase(databaseClass: Class<*>): DatabaseDefinition? { - return databaseClassLookupMap[databaseClass] - } + fun getDatabase(databaseClass: Class<*>): DatabaseDefinition? = + databaseClassLookupMap[databaseClass] /** * @param databaseName The name of the database to retrieve * @return The database that has the specified name */ - fun getDatabase(databaseName: String): DatabaseDefinition? { - return databaseNameMap[databaseName] - } + fun getDatabase(databaseName: String): DatabaseDefinition? = databaseNameMap[databaseName] /** * Helper method used to store a database for the specified table. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowLog.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowLog.kt index 4a1fce24d..687613e5b 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowLog.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowLog.kt @@ -33,7 +33,7 @@ object FlowLog { */ @JvmOverloads @JvmStatic - fun log(level: Level, tag: String = TAG, message: String = "", throwable: Throwable? = null) { + fun log(level: Level, tag: String = TAG, message: String? = "", throwable: Throwable? = null) { if (isEnabled(level)) { level.call(tag, message, throwable) } @@ -83,32 +83,32 @@ object FlowLog { */ enum class Level { V { - override fun call(tag: String, message: String, throwable: Throwable?) { + override fun call(tag: String, message: String?, throwable: Throwable?) { Log.v(tag, message, throwable) } }, D { - override fun call(tag: String, message: String, throwable: Throwable?) { + override fun call(tag: String, message: String?, throwable: Throwable?) { Log.d(tag, message, throwable) } }, I { - override fun call(tag: String, message: String, throwable: Throwable?) { + override fun call(tag: String, message: String?, throwable: Throwable?) { Log.i(tag, message, throwable) } }, W { - override fun call(tag: String, message: String, throwable: Throwable?) { + override fun call(tag: String, message: String?, throwable: Throwable?) { Log.w(tag, message, throwable) } }, E { - override fun call(tag: String, message: String, throwable: Throwable?) { + override fun call(tag: String, message: String?, throwable: Throwable?) { Log.e(tag, message, throwable) } }, WTF { - override fun call(tag: String, message: String, throwable: Throwable?) { + override fun call(tag: String, message: String?, throwable: Throwable?) { if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.FROYO) { Log.wtf(tag, message, throwable) } else { @@ -118,7 +118,7 @@ object FlowLog { } }; - internal abstract fun call(tag: String, message: String, throwable: Throwable?) + internal abstract fun call(tag: String, message: String?, throwable: Throwable?) } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt index 6b022ba82..0f05d08a0 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt @@ -241,18 +241,18 @@ object FlowManager { fun init(flowConfig: FlowConfig) { FlowManager.config = flowConfig + @Suppress("UNCHECKED_CAST") try { - val defaultHolderClass = Class.forName(DEFAULT_DATABASE_HOLDER_CLASSNAME) as Class loadDatabaseHolder(defaultHolderClass) } catch (e: ModuleNotFoundException) { // Ignore this exception since it means the application does not have its // own database. The initialization happens because the application is using // a module that has a database. - FlowLog.log(FlowLog.Level.W, e.message) + FlowLog.log(level = FlowLog.Level.W, message = e.message) } catch (e: ClassNotFoundException) { // warning if a library uses DBFlow with module support but the app you're using doesn't support it. - FlowLog.log(FlowLog.Level.W, "Could not find the default GeneratedDatabaseHolder") + FlowLog.log(level = FlowLog.Level.W, message = "Could not find the default GeneratedDatabaseHolder") } flowConfig.databaseHolders.forEach { loadDatabaseHolder(it) } @@ -298,7 +298,7 @@ object FlowManager { */ @Suppress("UNCHECKED_CAST") @JvmStatic - fun getInstanceAdapter(modelClass: Class): InstanceAdapter { + fun getInstanceAdapter(modelClass: Class): InstanceAdapter { var internalAdapter: InstanceAdapter<*>? = getModelAdapterOrNull(modelClass) if (internalAdapter == null) { internalAdapter = getModelViewAdapterOrNull(modelClass) @@ -306,7 +306,7 @@ object FlowManager { internalAdapter = getQueryModelAdapterOrNull(modelClass) } } - return internalAdapter as InstanceAdapter? ?: throwCannotFindAdapter("InstanceAdapter", modelClass) + return internalAdapter as InstanceAdapter? ?: throwCannotFindAdapter("InstanceAdapter", modelClass) } /** @@ -315,8 +315,8 @@ object FlowManager { * it checks both the [ModelViewAdapter] and [QueryModelAdapter]. */ @JvmStatic - fun getRetrievalAdapter(modelClass: Class): RetrievalAdapter { - var retrievalAdapter: RetrievalAdapter? = getModelAdapterOrNull(modelClass) + fun getRetrievalAdapter(modelClass: Class): RetrievalAdapter { + var retrievalAdapter: RetrievalAdapter? = getModelAdapterOrNull(modelClass) if (retrievalAdapter == null) { retrievalAdapter = getModelViewAdapterOrNull(modelClass) if (retrievalAdapter == null) { @@ -329,39 +329,36 @@ object FlowManager { /** * @param modelClass The class of the table - * @param The class that implements [Model] + * @param [T] The class that implements [Model] * @return The associated model adapter (DAO) that is generated from a [Table] class. Handles * interactions with the database. This method is meant for internal usage only. * We strongly prefer you use the built-in methods associated with [Model] and [BaseModel]. */ @JvmStatic - fun getModelAdapter(modelClass: Class): ModelAdapter { - return getModelAdapterOrNull(modelClass) ?: throwCannotFindAdapter("ModelAdapter", modelClass) - } + fun getModelAdapter(modelClass: Class): ModelAdapter = + getModelAdapterOrNull(modelClass) ?: throwCannotFindAdapter("ModelAdapter", modelClass) /** * Returns the model view adapter for a SQLite VIEW. These are only created with the [com.raizlabs.android.dbflow.annotation.ModelView] annotation. * * @param modelViewClass The class of the VIEW - * @param The class that extends [BaseModelView] + * @param [T] The class that extends [BaseModelView] * @return The model view adapter for the specified model view. */ @JvmStatic - fun getModelViewAdapter(modelViewClass: Class): ModelViewAdapter { - return getModelViewAdapterOrNull(modelViewClass) ?: throwCannotFindAdapter("ModelViewAdapter", modelViewClass) - } + fun getModelViewAdapter(modelViewClass: Class): ModelViewAdapter = + getModelViewAdapterOrNull(modelViewClass) ?: throwCannotFindAdapter("ModelViewAdapter", modelViewClass) /** - * Returns the query model adapter for an undefined query. These are only created with the [TQueryModel] annotation. + * Returns the query model adapter for an undefined query. These are only created with the [T] annotation. * * @param queryModelClass The class of the query - * @param The class that extends [BaseQueryModel] + * @param [T] The class that extends [BaseQueryModel] * @return The query model adapter for the specified model query. */ @JvmStatic - fun getQueryModelAdapter(queryModelClass: Class): QueryModelAdapter { - return getQueryModelAdapterOrNull(queryModelClass) ?: throwCannotFindAdapter("QueryModelAdapter", queryModelClass) - } + fun getQueryModelAdapter(queryModelClass: Class): QueryModelAdapter = + getQueryModelAdapterOrNull(queryModelClass) ?: throwCannotFindAdapter("QueryModelAdapter", queryModelClass) @JvmStatic fun getModelNotifierForTable(table: Class<*>): ModelNotifier = @@ -371,17 +368,14 @@ object FlowManager { fun newRegisterForTable(table: Class<*>): TableNotifierRegister = getModelNotifierForTable(table).newRegister() - private fun getModelAdapterOrNull(modelClass: Class): ModelAdapter? { - return FlowManager.getDatabaseForTable(modelClass).getModelAdapterForTable(modelClass) - } + private fun getModelAdapterOrNull(modelClass: Class): ModelAdapter? = + FlowManager.getDatabaseForTable(modelClass).getModelAdapterForTable(modelClass) - private fun getModelViewAdapterOrNull(modelClass: Class): ModelViewAdapter? { - return FlowManager.getDatabaseForTable(modelClass).getModelViewAdapterForTable(modelClass) - } + private fun getModelViewAdapterOrNull(modelClass: Class): ModelViewAdapter? = + FlowManager.getDatabaseForTable(modelClass).getModelViewAdapterForTable(modelClass) - private fun getQueryModelAdapterOrNull(modelClass: Class): QueryModelAdapter? { - return FlowManager.getDatabaseForTable(modelClass).getQueryModelAdapterForQueryClass(modelClass) - } + private fun getQueryModelAdapterOrNull(modelClass: Class): QueryModelAdapter? = + FlowManager.getDatabaseForTable(modelClass).getQueryModelAdapterForQueryClass(modelClass) /** * @param databaseName The name of the database. Will throw an exception if the database doesn't exist. @@ -426,4 +420,36 @@ object FlowManager { constructor(throwable: Throwable) : super(throwable) {} } -} \ No newline at end of file +} + +/** + * Easily get access to its [DatabaseDefinition] directly. + */ +inline fun database() = FlowManager.getDatabase(T::class.java) + +inline fun writableDatabaseForTable() = FlowManager.getWritableDatabaseForTable(T::class.java) + +/** + * Easily get access to its [DatabaseDefinition] directly. + */ +inline fun databaseForTable() = FlowManager.getDatabaseForTable(T::class.java) + +/** + * Easily get its table name. + */ +inline fun tableName() = FlowManager.getTableName(T::class.java) + +/** + * Easily get its [ModelAdapter]. + */ +inline fun modelAdapter() = FlowManager.getModelAdapter(T::class.java) + +/** + * Easily get its [QueryModelAdapter]. + */ +inline fun queryModelAdapter() = FlowManager.getQueryModelAdapter(T::class.java) + +/** + * Easily get its [ModelViewAdapter] + */ +inline fun modelViewAdapter() = FlowManager.getModelViewAdapter(T::class.java) \ No newline at end of file diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/TableConfig.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/TableConfig.kt index aa6217167..0a53f301d 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/TableConfig.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/TableConfig.kt @@ -9,12 +9,12 @@ import com.raizlabs.android.dbflow.structure.ModelAdapter * Description: Represents certain table configuration options. This allows you to easily specify * certain configuration options for a table. */ -class TableConfig(val tableClass: Class? = null, - val modelSaver: ModelSaver? = null, - val singleModelLoader: SingleModelLoader? = null, - val listModelLoader: ListModelLoader? = null) { +class TableConfig(val tableClass: Class, + val modelSaver: ModelSaver? = null, + val singleModelLoader: SingleModelLoader? = null, + val listModelLoader: ListModelLoader? = null) { - internal constructor(builder: Builder) : this( + internal constructor(builder: Builder) : this( tableClass = builder.tableClass, modelSaver = builder.modelAdapterModelSaver, singleModelLoader = builder.singleModelLoader, @@ -24,30 +24,30 @@ class TableConfig(val tableClass: Class? = null, /** * Table builder for java consumers. use [TableConfig] directly if calling from Kotlin. */ - class Builder(internal val tableClass: Class) { - internal var modelAdapterModelSaver: ModelSaver? = null - internal var singleModelLoader: SingleModelLoader? = null - internal var listModelLoader: ListModelLoader? = null + class Builder(internal val tableClass: Class) { + internal var modelAdapterModelSaver: ModelSaver? = null + internal var singleModelLoader: SingleModelLoader? = null + internal var listModelLoader: ListModelLoader? = null /** - * Define how the [ModelAdapter] saves data into the DB from its associated [TModel]. This + * Define how the [ModelAdapter] saves data into the DB from its associated [T]. This * will override the default. */ - fun modelAdapterModelSaver(modelSaver: ModelSaver) = apply { + fun modelAdapterModelSaver(modelSaver: ModelSaver) = apply { this.modelAdapterModelSaver = modelSaver } /** * Define how the table loads single models. This will override the default. */ - fun singleModelLoader(singleModelLoader: SingleModelLoader) = apply { + fun singleModelLoader(singleModelLoader: SingleModelLoader) = apply { this.singleModelLoader = singleModelLoader } /** * Define how the table loads a [List] of items. This will override the default. */ - fun listModelLoader(listModelLoader: ListModelLoader) = apply { + fun listModelLoader(listModelLoader: ListModelLoader) = apply { this.listModelLoader = listModelLoader } @@ -60,7 +60,8 @@ class TableConfig(val tableClass: Class? = null, companion object { - fun builder(tableClass: Class): TableConfig.Builder = + @JvmStatic + fun builder(tableClass: Class): TableConfig.Builder = TableConfig.Builder(tableClass) } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorIterator.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorIterator.kt index 33563b75c..901210099 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorIterator.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorIterator.kt @@ -51,7 +51,7 @@ class FlowCursorIterator override fun next(): TModel { checkSizes() - val item = cursorList.getItem(count - reverseIndex) + val item = cursorList.get(count - reverseIndex) reverseIndex-- return item } @@ -60,7 +60,7 @@ class FlowCursorIterator override fun previous(): TModel { checkSizes() - val item = cursorList.getItem(count - reverseIndex) + val item = cursorList.get(count - reverseIndex) reverseIndex++ return item } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorList.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorList.kt index 063f5371b..6b011958e 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorList.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorList.kt @@ -14,12 +14,12 @@ import java.util.* /** * Description: A non-modifiable, cursor-backed list that you can use in [ListView] or other data sources. */ -class FlowCursorList private constructor(builder: Builder) : IFlowCursorIterator { +class FlowCursorList private constructor(builder: Builder) : IFlowCursorIterator { /** * Interface for callbacks when cursor gets refreshed. */ - interface OnCursorRefreshListener { + interface OnCursorRefreshListener { /** * Callback when cursor refreshes. @@ -30,23 +30,23 @@ class FlowCursorList private constructor(builder: Builder) : IFl } - val table: Class - val modelQueriable: ModelQueriable + val table: Class + val modelQueriable: ModelQueriable private var cursor: FlowCursor? = null private val cursorFunc: () -> FlowCursor - internal val instanceAdapter: InstanceAdapter + internal val instanceAdapter: InstanceAdapter - private val cursorRefreshListenerSet = HashSet>() + private val cursorRefreshListenerSet = HashSet>() - internal val modelAdapter: ModelAdapter - get() = instanceAdapter as ModelAdapter + internal val modelAdapter: ModelAdapter + get() = instanceAdapter as ModelAdapter /** - * @return the full, converted [TModel] list from the database on this list. For large + * @return the full, converted [T] list from the database on this list. For large * data sets that require a large conversion, consider calling this on a BG thread. */ - val all: List + val all: List get() { throwIfCursorClosed() warnEmptyCursor() @@ -73,24 +73,24 @@ class FlowCursorList private constructor(builder: Builder) : IFl instanceAdapter = FlowManager.getInstanceAdapter(builder.modelClass) } - override operator fun iterator(): FlowCursorIterator { + override operator fun iterator(): FlowCursorIterator { return FlowCursorIterator(this) } - override fun iterator(startingLocation: Int, limit: Long): FlowCursorIterator { + override fun iterator(startingLocation: Int, limit: Long): FlowCursorIterator { return FlowCursorIterator(this, startingLocation, limit) } /** * Register listener for when cursor refreshes. */ - fun addOnCursorRefreshListener(onCursorRefreshListener: OnCursorRefreshListener) { + fun addOnCursorRefreshListener(onCursorRefreshListener: OnCursorRefreshListener) { synchronized(cursorRefreshListenerSet) { cursorRefreshListenerSet.add(onCursorRefreshListener) } } - fun removeOnCursorRefreshListener(onCursorRefreshListener: OnCursorRefreshListener) { + fun removeOnCursorRefreshListener(onCursorRefreshListener: OnCursorRefreshListener) { synchronized(cursorRefreshListenerSet) { cursorRefreshListenerSet.remove(onCursorRefreshListener) } @@ -111,12 +111,12 @@ class FlowCursorList private constructor(builder: Builder) : IFl /** * Returns a model at the specified position. If we are using the cache and it does not contain a model - * at that position, we move the cursor to the specified position and construct the [TModel]. + * at that position, we move the cursor to the specified position and construct the [T]. * * @param position The row number in the [android.database.Cursor] to look at - * @return The [TModel] converted from the cursor + * @return The [T] converted from the cursor */ - override fun getItem(position: Long): TModel { + override fun get(position: Long): T { throwIfCursorClosed() val cursor = unpackCursor() @@ -176,27 +176,27 @@ class FlowCursorList private constructor(builder: Builder) : IFl * @return A new [Builder] that contains the same cache, query statement, and other * underlying data, but allows for modification. */ - fun newBuilder(): Builder { + fun newBuilder(): Builder { return Builder(modelQueriable).cursor(unpackCursor()) } /** * Provides easy way to construct a [FlowCursorList]. * - * @param - */ - class Builder { + * @param [T] + */ + class Builder { - internal val modelClass: Class + internal val modelClass: Class internal var cursor: FlowCursor? = null - internal var modelQueriable: ModelQueriable + internal var modelQueriable: ModelQueriable - constructor(modelClass: Class) { + constructor(modelClass: Class) { this.modelClass = modelClass this.modelQueriable = SQLite.select().from(modelClass) } - constructor(modelQueriable: ModelQueriable) { + constructor(modelQueriable: ModelQueriable) { this.modelClass = modelQueriable.table this.modelQueriable = modelQueriable } @@ -213,11 +213,13 @@ class FlowCursorList private constructor(builder: Builder) : IFl /** * The default size of the cache if cache size is 0 or not specified. */ + @JvmStatic val DEFAULT_CACHE_SIZE = 50 /** * Minimum size that we make the cache (if size is supported in cache) */ + @JvmStatic val MIN_CACHE_SIZE = 20 } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowQueryList.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowQueryList.kt index bd46fb04a..588690cc6 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowQueryList.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowQueryList.kt @@ -23,7 +23,7 @@ import com.raizlabs.android.dbflow.structure.database.transaction.Transaction * on this list to know when the results complete. NOTE: any modifications to this list will be reflected * on the underlying table. */ -class FlowQueryList( +class FlowQueryList( /** * If true, we will make all modifications on the [DefaultTransactionQueue], else * we will run it on the main thread. @@ -33,21 +33,21 @@ class FlowQueryList( /** * Holds the table cursor */ - val internalCursorList: FlowCursorList) - : FlowContentObserver(), List, IFlowCursorIterator { + val internalCursorList: FlowCursorList) + : FlowContentObserver(), List, IFlowCursorIterator { private var pendingRefresh = false /** * @return a mutable list that does not reflect changes on the underlying DB. */ - val copy: List + val copy: List get() = internalCursorList.all - internal val modelAdapter: ModelAdapter + internal val modelAdapter: ModelAdapter get() = internalCursorList.modelAdapter - internal val instanceAdapter: InstanceAdapter + internal val instanceAdapter: InstanceAdapter get() = internalCursorList.instanceAdapter override val count: Long @@ -64,7 +64,7 @@ class FlowQueryList( } } - internal constructor(builder: Builder) : this( + internal constructor(builder: Builder) : this( transact = builder.transact, changeInTransaction = builder.changeInTransaction, internalCursorList = FlowCursorList.Builder(builder.modelQueriable) @@ -81,11 +81,11 @@ class FlowQueryList( super.registerForContentChanges(context, internalCursorList.table) } - fun addOnCursorRefreshListener(onCursorRefreshListener: OnCursorRefreshListener) { + fun addOnCursorRefreshListener(onCursorRefreshListener: OnCursorRefreshListener) { internalCursorList.addOnCursorRefreshListener(onCursorRefreshListener) } - fun removeOnCursorRefreshListener(onCursorRefreshListener: OnCursorRefreshListener) { + fun removeOnCursorRefreshListener(onCursorRefreshListener: OnCursorRefreshListener) { internalCursorList.removeOnCursorRefreshListener(onCursorRefreshListener) } @@ -114,14 +114,14 @@ class FlowQueryList( } } - val cursorList: FlowCursorList + val cursorList: FlowCursorList get() = internalCursorList /** * @return Constructs a new [Builder] that reuses the underlying [Cursor], cache, * callbacks, and other properties. */ - fun newBuilder(): Builder { + fun newBuilder(): Builder { return Builder(internalCursorList) .changeInTransaction(changeInTransaction) .transact(transact) @@ -157,12 +157,12 @@ class FlowQueryList( } /** - * Checks to see if the table contains the object only if its a [TModel] + * Checks to see if the table contains the object only if its a [T] * * @param element A model class. For interface purposes, this must be an Object. * @return always false if its anything other than the current table. True if [com.raizlabs.android.dbflow.structure.Model.exists] passes. */ - override operator fun contains(element: TModel): Boolean { + override operator fun contains(element: T): Boolean { return internalCursorList.instanceAdapter.exists(element) } @@ -172,7 +172,7 @@ class FlowQueryList( * @param elements The collection to check if all exist within the table. * @return true if all items exist in table, false if at least one fails. */ - override fun containsAll(elements: Collection): Boolean { + override fun containsAll(elements: Collection): Boolean { var contains = !elements.isEmpty() if (contains) { contains = elements.all { it in this } @@ -180,8 +180,8 @@ class FlowQueryList( return contains } - override fun getItem(position: Long): TModel { - return internalCursorList.getItem(position) + override fun get(position: Long): T { + return internalCursorList.get(position) } override fun cursor(): Cursor? { @@ -196,11 +196,9 @@ class FlowQueryList( * @return A model converted from the internal [FlowCursorList]. For * performance improvements, ensure caching is turned on. */ - override operator fun get(index: Int): TModel { - return internalCursorList.getItem(index.toLong()) - } + override operator fun get(index: Int): T = internalCursorList.get(index.toLong()) - override fun indexOf(element: TModel): Int { + override fun indexOf(element: T): Int { throw UnsupportedOperationException( "We cannot determine which index in the table this item exists at efficiently") } @@ -211,42 +209,42 @@ class FlowQueryList( /** * @return An iterator from [FlowCursorList.getAll]. - * Be careful as this method will convert all data under this table into a list of [TModel] in the UI thread. + * Be careful as this method will convert all data under this table into a list of [T] in the UI thread. */ - override fun iterator(): FlowCursorIterator { + override fun iterator(): FlowCursorIterator { return FlowCursorIterator(this) } - override fun iterator(startingLocation: Int, limit: Long): FlowCursorIterator { + override fun iterator(startingLocation: Int, limit: Long): FlowCursorIterator { return FlowCursorIterator(this, startingLocation, limit) } - override fun lastIndexOf(element: TModel): Int { + override fun lastIndexOf(element: T): Int { throw UnsupportedOperationException( "We cannot determine which index in the table this item exists at efficiently") } /** * @return A list iterator from the [FlowCursorList.getAll]. - * Be careful as this method will convert all data under this table into a list of [TModel] in the UI thread. + * Be careful as this method will convert all data under this table into a list of [T] in the UI thread. */ - override fun listIterator(): ListIterator { + override fun listIterator(): ListIterator { return FlowCursorIterator(this) } /** * @param location The index to start the iterator. * @return A list iterator from the [FlowCursorList.getAll]. - * Be careful as this method will convert all data under this table into a list of [TModel] in the UI thread. + * Be careful as this method will convert all data under this table into a list of [T] in the UI thread. */ - override fun listIterator(location: Int): ListIterator { + override fun listIterator(location: Int): ListIterator { return FlowCursorIterator(this, location) } override val size: Int get() = internalCursorList.count.toInt() - override fun subList(fromIndex: Int, toIndex: Int): List { + override fun subList(fromIndex: Int, toIndex: Int): List { val tableList = internalCursorList.all return tableList.subList(fromIndex, toIndex) } @@ -255,27 +253,27 @@ class FlowQueryList( internalCursorList.close() } - class Builder { + class Builder { - internal val table: Class + internal val table: Class internal var transact: Boolean = false internal var changeInTransaction: Boolean = false internal var cursor: Cursor? = null - internal var modelQueriable: ModelQueriable + internal var modelQueriable: ModelQueriable - internal constructor(cursorList: FlowCursorList) { + internal constructor(cursorList: FlowCursorList) { table = cursorList.table cursor = cursorList.cursor() modelQueriable = cursorList.modelQueriable } - constructor(table: Class) { + constructor(table: Class) { this.table = table modelQueriable = SQLite.select().from(table) } - constructor(modelQueriable: ModelQueriable) { + constructor(modelQueriable: ModelQueriable) { this.table = modelQueriable.table this.modelQueriable = modelQueriable } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/IFlowCursorIterator.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/list/IFlowCursorIterator.kt index 505ffa690..9c3d5f86d 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/IFlowCursorIterator.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/list/IFlowCursorIterator.kt @@ -18,7 +18,7 @@ interface IFlowCursorIterator : Closeable, Iterable { /** * @param position The position within the [Cursor] to retrieve and convert into a [TModel] */ - fun getItem(position: Long): TModel + operator fun get(position: Long): TModel /** * @return The cursor. @@ -35,3 +35,5 @@ interface IFlowCursorIterator : Closeable, Iterable { @Throws(IOException::class) override fun close() } + +operator fun IFlowCursorIterator.get(i: Int): TModel = this[i.toLong()] ?: throw IndexOutOfBoundsException("Could not find item at index $i from the cursor.") diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ContentResolverNotifier.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ContentResolverNotifier.kt index 4ae848c17..63889cef5 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ContentResolverNotifier.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ContentResolverNotifier.kt @@ -13,8 +13,8 @@ import com.raizlabs.android.dbflow.structure.ModelAdapter */ class ContentResolverNotifier : ModelNotifier { - override fun notifyModelChanged(model: T, adapter: ModelAdapter, - action: BaseModel.Action) { + override fun notifyModelChanged(model: T, adapter: ModelAdapter, + action: BaseModel.Action) { if (FlowContentObserver.shouldNotify()) { FlowManager.context.contentResolver .notifyChange(SqlUtils.getNotificationUri(adapter.modelClass, action, @@ -22,7 +22,7 @@ class ContentResolverNotifier : ModelNotifier { } } - override fun notifyTableChanged(table: Class, action: BaseModel.Action) { + override fun notifyTableChanged(table: Class, action: BaseModel.Action) { if (FlowContentObserver.shouldNotify()) { FlowManager.context.contentResolver .notifyChange(SqlUtils.getNotificationUri(table, action, @@ -30,9 +30,7 @@ class ContentResolverNotifier : ModelNotifier { } } - override fun newRegister(): TableNotifierRegister { - return FlowContentTableNotifierRegister() - } + override fun newRegister(): TableNotifierRegister = FlowContentTableNotifierRegister() class FlowContentTableNotifierRegister : TableNotifierRegister { @@ -40,9 +38,9 @@ class ContentResolverNotifier : ModelNotifier { private var tableChangedListener: OnTableChangedListener? = null - private val internalContentChangeListener = OnTableChangedListener { tableChanged, action -> - if (tableChangedListener != null) { - tableChangedListener!!.onTableChanged(tableChanged, action) + private val internalContentChangeListener = object : OnTableChangedListener { + override fun onTableChanged(table: Class<*>?, action: BaseModel.Action) { + tableChangedListener?.onTableChanged(table, action) } } @@ -63,12 +61,11 @@ class ContentResolverNotifier : ModelNotifier { this.tableChangedListener = null } - override fun setListener(contentChangeListener: OnTableChangedListener?) { - this.tableChangedListener = contentChangeListener + override fun setListener(listener: OnTableChangedListener?) { + this.tableChangedListener = listener } - override fun isSubscribed(): Boolean { - return !flowContentObserver.isSubscribed - } + override val isSubscribed: Boolean + get() = !flowContentObserver.isSubscribed } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DBBatchSaveQueue.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DBBatchSaveQueue.kt index 3dbcb054b..7e159395a 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DBBatchSaveQueue.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DBBatchSaveQueue.kt @@ -7,6 +7,9 @@ import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.structure.Model import com.raizlabs.android.dbflow.structure.database.transaction.ProcessModelTransaction import com.raizlabs.android.dbflow.structure.database.transaction.Transaction +import com.raizlabs.android.dbflow.structure.database.transaction.processModel +import com.raizlabs.android.dbflow.structure.database.transaction.transactionError +import com.raizlabs.android.dbflow.structure.database.transaction.transactionSuccess import java.util.* /** @@ -43,20 +46,15 @@ internal constructor(private val databaseDefinition: DatabaseDefinition) : Threa private var successListener: Transaction.Success? = null private var emptyTransactionListener: Runnable? = null - private val modelSaver = ProcessModelTransaction.ProcessModel { model, _ -> + private val modelSaver = processModel { model, _ -> (model as? Model)?.save() ?: if (model != null) { val modelClass = model.javaClass FlowManager.getModelAdapter(modelClass).save(model) } } - private val successCallback = Transaction.Success { transaction -> - successListener?.onSuccess(transaction) - } - - private val errorCallback = Transaction.Error { transaction, error -> - errorListener?.onError(transaction, error) - } + private val successCallback = transactionSuccess { transaction -> successListener?.onSuccess(transaction) } + private val errorCallback = transactionError { transaction, error -> errorListener?.onError(transaction, error) } /** * Sets how many models to save at a time in this queue. @@ -116,10 +114,9 @@ internal constructor(private val databaseDefinition: DatabaseDefinition) : Threa models.clear() } if (tmpModels.isNotEmpty()) { - databaseDefinition.beginTransactionAsync( - ProcessModelTransaction.Builder(modelSaver) - .addAll(tmpModels) - .build()) + val builder = ProcessModelTransaction.Builder(modelSaver) + tmpModels.forEach { builder.add(it) } + databaseDefinition.beginTransactionAsync(builder.build()) .success(successCallback) .error(errorCallback) .build() @@ -164,7 +161,7 @@ internal constructor(private val databaseDefinition: DatabaseDefinition) : Threa /** * Adds a [java.util.Collection] of DB objects to this queue */ - fun addAll(list: Collection) { + fun addAll(list: MutableCollection) { synchronized(models) { models.addAll(list) @@ -177,7 +174,7 @@ internal constructor(private val databaseDefinition: DatabaseDefinition) : Threa /** * Adds a [java.util.Collection] of class that extend Object to this queue */ - fun addAll2(list: Collection<*>) { + fun addAll2(list: Collection) { synchronized(models) { models.addAll(list) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/NotifyDistributor.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/NotifyDistributor.kt index e4a49371b..efd1e0889 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/NotifyDistributor.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/NotifyDistributor.kt @@ -13,9 +13,9 @@ class NotifyDistributor : ModelNotifier { throw RuntimeException("Cannot create a register from the distributor class") } - override fun notifyModelChanged(model: TModel, - adapter: ModelAdapter, - action: BaseModel.Action) { + override fun notifyModelChanged(model: T, + adapter: ModelAdapter, + action: BaseModel.Action) { FlowManager.getModelNotifierForTable(adapter.modelClass) .notifyModelChanged(model, adapter, action) } @@ -23,8 +23,8 @@ class NotifyDistributor : ModelNotifier { /** * Notifies listeners of table-level changes from the SQLite-wrapper language. */ - override fun notifyTableChanged(table: Class, - action: BaseModel.Action) { + override fun notifyTableChanged(table: Class, + action: BaseModel.Action) { FlowManager.getModelNotifierForTable(table).notifyTableChanged(table, action) } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/BaseAsyncObject.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/BaseAsyncObject.kt index f2384cb87..3787c1c50 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/BaseAsyncObject.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/BaseAsyncObject.kt @@ -4,24 +4,26 @@ import com.raizlabs.android.dbflow.config.DatabaseDefinition import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.structure.database.transaction.ITransaction import com.raizlabs.android.dbflow.structure.database.transaction.Transaction +import com.raizlabs.android.dbflow.structure.database.transaction.transactionError +import com.raizlabs.android.dbflow.structure.database.transaction.transactionSuccess /** * Description: Internal use to provide common implementation for async objects. */ -open class BaseAsyncObject(open val table: Class<*>) { +open class BaseAsyncObject(open val table: Class<*>) { private var successCallback: Transaction.Success? = null private var errorCallback: Transaction.Error? = null private var currentTransaction: Transaction? = null private val databaseDefinition: DatabaseDefinition by lazy { FlowManager.getDatabaseForTable(table) } - private val error = Transaction.Error { transaction, error -> + private val error = transactionError { transaction, error -> errorCallback?.onError(transaction, error) this@BaseAsyncObject.onError(transaction, error) currentTransaction = null } - private val success = Transaction.Success { transaction -> + private val success = transactionSuccess { transaction -> successCallback?.onSuccess(transaction) this@BaseAsyncObject.onSuccess(transaction) currentTransaction = null diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseModelQueriable.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseModelQueriable.kt index a00a8627d..7ec3dba3a 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseModelQueriable.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseModelQueriable.kt @@ -17,7 +17,7 @@ import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper * Description: Provides a base implementation of [ModelQueriable] to simplify a lot of code. It provides the * default implementation for convenience. */ -abstract class BaseModelQueriable +abstract class BaseModelQueriable /** * Constructs new instance of this class and is meant for subclasses only. * @@ -80,14 +80,14 @@ protected constructor(table: Class) override fun async(): AsyncQuery = AsyncQuery(this) - override fun queryCustomList(queryModelClass: Class): MutableList { + override fun queryCustomList(queryModelClass: Class): MutableList { val query = query FlowLog.log(FlowLog.Level.V, "Executing query: " + query) val adapter = FlowManager.getQueryModelAdapter(queryModelClass) return adapter.listModelLoader.load(query)!! } - override fun queryCustomSingle(queryModelClass: Class): QueryClass? { + override fun queryCustomSingle(queryModelClass: Class): QueryClass? { val query = query FlowLog.log(FlowLog.Level.V, "Executing query: " + query) val adapter = FlowManager.getQueryModelAdapter(queryModelClass) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseOperator.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseOperator.java deleted file mode 100644 index 2d3144f48..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseOperator.java +++ /dev/null @@ -1,269 +0,0 @@ -package com.raizlabs.android.dbflow.sql.language; - -import android.database.DatabaseUtils; -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.config.FlowManager; -import com.raizlabs.android.dbflow.converter.TypeConverter; -import com.raizlabs.android.dbflow.data.Blob; -import com.raizlabs.android.dbflow.sql.Query; -import com.raizlabs.android.dbflow.sql.QueryBuilder; -import com.raizlabs.android.dbflow.sql.SqlUtils; - -/** - * Description: Base class for all kinds of {@link SQLOperator} - */ -public abstract class BaseOperator implements SQLOperator { - - @Nullable - public static String convertValueToString(Object value, boolean appendInnerQueryParenthesis) { - return convertValueToString(value, appendInnerQueryParenthesis, true); - } - - /** - * Converts a value input into a String representation of that. - *

- * If it has a {@link TypeConverter}, it first will convert it's value into its {@link TypeConverter#getDBValue(Object)}. - *

- * If the value is a {@link Number}, we return a string rep of that. - *

- * If the value is a {@link BaseModelQueriable} and appendInnerQueryParenthesis is true, - * we return the query wrapped in "()" - *

- * If the value is a {@link NameAlias}, we return the {@link NameAlias#getQuery()} - *

- * If the value is a {@link SQLOperator}, we {@link SQLOperator#appendConditionToQuery(QueryBuilder)}. - *

- * If the value is a {@link Query}, we simply call {@link Query#getQuery()}. - *

- * If the value if a {@link Blob} or byte[] - * - * @param value The value of the column in Model format. - * @param appendInnerQueryParenthesis if its a {@link BaseModelQueriable} and an inner query value - * in a condition, we append parenthesis to the query. - * @return Returns the result as a string that's safe for SQLite. - */ - @SuppressWarnings("unchecked") - @Nullable - public static String convertValueToString(@Nullable Object value, - boolean appendInnerQueryParenthesis, - boolean typeConvert) { - if (value == null) { - return "NULL"; - } else { - String stringVal; - if (typeConvert) { - TypeConverter typeConverter = FlowManager.getTypeConverterForClass(value.getClass()); - if (typeConverter != null) { - value = typeConverter.getDBValue(value); - } - } - - if (value instanceof Number) { - stringVal = String.valueOf(value); - } else if (value instanceof Enum) { - stringVal = DatabaseUtils.sqlEscapeString(((Enum) value).name()); - } else { - if (appendInnerQueryParenthesis && value instanceof BaseModelQueriable) { - stringVal = String.format("(%1s)", ((BaseModelQueriable) value).getQuery().trim()); - } else if (value instanceof NameAlias) { - stringVal = ((NameAlias) value).getQuery(); - } else if (value instanceof SQLOperator) { - QueryBuilder queryBuilder = new QueryBuilder(); - ((SQLOperator) value).appendConditionToQuery(queryBuilder); - stringVal = queryBuilder.toString(); - } else if (value instanceof Query) { - stringVal = ((Query) value).getQuery(); - } else if (value instanceof Blob || value instanceof byte[]) { - byte[] bytes; - if (value instanceof Blob) { - bytes = ((Blob) value).getBlob(); - } else { - bytes = ((byte[]) value); - } - stringVal = "X" + DatabaseUtils.sqlEscapeString(SqlUtils.byteArrayToHexString(bytes)); - } else { - stringVal = String.valueOf(value); - if (!stringVal.equals(Operator.Operation.INSTANCE.getEMPTY_PARAM())) { - stringVal = DatabaseUtils.sqlEscapeString(stringVal); - } - } - } - - return stringVal; - } - } - - /** - * Returns a string containing the tokens joined by delimiters and converted into the property - * values for a query. - * - * @param delimiter The text to join the text with. - * @param tokens an {@link Iterable} of objects to be joined. Strings will be formed from - * the objects by calling {@link #convertValueToString(Object, boolean)}. - * @return A joined string - */ - @NonNull - public static String joinArguments(@NonNull CharSequence delimiter, - @NonNull Iterable tokens, - @NonNull BaseOperator condition) { - StringBuilder sb = new StringBuilder(); - boolean firstTime = true; - for (Object token : tokens) { - if (firstTime) { - firstTime = false; - } else { - sb.append(delimiter); - } - sb.append(condition.convertObjectToString(token, false)); - } - return sb.toString(); - } - - /** - * Returns a string containing the tokens converted into DBValues joined by delimiters. - * - * @param delimiter The text to join the text with. - * @param tokens an array objects to be joined. Strings will be formed from - * the objects by calling object.toString(). - * @return A joined string - */ - @NonNull - public static String joinArguments(@NonNull CharSequence delimiter, @NonNull Object[] tokens) { - StringBuilder sb = new StringBuilder(); - boolean firstTime = true; - for (Object token : tokens) { - if (firstTime) { - firstTime = false; - } else { - sb.append(delimiter); - } - sb.append(convertValueToString(token, false, true)); - } - return sb.toString(); - } - - /** - * Returns a string containing the tokens converted into DBValues joined by delimiters. - * - * @param delimiter The text to join the text with. - * @param tokens an array objects to be joined. Strings will be formed from - * the objects by calling object.toString(). - * @return A joined string - */ - @NonNull - public static String joinArguments(@NonNull CharSequence delimiter, @NonNull Iterable tokens) { - StringBuilder sb = new StringBuilder(); - boolean firstTime = true; - for (Object token : tokens) { - if (firstTime) { - firstTime = false; - } else { - sb.append(delimiter); - } - sb.append(convertValueToString(token, false, true)); - } - return sb.toString(); - } - - /** - * The operation such as "=", "<", and more - */ - protected String operation = ""; - - /** - * The value of the column we care about - */ - protected Object value; - - /** - * The column name - */ - @Nullable - protected NameAlias nameAlias; - - /** - * A custom SQL statement after the value of the Operator - */ - protected String postArg; - - /** - * An optional separator to use when chaining these together - */ - protected String separator; - - /** - * If true, the value is set and we should append it. (to prevent false positive nulls) - */ - protected boolean isValueSet; - - BaseOperator(@Nullable NameAlias nameAlias) { - this.nameAlias = nameAlias; - } - - /** - * @return the value of the argument - */ - @Override - public Object value() { - return value; - } - - /** - * @return the column name - */ - @NonNull - @Override - public String columnName() { - return nameAlias.getQuery(); - } - - @NonNull - @Override - public SQLOperator separator(@NonNull String separator) { - this.separator = separator; - return this; - } - - @Nullable - @Override - public String separator() { - return separator; - } - - /** - * @return true if has a separator defined for this condition. - */ - @Override - public boolean hasSeparator() { - return separator != null && (separator.length() > 0); - } - - /** - * @return the operator such as "<", ">", or "=" - */ - @NonNull - public String operation() { - return operation; - } - - /** - * @return An optional post argument for this condition - */ - public String postArgument() { - return postArg; - } - - /** - * @return internal alias used for subclasses. - */ - NameAlias columnAlias() { - return nameAlias; - } - - public String convertObjectToString(Object object, boolean appendInnerParenthesis) { - return convertValueToString(object, appendInnerParenthesis); - } - -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseOperator.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseOperator.kt new file mode 100644 index 000000000..c0ca39479 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseOperator.kt @@ -0,0 +1,230 @@ +package com.raizlabs.android.dbflow.sql.language + +import android.database.DatabaseUtils + +import com.raizlabs.android.dbflow.config.FlowManager +import com.raizlabs.android.dbflow.converter.TypeConverter +import com.raizlabs.android.dbflow.data.Blob +import com.raizlabs.android.dbflow.sql.Query +import com.raizlabs.android.dbflow.sql.QueryBuilder +import com.raizlabs.android.dbflow.sql.SqlUtils + +/** + * Description: Base class for all kinds of [SQLOperator] + */ +abstract class BaseOperator internal constructor( + /** + * The column name + */ + protected var nameAlias: NameAlias?) : SQLOperator { + + /** + * The operation such as "=", "<", and more + */ + protected var operation = "" + + /** + * The value of the column we care about + */ + protected var value: Any? = null + + /** + * A custom SQL statement after the value of the Operator + */ + protected var postArg: String? = null + + /** + * An optional separator to use when chaining these together + */ + protected var separator: String? = null + + /** + * If true, the value is set and we should append it. (to prevent false positive nulls) + */ + protected var isValueSet: Boolean = false + + /** + * @return the value of the argument + */ + override fun value(): Any? = value + + /** + * @return the column name + */ + override fun columnName(): String = nameAlias!!.query + + override fun separator(separator: String): SQLOperator { + this.separator = separator + return this + } + + override fun separator(): String? = separator + + /** + * @return true if has a separator defined for this condition. + */ + override fun hasSeparator(): Boolean = separator != null && separator!!.length > 0 + + /** + * @return the operator such as "<", ">", or "=" + */ + override fun operation(): String = operation + + /** + * @return An optional post argument for this condition + */ + fun postArgument(): String? = postArg + + /** + * @return internal alias used for subclasses. + */ + internal fun columnAlias(): NameAlias? = nameAlias + + open fun convertObjectToString(obj: Any?, appendInnerParenthesis: Boolean): String? = + convertValueToString(obj, appendInnerParenthesis) + + companion object { + + @JvmStatic + fun convertValueToString(value: Any?, appendInnerQueryParenthesis: Boolean): String? = + convertValueToString(value, appendInnerQueryParenthesis, true) + + /** + * Converts a value input into a String representation of that. + * + * + * If it has a [TypeConverter], it first will convert it's value into its [TypeConverter.getDBValue]. + * + * + * If the value is a [Number], we return a string rep of that. + * + * + * If the value is a [BaseModelQueriable] and appendInnerQueryParenthesis is true, + * we return the query wrapped in "()" + * + * + * If the value is a [NameAlias], we return the [NameAlias.getQuery] + * + * + * If the value is a [SQLOperator], we [SQLOperator.appendConditionToQuery]. + * + * + * If the value is a [Query], we simply call [Query.getQuery]. + * + * + * If the value if a [Blob] or byte[] + * + * @param value The value of the column in Model format. + * @param appendInnerQueryParenthesis if its a [BaseModelQueriable] and an inner query value + * in a condition, we append parenthesis to the query. + * @return Returns the result as a string that's safe for SQLite. + */ + @Suppress("UNCHECKED_CAST") + @JvmStatic + fun convertValueToString(value: Any?, + appendInnerQueryParenthesis: Boolean, + typeConvert: Boolean): String? { + var _value = value + if (_value == null) { + return "NULL" + } else { + var stringVal: String + if (typeConvert) { + val typeConverter: TypeConverter<*, Any?>? + = FlowManager.getTypeConverterForClass(_value.javaClass) as TypeConverter<*, Any?>? + if (typeConverter != null) { + _value = typeConverter.getDBValue(_value) + } + } + + if (_value is Number) { + stringVal = _value.toString() + } else if (_value is Enum<*>) { + stringVal = DatabaseUtils.sqlEscapeString(_value.name) + } else { + if (appendInnerQueryParenthesis && _value is BaseModelQueriable<*>) { + stringVal = String.format("(%1s)", _value.query.trim { it <= ' ' }) + } else if (_value is NameAlias) { + stringVal = _value.query + } else if (_value is SQLOperator) { + val queryBuilder = QueryBuilder() + _value.appendConditionToQuery(queryBuilder) + stringVal = queryBuilder.toString() + } else if (_value is Query) { + stringVal = _value.query + } else if (_value is Blob || _value is ByteArray) { + val bytes: ByteArray? + if (_value is Blob) { + bytes = _value.blob + } else { + bytes = _value as ByteArray? + } + stringVal = "X" + DatabaseUtils.sqlEscapeString(SqlUtils.byteArrayToHexString(bytes)) + } else { + stringVal = _value.toString() + if (stringVal != Operator.Operation.EMPTY_PARAM) { + stringVal = DatabaseUtils.sqlEscapeString(stringVal) + } + } + } + + return stringVal + } + } + + /** + * Returns a string containing the tokens joined by delimiters and converted into the property + * values for a query. + * + * @param delimiter The text to join the text with. + * @param tokens an [Iterable] of objects to be joined. Strings will be formed from + * the objects by calling [.convertValueToString]. + * @return A joined string + */ + @JvmStatic + fun joinArguments(delimiter: CharSequence, + tokens: Iterable<*>, + condition: BaseOperator): String { + val sb = StringBuilder() + var firstTime = true + for (token in tokens) { + if (firstTime) { + firstTime = false + } else { + sb.append(delimiter) + } + sb.append(condition.convertObjectToString(token, false)) + } + return sb.toString() + } + + /** + * Returns a string containing the tokens converted into DBValues joined by delimiters. + * + * @param delimiter The text to join the text with. + * @param tokens an array objects to be joined. Strings will be formed from + * the objects by calling object.toString(). + * @return A joined string + */ + @JvmStatic + fun joinArguments(delimiter: CharSequence, tokens: Array): String = + tokens.joinToString(separator = delimiter) { + convertValueToString(it, false, true) ?: "" + } + + /** + * Returns a string containing the tokens converted into DBValues joined by delimiters. + * + * @param delimiter The text to join the text with. + * @param tokens an array objects to be joined. Strings will be formed from + * the objects by calling object.toString(). + * @return A joined string + */ + @JvmStatic + fun joinArguments(delimiter: CharSequence, tokens: Iterable): String = + tokens.joinToString(separator = delimiter) { + convertValueToString(it, false, true) ?: "" + } + } + +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseQueriable.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseQueriable.kt index 6178dd259..316ff1293 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseQueriable.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseQueriable.kt @@ -15,7 +15,7 @@ import com.raizlabs.android.dbflow.structure.database.FlowCursor /** * Description: Base implementation of something that can be queried from the database. */ -abstract class BaseQueriable protected constructor( +abstract class BaseQueriable protected constructor( /** * @return The table associated with this INSERT */ diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseTransformable.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseTransformable.kt index bd73465e0..c7e8f82ac 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseTransformable.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseTransformable.kt @@ -7,7 +7,7 @@ import com.raizlabs.android.dbflow.structure.database.FlowCursor /** * Description: Combines basic transformations and query ops into a base class. */ -abstract class BaseTransformable +abstract class BaseTransformable /** * Constructs new instance of this class and is meant for subclasses only. * diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CaseCondition.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CaseCondition.kt index f45bcf491..09e0c2008 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CaseCondition.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CaseCondition.kt @@ -2,7 +2,6 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.sql.Query import com.raizlabs.android.dbflow.sql.QueryBuilder -import com.raizlabs.android.dbflow.sql.language.BaseOperator.convertValueToString import com.raizlabs.android.dbflow.sql.language.property.IProperty /** @@ -22,12 +21,12 @@ class CaseCondition : Query { get() { val queryBuilder = QueryBuilder(" WHEN ") if (caze.isEfficientCase) { - queryBuilder.append(convertValueToString(property ?: whenValue, false)) + queryBuilder.append(BaseOperator.convertValueToString(property ?: whenValue, false)) } else { sqlOperator?.appendConditionToQuery(queryBuilder) } queryBuilder.append(" THEN ") - .append(convertValueToString(if (isThenPropertySet) + .append(BaseOperator.convertValueToString(if (isThenPropertySet) thenProperty else thenValue, false)) @@ -41,7 +40,7 @@ class CaseCondition : Query { this.property = null } - internal constructor(caze: Case, whenValue: TReturn) { + internal constructor(caze: Case, whenValue: TReturn?) { this.caze = caze this.whenValue = whenValue this.sqlOperator = null diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CursorResult.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CursorResult.kt index 1e76ab716..524f4c46c 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CursorResult.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CursorResult.kt @@ -11,10 +11,10 @@ import com.raizlabs.android.dbflow.structure.database.FlowCursor * Description: A class that contains a [Cursor] and handy methods for retrieving data from it. * You must close this object post use via [.close]. */ -class CursorResult internal constructor(modelClass: Class, cursor: Cursor?) - : IFlowCursorIterator { +class CursorResult internal constructor(modelClass: Class, cursor: Cursor?) + : IFlowCursorIterator { - private val retrievalAdapter: InstanceAdapter + private val retrievalAdapter: InstanceAdapter private var cursor: FlowCursor? = null @@ -43,14 +43,14 @@ class CursorResult internal constructor(modelClass: Class, curso /** * @return A [List] of items from this object. You must call [.close] when finished. */ - fun toList(): List = cursor?.let { cursor -> + fun toList(): List = cursor?.let { cursor -> retrievalAdapter.listModelLoader.convertToData(cursor, null) } ?: arrayListOf() /** - * @return Converts the [Cursor] to a [List] of [TModel] and then closes it. + * @return Converts the [Cursor] to a [List] of [T] and then closes it. */ - fun toListClose(): List { + fun toListClose(): List { val list = retrievalAdapter.listModelLoader.load(cursor) ?: arrayListOf() close() return list @@ -59,7 +59,7 @@ class CursorResult internal constructor(modelClass: Class, curso /** * @return A [List] of items from this object. You must call [.close] when finished. */ - fun toCustomList(customClass: Class): List { + fun toCustomList(customClass: Class): List { return cursor?.let { cursor -> return@let FlowManager.getQueryModelAdapter(customClass) .listModelLoader.convertToData(cursor, null) @@ -67,50 +67,49 @@ class CursorResult internal constructor(modelClass: Class, curso } /** - * @return Converts the [Cursor] to a [List] of [TModel] and then closes it. + * @return Converts the [Cursor] to a [List] of [T] and then closes it. */ - fun toCustomListClose(customClass: Class): List { + fun toCustomListClose(customClass: Class): List { val customList = FlowManager.getQueryModelAdapter(customClass).listModelLoader.load(cursor) ?: arrayListOf() close() return customList } /** - * @return The first [TModel] of items from the contained [Cursor]. You must call [.close] when finished. + * @return The first [T] of items from the contained [Cursor]. You must call [.close] when finished. */ - fun toModel(): TModel? = cursor?.let { cursor -> retrievalAdapter.singleModelLoader.convertToData(cursor, null) } + fun toModel(): T? = cursor?.let { cursor -> retrievalAdapter.singleModelLoader.convertToData(cursor, null) } /** - * @return Converts the [Cursor] into the first [TModel] from the cursor and then closes it. + * @return Converts the [Cursor] into the first [T] from the cursor and then closes it. */ - fun toModelClose(): TModel? { + fun toModelClose(): T? { val model = retrievalAdapter.singleModelLoader.load(cursor) close() return model } /** - * @return The first [TModel] of items from the contained [Cursor]. You must call [.close] when finished. + * @return The first [T] of items from the contained [Cursor]. You must call [.close] when finished. */ - fun toCustomModel(customClass: Class): TCustom? { + fun toCustomModel(customClass: Class): TCustom? { return if (cursor != null) FlowManager.getQueryModelAdapter(customClass) .singleModelLoader.convertToData(cursor!!, null) - else - null + else null } /** - * @return Converts the [Cursor] to a [TModel] and then closes it. + * @return Converts the [Cursor] to a [T] and then closes it. */ - fun toCustomModelClose(customClass: Class): TCustom? { + fun toCustomModelClose(customClass: Class): TCustom? { val customList = FlowManager.getQueryModelAdapter(customClass).singleModelLoader.load(cursor) close() return customList } - override fun getItem(position: Long): TModel { - var model: TModel? = null + override fun get(position: Long): T { + var model: T? = null cursor?.let { cursor -> if (cursor.moveToPosition(position.toInt())) { model = retrievalAdapter.singleModelLoader.convertToData(cursor, null, false) @@ -119,9 +118,9 @@ class CursorResult internal constructor(modelClass: Class, curso return model!! } - override fun iterator(): FlowCursorIterator = FlowCursorIterator(this) + override fun iterator(): FlowCursorIterator = FlowCursorIterator(this) - override fun iterator(startingLocation: Int, limit: Long): FlowCursorIterator = + override fun iterator(startingLocation: Int, limit: Long): FlowCursorIterator = FlowCursorIterator(this, startingLocation, limit) override fun cursor(): Cursor? = cursor @@ -130,3 +129,11 @@ class CursorResult internal constructor(modelClass: Class, curso cursor?.close() } } + +inline fun CursorResult<*>.toCustomList() = toCustomList(T::class.java) + +inline fun CursorResult<*>.toCustomListClose() = toCustomListClose(T::class.java) + +inline fun CursorResult<*>.toCustomModel() = toCustomModel(T::class.java) + +inline fun CursorResult<*>.toCustomModelClose() = toCustomModelClose(T::class.java) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Delete.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Delete.kt index ffc59cea6..c74ea081b 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Delete.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Delete.kt @@ -17,10 +17,10 @@ class Delete : Query { * Returns the new SQL FROM statement wrapper * * @param table The table we want to run this query from - * @param The table class - * @return + * @param [T] The table class + * @return [T] **/ - fun from(table: Class): From = From(this, table) + fun from(table: Class): From = From(this, table) companion object { @@ -29,9 +29,9 @@ class Delete : Query { * * @param table The table to delete * @param conditions The list of conditions to use to delete from the specified table - * @param The class that implements [com.raizlabs.android.dbflow.structure.Model] - */ - fun table(table: Class, vararg conditions: SQLOperator) { + * @param [T] The class that implements [com.raizlabs.android.dbflow.structure.Model] + */ + fun table(table: Class, vararg conditions: SQLOperator) { Delete().from(table).where(*conditions).executeUpdateDelete() } @@ -46,3 +46,9 @@ class Delete : Query { } } } + + +inline fun delete() = SQLite.delete(T::class.java) + +inline fun delete(deleteClause: From.() -> BaseModelQueriable) + = deleteClause(SQLite.delete(T::class.java)) \ No newline at end of file diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/From.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/From.kt index dd3206eeb..93eb7585d 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/From.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/From.kt @@ -13,7 +13,7 @@ import kotlin.collections.Set as KSet /** * Description: The SQL FROM query wrapper that must have a [Query] base. */ -class From +class From /** * The SQL from statement constructed. * @@ -101,7 +101,7 @@ class From * @param table The table this corresponds to * @param joinType The type of join to use */ - fun join(table: Class, joinType: JoinType): Join { + fun join(table: Class, joinType: JoinType): Join { val join = Join(this, table, joinType) joins.add(join) return join @@ -113,7 +113,7 @@ class From * @param modelQueriable A query we construct the [Join] from. * @param joinType The type of join to use. */ - fun join(modelQueriable: ModelQueriable, joinType: JoinType): Join { + fun join(modelQueriable: ModelQueriable, joinType: JoinType): Join { val join = Join(this, joinType, modelQueriable) joins.add(join) return join @@ -125,7 +125,7 @@ class From * @param table The table to join on. * @param The class of the join table. */ - fun crossJoin(table: Class): Join = join(table, JoinType.CROSS) + fun crossJoin(table: Class): Join = join(table, JoinType.CROSS) /** * Adds a [JoinType.CROSS] join on a specific table for this query. @@ -133,7 +133,7 @@ class From * @param modelQueriable The query to join on. * @param The class of the join table. */ - fun crossJoin(modelQueriable: ModelQueriable): Join = + fun crossJoin(modelQueriable: ModelQueriable): Join = join(modelQueriable, JoinType.CROSS) /** @@ -142,7 +142,7 @@ class From * @param table The table to join on. * @param The class of the join table. */ - fun innerJoin(table: Class): Join = join(table, JoinType.INNER) + fun innerJoin(table: Class): Join = join(table, JoinType.INNER) /** * Adds a [JoinType.INNER] join on a specific table for this query. @@ -150,7 +150,7 @@ class From * @param modelQueriable The query to join on. * @param The class of the join table. */ - fun innerJoin(modelQueriable: ModelQueriable): Join = + fun innerJoin(modelQueriable: ModelQueriable): Join = join(modelQueriable, JoinType.INNER) /** @@ -159,7 +159,7 @@ class From * @param table The table to join on. * @param The class of the join table. */ - fun leftOuterJoin(table: Class): Join = + fun leftOuterJoin(table: Class): Join = join(table, JoinType.LEFT_OUTER) /** @@ -168,7 +168,7 @@ class From * @param modelQueriable The query to join on. * @param The class of the join table. */ - fun leftOuterJoin(modelQueriable: ModelQueriable): Join = + fun leftOuterJoin(modelQueriable: ModelQueriable): Join = join(modelQueriable, JoinType.LEFT_OUTER) @@ -178,7 +178,7 @@ class From * @param table The table to join on. * @param The class of the join table. */ - fun naturalJoin(table: Class): Join = + fun naturalJoin(table: Class): Join = join(table, JoinType.NATURAL) /** @@ -187,7 +187,7 @@ class From * @param modelQueriable The query to join on. * @param The class of the join table. */ - fun naturalJoin(modelQueriable: ModelQueriable): Join = + fun naturalJoin(modelQueriable: ModelQueriable): Join = join(modelQueriable, JoinType.NATURAL) /** diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IConditional.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IConditional.kt index af8ee9131..5b4132f32 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IConditional.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IConditional.kt @@ -88,3 +88,74 @@ interface IConditional : Query { operator fun rem(value: BaseModelQueriable<*>): Operator<*> } + +infix fun IConditional.eq(value: IConditional): Operator<*> = this.eq(value) + +infix fun IConditional.`is`(conditional: IConditional): Operator<*> = this.`is`(conditional) + +infix fun IConditional.isNot(conditional: IConditional): Operator<*> = this.isNot(conditional) + +infix fun IConditional.notEq(conditional: IConditional): Operator<*> = this.notEq(conditional) + +infix fun IConditional.like(conditional: IConditional): Operator<*> = this.like(conditional) + +infix fun IConditional.glob(conditional: IConditional): Operator<*> = this.glob(conditional) + +infix fun IConditional.like(value: String): Operator<*> = this.like(value) + +infix fun IConditional.glob(value: String): Operator<*> = this.glob(value) + +infix fun IConditional.greaterThan(conditional: IConditional): Operator<*> = this.greaterThan(conditional) + +infix fun IConditional.greaterThanOrEq(conditional: IConditional): Operator<*> = this.greaterThanOrEq(conditional) + +infix fun IConditional.lessThan(conditional: IConditional): Operator<*> = this.lessThan(conditional) + +infix fun IConditional.lessThanOrEq(conditional: IConditional): Operator<*> = this.lessThanOrEq(conditional) + +infix fun IConditional.between(conditional: IConditional): Operator.Between<*> = this.between(conditional) + +infix fun IConditional.`in`(values: Array): Operator.In<*> { + return when (values.size) { + 1 -> `in`(values[0]) + else -> this.`in`(values[0], *values.sliceArray(IntRange(1, values.size))) + } +} + +infix fun IConditional.notIn(values: Array): Operator.In<*> { + return when (values.size) { + 1 -> notIn(values[0]) + else -> this.notIn(values[0], *values.sliceArray(IntRange(1, values.size))) + } +} + +infix fun IConditional.`is`(baseModelQueriable: BaseModelQueriable): Operator<*> = this.`is`(baseModelQueriable) + +infix fun IConditional.eq(baseModelQueriable: BaseModelQueriable): Operator<*> = this.eq(baseModelQueriable) + +infix fun IConditional.isNot(baseModelQueriable: BaseModelQueriable): Operator<*> = this.isNot(baseModelQueriable) +infix fun IConditional.notEq(baseModelQueriable: BaseModelQueriable): Operator<*> = this.notEq(baseModelQueriable) +infix fun IConditional.like(baseModelQueriable: BaseModelQueriable): Operator<*> = this.like(baseModelQueriable) +infix fun IConditional.glob(baseModelQueriable: BaseModelQueriable): Operator<*> = this.glob(baseModelQueriable) +infix fun IConditional.greaterThan(baseModelQueriable: BaseModelQueriable): Operator<*> = this.greaterThan(baseModelQueriable) +infix fun IConditional.greaterThanOrEq(baseModelQueriable: BaseModelQueriable): Operator<*> = this.greaterThanOrEq(baseModelQueriable) +infix fun IConditional.lessThan(baseModelQueriable: BaseModelQueriable): Operator<*> = this.lessThan(baseModelQueriable) +infix fun IConditional.lessThanOrEq(baseModelQueriable: BaseModelQueriable): Operator<*> = this.lessThanOrEq(baseModelQueriable) +infix fun IConditional.between(baseModelQueriable: BaseModelQueriable): Operator.Between<*> = this.between(baseModelQueriable) + +infix fun IConditional.`in`(values: Array>): Operator.In<*> { + return when (values.size) { + 1 -> `in`(values[0]) + else -> this.`in`(values[0], *values.sliceArray(IntRange(1, values.size))) + } +} + +infix fun IConditional.notIn(values: Array>): Operator.In<*> { + return when (values.size) { + 1 -> notIn(values[0]) + else -> this.notIn(values[0], *values.sliceArray(IntRange(1, values.size))) + } +} + +infix fun IConditional.concatenate(conditional: IConditional): Operator<*> = this.concatenate(conditional) + diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IOperator.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IOperator.kt index 66baa9e8b..f9ba41c38 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IOperator.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IOperator.kt @@ -31,7 +31,7 @@ interface IOperator : Query, IConditional { * @param value The value to concatenate. * @return A [<] that represents concatenation. */ - fun concatenate(value: T?): Operator + fun concatenate(value: Any?): Operator /** * Assigns the operation to "!=" diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IndexedBy.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IndexedBy.kt index c4dd231aa..ae63ead29 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IndexedBy.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IndexedBy.kt @@ -8,7 +8,7 @@ import com.raizlabs.android.dbflow.structure.BaseModel /** * Description: The INDEXED BY part of a SELECT/UPDATE/DELETE */ -class IndexedBy +class IndexedBy /** * Creates the INDEXED BY part of the clause. * diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Insert.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Insert.kt index bd4e786c0..7d15b6faf 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Insert.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Insert.kt @@ -8,11 +8,12 @@ import com.raizlabs.android.dbflow.sql.QueryBuilder import com.raizlabs.android.dbflow.sql.language.property.IProperty import com.raizlabs.android.dbflow.structure.BaseModel import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import kotlin.reflect.KClass /** * Description: The SQLite INSERT command */ -class Insert +class Insert /** * Constructs a new INSERT command * @@ -76,7 +77,7 @@ class Insert if (i > 0) { queryBuilder.append(",(") } - queryBuilder.append(BaseOperator.joinArguments(", ", valuesList[i])).append(")") + queryBuilder.append(BaseOperator.joinArguments(", ", valuesList)).append(")") } } @@ -270,3 +271,30 @@ class Insert throw IllegalStateException("Cannot call executeUpdateDelete() from an Insert") } } + +fun insert(modelClass: KClass) = SQLite.insert(modelClass.java) + +infix fun Insert.orReplace(into: Array, *>>) = orReplace().columnValues(*into) + +infix fun Insert.orRollback(into: Array, *>>) = orRollback().columnValues(*into) + +infix fun Insert.orAbort(into: Array, *>>) = orAbort().columnValues(*into) + +infix fun Insert.orFail(into: Array, *>>) = orFail().columnValues(*into) + +infix fun Insert.orIgnore(into: Array, *>>) = orIgnore().columnValues(*into) + +infix fun Insert.select(from: From<*>): Insert = select(from) + +fun columnValues(vararg pairs: Pair, *>): Array, *>> = pairs + +fun Insert.columnValues(vararg pairs: Pair, *>): Insert { + val columns: MutableList> = java.util.ArrayList() + val values = java.util.ArrayList() + pairs.forEach { + columns.add(it.first) + values.add(it.second) + } + this.columns(columns).values(values) + return this +} \ No newline at end of file diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Join.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Join.kt index aec3e7c65..bb6c3c2a2 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Join.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Join.kt @@ -7,11 +7,12 @@ import com.raizlabs.android.dbflow.sql.language.property.IProperty import com.raizlabs.android.dbflow.sql.language.property.PropertyFactory import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable import java.util.* +import kotlin.reflect.KClass /** * Description: Specifies a SQLite JOIN statement */ -class Join : Query { +class Join : Query { val table: Class @@ -170,3 +171,15 @@ class Join : Query { } } } + +infix fun From.innerJoin(joinTable: KClass): Join = join(joinTable.java, Join.JoinType.INNER) + +infix fun From.crossJoin(joinTable: KClass): Join = join(joinTable.java, Join.JoinType.CROSS) + +infix fun From.leftOuterJoin(joinTable: KClass): Join = join(joinTable.java, Join.JoinType.LEFT_OUTER) + +infix fun From.naturalJoin(joinTable: KClass): Join = join(joinTable.java, Join.JoinType.NATURAL) + +infix fun Join.on(sqlOperator: SQLOperator): From = on(sqlOperator) + +infix fun Join.using(property: IProperty<*>): From = using(property) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/NameAlias.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/NameAlias.kt index 4184178d8..71ce94491 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/NameAlias.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/NameAlias.kt @@ -238,3 +238,8 @@ class NameAlias(private val name: String, NameAlias.builder(name).withTable(tableName).build() } } + +val String.nameAlias + get() = NameAlias.of(this) + +fun String.`as`(alias: String = "") = NameAlias.of(this, alias) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Operator.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Operator.kt index 2999cdafb..11f0a79d6 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Operator.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Operator.kt @@ -1,3 +1,5 @@ +@file:Suppress("UNCHECKED_CAST") + package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.annotation.Collate @@ -16,7 +18,7 @@ import java.util.* */ class Operator : BaseOperator, IOperator { - private var typeConverter: TypeConverter<*, *>? = null + private var typeConverter: TypeConverter<*, Any?>? = null private var convertToDB: Boolean = false override val query: String @@ -29,11 +31,11 @@ class Operator : BaseOperator, IOperator { /** * Creates a new instance * - * @param nameAlias The name of the column in the DB + * @param [nameAlias] The name of the column in the DB */ internal constructor(nameAlias: NameAlias) : super(nameAlias) - internal constructor(alias: NameAlias, typeConverter: TypeConverter<*, *>, convertToDB: Boolean) : super(alias) { + internal constructor(alias: NameAlias, typeConverter: TypeConverter<*, Any?>, convertToDB: Boolean) : super(alias) { this.typeConverter = typeConverter this.convertToDB = convertToDB } @@ -245,17 +247,17 @@ class Operator : BaseOperator, IOperator { override fun lessThanOrEq(conditional: IConditional): Operator = assignValueOp(conditional, Operation.LESS_THAN_OR_EQUALS) - override fun between(conditional: IConditional): Between<*> = Between(this, conditional) + override fun between(conditional: IConditional): Between<*> = Between(this as Operator, conditional) override fun `in`(firstConditional: IConditional, vararg conditionals: IConditional): In<*> = - In(this, firstConditional, true, *conditionals) + In(this as Operator, firstConditional, true, *conditionals) override fun notIn(firstConditional: IConditional, vararg conditionals: IConditional): In<*> = - In(this, firstConditional, false, *conditionals) + In(this as Operator, firstConditional, false, *conditionals) override fun notIn(firstBaseModelQueriable: BaseModelQueriable<*>, vararg baseModelQueriables: BaseModelQueriable<*>): In<*> = - In(this, firstBaseModelQueriable, false, *baseModelQueriables) + In(this as Operator, firstBaseModelQueriable, false, *baseModelQueriables) override fun `is`(baseModelQueriable: BaseModelQueriable<*>): Operator<*> = assignValueOp(baseModelQueriable, Operation.EQUALS) @@ -319,18 +321,18 @@ class Operator : BaseOperator, IOperator { assignValueOp(value, Operation.MOD) override fun between(baseModelQueriable: BaseModelQueriable<*>): Between<*> = - Between(this, baseModelQueriable) + Between(this as Operator, baseModelQueriable) override fun `in`(firstBaseModelQueriable: BaseModelQueriable<*>, vararg baseModelQueriables: BaseModelQueriable<*>): In<*> = - In>(this, firstBaseModelQueriable, true, *baseModelQueriables) + In(this as Operator, firstBaseModelQueriable, true, *baseModelQueriables) - override fun concatenate(value: T?): Operator { + override fun concatenate(value: Any?): Operator { var _value = value operation = QueryBuilder(Operation.EQUALS).append(columnName()).toString() - var typeConverter: TypeConverter<*, *>? = this.typeConverter + var typeConverter: TypeConverter<*, Any?>? = this.typeConverter if (typeConverter == null && _value != null) { - typeConverter = FlowManager.getTypeConverterForClass(_value.javaClass) + typeConverter = FlowManager.getTypeConverterForClass(_value.javaClass) as TypeConverter<*, Any?>? } if (typeConverter != null && convertToDB) { _value = typeConverter.getDBValue(_value) @@ -339,7 +341,7 @@ class Operator : BaseOperator, IOperator { is String, is IOperator<*>, is Char -> "$operation ${Operation.CONCATENATE} " is Number -> "$operation ${Operation.PLUS} " else -> throw IllegalArgumentException( - "Cannot concatenate the ${if (_value != null) _value.javaClass else "null"}" + "Cannot concatenate the ${if (_value != null) _value.javaClass else "null"}") } this.value = _value isValueSet = true @@ -369,21 +371,18 @@ class Operator : BaseOperator, IOperator { override fun notIn(values: Collection): In = In(this, values, false) - override fun convertObjectToString(`object`: Any?, appendInnerParenthesis: Boolean): String? { - if (typeConverter != null) { - var converted = `object` - try { - converted = if (convertToDB) typeConverter!!.getDBValue(`object`) else `object` - } catch (c: ClassCastException) { - // if object type is not valid converted type, just use type as is here. - FlowLog.log(FlowLog.Level.W, c) - } + override fun convertObjectToString(obj: Any?, appendInnerParenthesis: Boolean): String? = + typeConverter?.let { typeConverter -> + var converted = obj + try { + converted = if (convertToDB) typeConverter.getDBValue(obj) else obj + } catch (c: ClassCastException) { + // if object type is not valid converted type, just use type as is here. + FlowLog.log(FlowLog.Level.W, throwable = c) + } - return BaseOperator.convertValueToString(converted, appendInnerParenthesis, false) - } else { - return super.convertObjectToString(`object`, appendInnerParenthesis) - } - } + BaseOperator.convertValueToString(converted, appendInnerParenthesis, false) + } ?: super.convertObjectToString(obj, appendInnerParenthesis) private fun assignValueOp(value: Any?, operation: String): Operator { this.operation = operation @@ -614,13 +613,38 @@ class Operator : BaseOperator, IOperator { companion object { - fun convertValueToString(value: Any): String? = + @JvmStatic + fun convertValueToString(value: Any?): String? = BaseOperator.convertValueToString(value, false) + @JvmStatic fun op(column: NameAlias): Operator = Operator(column) - fun op(alias: NameAlias, typeConverter: TypeConverter<*, *>, convertToDB: Boolean): Operator = + @JvmStatic + fun op(alias: NameAlias, typeConverter: TypeConverter<*, Any?>, convertToDB: Boolean): Operator = Operator(alias, typeConverter, convertToDB) } } + +fun NameAlias.op() = Operator.op(this) + +fun String.op(): Operator = nameAlias.op() + +infix fun Operator.collate(collation: Collate) = collate(collation) + +infix fun Operator.collate(collation: String) = collate(collation) + +infix fun Operator.postfix(collation: String) = postfix(collation) + +infix fun Operator.Between.and(value: T?) = and(value) + +infix fun Operator.In.and(value: T?) = and(value) + +infix fun Operator.and(sqlOperator: SQLOperator) = OperatorGroup.clause(this).and(sqlOperator) + +infix fun Operator.or(sqlOperator: SQLOperator) = OperatorGroup.clause(this).or(sqlOperator) + +infix fun Operator.andAll(sqlOperator: Collection) = OperatorGroup.clause(this).andAll(sqlOperator) + +infix fun Operator.orAll(sqlOperator: Collection) = OperatorGroup.clause(this).orAll(sqlOperator) \ No newline at end of file diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/OperatorGroup.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/OperatorGroup.kt index 79545ef9c..39708436a 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/OperatorGroup.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/OperatorGroup.kt @@ -190,3 +190,13 @@ constructor(columnName: NameAlias? = null) : BaseOperator(columnName), Query, It OperatorGroup().setUseParenthesis(false).andAll(*condition) } } + +fun SQLOperator.clause() = OperatorGroup.clause(this) + +infix fun OperatorGroup.and(sqlOperator: SQLOperator) = and(sqlOperator) + +infix fun OperatorGroup.or(sqlOperator: SQLOperator) = or(sqlOperator) + +infix fun OperatorGroup.and(sqlOperator: OperatorGroup) = clause().and(sqlOperator) + +infix fun OperatorGroup.or(sqlOperator: OperatorGroup) = clause().or(sqlOperator) \ No newline at end of file diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/OrderBy.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/OrderBy.kt index 39084905e..479150e7a 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/OrderBy.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/OrderBy.kt @@ -71,3 +71,5 @@ constructor(private val column: NameAlias? = null, fun fromString(orderByString: String): OrderBy = OrderBy(orderByString) } } + +infix fun OrderBy.collate(collate: Collate) = collate(collate) \ No newline at end of file diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/QueryExtensions.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/QueryExtensions.kt new file mode 100644 index 000000000..d6c04b47a --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/QueryExtensions.kt @@ -0,0 +1,55 @@ +package com.raizlabs.android.dbflow.sql.language + +import com.raizlabs.android.dbflow.sql.language.property.IProperty +import kotlin.reflect.KClass + +/** + * Description: A file containing extensions for adding query syntactic sugar. + */ + +inline val select: Select + get() = SQLite.select() + +inline fun Select.from() = from(T::class.java) + +fun delete(modelClass: KClass) = SQLite.delete(modelClass.java) + +infix fun Select.from(modelClass: KClass) = from(modelClass.java) + +infix fun From.whereExists(where: Where) = where().exists(where) + +infix fun From.where(sqlOperator: SQLOperator) = where(sqlOperator) + +infix fun From.`as`(alias: String) = `as`(alias) + +infix fun Set.where(sqlOperator: SQLOperator) = where(sqlOperator) + +infix fun Where.and(sqlOperator: SQLOperator) = and(sqlOperator) + +infix fun Where.or(sqlOperator: SQLOperator) = or(sqlOperator) + +infix fun Case.`when`(sqlOperator: SQLOperator) = `when`(sqlOperator) + +infix fun Case.`when`(property: IProperty<*>) = `when`(property) + +infix fun Case.`when`(value: T?) = `when`(value) + +infix fun CaseCondition.then(value: T?) = then(value) + +infix fun CaseCondition.then(property: IProperty<*>) = then(property) + +infix fun Case.`else`(value: T?) = _else(value) + +infix fun Case.end(columnName: String) = end(columnName) + +fun case(caseColumn: IProperty<*>) = SQLite._case(caseColumn) + +fun caseWhen(operator: SQLOperator) = SQLite.caseWhen(operator) + +inline fun insert() = Insert(T::class.java) + +inline fun indexOn(indexName: String, vararg property: IProperty<*>) = Index(indexName).on(T::class.java, *property) + +inline fun indexOn(indexName: String, firstNameAlias: NameAlias, vararg arrayOfNameAlias: NameAlias) = Index(indexName).on(T::class.java, firstNameAlias, *arrayOfNameAlias) + + diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/SQLite.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/SQLite.kt index 66595f06f..c13562c49 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/SQLite.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/SQLite.kt @@ -28,19 +28,19 @@ object SQLite { /** * @param table The tablet to update. - * @param The class that implements [Model]. + * @param [T] The class that implements [Model]. * @return A new UPDATE statement. */ @JvmStatic - fun update(table: Class): Update = Update(table) + fun update(table: Class): Update = Update(table) /** * @param table The table to insert. - * @param The class that implements [Model]. + * @param [T] The class that implements [Model]. * @return A new INSERT statement. */ @JvmStatic - fun insert(table: Class): Insert = Insert(table) + fun insert(table: Class): Insert = Insert(table) /** * @return Begins a DELETE statement. @@ -52,21 +52,21 @@ object SQLite { * Starts a DELETE statement on the specified table. * * @param table The table to delete from. - * @param The class that implements [Model]. + * @param [T] The class that implements [Model]. * @return A [From] with specified DELETE on table. */ @JvmStatic - fun delete(table: Class): From = delete().from(table) + fun delete(table: Class): From = delete().from(table) /** * Starts an INDEX statement on specified table. * * @param name The name of the index. - * @param The class that implements [Model]. + * @param [T] The class that implements [Model]. * @return A new INDEX statement. */ @JvmStatic - fun index(name: String): Index = Index(name) + fun index(name: String): Index = Index(name) /** * Starts a TRIGGER statement. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Select.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Select.kt index 00032c323..672c4f30a 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Select.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Select.kt @@ -52,10 +52,10 @@ class Select * Passes this statement to the [From] * * @param table The model table to run this query on - * @param The class that implements [com.raizlabs.android.dbflow.structure.Model] + * @param [T] The class that implements [com.raizlabs.android.dbflow.structure.Model] * @return the From part of this query - */ - fun from(table: Class): From = From(this, table) + */ + fun from(table: Class): From = From(this, table) /** * appends [.DISTINCT] to the query diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Set.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Set.kt index 9746cf3cf..f2147d4c5 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Set.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Set.kt @@ -10,8 +10,8 @@ import com.raizlabs.android.dbflow.structure.BaseModel /** * Description: Used to specify the SET part of an [com.raizlabs.android.dbflow.sql.language.Update] query. */ -class Set(override val queryBuilderBase: Query, table: Class) - : BaseTransformable(table), WhereBase { +class Set(override val queryBuilderBase: Query, table: Class) + : BaseTransformable(table), WhereBase { private val operatorGroup: OperatorGroup = OperatorGroup.nonGroupingClause().setAllCommaSeparated(true) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Transformable.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Transformable.kt index 56faf88e7..0252f7cc0 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Transformable.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Transformable.kt @@ -6,7 +6,7 @@ import com.raizlabs.android.dbflow.sql.language.property.IProperty * Description: Provides a standard set of methods for ending a SQLite query method. These include * groupby, orderby, having, limit and offset. */ -interface Transformable { +interface Transformable { fun groupBy(vararg nameAliases: NameAlias): Where @@ -26,3 +26,16 @@ interface Transformable { fun orderByAll(orderBies: List): Where } + + +infix fun Transformable.groupBy(nameAlias: NameAlias): Where = groupBy(nameAlias) + +infix fun Transformable.groupBy(property: IProperty<*>): Where = groupBy(property) + +infix fun Transformable.orderBy(orderBy: OrderBy): Where = orderBy(orderBy) + +infix fun Transformable.limit(limit: Int): Where = limit(limit) + +infix fun Transformable.offset(offset: Int): Where = offset(offset) + +infix fun Transformable.having(sqlOperator: SQLOperator): Where = having(sqlOperator) \ No newline at end of file diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Trigger.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Trigger.kt index 6bb398386..86ed12fe9 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Trigger.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Trigger.kt @@ -3,6 +3,7 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.sql.Query import com.raizlabs.android.dbflow.sql.QueryBuilder import com.raizlabs.android.dbflow.sql.language.property.IProperty +import kotlin.reflect.KClass /** * Description: Describes an easy way to create a SQLite TRIGGER @@ -125,3 +126,15 @@ private constructor( fun create(triggerName: String) = Trigger(triggerName) } } + +fun createTrigger(name: String) = Trigger.create(name) + +infix fun Trigger.deleteOn(kClass: KClass) = deleteOn(kClass.java) + +infix fun Trigger.insertOn(kClass: KClass) = insertOn(kClass.java) + +infix fun Trigger.updateOn(kClass: KClass) = updateOn(kClass.java) + +infix fun TriggerMethod.begin(triggerStatement: Query) = begin(triggerStatement) + +infix fun CompletedTrigger.and(nextStatement: Query) = and(nextStatement) \ No newline at end of file diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/TriggerMethod.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/TriggerMethod.kt index 3dd72ee05..282fb70aa 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/TriggerMethod.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/TriggerMethod.kt @@ -9,8 +9,8 @@ import com.raizlabs.android.dbflow.sql.language.property.IProperty * Description: Describes the method that the trigger uses. */ class TriggerMethod -internal constructor(private val trigger: Trigger, private val methodName: String, - private var onTable: Class, vararg properties: IProperty<*>) : Query { +internal constructor(internal val trigger: Trigger, private val methodName: String, + internal var onTable: Class, vararg properties: IProperty<*>) : Query { private var properties: List> = arrayListOf() private var forEachRow = false private var whenCondition: SQLOperator? = null diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Update.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Update.kt index 516d10f52..cbd5a812f 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Update.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Update.kt @@ -8,13 +8,13 @@ import com.raizlabs.android.dbflow.sql.QueryBuilder /** * Description: The SQLite UPDATE query. Will update rows in the DB. */ -class Update +class Update /** * Constructs new instace of an UPDATE query with the specified table. * * @param table The table to use. */ -internal constructor(val table: Class) : Query { +internal constructor(val table: Class) : Query { /** * The conflict action to resolve updates. @@ -75,5 +75,10 @@ internal constructor(val table: Class) : Query { * @param conditions The array of conditions that define this SET statement * @return A SET query piece of this statement */ - fun set(vararg conditions: SQLOperator): Set = Set(this, table).conditions(*conditions) + fun set(vararg conditions: SQLOperator): Set = Set(this, table).conditions(*conditions) } + + +inline fun update() = SQLite.update(T::class.java) + +infix fun Update.set(sqlOperator: SQLOperator) = set(sqlOperator) \ No newline at end of file diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Where.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Where.kt index 9e8872183..4da3a24ba 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Where.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Where.kt @@ -14,7 +14,7 @@ import java.util.* /** * Description: Defines the SQL WHERE statement of the query. */ -class Where +class Where /** * Constructs this class with the specified [com.raizlabs.android.dbflow.config.FlowManager] * and [From] chunk @@ -25,8 +25,8 @@ class Where /** * The first chunk of the SQL statement before this query. */ - val whereBase: WhereBase, vararg conditions: SQLOperator) - : BaseModelQueriable(whereBase.table), ModelQueriable, Transformable { + val whereBase: WhereBase, vararg conditions: SQLOperator) + : BaseModelQueriable(whereBase.table), ModelQueriable, Transformable { /** * Helps to build the where statement easily @@ -169,22 +169,22 @@ class Where override fun query(): FlowCursor? = query(FlowManager.getDatabaseForTable(table).writableDatabase) /** - * Queries for all of the results this statement returns from a DB cursor in the form of the [TModel] + * Queries for all of the results this statement returns from a DB cursor in the form of the [T] * - * @return All of the entries in the DB converted into [TModel] + * @return All of the entries in the DB converted into [T] */ - override fun queryList(): MutableList { + override fun queryList(): MutableList { checkSelect("query") return super.queryList() } /** - * Queries and returns only the first [TModel] result from the DB. Will enforce a limit of 1 item + * Queries and returns only the first [T] result from the DB. Will enforce a limit of 1 item * returned from the database. * * @return The first result of this query. Note: this query forces a limit of 1 from the database. */ - override fun querySingle(): TModel? { + override fun querySingle(): T? { checkSelect("query") limit(1) return super.querySingle() diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/Property.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/Property.kt index 89fc03863..13c8b6140 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/Property.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/Property.kt @@ -6,7 +6,6 @@ import com.raizlabs.android.dbflow.sql.language.IConditional import com.raizlabs.android.dbflow.sql.language.IOperator import com.raizlabs.android.dbflow.sql.language.NameAlias import com.raizlabs.android.dbflow.sql.language.Operator -import com.raizlabs.android.dbflow.sql.language.Operator.op import com.raizlabs.android.dbflow.sql.language.OrderBy /** @@ -42,7 +41,7 @@ open class Property : IProperty>, IConditional, IOperator { .build() protected open val operator: Operator - get() = op(nameAlias) + get() = Operator.op(nameAlias) constructor(table: Class<*>?, nameAlias: NameAlias) { this.table = table @@ -251,7 +250,7 @@ open class Property : IProperty>, IConditional, IOperator { override fun notIn(values: Collection): Operator.In = operator.notIn(values) - override fun concatenate(value: T?): Operator = operator.concatenate(value) + override fun concatenate(value: Any?): Operator = operator.concatenate(value) override fun plus(value: T): Operator = operator.plus(value) @@ -281,3 +280,46 @@ open class Property : IProperty>, IConditional, IOperator { } } } + + +infix fun Property.eq(value: T?) = this.eq(value) + +infix fun Property.`is`(value: T?) = this.`is`(value) + +infix fun Property.isNot(value: T?) = this.isNot(value) + +infix fun Property.notEq(value: T?) = this.notEq(value) + +infix fun Property.like(value: String) = this.like(value) + +infix fun Property.glob(value: String) = this.glob(value) + +infix fun Property.greaterThan(value: T) = this.greaterThan(value) + +infix fun Property.greaterThanOrEq(value: T) = this.greaterThanOrEq(value) + +infix fun Property.lessThan(value: T) = this.lessThan(value) + +infix fun Property.lessThanOrEq(value: T) = this.lessThanOrEq(value) + +infix fun Property.between(value: T) = this.between(value) + +infix fun Property.`in`(values: Array): Operator.In { + return when (values.size) { + 1 -> `in`(values[0]) + else -> this.`in`(values[0], *values.sliceArray(IntRange(1, values.size))) + } +} + +infix fun Property.notIn(values: Array): Operator.In { + return when (values.size) { + 1 -> notIn(values[0]) + else -> this.notIn(values[0], *values.sliceArray(IntRange(1, values.size))) + } +} + +infix fun Property.`in`(values: Collection) = this.`in`(values) + +infix fun Property.notIn(values: Collection) = this.notIn(values) + +infix fun Property.concatenate(value: T) = this.concatenate(value) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/PropertyFactory.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/PropertyFactory.kt index fade08749..2e196542e 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/PropertyFactory.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/PropertyFactory.kt @@ -3,6 +3,7 @@ package com.raizlabs.android.dbflow.sql.language.property import com.raizlabs.android.dbflow.sql.language.NameAlias import com.raizlabs.android.dbflow.sql.language.Operator import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable +import kotlin.reflect.KClass /** * Description: Provides some useful methods for creating [IProperty] from non-property types. @@ -108,7 +109,7 @@ object PropertyFactory { @JvmStatic fun from(type: T?): Property { return Property(null, NameAlias.rawBuilder( - Operator.convertValueToString(type)) + Operator.convertValueToString(type) ?: "") .build()) } @@ -116,24 +117,54 @@ object PropertyFactory { * Creates a new [Property] that is used to allow selects in a query. * * @param queriable The queriable to use and evaulated into a query. - * @param The model class of the query. + * @param [T] The model class of the query. * @return A new property that is a query. */ @JvmStatic - fun from(queriable: ModelQueriable): Property { - return from(queriable.table, "(${queriable.query.trim { it <= ' ' }})") - } + fun from(queriable: ModelQueriable): Property = + from(queriable.table, "(${queriable.query.trim { it <= ' ' }})") /** * Creates a new type-parameterized [Property] to be used as its value represented by the string passed in. * * @param stringRepresentation The string representation of the object you wish to use. - * @param The parameter of its type. + * @param [T] The parameter of its type. * @return A new property with its type. */ @JvmStatic fun from(table: Class, stringRepresentation: String?): Property { - return Property(null, NameAlias.rawBuilder(stringRepresentation) + return Property(null, NameAlias.rawBuilder(stringRepresentation ?: "") .build()) } } + +val Int.property + get() = PropertyFactory.from(this) + +val Char.property + get() = PropertyFactory.from(this) + +val Double.property + get() = PropertyFactory.from(this) + +val Long.property + get() = PropertyFactory.from(this) + +val Float.property + get() = PropertyFactory.from(this) + +val Short.property + get() = PropertyFactory.from(this) + +val Byte.property + get() = PropertyFactory.from(this) + +val T?.property + get() = PropertyFactory.from(this) + +val ModelQueriable.property + get() = PropertyFactory.from(this) + +inline fun propertyString(stringRepresentation: String?) = PropertyFactory.from(T::class.java, stringRepresentation) + +inline fun KClass.allProperty() = Property.allProperty(this.java) \ No newline at end of file diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/TypeConvertedProperty.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/TypeConvertedProperty.kt index 2ebbb9620..1b25064f3 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/TypeConvertedProperty.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/TypeConvertedProperty.kt @@ -3,7 +3,6 @@ package com.raizlabs.android.dbflow.sql.language.property import com.raizlabs.android.dbflow.converter.TypeConverter import com.raizlabs.android.dbflow.sql.language.NameAlias import com.raizlabs.android.dbflow.sql.language.Operator -import com.raizlabs.android.dbflow.sql.language.Operator.op import com.raizlabs.android.dbflow.structure.ModelAdapter /** @@ -21,7 +20,7 @@ class TypeConvertedProperty : Property { private val getter: TypeConverterGetter override val operator: Operator - get() = op(nameAlias, getter.getTypeConverter(getTable()), convertToDB) + get() = Operator.op(nameAlias, getter.getTypeConverter(getTable()), convertToDB) /** * Generated by the compiler, looks up the type converter based on [ModelAdapter] when needed. @@ -29,7 +28,7 @@ class TypeConvertedProperty : Property { */ interface TypeConverterGetter { - fun getTypeConverter(modelClass: Class<*>): TypeConverter<*, *> + fun getTypeConverter(modelClass: Class<*>): TypeConverter<*, Any?> } constructor(table: Class<*>, nameAlias: NameAlias, @@ -54,9 +53,8 @@ class TypeConvertedProperty : Property { if (databaseProperty == null) { databaseProperty = TypeConvertedProperty(getTable(), nameAlias, !convertToDB, object : TypeConverterGetter { - override fun getTypeConverter(modelClass: Class<*>): TypeConverter<*, *> { - return getter.getTypeConverter(modelClass) - } + override fun getTypeConverter(modelClass: Class<*>): TypeConverter<*, Any?> = + getter.getTypeConverter(modelClass) }) } return databaseProperty!! diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/AlterTableMigration.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/AlterTableMigration.kt index 98b6bc361..38fb1a2c5 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/AlterTableMigration.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/AlterTableMigration.kt @@ -10,11 +10,11 @@ import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper /** * Description: Provides a very nice way to alter a single table quickly and easily. */ -class AlterTableMigration( +class AlterTableMigration( /** * The table to ALTER */ - private val table: Class) : BaseMigration() { + private val table: Class) : BaseMigration() { /** * The query we use @@ -93,7 +93,7 @@ class AlterTableMigration( } /** - * Add a column to the DB. This does not necessarily need to be reflected in the [TModel], + * Add a column to the DB. This does not necessarily need to be reflected in the [T], * but it is recommended. * * @param sqLiteType The type of column represented in the DB. @@ -108,7 +108,7 @@ class AlterTableMigration( } /** - * Add a column to the DB. This does not necessarily need to be reflected in the [TModel], + * Add a column to the DB. This does not necessarily need to be reflected in the [T], * but it is recommended. * * @param sqLiteType The type of column that pertains to an [SQLiteType] diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/UpdateTableMigration.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/UpdateTableMigration.kt index 679a786fa..b1392fc4a 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/UpdateTableMigration.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/UpdateTableMigration.kt @@ -11,7 +11,7 @@ import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper * It ties an SQLite [com.raizlabs.android.dbflow.sql.language.Update] * to migrations whenever we want to batch update tables in a structured manner. */ -open class UpdateTableMigration +open class UpdateTableMigration /** * Creates an update migration. * @@ -21,7 +21,7 @@ open class UpdateTableMigration /** * The table to update */ - private val table: Class) : BaseMigration() { + private val table: Class) : BaseMigration() { /** * Builds the conditions for the WHERE part of our query @@ -33,7 +33,7 @@ open class UpdateTableMigration */ private val setOperatorGroup: OperatorGroup by lazy { OperatorGroup.nonGroupingClause() } - val updateStatement: BaseQueriable + val updateStatement: BaseQueriable get() = SQLite.update(table) .set(setOperatorGroup) .where(whereOperatorGroup) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/AsyncQuery.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/AsyncQuery.kt index 9ffbd7689..32eb1e63e 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/AsyncQuery.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/AsyncQuery.kt @@ -1,42 +1,43 @@ package com.raizlabs.android.dbflow.sql.queriable import com.raizlabs.android.dbflow.sql.BaseAsyncObject +import com.raizlabs.android.dbflow.sql.language.CursorResult import com.raizlabs.android.dbflow.structure.database.transaction.QueryTransaction import com.raizlabs.android.dbflow.structure.database.transaction.QueryTransaction.* /** * Description: Adds async methods to a [ModelQueriable] */ -class AsyncQuery +class AsyncQuery /** * Constructs an instance of this async query. * * @param queriable The queriable object to use to query data. */ -(private val modelQueriable: ModelQueriable) : BaseAsyncObject>(modelQueriable.table) { +(private val modelQueriable: ModelQueriable) : BaseAsyncObject>(modelQueriable.table) { - private var queryResultCallback: QueryResultCallback? = null - private var queryResultListCallback: QueryResultListCallback? = null - private var queryResultSingleCallback: QueryResultSingleCallback? = null + private var queryResultCallback: QueryResultCallback? = null + private var queryResultListCallback: QueryResultListCallback? = null + private var queryResultSingleCallback: QueryResultSingleCallback? = null /** * @param queryResultCallback Called when query is executed and has a result. */ - fun queryResultCallback(queryResultCallback: QueryResultCallback) = apply { + fun queryResultCallback(queryResultCallback: QueryResultCallback) = apply { this.queryResultCallback = queryResultCallback } /** * @param queryResultSingleCallback Called when query is executed and has a result. */ - fun querySingleResultCallback(queryResultSingleCallback: QueryResultSingleCallback) = apply { + fun querySingleResultCallback(queryResultSingleCallback: QueryResultSingleCallback) = apply { this.queryResultSingleCallback = queryResultSingleCallback } /** * @param queryResultListCallback Called when query is executed and has a result. */ - fun queryListResultCallback(queryResultListCallback: QueryResultListCallback) = apply { + fun queryListResultCallback(queryResultListCallback: QueryResultListCallback) = apply { this.queryResultListCallback = queryResultListCallback } @@ -54,7 +55,28 @@ class AsyncQuery /** * @return The table this Query is associated with. */ - override val table: Class + override val table: Class get() = modelQueriable.table } + +infix inline fun AsyncQuery.list(crossinline callback: (QueryTransaction<*>, List) -> Unit) + = queryListResultCallback(object : QueryResultListCallback { + override fun onListQueryResult(transaction: QueryTransaction<*>, tResult: List) { + callback(transaction, tResult) + } +}).execute() + +infix inline fun AsyncQuery.result(crossinline callback: (QueryTransaction<*>, T?) -> Unit) + = querySingleResultCallback(object : QueryResultSingleCallback { + override fun onSingleQueryResult(transaction: QueryTransaction<*>, tResult: T?) { + callback(transaction, tResult) + } +}).execute() + +infix inline fun AsyncQuery.cursorResult(crossinline callback: (QueryTransaction<*>, CursorResult) -> Unit) + = queryResultCallback(object : QueryResultCallback { + override fun onQueryResult(transaction: QueryTransaction, tResult: CursorResult) { + callback(transaction, tResult) + } +}).execute() \ No newline at end of file diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/CacheableListModelLoader.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/CacheableListModelLoader.kt index 1fcd79f60..3437bc1cf 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/CacheableListModelLoader.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/CacheableListModelLoader.kt @@ -6,34 +6,32 @@ import com.raizlabs.android.dbflow.structure.cache.ModelCache import com.raizlabs.android.dbflow.structure.database.FlowCursor /** - * Description: Loads a [List] of [TModel] with [Table.cachingEnabled] true. + * Description: Loads a [List] of [T] with [Table.cachingEnabled] true. */ -open class CacheableListModelLoader(modelClass: Class) - : ListModelLoader(modelClass) { +open class CacheableListModelLoader(modelClass: Class) + : ListModelLoader(modelClass) { - val modelAdapter: ModelAdapter by lazy { + val modelAdapter: ModelAdapter by lazy { if (instanceAdapter !is ModelAdapter<*>) { throw IllegalArgumentException("A non-Table type was used.") } - val modelAdapter = instanceAdapter as ModelAdapter + val modelAdapter = instanceAdapter as ModelAdapter if (!modelAdapter.cachingEnabled()) { throw IllegalArgumentException("You cannot call this method for a table that has no caching id. Either" + "use one Primary Key or use the MultiCacheKeyConverter") } return@lazy modelAdapter } - val modelCache: ModelCache by lazy { - modelAdapter.modelCache ?: throw IllegalArgumentException("ModelCache specified in convertToCacheableList() must not be null.") - } + val modelCache: ModelCache by lazy { modelAdapter.modelCache } - override fun convertToData(cursor: FlowCursor, data: MutableList?): MutableList { + override fun convertToData(cursor: FlowCursor, data: MutableList?): MutableList { val _data = data ?: arrayListOf() val cacheValues = arrayOfNulls(modelAdapter.cachingColumns.size) // Ensure that we aren't iterating over this cursor concurrently from different threads if (cursor.moveToFirst()) { do { val values = modelAdapter.getCachingColumnValuesFromCursor(cacheValues, cursor) - var model: TModel? = modelCache.get(modelAdapter.getCachingId(values)) + var model: T? = modelCache.get(modelAdapter.getCachingId(values)) if (model != null) { modelAdapter.reloadRelationships(model, cursor) _data.add(model) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/CacheableModelLoader.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/CacheableModelLoader.kt index f74f4cdcb..a6a63332a 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/CacheableModelLoader.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/CacheableModelLoader.kt @@ -9,33 +9,33 @@ import com.raizlabs.android.dbflow.structure.database.FlowCursor * Description: Loads model data that is backed by a [ModelCache]. Used when [Table.cachingEnabled] * is true. */ -open class CacheableModelLoader(modelClass: Class) - : SingleModelLoader(modelClass) { +open class CacheableModelLoader(modelClass: Class) + : SingleModelLoader(modelClass) { val modelAdapter by lazy { if (instanceAdapter !is ModelAdapter<*>) { throw IllegalArgumentException("A non-Table type was used.") } - val modelAdapter = instanceAdapter as ModelAdapter + val modelAdapter = instanceAdapter as ModelAdapter if (!modelAdapter.cachingEnabled()) { throw IllegalArgumentException("You cannot call this method for a table that has no caching id. Either" + "use one Primary Key or use the MultiCacheKeyConverter") } return@lazy modelAdapter } - val modelCache: ModelCache by lazy { modelAdapter.modelCache } + val modelCache: ModelCache by lazy { modelAdapter.modelCache } /** * Converts data by loading from cache based on its sequence of caching ids. Will reuse the passed - * [TModel] if it's not found in the cache and non-null. + * [T] if it's not found in the cache and non-null. * * @return A model from cache. */ - override fun convertToData(cursor: FlowCursor, data: TModel?, moveToFirst: Boolean): TModel? { + override fun convertToData(cursor: FlowCursor, data: T?, moveToFirst: Boolean): T? { if (!moveToFirst || cursor.moveToFirst()) { val values = modelAdapter.getCachingColumnValuesFromCursor( arrayOfNulls(modelAdapter.cachingColumns.size), cursor) - var model: TModel? = modelCache.get(modelAdapter.getCachingId(values)) + var model: T? = modelCache[modelAdapter.getCachingId(values)] if (model == null) { model = (data ?: modelAdapter.newInstance()).apply { modelAdapter.loadFromCursor(cursor, this) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ListModelLoader.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ListModelLoader.kt index 29c237166..c431c72d4 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ListModelLoader.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ListModelLoader.kt @@ -3,12 +3,12 @@ package com.raizlabs.android.dbflow.sql.queriable import com.raizlabs.android.dbflow.structure.database.FlowCursor /** - * Description: Loads a [List] of [TModel]. + * Description: Loads a [List] of [T]. */ -open class ListModelLoader(modelClass: Class) - : ModelLoader>(modelClass) { +open class ListModelLoader(modelClass: Class) + : ModelLoader>(modelClass) { - override fun load(cursor: FlowCursor?, data: MutableList?): MutableList? { + override fun load(cursor: FlowCursor?, data: MutableList?): MutableList? { var _data = data if (_data == null) { _data = arrayListOf() @@ -18,7 +18,7 @@ open class ListModelLoader(modelClass: Class) return super.load(cursor, _data) } - override fun convertToData(cursor: FlowCursor, data: MutableList?): MutableList { + override fun convertToData(cursor: FlowCursor, data: MutableList?): MutableList { var _data = data if (_data == null) { _data = arrayListOf() diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ModelLoader.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ModelLoader.kt index 2c1f4c33c..bef399ffb 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ModelLoader.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ModelLoader.kt @@ -13,7 +13,7 @@ import com.raizlabs.android.dbflow.structure.database.FlowCursor * Description: Represents how models load from DB. It will query a [SQLiteDatabase] * and query for a [Cursor]. Then the cursor is used to convert itself into an object. */ -abstract class ModelLoader(val modelClass: Class) { +abstract class ModelLoader(val modelClass: Class) { val databaseDefinition: DatabaseDefinition by lazy { FlowManager.getDatabaseForTable(modelClass) } val instanceAdapter: InstanceAdapter by lazy { FlowManager.getInstanceAdapter(modelClass) } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ModelQueriable.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ModelQueriable.kt index 067068d6d..fe415cbed 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ModelQueriable.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ModelQueriable.kt @@ -14,58 +14,58 @@ import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper * Description: An interface for query objects to enable you to query from the database in a structured way. * Examples of such statements are: [From], [Where], [StringQuery] */ -interface ModelQueriable : Queriable { +interface ModelQueriable : Queriable { /** * @return the table that this query comes from. */ - val table: Class + val table: Class /** * @return A wrapper class around [Cursor] that allows you to convert its data into results. */ - fun queryResults(): CursorResult + fun queryResults(): CursorResult /** * @return a list of model converted items */ - fun queryList(): MutableList + fun queryList(): MutableList /** * Allows you to specify a DB, useful for migrations. * * @return a list of model converted items */ - fun queryList(wrapper: DatabaseWrapper): MutableList + fun queryList(wrapper: DatabaseWrapper): MutableList /** * @return Single model, the first of potentially many results */ - fun querySingle(): TModel? + fun querySingle(): T? /** * Allows you to specify a DB, useful for migrations. * * @return Single model, the first of potentially many results */ - fun querySingle(wrapper: DatabaseWrapper): TModel? + fun querySingle(wrapper: DatabaseWrapper): T? /** * @return A cursor-backed list that handles conversion, retrieval, and caching of lists. Can * cache models dynamically by setting [FlowCursorList.setCacheModels] to true. */ - fun cursorList(): FlowCursorList + fun cursorList(): FlowCursorList /** * @return A cursor-backed [List] that handles conversion, retrieval, caching, content changes, * and more. */ - fun flowQueryList(): FlowQueryList + fun flowQueryList(): FlowQueryList /** * @return an async version of this query to run. */ - fun async(): AsyncQuery + fun async(): AsyncQuery /** * Returns a [List] based on the custom [TQueryModel] you pass in. @@ -74,7 +74,7 @@ interface ModelQueriable : Queriable { * @param The class that extends [BaseQueryModel] * @return A list of custom models that are not tied to a table. */ - fun queryCustomList(queryModelClass: Class): MutableList + fun queryCustomList(queryModelClass: Class): MutableList /** * Returns a single [TQueryModel] from this query. @@ -83,6 +83,24 @@ interface ModelQueriable : Queriable { * @param The class that extends [BaseQueryModel] * @return A single model from the query. */ - fun queryCustomSingle(queryModelClass: Class): TQueryModel? + fun queryCustomSingle(queryModelClass: Class): TQueryModel? -} \ No newline at end of file +} + +inline val ModelQueriable.list + get() = queryList() + +inline val ModelQueriable.result + get() = querySingle() + +inline val ModelQueriable.cursorResult + get() = queryResults() + +inline val ModelQueriable.flowQueryList + get() = flowQueryList() + +inline val ModelQueriable.cursorList + get() = cursorList() + +inline val ModelQueriable.async + get() = async() \ No newline at end of file diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/Queriable.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/Queriable.kt index bd4d2b538..4ff3d6a86 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/Queriable.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/Queriable.kt @@ -101,3 +101,12 @@ interface Queriable : Query { */ fun execute(databaseWrapper: DatabaseWrapper) } + +inline val Queriable.cursor + get() = query() + +inline val Queriable.hasData + get() = hasData() + +inline val Queriable.statement + get() = compileStatement() diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleKeyCacheableListModelLoader.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleKeyCacheableListModelLoader.kt index c97769db0..483fce11a 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleKeyCacheableListModelLoader.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleKeyCacheableListModelLoader.kt @@ -5,17 +5,17 @@ import com.raizlabs.android.dbflow.structure.database.FlowCursor /** * Description: */ -class SingleKeyCacheableListModelLoader(tModelClass: Class) - : CacheableListModelLoader(tModelClass) { +class SingleKeyCacheableListModelLoader(tModelClass: Class) + : CacheableListModelLoader(tModelClass) { - override fun convertToData(cursor: FlowCursor, data: MutableList?): MutableList { + override fun convertToData(cursor: FlowCursor, data: MutableList?): MutableList { val _data = data ?: arrayListOf() - var cacheValue: Any + var cacheValue: Any? // Ensure that we aren't iterating over this cursor concurrently from different threads if (cursor.moveToFirst()) { do { cacheValue = modelAdapter.getCachingColumnValueFromCursor(cursor) - var model: TModel? = modelCache.get(cacheValue) + var model: T? = modelCache[cacheValue] if (model != null) { modelAdapter.reloadRelationships(model, cursor) } else { diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleKeyCacheableModelLoader.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleKeyCacheableModelLoader.kt index f641635e8..5a89e2c92 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleKeyCacheableModelLoader.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleKeyCacheableModelLoader.kt @@ -7,20 +7,20 @@ import com.raizlabs.android.dbflow.structure.database.FlowCursor * Description: More optimized version of [CacheableModelLoader] which assumes that the [Model] * only utilizes a single primary key. */ -class SingleKeyCacheableModelLoader(modelClass: Class) - : CacheableModelLoader(modelClass) { +class SingleKeyCacheableModelLoader(modelClass: Class) + : CacheableModelLoader(modelClass) { /** * Converts data by loading from cache based on its sequence of caching ids. Will reuse the passed - * [TModel] if it's not found in the cache and non-null. + * [T] if it's not found in the cache and non-null. * * @return A model from cache. */ - override fun convertToData(cursor: FlowCursor, data: TModel?, - moveToFirst: Boolean): TModel? { + override fun convertToData(cursor: FlowCursor, data: T?, + moveToFirst: Boolean): T? { if (!moveToFirst || cursor.moveToFirst()) { val value = modelAdapter.getCachingColumnValueFromCursor(cursor) - var model: TModel? = modelCache.get(value) + var model: T? = modelCache.get(value) if (model == null) { model = (data ?: modelAdapter.newInstance()).apply { modelAdapter.loadFromCursor(cursor, this) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleModelLoader.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleModelLoader.kt index ba1fc80b4..061834980 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleModelLoader.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleModelLoader.kt @@ -5,11 +5,11 @@ import com.raizlabs.android.dbflow.structure.database.FlowCursor /** * Description: Responsible for loading data into a single object. */ -open class SingleModelLoader(modelClass: Class) - : ModelLoader(modelClass) { +open class SingleModelLoader(modelClass: Class) + : ModelLoader(modelClass) { - open fun convertToData(cursor: FlowCursor, data: TModel?, - moveToFirst: Boolean): TModel? { + open fun convertToData(cursor: FlowCursor, data: T?, + moveToFirst: Boolean): T? { var _data = data if (!moveToFirst || cursor.moveToFirst()) { if (_data == null) { @@ -20,7 +20,7 @@ open class SingleModelLoader(modelClass: Class) return _data } - override fun convertToData(cursor: FlowCursor, data: TModel?): TModel? { + override fun convertToData(cursor: FlowCursor, data: T?): T? { return convertToData(cursor, data, true) } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/StringQuery.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/StringQuery.kt index 9f008397b..f42e8c1bd 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/StringQuery.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/StringQuery.kt @@ -15,7 +15,7 @@ import com.raizlabs.android.dbflow.structure.database.FlowCursor * code where this library does not provide. It only runs a * [SQLiteDatabase.rawQuery]. */ -class StringQuery +class StringQuery /** * Creates an instance of this class * @@ -23,11 +23,11 @@ class StringQuery * @param sql The sql statement to query the DB with. Does not work with [Delete], * this must be done with [SQLiteDatabase.execSQL] */ -(table: Class, +(table: Class, /** * The full SQLite query to use */ - override val query: String) : BaseModelQueriable(table), Query, ModelQueriable { + override val query: String) : BaseModelQueriable(table), Query, ModelQueriable { private var args: Array? = null override// we don't explicitly know the change, but something changed. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/AutoIncrementModelSaver.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/AutoIncrementModelSaver.kt index d1779b20a..d96e02487 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/AutoIncrementModelSaver.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/AutoIncrementModelSaver.kt @@ -9,13 +9,11 @@ import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper /** * Description: Used to properly handle autoincrementing fields. */ -class AutoIncrementModelSaver : ModelSaver() { +class AutoIncrementModelSaver : ModelSaver() { - @Synchronized override fun insert(model: TModel): Long { - return insert(model, writableDatabase) - } + @Synchronized override fun insert(model: T): Long = insert(model, writableDatabase) - @Synchronized override fun insert(model: TModel, wrapper: DatabaseWrapper): Long { + @Synchronized override fun insert(model: T, wrapper: DatabaseWrapper): Long { val hasAutoIncrement = modelAdapter.hasAutoIncrement(model) val insertStatement = when { hasAutoIncrement -> modelAdapter.getCompiledStatement(wrapper) @@ -41,7 +39,7 @@ class AutoIncrementModelSaver : ModelSaver() { return id } - @Synchronized override fun insert(model: TModel, + @Synchronized override fun insert(model: T, insertStatement: DatabaseStatement, wrapper: DatabaseWrapper): Long { return if (!modelAdapter.hasAutoIncrement(model)) { diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/CacheableListModelSaver.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/CacheableListModelSaver.kt index 7d404ffa1..633f61fdf 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/CacheableListModelSaver.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/CacheableListModelSaver.kt @@ -1,15 +1,13 @@ package com.raizlabs.android.dbflow.sql.saveable -import com.raizlabs.android.dbflow.structure.ModelAdapter -import com.raizlabs.android.dbflow.structure.database.DatabaseStatement import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper /** * Description: Used for model caching, enables caching models when saving in list. */ -class CacheableListModelSaver(modelSaver: ModelSaver) : ListModelSaver(modelSaver) { +class CacheableListModelSaver(modelSaver: ModelSaver) : ListModelSaver(modelSaver) { - @Synchronized override fun saveAll(tableCollection: Collection, + @Synchronized override fun saveAll(tableCollection: Collection, wrapper: DatabaseWrapper) { // skip if empty. if (tableCollection.isEmpty()) { @@ -32,7 +30,7 @@ class CacheableListModelSaver(modelSaver: ModelSaver) : ListMode } } - @Synchronized override fun insertAll(tableCollection: Collection, + @Synchronized override fun insertAll(tableCollection: Collection, wrapper: DatabaseWrapper) { // skip if empty. if (tableCollection.isEmpty()) { @@ -53,7 +51,7 @@ class CacheableListModelSaver(modelSaver: ModelSaver) : ListMode } } - @Synchronized override fun updateAll(tableCollection: Collection, + @Synchronized override fun updateAll(tableCollection: Collection, wrapper: DatabaseWrapper) { // skip if empty. if (tableCollection.isEmpty()) { @@ -73,7 +71,7 @@ class CacheableListModelSaver(modelSaver: ModelSaver) : ListMode } } - @Synchronized override fun deleteAll(tableCollection: Collection, + @Synchronized override fun deleteAll(tableCollection: Collection, wrapper: DatabaseWrapper) { // skip if empty. if (tableCollection.isEmpty()) { diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ListModelSaver.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ListModelSaver.kt index f4c24dd26..d8728d98b 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ListModelSaver.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ListModelSaver.kt @@ -2,16 +2,16 @@ package com.raizlabs.android.dbflow.sql.saveable import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper -open class ListModelSaver(val modelSaver: ModelSaver) { +open class ListModelSaver(val modelSaver: ModelSaver) { @Synchronized - fun saveAll(tableCollection: Collection) { + open fun saveAll(tableCollection: Collection) { saveAll(tableCollection, modelSaver.writableDatabase) } @Synchronized - fun saveAll(tableCollection: Collection, - wrapper: DatabaseWrapper) { + open fun saveAll(tableCollection: Collection, + wrapper: DatabaseWrapper) { // skip if empty. if (tableCollection.isEmpty()) { return @@ -30,13 +30,13 @@ open class ListModelSaver(val modelSaver: ModelSaver) { } @Synchronized - fun insertAll(tableCollection: Collection) { + open fun insertAll(tableCollection: Collection) { insertAll(tableCollection, modelSaver.writableDatabase) } @Synchronized - fun insertAll(tableCollection: Collection, - wrapper: DatabaseWrapper) { + open fun insertAll(tableCollection: Collection, + wrapper: DatabaseWrapper) { // skip if empty. if (tableCollection.isEmpty()) { return @@ -51,13 +51,13 @@ open class ListModelSaver(val modelSaver: ModelSaver) { } @Synchronized - fun updateAll(tableCollection: Collection) { + open fun updateAll(tableCollection: Collection) { updateAll(tableCollection, modelSaver.writableDatabase) } @Synchronized - fun updateAll(tableCollection: Collection, - wrapper: DatabaseWrapper) { + open fun updateAll(tableCollection: Collection, + wrapper: DatabaseWrapper) { // skip if empty. if (tableCollection.isEmpty()) { return @@ -72,13 +72,13 @@ open class ListModelSaver(val modelSaver: ModelSaver) { } @Synchronized - fun deleteAll(tableCollection: Collection) { + open fun deleteAll(tableCollection: Collection) { deleteAll(tableCollection, modelSaver.writableDatabase) } @Synchronized - fun deleteAll(tableCollection: Collection, - wrapper: DatabaseWrapper) { + open fun deleteAll(tableCollection: Collection, + wrapper: DatabaseWrapper) { // skip if empty. if (tableCollection.isEmpty()) { return diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ModelSaver.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ModelSaver.kt index 358c844ed..3e8ecefc4 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ModelSaver.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ModelSaver.kt @@ -14,28 +14,28 @@ import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper * Description: Defines how models get saved into the DB. It will bind values to [DatabaseStatement] * for all CRUD operations as they are wildly faster and more efficient than [ContentValues]. */ -open class ModelSaver { +open class ModelSaver { - lateinit var modelAdapter: ModelAdapter + lateinit var modelAdapter: ModelAdapter - protected val writableDatabase: DatabaseWrapper + val writableDatabase: DatabaseWrapper get() = FlowManager.getDatabaseForTable(modelAdapter.modelClass).writableDatabase @Synchronized - fun save(model: TModel): Boolean { - return save(model, writableDatabase, modelAdapter.insertStatement, - modelAdapter.updateStatement) + fun save(model: T): Boolean { + return save(model, writableDatabase, modelAdapter.getInsertStatement(), + modelAdapter.getUpdateStatement()) } @Synchronized - fun save(model: TModel, + fun save(model: T, wrapper: DatabaseWrapper): Boolean { return save(model, wrapper, modelAdapter.getInsertStatement(wrapper), modelAdapter.getUpdateStatement(wrapper)) } @Synchronized - fun save(model: TModel, + fun save(model: T, wrapper: DatabaseWrapper, insertStatement: DatabaseStatement, updateStatement: DatabaseStatement): Boolean { @@ -58,14 +58,13 @@ open class ModelSaver { } @Synchronized - fun update(model: TModel): Boolean { - return update(model, writableDatabase, modelAdapter.updateStatement) - } + fun update(model: T): Boolean = + update(model, writableDatabase, modelAdapter.getUpdateStatement()) @Synchronized - fun update(model: TModel, wrapper: DatabaseWrapper): Boolean { + fun update(model: T, wrapper: DatabaseWrapper): Boolean { val updateStatement = modelAdapter.getUpdateStatement(wrapper) - var success = false + val success: Boolean try { success = update(model, wrapper, updateStatement) } finally { @@ -76,7 +75,7 @@ open class ModelSaver { } @Synchronized - fun update(model: TModel, wrapper: DatabaseWrapper, + fun update(model: T, wrapper: DatabaseWrapper, databaseStatement: DatabaseStatement): Boolean { modelAdapter.saveForeignKeys(model, wrapper) modelAdapter.bindToUpdateStatement(databaseStatement, model) @@ -87,11 +86,10 @@ open class ModelSaver { return successful } - @Synchronized open fun insert(model: TModel): Long { - return insert(model, modelAdapter.insertStatement, writableDatabase) - } + @Synchronized open fun insert(model: T): Long = + insert(model, modelAdapter.getInsertStatement(), writableDatabase) - @Synchronized open fun insert(model: TModel, wrapper: DatabaseWrapper): Long { + @Synchronized open fun insert(model: T, wrapper: DatabaseWrapper): Long { val insertStatement = modelAdapter.getInsertStatement(wrapper) var result: Long = 0 try { @@ -103,7 +101,7 @@ open class ModelSaver { return result } - @Synchronized open fun insert(model: TModel, + @Synchronized open fun insert(model: T, insertStatement: DatabaseStatement, wrapper: DatabaseWrapper): Long { modelAdapter.saveForeignKeys(model, wrapper) @@ -117,12 +115,10 @@ open class ModelSaver { } @Synchronized - fun delete(model: TModel): Boolean { - return delete(model, modelAdapter.deleteStatement, writableDatabase) - } + fun delete(model: T): Boolean = delete(model, modelAdapter.getDeleteStatement(), writableDatabase) @Synchronized - fun delete(model: TModel, wrapper: DatabaseWrapper): Boolean { + fun delete(model: T, wrapper: DatabaseWrapper): Boolean { val deleteStatement = modelAdapter.getDeleteStatement(wrapper) var success = false try { @@ -135,7 +131,7 @@ open class ModelSaver { } @Synchronized - fun delete(model: TModel, + fun delete(model: T, deleteStatement: DatabaseStatement, wrapper: DatabaseWrapper): Boolean { modelAdapter.deleteForeignKeys(model, wrapper) @@ -156,7 +152,7 @@ open class ModelSaver { */ @Deprecated("") @Synchronized - fun save(model: TModel, + fun save(model: T, wrapper: DatabaseWrapper, insertStatement: DatabaseStatement, contentValues: ContentValues): Boolean { @@ -183,7 +179,7 @@ open class ModelSaver { */ @Deprecated("") @Synchronized - fun update(model: TModel, wrapper: DatabaseWrapper, contentValues: ContentValues): Boolean { + fun update(model: T, wrapper: DatabaseWrapper, contentValues: ContentValues): Boolean { modelAdapter.saveForeignKeys(model, wrapper) modelAdapter.bindToContentValues(contentValues, model) val successful = wrapper.updateWithOnConflict(modelAdapter.tableName, contentValues, diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/AsyncModel.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/AsyncModel.java deleted file mode 100644 index a477d8b5f..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/AsyncModel.java +++ /dev/null @@ -1,169 +0,0 @@ -package com.raizlabs.android.dbflow.structure; - -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.config.FlowManager; -import com.raizlabs.android.dbflow.sql.BaseAsyncObject; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; -import com.raizlabs.android.dbflow.structure.database.transaction.DefaultTransactionQueue; -import com.raizlabs.android.dbflow.structure.database.transaction.ProcessModelTransaction; -import com.raizlabs.android.dbflow.structure.database.transaction.Transaction; - -import java.lang.ref.WeakReference; - -/** - * Description: Called from a {@link BaseModel}, this places the current {@link Model} interaction on the background. - */ -public class AsyncModel extends BaseAsyncObject> implements Model { - - /** - * Listens for when this {@link Model} modification completes. - */ - public interface OnModelChangedListener { - - /** - * Called when the change finishes on the {@link DefaultTransactionQueue}. This method is called on the UI thread. - */ - void onModelChanged(@NonNull T model); - } - - private final TModel model; - private transient WeakReference> onModelChangedListener; - - private ModelAdapter modelAdapter; - - public AsyncModel(@NonNull TModel referenceModel) { - super(referenceModel.getClass()); - model = referenceModel; - } - - /** - * Call before {@link #save()}, {@link #delete()}, {@link #update()}, or {@link #insert()}. - * - * @param onModelChangedListener The listener to use for a corresponding call to a method. - */ - public AsyncModel withListener(@Nullable OnModelChangedListener onModelChangedListener) { - this.onModelChangedListener = new WeakReference<>(onModelChangedListener); - return this; - } - - private ModelAdapter getModelAdapter() { - if (modelAdapter == null) { - //noinspection unchecked - modelAdapter = (ModelAdapter) FlowManager.getModelAdapter(model.getClass()); - } - return modelAdapter; - } - - @Override - public boolean save(@NonNull DatabaseWrapper wrapper) { - return save(); - } - - @Override - public boolean save() { - executeTransaction(new ProcessModelTransaction.Builder<>( - new ProcessModelTransaction.ProcessModel() { - @Override - public void processModel(TModel model, DatabaseWrapper wrapper) { - getModelAdapter().save(model, wrapper); - } - }).add(model).build()); - return false; - } - - @Override - public boolean delete(@NonNull DatabaseWrapper wrapper) { - return delete(); - } - - @Override - public boolean delete() { - executeTransaction(new ProcessModelTransaction.Builder<>( - new ProcessModelTransaction.ProcessModel() { - @Override - public void processModel(TModel model, DatabaseWrapper wrapper) { - getModelAdapter().delete(model, wrapper); - } - }).add(model).build()); - return false; - } - - @Override - public boolean update(@NonNull DatabaseWrapper wrapper) { - return update(); - } - - @Override - public boolean update() { - executeTransaction(new ProcessModelTransaction.Builder<>( - new ProcessModelTransaction.ProcessModel() { - @Override - public void processModel(TModel model, DatabaseWrapper wrapper) { - getModelAdapter().update(model, wrapper); - } - }).add(model).build()); - return false; - } - - @Override - public long insert(DatabaseWrapper wrapper) { - return insert(); - } - - @Override - public long insert() { - executeTransaction(new ProcessModelTransaction.Builder<>( - new ProcessModelTransaction.ProcessModel() { - @Override - public void processModel(TModel model, DatabaseWrapper wrapper) { - getModelAdapter().insert(model, wrapper); - } - }).add(model).build()); - return INVALID_ROW_ID; - } - - @Override - public void load(@NonNull DatabaseWrapper wrapper) { - load(); - } - - @Override - public void load() { - executeTransaction(new ProcessModelTransaction.Builder<>( - new ProcessModelTransaction.ProcessModel() { - @Override - public void processModel(TModel model, DatabaseWrapper wrapper) { - getModelAdapter().load(model, wrapper); - } - }).add(model).build()); - } - - @Override - public boolean exists(@NonNull DatabaseWrapper wrapper) { - return exists(); - } - - @Override - public boolean exists() { - return getModelAdapter().exists(model); - } - - /** - * @return Itself since it's already async. - */ - @NonNull - @Override - public AsyncModel async() { - //noinspection unchecked - return (AsyncModel) this; - } - - @Override - protected void onSuccess(@NonNull Transaction transaction) { - if (onModelChangedListener != null && onModelChangedListener.get() != null) { - onModelChangedListener.get().onModelChanged(model); - } - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/AsyncModel.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/AsyncModel.kt new file mode 100644 index 000000000..e85175a4a --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/AsyncModel.kt @@ -0,0 +1,118 @@ +package com.raizlabs.android.dbflow.structure + +import com.raizlabs.android.dbflow.config.FlowManager +import com.raizlabs.android.dbflow.sql.BaseAsyncObject +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.structure.database.transaction.DefaultTransactionQueue +import com.raizlabs.android.dbflow.structure.database.transaction.ProcessModelTransaction +import com.raizlabs.android.dbflow.structure.database.transaction.Transaction + +import java.lang.ref.WeakReference + +/** + * Description: Called from a [BaseModel], this places the current [Model] interaction on the background. + */ +@Deprecated("use Transactions instead") +class AsyncModel(private val model: TModel) : BaseAsyncObject>(model.javaClass), Model { + + @Transient + private var onModelChangedListener: WeakReference>? = null + + private val modelAdapter: ModelAdapter by lazy { FlowManager.getModelAdapter(model.javaClass) } + + /** + * Listens for when this [Model] modification completes. + */ + interface OnModelChangedListener { + + /** + * Called when the change finishes on the [DefaultTransactionQueue]. This method is called on the UI thread. + */ + fun onModelChanged(model: T) + } + + /** + * Call before [.save], [.delete], [.update], or [.insert]. + * + * @param onModelChangedListener The listener to use for a corresponding call to a method. + */ + fun withListener(onModelChangedListener: OnModelChangedListener?): AsyncModel { + this.onModelChangedListener = WeakReference>(onModelChangedListener) + return this + } + + override fun save(wrapper: DatabaseWrapper): Boolean = save() + + override fun save(): Boolean { + executeTransaction(ProcessModelTransaction.Builder( + object : ProcessModelTransaction.ProcessModel { + override fun processModel(model: TModel, wrapper: DatabaseWrapper) { + modelAdapter.save(model, wrapper) + } + }).add(model).build()) + return false + } + + override fun delete(wrapper: DatabaseWrapper): Boolean = delete() + + override fun delete(): Boolean { + executeTransaction(ProcessModelTransaction.Builder( + object : ProcessModelTransaction.ProcessModel { + override fun processModel(model: TModel, wrapper: DatabaseWrapper) { + modelAdapter.delete(model, wrapper) + } + }).add(model).build()) + return false + } + + override fun update(wrapper: DatabaseWrapper): Boolean = update() + + override fun update(): Boolean { + executeTransaction(ProcessModelTransaction.Builder( + object : ProcessModelTransaction.ProcessModel { + override fun processModel(model: TModel, wrapper: DatabaseWrapper) { + modelAdapter.update(model, wrapper) + } + }).add(model).build()) + return false + } + + override fun insert(wrapper: DatabaseWrapper): Long = insert() + + override fun insert(): Long { + executeTransaction(ProcessModelTransaction.Builder( + object : ProcessModelTransaction.ProcessModel { + override fun processModel(model: TModel, wrapper: DatabaseWrapper) { + modelAdapter.insert(model, wrapper) + } + }).add(model).build()) + return Model.INVALID_ROW_ID + } + + override fun load(wrapper: DatabaseWrapper) { + load() + } + + override fun load() { + executeTransaction(ProcessModelTransaction.Builder( + object : ProcessModelTransaction.ProcessModel { + override fun processModel(model: TModel, wrapper: DatabaseWrapper) { + modelAdapter.load(model, wrapper) + } + }).add(model).build()) + } + + override fun exists(wrapper: DatabaseWrapper): Boolean = exists() + + override fun exists(): Boolean = modelAdapter.exists(model) + + /** + * @return Itself since it's already async. + */ + @Suppress("UNCHECKED_CAST") + override fun async(): AsyncModel = this as AsyncModel + + override fun onSuccess(transaction: Transaction) { + onModelChangedListener?.get()?.onModelChanged(model) + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseModel.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseModel.java deleted file mode 100644 index 1deeaa793..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseModel.java +++ /dev/null @@ -1,128 +0,0 @@ -package com.raizlabs.android.dbflow.structure; - -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.annotation.ColumnIgnore; -import com.raizlabs.android.dbflow.config.FlowManager; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; - -/** - * Description: The base implementation of {@link Model}. It is recommended to use this class as - * the base for your {@link Model}, but it is not required. - */ -@SuppressWarnings("unchecked") -public class BaseModel implements Model { - - /** - * Specifies the Action that was taken when data changes - */ - public enum Action { - - /** - * The model called {@link Model#save()} - */ - SAVE, - - /** - * The model called {@link Model#insert()} - */ - INSERT, - - /** - * The model called {@link Model#update()} - */ - UPDATE, - - /** - * The model called {@link Model#delete()} - */ - DELETE, - - /** - * The model was changed. used in prior to {@link android.os.Build.VERSION_CODES#JELLY_BEAN_MR1} - */ - CHANGE - } - - @ColumnIgnore - private transient ModelAdapter modelAdapter; - - @Override - public void load() { - getModelAdapter().load(this); - } - - @Override - public void load(@NonNull DatabaseWrapper wrapper) { - getModelAdapter().load(this, wrapper); - } - - @Override - public boolean save() { - return getModelAdapter().save(this); - } - - - @Override - public boolean save(@NonNull DatabaseWrapper databaseWrapper) { - return getModelAdapter().save(this, databaseWrapper); - } - - @Override - public boolean delete() { - return getModelAdapter().delete(this); - } - - @Override - public boolean delete(@NonNull DatabaseWrapper databaseWrapper) { - return getModelAdapter().delete(this, databaseWrapper); - } - - @Override - public boolean update() { - return getModelAdapter().update(this); - } - - @Override - public boolean update(@NonNull DatabaseWrapper databaseWrapper) { - return getModelAdapter().update(this, databaseWrapper); - } - - @Override - public long insert() { - return getModelAdapter().insert(this); - } - - @Override - public long insert(DatabaseWrapper databaseWrapper) { - return getModelAdapter().insert(this, databaseWrapper); - } - - @Override - public boolean exists() { - return getModelAdapter().exists(this); - } - - @Override - public boolean exists(@NonNull DatabaseWrapper databaseWrapper) { - return getModelAdapter().exists(this, databaseWrapper); - } - - @NonNull - @Override - public AsyncModel async() { - return new AsyncModel<>(this); - } - - /** - * @return The associated {@link ModelAdapter}. The {@link FlowManager} - * may throw a {@link InvalidDBConfiguration} for this call if this class - * is not associated with a table, so be careful when using this method. - */ - public ModelAdapter getModelAdapter() { - if (modelAdapter == null) { - modelAdapter = FlowManager.getModelAdapter(getClass()); - } - return modelAdapter; - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseModel.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseModel.kt new file mode 100644 index 000000000..c5756ec97 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseModel.kt @@ -0,0 +1,91 @@ +package com.raizlabs.android.dbflow.structure + +import com.raizlabs.android.dbflow.annotation.ColumnIgnore +import com.raizlabs.android.dbflow.config.FlowManager +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper + +/** + * Description: The base implementation of [Model]. It is recommended to use this class as + * the base for your [Model], but it is not required. + */ +@Deprecated("No subclass needed. Use extension methods instead") +open class BaseModel : Model { + + /** + * @return The associated [ModelAdapter]. The [FlowManager] + * may throw a [InvalidDBConfiguration] for this call if this class + * is not associated with a table, so be careful when using this method. + */ + @delegate:ColumnIgnore + @delegate:Transient + val modelAdapter: ModelAdapter by lazy { FlowManager.getModelAdapter(javaClass) } + + /** + * Specifies the Action that was taken when data changes + */ + enum class Action { + + /** + * The model called [Model.save] + */ + SAVE, + + /** + * The model called [Model.insert] + */ + INSERT, + + /** + * The model called [Model.update] + */ + UPDATE, + + /** + * The model called [Model.delete] + */ + DELETE, + + /** + * The model was changed. used in prior to [android.os.Build.VERSION_CODES.JELLY_BEAN_MR1] + */ + CHANGE + } + + override fun load() { + modelAdapter.load(this) + } + + override fun load(wrapper: DatabaseWrapper) { + modelAdapter.load(this, wrapper) + } + + override fun save(): Boolean = modelAdapter.save(this) + + + override fun save(wrapper: DatabaseWrapper): Boolean = + modelAdapter.save(this, wrapper) + + override fun delete(): Boolean = modelAdapter.delete(this) + + override fun delete(wrapper: DatabaseWrapper): Boolean = + modelAdapter.delete(this, wrapper) + + override fun update(): Boolean = modelAdapter.update(this) + + override fun update(wrapper: DatabaseWrapper): Boolean = + modelAdapter.update(this, wrapper) + + override fun insert(): Long = modelAdapter.insert(this) + + override fun insert(wrapper: DatabaseWrapper): Long = + modelAdapter.insert(this, wrapper) + + override fun exists(): Boolean = modelAdapter.exists(this) + + override fun exists(wrapper: DatabaseWrapper): Boolean = + modelAdapter.exists(this, wrapper) + + override fun async(): AsyncModel = AsyncModel(this) + + +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseModelView.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseModelView.java deleted file mode 100644 index 708640729..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseModelView.java +++ /dev/null @@ -1,13 +0,0 @@ -package com.raizlabs.android.dbflow.structure; - -import com.raizlabs.android.dbflow.annotation.ModelView; -import com.raizlabs.android.dbflow.annotation.ModelViewQuery; - -/** - * Description: Provides a base implementation for a ModelView. Use a {@link ModelView} - * annotation to register it properly. Also you need to specify a singular - * field via {@link ModelViewQuery}. - */ -public abstract class BaseModelView extends NoModificationModel { - -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseModelView.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseModelView.kt new file mode 100644 index 000000000..358ceb03c --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseModelView.kt @@ -0,0 +1,12 @@ +package com.raizlabs.android.dbflow.structure + +import com.raizlabs.android.dbflow.annotation.ModelView +import com.raizlabs.android.dbflow.annotation.ModelViewQuery + +/** + * Description: Provides a base implementation for a ModelView. Use a [ModelView] + * annotation to register it properly. Also you need to specify a singular + * field via [ModelViewQuery]. + */ +@Deprecated("No subclass needed. Use extension methods and modeladapters") +abstract class BaseModelView : NoModificationModel() diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseQueryModel.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseQueryModel.java deleted file mode 100644 index 36333d667..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseQueryModel.java +++ /dev/null @@ -1,24 +0,0 @@ -package com.raizlabs.android.dbflow.structure; - -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.annotation.QueryModel; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; - -/** - * Description: Provides a base class for objects that represent {@link QueryModel}. - */ -public class BaseQueryModel extends NoModificationModel { - - @Override - public boolean exists() { - throw new InvalidSqlViewOperationException("Query " + getClass().getName() + - " does not exist as a table." + "It's a convenient representation of a complex SQLite query."); - } - - @Override - public boolean exists(@NonNull DatabaseWrapper databaseWrapper) { - return exists(); - } - -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseQueryModel.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseQueryModel.kt new file mode 100644 index 000000000..7c25b9fcf --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseQueryModel.kt @@ -0,0 +1,19 @@ +package com.raizlabs.android.dbflow.structure + +import com.raizlabs.android.dbflow.annotation.QueryModel +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper + +/** + * Description: Provides a base class for objects that represent [QueryModel]. + */ +@Deprecated("No subclass needed. Use extension methods instead.") +class BaseQueryModel : NoModificationModel() { + + override fun exists(): Boolean { + throw NoModificationModel.InvalidSqlViewOperationException("Query " + javaClass.name + + " does not exist as a table." + "It's a convenient representation of a complex SQLite query.") + } + + override fun exists(wrapper: DatabaseWrapper): Boolean = exists() + +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/InstanceAdapter.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/InstanceAdapter.java deleted file mode 100644 index 4be57ecb5..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/InstanceAdapter.java +++ /dev/null @@ -1,24 +0,0 @@ -package com.raizlabs.android.dbflow.structure; - -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.config.DatabaseDefinition; - -/** - * Description: Provides a {@link #newInstance()} method to a {@link RetrievalAdapter} - */ -@SuppressWarnings("NullableProblems") -public abstract class InstanceAdapter - extends RetrievalAdapter { - - public InstanceAdapter(@NonNull DatabaseDefinition databaseDefinition) { - super(databaseDefinition); - } - - /** - * @return A new model using its default constructor. This is why default is required so that - * we don't use reflection to create objects = faster. - */ - @NonNull - public abstract TModel newInstance(); -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/InstanceAdapter.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/InstanceAdapter.kt new file mode 100644 index 000000000..2192102ee --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/InstanceAdapter.kt @@ -0,0 +1,16 @@ +package com.raizlabs.android.dbflow.structure + +import com.raizlabs.android.dbflow.config.DatabaseDefinition + +/** + * Description: Provides a [.newInstance] method to a [RetrievalAdapter] + */ +abstract class InstanceAdapter(databaseDefinition: DatabaseDefinition) + : RetrievalAdapter(databaseDefinition) { + + /** + * @return A new model using its default constructor. This is why default is required so that + * we don't use reflection to create objects = faster. + */ + abstract fun newInstance(): T +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/InternalAdapter.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/InternalAdapter.java deleted file mode 100644 index ed0686d2d..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/InternalAdapter.java +++ /dev/null @@ -1,221 +0,0 @@ -package com.raizlabs.android.dbflow.structure; - -import android.content.ContentValues; -import android.database.sqlite.SQLiteStatement; -import android.support.annotation.IntRange; -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.annotation.PrimaryKey; -import com.raizlabs.android.dbflow.structure.database.DatabaseStatement; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; - -import java.util.Collection; - -/** - * Description: Used for our internal Adapter classes such as generated {@link ModelAdapter}. - */ -@SuppressWarnings("NullableProblems") -public interface InternalAdapter { - - /** - * @return The table name of this adapter. - */ - @NonNull - String getTableName(); - - /** - * Saves the specified model to the DB. - * - * @param model The model to save/insert/update - */ - boolean save(@NonNull TModel model); - - /** - * Saves the specified model to the DB. - * - * @param model The model to save/insert/update - * @param databaseWrapper The manually specified wrapper. - */ - boolean save(@NonNull TModel model, @NonNull DatabaseWrapper databaseWrapper); - - /** - * Saves a {@link Collection} of models to the DB. - * - * @param models The {@link Collection} of models to save. - */ - void saveAll(@NonNull Collection models); - - /** - * Saves a {@link Collection} of models to the DB. - * - * @param models The {@link Collection} of models to save. - * @param databaseWrapper The manually specified wrapper - */ - void saveAll(@NonNull Collection models, @NonNull DatabaseWrapper databaseWrapper); - - /** - * Inserts the specified model into the DB. - * - * @param model The model to insert. - */ - long insert(@NonNull TModel model); - - /** - * Inserts the specified model into the DB. - * - * @param model The model to insert. - * @param databaseWrapper The manually specified wrapper. - */ - long insert(@NonNull TModel model, @NonNull DatabaseWrapper databaseWrapper); - - /** - * Inserts a {@link Collection} of models into the DB. - * - * @param models The {@link Collection} of models to save. - */ - void insertAll(@NonNull Collection models); - - /** - * Inserts a {@link Collection} of models into the DB. - * - * @param models The {@link Collection} of models to save. - * @param databaseWrapper The manually specified wrapper - */ - void insertAll(@NonNull Collection models, @NonNull DatabaseWrapper databaseWrapper); - - /** - * Updates the specified model into the DB. - * - * @param model The model to update. - */ - boolean update(@NonNull TModel model); - - /** - * Updates the specified model into the DB. - * - * @param model The model to update. - * @param databaseWrapper The manually specified wrapper. - */ - boolean update(@NonNull TModel model, @NonNull DatabaseWrapper databaseWrapper); - - /** - * Updates a {@link Collection} of models in the DB. - * - * @param models The {@link Collection} of models to save. - */ - void updateAll(@NonNull Collection models); - - /** - * Updates a {@link Collection} of models in the DB. - * - * @param models The {@link Collection} of models to save. - * @param databaseWrapper The manually specified wrapper - */ - void updateAll(@NonNull Collection models, @NonNull DatabaseWrapper databaseWrapper); - - /** - * Deletes the model from the DB - * - * @param model The model to delete - */ - boolean delete(@NonNull TModel model); - - /** - * Deletes the model from the DB - * - * @param model The model to delete - * @param databaseWrapper The manually specified wrapper. - */ - boolean delete(@NonNull TModel model, @NonNull DatabaseWrapper databaseWrapper); - - /** - * Updates a {@link Collection} of models in the DB. - * - * @param models The {@link Collection} of models to save. - */ - void deleteAll(@NonNull Collection models); - - /** - * Updates a {@link Collection} of models in the DB. - * - * @param models The {@link Collection} of models to save. - * @param databaseWrapper The manually specified wrapper - */ - void deleteAll(@NonNull Collection models, @NonNull DatabaseWrapper databaseWrapper); - - /** - * Binds a {@link TModel} to the specified db statement - * - * @param sqLiteStatement The statement to fill - */ - void bindToStatement(@NonNull DatabaseStatement sqLiteStatement, @NonNull TModel model); - - /** - * Provides common logic and a starting value for insert statements. So we can property compile - * and bind statements without generating duplicate code. - * - * @param sqLiteStatement The statement to bind. - * @param model The model to retrieve data from. - * @param start The starting index for this bind. - */ - void bindToInsertStatement(@NonNull DatabaseStatement sqLiteStatement, @NonNull TModel model, - @IntRange(from = 0, to = 1) int start); - - /** - * Binds to a {@link SQLiteStatement}. It leaves out an autoincrementing primary key (if specified) - * to keep the true nature of AI keys. - * - * @param sqLiteStatement The statement to bind to. - * @param model The model to read from. - */ - void bindToInsertStatement(@NonNull DatabaseStatement sqLiteStatement, @NonNull TModel model); - - /** - * Binds a {@link TModel} to the specified db statement - * - * @param contentValues The content values to fill. - * @param model The model values to put on the contentvalues - */ - void bindToContentValues(@NonNull ContentValues contentValues, @NonNull TModel model); - - /** - * Binds a {@link TModel} to the specified db statement, leaving out the {@link PrimaryKey#autoincrement()} - * column. - * - * @param contentValues The content values to fill. - * @param model The model values to put on the content values. - */ - void bindToInsertValues(@NonNull ContentValues contentValues, @NonNull TModel model); - - /** - * Binds values of the model to an update {@link DatabaseStatement}. It repeats each primary - * key binding twice to ensure proper update statements. - */ - void bindToUpdateStatement(@NonNull DatabaseStatement updateStatement, @NonNull TModel model); - - /** - * Binds values of the model to a delete {@link DatabaseStatement}. - */ - void bindToDeleteStatement(@NonNull DatabaseStatement deleteStatement, @NonNull TModel model); - - /** - * If a model has an autoincrementing primary key, then - * this method will be overridden. - * - * @param model The model object to store the key - * @param id The key to store - */ - void updateAutoIncrement(@NonNull TModel model, @NonNull Number id); - - /** - * @return The value for the {@link PrimaryKey#autoincrement()} - * if it has the field. This method is overridden when its specified for the {@link TModel} - */ - @NonNull - Number getAutoIncrementingId(@NonNull TModel model); - - /** - * @return true if the {@link InternalAdapter} can be cached. - */ - boolean cachingEnabled(); -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/InternalAdapter.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/InternalAdapter.kt new file mode 100644 index 000000000..361f7535a --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/InternalAdapter.kt @@ -0,0 +1,215 @@ +package com.raizlabs.android.dbflow.structure + +import android.content.ContentValues +import android.database.sqlite.SQLiteStatement +import android.support.annotation.IntRange + +import com.raizlabs.android.dbflow.annotation.PrimaryKey +import com.raizlabs.android.dbflow.structure.database.DatabaseStatement +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper + +/** + * Description: Used for our internal Adapter classes such as generated [ModelAdapter]. + */ +interface InternalAdapter { + + /** + * @return The table name of this adapter. + */ + val tableName: String + + /** + * Saves the specified model to the DB. + * + * @param model The model to save/insert/update + */ + fun save(model: TModel): Boolean + + /** + * Saves the specified model to the DB. + * + * @param model The model to save/insert/update + * @param databaseWrapper The manually specified wrapper. + */ + fun save(model: TModel, databaseWrapper: DatabaseWrapper): Boolean + + /** + * Saves a [Collection] of models to the DB. + * + * @param models The [Collection] of models to save. + */ + fun saveAll(models: Collection) + + /** + * Saves a [Collection] of models to the DB. + * + * @param models The [Collection] of models to save. + * @param databaseWrapper The manually specified wrapper + */ + fun saveAll(models: Collection, databaseWrapper: DatabaseWrapper) + + /** + * Inserts the specified model into the DB. + * + * @param model The model to insert. + */ + fun insert(model: TModel): Long + + /** + * Inserts the specified model into the DB. + * + * @param model The model to insert. + * @param databaseWrapper The manually specified wrapper. + */ + fun insert(model: TModel, databaseWrapper: DatabaseWrapper): Long + + /** + * Inserts a [Collection] of models into the DB. + * + * @param models The [Collection] of models to save. + */ + fun insertAll(models: Collection) + + /** + * Inserts a [Collection] of models into the DB. + * + * @param models The [Collection] of models to save. + * @param databaseWrapper The manually specified wrapper + */ + fun insertAll(models: Collection, databaseWrapper: DatabaseWrapper) + + /** + * Updates the specified model into the DB. + * + * @param model The model to update. + */ + fun update(model: TModel): Boolean + + /** + * Updates the specified model into the DB. + * + * @param model The model to update. + * @param databaseWrapper The manually specified wrapper. + */ + fun update(model: TModel, databaseWrapper: DatabaseWrapper): Boolean + + /** + * Updates a [Collection] of models in the DB. + * + * @param models The [Collection] of models to save. + */ + fun updateAll(models: Collection) + + /** + * Updates a [Collection] of models in the DB. + * + * @param models The [Collection] of models to save. + * @param databaseWrapper The manually specified wrapper + */ + fun updateAll(models: Collection, databaseWrapper: DatabaseWrapper) + + /** + * Deletes the model from the DB + * + * @param model The model to delete + */ + fun delete(model: TModel): Boolean + + /** + * Deletes the model from the DB + * + * @param model The model to delete + * @param databaseWrapper The manually specified wrapper. + */ + fun delete(model: TModel, databaseWrapper: DatabaseWrapper): Boolean + + /** + * Updates a [Collection] of models in the DB. + * + * @param models The [Collection] of models to save. + */ + fun deleteAll(models: Collection) + + /** + * Updates a [Collection] of models in the DB. + * + * @param models The [Collection] of models to save. + * @param databaseWrapper The manually specified wrapper + */ + fun deleteAll(models: Collection, databaseWrapper: DatabaseWrapper) + + /** + * Binds a [TModel] to the specified db statement + * + * @param sqLiteStatement The statement to fill + */ + fun bindToStatement(sqLiteStatement: DatabaseStatement, model: TModel) + + /** + * Provides common logic and a starting value for insert statements. So we can property compile + * and bind statements without generating duplicate code. + * + * @param sqLiteStatement The statement to bind. + * @param model The model to retrieve data from. + * @param start The starting index for this bind. + */ + fun bindToInsertStatement(sqLiteStatement: DatabaseStatement, model: TModel, + @IntRange(from = 0, to = 1) start: Int) + + /** + * Binds to a [SQLiteStatement]. It leaves out an autoincrementing primary key (if specified) + * to keep the true nature of AI keys. + * + * @param sqLiteStatement The statement to bind to. + * @param model The model to read from. + */ + fun bindToInsertStatement(sqLiteStatement: DatabaseStatement, model: TModel) + + /** + * Binds a [TModel] to the specified db statement + * + * @param contentValues The content values to fill. + * @param model The model values to put on the contentvalues + */ + fun bindToContentValues(contentValues: ContentValues, model: TModel) + + /** + * Binds a [TModel] to the specified db statement, leaving out the [PrimaryKey.autoincrement] + * column. + * + * @param contentValues The content values to fill. + * @param model The model values to put on the content values. + */ + fun bindToInsertValues(contentValues: ContentValues, model: TModel) + + /** + * Binds values of the model to an update [DatabaseStatement]. It repeats each primary + * key binding twice to ensure proper update statements. + */ + fun bindToUpdateStatement(updateStatement: DatabaseStatement, model: TModel) + + /** + * Binds values of the model to a delete [DatabaseStatement]. + */ + fun bindToDeleteStatement(deleteStatement: DatabaseStatement, model: TModel) + + /** + * If a model has an autoincrementing primary key, then + * this method will be overridden. + * + * @param model The model object to store the key + * @param id The key to store + */ + fun updateAutoIncrement(model: TModel, id: Number) + + /** + * @return The value for the [PrimaryKey.autoincrement] + * if it has the field. This method is overridden when its specified for the [TModel] + */ + fun getAutoIncrementingId(model: TModel): Number? + + /** + * @return true if the [InternalAdapter] can be cached. + */ + fun cachingEnabled(): Boolean +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/InvalidDBConfiguration.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/InvalidDBConfiguration.java deleted file mode 100644 index c863951b7..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/InvalidDBConfiguration.java +++ /dev/null @@ -1,15 +0,0 @@ -package com.raizlabs.android.dbflow.structure; - -/** - * Description: Thrown when a DB is incorrectly configured. - */ -public class InvalidDBConfiguration extends RuntimeException { - - public InvalidDBConfiguration() { - super("No Databases were found. Did you create a Database Annotation placeholder class?"); - } - - public InvalidDBConfiguration(String message) { - super(message); - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/InvalidDBConfiguration.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/InvalidDBConfiguration.kt new file mode 100644 index 000000000..4a2539d2f --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/InvalidDBConfiguration.kt @@ -0,0 +1,11 @@ +package com.raizlabs.android.dbflow.structure + +/** + * Description: Thrown when a DB is incorrectly configured. + */ +class InvalidDBConfiguration : RuntimeException { + + constructor() : super("No Databases were found. Did you create a Database Annotation placeholder class?") + + constructor(message: String) : super(message) {} +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/Model.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/Model.java deleted file mode 100644 index 12ea1a6f3..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/Model.java +++ /dev/null @@ -1,77 +0,0 @@ -package com.raizlabs.android.dbflow.structure; - -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; -import com.raizlabs.android.dbflow.structure.database.transaction.DefaultTransactionQueue; - -public interface Model extends ReadOnlyModel { - - /** - * Returned when {@link #insert()} occurs in an async state or some kind of issue occurs. - */ - long INVALID_ROW_ID = -1; - - /** - * Saves the object in the DB. - * - * @return true if successful - */ - boolean save(); - - /** - * Saves the object in the DB. - * - * @return true if successful - */ - boolean save(@NonNull DatabaseWrapper wrapper); - - /** - * Deletes the object in the DB - * - * @return true if successful - */ - boolean delete(); - - /** - * Deletes the object in the DB - * - * @return true if successful - */ - boolean delete(@NonNull DatabaseWrapper wrapper); - - /** - * Updates an object in the DB. Does not insert on failure. - * - * @return true if successful - */ - boolean update(); - - /** - * Updates an object in the DB. Does not insert on failure. - * - * @return true if successful - */ - boolean update(@NonNull DatabaseWrapper wrapper); - - /** - * Inserts the object into the DB - * - * @return the count of the rows affected, should only be 1 here, or -1 if failed. - */ - long insert(); - - /** - * Inserts the object into the DB - * - * @return the count of the rows affected, should only be 1 here, or -1 if failed. - */ - long insert(DatabaseWrapper wrapper); - - /** - * @return An async instance of this model where all transactions are on the {@link DefaultTransactionQueue} - */ - @NonNull - AsyncModel async(); - -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/Model.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/Model.kt new file mode 100644 index 000000000..cc4bc227a --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/Model.kt @@ -0,0 +1,92 @@ +package com.raizlabs.android.dbflow.structure + +import com.raizlabs.android.dbflow.config.modelAdapter +import com.raizlabs.android.dbflow.config.writableDatabaseForTable +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.structure.database.transaction.DefaultTransactionQueue + +interface Model : ReadOnlyModel { + + /** + * Saves the object in the DB. + * + * @return true if successful + */ + fun save(): Boolean + + /** + * Saves the object in the DB. + * + * @return true if successful + */ + fun save(wrapper: DatabaseWrapper): Boolean + + /** + * Deletes the object in the DB + * + * @return true if successful + */ + fun delete(): Boolean + + /** + * Deletes the object in the DB + * + * @return true if successful + */ + fun delete(wrapper: DatabaseWrapper): Boolean + + /** + * Updates an object in the DB. Does not insert on failure. + * + * @return true if successful + */ + fun update(): Boolean + + /** + * Updates an object in the DB. Does not insert on failure. + * + * @return true if successful + */ + fun update(wrapper: DatabaseWrapper): Boolean + + /** + * Inserts the object into the DB + * + * @return the count of the rows affected, should only be 1 here, or -1 if failed. + */ + fun insert(): Long + + /** + * Inserts the object into the DB + * + * @return the count of the rows affected, should only be 1 here, or -1 if failed. + */ + fun insert(wrapper: DatabaseWrapper): Long + + /** + * @return An async instance of this model where all transactions are on the [DefaultTransactionQueue] + */ + @Deprecated("Use Transactions and extensions.") + fun async(): AsyncModel + + companion object { + + /** + * Returned when [.insert] occurs in an async state or some kind of issue occurs. + */ + const val INVALID_ROW_ID: Long = -1 + } + +} + +inline fun T.save(databaseWrapper: DatabaseWrapper = writableDatabaseForTable()) = modelAdapter().save(this, databaseWrapper) + +inline fun T.insert(databaseWrapper: DatabaseWrapper = writableDatabaseForTable()) = modelAdapter().insert(this, databaseWrapper) + +inline fun T.update(databaseWrapper: DatabaseWrapper = writableDatabaseForTable()) = modelAdapter().update(this, databaseWrapper) + +inline fun T.delete(databaseWrapper: DatabaseWrapper = writableDatabaseForTable()) = modelAdapter().delete(this, databaseWrapper) + +inline fun T.exists(databaseWrapper: DatabaseWrapper = writableDatabaseForTable()) = modelAdapter().exists(this, databaseWrapper) + +inline fun T.async() = AsyncModel(this) \ No newline at end of file diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelAdapter.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelAdapter.java deleted file mode 100644 index 169e9c6e4..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelAdapter.java +++ /dev/null @@ -1,567 +0,0 @@ -package com.raizlabs.android.dbflow.structure; - -import android.content.ContentValues; -import android.database.sqlite.SQLiteStatement; -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.annotation.ConflictAction; -import com.raizlabs.android.dbflow.annotation.ForeignKey; -import com.raizlabs.android.dbflow.annotation.PrimaryKey; -import com.raizlabs.android.dbflow.annotation.Table; -import com.raizlabs.android.dbflow.config.DatabaseDefinition; -import com.raizlabs.android.dbflow.sql.language.property.IProperty; -import com.raizlabs.android.dbflow.sql.language.property.Property; -import com.raizlabs.android.dbflow.sql.saveable.ListModelSaver; -import com.raizlabs.android.dbflow.sql.saveable.ModelSaver; -import com.raizlabs.android.dbflow.structure.cache.IMultiKeyCacheConverter; -import com.raizlabs.android.dbflow.structure.cache.ModelCache; -import com.raizlabs.android.dbflow.structure.cache.SimpleMapCache; -import com.raizlabs.android.dbflow.structure.database.DatabaseStatement; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; -import com.raizlabs.android.dbflow.structure.database.FlowCursor; - -import java.util.Collection; - -import static com.raizlabs.android.dbflow.config.FlowManager.getWritableDatabaseForTable; - -/** - * Description: Used for generated classes from the combination of {@link Table} and {@link Model}. - */ -@SuppressWarnings("NullableProblems") -public abstract class ModelAdapter extends InstanceAdapter - implements InternalAdapter { - - private DatabaseStatement insertStatement; - private DatabaseStatement compiledStatement; - private DatabaseStatement updateStatement; - private DatabaseStatement deleteStatement; - - private String[] cachingColumns; - private ModelCache modelCache; - private ModelSaver modelSaver; - private ListModelSaver listModelSaver; - - public ModelAdapter(@NonNull DatabaseDefinition databaseDefinition) { - super(databaseDefinition); - if (getTableConfig() != null && getTableConfig().getModelSaver() != null) { - modelSaver = getTableConfig().getModelSaver(); - modelSaver.setModelAdapter(this); - } - } - - /** - * @return The pre-compiled insert statement for this table model adapter. This is reused and cached. - */ - @NonNull - public DatabaseStatement getInsertStatement() { - if (insertStatement == null) { - insertStatement = getInsertStatement(INSTANCE.getWritableDatabaseForTable(getModelClass())); - } - - return insertStatement; - } - - /** - * @return The pre-compiled update statement for this table model adapter. This is reused and cached. - */ - @NonNull - public DatabaseStatement getUpdateStatement() { - if (updateStatement == null) { - updateStatement = getUpdateStatement(INSTANCE.getWritableDatabaseForTable(getModelClass())); - } - - return updateStatement; - } - - /** - * @return The pre-compiled delete statement for this table model adapter. This is reused and cached. - */ - @NonNull - public DatabaseStatement getDeleteStatement() { - if (deleteStatement == null) { - deleteStatement = getDeleteStatement(INSTANCE.getWritableDatabaseForTable(getModelClass())); - } - - return deleteStatement; - } - - public void closeInsertStatement() { - if (insertStatement == null) { - return; - } - insertStatement.close(); - insertStatement = null; - } - - public void closeUpdateStatement() { - if (updateStatement == null) { - return; - } - updateStatement.close(); - updateStatement = null; - } - - public void closeDeleteStatement() { - if (deleteStatement == null) { - return; - } - deleteStatement.close(); - deleteStatement = null; - } - - /** - * @param databaseWrapper The database used to do an insert statement. - * @return a new compiled {@link DatabaseStatement} representing insert. Not cached, always generated. - * To bind values use {@link #bindToInsertStatement(DatabaseStatement, Object)}. - */ - @NonNull - public DatabaseStatement getInsertStatement(@NonNull DatabaseWrapper databaseWrapper) { - return databaseWrapper.compileStatement(getInsertStatementQuery()); - } - - /** - * @param databaseWrapper The database used to do an update statement. - * @return a new compiled {@link DatabaseStatement} representing update. Not cached, always generated. - * To bind values use {@link #bindToUpdateStatement(DatabaseStatement, Object)}. - */ - @NonNull - public DatabaseStatement getUpdateStatement(@NonNull DatabaseWrapper databaseWrapper) { - return databaseWrapper.compileStatement(getUpdateStatementQuery()); - } - - /** - * @param databaseWrapper The database used to do a delete statement. - * @return a new compiled {@link DatabaseStatement} representing delete. Not cached, always generated. - * To bind values use {@link #bindToDeleteStatement(DatabaseStatement, Object)}. - */ - @NonNull - public DatabaseStatement getDeleteStatement(@NonNull DatabaseWrapper databaseWrapper) { - return databaseWrapper.compileStatement(getDeleteStatementQuery()); - } - - /** - * @return The precompiled full statement for this table model adapter - */ - @NonNull - public DatabaseStatement getCompiledStatement() { - if (compiledStatement == null) { - compiledStatement = getCompiledStatement(INSTANCE.getWritableDatabaseForTable(getModelClass())); - } - - return compiledStatement; - } - - public void closeCompiledStatement() { - if (compiledStatement == null) { - return; - } - compiledStatement.close(); - compiledStatement = null; - } - - /** - * @param databaseWrapper The database used to do an insert statement. - * @return a new compiled {@link DatabaseStatement} representing insert. - * To bind values use {@link #bindToInsertStatement(DatabaseStatement, Object)}. - */ - public DatabaseStatement getCompiledStatement(@NonNull DatabaseWrapper databaseWrapper) { - return databaseWrapper.compileStatement(getCompiledStatementQuery()); - } - - /** - * Creates a new {@link TModel} and Loads the cursor into a the object. - * - * @param cursor The cursor to load - * @return A new {@link TModel} - */ - public TModel loadFromCursor(@NonNull FlowCursor cursor) { - TModel model = newInstance(); - loadFromCursor(cursor, model); - return model; - } - - @Override - public boolean save(@NonNull TModel model) { - return getModelSaver().save(model); - } - - @Override - public boolean save(@NonNull TModel model, @NonNull DatabaseWrapper databaseWrapper) { - return getModelSaver().save(model, databaseWrapper); - } - - @Override - public void saveAll(@NonNull Collection models) { - getListModelSaver().saveAll(models); - } - - @Override - public void saveAll(@NonNull Collection models, @NonNull DatabaseWrapper databaseWrapper) { - getListModelSaver().saveAll(models, databaseWrapper); - } - - @Override - public long insert(@NonNull TModel model) { - return getModelSaver().insert(model); - } - - @Override - public long insert(@NonNull TModel model, @NonNull DatabaseWrapper databaseWrapper) { - return getModelSaver().insert(model, databaseWrapper); - } - - @Override - public void insertAll(@NonNull Collection models) { - getListModelSaver().insertAll(models); - } - - @Override - public void insertAll(@NonNull Collection models, @NonNull DatabaseWrapper databaseWrapper) { - getListModelSaver().insertAll(models, databaseWrapper); - } - - @Override - public boolean update(@NonNull TModel model) { - return getModelSaver().update(model); - } - - @Override - public boolean update(@NonNull TModel model, @NonNull DatabaseWrapper databaseWrapper) { - return getModelSaver().update(model, databaseWrapper); - } - - @Override - public void updateAll(@NonNull Collection models) { - getListModelSaver().updateAll(models); - } - - @Override - public void updateAll(@NonNull Collection models, @NonNull DatabaseWrapper databaseWrapper) { - getListModelSaver().updateAll(models, databaseWrapper); - } - - @Override - public boolean delete(@NonNull TModel model) { - return getModelSaver().delete(model); - } - - @Override - public boolean delete(@NonNull TModel model, @NonNull DatabaseWrapper databaseWrapper) { - return getModelSaver().delete(model, databaseWrapper); - } - - @Override - public void deleteAll(@NonNull Collection tModels, @NonNull DatabaseWrapper databaseWrapper) { - getListModelSaver().deleteAll(tModels, databaseWrapper); - } - - @Override - public void deleteAll(@NonNull Collection tModels) { - getListModelSaver().deleteAll(tModels); - } - - @Override - public void bindToInsertStatement(@NonNull DatabaseStatement sqLiteStatement, @NonNull TModel model) { - bindToInsertStatement(sqLiteStatement, model, 0); - } - - @Override - public void bindToContentValues(@NonNull ContentValues contentValues, @NonNull TModel tModel) { - bindToInsertValues(contentValues, tModel); - } - - @Override - public void bindToStatement(@NonNull DatabaseStatement sqLiteStatement, @NonNull TModel tModel) { - bindToInsertStatement(sqLiteStatement, tModel, 0); - } - - /** - * If a {@link Model} has an auto-incrementing primary key, then - * this method will be overridden. - * - * @param model The model object to store the key - * @param id The key to store - */ - @Override - public void updateAutoIncrement(@NonNull TModel model, @NonNull Number id) { - - } - - /** - * @return The value for the {@link PrimaryKey#autoincrement()} - * if it has the field. This method is overridden when its specified for the {@link TModel} - */ - @NonNull - @Override - public Number getAutoIncrementingId(@NonNull TModel model) { - throw new InvalidDBConfiguration( - String.format("This method may have been called in error. The model class %1s must contain" + - "a single primary key (if used in a ModelCache, this method may be called)", - getModelClass())); - } - - /** - * @return The autoincrement column name for the {@link PrimaryKey#autoincrement()} - * if it has the field. This method is overridden when its specified for the {@link TModel} - */ - @NonNull - public String getAutoIncrementingColumnName() { - throw new InvalidDBConfiguration( - String.format("This method may have been called in error. The model class %1s must contain " + - "an autoincrementing or single int/long primary key (if used in a ModelCache, this method may be called)", - getModelClass())); - } - - public boolean hasAutoIncrement(TModel model) { - Number id = getAutoIncrementingId(model); - //noinspection ConstantConditions - if (id == null) { - throw new IllegalStateException("An autoincrementing column field cannot be null."); - } - return id.longValue() > 0; - } - - /** - * Called when we want to save our {@link ForeignKey} objects. usually during insert + update. - * This method is overridden when {@link ForeignKey} specified - */ - public void saveForeignKeys(@NonNull TModel model, @NonNull DatabaseWrapper wrapper) { - - } - - /** - * Called when we want to delete our {@link ForeignKey} objects. During deletion {@link #delete(Object, DatabaseWrapper)} - * This method is overridden when {@link ForeignKey} specified - */ - public void deleteForeignKeys(@NonNull TModel model, @NonNull DatabaseWrapper wrapper) { - - } - - /** - * @return A set of columns that represent the caching columns. - */ - @NonNull - public String[] createCachingColumns() { - return new String[]{getAutoIncrementingColumnName()}; - } - - /** - * @return The array of columns (in order) that represent what are cached. - */ - public String[] getCachingColumns() { - if (cachingColumns == null) { - cachingColumns = createCachingColumns(); - } - return cachingColumns; - } - - /** - * Loads all primary keys from the {@link FlowCursor} into the inValues. The size of the array must - * match all primary keys. This method gets generated when caching is enabled. - * - * @param inValues The reusable array of values to populate. - * @param cursor The cursor to load from. - * @return The populated set of values to load from cache. - */ - public Object[] getCachingColumnValuesFromCursor(@NonNull Object[] inValues, - @NonNull FlowCursor cursor) { - throwCachingError(); - return null; - } - - /** - * @param cursor The cursor to load caching id from. - * @return The single cache column from cursor (if single). - */ - public Object getCachingColumnValueFromCursor(@NonNull FlowCursor cursor) { - throwSingleCachingError(); - return null; - } - - /** - * Loads all primary keys from the {@link TModel} into the inValues. The size of the array must - * match all primary keys. This method gets generated when caching is enabled. It converts the primary fields - * of the {@link TModel} into the array of values the caching mechanism uses. - * - * @param inValues The reusable array of values to populate. - * @param TModel The model to load from. - * @return The populated set of values to load from cache. - */ - public Object[] getCachingColumnValuesFromModel(@NonNull Object[] inValues, @NonNull TModel TModel) { - throwCachingError(); - return null; - } - - /** - * @param model The model to load cache column data from. - * @return The single cache column from model (if single). - */ - public Object getCachingColumnValueFromModel(@NonNull TModel model) { - throwSingleCachingError(); - return null; - } - - public void storeModelInCache(@NonNull TModel model) { - getModelCache().addModel(getCachingId(model), model); - } - - public void removeModelFromCache(@NonNull TModel model) { - getModelCache().removeModel(getCachingId(model)); - } - - public ModelCache getModelCache() { - if (modelCache == null) { - modelCache = createModelCache(); - } - return modelCache; - } - - public Object getCachingId(@NonNull Object[] inValues) { - if (inValues.length == 1) { - // if it exists in cache no matter the query we will use that one - return inValues[0]; - } else { - return getCacheConverter().getCachingKey(inValues); - } - } - - public Object getCachingId(@NonNull TModel model) { - return getCachingId(getCachingColumnValuesFromModel(new Object[getCachingColumns().length], model)); - } - - public ModelSaver getModelSaver() { - if (modelSaver == null) { - modelSaver = createSingleModelSaver(); - modelSaver.setModelAdapter(this); - } - return modelSaver; - } - - public ListModelSaver getListModelSaver() { - if (listModelSaver == null) { - listModelSaver = createListModelSaver(); - } - return listModelSaver; - } - - protected ModelSaver createSingleModelSaver() { - return new ModelSaver<>(); - } - - protected ListModelSaver createListModelSaver() { - return new ListModelSaver<>(getModelSaver()); - } - - /** - * Sets how this {@link ModelAdapter} saves its objects. - * - * @param modelSaver The saver to use. - */ - public void setModelSaver(@NonNull ModelSaver modelSaver) { - this.modelSaver = modelSaver; - this.modelSaver.setModelAdapter(this); - } - - /** - * Reloads relationships when loading from {@link FlowCursor} in a model that's cacheable. By having - * relationships with cached models, the retrieval will be very fast. - * - * @param cursor The cursor to reload from. - */ - public void reloadRelationships(@NonNull TModel model, @NonNull FlowCursor cursor) { - if (!cachingEnabled()) { - throwCachingError(); - } - } - - @Override - public boolean cachingEnabled() { - return false; - } - - public int getCacheSize() { - return Table.Companion.getDEFAULT_CACHE_SIZE(); - } - - public IMultiKeyCacheConverter getCacheConverter() { - throw new InvalidDBConfiguration("For multiple primary keys, a public static IMultiKeyCacheConverter field must" + - "be marked with @MultiCacheField in the corresponding model class. The resulting key" + - "must be a unique combination of the multiple keys, otherwise inconsistencies may occur."); - } - - public ModelCache createModelCache() { - return new SimpleMapCache<>(getCacheSize()); - } - - /** - * @return The query used to create this table. - */ - public abstract String getCreationQuery(); - - /** - * Retrieves a property by name from the table via the corresponding generated "_Table" class. Useful - * when you want to dynamically get a property from an {@link ModelAdapter} and do an operation on it. - * - * @param columnName The column name of the property. - * @return The property from the corresponding Table class. - */ - public abstract Property getProperty(String columnName); - - /** - * @return An array of column properties, in order of declaration. - */ - public abstract IProperty[] getAllColumnProperties(); - - /** - * @return The query used to insert a model using a {@link SQLiteStatement} - */ - protected String getInsertStatementQuery() { - return getCompiledStatementQuery(); - } - - /** - * @return The normal query used in saving a model if we use a {@link SQLiteStatement}. - */ - protected abstract String getCompiledStatementQuery(); - - protected abstract String getUpdateStatementQuery(); - - protected abstract String getDeleteStatementQuery(); - - /** - * @return The conflict algorithm to use when updating a row in this table. - */ - public ConflictAction getUpdateOnConflictAction() { - return ConflictAction.ABORT; - } - - /** - * @return The conflict algorithm to use when inserting a row in this table. - */ - public ConflictAction getInsertOnConflictAction() { - return ConflictAction.ABORT; - } - - /** - * @return When false, this table gets generated and associated with database, however it will not immediately - * get created upon startup. This is useful for keeping around legacy tables for migrations. - */ - public boolean createWithDatabase() { - return true; - } - - private void throwCachingError() { - throw new InvalidDBConfiguration( - String.format("This method may have been called in error. The model class %1s must contain" + - "an auto-incrementing or at least one primary key (if used in a ModelCache, this method may be called)", - getModelClass())); - } - - private void throwSingleCachingError() { - throw new InvalidDBConfiguration( - String.format("This method may have been called in error. The model class %1s must contain" + - "an auto-incrementing or one primary key (if used in a ModelCache, this method may be called)", - getModelClass())); - } - -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelAdapter.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelAdapter.kt new file mode 100644 index 000000000..163700834 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelAdapter.kt @@ -0,0 +1,444 @@ +package com.raizlabs.android.dbflow.structure + +import android.content.ContentValues +import android.database.sqlite.SQLiteStatement +import com.raizlabs.android.dbflow.annotation.ConflictAction +import com.raizlabs.android.dbflow.annotation.DEFAULT_CACHE_SIZE +import com.raizlabs.android.dbflow.annotation.ForeignKey +import com.raizlabs.android.dbflow.annotation.PrimaryKey +import com.raizlabs.android.dbflow.annotation.Table +import com.raizlabs.android.dbflow.config.DatabaseDefinition +import com.raizlabs.android.dbflow.config.FlowManager +import com.raizlabs.android.dbflow.sql.language.property.IProperty +import com.raizlabs.android.dbflow.sql.language.property.Property +import com.raizlabs.android.dbflow.sql.saveable.ListModelSaver +import com.raizlabs.android.dbflow.sql.saveable.ModelSaver +import com.raizlabs.android.dbflow.structure.cache.IMultiKeyCacheConverter +import com.raizlabs.android.dbflow.structure.cache.ModelCache +import com.raizlabs.android.dbflow.structure.cache.SimpleMapCache +import com.raizlabs.android.dbflow.structure.database.DatabaseStatement +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.structure.database.FlowCursor + +/** + * Description: Used for generated classes from the combination of [Table] and [Model]. + */ +abstract class ModelAdapter(databaseDefinition: DatabaseDefinition) + : InstanceAdapter(databaseDefinition), InternalAdapter { + + private var insertStatement: DatabaseStatement? = null + private var compiledStatement: DatabaseStatement? = null + private var updateStatement: DatabaseStatement? = null + private var deleteStatement: DatabaseStatement? = null + + val cachingColumns: Array by lazy { createCachingColumns() } + val modelCache: ModelCache by lazy { createModelCache() } + private var _modelSaver: ModelSaver? = null + + val listModelSaver: ListModelSaver by lazy { createListModelSaver() } + + /** + * @return The autoincrement column name for the [PrimaryKey.autoincrement] + * if it has the field. This method is overridden when its specified for the [T] + */ + open val autoIncrementingColumnName: String + get() = throw InvalidDBConfiguration( + String.format("This method may have been called in error. The model class %1s must contain " + "an autoincrementing or single int/long primary key (if used in a ModelCache, this method may be called)", + modelClass)) + + open val cacheSize: Int + get() = DEFAULT_CACHE_SIZE + + open val cacheConverter: IMultiKeyCacheConverter<*> + get() = throw InvalidDBConfiguration("For multiple primary keys, a public static IMultiKeyCacheConverter field must" + + "be marked with @MultiCacheField in the corresponding model class. The resulting key" + + "must be a unique combination of the multiple keys, otherwise inconsistencies may occur.") + + /** + * @return The query used to create this table. + */ + abstract val creationQuery: String + + /** + * @return An array of column properties, in order of declaration. + */ + abstract val allColumnProperties: Array> + + /** + * @return The query used to insert a model using a [SQLiteStatement] + */ + protected open val insertStatementQuery: String + get() = compiledStatementQuery + + /** + * @return The normal query used in saving a model if we use a [SQLiteStatement]. + */ + protected abstract val compiledStatementQuery: String + + protected abstract val updateStatementQuery: String + + protected abstract val deleteStatementQuery: String + + /** + * @return The conflict algorithm to use when updating a row in this table. + */ + open val updateOnConflictAction: ConflictAction + get() = ConflictAction.ABORT + + /** + * @return The conflict algorithm to use when inserting a row in this table. + */ + open val insertOnConflictAction: ConflictAction + get() = ConflictAction.ABORT + + init { + if (tableConfig != null && tableConfig!!.modelSaver != null) { + _modelSaver = tableConfig!!.modelSaver + _modelSaver!!.modelAdapter = this + } + } + + /** + * @return The pre-compiled insert statement for this table model adapter. This is reused and cached. + */ + fun getInsertStatement(): DatabaseStatement { + if (insertStatement == null) { + insertStatement = getInsertStatement(FlowManager.getWritableDatabaseForTable(modelClass)) + } + + return insertStatement!! + } + + /** + * @return The pre-compiled update statement for this table model adapter. This is reused and cached. + */ + fun getUpdateStatement(): DatabaseStatement { + if (updateStatement == null) { + updateStatement = getUpdateStatement(FlowManager.getWritableDatabaseForTable(modelClass)) + } + + return updateStatement!! + } + + /** + * @return The pre-compiled delete statement for this table model adapter. This is reused and cached. + */ + fun getDeleteStatement(): DatabaseStatement { + if (deleteStatement == null) { + deleteStatement = getDeleteStatement(FlowManager.getWritableDatabaseForTable(modelClass)) + } + + return deleteStatement!! + } + + fun closeInsertStatement() { + insertStatement?.close() + insertStatement = null + } + + fun closeUpdateStatement() { + updateStatement?.close() + updateStatement = null + } + + fun closeDeleteStatement() { + deleteStatement?.close() + deleteStatement = null + } + + /** + * @param databaseWrapper The database used to do an insert statement. + * @return a new compiled [DatabaseStatement] representing insert. Not cached, always generated. + * To bind values use [.bindToInsertStatement]. + */ + fun getInsertStatement(databaseWrapper: DatabaseWrapper): DatabaseStatement = + databaseWrapper.compileStatement(insertStatementQuery) + + /** + * @param databaseWrapper The database used to do an update statement. + * @return a new compiled [DatabaseStatement] representing update. Not cached, always generated. + * To bind values use [.bindToUpdateStatement]. + */ + fun getUpdateStatement(databaseWrapper: DatabaseWrapper): DatabaseStatement = + databaseWrapper.compileStatement(updateStatementQuery) + + /** + * @param databaseWrapper The database used to do a delete statement. + * @return a new compiled [DatabaseStatement] representing delete. Not cached, always generated. + * To bind values use [.bindToDeleteStatement]. + */ + fun getDeleteStatement(databaseWrapper: DatabaseWrapper): DatabaseStatement = + databaseWrapper.compileStatement(deleteStatementQuery) + + /** + * @return The precompiled full statement for this table model adapter + */ + fun getCompiledStatement(): DatabaseStatement { + if (compiledStatement == null) { + compiledStatement = getCompiledStatement(FlowManager.getWritableDatabaseForTable(modelClass)) + } + + return compiledStatement!! + } + + fun closeCompiledStatement() { + compiledStatement?.close() + compiledStatement = null + } + + /** + * @param databaseWrapper The database used to do an insert statement. + * @return a new compiled [DatabaseStatement] representing insert. + * To bind values use [.bindToInsertStatement]. + */ + fun getCompiledStatement(databaseWrapper: DatabaseWrapper): DatabaseStatement = + databaseWrapper.compileStatement(compiledStatementQuery) + + /** + * Creates a new [T] and Loads the cursor into a the object. + * + * @param cursor The cursor to load + * @return A new [T] + */ + fun loadFromCursor(cursor: FlowCursor): T { + val model = newInstance() + loadFromCursor(cursor, model) + return model + } + + override fun save(model: T): Boolean = modelSaver.save(model) + + override fun save(model: T, databaseWrapper: DatabaseWrapper): Boolean = + modelSaver.save(model, databaseWrapper) + + override fun saveAll(models: Collection) { + listModelSaver.saveAll(models) + } + + override fun saveAll(models: Collection, databaseWrapper: DatabaseWrapper) { + listModelSaver.saveAll(models, databaseWrapper) + } + + override fun insert(model: T): Long = modelSaver.insert(model) + + override fun insert(model: T, databaseWrapper: DatabaseWrapper): Long = + modelSaver.insert(model, databaseWrapper) + + override fun insertAll(models: Collection) { + listModelSaver.insertAll(models) + } + + override fun insertAll(models: Collection, databaseWrapper: DatabaseWrapper) { + listModelSaver.insertAll(models, databaseWrapper) + } + + override fun update(model: T): Boolean = modelSaver.update(model) + + override fun update(model: T, databaseWrapper: DatabaseWrapper): Boolean = + modelSaver.update(model, databaseWrapper) + + override fun updateAll(models: Collection) { + listModelSaver.updateAll(models) + } + + override fun updateAll(models: Collection, databaseWrapper: DatabaseWrapper) { + listModelSaver.updateAll(models, databaseWrapper) + } + + override fun delete(model: T): Boolean = modelSaver.delete(model) + + override fun delete(model: T, databaseWrapper: DatabaseWrapper): Boolean = + modelSaver.delete(model, databaseWrapper) + + override fun deleteAll(models: Collection, databaseWrapper: DatabaseWrapper) { + listModelSaver.deleteAll(models, databaseWrapper) + } + + override fun deleteAll(models: Collection) { + listModelSaver.deleteAll(models) + } + + override fun bindToInsertStatement(sqLiteStatement: DatabaseStatement, model: T) { + bindToInsertStatement(sqLiteStatement, model, 0) + } + + override fun bindToContentValues(contentValues: ContentValues, model: T) { + bindToInsertValues(contentValues, model) + } + + override fun bindToStatement(sqLiteStatement: DatabaseStatement, model: T) { + bindToInsertStatement(sqLiteStatement, model, 0) + } + + /** + * If a [Model] has an auto-incrementing primary key, then + * this method will be overridden. + * + * @param model The model object to store the key + * @param id The key to store + */ + override fun updateAutoIncrement(model: T, id: Number) { + + } + + /** + * @return The value for the [PrimaryKey.autoincrement] + * if it has the field. This method is overridden when its specified for the [T] + */ + override fun getAutoIncrementingId(model: T): Number? { + throw InvalidDBConfiguration( + String.format("This method may have been called in error. The model class %1s must contain" + "a single primary key (if used in a ModelCache, this method may be called)", + modelClass)) + } + + fun hasAutoIncrement(model: T): Boolean { + val id = getAutoIncrementingId(model) ?: throw IllegalStateException("An autoincrementing column field cannot be null.") + + return id.toLong() > 0 + } + + /** + * Called when we want to save our [ForeignKey] objects. usually during insert + update. + * This method is overridden when [ForeignKey] specified + */ + open fun saveForeignKeys(model: T, wrapper: DatabaseWrapper) { + + } + + /** + * Called when we want to delete our [ForeignKey] objects. During deletion [.delete] + * This method is overridden when [ForeignKey] specified + */ + open fun deleteForeignKeys(model: T, wrapper: DatabaseWrapper) { + + } + + /** + * @return A set of columns that represent the caching columns. + */ + fun createCachingColumns(): Array = arrayOf(autoIncrementingColumnName) + + /** + * Loads all primary keys from the [FlowCursor] into the inValues. The size of the array must + * match all primary keys. This method gets generated when caching is enabled. + * + * @param inValues The reusable array of values to populate. + * @param cursor The cursor to load from. + * @return The populated set of values to load from cache. + */ + open fun getCachingColumnValuesFromCursor(inValues: Array, + cursor: FlowCursor): Array? { + throwCachingError() + return null + } + + /** + * @param cursor The cursor to load caching id from. + * @return The single cache column from cursor (if single). + */ + open fun getCachingColumnValueFromCursor(cursor: FlowCursor): Any? { + throwSingleCachingError() + return null + } + + /** + * Loads all primary keys from the [TModel] into the inValues. The size of the array must + * match all primary keys. This method gets generated when caching is enabled. It converts the primary fields + * of the [TModel] into the array of values the caching mechanism uses. + * + * @param inValues The reusable array of values to populate. + * @param TModel The model to load from. + * @return The populated set of values to load from cache. + */ + open fun getCachingColumnValuesFromModel(inValues: Array, TModel: T): Array? { + throwCachingError() + return null + } + + /** + * @param model The model to load cache column data from. + * @return The single cache column from model (if single). + */ + open fun getCachingColumnValueFromModel(model: T): Any? { + throwSingleCachingError() + return null + } + + fun storeModelInCache(model: T) { + modelCache.addModel(getCachingId(model), model) + } + + fun removeModelFromCache(model: T) { + getCachingId(model)?.let { modelCache.removeModel(it) } + } + + fun getCachingId(inValues: Array?): Any? = when { + inValues?.size == 1 -> // if it exists in cache no matter the query we will use that one + inValues.getOrNull(0) + inValues != null -> cacheConverter.getCachingKey(inValues) + else -> null + } + + fun getCachingId(model: T): Any? = + getCachingId(getCachingColumnValuesFromModel(arrayOfNulls(cachingColumns.size), model)) + + var modelSaver: ModelSaver + get() { + if (_modelSaver == null) { + _modelSaver = createSingleModelSaver().apply { modelAdapter = this@ModelAdapter } + } + return _modelSaver!! + } + set(value) { + this._modelSaver = value + value.modelAdapter = this + } + + protected open fun createSingleModelSaver(): ModelSaver = ModelSaver() + + protected open fun createListModelSaver(): ListModelSaver = ListModelSaver(modelSaver) + + /** + * Reloads relationships when loading from [FlowCursor] in a model that's cacheable. By having + * relationships with cached models, the retrieval will be very fast. + * + * @param cursor The cursor to reload from. + */ + open fun reloadRelationships(model: T, cursor: FlowCursor) { + if (!cachingEnabled()) { + throwCachingError() + } + } + + override fun cachingEnabled(): Boolean = false + + open fun createModelCache(): ModelCache = SimpleMapCache(cacheSize) + + /** + * Retrieves a property by name from the table via the corresponding generated "_Table" class. Useful + * when you want to dynamically get a property from an [ModelAdapter] and do an operation on it. + * + * @param columnName The column name of the property. + * @return The property from the corresponding Table class. + */ + abstract fun getProperty(columnName: String): Property<*> + + /** + * @return When false, this table gets generated and associated with database, however it will not immediately + * get created upon startup. This is useful for keeping around legacy tables for migrations. + */ + fun createWithDatabase(): Boolean = true + + private fun throwCachingError() { + throw InvalidDBConfiguration( + String.format("This method may have been called in error. The model class %1s must contain" + "an auto-incrementing or at least one primary key (if used in a ModelCache, this method may be called)", + modelClass)) + } + + private fun throwSingleCachingError() { + throw InvalidDBConfiguration( + String.format("This method may have been called in error. The model class %1s must contain" + "an auto-incrementing or one primary key (if used in a ModelCache, this method may be called)", + modelClass)) + } + +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelViewAdapter.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelViewAdapter.java deleted file mode 100644 index 337e4cd1a..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelViewAdapter.java +++ /dev/null @@ -1,26 +0,0 @@ -package com.raizlabs.android.dbflow.structure; - -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.config.DatabaseDefinition; - -/** - * Description: The base class for a {@link TModelView} adapter that defines how it interacts with the DB. - */ -public abstract class ModelViewAdapter - extends InstanceAdapter { - - public ModelViewAdapter(@NonNull DatabaseDefinition databaseDefinition) { - super(databaseDefinition); - } - - /** - * @return a string of the query that is used to create this model view. - */ - public abstract String getCreationQuery(); - - /** - * @return The name of this view in the database - */ - public abstract String getViewName(); -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelViewAdapter.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelViewAdapter.kt new file mode 100644 index 000000000..7cd6c03dc --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelViewAdapter.kt @@ -0,0 +1,20 @@ +package com.raizlabs.android.dbflow.structure + +import com.raizlabs.android.dbflow.config.DatabaseDefinition + +/** + * Description: The base class for a [T] adapter that defines how it interacts with the DB. + */ +abstract class ModelViewAdapter(databaseDefinition: DatabaseDefinition) + : InstanceAdapter(databaseDefinition) { + + /** + * @return a string of the query that is used to create this model view. + */ + abstract val creationQuery: String + + /** + * @return The name of this view in the database + */ + abstract val viewName: String +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/NoModificationModel.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/NoModificationModel.java deleted file mode 100644 index fdb59a9d7..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/NoModificationModel.java +++ /dev/null @@ -1,51 +0,0 @@ -package com.raizlabs.android.dbflow.structure; - -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.config.FlowManager; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; - -/** - * Description: A convenience class for {@link ReadOnlyModel}. - */ -abstract class NoModificationModel implements ReadOnlyModel { - - private transient RetrievalAdapter adapter; - - @SuppressWarnings("unchecked") - public boolean exists() { - return getRetrievalAdapter().exists(this); - } - - @SuppressWarnings("unchecked") - public boolean exists(@NonNull DatabaseWrapper databaseWrapper) { - return getRetrievalAdapter().exists(this, databaseWrapper); - } - - @SuppressWarnings("unchecked") - public void load() { - getRetrievalAdapter().load(this); - } - - @SuppressWarnings("unchecked") - public void load(@NonNull DatabaseWrapper wrapper) { - getRetrievalAdapter().load(this, wrapper); - } - - public RetrievalAdapter getRetrievalAdapter() { - if (adapter == null) { - adapter = FlowManager.getInstanceAdapter(getClass()); - } - return adapter; - } - - /** - * Gets thrown when an operation is not valid for the SQL View - */ - static class InvalidSqlViewOperationException extends RuntimeException { - - InvalidSqlViewOperationException(String detailMessage) { - super(detailMessage); - } - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/NoModificationModel.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/NoModificationModel.kt new file mode 100644 index 000000000..21ee210e1 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/NoModificationModel.kt @@ -0,0 +1,31 @@ +package com.raizlabs.android.dbflow.structure + +import com.raizlabs.android.dbflow.config.FlowManager +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper + +/** + * Description: A convenience class for [ReadOnlyModel]. + */ +abstract class NoModificationModel : ReadOnlyModel { + + @delegate:Transient + private val retrievalAdapter: RetrievalAdapter by lazy { FlowManager.getInstanceAdapter(javaClass) } + + override fun exists(): Boolean = retrievalAdapter.exists(this) + + override fun exists(wrapper: DatabaseWrapper): Boolean = + retrievalAdapter.exists(this, wrapper) + + override fun load() { + retrievalAdapter.load(this) + } + + override fun load(wrapper: DatabaseWrapper) { + retrievalAdapter.load(this, wrapper) + } + + /** + * Gets thrown when an operation is not valid for the SQL View + */ + internal class InvalidSqlViewOperationException(detailMessage: String) : RuntimeException(detailMessage) +} diff --git a/dbflow-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/kotlinextensions/OneToManyExtensions.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/OneToMany.kt similarity index 85% rename from dbflow-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/kotlinextensions/OneToManyExtensions.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/structure/OneToMany.kt index 6e63c8086..9a27c2851 100644 --- a/dbflow-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/kotlinextensions/OneToManyExtensions.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/OneToMany.kt @@ -1,10 +1,13 @@ -package com.raizlabs.android.dbflow.kotlinextensions +package com.raizlabs.android.dbflow.structure import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable +import com.raizlabs.android.dbflow.sql.queriable.list import kotlin.properties.ReadWriteProperty import kotlin.reflect.KProperty - +/** + * Description: + */ fun oneToMany(query: () -> ModelQueriable) = OneToMany(query) /** diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/QueryModelAdapter.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/QueryModelAdapter.java deleted file mode 100644 index f00637fae..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/QueryModelAdapter.java +++ /dev/null @@ -1,35 +0,0 @@ -package com.raizlabs.android.dbflow.structure; - -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.annotation.QueryModel; -import com.raizlabs.android.dbflow.config.DatabaseDefinition; -import com.raizlabs.android.dbflow.sql.language.OperatorGroup; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; - -/** - * Description: The baseclass for adapters to {@link QueryModel} that defines how it interacts with the DB. The - * where query is not defined here, rather its determined by the query used. - */ -public abstract class QueryModelAdapter extends - InstanceAdapter { - - public QueryModelAdapter(DatabaseDefinition databaseDefinition) { - super(databaseDefinition); - } - - @Override - public OperatorGroup getPrimaryConditionClause(@NonNull TQueryModel model) { - throw new UnsupportedOperationException("QueryModels cannot check for existence"); - } - - @Override - public boolean exists(@NonNull TQueryModel model) { - throw new UnsupportedOperationException("QueryModels cannot check for existence"); - } - - @Override - public boolean exists(@NonNull TQueryModel model, @NonNull DatabaseWrapper databaseWrapper) { - throw new UnsupportedOperationException("QueryModels cannot check for existence"); - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/QueryModelAdapter.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/QueryModelAdapter.kt new file mode 100644 index 000000000..23fd06001 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/QueryModelAdapter.kt @@ -0,0 +1,26 @@ +package com.raizlabs.android.dbflow.structure + +import com.raizlabs.android.dbflow.annotation.QueryModel +import com.raizlabs.android.dbflow.config.DatabaseDefinition +import com.raizlabs.android.dbflow.sql.language.OperatorGroup +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper + +/** + * Description: The baseclass for adapters to [QueryModel] that defines how it interacts with the DB. The + * where query is not defined here, rather its determined by the query used. + */ +abstract class QueryModelAdapter(databaseDefinition: DatabaseDefinition) + : InstanceAdapter(databaseDefinition) { + + override fun getPrimaryConditionClause(model: T): OperatorGroup { + throw UnsupportedOperationException("QueryModels cannot check for existence") + } + + override fun exists(model: T): Boolean { + throw UnsupportedOperationException("QueryModels cannot check for existence") + } + + override fun exists(model: T, databaseWrapper: DatabaseWrapper): Boolean { + throw UnsupportedOperationException("QueryModels cannot check for existence") + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ReadOnlyModel.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ReadOnlyModel.kt similarity index 56% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ReadOnlyModel.java rename to dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ReadOnlyModel.kt index d0bb43f31..d36b9f528 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ReadOnlyModel.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ReadOnlyModel.kt @@ -1,34 +1,32 @@ -package com.raizlabs.android.dbflow.structure; +package com.raizlabs.android.dbflow.structure -import android.support.annotation.NonNull; +import com.raizlabs.android.dbflow.sql.migration.Migration +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper -import com.raizlabs.android.dbflow.sql.migration.Migration; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; - -public interface ReadOnlyModel { +interface ReadOnlyModel { /** * Loads from the database the most recent version of the model based on it's primary keys. */ - void load(); + fun load() /** * Loads from the database the most recent version of the model based on it's primary keys. * - * @param wrapper Database object to use. Useful for {@link Migration} classes. + * @param wrapper Database object to use. Useful for [Migration] classes. */ - void load(@NonNull DatabaseWrapper wrapper); + fun load(wrapper: DatabaseWrapper) /** * @return true if this object exists in the DB. It combines all of it's primary key fields * into a SELECT query and checks to see if any results occur. */ - boolean exists(); + fun exists(): Boolean /** - * @param wrapper Database object to use. Useful for {@link Migration} classes. + * @param wrapper Database object to use. Useful for [Migration] classes. * @return true if this object exists in the DB. It combines all of it's primary key fields * into a SELECT query and checks to see if any results occur. */ - boolean exists(@NonNull DatabaseWrapper wrapper); + fun exists(wrapper: DatabaseWrapper): Boolean } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/RetrievalAdapter.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/RetrievalAdapter.java deleted file mode 100644 index 1eafe3dc9..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/RetrievalAdapter.java +++ /dev/null @@ -1,178 +0,0 @@ -package com.raizlabs.android.dbflow.structure; - -import android.database.Cursor; -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.config.DatabaseConfig; -import com.raizlabs.android.dbflow.config.DatabaseDefinition; -import com.raizlabs.android.dbflow.config.FlowManager; -import com.raizlabs.android.dbflow.config.TableConfig; -import com.raizlabs.android.dbflow.sql.language.OperatorGroup; -import com.raizlabs.android.dbflow.sql.language.SQLite; -import com.raizlabs.android.dbflow.sql.queriable.ListModelLoader; -import com.raizlabs.android.dbflow.sql.queriable.SingleModelLoader; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; -import com.raizlabs.android.dbflow.structure.database.FlowCursor; - -/** - * Description: Provides a base retrieval class for all {@link Model} backed - * adapters. - */ -@SuppressWarnings("NullableProblems") -public abstract class RetrievalAdapter { - - private SingleModelLoader singleModelLoader; - private ListModelLoader listModelLoader; - - private TableConfig tableConfig; - - public RetrievalAdapter(@NonNull DatabaseDefinition databaseDefinition) { - DatabaseConfig databaseConfig = FlowManager.getConfig() - .getConfigForDatabase(databaseDefinition.getAssociatedDatabaseClassFile()); - if (databaseConfig != null) { - tableConfig = databaseConfig.getTableConfigForTable(getModelClass()); - if (tableConfig != null) { - if (tableConfig.getSingleModelLoader() != null) { - singleModelLoader = tableConfig.getSingleModelLoader(); - } - - if (tableConfig.getListModelLoader() != null) { - listModelLoader = tableConfig.getListModelLoader(); - } - } - } - } - - /** - * Force loads the model from the DB. Even if caching is enabled it will requery the object. - */ - public void load(@NonNull TModel model) { - load(model, FlowManager.getDatabaseForTable(getModelClass()).getWritableDatabase()); - } - - /** - * Force loads the model from the DB. Even if caching is enabled it will requery the object. - */ - public void load(@NonNull TModel model, DatabaseWrapper databaseWrapper) { - getNonCacheableSingleModelLoader().load(databaseWrapper, - SQLite.INSTANCE.select() - .from(getModelClass()) - .where(getPrimaryConditionClause(model)).getQuery(), - model); - } - - /** - * Assigns the {@link Cursor} data into the specified {@link TModel} - * - * @param model The model to assign cursor data to - * @param cursor The cursor to load into the model - */ - public abstract void loadFromCursor(@NonNull FlowCursor cursor, @NonNull TModel model); - - /** - * @param model The model to query values from - * @return True if it exists as a row in the corresponding database table - */ - public boolean exists(@NonNull TModel model) { - return exists(model, FlowManager.getDatabaseForTable(getModelClass()).getWritableDatabase()); - } - - /** - * @param model The model to query values from - * @return True if it exists as a row in the corresponding database table - */ - public abstract boolean exists(@NonNull TModel model, - @NonNull DatabaseWrapper databaseWrapper); - - /** - * @param model The primary condition clause. - * @return The clause that contains necessary primary conditions for this table. - */ - public abstract OperatorGroup getPrimaryConditionClause(@NonNull TModel model); - - /** - * @return the model class this adapter corresponds to - */ - @NonNull - public abstract Class getModelClass(); - - @Nullable - protected TableConfig getTableConfig() { - return tableConfig; - } - - /** - * @return A new {@link ListModelLoader}, caching will override this loader instance. - */ - @NonNull - public ListModelLoader getListModelLoader() { - if (listModelLoader == null) { - listModelLoader = createListModelLoader(); - } - return listModelLoader; - } - - /** - * @return A new {@link ListModelLoader}, caching will override this loader instance. - */ - @NonNull - protected ListModelLoader createListModelLoader() { - return new ListModelLoader<>(getModelClass()); - } - - /** - * @return A new {@link SingleModelLoader}, caching will override this loader instance. - */ - @NonNull - protected SingleModelLoader createSingleModelLoader() { - return new SingleModelLoader<>(getModelClass()); - } - - @NonNull - public SingleModelLoader getSingleModelLoader() { - if (singleModelLoader == null) { - singleModelLoader = createSingleModelLoader(); - } - return singleModelLoader; - } - - /** - * @return A new instance of a {@link SingleModelLoader}. Subsequent calls do not cache - * this object so it's recommended only calling this in bulk if possible. - */ - @NonNull - public SingleModelLoader getNonCacheableSingleModelLoader() { - return new SingleModelLoader<>(getModelClass()); - } - - /** - * @return A new instance of a {@link ListModelLoader}. Subsequent calls do not cache - * this object so it's recommended only calling this in bulk if possible. - */ - @NonNull - public ListModelLoader getNonCacheableListModelLoader() { - return new ListModelLoader<>(getModelClass()); - } - - /** - * Overrides the default implementation and allows you to provide your own implementation. Defines - * how a single {@link TModel} is loaded. - * - * @param singleModelLoader The loader to use. - */ - public void setSingleModelLoader(@NonNull SingleModelLoader singleModelLoader) { - this.singleModelLoader = singleModelLoader; - } - - /** - * Overrides the default implementation and allows you to provide your own implementation. Defines - * how a list of {@link TModel} are loaded. - * - * @param listModelLoader The loader to use. - */ - public void setListModelLoader(@NonNull ListModelLoader listModelLoader) { - this.listModelLoader = listModelLoader; - } - -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/RetrievalAdapter.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/RetrievalAdapter.kt new file mode 100644 index 000000000..7e9216089 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/RetrievalAdapter.kt @@ -0,0 +1,146 @@ +package com.raizlabs.android.dbflow.structure + +import android.database.Cursor +import com.raizlabs.android.dbflow.config.DatabaseDefinition +import com.raizlabs.android.dbflow.config.FlowManager +import com.raizlabs.android.dbflow.config.TableConfig +import com.raizlabs.android.dbflow.sql.language.OperatorGroup +import com.raizlabs.android.dbflow.sql.language.SQLite +import com.raizlabs.android.dbflow.sql.queriable.ListModelLoader +import com.raizlabs.android.dbflow.sql.queriable.SingleModelLoader +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.structure.database.FlowCursor + +/** + * Description: Provides a base retrieval class for all [Model] backed + * adapters. + */ +abstract class RetrievalAdapter(databaseDefinition: DatabaseDefinition) { + + /** + * Overrides the default implementation and allows you to provide your own implementation. Defines + * how a single [T] is loaded. + * + * @param singleModelLoader The loader to use. + */ + private var _singleModelLoader: SingleModelLoader? = null + + var singleModelLoader: SingleModelLoader + get() { + if (_singleModelLoader == null) { + _singleModelLoader = createSingleModelLoader() + } + return _singleModelLoader!! + } + set(value) { + this._singleModelLoader = value + } + /** + * @return A new [ListModelLoader], caching will override this loader instance. + */ + /** + * Overrides the default implementation and allows you to provide your own implementation. Defines + * how a list of [T] are loaded. + * + * @param listModelLoader The loader to use. + */ + private var _listModelLoader: ListModelLoader? = null + + var listModelLoader: ListModelLoader + get() { + if (_listModelLoader == null) { + _listModelLoader = createListModelLoader() + } + return _listModelLoader!! + } + set(value) { + this._listModelLoader = value + } + + protected var tableConfig: TableConfig? = null + private set + + /** + * @return the model class this adapter corresponds to + */ + abstract val modelClass: Class + + /** + * @return A new instance of a [SingleModelLoader]. Subsequent calls do not cache + * this object so it's recommended only calling this in bulk if possible. + */ + val nonCacheableSingleModelLoader: SingleModelLoader + get() = SingleModelLoader(modelClass) + + /** + * @return A new instance of a [ListModelLoader]. Subsequent calls do not cache + * this object so it's recommended only calling this in bulk if possible. + */ + val nonCacheableListModelLoader: ListModelLoader + get() = ListModelLoader(modelClass) + + init { + val databaseConfig = FlowManager.getConfig() + .getConfigForDatabase(databaseDefinition.associatedDatabaseClassFile) + if (databaseConfig != null) { + tableConfig = databaseConfig.getTableConfigForTable(modelClass) + if (tableConfig != null) { + tableConfig?.singleModelLoader?.let { _singleModelLoader = it } + tableConfig?.listModelLoader?.let { _listModelLoader = it } + } + } + } + + /** + * Force loads the model from the DB. Even if caching is enabled it will requery the object. + */ + @JvmOverloads + fun load(model: T, databaseWrapper: DatabaseWrapper = FlowManager.getDatabaseForTable(modelClass).writableDatabase) { + nonCacheableSingleModelLoader.load(databaseWrapper, + SQLite.select() + .from(modelClass) + .where(getPrimaryConditionClause(model)).query, + model) + } + + /** + * Assigns the [Cursor] data into the specified [T] + * + * @param model The model to assign cursor data to + * @param cursor The cursor to load into the model + */ + abstract fun loadFromCursor(cursor: FlowCursor, model: T) + + /** + * @param model The model to query values from + * @return True if it exists as a row in the corresponding database table + */ + open fun exists(model: T): Boolean = + exists(model, FlowManager.getDatabaseForTable(modelClass).writableDatabase) + + /** + * @param model The model to query values from + * @return True if it exists as a row in the corresponding database table + */ + abstract fun exists(model: T, databaseWrapper: DatabaseWrapper): Boolean + + /** + * @param model The primary condition clause. + * @return The clause that contains necessary primary conditions for this table. + */ + abstract fun getPrimaryConditionClause(model: T): OperatorGroup + + /** + * @return A new [ListModelLoader], caching will override this loader instance. + */ + protected fun createListModelLoader(): ListModelLoader = ListModelLoader(modelClass) + + /** + * @return A new [SingleModelLoader], caching will override this loader instance. + */ + protected fun createSingleModelLoader(): SingleModelLoader = SingleModelLoader(modelClass) + +} +/** + * Force loads the model from the DB. Even if caching is enabled it will requery the object. + */ diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/ModelLruCache.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/ModelLruCache.kt index d7e0683ae..ef158514a 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/ModelLruCache.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/ModelLruCache.kt @@ -1,8 +1,7 @@ package com.raizlabs.android.dbflow.structure.cache import android.util.LruCache - -import com.raizlabs.android.dbflow.annotation.Table +import com.raizlabs.android.dbflow.annotation.DEFAULT_CACHE_SIZE /** * Description: Provides an [android.util.LruCache] under its hood @@ -52,12 +51,12 @@ class ModelLruCache(size: Int) companion object { /** - * @param size The size, if less than or equal to 0 we set it to [Table.DEFAULT_CACHE_SIZE]. + * @param size The size, if less than or equal to 0 we set it to [DEFAULT_CACHE_SIZE]. */ fun newInstance(size: Int): ModelLruCache { var _size = size if (_size <= 0) { - _size = Table.DEFAULT_CACHE_SIZE + _size = DEFAULT_CACHE_SIZE } return ModelLruCache(_size) } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/SimpleMapCache.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/SimpleMapCache.kt index a1df046ec..2e05c4674 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/SimpleMapCache.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/SimpleMapCache.kt @@ -27,17 +27,13 @@ class SimpleMapCache : ModelCache> { cache.put(id, model) } - override fun removeModel(id: Any): TModel? { - return cache.remove(id) - } + override fun removeModel(id: Any): TModel? = cache.remove(id) override fun clear() { cache.clear() } - override fun get(id: Any?): TModel? { - return cache.get(id) - } + override fun get(id: Any?): TModel? = cache[id] override fun setCacheSize(size: Int) { FlowLog.log(FlowLog.Level.W, "The cache size for ${SimpleMapCache::class.java.simpleName} is not re-configurable.") diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/AndroidDatabase.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/AndroidDatabase.java deleted file mode 100644 index bad1e661b..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/AndroidDatabase.java +++ /dev/null @@ -1,103 +0,0 @@ -package com.raizlabs.android.dbflow.structure.database; - -import android.content.ContentValues; -import android.database.sqlite.SQLiteDatabase; -import android.os.Build; -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -/** - * Description: Specifies the android default implementation of a database. - */ -public class AndroidDatabase implements DatabaseWrapper { - - public static AndroidDatabase from(@NonNull SQLiteDatabase database) { - return new AndroidDatabase(database); - } - - private final SQLiteDatabase database; - - AndroidDatabase(@NonNull SQLiteDatabase database) { - this.database = database; - } - - @Override - public void execSQL(@NonNull String query) { - database.execSQL(query); - } - - @Override - public void beginTransaction() { - database.beginTransaction(); - } - - @Override - public void setTransactionSuccessful() { - database.setTransactionSuccessful(); - } - - @Override - public void endTransaction() { - database.endTransaction(); - } - - @Override - public int getVersion() { - return database.getVersion(); - } - - public SQLiteDatabase getDatabase() { - return database; - } - - @NonNull - @Override - public DatabaseStatement compileStatement(@NonNull String rawQuery) { - return AndroidDatabaseStatement.from(database.compileStatement(rawQuery), database); - } - - @NonNull - @Override - public FlowCursor rawQuery(@NonNull String query, @Nullable String[] selectionArgs) { - return FlowCursor.from(database.rawQuery(query, selectionArgs)); - } - - @Override - public long updateWithOnConflict(@NonNull String tableName, @NonNull ContentValues contentValues, @Nullable String where, @Nullable String[] whereArgs, int conflictAlgorithm) { - long count; - if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.FROYO) { - count = database.updateWithOnConflict(tableName, contentValues, where, whereArgs, conflictAlgorithm); - } else { - count = database.update(tableName, contentValues, where, whereArgs); - } - return count; - } - - @Override - public long insertWithOnConflict(@NonNull String tableName, @Nullable String nullColumnHack, @NonNull ContentValues values, int sqLiteDatabaseAlgorithmInt) { - long count; - if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.FROYO) { - count = database.insertWithOnConflict(tableName, nullColumnHack, values, sqLiteDatabaseAlgorithmInt); - } else { - count = database.insert(tableName, nullColumnHack, values); - } - return count; - } - - @NonNull - @Override - public FlowCursor query(@NonNull String tableName, - @Nullable String[] columns, - @Nullable String selection, - @Nullable String[] selectionArgs, - @Nullable String groupBy, - @Nullable String having, - @Nullable String orderBy) { - return FlowCursor.from(database.query(tableName, columns, selection, selectionArgs, groupBy, having, orderBy)); - } - - @Override - public int delete(@NonNull String tableName, @Nullable String whereClause, @Nullable String[] whereArgs) { - return database.delete(tableName, whereClause, whereArgs); - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/AndroidDatabase.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/AndroidDatabase.kt new file mode 100644 index 000000000..1d2beda50 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/AndroidDatabase.kt @@ -0,0 +1,75 @@ +package com.raizlabs.android.dbflow.structure.database + +import android.content.ContentValues +import android.database.sqlite.SQLiteDatabase +import android.os.Build + +/** + * Description: Specifies the android default implementation of a database. + */ +class AndroidDatabase internal constructor(val database: SQLiteDatabase) : DatabaseWrapper { + + override fun execSQL(query: String) { + database.execSQL(query) + } + + override fun beginTransaction() { + database.beginTransaction() + } + + override fun setTransactionSuccessful() { + database.setTransactionSuccessful() + } + + override fun endTransaction() { + database.endTransaction() + } + + override val version: Int + get() = database.version + + override fun compileStatement(rawQuery: String): DatabaseStatement = + AndroidDatabaseStatement.from(database.compileStatement(rawQuery), database) + + override fun rawQuery(query: String, selectionArgs: Array?): FlowCursor = + FlowCursor.from(database.rawQuery(query, selectionArgs)) + + override fun updateWithOnConflict(tableName: String, + contentValues: ContentValues, + where: String?, + whereArgs: Array?, + conflictAlgorithm: Int): Long = + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.FROYO) { + database.updateWithOnConflict(tableName, contentValues, where, whereArgs, conflictAlgorithm).toLong() + } else { + database.update(tableName, contentValues, where, whereArgs).toLong() + } + + override fun insertWithOnConflict(tableName: String, + nullColumnHack: String?, + values: ContentValues, + sqLiteDatabaseAlgorithmInt: Int): Long = + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.FROYO) { + database.insertWithOnConflict(tableName, nullColumnHack, values, sqLiteDatabaseAlgorithmInt) + } else { + database.insert(tableName, nullColumnHack, values) + } + + override fun query(tableName: String, + columns: Array?, + selection: String?, + selectionArgs: Array?, + groupBy: String?, + having: String?, + orderBy: String?): FlowCursor = + FlowCursor.from(database.query(tableName, columns, selection, selectionArgs, groupBy, having, orderBy)) + + override fun delete(tableName: String, whereClause: String?, whereArgs: Array?): Int = + database.delete(tableName, whereClause, whereArgs) + + companion object { + + @JvmStatic + fun from(database: SQLiteDatabase): AndroidDatabase = AndroidDatabase(database) + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/AndroidDatabaseStatement.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/AndroidDatabaseStatement.java deleted file mode 100644 index df44ce5c8..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/AndroidDatabaseStatement.java +++ /dev/null @@ -1,110 +0,0 @@ -package com.raizlabs.android.dbflow.structure.database; - -import android.database.Cursor; -import android.database.SQLException; -import android.database.sqlite.SQLiteDatabase; -import android.database.sqlite.SQLiteStatement; -import android.os.Build; -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -/** - * Description: - */ -public class AndroidDatabaseStatement extends BaseDatabaseStatement { - - public static AndroidDatabaseStatement from(@NonNull SQLiteStatement sqLiteStatement, - @NonNull SQLiteDatabase database) { - return new AndroidDatabaseStatement(sqLiteStatement, database); - } - - private final SQLiteStatement statement; - private final SQLiteDatabase database; - - AndroidDatabaseStatement(@NonNull SQLiteStatement statement, - @NonNull SQLiteDatabase database) { - this.statement = statement; - this.database = database; - } - - @NonNull - public SQLiteStatement getStatement() { - return statement; - } - - @Override - public long executeUpdateDelete() { - long count = 0; - if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) { - count = statement.executeUpdateDelete(); - } else { - statement.execute(); - - Cursor cursor = null; - try { - cursor = database.rawQuery("SELECT changes() AS affected_row_count", null); - if (cursor != null && cursor.getCount() > 0 && cursor.moveToFirst()) { - count = cursor.getLong(cursor.getColumnIndex("affected_row_count")); - } - } catch (SQLException e) { - // Handle exception here. - } finally { - if (cursor != null) { - cursor.close(); - } - } - } - return count; - } - - @Override - public void execute() { - statement.execute(); - } - - @Override - public void close() { - statement.close(); - } - - @Override - public long simpleQueryForLong() { - return statement.simpleQueryForLong(); - } - - @Nullable - @Override - public String simpleQueryForString() { - return statement.simpleQueryForString(); - } - - @Override - public long executeInsert() { - return statement.executeInsert(); - } - - @Override - public void bindString(int index, String s) { - statement.bindString(index, s); - } - - @Override - public void bindNull(int index) { - statement.bindNull(index); - } - - @Override - public void bindLong(int index, long aLong) { - statement.bindLong(index, aLong); - } - - @Override - public void bindDouble(int index, double aDouble) { - statement.bindDouble(index, aDouble); - } - - @Override - public void bindBlob(int index, byte[] bytes) { - statement.bindBlob(index, bytes); - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/AndroidDatabaseStatement.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/AndroidDatabaseStatement.kt new file mode 100644 index 000000000..f37155cec --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/AndroidDatabaseStatement.kt @@ -0,0 +1,81 @@ +package com.raizlabs.android.dbflow.structure.database + +import android.database.Cursor +import android.database.SQLException +import android.database.sqlite.SQLiteDatabase +import android.database.sqlite.SQLiteStatement +import android.os.Build + +/** + * Description: + */ +class AndroidDatabaseStatement +internal constructor(val statement: SQLiteStatement, + private val database: SQLiteDatabase) : BaseDatabaseStatement() { + + override fun executeUpdateDelete(): Long { + var count: Long = 0 + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) { + count = statement.executeUpdateDelete().toLong() + } else { + statement.execute() + + var cursor: Cursor? = null + try { + cursor = database.rawQuery("SELECT changes() AS affected_row_count", null) + if (cursor != null && cursor.count > 0 && cursor.moveToFirst()) { + count = cursor.getLong(cursor.getColumnIndex("affected_row_count")) + } + } catch (e: SQLException) { + // Handle exception here. + } finally { + if (cursor != null) { + cursor.close() + } + } + } + return count + } + + override fun execute() { + statement.execute() + } + + override fun close() { + statement.close() + } + + override fun simpleQueryForLong(): Long = statement.simpleQueryForLong() + + override fun simpleQueryForString(): String? = statement.simpleQueryForString() + + override fun executeInsert(): Long = statement.executeInsert() + + override fun bindString(index: Int, s: String) { + statement.bindString(index, s) + } + + override fun bindNull(index: Int) { + statement.bindNull(index) + } + + override fun bindLong(index: Int, aLong: Long) { + statement.bindLong(index, aLong) + } + + override fun bindDouble(index: Int, aDouble: Double) { + statement.bindDouble(index, aDouble) + } + + override fun bindBlob(index: Int, bytes: ByteArray) { + statement.bindBlob(index, bytes) + } + + companion object { + + @JvmStatic + fun from(sqLiteStatement: SQLiteStatement, + database: SQLiteDatabase): AndroidDatabaseStatement = + AndroidDatabaseStatement(sqLiteStatement, database) + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/BaseDatabaseHelper.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/BaseDatabaseHelper.java deleted file mode 100644 index 807056552..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/BaseDatabaseHelper.java +++ /dev/null @@ -1,233 +0,0 @@ -package com.raizlabs.android.dbflow.structure.database; - -import android.database.sqlite.SQLiteException; -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.config.DatabaseDefinition; -import com.raizlabs.android.dbflow.config.FlowLog; -import com.raizlabs.android.dbflow.config.FlowManager; -import com.raizlabs.android.dbflow.config.NaturalOrderComparator; -import com.raizlabs.android.dbflow.sql.QueryBuilder; -import com.raizlabs.android.dbflow.sql.migration.Migration; -import com.raizlabs.android.dbflow.structure.ModelAdapter; -import com.raizlabs.android.dbflow.structure.ModelViewAdapter; - -import java.io.BufferedReader; -import java.io.IOException; -import java.io.InputStream; -import java.io.InputStreamReader; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collections; -import java.util.HashMap; -import java.util.List; -import java.util.Map; - -/** - * Description: - */ -public class BaseDatabaseHelper { - - /** - * Location where the migration files should exist. - */ - public static final String MIGRATION_PATH = "migrations"; - private final DatabaseDefinition databaseDefinition; - - public BaseDatabaseHelper(@NonNull DatabaseDefinition databaseDefinition) { - this.databaseDefinition = databaseDefinition; - } - - @NonNull - public DatabaseDefinition getDatabaseDefinition() { - return databaseDefinition; - } - - public void onCreate(@NonNull DatabaseWrapper db) { - checkForeignKeySupport(db); - executeTableCreations(db); - executeMigrations(db, -1, db.getVersion()); - executeViewCreations(db); - } - - public void onUpgrade(@NonNull DatabaseWrapper db, int oldVersion, int newVersion) { - checkForeignKeySupport(db); - executeTableCreations(db); - executeMigrations(db, oldVersion, newVersion); - executeViewCreations(db); - } - - public void onOpen(@NonNull DatabaseWrapper db) { - checkForeignKeySupport(db); - } - - public void onDowngrade(@NonNull DatabaseWrapper db, int oldVersion, int newVersion) { - checkForeignKeySupport(db); - } - - /** - * If foreign keys are supported, we turn it on the DB specified. - */ - protected void checkForeignKeySupport(@NonNull DatabaseWrapper database) { - if (databaseDefinition.isForeignKeysSupported()) { - database.execSQL("PRAGMA foreign_keys=ON;"); - FlowLog.log(FlowLog.Level.I, "Foreign Keys supported. Enabling foreign key features."); - } - } - - protected void executeTableCreations(@NonNull final DatabaseWrapper database){ - try { - database.beginTransaction(); - List modelAdapters = databaseDefinition.getModelAdapters(); - for (ModelAdapter modelAdapter : modelAdapters) { - if (modelAdapter.createWithDatabase()) { - try { - database.execSQL(modelAdapter.getCreationQuery()); - } catch (SQLiteException e) { - FlowLog.logError(e); - } - } - } - database.setTransactionSuccessful(); - } finally { - database.endTransaction(); - } - } - - /** - * This method executes CREATE TABLE statements as well as CREATE VIEW on the database passed. - */ - protected void executeViewCreations(@NonNull final DatabaseWrapper database){ - - try { - database.beginTransaction(); - List modelViews = databaseDefinition.getModelViewAdapters(); - for (ModelViewAdapter modelView : modelViews) { - QueryBuilder queryBuilder = new QueryBuilder() - .append("CREATE VIEW IF NOT EXISTS") - .appendSpaceSeparated(modelView.getViewName()) - .append("AS ") - .append(modelView.getCreationQuery()); - try { - database.execSQL(queryBuilder.getQuery()); - } catch (SQLiteException e) { - FlowLog.logError(e); - } - } - database.setTransactionSuccessful(); - } finally { - database.endTransaction(); - } - } - - protected void executeMigrations(@NonNull final DatabaseWrapper db, - final int oldVersion, final int newVersion) { - - // will try migrations file or execute migrations from code - try { - final List files = Arrays.asList(FlowManager.getContext().getAssets().list( - MIGRATION_PATH + "/" + databaseDefinition.getDatabaseName())); - Collections.sort(files, new NaturalOrderComparator()); - - final Map> migrationFileMap = new HashMap<>(); - for (String file : files) { - try { - final Integer version = Integer.valueOf(file.replace(".sql", "")); - List fileList = migrationFileMap.get(version); - if (fileList == null) { - fileList = new ArrayList<>(); - migrationFileMap.put(version, fileList); - } - fileList.add(file); - } catch (NumberFormatException e) { - FlowLog.log(FlowLog.Level.W, "Skipping invalidly named file: " + file, e); - } - } - - final Map> migrationMap = databaseDefinition.getMigrations(); - - final int curVersion = oldVersion + 1; - - try { - db.beginTransaction(); - - // execute migrations in order, migration file first before wrapped migration classes. - for (int i = curVersion; i <= newVersion; i++) { - List migrationFiles = migrationFileMap.get(i); - if (migrationFiles != null) { - for (String migrationFile : migrationFiles) { - executeSqlScript(db, migrationFile); - FlowLog.log(FlowLog.Level.I, migrationFile + " executed successfully."); - } - } - - List migrationsList = migrationMap.get(i); - if (migrationsList != null) { - for (Migration migration : migrationsList) { - // before migration - migration.onPreMigrate(); - - // migrate - migration.migrate(db); - - // after migration cleanup - migration.onPostMigrate(); - FlowLog.log(FlowLog.Level.I, migration.getClass() + " executed successfully."); - } - } - } - db.setTransactionSuccessful(); - } finally { - db.endTransaction(); - } - } catch (IOException e) { - FlowLog.log(FlowLog.Level.E, "Failed to execute migrations.", e); - } - - } - - /** - * Supports multiline sql statements with ended with the standard ";" - * - * @param db The database to run it on - * @param file the file name in assets/migrations that we read from - */ - private void executeSqlScript(@NonNull DatabaseWrapper db, - @NonNull String file) { - try { - final InputStream input = FlowManager.getContext().getAssets().open(MIGRATION_PATH + "/" + getDatabaseDefinition().getDatabaseName() + "/" + file); - final BufferedReader reader = new BufferedReader(new InputStreamReader(input)); - String line; - - // ends line with SQL - String querySuffix = ";"; - - // standard java comments - String queryCommentPrefix = "--"; - StringBuffer query = new StringBuffer(); - - while ((line = reader.readLine()) != null) { - line = line.trim(); - boolean isEndOfQuery = line.endsWith(querySuffix); - if (line.startsWith(queryCommentPrefix)) { - continue; - } - if (isEndOfQuery) { - line = line.substring(0, line.length() - querySuffix.length()); - } - query.append(" ").append(line); - if (isEndOfQuery) { - db.execSQL(query.toString()); - query = new StringBuffer(); - } - } - - String queryString = query.toString(); - if (queryString.trim().length() > 0) { - db.execSQL(queryString); - } - } catch (IOException e) { - FlowLog.log(FlowLog.Level.E, "Failed to execute " + file, e); - } - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/BaseDatabaseHelper.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/BaseDatabaseHelper.kt new file mode 100644 index 000000000..ebd096f78 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/BaseDatabaseHelper.kt @@ -0,0 +1,217 @@ +package com.raizlabs.android.dbflow.structure.database + +import android.database.sqlite.SQLiteException +import com.raizlabs.android.dbflow.config.DatabaseDefinition +import com.raizlabs.android.dbflow.config.FlowLog +import com.raizlabs.android.dbflow.config.FlowManager +import com.raizlabs.android.dbflow.config.NaturalOrderComparator +import com.raizlabs.android.dbflow.sql.QueryBuilder +import java.io.BufferedReader +import java.io.IOException +import java.io.InputStreamReader +import java.util.* + +/** + * Description: + */ +open class BaseDatabaseHelper(val databaseDefinition: DatabaseDefinition) { + + open fun onCreate(db: DatabaseWrapper) { + checkForeignKeySupport(db) + executeTableCreations(db) + executeMigrations(db, -1, db.version) + executeViewCreations(db) + } + + open fun onUpgrade(db: DatabaseWrapper, oldVersion: Int, newVersion: Int) { + checkForeignKeySupport(db) + executeTableCreations(db) + executeMigrations(db, oldVersion, newVersion) + executeViewCreations(db) + } + + open fun onOpen(db: DatabaseWrapper) { + checkForeignKeySupport(db) + } + + open fun onDowngrade(db: DatabaseWrapper, oldVersion: Int, newVersion: Int) { + checkForeignKeySupport(db) + } + + /** + * If foreign keys are supported, we turn it on the DB specified. + */ + protected fun checkForeignKeySupport(database: DatabaseWrapper) { + if (databaseDefinition.isForeignKeysSupported) { + database.execSQL("PRAGMA foreign_keys=ON;") + FlowLog.log(FlowLog.Level.I, "Foreign Keys supported. Enabling foreign key features.") + } + } + + protected fun executeTableCreations(database: DatabaseWrapper) { + try { + database.beginTransaction() + val modelAdapters = databaseDefinition.getModelAdapters() + for (modelAdapter in modelAdapters) { + if (modelAdapter.createWithDatabase()) { + try { + database.execSQL(modelAdapter.creationQuery) + } catch (e: SQLiteException) { + FlowLog.logError(e) + } + + } + } + database.setTransactionSuccessful() + } finally { + database.endTransaction() + } + } + + /** + * This method executes CREATE TABLE statements as well as CREATE VIEW on the database passed. + */ + protected fun executeViewCreations(database: DatabaseWrapper) { + + try { + database.beginTransaction() + val modelViews = databaseDefinition.modelViewAdapters + for (modelView in modelViews) { + val queryBuilder = QueryBuilder() + .append("CREATE VIEW IF NOT EXISTS") + .appendSpaceSeparated(modelView.viewName) + .append("AS ") + .append(modelView.creationQuery) + try { + database.execSQL(queryBuilder.query) + } catch (e: SQLiteException) { + FlowLog.logError(e) + } + + } + database.setTransactionSuccessful() + } finally { + database.endTransaction() + } + } + + protected fun executeMigrations(db: DatabaseWrapper, + oldVersion: Int, newVersion: Int) { + + // will try migrations file or execute migrations from code + try { + val files = Arrays.asList(*FlowManager.context.assets.list( + MIGRATION_PATH + "/" + databaseDefinition.databaseName)) + Collections.sort(files, NaturalOrderComparator()) + + val migrationFileMap = hashMapOf>() + for (file in files) { + try { + val version = Integer.valueOf(file.replace(".sql", "")) + var fileList: MutableList? = migrationFileMap[version] + if (fileList == null) { + fileList = arrayListOf() + migrationFileMap.put(version, fileList) + } + fileList.add(file) + } catch (e: NumberFormatException) { + FlowLog.log(FlowLog.Level.W, "Skipping invalidly named file: " + file, e) + } + + } + + val migrationMap = databaseDefinition.migrations + + val curVersion = oldVersion + 1 + + try { + db.beginTransaction() + + // execute migrations in order, migration file first before wrapped migration classes. + for (i in curVersion..newVersion) { + val migrationFiles = migrationFileMap[i] + if (migrationFiles != null) { + for (migrationFile in migrationFiles) { + executeSqlScript(db, migrationFile) + FlowLog.log(FlowLog.Level.I, migrationFile + " executed successfully.") + } + } + + val migrationsList = migrationMap[i] + if (migrationsList != null) { + for (migration in migrationsList) { + // before migration + migration.onPreMigrate() + + // migrate + migration.migrate(db) + + // after migration cleanup + migration.onPostMigrate() + FlowLog.log(FlowLog.Level.I, migration.javaClass.toString() + " executed successfully.") + } + } + } + db.setTransactionSuccessful() + } finally { + db.endTransaction() + } + } catch (e: IOException) { + FlowLog.log(FlowLog.Level.E, "Failed to execute migrations.", e) + } + + } + + /** + * Supports multiline sql statements with ended with the standard ";" + * + * @param db The database to run it on + * @param file the file name in assets/migrations that we read from + */ + private fun executeSqlScript(db: DatabaseWrapper, + file: String) { + try { + val input = FlowManager.context.assets.open("$MIGRATION_PATH/${databaseDefinition.databaseName}/$file") + val reader = BufferedReader(InputStreamReader(input)) + + // ends line with SQL + val querySuffix = ";" + + // standard java comments + val queryCommentPrefix = "--" + var query = StringBuffer() + + reader.forEachLine { fileLine -> + var line = fileLine.trim { it <= ' ' } + val isEndOfQuery = line.endsWith(querySuffix) + if (line.startsWith(queryCommentPrefix)) { + return@forEachLine + } + if (isEndOfQuery) { + line = line.substring(0, line.length - querySuffix.length) + } + query.append(" ").append(line) + if (isEndOfQuery) { + db.execSQL(query.toString()) + query = StringBuffer() + } + } + + val queryString = query.toString() + if (queryString.trim { it <= ' ' }.isNotEmpty()) { + db.execSQL(queryString) + } + } catch (e: IOException) { + FlowLog.log(FlowLog.Level.E, "Failed to execute " + file, e) + } + } + + companion object { + + /** + * Location where the migration files should exist. + */ + @JvmStatic + val MIGRATION_PATH = "migrations" + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/BaseDatabaseStatement.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/BaseDatabaseStatement.java deleted file mode 100644 index 4918b70bb..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/BaseDatabaseStatement.java +++ /dev/null @@ -1,60 +0,0 @@ -package com.raizlabs.android.dbflow.structure.database; - -import android.support.annotation.Nullable; - -/** - * Description: Default implementation for some {@link DatabaseStatement} methods. - */ -public abstract class BaseDatabaseStatement implements DatabaseStatement { - - @Override - public void bindStringOrNull(int index, @Nullable String s) { - if (s != null) { - bindString(index, s); - } else { - bindNull(index); - } - } - - @Override - public void bindNumber(int index, @Nullable Number number) { - bindNumberOrNull(index, number); - } - - @Override - public void bindNumberOrNull(int index, @Nullable Number number) { - if (number != null) { - bindLong(index, number.longValue()); - } else { - bindNull(index); - } - } - - @Override - public void bindDoubleOrNull(int index, @Nullable Double aDouble) { - if (aDouble != null) { - bindDouble(index, aDouble); - } else { - bindNull(index); - } - } - - @Override - public void bindFloatOrNull(int index, @Nullable Float aFloat) { - if (aFloat != null) { - bindDouble(index, aFloat); - } else { - bindNull(index); - } - } - - @Override - public void bindBlobOrNull(int index, @Nullable byte[] bytes) { - if (bytes != null) { - bindBlob(index, bytes); - } else { - bindNull(index); - } - } - -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/BaseDatabaseStatement.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/BaseDatabaseStatement.kt new file mode 100644 index 000000000..8d707c262 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/BaseDatabaseStatement.kt @@ -0,0 +1,52 @@ +package com.raizlabs.android.dbflow.structure.database + +/** + * Description: Default implementation for some [DatabaseStatement] methods. + */ +abstract class BaseDatabaseStatement : DatabaseStatement { + + override fun bindStringOrNull(index: Int, s: String?) { + if (s != null) { + bindString(index, s) + } else { + bindNull(index) + } + } + + override fun bindNumber(index: Int, number: Number?) { + bindNumberOrNull(index, number) + } + + override fun bindNumberOrNull(index: Int, number: Number?) { + if (number != null) { + bindLong(index, number.toLong()) + } else { + bindNull(index) + } + } + + override fun bindDoubleOrNull(index: Int, aDouble: Double?) { + if (aDouble != null) { + bindDouble(index, aDouble) + } else { + bindNull(index) + } + } + + override fun bindFloatOrNull(index: Int, aFloat: Float?) { + if (aFloat != null) { + bindDouble(index, aFloat.toDouble()) + } else { + bindNull(index) + } + } + + override fun bindBlobOrNull(index: Int, bytes: ByteArray?) { + if (bytes != null) { + bindBlob(index, bytes) + } else { + bindNull(index) + } + } + +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/ContentValueExtensions.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/ContentValueExtensions.kt new file mode 100644 index 000000000..40c816e5d --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/ContentValueExtensions.kt @@ -0,0 +1,24 @@ +package com.raizlabs.android.dbflow.structure.database + +import android.content.ContentValues + +operator fun ContentValues.set(key: String, value: String?) = put(key, value) + +operator fun ContentValues.set(key: String, value: Byte?) = put(key, value) + +operator fun ContentValues.set(key: String, value: Short?) = put(key, value) + +operator fun ContentValues.set(key: String, value: Int?) = put(key, value) + +operator fun ContentValues.set(key: String, value: Long?) = put(key, value) + +operator fun ContentValues.set(key: String, value: Float?) = put(key, value) + +operator fun ContentValues.set(key: String, value: Double?) = put(key, value) + +operator fun ContentValues.set(key: String, value: Boolean?) = put(key, value) + +operator fun ContentValues.set(key: String, value: ByteArray?) = put(key, value) + + + diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseHelperDelegate.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseHelperDelegate.java deleted file mode 100644 index edfb62be7..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseHelperDelegate.java +++ /dev/null @@ -1,316 +0,0 @@ -package com.raizlabs.android.dbflow.structure.database; - -import android.content.Context; -import android.database.sqlite.SQLiteOpenHelper; -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.config.DatabaseDefinition; -import com.raizlabs.android.dbflow.config.FlowLog; -import com.raizlabs.android.dbflow.config.FlowManager; -import com.raizlabs.android.dbflow.structure.database.transaction.DefaultTransactionQueue; -import com.raizlabs.android.dbflow.structure.database.transaction.ITransaction; - -import java.io.File; -import java.io.FileInputStream; -import java.io.FileOutputStream; -import java.io.IOException; -import java.io.InputStream; -import java.io.OutputStream; - -/** - * Description: An abstraction from some parts of the {@link SQLiteOpenHelper} where this can be - * used in other helper class definitions. - */ -public class DatabaseHelperDelegate extends BaseDatabaseHelper { - - public static final String TEMP_DB_NAME = "temp-"; - - public static String getTempDbFileName(DatabaseDefinition databaseDefinition) { - return TEMP_DB_NAME + databaseDefinition.getDatabaseName() + ".db"; - } - - private DatabaseHelperListener databaseHelperListener; - - @Nullable private final OpenHelper backupHelper; - - public DatabaseHelperDelegate(DatabaseHelperListener databaseHelperListener, - DatabaseDefinition databaseDefinition, @Nullable OpenHelper backupHelper) { - super(databaseDefinition); - this.databaseHelperListener = databaseHelperListener; - this.backupHelper = backupHelper; - } - - public void performRestoreFromBackup() { - movePrepackagedDB(getDatabaseDefinition().getDatabaseFileName(), - getDatabaseDefinition().getDatabaseFileName()); - - if (getDatabaseDefinition().backupEnabled()) { - if (backupHelper == null) { - throw new IllegalStateException("the passed backup helper was null, even though backup is enabled. " + - "Ensure that its passed in."); - } - restoreDatabase(getTempDbFileName(), getDatabaseDefinition().getDatabaseFileName()); - backupHelper.getDatabase(); - } - } - - /** - * @param databaseHelperListener Listens for operations the DB and allow you to provide extra - * functionality. - */ - public void setDatabaseHelperListener(DatabaseHelperListener databaseHelperListener) { - this.databaseHelperListener = databaseHelperListener; - } - - @Override - public void onCreate(@NonNull DatabaseWrapper db) { - if (databaseHelperListener != null) { - databaseHelperListener.onCreate(db); - } - super.onCreate(db); - } - - @Override - public void onUpgrade(@NonNull DatabaseWrapper db, int oldVersion, int newVersion) { - if (databaseHelperListener != null) { - databaseHelperListener.onUpgrade(db, oldVersion, newVersion); - } - super.onUpgrade(db, oldVersion, newVersion); - } - - @Override - public void onOpen(@NonNull DatabaseWrapper db) { - if (databaseHelperListener != null) { - databaseHelperListener.onOpen(db); - } - super.onOpen(db); - } - - @Override - public void onDowngrade(@NonNull DatabaseWrapper db, int oldVersion, int newVersion) { - if (databaseHelperListener != null) { - databaseHelperListener.onDowngrade(db, oldVersion, newVersion); - } - super.onDowngrade(db, oldVersion, newVersion); - } - - /** - * @return the temporary database file name for when we have backups enabled - * {@link DatabaseDefinition#backupEnabled()} - */ - private String getTempDbFileName() { - return getTempDbFileName(getDatabaseDefinition()); - } - - /** - * Copies over the prepackaged DB into the main DB then deletes the existing DB to save storage space. If - * we have a backup that exists - * - * @param databaseName The name of the database to copy over - * @param prepackagedName The name of the prepackaged db file - */ - public void movePrepackagedDB(String databaseName, String prepackagedName) { - final File dbPath = FlowManager.getContext().getDatabasePath(databaseName); - - // If the database already exists, and is ok return - if (dbPath.exists() && (!getDatabaseDefinition().areConsistencyChecksEnabled() || - (getDatabaseDefinition().areConsistencyChecksEnabled() - && isDatabaseIntegrityOk(getWritableDatabase())))) { - return; - } - - // Make sure we have a path to the file - dbPath.getParentFile().mkdirs(); - - // Try to copy database file - try { - // check existing and use that as backup - File existingDb = FlowManager.getContext().getDatabasePath(getTempDbFileName()); - InputStream inputStream; - // if it exists and the integrity is ok we use backup as the main DB is no longer valid - if (existingDb.exists() && (!getDatabaseDefinition().backupEnabled() || getDatabaseDefinition().backupEnabled() - && backupHelper != null && isDatabaseIntegrityOk(backupHelper.getDatabase()))) { - inputStream = new FileInputStream(existingDb); - } else { - inputStream = FlowManager.getContext().getAssets().open(prepackagedName); - } - writeDB(dbPath, inputStream); - - } catch (IOException e) { - FlowLog.log(FlowLog.Level.W, "Failed to open file", e); - } - } - - /** - * Pulled partially from code, it runs a "PRAGMA quick_check(1)" to see if the database is ok. - * This method will {@link #restoreBackUp()} if they are enabled on the database if this check fails. So - * use with caution and ensure that you backup the database often! - * - * @return true if the database is ok, false if the consistency has been compromised. - */ - public boolean isDatabaseIntegrityOk() { - return isDatabaseIntegrityOk(getWritableDatabase()); - } - - /** - * Pulled partially from code, it runs a "PRAGMA quick_check(1)" to see if the database is ok. - * This method will {@link #restoreBackUp()} if they are enabled on the database if this check fails. So - * use with caution and ensure that you backup the database often! - * - * @return true if the database is ok, false if the consistency has been compromised. - */ - public boolean isDatabaseIntegrityOk(DatabaseWrapper databaseWrapper) { - boolean integrityOk = true; - - DatabaseStatement statement = null; - try { - statement = databaseWrapper.compileStatement("PRAGMA quick_check(1)"); - String result = statement.simpleQueryForString(); - if (!result.equalsIgnoreCase("ok")) { - // integrity_checker failed on main or attached databases - FlowLog.log(FlowLog.Level.E, "PRAGMA integrity_check on " + - getDatabaseDefinition().getDatabaseName() + " returned: " + result); - - integrityOk = false; - - if (getDatabaseDefinition().backupEnabled()) { - integrityOk = restoreBackUp(); - } - } - } finally { - if (statement != null) { - statement.close(); - } - } - return integrityOk; - } - - /** - * If integrity check fails, this method will use the backup db to fix itself. In order to prevent - * loss of data, please backup often! - */ - public boolean restoreBackUp() { - boolean success = true; - - File db = FlowManager.getContext().getDatabasePath(TEMP_DB_NAME + getDatabaseDefinition().getDatabaseName()); - File corrupt = FlowManager.getContext().getDatabasePath(getDatabaseDefinition().getDatabaseName()); - if (corrupt.delete()) { - try { - writeDB(corrupt, new FileInputStream(db)); - } catch (IOException e) { - FlowLog.logError(e); - success = false; - } - } else { - FlowLog.log(FlowLog.Level.E, "Failed to delete DB"); - } - return success; - } - - /** - * Writes the {@link InputStream} of the existing db to the file specified. - * - * @param dbPath The file to write to. - * @param existingDB The existing database file's input stream¬ - * @throws IOException - */ - private void writeDB(File dbPath, InputStream existingDB) throws IOException { - final OutputStream output = new FileOutputStream(dbPath); - - byte[] buffer = new byte[1024]; - int length; - - while ((length = existingDB.read(buffer)) > 0) { - output.write(buffer, 0, length); - } - - output.flush(); - output.close(); - existingDB.close(); - } - - /** - * Will use the already existing app database if {@link DatabaseDefinition#backupEnabled()} is true. If the existing - * is not there we will try to use the prepackaged database for that purpose. - * - * @param databaseName The name of the database to restore - * @param prepackagedName The name of the prepackaged db file - */ - public void restoreDatabase(String databaseName, String prepackagedName) { - final File dbPath = FlowManager.getContext().getDatabasePath(databaseName); - - // If the database already exists, return - if (dbPath.exists()) { - return; - } - - // Make sure we have a path to the file - dbPath.getParentFile().mkdirs(); - - // Try to copy database file - try { - // check existing and use that as backup - File existingDb = FlowManager.getContext().getDatabasePath(getDatabaseDefinition().getDatabaseFileName()); - InputStream inputStream; - // if it exists and the integrity is ok - if (existingDb.exists() && (getDatabaseDefinition().backupEnabled() - && backupHelper != null && isDatabaseIntegrityOk(backupHelper.getDatabase()))) { - inputStream = new FileInputStream(existingDb); - } else { - inputStream = FlowManager.getContext().getAssets().open(prepackagedName); - } - writeDB(dbPath, inputStream); - } catch (IOException e) { - FlowLog.logError(e); - } - } - - - /** - * Saves the database as a backup on the {@link DefaultTransactionQueue}. - * This will create a THIRD database to use as a backup to the backup in case somehow the overwrite fails. - */ - public void backupDB() { - if (!getDatabaseDefinition().backupEnabled() || !getDatabaseDefinition().areConsistencyChecksEnabled()) { - throw new IllegalStateException("Backups are not enabled for : " + getDatabaseDefinition().getDatabaseName() + ". Please consider adding " + - "both backupEnabled and consistency checks enabled to the Database annotation"); - } - - getDatabaseDefinition().beginTransactionAsync(new ITransaction() { - @SuppressWarnings("ResultOfMethodCallIgnored") - @Override - public void execute(DatabaseWrapper databaseWrapper) { - Context context = FlowManager.getContext(); - File backup = context.getDatabasePath(getTempDbFileName()); - File temp = context.getDatabasePath(TEMP_DB_NAME + "-2-" + getDatabaseDefinition().getDatabaseFileName()); - - // if exists we want to delete it before rename - if (temp.exists()) { - temp.delete(); - } - - backup.renameTo(temp); - if (backup.exists()) { - backup.delete(); - } - File existing = context.getDatabasePath(getDatabaseDefinition().getDatabaseFileName()); - - try { - backup.getParentFile().mkdirs(); - writeDB(backup, new FileInputStream(existing)); - - temp.delete(); - } catch (Exception e) { - FlowLog.logError(e); - - } - } - }).build().execute(); - - } - - public DatabaseWrapper getWritableDatabase() { - return getDatabaseDefinition().getWritableDatabase(); - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseHelperDelegate.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseHelperDelegate.kt new file mode 100644 index 000000000..87e52d938 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseHelperDelegate.kt @@ -0,0 +1,299 @@ +package com.raizlabs.android.dbflow.structure.database + +import android.database.sqlite.SQLiteOpenHelper +import com.raizlabs.android.dbflow.config.DatabaseDefinition +import com.raizlabs.android.dbflow.config.FlowLog +import com.raizlabs.android.dbflow.config.FlowManager +import com.raizlabs.android.dbflow.structure.database.transaction.DefaultTransactionQueue +import com.raizlabs.android.dbflow.structure.database.transaction.ITransaction +import java.io.File +import java.io.FileInputStream +import java.io.FileOutputStream +import java.io.IOException +import java.io.InputStream + +/** + * Description: An abstraction from some parts of the [SQLiteOpenHelper] where this can be + * used in other helper class definitions. + */ +class DatabaseHelperDelegate( + private var databaseHelperListener: DatabaseHelperListener?, + databaseDefinition: DatabaseDefinition, + private val backupHelper: OpenHelper?) + : BaseDatabaseHelper(databaseDefinition) { + + /** + * @return the temporary database file name for when we have backups enabled + * [DatabaseDefinition.backupEnabled] + */ + private val tempDbFileName: String + get() = getTempDbFileName(databaseDefinition) + + /** + * Pulled partially from code, it runs a "PRAGMA quick_check(1)" to see if the database is ok. + * This method will [.restoreBackUp] if they are enabled on the database if this check fails. So + * use with caution and ensure that you backup the database often! + * + * @return true if the database is ok, false if the consistency has been compromised. + */ + val isDatabaseIntegrityOk: Boolean + get() = isDatabaseIntegrityOk(writableDatabase) + + val writableDatabase: DatabaseWrapper + get() = databaseDefinition.writableDatabase + + fun performRestoreFromBackup() { + movePrepackagedDB(databaseDefinition.databaseFileName, + databaseDefinition.databaseFileName) + + if (databaseDefinition.backupEnabled()) { + if (backupHelper == null) { + throw IllegalStateException("the passed backup helper was null, even though backup is enabled. " + "Ensure that its passed in.") + } + restoreDatabase(tempDbFileName, databaseDefinition.databaseFileName) + backupHelper.database + } + } + + /** + * @param databaseHelperListener Listens for operations the DB and allow you to provide extra + * functionality. + */ + fun setDatabaseHelperListener(databaseHelperListener: DatabaseHelperListener) { + this.databaseHelperListener = databaseHelperListener + } + + override fun onCreate(db: DatabaseWrapper) { + if (databaseHelperListener != null) { + databaseHelperListener!!.onCreate(db) + } + super.onCreate(db) + } + + override fun onUpgrade(db: DatabaseWrapper, oldVersion: Int, newVersion: Int) { + if (databaseHelperListener != null) { + databaseHelperListener!!.onUpgrade(db, oldVersion, newVersion) + } + super.onUpgrade(db, oldVersion, newVersion) + } + + override fun onOpen(db: DatabaseWrapper) { + if (databaseHelperListener != null) { + databaseHelperListener!!.onOpen(db) + } + super.onOpen(db) + } + + override fun onDowngrade(db: DatabaseWrapper, oldVersion: Int, newVersion: Int) { + if (databaseHelperListener != null) { + databaseHelperListener!!.onDowngrade(db, oldVersion, newVersion) + } + super.onDowngrade(db, oldVersion, newVersion) + } + + /** + * Copies over the prepackaged DB into the main DB then deletes the existing DB to save storage space. If + * we have a backup that exists + * + * @param databaseName The name of the database to copy over + * @param prepackagedName The name of the prepackaged db file + */ + fun movePrepackagedDB(databaseName: String, prepackagedName: String) { + val dbPath = FlowManager.context.getDatabasePath(databaseName) + + // If the database already exists, and is ok return + if (dbPath.exists() && (!databaseDefinition.areConsistencyChecksEnabled() || databaseDefinition.areConsistencyChecksEnabled() && isDatabaseIntegrityOk(writableDatabase))) { + return + } + + // Make sure we have a path to the file + dbPath.parentFile.mkdirs() + + // Try to copy database file + try { + // check existing and use that as backup + val existingDb = FlowManager.context.getDatabasePath(tempDbFileName) + val inputStream: InputStream + // if it exists and the integrity is ok we use backup as the main DB is no longer valid + if (existingDb.exists() && (!databaseDefinition.backupEnabled() || (databaseDefinition.backupEnabled() + && backupHelper != null && isDatabaseIntegrityOk(backupHelper.database)))) { + inputStream = FileInputStream(existingDb) + } else { + inputStream = FlowManager.context.assets.open(prepackagedName) + } + writeDB(dbPath, inputStream) + + } catch (e: IOException) { + FlowLog.log(FlowLog.Level.W, "Failed to open file", e) + } + + } + + /** + * Pulled partially from code, it runs a "PRAGMA quick_check(1)" to see if the database is ok. + * This method will [.restoreBackUp] if they are enabled on the database if this check fails. So + * use with caution and ensure that you backup the database often! + * + * @return true if the database is ok, false if the consistency has been compromised. + */ + fun isDatabaseIntegrityOk(databaseWrapper: DatabaseWrapper): Boolean { + var integrityOk = true + + var statement: DatabaseStatement? = null + try { + statement = databaseWrapper.compileStatement("PRAGMA quick_check(1)") + val result = statement.simpleQueryForString() + if (!result!!.equals("ok", ignoreCase = true)) { + // integrity_checker failed on main or attached databases + FlowLog.log(FlowLog.Level.E, "PRAGMA integrity_check on " + + databaseDefinition.databaseName + " returned: " + result) + + integrityOk = false + + if (databaseDefinition.backupEnabled()) { + integrityOk = restoreBackUp() + } + } + } finally { + if (statement != null) { + statement.close() + } + } + return integrityOk + } + + /** + * If integrity check fails, this method will use the backup db to fix itself. In order to prevent + * loss of data, please backup often! + */ + fun restoreBackUp(): Boolean { + var success = true + + val db = FlowManager.context.getDatabasePath(TEMP_DB_NAME + databaseDefinition.databaseName) + val corrupt = FlowManager.context.getDatabasePath(databaseDefinition.databaseName) + if (corrupt.delete()) { + try { + writeDB(corrupt, FileInputStream(db)) + } catch (e: IOException) { + FlowLog.logError(e) + success = false + } + + } else { + FlowLog.log(FlowLog.Level.E, "Failed to delete DB") + } + return success + } + + /** + * Writes the [InputStream] of the existing db to the file specified. + * + * @param dbPath The file to write to. + * @param existingDB The existing database file's input stream¬ + * @throws IOException + */ + @Throws(IOException::class) + private fun writeDB(dbPath: File, existingDB: InputStream) { + val output = FileOutputStream(dbPath) + + val buffer = ByteArray(1024) + var length: Int = existingDB.read(buffer) + while (length > 0) { + output.write(buffer, 0, length) + length = existingDB.read(buffer) + } + + output.flush() + output.close() + existingDB.close() + } + + /** + * Will use the already existing app database if [DatabaseDefinition.backupEnabled] is true. If the existing + * is not there we will try to use the prepackaged database for that purpose. + * + * @param databaseName The name of the database to restore + * @param prepackagedName The name of the prepackaged db file + */ + fun restoreDatabase(databaseName: String, prepackagedName: String) { + val dbPath = FlowManager.context.getDatabasePath(databaseName) + + // If the database already exists, return + if (dbPath.exists()) { + return + } + + // Make sure we have a path to the file + dbPath.parentFile.mkdirs() + + // Try to copy database file + try { + // check existing and use that as backup + val existingDb = FlowManager.context.getDatabasePath(databaseDefinition.databaseFileName) + val inputStream: InputStream + // if it exists and the integrity is ok + if (existingDb.exists() && (databaseDefinition.backupEnabled() + && backupHelper != null && isDatabaseIntegrityOk(backupHelper.database))) { + inputStream = FileInputStream(existingDb) + } else { + inputStream = FlowManager.context.assets.open(prepackagedName) + } + writeDB(dbPath, inputStream) + } catch (e: IOException) { + FlowLog.logError(e) + } + + } + + + /** + * Saves the database as a backup on the [DefaultTransactionQueue]. + * This will create a THIRD database to use as a backup to the backup in case somehow the overwrite fails. + */ + fun backupDB() { + if (!databaseDefinition.backupEnabled() || !databaseDefinition.areConsistencyChecksEnabled()) { + throw IllegalStateException("Backups are not enabled for : " + databaseDefinition.databaseName + ". Please consider adding " + + "both backupEnabled and consistency checks enabled to the Database annotation") + } + + databaseDefinition.beginTransactionAsync(object : ITransaction { + override fun execute(databaseWrapper: DatabaseWrapper) { + val context = FlowManager.context + val backup = context.getDatabasePath(tempDbFileName) + val temp = context.getDatabasePath(TEMP_DB_NAME + "-2-" + databaseDefinition.databaseFileName) + + // if exists we want to delete it before rename + if (temp.exists()) { + temp.delete() + } + + backup.renameTo(temp) + if (backup.exists()) { + backup.delete() + } + val existing = context.getDatabasePath(databaseDefinition.databaseFileName) + + try { + backup.parentFile.mkdirs() + writeDB(backup, FileInputStream(existing)) + + temp.delete() + } catch (e: Exception) { + FlowLog.logError(e) + + } + + } + }).build().execute() + + } + + companion object { + + val TEMP_DB_NAME = "temp-" + + fun getTempDbFileName(databaseDefinition: DatabaseDefinition): String { + return TEMP_DB_NAME + databaseDefinition.databaseName + ".db" + } + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseHelperListener.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseHelperListener.kt similarity index 59% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseHelperListener.java rename to dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseHelperListener.kt index 7d787642a..122dc24dc 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseHelperListener.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseHelperListener.kt @@ -1,25 +1,23 @@ -package com.raizlabs.android.dbflow.structure.database; - -import android.support.annotation.NonNull; +package com.raizlabs.android.dbflow.structure.database /** - * Description: Provides callbacks for {@link OpenHelper} methods + * Description: Provides callbacks for [OpenHelper] methods */ -public interface DatabaseHelperListener { +interface DatabaseHelperListener { /** * Called when the DB is opened * * @param database The database that is opened */ - void onOpen(@NonNull DatabaseWrapper database); + fun onOpen(database: DatabaseWrapper) /** * Called when the DB is created * * @param database The database that is created */ - void onCreate(@NonNull DatabaseWrapper database); + fun onCreate(database: DatabaseWrapper) /** * Called when the DB is upgraded. @@ -28,7 +26,7 @@ public interface DatabaseHelperListener { * @param oldVersion The previous DB version * @param newVersion The new DB version */ - void onUpgrade(@NonNull DatabaseWrapper database, int oldVersion, int newVersion); + fun onUpgrade(database: DatabaseWrapper, oldVersion: Int, newVersion: Int) /** * Called when DB is downgraded. Note that this may not be supported by all implementations of the DB. @@ -37,5 +35,5 @@ public interface DatabaseHelperListener { * @param oldVersion The old. higher version. * @param newVersion The new lower version. */ - void onDowngrade(@NonNull DatabaseWrapper databaseWrapper, int oldVersion, int newVersion); + fun onDowngrade(databaseWrapper: DatabaseWrapper, oldVersion: Int, newVersion: Int) } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseStatement.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseStatement.java deleted file mode 100644 index 99c1c9d06..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseStatement.java +++ /dev/null @@ -1,47 +0,0 @@ -package com.raizlabs.android.dbflow.structure.database; - -import android.database.sqlite.SQLiteStatement; -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -/** - * Description: Abstracts out a {@link SQLiteStatement}. - */ -public interface DatabaseStatement { - - long executeUpdateDelete(); - - void execute(); - - void close(); - - long simpleQueryForLong(); - - @Nullable - String simpleQueryForString(); - - long executeInsert(); - - void bindString(int index, String s); - - void bindStringOrNull(int index, @Nullable String s); - - void bindNull(int index); - - void bindLong(int index, long aLong); - - void bindNumber(int index, @Nullable Number number); - - void bindNumberOrNull(int index, @Nullable Number number); - - void bindDouble(int index, double aDouble); - - void bindDoubleOrNull(int index, @Nullable Double aDouble); - - void bindFloatOrNull(int index, @Nullable Float aFloat); - - void bindBlob(int index, byte[] bytes); - - void bindBlobOrNull(int index, @Nullable byte[] bytes); - -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseStatement.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseStatement.kt new file mode 100644 index 000000000..6e9779763 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseStatement.kt @@ -0,0 +1,44 @@ +package com.raizlabs.android.dbflow.structure.database + +import android.database.sqlite.SQLiteStatement + +/** + * Description: Abstracts out a [SQLiteStatement]. + */ +interface DatabaseStatement { + + fun executeUpdateDelete(): Long + + fun execute() + + fun close() + + fun simpleQueryForLong(): Long + + fun simpleQueryForString(): String? + + fun executeInsert(): Long + + fun bindString(index: Int, s: String) + + fun bindStringOrNull(index: Int, s: String?) + + fun bindNull(index: Int) + + fun bindLong(index: Int, aLong: Long) + + fun bindNumber(index: Int, number: Number?) + + fun bindNumberOrNull(index: Int, number: Number?) + + fun bindDouble(index: Int, aDouble: Double) + + fun bindDoubleOrNull(index: Int, aDouble: Double?) + + fun bindFloatOrNull(index: Int, aFloat: Float?) + + fun bindBlob(index: Int, bytes: ByteArray) + + fun bindBlobOrNull(index: Int, bytes: ByteArray?) + +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseStatementWrapper.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseStatementWrapper.java deleted file mode 100644 index 9427d2179..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseStatementWrapper.java +++ /dev/null @@ -1,90 +0,0 @@ -package com.raizlabs.android.dbflow.structure.database; - -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.runtime.NotifyDistributor; -import com.raizlabs.android.dbflow.sql.language.BaseQueriable; - -/** - * Description: Delegates all of its calls to the contained {@link DatabaseStatement}, while - * providing notification methods for when operations occur. - */ -public class DatabaseStatementWrapper extends BaseDatabaseStatement { - - @NonNull - private final DatabaseStatement databaseStatement; - private final BaseQueriable modelQueriable; - - public DatabaseStatementWrapper(@NonNull DatabaseStatement databaseStatement, - @NonNull BaseQueriable modelQueriable) { - this.databaseStatement = databaseStatement; - this.modelQueriable = modelQueriable; - } - - @Override - public long executeUpdateDelete() { - long affected = databaseStatement.executeUpdateDelete(); - if (affected > 0) { - NotifyDistributor.Companion.get().notifyTableChanged(modelQueriable.getTable(), - modelQueriable.getPrimaryAction()); - } - return affected; - } - - @Override - public void execute() { - databaseStatement.execute(); - } - - @Override - public void close() { - databaseStatement.close(); - } - - @Override - public long simpleQueryForLong() { - return databaseStatement.simpleQueryForLong(); - } - - @Nullable - @Override - public String simpleQueryForString() { - return databaseStatement.simpleQueryForString(); - } - - @Override - public long executeInsert() { - long affected = databaseStatement.executeInsert(); - if (affected > 0) { - NotifyDistributor.Companion.get().notifyTableChanged(modelQueriable.getTable(), - modelQueriable.getPrimaryAction()); - } - return affected; - } - - @Override - public void bindString(int index, String s) { - databaseStatement.bindString(index, s); - } - - @Override - public void bindNull(int index) { - databaseStatement.bindNull(index); - } - - @Override - public void bindLong(int index, long aLong) { - databaseStatement.bindLong(index, aLong); - } - - @Override - public void bindDouble(int index, double aDouble) { - databaseStatement.bindDouble(index, aDouble); - } - - @Override - public void bindBlob(int index, byte[] bytes) { - databaseStatement.bindBlob(index, bytes); - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseStatementWrapper.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseStatementWrapper.kt new file mode 100644 index 000000000..fecf241de --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseStatementWrapper.kt @@ -0,0 +1,67 @@ +package com.raizlabs.android.dbflow.structure.database + +import com.raizlabs.android.dbflow.runtime.NotifyDistributor +import com.raizlabs.android.dbflow.sql.language.BaseQueriable + +/** + * Description: Delegates all of its calls to the contained [DatabaseStatement], while + * providing notification methods for when operations occur. + */ +class DatabaseStatementWrapper( + private val databaseStatement: DatabaseStatement, + private val modelQueriable: BaseQueriable) : BaseDatabaseStatement() { + + override fun executeUpdateDelete(): Long { + val affected = databaseStatement.executeUpdateDelete() + if (affected > 0) { + NotifyDistributor.get().notifyTableChanged(modelQueriable.table, + modelQueriable.primaryAction) + } + return affected + } + + override fun execute() { + databaseStatement.execute() + } + + override fun close() { + databaseStatement.close() + } + + override fun simpleQueryForLong(): Long { + return databaseStatement.simpleQueryForLong() + } + + override fun simpleQueryForString(): String? { + return databaseStatement.simpleQueryForString() + } + + override fun executeInsert(): Long { + val affected = databaseStatement.executeInsert() + if (affected > 0) { + NotifyDistributor.get().notifyTableChanged(modelQueriable.table, + modelQueriable.primaryAction) + } + return affected + } + + override fun bindString(index: Int, s: String) { + databaseStatement.bindString(index, s) + } + + override fun bindNull(index: Int) { + databaseStatement.bindNull(index) + } + + override fun bindLong(index: Int, aLong: Long) { + databaseStatement.bindLong(index, aLong) + } + + override fun bindDouble(index: Int, aDouble: Double) { + databaseStatement.bindDouble(index, aDouble) + } + + override fun bindBlob(index: Int, bytes: ByteArray) { + databaseStatement.bindBlob(index, bytes) + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseWrapper.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseWrapper.java deleted file mode 100644 index 8e7d8ffb2..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseWrapper.java +++ /dev/null @@ -1,45 +0,0 @@ -package com.raizlabs.android.dbflow.structure.database; - -import android.content.ContentValues; -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -/** - * Description: Provides a base implementation that wraps a database, so other database engines potentially can - * be used. - */ -public interface DatabaseWrapper { - - void execSQL(@NonNull String query); - - void beginTransaction(); - - void setTransactionSuccessful(); - - void endTransaction(); - - int getVersion(); - - @NonNull - DatabaseStatement compileStatement(@NonNull String rawQuery); - - @NonNull - FlowCursor rawQuery(@NonNull String query, @Nullable String[] selectionArgs); - - long updateWithOnConflict(@NonNull String tableName, - @NonNull ContentValues contentValues, - @Nullable String where, - @Nullable String[] whereArgs, int conflictAlgorithm); - - long insertWithOnConflict(@NonNull String tableName, - @Nullable String nullColumnHack, - @NonNull ContentValues values, - int sqLiteDatabaseAlgorithmInt); - - @NonNull - FlowCursor query(@NonNull String tableName, @Nullable String[] columns, @Nullable String selection, - @Nullable String[] selectionArgs, @Nullable String groupBy, - @Nullable String having, @Nullable String orderBy); - - int delete(@NonNull String tableName, @Nullable String whereClause, @Nullable String[] whereArgs); -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseWrapper.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseWrapper.kt new file mode 100644 index 000000000..c8e3f442d --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseWrapper.kt @@ -0,0 +1,40 @@ +package com.raizlabs.android.dbflow.structure.database + +import android.content.ContentValues + +/** + * Description: Provides a base implementation that wraps a database, so other database engines potentially can + * be used. + */ +interface DatabaseWrapper { + + val version: Int + + fun execSQL(query: String) + + fun beginTransaction() + + fun setTransactionSuccessful() + + fun endTransaction() + + fun compileStatement(rawQuery: String): DatabaseStatement + + fun rawQuery(query: String, selectionArgs: Array?): FlowCursor + + fun updateWithOnConflict(tableName: String, + contentValues: ContentValues, + where: String?, + whereArgs: Array?, conflictAlgorithm: Int): Long + + fun insertWithOnConflict(tableName: String, + nullColumnHack: String?, + values: ContentValues, + sqLiteDatabaseAlgorithmInt: Int): Long + + fun query(tableName: String, columns: Array?, selection: String?, + selectionArgs: Array?, groupBy: String?, + having: String?, orderBy: String?): FlowCursor + + fun delete(tableName: String, whereClause: String?, whereArgs: Array?): Int +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/FlowCursor.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/FlowCursor.java deleted file mode 100644 index 2f30379fd..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/FlowCursor.java +++ /dev/null @@ -1,293 +0,0 @@ -package com.raizlabs.android.dbflow.structure.database; - -import android.database.Cursor; -import android.database.CursorWrapper; -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -/** - * Common {@link Cursor} class that wraps cursors we use in this library with convenience loading methods. - * This is used to help cut down on generated code size and potentially decrease method count. - */ -public class FlowCursor extends CursorWrapper { - - public static FlowCursor from(@NonNull Cursor cursor) { - if (cursor instanceof FlowCursor) { - return (FlowCursor) cursor; - } else { - return new FlowCursor(cursor); - } - } - - private Cursor cursor; // compatibility reasons - - private FlowCursor(@NonNull Cursor cursor) { - super(cursor); - this.cursor = cursor; - } - - // compatibility - public Cursor getWrappedCursor() { - return cursor; - } - - public String getStringOrDefault(int index, String defValue) { - if (index != -1 && !cursor.isNull(index)) { - return cursor.getString(index); - } else { - return defValue; - } - } - - @Nullable - public String getStringOrDefault(String columnName) { - return getStringOrDefault(cursor.getColumnIndex(columnName)); - } - - @Nullable - public String getStringOrDefault(int index) { - if (index != -1 && !cursor.isNull(index)) { - return cursor.getString(index); - } else { - return null; - } - } - - public String getStringOrDefault(String columnName, String defValue) { - return getStringOrDefault(cursor.getColumnIndex(columnName), defValue); - } - - public int getIntOrDefault(String columnName) { - return getIntOrDefault(cursor.getColumnIndex(columnName)); - } - - public int getIntOrDefault(int index) { - if (index != -1 && !cursor.isNull(index)) { - return cursor.getInt(index); - } else { - return 0; - } - } - - public int getIntOrDefault(int index, int defValue) { - if (index != -1 && !cursor.isNull(index)) { - return cursor.getInt(index); - } else { - return defValue; - } - } - - public int getIntOrDefault(String columnName, int defValue) { - return getIntOrDefault(cursor.getColumnIndex(columnName), defValue); - } - - public Integer getIntOrDefault(int index, Integer defValue) { - if (index != -1 && !cursor.isNull(index)) { - return cursor.getInt(index); - } else { - return defValue; - } - } - - public Integer getIntOrDefault(String columnName, Integer defValue) { - return getIntOrDefault(cursor.getColumnIndex(columnName), defValue); - } - - public double getDoubleOrDefault(int index, double defValue) { - if (index != -1 && !cursor.isNull(index)) { - return cursor.getDouble(index); - } else { - return defValue; - } - } - - public double getDoubleOrDefault(String columnName) { - return getDoubleOrDefault(cursor.getColumnIndex(columnName)); - } - - public double getDoubleOrDefault(int index) { - if (index != -1 && !cursor.isNull(index)) { - return cursor.getDouble(index); - } else { - return 0; - } - } - - public double getDoubleOrDefault(String columnName, double defValue) { - return getDoubleOrDefault(cursor.getColumnIndex(columnName), defValue); - } - - public Double getDoubleOrDefault(int index, Double defValue) { - if (index != -1 && !cursor.isNull(index)) { - return cursor.getDouble(index); - } else { - return defValue; - } - } - - public Double getDoubleOrDefault(String columnName, Double defValue) { - return getDoubleOrDefault(cursor.getColumnIndex(columnName), defValue); - } - - public float getFloatOrDefault(int index, float defValue) { - if (index != -1 && !cursor.isNull(index)) { - return cursor.getFloat(index); - } else { - return defValue; - } - } - - public float getFloatOrDefault(String columnName) { - return getFloatOrDefault(cursor.getColumnIndex(columnName)); - } - - public float getFloatOrDefault(int index) { - if (index != -1 && !cursor.isNull(index)) { - return cursor.getFloat(index); - } else { - return 0; - } - } - - public float getFloatOrDefault(String columnName, float defValue) { - return getFloatOrDefault(cursor.getColumnIndex(columnName), defValue); - } - - public Float getFloatOrDefault(int index, Float defValue) { - if (index != -1 && !cursor.isNull(index)) { - return cursor.getFloat(index); - } else { - return defValue; - } - } - - public Float getFloatOrDefault(String columnName, Float defValue) { - return getFloatOrDefault(cursor.getColumnIndex(columnName), defValue); - } - - public long getLongOrDefault(int index, long defValue) { - if (index != -1 && !cursor.isNull(index)) { - return cursor.getLong(index); - } else { - return defValue; - } - } - - public long getLongOrDefault(String columnName) { - return getLongOrDefault(cursor.getColumnIndex(columnName)); - } - - public long getLongOrDefault(int index) { - if (index != -1 && !cursor.isNull(index)) { - return cursor.getLong(index); - } else { - return 0; - } - } - - public long getLongOrDefault(String columnName, long defValue) { - return getLongOrDefault(cursor.getColumnIndex(columnName), defValue); - } - - public Long getLongOrDefault(int index, Long defValue) { - if (index != -1 && !cursor.isNull(index)) { - return cursor.getLong(index); - } else { - return defValue; - } - } - - public Long getLongOrDefault(String columnName, Long defValue) { - return getLongOrDefault(cursor.getColumnIndex(columnName), defValue); - } - - public short getShortOrDefault(int index, short defValue) { - if (index != -1 && !cursor.isNull(index)) { - return cursor.getShort(index); - } else { - return defValue; - } - } - - public short getShortOrDefault(String columnName) { - return getShortOrDefault(cursor.getColumnIndex(columnName)); - } - - public short getShortOrDefault(int index) { - if (index != -1 && !cursor.isNull(index)) { - return cursor.getShort(index); - } else { - return 0; - } - } - - public short getShortOrDefault(String columnName, short defValue) { - return getShortOrDefault(cursor.getColumnIndex(columnName), defValue); - } - - public Short getShortOrDefault(int index, Short defValue) { - if (index != -1 && !cursor.isNull(index)) { - return cursor.getShort(index); - } else { - return defValue; - } - } - - public Short getShortOrDefault(String columnName, Short defValue) { - return getShortOrDefault(cursor.getColumnIndex(columnName), defValue); - } - - public byte[] getBlobOrDefault(String columnName) { - return getBlobOrDefault(cursor.getColumnIndex(columnName)); - } - - public byte[] getBlobOrDefault(int index) { - if (index != -1 && !cursor.isNull(index)) { - return cursor.getBlob(index); - } else { - return null; - } - } - - public byte[] getBlobOrDefault(int index, byte[] defValue) { - if (index != -1 && !cursor.isNull(index)) { - return cursor.getBlob(index); - } else { - return defValue; - } - } - - public byte[] getBlobOrDefault(String columnName, byte[] defValue) { - return getBlobOrDefault(cursor.getColumnIndex(columnName), defValue); - } - - public boolean getBooleanOrDefault(int index, boolean defValue) { - if (index != -1 && !cursor.isNull(index)) { - return getBoolean(index); - } else { - return defValue; - } - } - - public boolean getBooleanOrDefault(String columnName) { - return getBooleanOrDefault(cursor.getColumnIndex(columnName)); - } - - public boolean getBooleanOrDefault(int index) { - if (index != -1 && !cursor.isNull(index)) { - return getBoolean(index); - } else { - return false; - } - } - - public boolean getBooleanOrDefault(String columnName, boolean defValue) { - return getBooleanOrDefault(cursor.getColumnIndex(columnName), defValue); - } - - public boolean getBoolean(int index) { - return cursor.getInt(index) == 1; - } - -} - diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/FlowCursor.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/FlowCursor.kt new file mode 100644 index 000000000..9408ab92d --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/FlowCursor.kt @@ -0,0 +1,255 @@ +package com.raizlabs.android.dbflow.structure.database + +import android.database.Cursor +import android.database.CursorWrapper + +/** + * Common [Cursor] class that wraps cursors we use in this library with convenience loading methods. + * This is used to help cut down on generated code size and potentially decrease method count. + */ +class FlowCursor private constructor(private val cursor: Cursor) : CursorWrapper(cursor) { + + // compatibility + override fun getWrappedCursor(): Cursor = cursor + + fun getStringOrDefault(index: Int, defValue: String): String { + return if (index != -1 && !cursor.isNull(index)) { + cursor.getString(index) + } else { + defValue + } + } + + fun getStringOrDefault(columnName: String): String? = + getStringOrDefault(cursor.getColumnIndex(columnName)) + + fun getStringOrDefault(index: Int): String? { + return if (index != -1 && !cursor.isNull(index)) { + cursor.getString(index) + } else { + null + } + } + + fun getStringOrDefault(columnName: String, defValue: String): String = + getStringOrDefault(cursor.getColumnIndex(columnName), defValue) + + fun getIntOrDefault(columnName: String): Int = + getIntOrDefault(cursor.getColumnIndex(columnName)) + + fun getIntOrDefault(index: Int): Int { + return if (index != -1 && !cursor.isNull(index)) { + cursor.getInt(index) + } else { + 0 + } + } + + fun getIntOrDefault(index: Int, defValue: Int): Int { + return if (index != -1 && !cursor.isNull(index)) { + cursor.getInt(index) + } else { + defValue + } + } + + fun getIntOrDefault(columnName: String, defValue: Int): Int = + getIntOrDefault(cursor.getColumnIndex(columnName), defValue) + + fun getIntOrDefault(index: Int, defValue: Int?): Int? { + return if (index != -1 && !cursor.isNull(index)) { + cursor.getInt(index) + } else { + defValue + } + } + + fun getIntOrDefault(columnName: String, defValue: Int?): Int? = + getIntOrDefault(cursor.getColumnIndex(columnName), defValue) + + fun getDoubleOrDefault(index: Int, defValue: Double): Double { + return if (index != -1 && !cursor.isNull(index)) { + cursor.getDouble(index) + } else { + defValue + } + } + + fun getDoubleOrDefault(columnName: String): Double = + getDoubleOrDefault(cursor.getColumnIndex(columnName)) + + fun getDoubleOrDefault(index: Int): Double { + return if (index != -1 && !cursor.isNull(index)) { + cursor.getDouble(index) + } else { + 0.0 + } + } + + fun getDoubleOrDefault(columnName: String, defValue: Double): Double = + getDoubleOrDefault(cursor.getColumnIndex(columnName), defValue) + + fun getDoubleOrDefault(index: Int, defValue: Double?): Double? { + return if (index != -1 && !cursor.isNull(index)) { + cursor.getDouble(index) + } else { + defValue + } + } + + fun getDoubleOrDefault(columnName: String, defValue: Double?): Double? = + getDoubleOrDefault(cursor.getColumnIndex(columnName), defValue) + + fun getFloatOrDefault(index: Int, defValue: Float): Float { + return if (index != -1 && !cursor.isNull(index)) { + cursor.getFloat(index) + } else { + defValue + } + } + + fun getFloatOrDefault(columnName: String): Float = + getFloatOrDefault(cursor.getColumnIndex(columnName)) + + fun getFloatOrDefault(index: Int): Float { + return if (index != -1 && !cursor.isNull(index)) { + cursor.getFloat(index) + } else { + 0f + } + } + + fun getFloatOrDefault(columnName: String, defValue: Float): Float = + getFloatOrDefault(cursor.getColumnIndex(columnName), defValue) + + fun getFloatOrDefault(index: Int, defValue: Float?): Float? { + return if (index != -1 && !cursor.isNull(index)) { + cursor.getFloat(index) + } else { + defValue + } + } + + fun getFloatOrDefault(columnName: String, defValue: Float?): Float? = + getFloatOrDefault(cursor.getColumnIndex(columnName), defValue) + + fun getLongOrDefault(index: Int, defValue: Long): Long { + return if (index != -1 && !cursor.isNull(index)) { + cursor.getLong(index) + } else { + defValue + } + } + + fun getLongOrDefault(columnName: String): Long = + getLongOrDefault(cursor.getColumnIndex(columnName)) + + fun getLongOrDefault(index: Int): Long { + return if (index != -1 && !cursor.isNull(index)) { + cursor.getLong(index) + } else { + 0 + } + } + + fun getLongOrDefault(columnName: String, defValue: Long): Long = + getLongOrDefault(cursor.getColumnIndex(columnName), defValue) + + fun getLongOrDefault(index: Int, defValue: Long?): Long? { + return if (index != -1 && !cursor.isNull(index)) { + cursor.getLong(index) + } else { + defValue + } + } + + fun getLongOrDefault(columnName: String, defValue: Long?): Long? = + getLongOrDefault(cursor.getColumnIndex(columnName), defValue) + + fun getShortOrDefault(index: Int, defValue: Short): Short { + return if (index != -1 && !cursor.isNull(index)) { + cursor.getShort(index) + } else { + defValue + } + } + + fun getShortOrDefault(columnName: String): Short = + getShortOrDefault(cursor.getColumnIndex(columnName)) + + fun getShortOrDefault(index: Int): Short { + return if (index != -1 && !cursor.isNull(index)) { + cursor.getShort(index) + } else { + 0 + } + } + + fun getShortOrDefault(columnName: String, defValue: Short): Short = + getShortOrDefault(cursor.getColumnIndex(columnName), defValue) + + fun getShortOrDefault(index: Int, defValue: Short?): Short? { + return if (index != -1 && !cursor.isNull(index)) { + cursor.getShort(index) + } else { + defValue + } + } + + fun getShortOrDefault(columnName: String, defValue: Short?): Short? = + getShortOrDefault(cursor.getColumnIndex(columnName), defValue) + + fun getBlobOrDefault(columnName: String): ByteArray? = + getBlobOrDefault(cursor.getColumnIndex(columnName)) + + fun getBlobOrDefault(index: Int): ByteArray? { + return if (index != -1 && !cursor.isNull(index)) { + cursor.getBlob(index) + } else { + null + } + } + + fun getBlobOrDefault(index: Int, defValue: ByteArray): ByteArray { + return if (index != -1 && !cursor.isNull(index)) { + cursor.getBlob(index) + } else { + defValue + } + } + + fun getBlobOrDefault(columnName: String, defValue: ByteArray): ByteArray = + getBlobOrDefault(cursor.getColumnIndex(columnName), defValue) + + fun getBooleanOrDefault(index: Int, defValue: Boolean): Boolean { + return if (index != -1 && !cursor.isNull(index)) { + getBoolean(index) + } else { + defValue + } + } + + fun getBooleanOrDefault(columnName: String): Boolean = + getBooleanOrDefault(cursor.getColumnIndex(columnName)) + + fun getBooleanOrDefault(index: Int): Boolean { + return if (index != -1 && !cursor.isNull(index)) { + getBoolean(index) + } else { + false + } + } + + fun getBooleanOrDefault(columnName: String, defValue: Boolean): Boolean = + getBooleanOrDefault(cursor.getColumnIndex(columnName), defValue) + + fun getBoolean(index: Int): Boolean = cursor.getInt(index) == 1 + + companion object { + + @JvmStatic + fun from(cursor: Cursor): FlowCursor = cursor as? FlowCursor ?: FlowCursor(cursor) + } + +} + diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/FlowSQLiteOpenHelper.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/FlowSQLiteOpenHelper.java deleted file mode 100644 index 42e0db042..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/FlowSQLiteOpenHelper.java +++ /dev/null @@ -1,173 +0,0 @@ -package com.raizlabs.android.dbflow.structure.database; - -import android.content.Context; -import android.database.sqlite.SQLiteDatabase; -import android.database.sqlite.SQLiteOpenHelper; -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.config.DatabaseDefinition; -import com.raizlabs.android.dbflow.config.FlowManager; - -/** - * Description: Wraps around the {@link SQLiteOpenHelper} and provides extra features for use in this library. - */ -public class FlowSQLiteOpenHelper extends SQLiteOpenHelper implements OpenHelper { - - private DatabaseHelperDelegate databaseHelperDelegate; - private AndroidDatabase androidDatabase; - - - public FlowSQLiteOpenHelper(@NonNull DatabaseDefinition databaseDefinition, - @Nullable DatabaseHelperListener listener) { - super(FlowManager.getContext(), databaseDefinition.isInMemory() ? null : databaseDefinition.getDatabaseFileName(), - null, databaseDefinition.getDatabaseVersion()); - - OpenHelper backupHelper = null; - if (databaseDefinition.backupEnabled()) { - // Temp database mirrors existing - backupHelper = new BackupHelper(FlowManager.getContext(), - DatabaseHelperDelegate.getTempDbFileName(databaseDefinition), - databaseDefinition.getDatabaseVersion(), databaseDefinition); - } - - databaseHelperDelegate = new DatabaseHelperDelegate(listener, databaseDefinition, backupHelper); - } - - @Override - public void performRestoreFromBackup() { - databaseHelperDelegate.performRestoreFromBackup(); - } - - @Nullable - @Override - public DatabaseHelperDelegate getDelegate() { - return databaseHelperDelegate; - } - - @Override - public boolean isDatabaseIntegrityOk() { - return databaseHelperDelegate.isDatabaseIntegrityOk(); - } - - @Override - public void backupDB() { - databaseHelperDelegate.backupDB(); - } - - @NonNull - @Override - public DatabaseWrapper getDatabase() { - if (androidDatabase == null || !androidDatabase.getDatabase().isOpen()) { - androidDatabase = AndroidDatabase.from(getWritableDatabase()); - } - return androidDatabase; - } - - /** - * Set a listener to listen for specific DB events and perform an action before we execute this classes - * specific methods. - * - * @param listener - */ - public void setDatabaseListener(@Nullable DatabaseHelperListener listener) { - databaseHelperDelegate.setDatabaseHelperListener(listener); - } - - @Override - public void onCreate(@NonNull SQLiteDatabase db) { - databaseHelperDelegate.onCreate(AndroidDatabase.from(db)); - } - - @Override - public void onUpgrade(@NonNull SQLiteDatabase db, int oldVersion, int newVersion) { - databaseHelperDelegate.onUpgrade(AndroidDatabase.from(db), oldVersion, newVersion); - } - - @Override - public void onOpen(@NonNull SQLiteDatabase db) { - databaseHelperDelegate.onOpen(AndroidDatabase.from(db)); - } - - @Override - public void onDowngrade(@NonNull SQLiteDatabase db, int oldVersion, int newVersion) { - databaseHelperDelegate.onDowngrade(AndroidDatabase.from(db), oldVersion, newVersion); - } - - @Override - public void closeDB() { - getDatabase(); - androidDatabase.getDatabase().close(); - } - - /** - * Simple helper to manage backup. - */ - private class BackupHelper extends SQLiteOpenHelper implements OpenHelper { - - private AndroidDatabase androidDatabase; - private final BaseDatabaseHelper baseDatabaseHelper; - - public BackupHelper(Context context, String name, int version, DatabaseDefinition databaseDefinition) { - super(context, name, null, version); - this.baseDatabaseHelper = new BaseDatabaseHelper(databaseDefinition); - } - - @NonNull - @Override - public DatabaseWrapper getDatabase() { - if (androidDatabase == null) { - androidDatabase = AndroidDatabase.from(getWritableDatabase()); - } - return androidDatabase; - } - - @Override - public void performRestoreFromBackup() { - } - - @Nullable - @Override - public DatabaseHelperDelegate getDelegate() { - return null; - } - - @Override - public boolean isDatabaseIntegrityOk() { - return false; - } - - @Override - public void backupDB() { - } - - @Override - public void setDatabaseListener(@Nullable DatabaseHelperListener helperListener) { - } - - @Override - public void onCreate(SQLiteDatabase db) { - baseDatabaseHelper.onCreate(AndroidDatabase.from(db)); - } - - @Override - public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { - baseDatabaseHelper.onUpgrade(AndroidDatabase.from(db), oldVersion, newVersion); - } - - @Override - public void onOpen(SQLiteDatabase db) { - baseDatabaseHelper.onOpen(AndroidDatabase.from(db)); - } - - @Override - public void onDowngrade(SQLiteDatabase db, int oldVersion, int newVersion) { - baseDatabaseHelper.onDowngrade(AndroidDatabase.from(db), oldVersion, newVersion); - } - - @Override - public void closeDB() { - } - } - -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/FlowSQLiteOpenHelper.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/FlowSQLiteOpenHelper.kt new file mode 100644 index 000000000..3b3e1632d --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/FlowSQLiteOpenHelper.kt @@ -0,0 +1,142 @@ +package com.raizlabs.android.dbflow.structure.database + +import android.content.Context +import android.database.sqlite.SQLiteDatabase +import android.database.sqlite.SQLiteOpenHelper + +import com.raizlabs.android.dbflow.config.DatabaseDefinition +import com.raizlabs.android.dbflow.config.FlowManager + +/** + * Description: Wraps around the [SQLiteOpenHelper] and provides extra features for use in this library. + */ +class FlowSQLiteOpenHelper( + databaseDefinition: DatabaseDefinition, + listener: DatabaseHelperListener?) + : SQLiteOpenHelper(FlowManager.context, + if (databaseDefinition.isInMemory) null else databaseDefinition.databaseFileName, + null, + databaseDefinition.databaseVersion), OpenHelper { + + private val databaseHelperDelegate: DatabaseHelperDelegate + private var androidDatabase: AndroidDatabase? = null + + init { + var backupHelper: OpenHelper? = null + if (databaseDefinition.backupEnabled()) { + // Temp database mirrors existing + backupHelper = BackupHelper(FlowManager.context, + DatabaseHelperDelegate.getTempDbFileName(databaseDefinition), + databaseDefinition.databaseVersion, databaseDefinition) + } + + databaseHelperDelegate = DatabaseHelperDelegate(listener, databaseDefinition, backupHelper) + } + + override fun performRestoreFromBackup() { + databaseHelperDelegate.performRestoreFromBackup() + } + + override val delegate: DatabaseHelperDelegate? + get() = databaseHelperDelegate + + override val isDatabaseIntegrityOk: Boolean + get() = databaseHelperDelegate.isDatabaseIntegrityOk + + override fun backupDB() { + databaseHelperDelegate.backupDB() + } + + override val database: DatabaseWrapper + get() { + if (androidDatabase == null || !androidDatabase!!.database.isOpen) { + androidDatabase = AndroidDatabase.from(writableDatabase) + } + return androidDatabase!! + } + + /** + * Set a listener to listen for specific DB events and perform an action before we execute this classes + * specific methods. + * + * @param listener + */ + override fun setDatabaseListener(listener: DatabaseHelperListener?) { + databaseHelperDelegate.setDatabaseHelperListener(listener!!) + } + + override fun onCreate(db: SQLiteDatabase) { + databaseHelperDelegate.onCreate(AndroidDatabase.from(db)) + } + + override fun onUpgrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) { + databaseHelperDelegate.onUpgrade(AndroidDatabase.from(db), oldVersion, newVersion) + } + + override fun onOpen(db: SQLiteDatabase) { + databaseHelperDelegate.onOpen(AndroidDatabase.from(db)) + } + + override fun onDowngrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) { + databaseHelperDelegate.onDowngrade(AndroidDatabase.from(db), oldVersion, newVersion) + } + + override fun closeDB() { + androidDatabase?.database?.close() + } + + /** + * Simple helper to manage backup. + */ + private inner class BackupHelper(context: Context, + name: String, version: Int, + databaseDefinition: DatabaseDefinition) + : SQLiteOpenHelper(context, name, null, version), OpenHelper { + + private var androidDatabase: AndroidDatabase? = null + private val baseDatabaseHelper: BaseDatabaseHelper + + init { + this.baseDatabaseHelper = BaseDatabaseHelper(databaseDefinition) + } + + override val database: DatabaseWrapper + get() { + if (androidDatabase == null) { + androidDatabase = AndroidDatabase.from(writableDatabase) + } + return androidDatabase!! + } + + override fun performRestoreFromBackup() {} + + override val delegate: DatabaseHelperDelegate? + get() = null + + override val isDatabaseIntegrityOk: Boolean + get() = false + + override fun backupDB() {} + + override fun setDatabaseListener(helperListener: DatabaseHelperListener?) {} + + override fun onCreate(db: SQLiteDatabase) { + baseDatabaseHelper.onCreate(AndroidDatabase.from(db)) + } + + override fun onUpgrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) { + baseDatabaseHelper.onUpgrade(AndroidDatabase.from(db), oldVersion, newVersion) + } + + override fun onOpen(db: SQLiteDatabase) { + baseDatabaseHelper.onOpen(AndroidDatabase.from(db)) + } + + override fun onDowngrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) { + baseDatabaseHelper.onDowngrade(AndroidDatabase.from(db), oldVersion, newVersion) + } + + override fun closeDB() {} + } + +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/OpenHelper.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/OpenHelper.java deleted file mode 100644 index 280e3b80a..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/OpenHelper.java +++ /dev/null @@ -1,26 +0,0 @@ -package com.raizlabs.android.dbflow.structure.database; - -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -/** - * Description: Abstracts out the {@link DatabaseHelperDelegate} into the one used in this library. - */ -public interface OpenHelper { - - void performRestoreFromBackup(); - - @NonNull - DatabaseWrapper getDatabase(); - - @Nullable - DatabaseHelperDelegate getDelegate(); - - boolean isDatabaseIntegrityOk(); - - void backupDB(); - - void setDatabaseListener(@Nullable DatabaseHelperListener helperListener); - - void closeDB(); -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/OpenHelper.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/OpenHelper.kt new file mode 100644 index 000000000..6cd6ba15a --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/OpenHelper.kt @@ -0,0 +1,21 @@ +package com.raizlabs.android.dbflow.structure.database + +/** + * Description: Abstracts out the [DatabaseHelperDelegate] into the one used in this library. + */ +interface OpenHelper { + + val database: DatabaseWrapper + + val delegate: DatabaseHelperDelegate? + + val isDatabaseIntegrityOk: Boolean + + fun performRestoreFromBackup() + + fun backupDB() + + fun setDatabaseListener(helperListener: DatabaseHelperListener?) + + fun closeDB() +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/DefaultTransactionManager.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/DefaultTransactionManager.java deleted file mode 100644 index 4f8d81ced..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/DefaultTransactionManager.java +++ /dev/null @@ -1,23 +0,0 @@ -package com.raizlabs.android.dbflow.structure.database.transaction; - -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.config.DatabaseDefinition; -import com.raizlabs.android.dbflow.runtime.BaseTransactionManager; - -/** - * Description: This class manages batch database interactions. It is useful for retrieving, updating, saving, - * and deleting lists of items. The bulk of DB operations should exist in this class. - */ -public class DefaultTransactionManager extends BaseTransactionManager { - - public DefaultTransactionManager(@NonNull DatabaseDefinition databaseDefinition) { - super(new DefaultTransactionQueue("DBFlow Transaction Queue"), databaseDefinition); - } - - public DefaultTransactionManager(@NonNull ITransactionQueue transactionQueue, - @NonNull DatabaseDefinition databaseDefinition) { - super(transactionQueue, databaseDefinition); - } - -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/DefaultTransactionManager.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/DefaultTransactionManager.kt new file mode 100644 index 000000000..343917040 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/DefaultTransactionManager.kt @@ -0,0 +1,19 @@ +package com.raizlabs.android.dbflow.structure.database.transaction + +import com.raizlabs.android.dbflow.config.DatabaseDefinition +import com.raizlabs.android.dbflow.runtime.BaseTransactionManager + +/** + * Description: This class manages batch database interactions. It is useful for retrieving, updating, saving, + * and deleting lists of items. The bulk of DB operations should exist in this class. + */ +class DefaultTransactionManager : BaseTransactionManager { + + constructor(databaseDefinition: DatabaseDefinition) + : super(DefaultTransactionQueue("DBFlow Transaction Queue"), databaseDefinition) + + constructor(transactionQueue: ITransactionQueue, + databaseDefinition: DatabaseDefinition) + : super(transactionQueue, databaseDefinition) + +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/DefaultTransactionQueue.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/DefaultTransactionQueue.java deleted file mode 100644 index 75503e926..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/DefaultTransactionQueue.java +++ /dev/null @@ -1,125 +0,0 @@ -package com.raizlabs.android.dbflow.structure.database.transaction; - -import android.os.Looper; -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.config.FlowLog; - -import java.util.Iterator; -import java.util.concurrent.LinkedBlockingQueue; - -/** - * Description: Handles concurrent requests to the database and puts them in FIFO order based on a - * {@link LinkedBlockingQueue}. As requests come in, they're placed in order and ran one at a time - * until the queue becomes empty. - */ -public class DefaultTransactionQueue extends Thread implements ITransactionQueue { - - private final LinkedBlockingQueue queue; - - private boolean isQuitting = false; - - /** - * Creates a queue with the specified name to ID it. - * - * @param name - */ - public DefaultTransactionQueue(String name) { - super(name); - queue = new LinkedBlockingQueue<>(); - } - - @SuppressWarnings("unchecked") - @Override - public void run() { - Looper.prepare(); - android.os.Process.setThreadPriority(android.os.Process.THREAD_PRIORITY_BACKGROUND); - Transaction transaction; - while (true) { - try { - transaction = queue.take(); - } catch (InterruptedException e) { - synchronized (this) { - if (isQuitting) { - synchronized (queue) { - queue.clear(); - } - return; - } - } - continue; - } - - if (!isQuitting) { - transaction.executeSync(); - } - } - } - - @Override - public void add(@NonNull Transaction runnable) { - synchronized (queue) { - if (!queue.contains(runnable)) { - queue.add(runnable); - } - } - } - - /** - * Cancels the specified request. - * - * @param runnable - */ - @Override - public void cancel(@NonNull Transaction runnable) { - synchronized (queue) { - if (queue.contains(runnable)) { - queue.remove(runnable); - } - } - } - - /** - * Cancels all requests by a specific tag - * - * @param tag - */ - @Override - public void cancel(@NonNull String tag) { - synchronized (queue) { - Iterator it = queue.iterator(); - while (it.hasNext()) { - Transaction next = it.next(); - if (next.name() != null && next.name().equals(tag)) { - it.remove(); - } - } - } - } - - @Override - public void startIfNotAlive() { - synchronized (this) { - if (!isAlive()) { - try { - start(); - } catch (IllegalThreadStateException i) { - // log if failure from thread is still alive. - FlowLog.log(FlowLog.Level.E, i); - } - } - } - } - - /** - * Quits this process - */ - @Override - public void quit() { - synchronized (this) { - isQuitting = true; - } - interrupt(); - } -} - diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/DefaultTransactionQueue.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/DefaultTransactionQueue.kt new file mode 100644 index 000000000..b4a75c68b --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/DefaultTransactionQueue.kt @@ -0,0 +1,112 @@ +package com.raizlabs.android.dbflow.structure.database.transaction + +import android.os.Looper + +import com.raizlabs.android.dbflow.config.FlowLog +import java.util.concurrent.LinkedBlockingQueue + +/** + * Description: Handles concurrent requests to the database and puts them in FIFO order based on a + * [LinkedBlockingQueue]. As requests come in, they're placed in order and ran one at a time + * until the queue becomes empty. + */ +class DefaultTransactionQueue +/** + * Creates a queue with the specified name to ID it. + * + * @param name + */ +(name: String) : Thread(name), ITransactionQueue { + + private val queue = LinkedBlockingQueue() + + private var isQuitting = false + + override fun run() { + Looper.prepare() + android.os.Process.setThreadPriority(android.os.Process.THREAD_PRIORITY_BACKGROUND) + var transaction: Transaction + while (true) { + try { + transaction = queue.take() + } catch (e: InterruptedException) { + synchronized(this) { + if (isQuitting) { + synchronized(queue) { + queue.clear() + } + return + } + } + continue + } + + if (!isQuitting) { + transaction.executeSync() + } + } + } + + override fun add(runnable: Transaction) { + synchronized(queue) { + if (!queue.contains(runnable)) { + queue.add(runnable) + } + } + } + + /** + * Cancels the specified request. + * + * @param runnable + */ + override fun cancel(runnable: Transaction) { + synchronized(queue) { + if (queue.contains(runnable)) { + queue.remove(runnable) + } + } + } + + /** + * Cancels all requests by a specific tag + * + * @param tag + */ + override fun cancel(tag: String) { + synchronized(queue) { + val it = queue.iterator() + while (it.hasNext()) { + val next = it.next() + if (next.name() != null && next.name() == tag) { + it.remove() + } + } + } + } + + override fun startIfNotAlive() { + synchronized(this) { + if (!isAlive) { + try { + start() + } catch (i: IllegalThreadStateException) { + // log if failure from thread is still alive. + FlowLog.log(FlowLog.Level.E, throwable = i) + } + + } + } + } + + /** + * Quits this process + */ + override fun quit() { + synchronized(this) { + isQuitting = true + } + interrupt() + } +} + diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/FastStoreModelTransaction.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/FastStoreModelTransaction.java deleted file mode 100644 index da5ba517c..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/FastStoreModelTransaction.java +++ /dev/null @@ -1,145 +0,0 @@ -package com.raizlabs.android.dbflow.structure.database.transaction; - -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.structure.InternalAdapter; -import com.raizlabs.android.dbflow.structure.Model; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collection; -import java.util.List; - -/** - * Description: Similiar to {@link ProcessModelTransaction} in that it allows you to store a {@link List} of - * {@link Model}, except that it performs it as efficiently as possible. Also due to way the class operates, - * only one kind of {@link TModel} is allowed. - */ -public class FastStoreModelTransaction implements ITransaction { - - @NonNull - public static Builder saveBuilder(@NonNull InternalAdapter internalAdapter) { - return new Builder<>(new ProcessModelList() { - @Override - public void processModel(@NonNull List tModels, InternalAdapter adapter, DatabaseWrapper wrapper) { - adapter.saveAll(tModels, wrapper); - } - }, internalAdapter); - } - - @NonNull - public static Builder insertBuilder(@NonNull InternalAdapter internalAdapter) { - return new Builder<>(new ProcessModelList() { - @Override - public void processModel(@NonNull List tModels, InternalAdapter adapter, DatabaseWrapper wrapper) { - adapter.insertAll(tModels, wrapper); - } - }, internalAdapter); - } - - @NonNull - public static Builder updateBuilder(@NonNull InternalAdapter internalAdapter) { - return new Builder<>(new ProcessModelList() { - @Override - public void processModel(@NonNull List tModels, InternalAdapter adapter, DatabaseWrapper wrapper) { - adapter.updateAll(tModels, wrapper); - } - }, internalAdapter); - } - - @NonNull - public static Builder deleteBuilder(@NonNull InternalAdapter internalAdapter) { - return new Builder<>(new ProcessModelList() { - @Override - public void processModel(@NonNull List tModels, InternalAdapter adapter, DatabaseWrapper wrapper) { - adapter.deleteAll(tModels, wrapper); - } - }, internalAdapter); - } - - /** - * Description: Simple interface for acting on a model in a Transaction or list of {@link Model} - */ - interface ProcessModelList { - - /** - * Called when processing models - * - * @param modelList The model list to process - */ - void processModel(@NonNull List modelList, InternalAdapter adapter, - DatabaseWrapper wrapper); - } - - final List models; - final ProcessModelList processModelList; - final InternalAdapter internalAdapter; - - FastStoreModelTransaction(Builder builder) { - models = builder.models; - processModelList = builder.processModelList; - internalAdapter = builder.internalAdapter; - } - - @Override - public void execute(DatabaseWrapper databaseWrapper) { - if (models != null) { - processModelList.processModel(models, internalAdapter, databaseWrapper); - } - } - - /** - * Makes it easy to build a {@link ProcessModelTransaction}. - * - * @param - */ - public static final class Builder { - - private final ProcessModelList processModelList; - @NonNull private final InternalAdapter internalAdapter; - List models = new ArrayList<>(); - - Builder(@NonNull ProcessModelList processModelList, - @NonNull InternalAdapter internalAdapter) { - this.processModelList = processModelList; - this.internalAdapter = internalAdapter; - } - - @NonNull - public Builder add(TModel model) { - models.add(model); - return this; - } - - /** - * Adds all specified models to the {@link ArrayList}. - */ - @NonNull - @SafeVarargs - public final Builder addAll(TModel... models) { - this.models.addAll(Arrays.asList(models)); - return this; - } - - /** - * Adds a {@link Collection} of {@link Model} to the existing {@link ArrayList}. - */ - @NonNull - public Builder addAll(Collection models) { - if (models != null) { - this.models.addAll(models); - } - return this; - } - - /** - * @return A new {@link ProcessModelTransaction}. Subsequent calls to this method produce - * new instances. - */ - @NonNull - public FastStoreModelTransaction build() { - return new FastStoreModelTransaction<>(this); - } - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/FastStoreModelTransaction.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/FastStoreModelTransaction.kt new file mode 100644 index 000000000..048435152 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/FastStoreModelTransaction.kt @@ -0,0 +1,127 @@ +package com.raizlabs.android.dbflow.structure.database.transaction + +import com.raizlabs.android.dbflow.config.modelAdapter +import com.raizlabs.android.dbflow.structure.InternalAdapter +import com.raizlabs.android.dbflow.structure.Model +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import java.util.* + +/** + * Description: Similiar to [ProcessModelTransaction] in that it allows you to store a [List] of + * [Model], except that it performs it as efficiently as possible. Also due to way the class operates, + * only one kind of [TModel] is allowed. + */ +class FastStoreModelTransaction internal constructor(builder: Builder) : ITransaction { + + internal val models: List? + internal val processModelList: ProcessModelList + internal val internalAdapter: InternalAdapter + + /** + * Description: Simple interface for acting on a model in a Transaction or list of [Model] + */ + internal interface ProcessModelList { + + /** + * Called when processing models + * + * @param modelList The model list to process + */ + fun processModel(modelList: List, adapter: InternalAdapter, + wrapper: DatabaseWrapper) + } + + init { + models = builder.models + processModelList = builder.processModelList + internalAdapter = builder.internalAdapter + } + + override fun execute(databaseWrapper: DatabaseWrapper) { + if (models != null) { + processModelList.processModel(models, internalAdapter, databaseWrapper) + } + } + + /** + * Makes it easy to build a [ProcessModelTransaction]. + * + * @param + */ + class Builder internal constructor(internal val processModelList: ProcessModelList, + internal val internalAdapter: InternalAdapter) { + internal var models: MutableList = ArrayList() + + fun add(model: TModel) = apply { + models.add(model) + } + + /** + * Adds all specified models to the [ArrayList]. + */ + @SafeVarargs + fun addAll(vararg models: TModel) = apply { + this.models.addAll(models.toList()) + } + + /** + * Adds a [Collection] of [Model] to the existing [ArrayList]. + */ + fun addAll(models: Collection?) = apply { + if (models != null) { + this.models.addAll(models) + } + } + + /** + * @return A new [ProcessModelTransaction]. Subsequent calls to this method produce + * new instances. + */ + fun build(): FastStoreModelTransaction = FastStoreModelTransaction(this) + } + + companion object { + + @JvmStatic + fun saveBuilder(internalAdapter: InternalAdapter): Builder { + return Builder(object : ProcessModelList { + override fun processModel(tModels: List, adapter: InternalAdapter, wrapper: DatabaseWrapper) { + adapter.saveAll(tModels, wrapper) + } + }, internalAdapter) + } + + @JvmStatic + fun insertBuilder(internalAdapter: InternalAdapter): Builder { + return Builder(object : ProcessModelList { + override fun processModel(tModels: List, adapter: InternalAdapter, wrapper: DatabaseWrapper) { + adapter.insertAll(tModels, wrapper) + } + }, internalAdapter) + } + + @JvmStatic + fun updateBuilder(internalAdapter: InternalAdapter): Builder { + return Builder(object : ProcessModelList { + override fun processModel(tModels: List, adapter: InternalAdapter, wrapper: DatabaseWrapper) { + adapter.updateAll(tModels, wrapper) + } + }, internalAdapter) + } + + @JvmStatic + fun deleteBuilder(internalAdapter: InternalAdapter): Builder { + return Builder(object : ProcessModelList { + override fun processModel(tModels: List, adapter: InternalAdapter, wrapper: DatabaseWrapper) { + adapter.deleteAll(tModels, wrapper) + } + }, internalAdapter) + } + } +} + +inline fun Collection.fastSave() = FastStoreModelTransaction.saveBuilder(modelAdapter()).addAll(this) + +inline fun Collection.fastInsert() = FastStoreModelTransaction.insertBuilder(modelAdapter()).addAll(this) + +inline fun Collection.fastUpdate() = FastStoreModelTransaction.updateBuilder(modelAdapter()).addAll(this) \ No newline at end of file diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ITransaction.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ITransaction.kt similarity index 64% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ITransaction.java rename to dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ITransaction.kt index 292a645a1..7b671f232 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ITransaction.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ITransaction.kt @@ -1,20 +1,20 @@ -package com.raizlabs.android.dbflow.structure.database.transaction; +package com.raizlabs.android.dbflow.structure.database.transaction -import android.database.sqlite.SQLiteDatabaseLockedException; +import android.database.sqlite.SQLiteDatabaseLockedException -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper /** * Description: Simplest form of a transaction. It represents an interface by which code is executed * inside a database transaction. */ -public interface ITransaction { +interface ITransaction { /** * Called within a database transaction. * * @param databaseWrapper The database to save data into. Use this access to operate on the DB - * without causing {@link SQLiteDatabaseLockedException}. + * without causing [SQLiteDatabaseLockedException]. */ - void execute(DatabaseWrapper databaseWrapper); + fun execute(databaseWrapper: DatabaseWrapper) } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ITransactionQueue.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ITransactionQueue.kt similarity index 62% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ITransactionQueue.java rename to dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ITransactionQueue.kt index 581b39374..51c49f1c2 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ITransactionQueue.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ITransactionQueue.kt @@ -1,41 +1,39 @@ -package com.raizlabs.android.dbflow.structure.database.transaction; - -import android.support.annotation.NonNull; +package com.raizlabs.android.dbflow.structure.database.transaction /** * Description: Interface for a queue that manages transactions. */ -public interface ITransactionQueue { +interface ITransactionQueue { /** * Adds a transaction to the queue. * * @param transaction The transaction to run on the queue. */ - void add(@NonNull Transaction transaction); + fun add(transaction: Transaction) /** * Cancels a transaction. * * @param transaction The transaction to cancel on the queue. */ - void cancel(@NonNull Transaction transaction); + fun cancel(transaction: Transaction) /** * Starts if not alive. */ - void startIfNotAlive(); + fun startIfNotAlive() /** * Cancels a transaction by name. * - * @param name the {@link Transaction#name()} property. + * @param name the [Transaction.name] property. */ - void cancel(@NonNull String name); + fun cancel(name: String) /** * Stops/interrupts the queue. */ - void quit(); + fun quit() } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/PriorityTransactionQueue.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/PriorityTransactionQueue.java deleted file mode 100644 index 280e5e431..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/PriorityTransactionQueue.java +++ /dev/null @@ -1,173 +0,0 @@ -package com.raizlabs.android.dbflow.structure.database.transaction; - -import android.os.Looper; -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.config.FlowLog; - -import java.util.Iterator; -import java.util.concurrent.PriorityBlockingQueue; - -/** - * Description: Orders {@link Transaction} in a priority-based queue, enabling you perform higher priority - * tasks first (such as retrievals) if you are attempting many DB operations at once. - */ -public class PriorityTransactionQueue extends Thread implements ITransactionQueue { - - private final PriorityBlockingQueue> queue; - - private boolean isQuitting = false; - - /** - * Creates a queue with the specified name to ID it. - * - * @param name - */ - public PriorityTransactionQueue(String name) { - super(name); - queue = new PriorityBlockingQueue<>(); - } - - @SuppressWarnings("unchecked") - @Override - public void run() { - Looper.prepare(); - android.os.Process.setThreadPriority(android.os.Process.THREAD_PRIORITY_BACKGROUND); - PriorityEntry transaction; - while (true) { - try { - transaction = queue.take(); - } catch (InterruptedException e) { - if (isQuitting) { - synchronized (queue) { - queue.clear(); - } - return; - } - continue; - } - - transaction.entry.executeSync(); - } - } - - @Override - public void add(@NonNull Transaction transaction) { - synchronized (queue) { - PriorityEntry priorityEntry = new PriorityEntry<>(transaction); - if (!queue.contains(priorityEntry)) { - queue.add(priorityEntry); - } - } - } - - /** - * Cancels the specified request. - * - * @param transaction The transaction to cancel (if still in the queue). - */ - @Override - public void cancel(@NonNull Transaction transaction) { - synchronized (queue) { - PriorityEntry priorityEntry = new PriorityEntry<>(transaction); - if (queue.contains(priorityEntry)) { - queue.remove(priorityEntry); - } - } - } - - /** - * Cancels all requests by a specific tag - * - * @param tag - */ - @Override - public void cancel(@NonNull String tag) { - synchronized (queue) { - Iterator> it = queue.iterator(); - while (it.hasNext()) { - Transaction next = it.next().entry; - if (next.name() != null && next.name().equals(tag)) { - it.remove(); - } - } - } - } - - @Override - public void startIfNotAlive() { - synchronized (this) { - if (!isAlive()) { - try { - start(); - } catch (IllegalThreadStateException i) { - // log if failure from thread is still alive. - FlowLog.log(FlowLog.Level.E, i); - } - } - } - } - - /** - * Quits this process - */ - @Override - public void quit() { - isQuitting = true; - interrupt(); - } - - private void throwInvalidTransactionType(Transaction transaction) { - throw new IllegalArgumentException("Transaction of type:" + - (transaction != null ? transaction.transaction().getClass() : "Unknown") - + " should be of type PriorityTransactionWrapper"); - } - - class PriorityEntry - implements Comparable> { - final E entry; - final PriorityTransactionWrapper transactionWrapper; - - public PriorityEntry(E entry) { - this.entry = entry; - if (entry.transaction() instanceof PriorityTransactionWrapper) { - transactionWrapper = ((PriorityTransactionWrapper) entry.transaction()); - } else { - transactionWrapper = new PriorityTransactionWrapper.Builder(entry.transaction()) - .build(); - } - } - - public E getEntry() { - return entry; - } - - @Override - public int compareTo(@NonNull PriorityEntry another) { - return transactionWrapper.compareTo(another.transactionWrapper); - } - - @Override - public boolean equals(Object o) { - if (this == o) { - return true; - } - if (o == null || getClass() != o.getClass()) { - return false; - } - - PriorityEntry that = (PriorityEntry) o; - - return transactionWrapper != null ? transactionWrapper.equals(that.transactionWrapper) - : that.transactionWrapper == null; - - } - - @Override - public int hashCode() { - return transactionWrapper != null ? transactionWrapper.hashCode() : 0; - } - } - - -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/PriorityTransactionQueue.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/PriorityTransactionQueue.kt new file mode 100644 index 000000000..105eb7256 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/PriorityTransactionQueue.kt @@ -0,0 +1,146 @@ +package com.raizlabs.android.dbflow.structure.database.transaction + +import android.os.Looper + +import com.raizlabs.android.dbflow.config.FlowLog +import java.util.concurrent.PriorityBlockingQueue + +/** + * Description: Orders [Transaction] in a priority-based queue, enabling you perform higher priority + * tasks first (such as retrievals) if you are attempting many DB operations at once. + */ +class PriorityTransactionQueue +/** + * Creates a queue with the specified name to ID it. + * + * @param name + */ +(name: String) : Thread(name), ITransactionQueue { + + private val queue = PriorityBlockingQueue>() + + private var isQuitting = false + + override fun run() { + Looper.prepare() + android.os.Process.setThreadPriority(android.os.Process.THREAD_PRIORITY_BACKGROUND) + var transaction: PriorityEntry + while (true) { + try { + transaction = queue.take() + } catch (e: InterruptedException) { + if (isQuitting) { + synchronized(queue) { + queue.clear() + } + return + } + continue + } + + transaction.entry.executeSync() + } + } + + override fun add(transaction: Transaction) { + synchronized(queue) { + val priorityEntry = PriorityEntry(transaction) + if (!queue.contains(priorityEntry)) { + queue.add(priorityEntry) + } + } + } + + /** + * Cancels the specified request. + * + * @param transaction The transaction to cancel (if still in the queue). + */ + override fun cancel(transaction: Transaction) { + synchronized(queue) { + val priorityEntry = PriorityEntry(transaction) + if (queue.contains(priorityEntry)) { + queue.remove(priorityEntry) + } + } + } + + /** + * Cancels all requests by a specific tag + * + * @param tag + */ + override fun cancel(tag: String) { + synchronized(queue) { + val it = queue.iterator() + while (it.hasNext()) { + val next = it.next().entry + if (next.name() != null && next.name() == tag) { + it.remove() + } + } + } + } + + override fun startIfNotAlive() { + synchronized(this) { + if (!isAlive) { + try { + start() + } catch (i: IllegalThreadStateException) { + // log if failure from thread is still alive. + FlowLog.log(FlowLog.Level.E, throwable = i) + } + + } + } + } + + /** + * Quits this process + */ + override fun quit() { + isQuitting = true + interrupt() + } + + private fun throwInvalidTransactionType(transaction: Transaction?) { + throw IllegalArgumentException("Transaction of type:" + + (transaction?.transaction()?.javaClass ?: "Unknown") + + " should be of type PriorityTransactionWrapper") + } + + internal inner class PriorityEntry(val entry: E) : Comparable> { + val transactionWrapper: PriorityTransactionWrapper? = + if (entry.transaction() is PriorityTransactionWrapper) { + entry.transaction() as PriorityTransactionWrapper + } else { + PriorityTransactionWrapper.Builder(entry.transaction()) + .build() + } + + override fun compareTo(other: PriorityEntry): Int = + transactionWrapper!!.compareTo(other.transactionWrapper!!) + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + if (other == null || javaClass != other.javaClass) { + return false + } + + val that = other as PriorityEntry<*>? + + return if (transactionWrapper != null) + transactionWrapper == that!!.transactionWrapper + else + that!!.transactionWrapper == null + + } + + override fun hashCode(): Int = transactionWrapper?.hashCode() ?: 0 + } + + +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/PriorityTransactionWrapper.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/PriorityTransactionWrapper.java deleted file mode 100644 index 84902201d..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/PriorityTransactionWrapper.java +++ /dev/null @@ -1,87 +0,0 @@ -package com.raizlabs.android.dbflow.structure.database.transaction; - -import android.support.annotation.IntDef; -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; - -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; - -/** - * Description: Provides transaction with priority. Meant to be used in a {@link PriorityTransactionQueue}. - */ -public class PriorityTransactionWrapper implements ITransaction, Comparable { - - @Retention(RetentionPolicy.SOURCE) - @IntDef({PRIORITY_LOW, PRIORITY_NORMAL, PRIORITY_HIGH, PRIORITY_UI}) - public @interface Priority { - } - - /** - * Low priority requests, reserved for non-essential tasks - */ - public static final int PRIORITY_LOW = 0; - - /** - * The main of the requests, good for when adding a bunch of - * data to the DB that the app does not access right away (default). - */ - public static final int PRIORITY_NORMAL = 1; - - /** - * Reserved for tasks that will influence user interaction, such as displaying data in the UI - * some point in the future (not necessarily right away) - */ - public static final int PRIORITY_HIGH = 2; - - /** - * Reserved for only immediate tasks and all forms of fetching that will display on the UI - */ - public static final int PRIORITY_UI = 5; - - private final int priority; - private final ITransaction transaction; - - PriorityTransactionWrapper(Builder builder) { - if (builder.priority == 0) { - priority = PRIORITY_NORMAL; - } else { - priority = builder.priority; - } - transaction = builder.transaction; - } - - @Override - public void execute(DatabaseWrapper databaseWrapper) { - transaction.execute(databaseWrapper); - } - - @Override - public int compareTo(@NonNull PriorityTransactionWrapper another) { - return another.priority - priority; - } - - public static class Builder { - - private final ITransaction transaction; - private int priority; - - public Builder(@NonNull ITransaction transaction) { - this.transaction = transaction; - } - - /** - * Sets a {@link Priority} that orders this transaction. - */ - public Builder priority(@Priority int priority) { - this.priority = priority; - return this; - } - - public PriorityTransactionWrapper build() { - return new PriorityTransactionWrapper(this); - } - } - -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/PriorityTransactionWrapper.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/PriorityTransactionWrapper.kt new file mode 100644 index 000000000..0c43013e5 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/PriorityTransactionWrapper.kt @@ -0,0 +1,69 @@ +package com.raizlabs.android.dbflow.structure.database.transaction + +import android.support.annotation.IntDef + +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper + +/** + * Description: Provides transaction with priority. Meant to be used in a [PriorityTransactionQueue]. + */ +class PriorityTransactionWrapper(private val priority: Int, private val transaction: ITransaction) + : ITransaction, Comparable { + + @Retention(AnnotationRetention.SOURCE) + @IntDef(PRIORITY_LOW.toLong(), PRIORITY_NORMAL.toLong(), PRIORITY_HIGH.toLong(), PRIORITY_UI.toLong()) + annotation class Priority() + + internal constructor(builder: Builder) : this( + priority = if (builder.priority == 0) { + PRIORITY_NORMAL + } else { + builder.priority + }, + transaction = builder.transaction) + + override fun execute(databaseWrapper: DatabaseWrapper) { + transaction.execute(databaseWrapper) + } + + override fun compareTo(other: PriorityTransactionWrapper): Int = other.priority - priority + + class Builder(internal val transaction: ITransaction) { + internal var priority: Int = 0 + + /** + * Sets a [Priority] that orders this transaction. + */ + fun priority(@Priority priority: Int) = apply { + this.priority = priority + } + + fun build(): PriorityTransactionWrapper = PriorityTransactionWrapper(this) + } + + companion object { + + /** + * Low priority requests, reserved for non-essential tasks + */ + const val PRIORITY_LOW = 0 + + /** + * The main of the requests, good for when adding a bunch of + * data to the DB that the app does not access right away (default). + */ + const val PRIORITY_NORMAL = 1 + + /** + * Reserved for tasks that will influence user interaction, such as displaying data in the UI + * some point in the future (not necessarily right away) + */ + const val PRIORITY_HIGH = 2 + + /** + * Reserved for only immediate tasks and all forms of fetching that will display on the UI + */ + const val PRIORITY_UI = 5 + } + +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ProcessModelTransaction.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ProcessModelTransaction.java deleted file mode 100644 index 3ae0c3bd7..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ProcessModelTransaction.java +++ /dev/null @@ -1,166 +0,0 @@ -package com.raizlabs.android.dbflow.structure.database.transaction; - -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.structure.Model; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collection; -import java.util.List; - -/** - * Description: Allows you to process a single or {@link List} of models in a transaction. You - * can operate on a set of {@link Model} to {@link Model#save()}, {@link Model#update()}, etc. - */ -public class ProcessModelTransaction implements ITransaction { - - - /** - * Description: Simple interface for acting on a model in a Transaction or list of {@link Model} - */ - public interface ProcessModel { - - /** - * Called when processing models - * - * @param model The model to process - * @param wrapper - */ - void processModel(TModel model, DatabaseWrapper wrapper); - } - - /** - * Listener for providing callbacks as models are processed in this {@link ITransaction}. - * - * @param The model class. - */ - public interface OnModelProcessListener { - - /** - * Called when model has been operated on. - * - * @param current The current index of items processed. - * @param total The total number of items to process. - * @param modifiedModel The model previously modified. - */ - void onModelProcessed(long current, long total, TModel modifiedModel); - } - - final OnModelProcessListener processListener; - final List models; - final ProcessModel processModel; - final boolean runProcessListenerOnSameThread; - - ProcessModelTransaction(Builder builder) { - processListener = builder.processListener; - models = builder.models; - processModel = builder.processModel; - runProcessListenerOnSameThread = builder.runProcessListenerOnSameThread; - } - - @Override - public void execute(DatabaseWrapper databaseWrapper) { - if (models != null) { - final int size = models.size(); - for (int i = 0; i < size; i++) { - final TModel model = models.get(i); - processModel.processModel(model, databaseWrapper); - - if (processListener != null) { - if (runProcessListenerOnSameThread) { - processListener.onModelProcessed(i, size, model); - } else { - final int finalI = i; - Transaction.getTransactionHandler().post(new Runnable() { - @Override - public void run() { - processListener.onModelProcessed(finalI, size, model); - } - }); - } - } - } - } - } - - /** - * Makes it easy to build a {@link ProcessModelTransaction}. - * - * @param - */ - public static final class Builder { - - private final ProcessModel processModel; - OnModelProcessListener processListener; - List models = new ArrayList<>(); - private boolean runProcessListenerOnSameThread; - - - public Builder(@NonNull ProcessModel processModel) { - this.processModel = processModel; - } - - /** - * @param models The models to process. This constructor creates a new {@link ArrayList} - * from the {@link Collection} passed. - * @param processModel The method call interface. - */ - public Builder(Collection models, @NonNull ProcessModel processModel) { - this.processModel = processModel; - this.models = new ArrayList<>(models); - } - - public Builder add(TModel model) { - models.add(model); - return this; - } - - /** - * Adds all specified models to the {@link ArrayList}. - */ - @SafeVarargs - public final Builder addAll(TModel... models) { - this.models.addAll(Arrays.asList(models)); - return this; - } - - /** - * Adds a {@link Collection} of {@link Model} to the existing {@link ArrayList}. - */ - public Builder addAll(Collection models) { - if (models != null) { - this.models.addAll(models); - } - return this; - } - - /** - * @param processListener Allows you to listen for when models are processed to update UI, - * this is called on the UI thread. - */ - public Builder processListener(OnModelProcessListener processListener) { - this.processListener = processListener; - return this; - } - - /** - * @param runProcessListenerOnSameThread Default is false. If true we return callback - * on same calling thread, if false we push the callback - * to the UI thread. - */ - public Builder runProcessListenerOnSameThread(boolean runProcessListenerOnSameThread) { - this.runProcessListenerOnSameThread = runProcessListenerOnSameThread; - return this; - } - - /** - * @return A new {@link ProcessModelTransaction}. Subsequent calls to this method produce - * new instances. - */ - public ProcessModelTransaction build() { - return new ProcessModelTransaction<>(this); - } - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ProcessModelTransaction.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ProcessModelTransaction.kt new file mode 100644 index 000000000..58d7384b4 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ProcessModelTransaction.kt @@ -0,0 +1,183 @@ +package com.raizlabs.android.dbflow.structure.database.transaction + +import com.raizlabs.android.dbflow.config.databaseForTable +import com.raizlabs.android.dbflow.structure.Model +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper + +/** + * Description: Allows you to process a single or [List] of models in a transaction. You + * can operate on a set of [Model] to [Model.save], [Model.update], etc. + */ +class ProcessModelTransaction( + private val models: List = arrayListOf(), + private val processListener: OnModelProcessListener? = null, + private val processModel: ProcessModel, + private val runProcessListenerOnSameThread: Boolean) : ITransaction { + + + /** + * Description: Simple interface for acting on a model in a Transaction or list of [Model] + */ + interface ProcessModel { + + /** + * Called when processing models + * + * @param model The model to process + * @param wrapper + */ + fun processModel(model: TModel, wrapper: DatabaseWrapper) + } + + /** + * Listener for providing callbacks as models are processed in this [ITransaction]. + * + * @param The model class. + */ + interface OnModelProcessListener { + + /** + * Called when model has been operated on. + * + * @param current The current index of items processed. + * @param total The total number of items to process. + * @param modifiedModel The model previously modified. + */ + fun onModelProcessed(current: Long, total: Long, modifiedModel: TModel) + } + + internal constructor(builder: Builder) : this( + processListener = builder.processListener, + models = builder.models, + processModel = builder.processModel, + runProcessListenerOnSameThread = builder.runProcessListenerOnSameThread + ) + + override fun execute(databaseWrapper: DatabaseWrapper) { + val size = models.size + for (i in 0 until size) { + val model = models[i] + processModel.processModel(model, databaseWrapper) + + if (processListener != null) { + if (runProcessListenerOnSameThread) { + processListener.onModelProcessed(i.toLong(), size.toLong(), model) + } else { + Transaction.transactionHandler.post { + processListener.onModelProcessed(i.toLong(), size.toLong(), model) + } + } + } + } + } + + /** + * Makes it easy to build a [ProcessModelTransaction]. + * + * @param + */ + class Builder { + + internal val processModel: ProcessModel + internal var processListener: OnModelProcessListener? = null + internal var models: MutableList = arrayListOf() + internal var runProcessListenerOnSameThread: Boolean = false + + + constructor(processModel: ProcessModel) { + this.processModel = processModel + } + + /** + * @param models The models to process. This constructor creates a new [ArrayList] + * from the [Collection] passed. + * @param processModel The method call interface. + */ + constructor(models: Collection, processModel: ProcessModel) { + this.processModel = processModel + this.models = models.toMutableList() + } + + fun add(model: TModel) = apply { + models.add(model) + } + + /** + * Adds all specified models to the [ArrayList]. + */ + @SafeVarargs + fun addAll(vararg models: TModel) = apply { + this.models.addAll(models.toList()) + } + + /** + * Adds a [Collection] of [Model] to the existing [ArrayList]. + */ + fun addAll(models: Collection?) = apply { + if (models != null) { + this.models.addAll(models) + } + } + + /** + * @param processListener Allows you to listen for when models are processed to update UI, + * this is called on the UI thread. + */ + fun processListener(processListener: OnModelProcessListener) = apply { + this.processListener = processListener + } + + /** + * @param runProcessListenerOnSameThread Default is false. If true we return callback + * on same calling thread, if false we push the callback + * to the UI thread. + */ + fun runProcessListenerOnSameThread(runProcessListenerOnSameThread: Boolean) = apply { + this.runProcessListenerOnSameThread = runProcessListenerOnSameThread + } + + /** + * @return A new [ProcessModelTransaction]. Subsequent calls to this method produce + * new instances. + */ + fun build(): ProcessModelTransaction = ProcessModelTransaction(this) + } +} + + +typealias ProcessFunction = (T, DatabaseWrapper) -> Unit + +/** + * Enables a collection of T objects to easily operate on them within a synchronous database transaction. + */ +inline fun Collection.processInTransaction( + crossinline processFunction: ProcessFunction) { + databaseForTable().executeTransaction { db -> forEach { processFunction(it, db) } } +} + +inline fun processModel(crossinline function: (T, DatabaseWrapper) -> Unit) + = object : ProcessModelTransaction.ProcessModel { + override fun processModel(model: T, wrapper: DatabaseWrapper) = function(model, wrapper) +} + +/** + * Places the [Collection] of items on the [ITransactionQueue]. Use the [processFunction] to perform + * an action on each individual [Model]. This happens on a non-UI thread. + */ +inline fun Collection.processInTransactionAsync( + crossinline processFunction: ProcessFunction, + success: Transaction.Success? = null, + error: Transaction.Error? = null, + processListener: ProcessModelTransaction.OnModelProcessListener? = null) { + val builder = this.processTransaction(processFunction) + processListener?.let { builder.processListener(processListener) } + databaseForTable().beginTransactionAsync(builder.build()) + .success(success) + .error(error) + .execute() +} + +inline fun Collection.processTransaction( + crossinline processFunction: ProcessFunction): ProcessModelTransaction.Builder = + ProcessModelTransaction.Builder(processModel { model, wrapper -> processFunction(model, wrapper) }) + .addAll(this) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/QueryTransaction.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/QueryTransaction.java deleted file mode 100644 index f96b7e562..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/QueryTransaction.java +++ /dev/null @@ -1,183 +0,0 @@ -package com.raizlabs.android.dbflow.structure.database.transaction; - -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.sql.language.CursorResult; -import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; - -import java.util.List; - -/** - * Description: Provides an easy way to query for data asynchronously. - */ -public class QueryTransaction implements ITransaction { - - /** - * Simple interface that provides callback on result. - * - * @param The result that we got from querying. - */ - public interface QueryResultCallback { - - /** - * Called when the query completes. - * - * @param transaction The transaction that ran. - * @param tResult The result of the query. Use this object to get data that you need. - */ - void onQueryResult(@NonNull QueryTransaction transaction, - @NonNull CursorResult tResult); - } - - /** - * Simple interface that provides {@link List} callback on result. - * - * @param The result that we got from querying. - */ - public interface QueryResultListCallback { - - /** - * Called when the query completes. - * - * @param transaction The transaction that ran. - * @param tResult The {@link List} result of the query. - */ - void onListQueryResult(QueryTransaction transaction, @NonNull List tResult); - } - - /** - * Simple interface that provides single {@link TResult} callback on result. - * - * @param The result that we got from querying. - */ - public interface QueryResultSingleCallback { - - /** - * Called when the query completes. - * - * @param transaction The transaction that ran. - * @param tResult The single result of the query. - */ - void onSingleQueryResult(QueryTransaction transaction, @Nullable TResult tResult); - } - - final ModelQueriable modelQueriable; - final QueryResultCallback queryResultCallback; - final QueryResultListCallback queryResultListCallback; - final QueryResultSingleCallback queryResultSingleCallback; - final boolean runResultCallbacksOnSameThread; - - QueryTransaction(Builder builder) { - modelQueriable = builder.modelQueriable; - queryResultCallback = builder.queryResultCallback; - queryResultListCallback = builder.queryResultListCallback; - queryResultSingleCallback = builder.queryResultSingleCallback; - runResultCallbacksOnSameThread = builder.runResultCallbacksOnSameThread; - } - - @Override - public void execute(DatabaseWrapper databaseWrapper) { - final CursorResult cursorResult = modelQueriable.queryResults(); - if (queryResultCallback != null) { - if (runResultCallbacksOnSameThread) { - queryResultCallback.onQueryResult(this, cursorResult); - } else { - Transaction.getTransactionHandler().post(new Runnable() { - @Override - public void run() { - queryResultCallback.onQueryResult(QueryTransaction.this, cursorResult); - } - }); - } - } - - if (queryResultListCallback != null) { - final List resultList = cursorResult.toListClose(); - if (runResultCallbacksOnSameThread) { - queryResultListCallback.onListQueryResult(this, resultList); - } else { - Transaction.getTransactionHandler().post(new Runnable() { - @Override - public void run() { - queryResultListCallback.onListQueryResult(QueryTransaction.this, resultList); - } - }); - } - } - - if (queryResultSingleCallback != null) { - final TResult result = cursorResult.toModelClose(); - if (runResultCallbacksOnSameThread) { - queryResultSingleCallback.onSingleQueryResult(this, result); - } else { - Transaction.getTransactionHandler().post(new Runnable() { - @Override - public void run() { - queryResultSingleCallback.onSingleQueryResult(QueryTransaction.this, result); - } - }); - } - } - } - - /** - * Provides easy way to build a {@link QueryTransaction}. - * - * @param - */ - public static final class Builder { - - final ModelQueriable modelQueriable; - QueryResultCallback queryResultCallback; - QueryResultListCallback queryResultListCallback; - QueryResultSingleCallback queryResultSingleCallback; - boolean runResultCallbacksOnSameThread; - - public Builder(@NonNull ModelQueriable modelQueriable) { - this.modelQueriable = modelQueriable; - } - - /** - * Called when transaction completes and use this to get results. - */ - public Builder queryResult(QueryResultCallback queryResultCallback) { - this.queryResultCallback = queryResultCallback; - return this; - } - - /** - * Called when transaction completes, which returns a {@link List} result. - */ - public Builder queryListResult(QueryResultListCallback queryResultListCallback) { - this.queryResultListCallback = queryResultListCallback; - return this; - } - - /** - * Called when transaction completes, which returns a single {@link TResult}. - */ - public Builder querySingleResult(QueryResultSingleCallback queryResultSingleCallback) { - this.queryResultSingleCallback = queryResultSingleCallback; - return this; - } - - /** - * Runs result callback on UI thread by default. setting this to true would run the callback - * synchrously on the same thread this transaction executes from. - */ - public Builder runResultCallbacksOnSameThread(boolean runResultCallbacksOnSameThread) { - this.runResultCallbacksOnSameThread = runResultCallbacksOnSameThread; - return this; - } - - /** - * @return A new {@link QueryTransaction}. Subsequent calls to this method produce new - * instances. - */ - public QueryTransaction build() { - return new QueryTransaction<>(this); - } - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/QueryTransaction.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/QueryTransaction.kt new file mode 100644 index 000000000..d1d15ebd9 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/QueryTransaction.kt @@ -0,0 +1,155 @@ +package com.raizlabs.android.dbflow.structure.database.transaction + +import com.raizlabs.android.dbflow.sql.language.CursorResult +import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper + +/** + * Description: Provides an easy way to query for data asynchronously. + */ +class QueryTransaction( + private val modelQueriable: ModelQueriable, + private val queryResultCallback: QueryResultCallback? = null, + private val queryResultListCallback: QueryResultListCallback? = null, + private val queryResultSingleCallback: QueryResultSingleCallback? = null, + private val runResultCallbacksOnSameThread: Boolean = true) : ITransaction { + + /** + * Simple interface that provides callback on result. + * + * @param The result that we got from querying. + */ + interface QueryResultCallback { + + /** + * Called when the query completes. + * + * @param transaction The transaction that ran. + * @param tResult The result of the query. Use this object to get data that you need. + */ + fun onQueryResult(transaction: QueryTransaction, + tResult: CursorResult) + } + + /** + * Simple interface that provides [List] callback on result. + * + * @param The result that we got from querying. + */ + interface QueryResultListCallback { + + /** + * Called when the query completes. + * + * @param transaction The transaction that ran. + * @param tResult The [List] result of the query. + */ + fun onListQueryResult(transaction: QueryTransaction<*>, tResult: List) + } + + /** + * Simple interface that provides single [T] callback on result. + * + * @param The result that we got from querying. + */ + interface QueryResultSingleCallback { + + /** + * Called when the query completes. + * + * @param transaction The transaction that ran. + * @param tResult The single result of the query. + */ + fun onSingleQueryResult(transaction: QueryTransaction<*>, tResult: TResult?) + } + + internal constructor(builder: Builder) : this( + modelQueriable = builder.modelQueriable, + queryResultCallback = builder.queryResultCallback, + queryResultListCallback = builder.queryResultListCallback, + queryResultSingleCallback = builder.queryResultSingleCallback, + runResultCallbacksOnSameThread = builder.runResultCallbacksOnSameThread + ) + + override fun execute(databaseWrapper: DatabaseWrapper) { + val cursorResult = modelQueriable.queryResults() + if (queryResultCallback != null) { + if (runResultCallbacksOnSameThread) { + queryResultCallback.onQueryResult(this, cursorResult) + } else { + Transaction.transactionHandler.post { + queryResultCallback.onQueryResult(this@QueryTransaction, cursorResult) + } + } + } + + if (queryResultListCallback != null) { + val resultList = cursorResult.toListClose() + if (runResultCallbacksOnSameThread) { + queryResultListCallback.onListQueryResult(this, resultList) + } else { + Transaction.transactionHandler.post { + queryResultListCallback.onListQueryResult(this@QueryTransaction, resultList) + } + } + } + + if (queryResultSingleCallback != null) { + val result = cursorResult.toModelClose() + if (runResultCallbacksOnSameThread) { + queryResultSingleCallback.onSingleQueryResult(this, result) + } else { + Transaction.transactionHandler.post { + queryResultSingleCallback.onSingleQueryResult(this@QueryTransaction, result) + } + } + } + } + + /** + * Provides easy way to build a [QueryTransaction]. + * + * @param + */ + class Builder(internal val modelQueriable: ModelQueriable) { + internal var queryResultCallback: QueryResultCallback? = null + internal var queryResultListCallback: QueryResultListCallback? = null + internal var queryResultSingleCallback: QueryResultSingleCallback? = null + internal var runResultCallbacksOnSameThread: Boolean = false + + /** + * Called when transaction completes and use this to get results. + */ + fun queryResult(queryResultCallback: QueryResultCallback?) = apply { + this.queryResultCallback = queryResultCallback + } + + /** + * Called when transaction completes, which returns a [List] result. + */ + fun queryListResult(queryResultListCallback: QueryResultListCallback?) = apply { + this.queryResultListCallback = queryResultListCallback + } + + /** + * Called when transaction completes, which returns a single [T]. + */ + fun querySingleResult(queryResultSingleCallback: QueryResultSingleCallback?) = apply { + this.queryResultSingleCallback = queryResultSingleCallback + } + + /** + * Runs result callback on UI thread by default. setting this to true would run the callback + * synchrously on the same thread this transaction executes from. + */ + fun runResultCallbacksOnSameThread(runResultCallbacksOnSameThread: Boolean) = apply { + this.runResultCallbacksOnSameThread = runResultCallbacksOnSameThread + } + + /** + * @return A new [QueryTransaction]. Subsequent calls to this method produce new + * instances. + */ + fun build(): QueryTransaction = QueryTransaction(this) + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Transaction.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Transaction.java deleted file mode 100644 index 5f5a4bd64..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Transaction.java +++ /dev/null @@ -1,262 +0,0 @@ -package com.raizlabs.android.dbflow.structure.database.transaction; - -import android.os.Handler; -import android.os.Looper; -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.config.DatabaseDefinition; -import com.raizlabs.android.dbflow.config.FlowLog; -import com.raizlabs.android.dbflow.runtime.BaseTransactionManager; - -/** - * Description: The main transaction class. It represents a transaction that occurs in the database. - * This is a handy class that allows you to wrap up a set of database modification (or queries) into - * a code block that gets accessed all on the same thread, in the same queue. This can prevent locking - * and synchronization issues when trying to read and write from the database at the same time. - *

- * To create one, the recommended method is to use the {@link DatabaseDefinition#beginTransactionAsync(ITransaction)}. - */ -public final class Transaction { - - /** - * Callback when a {@link ITransaction} failed because of an exception. - */ - public interface Error { - - /** - * Called when transaction fails. - * - * @param transaction The transaction that failed. - * @param error The error that was thrown. - */ - void onError(@NonNull Transaction transaction, - @NonNull Throwable error); - } - - /** - * Interface callback when a {@link ITransaction} was successful. - */ - public interface Success { - - /** - * Called when a transaction succeeded. - * - * @param transaction The transaction that succeeded. - */ - void onSuccess(@NonNull Transaction transaction); - } - - private static Handler TRANSACTION_HANDLER; - - static Handler getTransactionHandler() { - if (TRANSACTION_HANDLER == null) { - TRANSACTION_HANDLER = new Handler(Looper.getMainLooper()); - } - return TRANSACTION_HANDLER; - } - - - final Error errorCallback; - final Success successCallback; - final ITransaction transaction; - final DatabaseDefinition databaseDefinition; - final String name; - final boolean shouldRunInTransaction; - final boolean runCallbacksOnSameThread; - - - Transaction(Builder builder) { - databaseDefinition = builder.databaseDefinition; - errorCallback = builder.errorCallback; - successCallback = builder.successCallback; - transaction = builder.transaction; - name = builder.name; - shouldRunInTransaction = builder.shouldRunInTransaction; - runCallbacksOnSameThread = builder.runCallbacksOnSameThread; - } - - @Nullable - public Error error() { - return errorCallback; - } - - @Nullable - public Success success() { - return successCallback; - } - - @NonNull - public ITransaction transaction() { - return transaction; - } - - @Nullable - public String name() { - return name; - } - - /** - * Runs the transaction in the {@link BaseTransactionManager} of the associated database. - */ - public void execute() { - databaseDefinition.getTransactionManager().addTransaction(this); - } - - /** - * Cancels a transaction that has not run yet. - */ - public void cancel() { - databaseDefinition.getTransactionManager().cancelTransaction(this); - } - - /** - * Executes the transaction immediately on the same thread from which it is called. This calls - * the {@link DatabaseDefinition#executeTransaction(ITransaction)} method, which runs the - * {@link #transaction()} in a database transaction. - */ - public void executeSync() { - try { - if (shouldRunInTransaction) { - databaseDefinition.executeTransaction(transaction); - } else { - transaction.execute(databaseDefinition.getWritableDatabase()); - } - if (successCallback != null) { - if (runCallbacksOnSameThread) { - successCallback.onSuccess(this); - } else { - getTransactionHandler().post(new Runnable() { - @Override - public void run() { - successCallback.onSuccess(Transaction.this); - } - }); - } - } - } catch (final Throwable throwable) { - FlowLog.logError(throwable); - if (errorCallback != null) { - if (runCallbacksOnSameThread) { - errorCallback.onError(this, throwable); - } else { - getTransactionHandler().post(new Runnable() { - @Override - public void run() { - errorCallback.onError(Transaction.this, throwable); - } - }); - } - } else { - throw new RuntimeException("An exception occurred while executing a transaction", throwable); - } - } - } - - @NonNull - public Builder newBuilder() { - return new Builder(transaction, databaseDefinition) - .error(errorCallback) - .success(successCallback) - .name(name) - .shouldRunInTransaction(shouldRunInTransaction) - .runCallbacksOnSameThread(runCallbacksOnSameThread); - } - - /** - * The main entry point into {@link Transaction}, this provides an easy way to build up transactions. - */ - public static final class Builder { - - final ITransaction transaction; - @NonNull final DatabaseDefinition databaseDefinition; - Error errorCallback; - Success successCallback; - String name; - boolean shouldRunInTransaction = true; - private boolean runCallbacksOnSameThread; - - - /** - * @param transaction The interface that actually executes the transaction. - * @param databaseDefinition The database this transaction will run on. Should be the same - * DB as the code that the transaction runs in. - */ - public Builder(@NonNull ITransaction transaction, @NonNull DatabaseDefinition databaseDefinition) { - this.transaction = transaction; - this.databaseDefinition = databaseDefinition; - } - - /** - * Specify an error callback to return all and any {@link Throwable} that occured during a {@link Transaction}. - */ - @NonNull - public Builder error(@Nullable Error errorCallback) { - this.errorCallback = errorCallback; - return this; - } - - /** - * Specify a listener for successful transactions. This is called when the {@link ITransaction} - * specified is finished and it is posted on the UI thread. - * - * @param successCallback The callback, invoked on the UI thread. - */ - @NonNull - public Builder success(@Nullable Success successCallback) { - this.successCallback = successCallback; - return this; - } - - /** - * Give this transaction a name. This will allow you to call {@link ITransactionQueue#cancel(String)}. - * - * @param name The name of this transaction. Should be unique for any transaction currently - * running in the {@link ITransactionQueue}. - */ - @NonNull - public Builder name(@Nullable String name) { - this.name = name; - return this; - } - - /** - * @param shouldRunInTransaction True is default. If true, we run this {@link Transaction} in - * a database transaction. If this is not necessary (usually for - * {@link QueryTransaction}), you should specify false. - * @return - */ - @NonNull - public Builder shouldRunInTransaction(boolean shouldRunInTransaction) { - this.shouldRunInTransaction = shouldRunInTransaction; - return this; - } - - /** - * @param runCallbacksOnSameThread Default is false. If true we return the callbacks from - * this {@link Transaction} on the same thread we call - * {@link #execute()} from. - */ - @NonNull - public Builder runCallbacksOnSameThread(boolean runCallbacksOnSameThread) { - this.runCallbacksOnSameThread = runCallbacksOnSameThread; - return this; - } - - /** - * @return A new instance of {@link Transaction}. Subsequent calls to this method produce - * new instances. - */ - @NonNull - public Transaction build() { - return new Transaction(this); - } - - /** - * Convenience method to simply execute a transaction. - */ - public void execute() { - build().execute(); - } - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Transaction.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Transaction.kt new file mode 100644 index 000000000..0cb6c86e5 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Transaction.kt @@ -0,0 +1,220 @@ +package com.raizlabs.android.dbflow.structure.database.transaction + +import android.os.Handler +import android.os.Looper + +import com.raizlabs.android.dbflow.config.DatabaseDefinition +import com.raizlabs.android.dbflow.config.FlowLog +import com.raizlabs.android.dbflow.runtime.BaseTransactionManager + +/** + * Description: The main transaction class. It represents a transaction that occurs in the database. + * This is a handy class that allows you to wrap up a set of database modification (or queries) into + * a code block that gets accessed all on the same thread, in the same queue. This can prevent locking + * and synchronization issues when trying to read and write from the database at the same time. + * + * + * To create one, the recommended method is to use the [DatabaseDefinition.beginTransactionAsync]. + */ +class Transaction(private val transaction: ITransaction, + private val databaseDefinition: DatabaseDefinition, + private val errorCallback: Error? = null, + private val successCallback: Success? = null, + private val name: String?, + private val shouldRunInTransaction: Boolean = true, + private val runCallbacksOnSameThread: Boolean = true) { + + + /** + * Callback when a [ITransaction] failed because of an exception. + */ + interface Error { + + /** + * Called when transaction fails. + * + * @param transaction The transaction that failed. + * @param error The error that was thrown. + */ + fun onError(transaction: Transaction, + error: Throwable) + } + + /** + * Interface callback when a [ITransaction] was successful. + */ + interface Success { + + /** + * Called when a transaction succeeded. + * + * @param transaction The transaction that succeeded. + */ + fun onSuccess(transaction: Transaction) + } + + + internal constructor(builder: Builder) : this( + databaseDefinition = builder.databaseDefinition, + errorCallback = builder.errorCallback, + successCallback = builder.successCallback, + transaction = builder.transaction, + name = builder.name, + shouldRunInTransaction = builder.shouldRunInTransaction, + runCallbacksOnSameThread = builder.runCallbacksOnSameThread + ) + + fun error(): Error? = errorCallback + + fun success(): Success? = successCallback + + fun transaction(): ITransaction = transaction + + fun name(): String? = name + + /** + * Runs the transaction in the [BaseTransactionManager] of the associated database. + */ + fun execute() { + databaseDefinition.transactionManager.addTransaction(this) + } + + /** + * Cancels a transaction that has not run yet. + */ + fun cancel() { + databaseDefinition.transactionManager.cancelTransaction(this) + } + + /** + * Executes the transaction immediately on the same thread from which it is called. This calls + * the [DatabaseDefinition.executeTransaction] method, which runs the + * [.transaction] in a database transaction. + */ + fun executeSync() { + try { + if (shouldRunInTransaction) { + databaseDefinition.executeTransaction(transaction) + } else { + transaction.execute(databaseDefinition.writableDatabase) + } + if (successCallback != null) { + if (runCallbacksOnSameThread) { + successCallback.onSuccess(this) + } else { + transactionHandler.post { successCallback.onSuccess(this@Transaction) } + } + } + } catch (throwable: Throwable) { + FlowLog.logError(throwable) + if (errorCallback != null) { + if (runCallbacksOnSameThread) { + errorCallback.onError(this, throwable) + } else { + transactionHandler.post { errorCallback.onError(this@Transaction, throwable) } + } + } else { + throw RuntimeException("An exception occurred while executing a transaction", throwable) + } + } + + } + + fun newBuilder(): Builder { + return Builder(transaction, databaseDefinition) + .error(errorCallback) + .success(successCallback) + .name(name) + .shouldRunInTransaction(shouldRunInTransaction) + .runCallbacksOnSameThread(runCallbacksOnSameThread) + } + + /** + * The main entry point into [Transaction], this provides an easy way to build up transactions. + */ + class Builder + /** + * @param transaction The interface that actually executes the transaction. + * @param databaseDefinition The database this transaction will run on. Should be the same + * DB as the code that the transaction runs in. + */ + (internal val transaction: ITransaction, internal val databaseDefinition: DatabaseDefinition) { + internal var errorCallback: Error? = null + internal var successCallback: Success? = null + internal var name: String? = null + internal var shouldRunInTransaction = true + internal var runCallbacksOnSameThread: Boolean = false + + /** + * Specify an error callback to return all and any [Throwable] that occured during a [Transaction]. + */ + fun error(errorCallback: Error?) = apply { + this.errorCallback = errorCallback + } + + /** + * Specify a listener for successful transactions. This is called when the [ITransaction] + * specified is finished and it is posted on the UI thread. + * + * @param successCallback The callback, invoked on the UI thread. + */ + fun success(successCallback: Success?) = apply { + this.successCallback = successCallback + } + + /** + * Give this transaction a name. This will allow you to call [ITransactionQueue.cancel]. + * + * @param name The name of this transaction. Should be unique for any transaction currently + * running in the [ITransactionQueue]. + */ + fun name(name: String?) = apply { + this.name = name + } + + /** + * @param shouldRunInTransaction True is default. If true, we run this [Transaction] in + * a database transaction. If this is not necessary (usually for + * [QueryTransaction]), you should specify false. + * @return + */ + fun shouldRunInTransaction(shouldRunInTransaction: Boolean) = apply { + this.shouldRunInTransaction = shouldRunInTransaction + } + + /** + * @param runCallbacksOnSameThread Default is false. If true we return the callbacks from + * this [Transaction] on the same thread we call + * [.execute] from. + */ + fun runCallbacksOnSameThread(runCallbacksOnSameThread: Boolean) = apply { + this.runCallbacksOnSameThread = runCallbacksOnSameThread + } + + /** + * @return A new instance of [Transaction]. Subsequent calls to this method produce + * new instances. + */ + fun build(): Transaction = Transaction(this) + + /** + * Convenience method to simply execute a transaction. + */ + fun execute() { + build().execute() + } + } + + companion object { + + internal val transactionHandler: Handler by lazy { Handler(Looper.getMainLooper()) } + } +} + +inline fun transactionSuccess(crossinline function: (Transaction) -> Unit) = object : Transaction.Success { + override fun onSuccess(transaction: Transaction) = function(transaction) +} + +inline fun transactionError(crossinline function: (Transaction, Throwable) -> Unit) = object : Transaction.Error { + override fun onError(transaction: Transaction, error: Throwable) = function(transaction, error) +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/TransactionWrapper.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/TransactionWrapper.java deleted file mode 100644 index 4ef0b1bc7..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/TransactionWrapper.java +++ /dev/null @@ -1,31 +0,0 @@ -package com.raizlabs.android.dbflow.structure.database.transaction; - -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collection; -import java.util.List; - -/** - * Description: Wraps multiple transactions together. - */ -public class TransactionWrapper implements ITransaction { - - private final List transactions = new ArrayList<>(); - - public TransactionWrapper(ITransaction... transactions) { - this.transactions.addAll(Arrays.asList(transactions)); - } - - public TransactionWrapper(Collection transactions) { - this.transactions.addAll(transactions); - } - - @Override - public void execute(DatabaseWrapper databaseWrapper) { - for (ITransaction transaction : transactions) { - transaction.execute(databaseWrapper); - } - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/TransactionWrapper.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/TransactionWrapper.kt new file mode 100644 index 000000000..4da0ac00b --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/TransactionWrapper.kt @@ -0,0 +1,24 @@ +package com.raizlabs.android.dbflow.structure.database.transaction + +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import java.util.* + +/** + * Description: Wraps multiple transactions together. + */ +class TransactionWrapper : ITransaction { + + private val transactions = ArrayList() + + constructor(vararg transactions: ITransaction) { + this.transactions.addAll(Arrays.asList(*transactions)) + } + + constructor(transactions: Collection) { + this.transactions.addAll(transactions) + } + + override fun execute(databaseWrapper: DatabaseWrapper) { + transactions.forEach { it.execute(databaseWrapper) } + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/listener/ContentValuesListener.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/listener/ContentValuesListener.java deleted file mode 100644 index 813059056..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/listener/ContentValuesListener.java +++ /dev/null @@ -1,41 +0,0 @@ -package com.raizlabs.android.dbflow.structure.listener; - -import android.content.ContentValues; - -import com.raizlabs.android.dbflow.annotation.provider.ContentProvider; -import com.raizlabs.android.dbflow.structure.Model; -import com.raizlabs.android.dbflow.structure.ModelAdapter; - -/** - * Description: Called after the declared {@link ContentValues} are binded. It enables - * us to listen and add custom behavior to the {@link ContentValues}. These must be - * defined in a {@link Model} class to register properly. - *

- * This class will no longer get called during updates unless explicit call to - * {@link ModelAdapter#bindToContentValues(ContentValues, Object)} - * or {@link ModelAdapter#bindToInsertValues(ContentValues, Object)} - * - * @see SQLiteStatementListener - */ -@Deprecated -public interface ContentValuesListener { - - /** - * Called during an {@link Model#update()} and at the end of - * {@link ModelAdapter#bindToContentValues(ContentValues, Object)} - * . It enables you to customly change the values as necessary during update to the database. - * - * @param contentValues The content values to bind to for an update. - */ - void onBindToContentValues(ContentValues contentValues); - - /** - * Called during an {@link Model#update()} and at the end of - * {@link ModelAdapter#bindToInsertValues(ContentValues, Object)}. - * It enables you to customly change the values as necessary during insert - * to the database for a {@link ContentProvider}. - * - * @param contentValues The content values to insert into DB for a {@link ContentProvider} - */ - void onBindToInsertValues(ContentValues contentValues); -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/listener/ContentValuesListener.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/listener/ContentValuesListener.kt new file mode 100644 index 000000000..5f3aef9bb --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/listener/ContentValuesListener.kt @@ -0,0 +1,42 @@ +package com.raizlabs.android.dbflow.structure.listener + +import android.content.ContentValues + +import com.raizlabs.android.dbflow.annotation.provider.ContentProvider +import com.raizlabs.android.dbflow.structure.Model +import com.raizlabs.android.dbflow.structure.ModelAdapter + +/** + * Description: Called after the declared [ContentValues] are binded. It enables + * us to listen and add custom behavior to the [ContentValues]. These must be + * defined in a [Model] class to register properly. + * + * + * This class will no longer get called during updates unless explicit call to + * [ModelAdapter.bindToContentValues] + * or [ModelAdapter.bindToInsertValues] + * + * @see SQLiteStatementListener + */ +@Deprecated("") +interface ContentValuesListener { + + /** + * Called during an [Model.update] and at the end of + * [ModelAdapter.bindToContentValues] + * . It enables you to customly change the values as necessary during update to the database. + * + * @param contentValues The content values to bind to for an update. + */ + fun onBindToContentValues(contentValues: ContentValues) + + /** + * Called during an [Model.update] and at the end of + * [ModelAdapter.bindToInsertValues]. + * It enables you to customly change the values as necessary during insert + * to the database for a [ContentProvider]. + * + * @param contentValues The content values to insert into DB for a [ContentProvider] + */ + fun onBindToInsertValues(contentValues: ContentValues) +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/listener/LoadFromCursorListener.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/listener/LoadFromCursorListener.java deleted file mode 100644 index e0d52053a..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/listener/LoadFromCursorListener.java +++ /dev/null @@ -1,20 +0,0 @@ -package com.raizlabs.android.dbflow.structure.listener; - -import android.database.Cursor; -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.structure.Model; - -/** - * Description: Marks a {@link Model} as listening to {@link Cursor} - * events for custom handling when loading from the DB. - */ -public interface LoadFromCursorListener { - - /** - * Called when the {@link Model} is loaded from the DB. - * - * @param cursor The cursor that is loaded. - */ - void onLoadFromCursor(@NonNull Cursor cursor); -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/listener/LoadFromCursorListener.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/listener/LoadFromCursorListener.kt new file mode 100644 index 000000000..eb7ff0da5 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/listener/LoadFromCursorListener.kt @@ -0,0 +1,19 @@ +package com.raizlabs.android.dbflow.structure.listener + +import android.database.Cursor + +import com.raizlabs.android.dbflow.structure.Model + +/** + * Description: Marks a [Model] as listening to [Cursor] + * events for custom handling when loading from the DB. + */ +interface LoadFromCursorListener { + + /** + * Called when the [Model] is loaded from the DB. + * + * @param cursor The cursor that is loaded. + */ + fun onLoadFromCursor(cursor: Cursor) +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/listener/SQLiteStatementListener.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/listener/SQLiteStatementListener.java deleted file mode 100644 index 788f89a6c..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/listener/SQLiteStatementListener.java +++ /dev/null @@ -1,41 +0,0 @@ -package com.raizlabs.android.dbflow.structure.listener; - -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.structure.InternalAdapter; -import com.raizlabs.android.dbflow.structure.Model; -import com.raizlabs.android.dbflow.structure.ModelAdapter; -import com.raizlabs.android.dbflow.structure.database.DatabaseStatement; - -/** - * Description: Marks a {@link Model} as subscribing to the {@link DatabaseStatement} - * that is used to {@link Model#insert()} a model into the DB. - */ -public interface SQLiteStatementListener { - - /** - * Called at the end of {@link InternalAdapter#bindToStatement(DatabaseStatement, Object)} - * Perform a custom manipulation of the statement as willed. - * - * @param databaseStatement The statement from the {@link ModelAdapter} - */ - void onBindToStatement(@NonNull DatabaseStatement databaseStatement); - - /** - * Called at the end of {@link InternalAdapter#bindToInsertStatement(DatabaseStatement, Object)} - * Perform a custom manipulation of the statement as willed. - * - * @param databaseStatement The insert statement from the {@link ModelAdapter} - */ - void onBindToInsertStatement(@NonNull DatabaseStatement databaseStatement); - - /** - * Called at the end of {@link InternalAdapter#bindToUpdateStatement(DatabaseStatement, Object)} - * Perform a custom manipulation of the statement as willed. - * - * @param databaseStatement The insert statement from the {@link ModelAdapter} - */ - void onBindToUpdateStatement(@NonNull DatabaseStatement databaseStatement); - - void onBindToDeleteStatement(@NonNull DatabaseStatement databaseStatement); -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/listener/SQLiteStatementListener.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/listener/SQLiteStatementListener.kt new file mode 100644 index 000000000..a60ae4328 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/listener/SQLiteStatementListener.kt @@ -0,0 +1,39 @@ +package com.raizlabs.android.dbflow.structure.listener + +import com.raizlabs.android.dbflow.structure.InternalAdapter +import com.raizlabs.android.dbflow.structure.Model +import com.raizlabs.android.dbflow.structure.ModelAdapter +import com.raizlabs.android.dbflow.structure.database.DatabaseStatement + +/** + * Description: Marks a [Model] as subscribing to the [DatabaseStatement] + * that is used to [Model.insert] a model into the DB. + */ +interface SQLiteStatementListener { + + /** + * Called at the end of [InternalAdapter.bindToStatement] + * Perform a custom manipulation of the statement as willed. + * + * @param databaseStatement The statement from the [ModelAdapter] + */ + fun onBindToStatement(databaseStatement: DatabaseStatement) + + /** + * Called at the end of [InternalAdapter.bindToInsertStatement] + * Perform a custom manipulation of the statement as willed. + * + * @param databaseStatement The insert statement from the [ModelAdapter] + */ + fun onBindToInsertStatement(databaseStatement: DatabaseStatement) + + /** + * Called at the end of [InternalAdapter.bindToUpdateStatement] + * Perform a custom manipulation of the statement as willed. + * + * @param databaseStatement The insert statement from the [ModelAdapter] + */ + fun onBindToUpdateStatement(databaseStatement: DatabaseStatement) + + fun onBindToDeleteStatement(databaseStatement: DatabaseStatement) +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/BaseProviderModel.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/BaseProviderModel.java deleted file mode 100644 index 99442795f..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/BaseProviderModel.java +++ /dev/null @@ -1,84 +0,0 @@ -package com.raizlabs.android.dbflow.structure.provider; - -import android.content.ContentProvider; -import android.database.Cursor; -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.config.FlowManager; -import com.raizlabs.android.dbflow.sql.language.OperatorGroup; -import com.raizlabs.android.dbflow.structure.BaseModel; -import com.raizlabs.android.dbflow.structure.Model; -import com.raizlabs.android.dbflow.structure.database.FlowCursor; - -/** - * Description: Provides a base implementation of a {@link Model} backed - * by a content provider. All model operations are overridden using the {@link ContentUtils}. - * Consider using a {@link BaseSyncableProviderModel} if you wish to - * keep modifications locally from the {@link ContentProvider} - */ -public abstract class BaseProviderModel - extends BaseModel implements ModelProvider { - - @Override - public boolean delete() { - return ContentUtils.delete(getDeleteUri(), this) > 0; - } - - @Override - public boolean save() { - int count = ContentUtils.update(getUpdateUri(), this); - if (count == 0) { - return ContentUtils.insert(getInsertUri(), this) != null; - } else { - return count > 0; - } - } - - @Override - public boolean update() { - return ContentUtils.update(getUpdateUri(), this) > 0; - } - - @Override - public long insert() { - ContentUtils.insert(getInsertUri(), this); - return 0; - } - - /** - * Runs a query on the {@link ContentProvider} to see if it returns data. - * - * @return true if this model exists in the {@link ContentProvider} based on its primary keys. - */ - @Override - @SuppressWarnings("unchecked") - public boolean exists() { - Cursor cursor = ContentUtils.query(FlowManager.getContext().getContentResolver(), - getQueryUri(), getModelAdapter().getPrimaryConditionClause(this), ""); - boolean exists = (cursor != null && cursor.getCount() > 0); - if (cursor != null) { - cursor.close(); - } - return exists; - } - - @Override - @SuppressWarnings("unchecked") - public void load(@NonNull OperatorGroup whereConditions, - @Nullable String orderBy, String... columns) { - FlowCursor cursor = FlowCursor.from(ContentUtils.query(FlowManager.getContext().getContentResolver(), - getQueryUri(), whereConditions, orderBy, columns)); - if (cursor != null && cursor.moveToFirst()) { - getModelAdapter().loadFromCursor(cursor, this); - cursor.close(); - } - } - - @Override - @SuppressWarnings("unchecked") - public void load() { - load(getModelAdapter().getPrimaryConditionClause(this), ""); - } - -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/BaseProviderModel.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/BaseProviderModel.kt new file mode 100644 index 000000000..ca3d2924b --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/BaseProviderModel.kt @@ -0,0 +1,66 @@ +package com.raizlabs.android.dbflow.structure.provider + +import android.content.ContentProvider +import com.raizlabs.android.dbflow.config.FlowManager +import com.raizlabs.android.dbflow.sql.language.OperatorGroup +import com.raizlabs.android.dbflow.structure.BaseModel +import com.raizlabs.android.dbflow.structure.Model +import com.raizlabs.android.dbflow.structure.database.FlowCursor + +/** + * Description: Provides a base implementation of a [Model] backed + * by a content provider. All model operations are overridden using the [ContentUtils]. + * Consider using a [BaseSyncableProviderModel] if you wish to + * keep modifications locally from the [ContentProvider] + */ +abstract class BaseProviderModel : BaseModel(), ModelProvider { + + override fun delete(): Boolean = ContentUtils.delete(deleteUri, this) > 0 + + override fun save(): Boolean { + val count = ContentUtils.update(updateUri, this) + return if (count == 0) { + ContentUtils.insert(insertUri, this) != null + } else { + count > 0 + } + } + + override fun update(): Boolean = ContentUtils.update(updateUri, this) > 0 + + override fun insert(): Long { + ContentUtils.insert(insertUri, this) + return 0 + } + + /** + * Runs a query on the [ContentProvider] to see if it returns data. + * + * @return true if this model exists in the [ContentProvider] based on its primary keys. + */ + override fun exists(): Boolean { + val cursor = ContentUtils.query(FlowManager.context.contentResolver, + queryUri, modelAdapter.getPrimaryConditionClause(this), "") + val exists = cursor != null && cursor.count > 0 + cursor?.close() + return exists + } + + override fun load(whereOperatorGroup: OperatorGroup, + orderBy: String?, vararg columns: String?) { + val cursor = ContentUtils.query(FlowManager.context.contentResolver, + queryUri, whereOperatorGroup, orderBy, *columns) + if (cursor != null) { + val flowCursor = FlowCursor.from(cursor) + if (flowCursor.moveToFirst()) { + modelAdapter.loadFromCursor(flowCursor, this) + flowCursor.close() + } + } + } + + override fun load() { + load(modelAdapter.getPrimaryConditionClause(this), "") + } + +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/BaseSyncableProviderModel.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/BaseSyncableProviderModel.java deleted file mode 100644 index 8699e99d8..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/BaseSyncableProviderModel.java +++ /dev/null @@ -1,62 +0,0 @@ -package com.raizlabs.android.dbflow.structure.provider; - -import android.content.ContentProvider; -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.config.FlowManager; -import com.raizlabs.android.dbflow.sql.language.OperatorGroup; -import com.raizlabs.android.dbflow.structure.BaseModel; -import com.raizlabs.android.dbflow.structure.Model; -import com.raizlabs.android.dbflow.structure.database.FlowCursor; - -/** - * Description: Provides a base implementation of a {@link Model} backed - * by a content provider. All operations sync with the content provider in this app from a {@link ContentProvider} - */ -public abstract class BaseSyncableProviderModel extends BaseModel implements ModelProvider { - - @Override - public long insert() { - long rowId = super.insert(); - ContentUtils.insert(getInsertUri(), this); - return rowId; - } - - @Override - public boolean save() { - if (exists()) { - return super.save() && ContentUtils.update(getUpdateUri(), this) > 0; - } else { - return super.save() && ContentUtils.insert(getInsertUri(), this) != null; - } - } - - @Override - public boolean delete() { - return super.delete() && ContentUtils.delete(getDeleteUri(), this) > 0; - } - - @Override - public boolean update() { - return super.update() && ContentUtils.update(getUpdateUri(), this) > 0; - } - - @Override - @SuppressWarnings("unchecked") - public void load(@NonNull OperatorGroup whereOperatorGroup, - @Nullable String orderBy, String... columns) { - FlowCursor cursor = FlowCursor.from(ContentUtils.query(FlowManager.getContext().getContentResolver(), - getQueryUri(), whereOperatorGroup, orderBy, columns)); - if (cursor != null && cursor.moveToFirst()) { - getModelAdapter().loadFromCursor(cursor, this); - cursor.close(); - } - } - - @Override - @SuppressWarnings("unchecked") - public void load() { - load(getModelAdapter().getPrimaryConditionClause(this), ""); - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/BaseSyncableProviderModel.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/BaseSyncableProviderModel.kt new file mode 100644 index 000000000..2ce27e614 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/BaseSyncableProviderModel.kt @@ -0,0 +1,51 @@ +package com.raizlabs.android.dbflow.structure.provider + +import android.content.ContentProvider + +import com.raizlabs.android.dbflow.config.FlowManager +import com.raizlabs.android.dbflow.sql.language.OperatorGroup +import com.raizlabs.android.dbflow.structure.BaseModel +import com.raizlabs.android.dbflow.structure.Model +import com.raizlabs.android.dbflow.structure.database.FlowCursor + +/** + * Description: Provides a base implementation of a [Model] backed + * by a content provider. All operations sync with the content provider in this app from a [ContentProvider] + */ +abstract class BaseSyncableProviderModel : BaseModel(), ModelProvider { + + override fun insert(): Long { + val rowId = super.insert() + ContentUtils.insert(insertUri, this) + return rowId + } + + override fun save(): Boolean { + return if (exists()) { + super.save() && ContentUtils.update(updateUri, this) > 0 + } else { + super.save() && ContentUtils.insert(insertUri, this) != null + } + } + + override fun delete(): Boolean = super.delete() && ContentUtils.delete(deleteUri, this) > 0 + + override fun update(): Boolean = super.update() && ContentUtils.update(updateUri, this) > 0 + + override fun load(whereOperatorGroup: OperatorGroup, + orderBy: String?, vararg columns: String?) { + val cursor = ContentUtils.query(FlowManager.context.contentResolver, + queryUri, whereOperatorGroup, orderBy, *columns) + cursor?.let { + val flowCursor = FlowCursor.from(cursor) + if (flowCursor.moveToFirst()) { + modelAdapter.loadFromCursor(flowCursor, this) + flowCursor.close() + } + } + } + + override fun load() { + load(modelAdapter.getPrimaryConditionClause(this), "") + } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/ContentUtils.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/ContentUtils.java deleted file mode 100644 index 31902791e..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/ContentUtils.java +++ /dev/null @@ -1,296 +0,0 @@ -package com.raizlabs.android.dbflow.structure.provider; - -import android.content.ContentResolver; -import android.content.ContentValues; -import android.database.Cursor; -import android.net.Uri; - -import com.raizlabs.android.dbflow.annotation.provider.ContentProvider; -import com.raizlabs.android.dbflow.config.FlowLog; -import com.raizlabs.android.dbflow.config.FlowManager; -import com.raizlabs.android.dbflow.sql.language.Operator; -import com.raizlabs.android.dbflow.sql.language.OperatorGroup; -import com.raizlabs.android.dbflow.structure.ModelAdapter; -import com.raizlabs.android.dbflow.structure.database.FlowCursor; - -import java.util.ArrayList; -import java.util.List; - -/** - * Description: Provides handy wrapper mechanisms for {@link android.content.ContentProvider} - */ -public class ContentUtils { - - /** - * The default content URI that Android recommends. Not necessary, however. - */ - public static final String BASE_CONTENT_URI = "content://"; - - /** - * Constructs an Uri with the {@link #BASE_CONTENT_URI} and authority. Add paths to append to the Uri. - * - * @param authority The authority for a {@link ContentProvider} - * @param paths The list of paths to append. - * @return A complete Uri for a {@link ContentProvider} - */ - public static Uri buildUriWithAuthority(String authority, String... paths) { - return buildUri(BASE_CONTENT_URI, authority, paths); - } - - /** - * Constructs an Uri with the specified baseContent uri and authority. Add paths to append to the Uri. - * - * @param baseContentUri The base content URI for a {@link ContentProvider} - * @param authority The authority for a {@link ContentProvider} - * @param paths The list of paths to append. - * @return A complete Uri for a {@link ContentProvider} - */ - public static Uri buildUri(String baseContentUri, String authority, String... paths) { - Uri.Builder builder = Uri.parse(baseContentUri + authority).buildUpon(); - for (String path : paths) { - builder.appendPath(path); - } - return builder.build(); - } - - /** - * Inserts the model into the {@link android.content.ContentResolver}. Uses the insertUri to resolve - * the reference and the model to convert its data into {@link android.content.ContentValues} - * - * @param insertUri A {@link android.net.Uri} from the {@link ContentProvider} class definition. - * @param model The model to insert. - * @return A Uri of the inserted data. - */ - public static Uri insert(Uri insertUri, TableClass model) { - return insert(FlowManager.getContext().getContentResolver(), insertUri, model); - } - - /** - * Inserts the model into the {@link android.content.ContentResolver}. Uses the insertUri to resolve - * the reference and the model to convert its data into {@link android.content.ContentValues} - * - * @param contentResolver The content resolver to use (if different from {@link FlowManager#getContext()}) - * @param insertUri A {@link android.net.Uri} from the {@link ContentProvider} class definition. - * @param model The model to insert. - * @return The Uri of the inserted data. - */ - @SuppressWarnings("unchecked") - public static Uri insert(ContentResolver contentResolver, Uri insertUri, TableClass model) { - ModelAdapter adapter = (ModelAdapter) FlowManager.getModelAdapter(model.getClass()); - - ContentValues contentValues = new ContentValues(); - adapter.bindToInsertValues(contentValues, model); - Uri uri = contentResolver.insert(insertUri, contentValues); - adapter.updateAutoIncrement(model, Long.valueOf(uri.getPathSegments().get(uri.getPathSegments().size() - 1))); - return uri; - } - - /** - * Inserts the list of model into the {@link ContentResolver}. Binds all of the models to {@link ContentValues} - * and runs the {@link ContentResolver#bulkInsert(Uri, ContentValues[])} method. Note: if any of these use - * autoIncrementing primary keys the ROWID will not be properly updated from this method. If you care - * use {@link #insert(ContentResolver, Uri, Object)} instead. - * - * @param contentResolver The content resolver to use (if different from {@link FlowManager#getContext()}) - * @param bulkInsertUri The URI to bulk insert with - * @param table The table to insert into - * @param models The models to insert. - * @return The count of the rows affected by the insert. - */ - public static int bulkInsert(ContentResolver contentResolver, Uri bulkInsertUri, - Class table, List models) { - ContentValues[] contentValues = new ContentValues[models == null ? 0 : models.size()]; - ModelAdapter adapter = FlowManager.getModelAdapter(table); - - if (models != null) { - for (int i = 0; i < contentValues.length; i++) { - contentValues[i] = new ContentValues(); - adapter.bindToInsertValues(contentValues[i], models.get(i)); - } - } - return contentResolver.bulkInsert(bulkInsertUri, contentValues); - } - - /** - * Inserts the list of model into the {@link ContentResolver}. Binds all of the models to {@link ContentValues} - * and runs the {@link ContentResolver#bulkInsert(Uri, ContentValues[])} method. Note: if any of these use - * autoincrement primary keys the ROWID will not be properly updated from this method. If you care - * use {@link #insert(Uri, Object)} instead. - * - * @param bulkInsertUri The URI to bulk insert with - * @param table The table to insert into - * @param models The models to insert. - * @return The count of the rows affected by the insert. - */ - public static int bulkInsert(Uri bulkInsertUri, Class table, List models) { - return bulkInsert(FlowManager.getContext().getContentResolver(), bulkInsertUri, table, models); - } - - /** - * Updates the model through the {@link android.content.ContentResolver}. Uses the updateUri to - * resolve the reference and the model to convert its data in {@link android.content.ContentValues} - * - * @param updateUri A {@link android.net.Uri} from the {@link ContentProvider} - * @param model A model to update - * @return The number of rows updated. - */ - public static int update(Uri updateUri, TableClass model) { - return update(FlowManager.getContext().getContentResolver(), updateUri, model); - } - - /** - * Updates the model through the {@link android.content.ContentResolver}. Uses the updateUri to - * resolve the reference and the model to convert its data in {@link android.content.ContentValues} - * - * @param contentResolver The content resolver to use (if different from {@link FlowManager#getContext()}) - * @param updateUri A {@link android.net.Uri} from the {@link ContentProvider} - * @param model The model to update - * @return The number of rows updated. - */ - @SuppressWarnings("unchecked") - public static int update(ContentResolver contentResolver, Uri updateUri, TableClass model) { - ModelAdapter adapter = (ModelAdapter) FlowManager.getModelAdapter(model.getClass()); - - ContentValues contentValues = new ContentValues(); - adapter.bindToContentValues(contentValues, model); - int count = contentResolver.update(updateUri, contentValues, adapter.getPrimaryConditionClause(model).getQuery(), null); - if (count == 0) { - FlowLog.log(FlowLog.Level.W, "Updated failed of: " + model.getClass()); - } - return count; - } - - /** - * Deletes the specified model through the {@link android.content.ContentResolver}. Uses the deleteUri - * to resolve the reference and the model to {@link ModelAdapter#getPrimaryConditionClause(Object)}} - * - * @param deleteUri A {@link android.net.Uri} from the {@link ContentProvider} - * @param model The model to delete - * @return The number of rows deleted. - */ - @SuppressWarnings("unchecked") - public static int delete(Uri deleteUri, TableClass model) { - return delete(FlowManager.getContext().getContentResolver(), deleteUri, model); - } - - /** - * Deletes the specified model through the {@link android.content.ContentResolver}. Uses the deleteUri - * to resolve the reference and the model to {@link ModelAdapter#getPrimaryConditionClause(Object)} - * - * @param contentResolver The content resolver to use (if different from {@link FlowManager#getContext()}) - * @param deleteUri A {@link android.net.Uri} from the {@link ContentProvider} - * @param model The model to delete - * @return The number of rows deleted. - */ - @SuppressWarnings("unchecked") - public static int delete(ContentResolver contentResolver, Uri deleteUri, TableClass model) { - ModelAdapter adapter = (ModelAdapter) FlowManager.getModelAdapter(model.getClass()); - - int count = contentResolver.delete(deleteUri, adapter.getPrimaryConditionClause(model).getQuery(), null); - - // reset autoincrement to 0 - if (count > 0) { - adapter.updateAutoIncrement(model, 0); - } else { - FlowLog.log(FlowLog.Level.W, "A delete on " + model.getClass() + " within the ContentResolver appeared to fail."); - } - return count; - } - - /** - * Queries the {@link android.content.ContentResolver} with the specified query uri. It generates - * the correct query and returns a {@link android.database.Cursor} - * - * @param contentResolver The content resolver to use (if different from {@link FlowManager#getContext()}) - * @param queryUri The URI of the query - * @param whereConditions The set of {@link Operator} to query the content provider. - * @param orderBy The order by clause without the ORDER BY - * @param columns The list of columns to query. - * @return A {@link android.database.Cursor} - */ - public static Cursor query(ContentResolver contentResolver, Uri queryUri, - OperatorGroup whereConditions, - String orderBy, String... columns) { - return contentResolver.query(queryUri, columns, whereConditions.getQuery(), null, orderBy); - } - - /** - * Queries the {@link android.content.ContentResolver} with the specified queryUri. It will generate - * the correct query and return a list of {@link TableClass} - * - * @param queryUri The URI of the query - * @param table The table to get from. - * @param whereConditions The set of {@link Operator} to query the content provider. - * @param orderBy The order by clause without the ORDER BY - * @param columns The list of columns to query. - * @return A list of {@link TableClass} - */ - public static List queryList(Uri queryUri, Class table, - OperatorGroup whereConditions, - String orderBy, String... columns) { - return queryList(FlowManager.getContext().getContentResolver(), queryUri, table, whereConditions, orderBy, columns); - } - - - /** - * Queries the {@link android.content.ContentResolver} with the specified queryUri. It will generate - * the correct query and return a list of {@link TableClass} - * - * @param contentResolver The content resolver to use (if different from {@link FlowManager#getContext()}) - * @param queryUri The URI of the query - * @param table The table to get from. - * @param whereConditions The set of {@link Operator} to query the content provider. - * @param orderBy The order by clause without the ORDER BY - * @param columns The list of columns to query. - * @return A list of {@link TableClass} - */ - public static List queryList(ContentResolver contentResolver, Uri queryUri, - Class table, - OperatorGroup whereConditions, - String orderBy, String... columns) { - FlowCursor cursor = FlowCursor.from(contentResolver.query(queryUri, columns, whereConditions.getQuery(), null, orderBy)); - if (cursor != null) { - return FlowManager.getModelAdapter(table) - .getListModelLoader() - .load(cursor); - } - return new ArrayList<>(); - } - - /** - * Queries the {@link android.content.ContentResolver} with the specified queryUri. It will generate - * the correct query and return a the first item from the list of {@link TableClass} - * - * @param queryUri The URI of the query - * @param table The table to get from - * @param whereConditions The set of {@link Operator} to query the content provider. - * @param orderBy The order by clause without the ORDER BY - * @param columns The list of columns to query. - * @return The first {@link TableClass} of the list query from the content provider. - */ - public static TableClass querySingle(Uri queryUri, Class table, - OperatorGroup whereConditions, - String orderBy, String... columns) { - return querySingle(FlowManager.getContext().getContentResolver(), queryUri, table, whereConditions, orderBy, columns); - } - - /** - * Queries the {@link android.content.ContentResolver} with the specified queryUri. It will generate - * the correct query and return a the first item from the list of {@link TableClass} - * - * @param contentResolver The content resolver to use (if different from {@link FlowManager#getContext()}) - * @param queryUri The URI of the query - * @param table The table to get from - * @param whereConditions The set of {@link Operator} to query the content provider. - * @param orderBy The order by clause without the ORDER BY - * @param columns The list of columns to query. - * @return The first {@link TableClass} of the list query from the content provider. - */ - public static TableClass querySingle(ContentResolver contentResolver, Uri queryUri, Class table, - OperatorGroup whereConditions, - String orderBy, String... columns) { - List list = queryList(contentResolver, queryUri, table, whereConditions, orderBy, columns); - return list.size() > 0 ? list.get(0) : null; - } - -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/ContentUtils.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/ContentUtils.kt new file mode 100644 index 000000000..29a4e7aa9 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/ContentUtils.kt @@ -0,0 +1,295 @@ +package com.raizlabs.android.dbflow.structure.provider + +import android.content.ContentResolver +import android.content.ContentValues +import android.database.Cursor +import android.net.Uri +import com.raizlabs.android.dbflow.annotation.provider.ContentProvider +import com.raizlabs.android.dbflow.config.FlowLog +import com.raizlabs.android.dbflow.config.FlowManager +import com.raizlabs.android.dbflow.sql.language.Operator +import com.raizlabs.android.dbflow.sql.language.OperatorGroup +import com.raizlabs.android.dbflow.structure.ModelAdapter +import com.raizlabs.android.dbflow.structure.database.FlowCursor + +/** + * Description: Provides handy wrapper mechanisms for [android.content.ContentProvider] + */ +object ContentUtils { + + /** + * The default content URI that Android recommends. Not necessary, however. + */ + const val BASE_CONTENT_URI = "content://" + + /** + * Constructs an Uri with the [.BASE_CONTENT_URI] and authority. Add paths to append to the Uri. + * + * @param authority The authority for a [ContentProvider] + * @param paths The list of paths to append. + * @return A complete Uri for a [ContentProvider] + */ + @JvmStatic + fun buildUriWithAuthority(authority: String, vararg paths: String): Uri = + buildUri(BASE_CONTENT_URI, authority, *paths) + + /** + * Constructs an Uri with the specified baseContent uri and authority. Add paths to append to the Uri. + * + * @param baseContentUri The base content URI for a [ContentProvider] + * @param authority The authority for a [ContentProvider] + * @param paths The list of paths to append. + * @return A complete Uri for a [ContentProvider] + */ + @JvmStatic + fun buildUri(baseContentUri: String, authority: String, vararg paths: String): Uri { + val builder = Uri.parse(baseContentUri + authority).buildUpon() + for (path in paths) { + builder.appendPath(path) + } + return builder.build() + } + + /** + * Inserts the model into the [android.content.ContentResolver]. Uses the insertUri to resolve + * the reference and the model to convert its data into [android.content.ContentValues] + * + * @param insertUri A [android.net.Uri] from the [ContentProvider] class definition. + * @param model The model to insert. + * @return A Uri of the inserted data. + */ + @JvmStatic + fun insert(insertUri: Uri, model: TableClass): Uri? = + insert(FlowManager.context.contentResolver, insertUri, model) + + /** + * Inserts the model into the [android.content.ContentResolver]. Uses the insertUri to resolve + * the reference and the model to convert its data into [android.content.ContentValues] + * + * @param contentResolver The content resolver to use (if different from [FlowManager.getContext]) + * @param insertUri A [android.net.Uri] from the [ContentProvider] class definition. + * @param model The model to insert. + * @return The Uri of the inserted data. + */ + @JvmStatic + fun insert(contentResolver: ContentResolver, insertUri: Uri, model: TableClass): Uri? { + val adapter = FlowManager.getModelAdapter(model.javaClass) + + val contentValues = ContentValues() + adapter.bindToInsertValues(contentValues, model) + val uri: Uri? = contentResolver.insert(insertUri, contentValues) + uri?.let { + adapter.updateAutoIncrement(model, uri.pathSegments[uri.pathSegments.size - 1].toLong()) + } + return uri + } + + /** + * Inserts the list of model into the [ContentResolver]. Binds all of the models to [ContentValues] + * and runs the [ContentResolver.bulkInsert] method. Note: if any of these use + * autoIncrementing primary keys the ROWID will not be properly updated from this method. If you care + * use [.insert] instead. + * + * @param contentResolver The content resolver to use (if different from [FlowManager.getContext]) + * @param bulkInsertUri The URI to bulk insert with + * @param table The table to insert into + * @param models The models to insert. + * @return The count of the rows affected by the insert. + */ + @JvmStatic + fun bulkInsert(contentResolver: ContentResolver, bulkInsertUri: Uri, + table: Class, models: List?): Int { + val contentValues = arrayListOf() + val adapter = FlowManager.getModelAdapter(table) + + if (models != null) { + for (i in contentValues.indices) { + val values = ContentValues() + adapter.bindToInsertValues(values, models[i]) + contentValues += values + } + } + return contentResolver.bulkInsert(bulkInsertUri, contentValues.toTypedArray()) + } + + /** + * Inserts the list of model into the [ContentResolver]. Binds all of the models to [ContentValues] + * and runs the [ContentResolver.bulkInsert] method. Note: if any of these use + * autoincrement primary keys the ROWID will not be properly updated from this method. If you care + * use [.insert] instead. + * + * @param bulkInsertUri The URI to bulk insert with + * @param table The table to insert into + * @param models The models to insert. + * @return The count of the rows affected by the insert. + */ + @JvmStatic + fun bulkInsert(bulkInsertUri: Uri, table: Class, models: List): Int = + bulkInsert(FlowManager.context.contentResolver, bulkInsertUri, table, models) + + /** + * Updates the model through the [android.content.ContentResolver]. Uses the updateUri to + * resolve the reference and the model to convert its data in [android.content.ContentValues] + * + * @param updateUri A [android.net.Uri] from the [ContentProvider] + * @param model A model to update + * @return The number of rows updated. + */ + @JvmStatic + fun update(updateUri: Uri, model: TableClass): Int = + update(FlowManager.context.contentResolver, updateUri, model) + + /** + * Updates the model through the [android.content.ContentResolver]. Uses the updateUri to + * resolve the reference and the model to convert its data in [android.content.ContentValues] + * + * @param contentResolver The content resolver to use (if different from [FlowManager.getContext]) + * @param updateUri A [android.net.Uri] from the [ContentProvider] + * @param model The model to update + * @return The number of rows updated. + */ + @JvmStatic + fun update(contentResolver: ContentResolver, updateUri: Uri, model: TableClass): Int { + val adapter = FlowManager.getModelAdapter(model.javaClass) + + val contentValues = ContentValues() + adapter.bindToContentValues(contentValues, model) + val count = contentResolver.update(updateUri, contentValues, adapter.getPrimaryConditionClause(model).query, null) + if (count == 0) { + FlowLog.log(FlowLog.Level.W, "Updated failed of: " + model.javaClass) + } + return count + } + + /** + * Deletes the specified model through the [android.content.ContentResolver]. Uses the deleteUri + * to resolve the reference and the model to [ModelAdapter.getPrimaryConditionClause]} + * + * @param deleteUri A [android.net.Uri] from the [ContentProvider] + * @param model The model to delete + * @return The number of rows deleted. + */ + @JvmStatic + fun delete(deleteUri: Uri, model: TableClass): Int = + delete(FlowManager.context.contentResolver, deleteUri, model) + + /** + * Deletes the specified model through the [android.content.ContentResolver]. Uses the deleteUri + * to resolve the reference and the model to [ModelAdapter.getPrimaryConditionClause] + * + * @param contentResolver The content resolver to use (if different from [FlowManager.getContext]) + * @param deleteUri A [android.net.Uri] from the [ContentProvider] + * @param model The model to delete + * @return The number of rows deleted. + */ + @JvmStatic + fun delete(contentResolver: ContentResolver, deleteUri: Uri, model: TableClass): Int { + val adapter = FlowManager.getModelAdapter(model.javaClass) + + val count = contentResolver.delete(deleteUri, adapter.getPrimaryConditionClause(model).query, null) + + // reset autoincrement to 0 + if (count > 0) { + adapter.updateAutoIncrement(model, 0) + } else { + FlowLog.log(FlowLog.Level.W, "A delete on " + model.javaClass + " within the ContentResolver appeared to fail.") + } + return count + } + + /** + * Queries the [android.content.ContentResolver] with the specified query uri. It generates + * the correct query and returns a [android.database.Cursor] + * + * @param contentResolver The content resolver to use (if different from [FlowManager.getContext]) + * @param queryUri The URI of the query + * @param whereConditions The set of [Operator] to query the content provider. + * @param orderBy The order by clause without the ORDER BY + * @param columns The list of columns to query. + * @return A [android.database.Cursor] + */ + @JvmStatic + fun query(contentResolver: ContentResolver, queryUri: Uri, + whereConditions: OperatorGroup, + orderBy: String?, vararg columns: String?): Cursor? = + contentResolver.query(queryUri, columns, whereConditions.query, null, orderBy) + + /** + * Queries the [android.content.ContentResolver] with the specified queryUri. It will generate + * the correct query and return a list of [TableClass] + * + * @param queryUri The URI of the query + * @param table The table to get from. + * @param whereConditions The set of [Operator] to query the content provider. + * @param orderBy The order by clause without the ORDER BY + * @param columns The list of columns to query. + * @return A list of [TableClass] + */ + @JvmStatic + fun queryList(queryUri: Uri, table: Class, + whereConditions: OperatorGroup, + orderBy: String, vararg columns: String): List? = + queryList(FlowManager.context.contentResolver, queryUri, table, whereConditions, orderBy, *columns) + + + /** + * Queries the [android.content.ContentResolver] with the specified queryUri. It will generate + * the correct query and return a list of [TableClass] + * + * @param contentResolver The content resolver to use (if different from [FlowManager.getContext]) + * @param queryUri The URI of the query + * @param table The table to get from. + * @param whereConditions The set of [Operator] to query the content provider. + * @param orderBy The order by clause without the ORDER BY + * @param columns The list of columns to query. + * @return A list of [TableClass] + */ + @JvmStatic + fun queryList(contentResolver: ContentResolver, queryUri: Uri, + table: Class, + whereConditions: OperatorGroup, + orderBy: String, vararg columns: String): List? { + val cursor = FlowCursor.from(contentResolver.query(queryUri, columns, whereConditions.query, null, orderBy)!!) + return FlowManager.getModelAdapter(table) + .listModelLoader + .load(cursor) + } + + /** + * Queries the [android.content.ContentResolver] with the specified queryUri. It will generate + * the correct query and return a the first item from the list of [TableClass] + * + * @param queryUri The URI of the query + * @param table The table to get from + * @param whereConditions The set of [Operator] to query the content provider. + * @param orderBy The order by clause without the ORDER BY + * @param columns The list of columns to query. + * @return The first [TableClass] of the list query from the content provider. + */ + @JvmStatic + fun querySingle(queryUri: Uri, table: Class, + whereConditions: OperatorGroup, + orderBy: String, vararg columns: String): TableClass? = + querySingle(FlowManager.context.contentResolver, queryUri, table, whereConditions, orderBy, *columns) + + /** + * Queries the [android.content.ContentResolver] with the specified queryUri. It will generate + * the correct query and return a the first item from the list of [TableClass] + * + * @param contentResolver The content resolver to use (if different from [FlowManager.getContext]) + * @param queryUri The URI of the query + * @param table The table to get from + * @param whereConditions The set of [Operator] to query the content provider. + * @param orderBy The order by clause without the ORDER BY + * @param columns The list of columns to query. + * @return The first [TableClass] of the list query from the content provider. + */ + @JvmStatic + fun querySingle(contentResolver: ContentResolver, queryUri: Uri, table: Class, + whereConditions: OperatorGroup, + orderBy: String, vararg columns: String): TableClass? { + val list = queryList(contentResolver, queryUri, table, whereConditions, orderBy, *columns) + return list?.let { if (list.isNotEmpty()) list[0] else null } + } + +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/ModelProvider.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/ModelProvider.java deleted file mode 100644 index d1d8eae33..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/ModelProvider.java +++ /dev/null @@ -1,52 +0,0 @@ -package com.raizlabs.android.dbflow.structure.provider; - -import android.content.ContentResolver; -import android.net.Uri; -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.sql.language.Operator; -import com.raizlabs.android.dbflow.sql.language.OperatorGroup; - -/** - * Description: A base interface for Models that are connected to providers. - */ -public interface ModelProvider { - - /** - * Queries the {@link ContentResolver} of the app based on the passed parameters and - * populates this object with the first row from the returned data. - * - * @param whereOperatorGroup The set of {@link Operator} to filter the query by. - * @param orderBy The order by without the ORDER BY - * @param columns The list of columns to select. Leave blank for * - */ - void load(@NonNull OperatorGroup whereOperatorGroup, - @Nullable String orderBy, String... columns); - - /** - * Queries the {@link ContentResolver} of the app based on the primary keys of the object and populates - * this object with the first row from the returned data. - */ - void load(); - - /** - * @return The {@link android.net.Uri} that passes to a {@link android.content.ContentProvider} to delete a Model. - */ - Uri getDeleteUri(); - - /** - * @return The {@link android.net.Uri} that passes to a {@link android.content.ContentProvider} to insert a Model. - */ - Uri getInsertUri(); - - /** - * @return The {@link android.net.Uri} that passes to a {@link android.content.ContentProvider} to update a Model. - */ - Uri getUpdateUri(); - - /** - * @return The {@link android.net.Uri} that passes to a {@link android.content.ContentProvider} to query a Model. - */ - Uri getQueryUri(); -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/ModelProvider.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/ModelProvider.kt new file mode 100644 index 000000000..ec83cbfe7 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/ModelProvider.kt @@ -0,0 +1,50 @@ +package com.raizlabs.android.dbflow.structure.provider + +import android.content.ContentResolver +import android.net.Uri + +import com.raizlabs.android.dbflow.sql.language.Operator +import com.raizlabs.android.dbflow.sql.language.OperatorGroup + +/** + * Description: A base interface for Models that are connected to providers. + */ +interface ModelProvider { + + /** + * @return The [android.net.Uri] that passes to a [android.content.ContentProvider] to delete a Model. + */ + val deleteUri: Uri + + /** + * @return The [android.net.Uri] that passes to a [android.content.ContentProvider] to insert a Model. + */ + val insertUri: Uri + + /** + * @return The [android.net.Uri] that passes to a [android.content.ContentProvider] to update a Model. + */ + val updateUri: Uri + + /** + * @return The [android.net.Uri] that passes to a [android.content.ContentProvider] to query a Model. + */ + val queryUri: Uri + + /** + * Queries the [ContentResolver] of the app based on the passed parameters and + * populates this object with the first row from the returned data. + * + * @param whereOperatorGroup The set of [Operator] to filter the query by. + * @param orderBy The order by without the ORDER BY + * @param columns The list of columns to select. Leave blank for * + */ + fun load(whereOperatorGroup: OperatorGroup, + orderBy: String?, vararg columns: String?) + + /** + * Queries the [ContentResolver] of the app based on the primary keys of the object and populates + * this object with the first row from the returned data. + */ + fun load() +} From d7f4a8b2b8fccf0b9cb32f893f6f844fd2664d02 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Thu, 23 Nov 2017 12:00:15 -0500 Subject: [PATCH 057/234] [5.0] finish compilation. now compiles. fix tests with updated methods. --- .../android/dbflow/annotation/ColumnIgnore.kt | 2 +- .../raizlabs/android/dbflow/DBFlowTestRule.kt | 17 +++-- .../dbflow/config/DatabaseConfigTest.kt | 44 ++++++------- .../contentprovider/ContentProviderTests.kt | 10 ++- .../contentprovider/TestContentProvider.kt | 39 ++++++----- .../FastStoreModelTransactionTest.kt | 40 ++++++------ .../dbflow/list/FlowCursorIteratorTest.kt | 4 +- .../android/dbflow/list/FlowCursorListTest.kt | 44 +++---------- .../android/dbflow/list/FlowQueryListTest.kt | 54 ++------------- .../dbflow/models/AutoIncrementTest.kt | 1 + .../android/dbflow/models/CachingModels.kt | 4 +- .../dbflow/models/CachingModelsTest.kt | 6 +- .../dbflow/models/DontCreateModelTest.kt | 2 +- .../android/dbflow/models/ManyToManyTest.kt | 2 +- .../android/dbflow/models/ModelViews.kt | 16 ++--- .../dbflow/models/OneToManyModelTest.kt | 15 ++--- .../android/dbflow/models/OneToManyModels.kt | 17 ++--- .../dbflow/models/ParentChildCachingTest.kt | 2 +- .../android/dbflow/models/QueryModelTest.kt | 18 ++--- .../android/dbflow/models/QueryModels.kt | 4 +- .../android/dbflow/models/SimpleTestModels.kt | 4 +- .../dbflow/runtime/DirectNotifierTest.kt | 14 ++-- .../rx/language/CursorResultSubscriberTest.kt | 18 ++--- .../dbflow/rx/language/RXQueryTests.kt | 37 ++++++----- .../android/dbflow/sql/language/CaseTest.kt | 2 +- .../dbflow/sql/language/CursorResultTest.kt | 8 +-- .../android/dbflow/sql/language/DeleteTest.kt | 4 +- .../sql/language/ExistenceOperatorTest.kt | 7 +- .../android/dbflow/sql/language/FromTest.kt | 2 - .../android/dbflow/sql/language/IndexTest.kt | 9 ++- .../android/dbflow/sql/language/JoinTest.kt | 6 -- .../android/dbflow/sql/language/MethodTest.kt | 18 +---- .../dbflow/sql/language/NameAliasTest.kt | 23 ++++--- .../dbflow/sql/language/OperatorGroupTest.kt | 18 +++-- .../dbflow/sql/language/OperatorTest.kt | 5 +- .../dbflow/sql/language/OrderByTest.kt | 2 - .../android/dbflow/sql/language/SetTest.kt | 10 ++- .../dbflow/sql/language/TriggerTest.kt | 40 +++++------- .../android/dbflow/sql/language/UpdateTest.kt | 8 +-- .../android/dbflow/sql/language/WhereTest.kt | 65 +++++++++---------- .../language/property/PropertyFactoryTest.kt | 2 - .../property/TypeConvertedPropertyTest.kt | 5 +- .../sql/migration/UpdateTableMigrationTest.kt | 4 +- .../dbflow/sql/queriable/AsyncQueryTest.kt | 12 ++-- .../structure/cache/ModelLruCacheTest.kt | 2 +- .../structure/cache/SimpleMapCacheTest.kt | 2 +- .../android/dbflow/config/DatabaseConfig.kt | 6 ++ .../android/dbflow/sql/language/Case.kt | 2 +- .../android/dbflow/sql/language/NameAlias.kt | 8 +-- .../android/dbflow/sql/language/Operator.kt | 12 ++-- .../property/TypeConvertedProperty.kt | 4 +- .../android/dbflow/structure/ModelAdapter.kt | 6 +- .../dbflow/structure/RetrievalAdapter.kt | 6 +- .../cache/IMultiKeyCacheConverter.kt | 2 +- 54 files changed, 311 insertions(+), 403 deletions(-) diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ColumnIgnore.kt b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ColumnIgnore.kt index 29d4ed5f9..a5523b633 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ColumnIgnore.kt +++ b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ColumnIgnore.kt @@ -3,6 +3,6 @@ package com.raizlabs.android.dbflow.annotation /** * Description: An annotation used to ignore a column in the [Table.allFields] instance. */ -@Retention(AnnotationRetention.SOURCE) +@Retention(AnnotationRetention.BINARY) @Target(AnnotationTarget.FIELD) annotation class ColumnIgnore diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/DBFlowTestRule.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/DBFlowTestRule.kt index 261fb65c3..cd450e6ec 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/DBFlowTestRule.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/DBFlowTestRule.kt @@ -1,6 +1,7 @@ package com.raizlabs.android.dbflow import com.raizlabs.android.dbflow.config.DatabaseConfig +import com.raizlabs.android.dbflow.config.DatabaseDefinition import com.raizlabs.android.dbflow.config.FlowConfig import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.contentprovider.ContentDatabase @@ -17,13 +18,17 @@ class DBFlowTestRule : TestRule { @Throws(Throwable::class) override fun evaluate() { FlowManager.init(FlowConfig.Builder(RuntimeEnvironment.application) - .addDatabaseConfig(DatabaseConfig.Builder(TestDatabase::class.java) - .transactionManagerCreator(::ImmediateTransactionManager2) + .addDatabaseConfig(DatabaseConfig.Builder(AppDatabase::class.java) + .transactionManagerCreator( + object : DatabaseConfig.TransactionManagerCreator { + override fun createManager(databaseDefinition: DatabaseDefinition) + = ImmediateTransactionManager2(databaseDefinition) + }) + .build()) + .addDatabaseConfig(DatabaseConfig.builder(ContentDatabase::class.java) + .databaseName("content") + .build()) .build()) - .addDatabaseConfig(DatabaseConfig.builder(ContentDatabase::class.java) - .databaseName("content") - .build()) - .build()) try { base.evaluate() } finally { diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/config/DatabaseConfigTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/config/DatabaseConfigTest.kt index 8596a1623..e5a22efc8 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/config/DatabaseConfigTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/config/DatabaseConfigTest.kt @@ -6,7 +6,6 @@ import com.raizlabs.android.dbflow.TestDatabase import com.raizlabs.android.dbflow.runtime.BaseTransactionManager import com.raizlabs.android.dbflow.structure.database.DatabaseHelperListener import com.raizlabs.android.dbflow.structure.database.OpenHelper -import com.raizlabs.android.dbflow.structure.database.transaction.ITransactionQueue import org.junit.Assert import org.junit.Before import org.junit.Test @@ -35,43 +34,43 @@ class DatabaseConfigTest : BaseUnitTest() { val managerCreator = CustomTransactionManagerCreator() FlowManager.init(builder - .addDatabaseConfig(DatabaseConfig.Builder(TestDatabase::class.java) - .databaseName("Test") - .helperListener(helperListener) - .openHelper(openHelperCreator) - .transactionManagerCreator(managerCreator) + .addDatabaseConfig(DatabaseConfig.Builder(TestDatabase::class.java) + .databaseName("Test") + .helperListener(helperListener) + .openHelper(openHelperCreator) + .transactionManagerCreator(managerCreator) + .build()) .build()) - .build()) val flowConfig = FlowManager.getConfig() Assert.assertNotNull(flowConfig) - val databaseConfig = flowConfig.getDatabaseConfigMap()[TestDatabase::class.java]!! + val databaseConfig = flowConfig.databaseConfigMap[TestDatabase::class.java]!! Assert.assertEquals("Test", databaseConfig.databaseName) Assert.assertEquals(".db", databaseConfig.databaseExtensionName) - Assert.assertEquals(databaseConfig.getTransactionManagerCreator(), managerCreator) - Assert.assertEquals(databaseConfig.getDatabaseClass(), TestDatabase::class.java) - Assert.assertEquals(databaseConfig.getOpenHelperCreator(), openHelperCreator) - Assert.assertEquals(databaseConfig.getHelperListener(), helperListener) - Assert.assertTrue(databaseConfig.getTableConfigMap().isEmpty()) + Assert.assertEquals(databaseConfig.transactionManagerCreator, managerCreator) + Assert.assertEquals(databaseConfig.databaseClass, TestDatabase::class.java) + Assert.assertEquals(databaseConfig.openHelperCreator, openHelperCreator) + Assert.assertEquals(databaseConfig.helperListener, helperListener) + Assert.assertTrue(databaseConfig.tableConfigMap.isEmpty()) val databaseDefinition = FlowManager.getDatabase(TestDatabase::class.java) Assert.assertEquals(databaseDefinition.transactionManager, - managerCreator.testTransactionManager) + managerCreator.testTransactionManager) Assert.assertEquals(databaseDefinition.helper, openHelperCreator.customOpenHelper) } @Test fun test_EmptyName() { FlowManager.init(builder - .addDatabaseConfig(DatabaseConfig.Builder(TestDatabase::class.java) - .databaseName("Test") - .extensionName("") + .addDatabaseConfig(DatabaseConfig.Builder(TestDatabase::class.java) + .databaseName("Test") + .extensionName("") + .build()) .build()) - .build()) - val databaseConfig = FlowManager.getConfig().getDatabaseConfigMap()[TestDatabase::class.java]!! + val databaseConfig = FlowManager.getConfig().databaseConfigMap[TestDatabase::class.java]!! Assert.assertEquals("Test", databaseConfig.databaseName) Assert.assertEquals("", databaseConfig.databaseExtensionName) } @@ -90,12 +89,11 @@ class DatabaseConfigTest : BaseUnitTest() { val customOpenHelper = mock() - override fun createHelper(databaseDefinition: DatabaseDefinition, helperListener: DatabaseHelperListener): OpenHelper { - return customOpenHelper - } + override fun createHelper(databaseDefinition: DatabaseDefinition, + helperListener: DatabaseHelperListener?) = customOpenHelper } } class TestTransactionManager(databaseDefinition: DatabaseDefinition) - : BaseTransactionManager(mock(), databaseDefinition) \ No newline at end of file + : BaseTransactionManager(mock(), databaseDefinition) \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/contentprovider/ContentProviderTests.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/contentprovider/ContentProviderTests.kt index 6edb73d41..ae1ad4b50 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/contentprovider/ContentProviderTests.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/contentprovider/ContentProviderTests.kt @@ -3,15 +3,13 @@ package com.raizlabs.android.dbflow.contentprovider import android.content.ContentResolver import android.content.pm.ProviderInfo import com.raizlabs.android.dbflow.BaseUnitTest +import com.raizlabs.android.dbflow.sql.language.Delete import com.raizlabs.android.dbflow.sql.language.from -import com.raizlabs.android.dbflow.kotlinextensions.result import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.sql.language.where -import com.raizlabs.android.dbflow.sql.language.Delete +import com.raizlabs.android.dbflow.sql.queriable.result import com.raizlabs.android.dbflow.structure.provider.ContentUtils -import org.junit.Assert.assertEquals -import org.junit.Assert.assertFalse -import org.junit.Assert.assertTrue +import org.junit.Assert.* import org.junit.Before import org.junit.Test import org.robolectric.Robolectric @@ -110,7 +108,7 @@ class ContentProviderTests : BaseUnitTest() { assertEquals(testSyncableModel.name, "TestName") testSyncableModel = (select from TestSyncableModel::class - where (TestSyncableModel_Table.id.`is`(testSyncableModel.id))).result!! + where (TestSyncableModel_Table.id.`is`(testSyncableModel.id))).result!! val fromContentProvider = TestSyncableModel(id = testSyncableModel.id) fromContentProvider.load() diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/contentprovider/TestContentProvider.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/contentprovider/TestContentProvider.kt index c7cdd3aeb..f1ade3003 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/contentprovider/TestContentProvider.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/contentprovider/TestContentProvider.kt @@ -4,13 +4,16 @@ import android.content.ContentValues import android.content.Context import android.net.Uri import com.raizlabs.android.dbflow.annotation.provider.ContentProvider +import com.raizlabs.android.dbflow.annotation.provider.ContentType import com.raizlabs.android.dbflow.annotation.provider.ContentUri import com.raizlabs.android.dbflow.annotation.provider.Notify +import com.raizlabs.android.dbflow.annotation.provider.NotifyMethod +import com.raizlabs.android.dbflow.annotation.provider.PathSegment import com.raizlabs.android.dbflow.annotation.provider.TableEndpoint import com.raizlabs.android.dbflow.sql.SqlUtils @ContentProvider(authority = TestContentProvider.AUTHORITY, database = ContentDatabase::class, - baseContentUri = TestContentProvider.BASE_CONTENT_URI) + baseContentUri = TestContentProvider.BASE_CONTENT_URI) object TestContentProvider { const val AUTHORITY = "com.raizlabs.android.dbflow.test.provider" @@ -32,19 +35,19 @@ object TestContentProvider { @JvmStatic @ContentUri(path = ContentProviderModel.ENDPOINT, - type = ContentUri.ContentType.VND_MULTIPLE + ENDPOINT) + type = ContentType.VND_MULTIPLE + ENDPOINT) var CONTENT_URI = buildUri(ENDPOINT) @JvmStatic @ContentUri(path = ContentProviderModel.ENDPOINT + "/#", - type = ContentUri.ContentType.VND_SINGLE + ENDPOINT, - segments = arrayOf(ContentUri.PathSegment(segment = 1, column = "id"))) + type = ContentType.VND_SINGLE + ENDPOINT, + segments = arrayOf(PathSegment(segment = 1, column = "id"))) fun withId(id: Long): Uri { return buildUri(id.toString()) } @JvmStatic - @Notify(notifyMethod = Notify.Method.INSERT, paths = arrayOf(ContentProviderModel.ENDPOINT + "/#")) + @Notify(notifyMethod = NotifyMethod.INSERT, paths = arrayOf(ContentProviderModel.ENDPOINT + "/#")) fun onInsert(contentValues: ContentValues): Array { val id = contentValues.getAsLong("id")!! return arrayOf(withId(id)) @@ -57,49 +60,49 @@ object TestContentProvider { const val ENDPOINT = "NoteModel" - @ContentUri(path = ENDPOINT, type = ContentUri.ContentType.VND_MULTIPLE + ENDPOINT) + @ContentUri(path = ENDPOINT, type = ContentType.VND_MULTIPLE + ENDPOINT) var CONTENT_URI = buildUri(ENDPOINT) @JvmStatic - @ContentUri(path = ENDPOINT + "/#", type = ContentUri.ContentType.VND_MULTIPLE + ENDPOINT, - segments = arrayOf(ContentUri.PathSegment(column = "id", segment = 1))) + @ContentUri(path = ENDPOINT + "/#", type = ContentType.VND_MULTIPLE + ENDPOINT, + segments = arrayOf(PathSegment(column = "id", segment = 1))) fun withId(id: Long): Uri { return buildUri(ENDPOINT, id.toString()) } @JvmStatic @ContentUri(path = ENDPOINT + "/#/#", - type = ContentUri.ContentType.VND_SINGLE + ContentProviderModel.ENDPOINT, - segments = arrayOf(ContentUri.PathSegment(column = "id", segment = 2))) + type = ContentType.VND_SINGLE + ContentProviderModel.ENDPOINT, + segments = arrayOf(PathSegment(column = "id", segment = 2))) fun fromList(id: Long): Uri { return buildUri(ENDPOINT, "fromList", id.toString()) } @JvmStatic @ContentUri(path = ENDPOINT + "/#/#", - type = ContentUri.ContentType.VND_SINGLE + ContentProviderModel.ENDPOINT, - segments = arrayOf(ContentUri.PathSegment(column = "id", segment = 1), - ContentUri.PathSegment(column = "isOpen", segment = 2))) + type = ContentType.VND_SINGLE + ContentProviderModel.ENDPOINT, + segments = arrayOf(PathSegment(column = "id", segment = 1), + PathSegment(column = "isOpen", segment = 2))) fun withOpenId(id: Long, isOpen: Boolean): Uri { return buildUri(ENDPOINT, id.toString(), isOpen.toString()) } @JvmStatic - @Notify(notifyMethod = Notify.Method.INSERT, paths = arrayOf(ENDPOINT)) + @Notify(notifyMethod = NotifyMethod.INSERT, paths = arrayOf(ENDPOINT)) fun onInsert(contentValues: ContentValues): Array { val listId = contentValues.getAsLong(SqlUtils.getContentValuesKey(contentValues, "providerModel"))!! return arrayOf(ContentProviderModel.withId(listId), fromList(listId)) } @JvmStatic - @Notify(notifyMethod = Notify.Method.INSERT, paths = arrayOf(ENDPOINT)) + @Notify(notifyMethod = NotifyMethod.INSERT, paths = arrayOf(ENDPOINT)) fun onInsert2(contentValues: ContentValues): Uri { val listId = contentValues.getAsLong(SqlUtils.getContentValuesKey(contentValues, "providerModel"))!! return fromList(listId) } @JvmStatic - @Notify(notifyMethod = Notify.Method.UPDATE, paths = arrayOf(ENDPOINT + "/#")) + @Notify(notifyMethod = NotifyMethod.UPDATE, paths = arrayOf(ENDPOINT + "/#")) fun onUpdate(context: Context, uri: Uri): Array { val noteId = java.lang.Long.valueOf(uri.pathSegments[1])!! val c = context.contentResolver.query(uri, arrayOf("noteModel"), null, null, null) @@ -111,7 +114,7 @@ object TestContentProvider { } @JvmStatic - @Notify(notifyMethod = Notify.Method.DELETE, paths = arrayOf(ENDPOINT + "/#")) + @Notify(notifyMethod = NotifyMethod.DELETE, paths = arrayOf(ENDPOINT + "/#")) fun onDelete(context: Context, uri: Uri): Array { val noteId = java.lang.Long.valueOf(uri.pathSegments[1])!! val c = context.contentResolver.query(uri, null, null, null, null) @@ -128,7 +131,7 @@ object TestContentProvider { const val ENDPOINT = "TestSyncableModel" - @ContentUri(path = ENDPOINT, type = ContentUri.ContentType.VND_MULTIPLE + ENDPOINT) + @ContentUri(path = ENDPOINT, type = "${ContentType.VND_MULTIPLE}$ENDPOINT") var CONTENT_URI = buildUri(ENDPOINT) } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/FastStoreModelTransactionTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/FastStoreModelTransactionTest.kt index 71c9fae02..7419d563d 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/FastStoreModelTransactionTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/FastStoreModelTransactionTest.kt @@ -2,15 +2,15 @@ package com.raizlabs.android.dbflow.database.transaction import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.TestDatabase -import com.raizlabs.android.dbflow.kotlinextensions.database -import com.raizlabs.android.dbflow.kotlinextensions.fastInsert -import com.raizlabs.android.dbflow.kotlinextensions.fastSave -import com.raizlabs.android.dbflow.kotlinextensions.fastUpdate -import com.raizlabs.android.dbflow.sql.language.from -import com.raizlabs.android.dbflow.kotlinextensions.list -import com.raizlabs.android.dbflow.sql.language.select +import com.raizlabs.android.dbflow.config.database import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.TwoColumnModel +import com.raizlabs.android.dbflow.sql.language.from +import com.raizlabs.android.dbflow.sql.language.select +import com.raizlabs.android.dbflow.sql.queriable.list +import com.raizlabs.android.dbflow.structure.database.transaction.fastInsert +import com.raizlabs.android.dbflow.structure.database.transaction.fastSave +import com.raizlabs.android.dbflow.structure.database.transaction.fastUpdate import org.junit.Assert.assertEquals import org.junit.Assert.assertNotEquals import org.junit.Test @@ -22,10 +22,10 @@ class FastStoreModelTransactionTest : BaseUnitTest() { fun testSaveBuilder() { database() - .beginTransactionAsync((0..9) - .map { SimpleModel("$it") } - .fastSave().build()) - .execute() + .beginTransactionAsync((0..9) + .map { SimpleModel("$it") } + .fastSave().build()) + .execute() val list = (select from SimpleModel::class).list assertEquals(10, list.size) @@ -35,10 +35,10 @@ class FastStoreModelTransactionTest : BaseUnitTest() { fun testInsertBuilder() { database() - .beginTransactionAsync((0..9) - .map { SimpleModel("$it") } - .fastInsert().build()) - .execute() + .beginTransactionAsync((0..9) + .map { SimpleModel("$it") } + .fastInsert().build()) + .execute() val list = (select from SimpleModel::class).list assertEquals(10, list.size) @@ -49,13 +49,13 @@ class FastStoreModelTransactionTest : BaseUnitTest() { val oldList = (0..9).map { TwoColumnModel("$it", Random().nextInt()) } database() - .beginTransactionAsync(oldList.fastInsert().build()) - .execute() + .beginTransactionAsync(oldList.fastInsert().build()) + .execute() database() - .beginTransactionAsync((0..9).map { TwoColumnModel("$it", Random().nextInt()) } - .fastUpdate().build()) - .execute() + .beginTransactionAsync((0..9).map { TwoColumnModel("$it", Random().nextInt()) } + .fastUpdate().build()) + .execute() val list = (select from TwoColumnModel::class).list assertEquals(10, list.size) diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorIteratorTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorIteratorTest.kt index daff07b47..e50b5c19d 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorIteratorTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorIteratorTest.kt @@ -1,10 +1,10 @@ package com.raizlabs.android.dbflow.list import com.raizlabs.android.dbflow.BaseUnitTest +import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.sql.language.from -import com.raizlabs.android.dbflow.kotlinextensions.save import com.raizlabs.android.dbflow.sql.language.select -import com.raizlabs.android.dbflow.models.SimpleModel +import com.raizlabs.android.dbflow.structure.save import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorListTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorListTest.kt index bc47de5aa..b0155a6f6 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorListTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorListTest.kt @@ -4,17 +4,13 @@ import com.nhaarman.mockito_kotlin.mock import com.nhaarman.mockito_kotlin.times import com.nhaarman.mockito_kotlin.verify import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.kotlinextensions.cursor +import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.sql.language.from -import com.raizlabs.android.dbflow.kotlinextensions.get -import com.raizlabs.android.dbflow.kotlinextensions.save import com.raizlabs.android.dbflow.sql.language.select -import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.structure.cache.SimpleMapCache +import com.raizlabs.android.dbflow.sql.queriable.cursor +import com.raizlabs.android.dbflow.structure.save import org.junit.Assert.assertEquals -import org.junit.Assert.assertFalse import org.junit.Assert.assertNotEquals -import org.junit.Assert.assertTrue import org.junit.Test /** @@ -22,34 +18,12 @@ import org.junit.Test */ class FlowCursorListTest : BaseUnitTest() { - - @Test - fun validateBuilder() { - - val list = FlowCursorList.Builder(select from SimpleModel::class) - .modelCache(SimpleMapCache(55)) - .build() - - assertTrue(list.modelCache is SimpleMapCache<*>) - assertTrue(list.cachingEnabled) - } - - @Test - fun validateNonCachedBuilder() { - - val list = FlowCursorList.Builder(select from SimpleModel::class) - .cacheModels(false) - .build() - - assertFalse(list.cachingEnabled) - } - @Test fun validateCursorPassed() { val cursor = (select from SimpleModel::class).cursor - val list = FlowCursorList.Builder(SimpleModel::class.java) - .cursor(cursor) - .build() + val list = FlowCursorList.Builder(SimpleModel::class.java) + .cursor(cursor) + .build() assertEquals(cursor, list.cursor()) } @@ -57,9 +31,8 @@ class FlowCursorListTest : BaseUnitTest() { @Test fun validateModelQueriable() { val modelQueriable = (select from SimpleModel::class) - val list = FlowCursorList.Builder(SimpleModel::class.java) - .modelQueriable(modelQueriable) - .build() + val list = FlowCursorList.Builder(modelQueriable) + .build() assertEquals(modelQueriable, list.modelQueriable) } @@ -76,7 +49,6 @@ class FlowCursorListTest : BaseUnitTest() { assertEquals(firsItem, firsItem) assertEquals(list[2], list[2]) - list.clearCache() assertNotEquals(firsItem, list[0]) } diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowQueryListTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowQueryListTest.kt index b931e8a1b..34a464703 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowQueryListTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowQueryListTest.kt @@ -1,15 +1,10 @@ package com.raizlabs.android.dbflow.list -import com.nhaarman.mockito_kotlin.argumentCaptor -import com.nhaarman.mockito_kotlin.mock -import com.nhaarman.mockito_kotlin.verify import com.raizlabs.android.dbflow.BaseUnitTest +import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.sql.language.from import com.raizlabs.android.dbflow.sql.language.select -import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.structure.cache.SimpleMapCache -import com.raizlabs.android.dbflow.structure.database.transaction.Transaction -import org.junit.Assert.* +import org.junit.Assert.assertTrue import org.junit.Test class FlowQueryListTest : BaseUnitTest() { @@ -17,53 +12,12 @@ class FlowQueryListTest : BaseUnitTest() { @Test fun validateBuilder() { - val list = FlowQueryList.Builder(select from SimpleModel::class) - .modelCache(SimpleMapCache(55)) + val list = FlowQueryList.Builder(select from SimpleModel::class) .transact(true) .changeInTransaction(true) .build() - assertTrue(list.transact()) + assertTrue(list.transact) assertTrue(list.changeInTransaction()) } - - @Test - fun validateListOperations() { - val mockSuccess = mock() - val mockError = mock() - val list = (select from SimpleModel::class).flowQueryList() - .newBuilder().success(mockSuccess) - .error(mockError) - .build() - list += SimpleModel("1") - - // verify added - assertEquals(1, list.count) - assertFalse(list.isEmpty()) - - // verify success called - verify(mockSuccess).onSuccess(argumentCaptor().capture()) - - list -= SimpleModel("1") - assertEquals(0, list.count) - - list += SimpleModel("1") - list.removeAt(0) - assertEquals(0, list.count) - - val elements = arrayListOf(SimpleModel("1"), SimpleModel("2")) - list.addAll(elements) - assertEquals(2, list.count) - list.removeAll(elements) - assertEquals(0, list.count) - - list.addAll(elements) - - val typedArray = list.toTypedArray() - assertEquals(typedArray.size, list.size) - - list.clear() - assertEquals(0, list.size) - } - } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/AutoIncrementTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/AutoIncrementTest.kt index 839ed4ab4..e3a39d044 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/AutoIncrementTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/AutoIncrementTest.kt @@ -4,6 +4,7 @@ import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.TestDatabase import com.raizlabs.android.dbflow.annotation.PrimaryKey import com.raizlabs.android.dbflow.annotation.Table +import com.raizlabs.android.dbflow.structure.insert import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/CachingModels.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/CachingModels.kt index 3bf98526f..3a5d8e5f2 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/CachingModels.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/CachingModels.kt @@ -19,7 +19,9 @@ class Coordinate(@PrimaryKey var latitude: Double = 0.0, companion object { @JvmField @MultiCacheField - val cacheConverter = IMultiKeyCacheConverter { values -> "${values[0]},${values[1]}" } + val cacheConverter = object : IMultiKeyCacheConverter { + override fun getCachingKey(values: Array) = "${values[0]},${values[1]}" + } } } diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/CachingModelsTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/CachingModelsTest.kt index d94185f7d..65c452add 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/CachingModelsTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/CachingModelsTest.kt @@ -2,10 +2,10 @@ package com.raizlabs.android.dbflow.models import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.sql.language.from -import com.raizlabs.android.dbflow.kotlinextensions.list -import com.raizlabs.android.dbflow.kotlinextensions.result -import com.raizlabs.android.dbflow.kotlinextensions.save import com.raizlabs.android.dbflow.sql.language.select +import com.raizlabs.android.dbflow.sql.queriable.list +import com.raizlabs.android.dbflow.sql.queriable.result +import com.raizlabs.android.dbflow.structure.save import org.junit.Assert.assertEquals import org.junit.Assert.assertNotEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/DontCreateModelTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/DontCreateModelTest.kt index f3bff4622..ea7e56fb3 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/DontCreateModelTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/DontCreateModelTest.kt @@ -4,8 +4,8 @@ import android.database.sqlite.SQLiteException import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.assertThrowsException import com.raizlabs.android.dbflow.sql.language.from -import com.raizlabs.android.dbflow.kotlinextensions.list import com.raizlabs.android.dbflow.sql.language.select +import com.raizlabs.android.dbflow.sql.queriable.list import org.junit.Test /** diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ManyToManyTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ManyToManyTest.kt index 87f05141a..25627f043 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ManyToManyTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ManyToManyTest.kt @@ -1,7 +1,7 @@ package com.raizlabs.android.dbflow.models import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.kotlinextensions.save +import com.raizlabs.android.dbflow.structure.save import org.junit.Assert.assertTrue import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ModelViews.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ModelViews.kt index 64cd61bea..1835486ab 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ModelViews.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ModelViews.kt @@ -5,13 +5,11 @@ import com.raizlabs.android.dbflow.annotation.Column import com.raizlabs.android.dbflow.annotation.ColumnMap import com.raizlabs.android.dbflow.annotation.ModelView import com.raizlabs.android.dbflow.annotation.ModelViewQuery -import com.raizlabs.android.dbflow.sql.language.from -import com.raizlabs.android.dbflow.kotlinextensions.property -import com.raizlabs.android.dbflow.models.Author_Table.first_name -import com.raizlabs.android.dbflow.models.Author_Table.id -import com.raizlabs.android.dbflow.models.Author_Table.last_name +import com.raizlabs.android.dbflow.models.Author_Table.* import com.raizlabs.android.dbflow.sql.language.SQLite.select +import com.raizlabs.android.dbflow.sql.language.from import com.raizlabs.android.dbflow.sql.language.property.IProperty +import com.raizlabs.android.dbflow.sql.language.property.property class AuthorName(var name: String = "", var age: Int = 0) @@ -23,9 +21,11 @@ class AuthorView(@Column var authorId: Int = 0, @Column var authorName: String = companion object { @JvmField @ModelViewQuery - val query = select(id.`as`("authorId"), - first_name.concatenate(" ".property as IProperty>) - .concatenate(last_name as IProperty>).`as`("authorName")) from Author::class + val query = (select(id.`as`("authorId"), + first_name.concatenate(" ".property as IProperty>) + .concatenate(last_name as IProperty>) + .`as`("authorName")) + from Author::class) } } diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModelTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModelTest.kt index dc72531ea..844f17ecd 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModelTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModelTest.kt @@ -1,17 +1,14 @@ package com.raizlabs.android.dbflow.models import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.kotlinextensions.exists import com.raizlabs.android.dbflow.sql.language.from -import com.raizlabs.android.dbflow.kotlinextensions.list -import com.raizlabs.android.dbflow.kotlinextensions.result -import com.raizlabs.android.dbflow.kotlinextensions.save import com.raizlabs.android.dbflow.sql.language.select -import com.raizlabs.android.dbflow.kotlinextensions.writableDatabaseForTable -import org.junit.Assert.assertFalse -import org.junit.Assert.assertNotNull -import org.junit.Assert.assertNull -import org.junit.Assert.assertTrue +import com.raizlabs.android.dbflow.sql.queriable.list +import com.raizlabs.android.dbflow.sql.queriable.result +import com.raizlabs.android.dbflow.structure.delete +import com.raizlabs.android.dbflow.structure.exists +import com.raizlabs.android.dbflow.structure.save +import org.junit.Assert.* import org.junit.Test class OneToManyModelTest : BaseUnitTest() { diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModels.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModels.kt index 1bb0d72f0..3b10ff0c4 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModels.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModels.kt @@ -2,14 +2,15 @@ package com.raizlabs.android.dbflow.models import com.raizlabs.android.dbflow.TestDatabase import com.raizlabs.android.dbflow.annotation.OneToMany +import com.raizlabs.android.dbflow.annotation.OneToManyMethod import com.raizlabs.android.dbflow.annotation.PrimaryKey import com.raizlabs.android.dbflow.annotation.Table +import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id import com.raizlabs.android.dbflow.sql.language.from -import com.raizlabs.android.dbflow.kotlinextensions.oneToMany import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.sql.language.where -import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id import com.raizlabs.android.dbflow.structure.BaseModel +import com.raizlabs.android.dbflow.structure.oneToMany @Table(database = TestDatabase::class) class OneToManyModel(@PrimaryKey var name: String? = null) { @@ -18,23 +19,23 @@ class OneToManyModel(@PrimaryKey var name: String? = null) { var models: List? = null - @get:OneToMany(oneToManyMethods = arrayOf(OneToMany.Method.ALL)) + @get:OneToMany(oneToManyMethods = arrayOf(OneToManyMethod.ALL)) var simpleModels by oneToMany { select from OneToManyBaseModel::class } - @OneToMany(oneToManyMethods = arrayOf(OneToMany.Method.ALL), isVariablePrivate = true, - variableName = "orders", efficientMethods = false) + @OneToMany(oneToManyMethods = arrayOf(OneToManyMethod.ALL), isVariablePrivate = true, + variableName = "orders", efficientMethods = false) fun getRelatedOrders(): List { var localOrders = orders if (localOrders == null) { localOrders = (select from TwoColumnModel::class where id.greaterThan(3)) - .queryList() + .queryList() } orders = localOrders return localOrders } - @OneToMany(oneToManyMethods = arrayOf(OneToMany.Method.DELETE), isVariablePrivate = true, - variableName = "models") + @OneToMany(oneToManyMethods = arrayOf(OneToManyMethod.DELETE), isVariablePrivate = true, + variableName = "models") fun getRelatedModels(): List { var localModels = models if (localModels == null) { diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ParentChildCachingTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ParentChildCachingTest.kt index 66a96cbea..589617731 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ParentChildCachingTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ParentChildCachingTest.kt @@ -2,8 +2,8 @@ package com.raizlabs.android.dbflow.models import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.sql.language.from -import com.raizlabs.android.dbflow.kotlinextensions.result import com.raizlabs.android.dbflow.sql.language.select +import com.raizlabs.android.dbflow.sql.queriable.result import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/QueryModelTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/QueryModelTest.kt index 325a28cb7..2d8be3e7a 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/QueryModelTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/QueryModelTest.kt @@ -1,16 +1,16 @@ package com.raizlabs.android.dbflow.models import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.kotlinextensions.eq -import com.raizlabs.android.dbflow.kotlinextensions.exists -import com.raizlabs.android.dbflow.sql.language.from -import com.raizlabs.android.dbflow.kotlinextensions.innerJoin -import com.raizlabs.android.dbflow.kotlinextensions.on -import com.raizlabs.android.dbflow.kotlinextensions.save import com.raizlabs.android.dbflow.models.Author_Table.id import com.raizlabs.android.dbflow.models.Blog_Table.author_id import com.raizlabs.android.dbflow.models.Blog_Table.name import com.raizlabs.android.dbflow.sql.language.SQLite.select +import com.raizlabs.android.dbflow.sql.language.eq +import com.raizlabs.android.dbflow.sql.language.from +import com.raizlabs.android.dbflow.sql.language.innerJoin +import com.raizlabs.android.dbflow.sql.language.on +import com.raizlabs.android.dbflow.structure.exists +import com.raizlabs.android.dbflow.structure.save import org.junit.Assert.assertEquals import org.junit.Test @@ -31,9 +31,9 @@ class QueryModelTest : BaseUnitTest() { assert(blog.exists()) val result = (select(name.withTable().`as`("blogName"), id.withTable().`as`("authorId"), - Blog_Table.id.withTable().`as`("blogId")) from Blog::class innerJoin - Author::class on (author_id.withTable() eq id.withTable())) - .queryCustomSingle(AuthorNameQuery::class.java)!! + Blog_Table.id.withTable().`as`("blogId")) from Blog::class innerJoin + Author::class on (author_id.withTable() eq id.withTable())) + .queryCustomSingle(AuthorNameQuery::class.java)!! assertEquals(author.id, result.authorId) assertEquals(blog.id, result.blogId) } diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/QueryModels.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/QueryModels.kt index 8341df1e5..8f963cbc6 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/QueryModels.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/QueryModels.kt @@ -19,9 +19,9 @@ class CustomBlobModel(@Column var myBlob: MyBlob? = null) { @com.raizlabs.android.dbflow.annotation.TypeConverter class MyTypeConverter : TypeConverter() { - override fun getDBValue(model: MyBlob) = Blob(model.blob) + override fun getDBValue(model: MyBlob?) = model?.let { Blob(model.blob) } - override fun getModelValue(data: Blob) = MyBlob(data.blob) + override fun getModelValue(data: Blob?) = data?.blob?.let { MyBlob(it) } } } diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/SimpleTestModels.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/SimpleTestModels.kt index b13b74690..d18a5be15 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/SimpleTestModels.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/SimpleTestModels.kt @@ -147,9 +147,9 @@ class CustomTypeConverter : TypeConverter() { } class CustomEnumTypeConverter : TypeConverter() { - override fun getDBValue(model: Difficulty) = model.name.substring(0..0) + override fun getDBValue(model: Difficulty?) = model?.name?.substring(0..0) - override fun getModelValue(data: String) = when (data) { + override fun getModelValue(data: String?) = when (data) { "E" -> Difficulty.EASY "M" -> Difficulty.MEDIUM "H" -> Difficulty.HARD diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/runtime/DirectNotifierTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/runtime/DirectNotifierTest.kt index 0896ab41d..bedb2aea0 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/runtime/DirectNotifierTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/runtime/DirectNotifierTest.kt @@ -9,12 +9,18 @@ import com.raizlabs.android.dbflow.TestDatabase import com.raizlabs.android.dbflow.config.DatabaseConfig import com.raizlabs.android.dbflow.config.FlowConfig import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.sql.language.delete -import com.raizlabs.android.dbflow.sql.language.insert -import com.raizlabs.android.dbflow.kotlinextensions.update import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table +import com.raizlabs.android.dbflow.sql.language.columnValues +import com.raizlabs.android.dbflow.sql.language.delete +import com.raizlabs.android.dbflow.sql.language.insert +import com.raizlabs.android.dbflow.sql.language.set +import com.raizlabs.android.dbflow.sql.language.update import com.raizlabs.android.dbflow.structure.BaseModel +import com.raizlabs.android.dbflow.structure.delete +import com.raizlabs.android.dbflow.structure.insert +import com.raizlabs.android.dbflow.structure.save +import com.raizlabs.android.dbflow.structure.update import org.junit.After import org.junit.Before import org.junit.Test @@ -25,7 +31,7 @@ import org.robolectric.RuntimeEnvironment import org.robolectric.annotation.Config @RunWith(RobolectricTestRunner::class) -@Config (manifest = Config.NONE) +@Config(manifest = Config.NONE) class DirectNotifierTest { val context: Context diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriberTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriberTest.kt index 508b93d9b..12df4fd03 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriberTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriberTest.kt @@ -1,11 +1,11 @@ package com.raizlabs.android.dbflow.rx.language import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.sql.language.from -import com.raizlabs.android.dbflow.kotlinextensions.save -import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.rx.kotlinextensions.rx +import com.raizlabs.android.dbflow.sql.language.from +import com.raizlabs.android.dbflow.sql.language.select +import com.raizlabs.android.dbflow.structure.save import org.junit.Assert.assertEquals import org.junit.Test @@ -18,12 +18,12 @@ class CursorResultSubscriberTest : BaseUnitTest() { var count = 0 (select from SimpleModel::class).rx() - .queryStreamResults() - .toBlocking() - .subscribe { - count++ - assert(it != null) - } + .queryStreamResults() + .toBlocking() + .subscribe { + count++ + assert(it != null) + } assertEquals(10, count) } diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/RXQueryTests.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/RXQueryTests.kt index db2b8e9d2..53ca2cc8c 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/RXQueryTests.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/RXQueryTests.kt @@ -2,16 +2,17 @@ package com.raizlabs.android.dbflow.rx.language import android.database.Cursor import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.sql.language.from -import com.raizlabs.android.dbflow.sql.language.insert -import com.raizlabs.android.dbflow.kotlinextensions.save -import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table.name import com.raizlabs.android.dbflow.rx.kotlinextensions.rx +import com.raizlabs.android.dbflow.rx.kotlinextensions.rxBaseQueriable import com.raizlabs.android.dbflow.sql.language.SQLite.selectCountOf +import com.raizlabs.android.dbflow.sql.language.from +import com.raizlabs.android.dbflow.sql.language.insert import com.raizlabs.android.dbflow.sql.language.property.Property +import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.structure.database.DatabaseStatement +import com.raizlabs.android.dbflow.structure.save import org.junit.Assert.assertEquals import org.junit.Assert.assertNotNull import org.junit.Test @@ -24,10 +25,10 @@ class RXQueryTests : BaseUnitTest() { var cursor: Cursor? = null (select from SimpleModel::class).rx() - .query() - .subscribe { - cursor = it - } + .query() + .subscribe { + cursor = it + } assertEquals(1, cursor!!.count) cursor!!.close() @@ -37,10 +38,10 @@ class RXQueryTests : BaseUnitTest() { fun testCanCompileStatement() { var databaseStatement: DatabaseStatement? = null (insert().columnValues(name.`is`("name"))) - .rxBaseQueriable().compileStatement() - .subscribe { - databaseStatement = it - } + .rxBaseQueriable().compileStatement() + .subscribe { + databaseStatement = it + } assertNotNull(databaseStatement) databaseStatement!!.close() } @@ -51,7 +52,7 @@ class RXQueryTests : BaseUnitTest() { SimpleModel("name2").save() var count = 0L (selectCountOf(Property.ALL_PROPERTY) from SimpleModel::class).rx() - .count().subscribe { + .longValue().subscribe { count = it } @@ -62,11 +63,11 @@ class RXQueryTests : BaseUnitTest() { fun testInsertMethod() { var count = 0L (insert().columnValues(name.eq("name"))) - .rxBaseQueriable() - .executeInsert() - .subscribe { - count = it - } + .rxBaseQueriable() + .executeInsert() + .subscribe { + count = it + } assertEquals(1, count) } diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CaseTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CaseTest.kt index c5f7f5084..eb09e2a10 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CaseTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CaseTest.kt @@ -1,8 +1,8 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.kotlinextensions.propertyString import com.raizlabs.android.dbflow.models.SimpleModel_Table +import com.raizlabs.android.dbflow.sql.language.property.propertyString import org.junit.Assert.assertEquals import org.junit.Assert.assertFalse import org.junit.Assert.assertTrue diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CursorResultTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CursorResultTest.kt index 06aa227c6..907ee3cfa 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CursorResultTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CursorResultTest.kt @@ -2,14 +2,10 @@ package com.raizlabs.android.dbflow.sql.language import android.database.StaleDataException import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.kotlinextensions.cursorResult -import com.raizlabs.android.dbflow.kotlinextensions.save -import com.raizlabs.android.dbflow.kotlinextensions.toCustomList -import com.raizlabs.android.dbflow.kotlinextensions.toCustomListClose -import com.raizlabs.android.dbflow.kotlinextensions.toCustomModel -import com.raizlabs.android.dbflow.kotlinextensions.toCustomModelClose import com.raizlabs.android.dbflow.models.SimpleCustomModel import com.raizlabs.android.dbflow.models.SimpleModel +import com.raizlabs.android.dbflow.sql.queriable.cursorResult +import com.raizlabs.android.dbflow.structure.save import org.junit.Assert.assertEquals import org.junit.Assert.assertNotNull import org.junit.Assert.assertTrue diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/DeleteTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/DeleteTest.kt index 7a77af991..f10768835 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/DeleteTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/DeleteTest.kt @@ -1,10 +1,10 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.kotlinextensions.list -import com.raizlabs.android.dbflow.kotlinextensions.save import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table +import com.raizlabs.android.dbflow.sql.queriable.list +import com.raizlabs.android.dbflow.structure.save import org.junit.Assert.assertEquals import org.junit.Assert.assertFalse import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/ExistenceOperatorTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/ExistenceOperatorTest.kt index 8dc8cbc27..e83068fae 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/ExistenceOperatorTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/ExistenceOperatorTest.kt @@ -11,7 +11,10 @@ class ExistenceOperatorTest : BaseUnitTest() { @Test fun validateQuery() { - assertEquals("EXISTS (SELECT * FROM `SimpleModel` WHERE `name`='name')", ExistenceOperator() - .where(select from SimpleModel::class where SimpleModel_Table.name.eq("name")).query.trim()) + assertEquals("EXISTS (SELECT * FROM `SimpleModel` WHERE `name`='name')", + ExistenceOperator( + (select from SimpleModel::class + where SimpleModel_Table.name.eq("name"))) + .query.trim()) } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/FromTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/FromTest.kt index 2fda66327..3c205a9e5 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/FromTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/FromTest.kt @@ -1,8 +1,6 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.kotlinextensions.innerJoin -import com.raizlabs.android.dbflow.kotlinextensions.on import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table.name import com.raizlabs.android.dbflow.models.TwoColumnModel diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexTest.kt index 94a01b3c8..82f6d738a 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexTest.kt @@ -1,7 +1,6 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.kotlinextensions.nameAlias import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table import org.junit.Assert.assertEquals @@ -12,19 +11,19 @@ class IndexTest : BaseUnitTest() { @Test fun validateBasicIndex() { assertEquals("CREATE INDEX IF NOT EXISTS `index` ON `SimpleModel`(`name`)", - indexOn("index", SimpleModel_Table.name).query) + indexOn("index", SimpleModel_Table.name).query) } @Test fun validateUniqueIndex() { assertEquals("CREATE UNIQUE INDEX IF NOT EXISTS `index` ON `SimpleModel`(`name`, `test`)", - indexOn("index").unique(true).and(SimpleModel_Table.name) - .and("test".nameAlias).query) + indexOn("index").unique(true).and(SimpleModel_Table.name) + .and("test".nameAlias).query) } @Test fun validateBasicIndexNameAlias() { assertEquals("CREATE INDEX IF NOT EXISTS `index` ON `SimpleModel`(`name`, `test`)", - indexOn("index", "name".nameAlias, "test".nameAlias).query) + indexOn("index", "name".nameAlias, "test".nameAlias).query) } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/JoinTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/JoinTest.kt index b7d6f8919..c1b0aa4a2 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/JoinTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/JoinTest.kt @@ -1,12 +1,6 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.kotlinextensions.crossJoin -import com.raizlabs.android.dbflow.kotlinextensions.innerJoin -import com.raizlabs.android.dbflow.kotlinextensions.leftOuterJoin -import com.raizlabs.android.dbflow.kotlinextensions.naturalJoin -import com.raizlabs.android.dbflow.kotlinextensions.on -import com.raizlabs.android.dbflow.kotlinextensions.using import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table import com.raizlabs.android.dbflow.models.TwoColumnModel diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/MethodTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/MethodTest.kt index d1d63bb9d..9fe8f792f 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/MethodTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/MethodTest.kt @@ -4,20 +4,6 @@ import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.name import com.raizlabs.android.dbflow.sql.SQLiteType -import com.raizlabs.android.dbflow.sql.language.Method.avg -import com.raizlabs.android.dbflow.sql.language.Method.cast -import com.raizlabs.android.dbflow.sql.language.Method.count -import com.raizlabs.android.dbflow.sql.language.Method.date -import com.raizlabs.android.dbflow.sql.language.Method.datetime -import com.raizlabs.android.dbflow.sql.language.Method.group_concat -import com.raizlabs.android.dbflow.sql.language.Method.ifNull -import com.raizlabs.android.dbflow.sql.language.Method.max -import com.raizlabs.android.dbflow.sql.language.Method.min -import com.raizlabs.android.dbflow.sql.language.Method.nullIf -import com.raizlabs.android.dbflow.sql.language.Method.replace -import com.raizlabs.android.dbflow.sql.language.Method.strftime -import com.raizlabs.android.dbflow.sql.language.Method.sum -import com.raizlabs.android.dbflow.sql.language.Method.total import org.junit.Assert.assertEquals import org.junit.Test @@ -44,13 +30,13 @@ class MethodTest : BaseUnitTest() { @Test fun test_dateMethod() { assertEquals("date('now', 'start of month', '+1 month')", - date("now", "start of month", "+1 month").query) + date("now", "start of month", "+1 month").query) } @Test fun test_datetimeMethod() { assertEquals("datetime(1092941466, 'unix epoch')", - datetime(1092941466, "unix epoch").query) + datetime(1092941466, "unix epoch").query) } @Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/NameAliasTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/NameAliasTest.kt index 1c31f5cba..e206582f8 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/NameAliasTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/NameAliasTest.kt @@ -1,7 +1,6 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.kotlinextensions.nameAlias import org.junit.Assert.assertEquals import org.junit.Assert.assertFalse import org.junit.Test @@ -21,19 +20,19 @@ class NameAliasTest : BaseUnitTest() { @Test fun validateBuilder() { val nameAlias = NameAlias.builder("name") - .keyword("DISTINCT") - .`as`("Alias") - .withTable("MyTable") - .shouldAddIdentifierToAliasName(false) - .shouldAddIdentifierToName(false) - .shouldStripAliasName(false) - .shouldStripIdentifier(false).build() - assertEquals("DISTINCT", nameAlias.keyword()) + .keyword("DISTINCT") + .`as`("Alias") + .withTable("MyTable") + .shouldAddIdentifierToAliasName(false) + .shouldAddIdentifierToName(false) + .shouldStripAliasName(false) + .shouldStripIdentifier(false).build() + assertEquals("DISTINCT", nameAlias.keyword) assertEquals("Alias", nameAlias.aliasName()) assertEquals("Alias", nameAlias.aliasNameRaw()) - assertEquals("`MyTable`", nameAlias.tableName()) - assertFalse(nameAlias.shouldStripAliasName()) - assertFalse(nameAlias.shouldStripIdentifier()) + assertEquals("`MyTable`", nameAlias.tableName) + assertFalse(nameAlias.shouldStripAliasName) + assertFalse(nameAlias.shouldStripIdentifier) assertEquals("Alias", nameAlias.nameAsKey) assertEquals("DISTINCT `MyTable`.name AS Alias", nameAlias.fullQuery) } diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OperatorGroupTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OperatorGroupTest.kt index 63810d910..ec911f837 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OperatorGroupTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OperatorGroupTest.kt @@ -2,8 +2,6 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.assertEquals -import com.raizlabs.android.dbflow.kotlinextensions.andAll -import com.raizlabs.android.dbflow.kotlinextensions.orAll import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.name import org.junit.Test @@ -13,32 +11,38 @@ class OperatorGroupTest : BaseUnitTest() { @Test fun validateCommaSeparated() { - assertEquals("(`name`='name', `id`=0)", OperatorGroup.clause().setAllCommaSeparated(true).andAll(name.eq("name"), id.eq(0))) + assertEquals("(`name`='name', `id`=0)", + OperatorGroup.clause().setAllCommaSeparated(true).andAll(name.eq("name"), id.eq(0))) } @Test fun validateParanthesis() { - assertEquals("`name`='name'", OperatorGroup.nonGroupingClause(name.eq("name")).setUseParenthesis(false)) + assertEquals("`name`='name'", + OperatorGroup.nonGroupingClause(name.eq("name")).setUseParenthesis(false)) } @Test fun validateOr() { - assertEquals("(`name`='name' OR `id`=0)", name.eq("name") or id.eq(0)) + assertEquals("(`name`='name' OR `id`=0)", + name.eq("name") or id.eq(0)) } @Test fun validateOrAll() { - assertEquals("(`name`='name' OR `id`=0 OR `name`='test')", name.eq("name") orAll arrayListOf(id.eq(0), name.eq("test"))) + assertEquals("(`name`='name' OR `id`=0 OR `name`='test')", + name.eq("name") orAll arrayListOf(id.eq(0), name.eq("test"))) } @Test + fun validateAnd() { assertEquals("(`name`='name' AND `id`=0)", name.eq("name") and id.eq(0)) } @Test fun validateAndAll() { - assertEquals("(`name`='name' AND `id`=0 AND `name`='test')", name.eq("name") andAll arrayListOf(id.eq(0), name.eq("test"))) + assertEquals("(`name`='name' AND `id`=0 AND `name`='test')", + name.eq("name") andAll arrayListOf(id.eq(0), name.eq("test"))) } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OperatorTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OperatorTest.kt index 58b83036e..3db544ced 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OperatorTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OperatorTest.kt @@ -3,9 +3,6 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.annotation.Collate import com.raizlabs.android.dbflow.assertEquals -import com.raizlabs.android.dbflow.kotlinextensions.between -import com.raizlabs.android.dbflow.kotlinextensions.collate -import com.raizlabs.android.dbflow.kotlinextensions.op import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id import org.junit.Test @@ -52,7 +49,7 @@ class OperatorTest : BaseUnitTest() { @Test fun testBetween() { - assertEquals("`id` BETWEEN 6 AND 7", id between 6 and 7) + assertEquals("`id` BETWEEN 6 AND 7", id.between(6) and 7) } @Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OrderByTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OrderByTest.kt index 38c9b82f6..47f3bff50 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OrderByTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OrderByTest.kt @@ -3,8 +3,6 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.annotation.Collate import com.raizlabs.android.dbflow.assertEquals -import com.raizlabs.android.dbflow.kotlinextensions.collate -import com.raizlabs.android.dbflow.kotlinextensions.nameAlias import com.raizlabs.android.dbflow.models.SimpleModel_Table.name import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/SetTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/SetTest.kt index f83a64dfc..c80bcc591 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/SetTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/SetTest.kt @@ -13,13 +13,17 @@ class SetTest : BaseUnitTest() { @Test fun validateSetWithConditions() { assertEquals("SET `name`='name'", - Set(Query { "" }, SimpleModel::class.java).conditions(name.`is`("name"))) + Set(object : Query { + override val query = "" + }, SimpleModel::class.java).conditions(name.`is`("name"))) } @Test fun validateMultipleConditions() { assertEquals("SET `name`='name', `id`=0", - Set(Query { "" }, SimpleModel::class.java) - .conditions(name.`is`("name"), id.`is`(0))) + Set(object : Query { + override val query = "" + }, SimpleModel::class.java) + .conditions(name.`is`("name"), id.`is`(0))) } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/TriggerTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/TriggerTest.kt index 51315bc3f..6fff30dac 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/TriggerTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/TriggerTest.kt @@ -2,18 +2,14 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.assertEquals -import com.raizlabs.android.dbflow.kotlinextensions.begin -import com.raizlabs.android.dbflow.kotlinextensions.columnValues -import com.raizlabs.android.dbflow.kotlinextensions.createTrigger -import com.raizlabs.android.dbflow.kotlinextensions.eq -import com.raizlabs.android.dbflow.kotlinextensions.insertOn -import com.raizlabs.android.dbflow.kotlinextensions.property -import com.raizlabs.android.dbflow.kotlinextensions.updateOn import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table.name import com.raizlabs.android.dbflow.models.TwoColumnModel import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id import com.raizlabs.android.dbflow.sql.SQLiteType +import com.raizlabs.android.dbflow.sql.language.property.eq +import com.raizlabs.android.dbflow.sql.language.property.property +import com.raizlabs.android.dbflow.structure.insert import org.junit.Assert.assertNotNull import org.junit.Test @@ -22,32 +18,32 @@ class TriggerTest : BaseUnitTest() { @Test fun validateBasicTrigger() { assertEquals("CREATE TRIGGER IF NOT EXISTS `MyTrigger` AFTER INSERT ON `SimpleModel` " + - "\nBEGIN" + - "\nINSERT INTO `TwoColumnModel`(`name`) VALUES(`new`.`name`);" + - "\nEND", - createTrigger("MyTrigger").after() insertOn SimpleModel::class begin - insert(TwoColumnModel::class).columnValues(name to NameAlias.ofTable("new", "name"))) + "\nBEGIN" + + "\nINSERT INTO `TwoColumnModel`(`name`) VALUES(`new`.`name`);" + + "\nEND", + createTrigger("MyTrigger").after() insertOn SimpleModel::class begin + insert(TwoColumnModel::class).columnValues(name to NameAlias.ofTable("new", "name"))) } @Test fun validateUpdateTriggerMultiline() { assertEquals("CREATE TEMP TRIGGER IF NOT EXISTS `MyTrigger` BEFORE UPDATE ON `SimpleModel` " + - "\nBEGIN" + - "\nINSERT INTO `TwoColumnModel`(`name`) VALUES(`new`.`name`);" + - "\nINSERT INTO `TwoColumnModel`(`id`) VALUES(CAST(`new`.`name` AS INTEGER));" + - "\nEND", - createTrigger("MyTrigger").temporary().before() updateOn SimpleModel::class begin - insert(TwoColumnModel::class).columnValues(name to NameAlias.ofTable("new", "name")) and - insert(TwoColumnModel::class) - .columnValues(id to Method.cast(NameAlias.ofTable("new", "name").property) - .`as`(SQLiteType.INTEGER))) + "\nBEGIN" + + "\nINSERT INTO `TwoColumnModel`(`name`) VALUES(`new`.`name`);" + + "\nINSERT INTO `TwoColumnModel`(`id`) VALUES(CAST(`new`.`name` AS INTEGER));" + + "\nEND", + createTrigger("MyTrigger").temporary().before() updateOn SimpleModel::class begin + insert(TwoColumnModel::class).columnValues(name to NameAlias.ofTable("new", "name")) and + insert(TwoColumnModel::class) + .columnValues(id to cast(NameAlias.ofTable("new", "name").property) + .`as`(SQLiteType.INTEGER))) } @Test fun validateTriggerWorks() { val trigger = createTrigger("MyTrigger").after() insertOn SimpleModel::class begin - insert(TwoColumnModel::class).columnValues(name to NameAlias.ofTable("new", "name")) + insert(TwoColumnModel::class).columnValues(name to NameAlias.ofTable("new", "name")) trigger.enable() SimpleModel("Test").insert() diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UpdateTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UpdateTest.kt index d6704575e..9e8507717 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UpdateTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UpdateTest.kt @@ -3,12 +3,12 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.annotation.ConflictAction import com.raizlabs.android.dbflow.assertEquals -import com.raizlabs.android.dbflow.kotlinextensions.update import com.raizlabs.android.dbflow.models.NumberModel import com.raizlabs.android.dbflow.models.NumberModel_Table.id import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table.name import com.raizlabs.android.dbflow.sql.language.property.Property +import com.raizlabs.android.dbflow.sql.language.property.eq import org.junit.Test class UpdateTest : BaseUnitTest() { @@ -46,8 +46,8 @@ class UpdateTest : BaseUnitTest() { @Test fun validateWildcardQuery() { assertEquals("UPDATE OR FAIL `NumberModel` SET `id`=? WHERE `id`=?", - update().or(ConflictAction.FAIL) - .set(id.eq(Property.WILDCARD)) - .where(id.eq(Property.WILDCARD))) + update().or(ConflictAction.FAIL) + .set(id.eq(Property.WILDCARD)) + .where(id.eq(Property.WILDCARD))) } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/WhereTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/WhereTest.kt index e264545da..2e0603ef9 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/WhereTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/WhereTest.kt @@ -2,21 +2,14 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.assertEquals -import com.raizlabs.android.dbflow.kotlinextensions.groupBy -import com.raizlabs.android.dbflow.kotlinextensions.having -import com.raizlabs.android.dbflow.kotlinextensions.limit -import com.raizlabs.android.dbflow.kotlinextensions.list -import com.raizlabs.android.dbflow.kotlinextensions.nameAlias -import com.raizlabs.android.dbflow.kotlinextensions.offset -import com.raizlabs.android.dbflow.kotlinextensions.orderBy -import com.raizlabs.android.dbflow.kotlinextensions.result -import com.raizlabs.android.dbflow.kotlinextensions.update import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table.name import com.raizlabs.android.dbflow.models.TwoColumnModel import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id -import com.raizlabs.android.dbflow.sql.language.OrderBy.fromNameAlias +import com.raizlabs.android.dbflow.sql.language.OrderBy.Companion.fromNameAlias import com.raizlabs.android.dbflow.sql.language.SQLite.select +import com.raizlabs.android.dbflow.sql.queriable.list +import com.raizlabs.android.dbflow.sql.queriable.result import org.junit.Assert.fail import org.junit.Test @@ -25,92 +18,92 @@ class WhereTest : BaseUnitTest() { @Test fun validateBasicWhere() { assertEquals("SELECT * FROM `SimpleModel` WHERE `name`='name'", - select from SimpleModel::class where name.`is`("name")) + select from SimpleModel::class where name.`is`("name")) } @Test fun validateComplexQueryWhere() { assertEquals("SELECT * FROM `SimpleModel` WHERE `name`='name' OR `id`=1 AND (`id`=0 OR `name`='hi')", - select from SimpleModel::class where name.`is`("name") or id.eq(1) and (id.`is`(0) or name.eq("hi"))) + select from SimpleModel::class where name.`is`("name") or id.eq(1) and (id.`is`(0) or name.eq("hi"))) } @Test fun validateGroupBy() { assertEquals("SELECT * FROM `SimpleModel` WHERE `name`='name' GROUP BY `name`", - select from SimpleModel::class where name.`is`("name") groupBy name) + select from SimpleModel::class where name.`is`("name") groupBy name) } @Test fun validateGroupByNameAlias() { assertEquals("SELECT * FROM `SimpleModel` WHERE `name`='name' GROUP BY `name`,`id`", - (select from SimpleModel::class where name.`is`("name")).groupBy("name".nameAlias, "id".nameAlias)) + (select from SimpleModel::class where name.`is`("name")).groupBy("name".nameAlias, "id".nameAlias)) } @Test fun validateGroupByNameProps() { assertEquals("SELECT * FROM `SimpleModel` WHERE `name`='name' GROUP BY `name`,`id`", - (select from SimpleModel::class where name.`is`("name")).groupBy(name, id)) + (select from SimpleModel::class where name.`is`("name")).groupBy(name, id)) } @Test fun validateHaving() { assertEquals("SELECT * FROM `SimpleModel` WHERE `name`='name' HAVING `name` LIKE 'That'", - select from SimpleModel::class where name.`is`("name") having name.like("That")) + select from SimpleModel::class where name.`is`("name") having name.like("That")) } @Test fun validateLimit() { assertEquals("SELECT * FROM `SimpleModel` WHERE `name`='name' LIMIT 10", - select from SimpleModel::class where name.`is`("name") limit 10) + select from SimpleModel::class where name.`is`("name") limit 10) } @Test fun validateOffset() { assertEquals("SELECT * FROM `SimpleModel` WHERE `name`='name' OFFSET 10", - select from SimpleModel::class where name.`is`("name") offset 10) + select from SimpleModel::class where name.`is`("name") offset 10) } @Test fun validateWhereExists() { assertEquals("SELECT * FROM `SimpleModel` " + - "WHERE EXISTS (SELECT `name` FROM `SimpleModel` WHERE `name` LIKE 'Andrew')", - select from SimpleModel::class - whereExists (select(name) from SimpleModel::class where name.like("Andrew"))) + "WHERE EXISTS (SELECT `name` FROM `SimpleModel` WHERE `name` LIKE 'Andrew')", + select from SimpleModel::class + whereExists (select(name) from SimpleModel::class where name.like("Andrew"))) } @Test fun validateOrderByWhere() { assertEquals("SELECT * FROM `SimpleModel` " + - "WHERE `name`='name' ORDER BY `name` ASC", - (select from SimpleModel::class - where name.eq("name")).orderBy(name, true)) + "WHERE `name`='name' ORDER BY `name` ASC", + (select from SimpleModel::class + where name.eq("name")).orderBy(name, true)) } @Test fun validateOrderByWhereAlias() { assertEquals("SELECT * FROM `SimpleModel` " + - "WHERE `name`='name' ORDER BY `name` ASC", - (select from SimpleModel::class - where name.eq("name")).orderBy("name".nameAlias, true)) + "WHERE `name`='name' ORDER BY `name` ASC", + (select from SimpleModel::class + where name.eq("name")).orderBy("name".nameAlias, true)) } @Test fun validateOrderBy() { assertEquals("SELECT * FROM `SimpleModel` " + - "WHERE `name`='name' ORDER BY `name` ASC", - select from SimpleModel::class - where name.eq("name") orderBy fromNameAlias("name".nameAlias).ascending()) + "WHERE `name`='name' ORDER BY `name` ASC", + select from SimpleModel::class + where name.eq("name") orderBy fromNameAlias("name".nameAlias).ascending()) } @Test fun validateOrderByAll() { assertEquals("SELECT * FROM `TwoColumnModel` " + - "WHERE `name`='name' ORDER BY `name` ASC,`id` DESC", - (select from TwoColumnModel::class - where name.eq("name")) - .orderByAll(listOf( - fromNameAlias("name".nameAlias).ascending(), - fromNameAlias("id".nameAlias).descending()))) + "WHERE `name`='name' ORDER BY `name` ASC,`id` DESC", + (select from TwoColumnModel::class + where name.eq("name")) + .orderByAll(listOf( + fromNameAlias("name".nameAlias).ascending(), + fromNameAlias("id".nameAlias).descending()))) } @Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/PropertyFactoryTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/PropertyFactoryTest.kt index 74fcd95e2..bdcc567a0 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/PropertyFactoryTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/PropertyFactoryTest.kt @@ -2,8 +2,6 @@ package com.raizlabs.android.dbflow.sql.language.property import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.sql.language.from -import com.raizlabs.android.dbflow.kotlinextensions.property -import com.raizlabs.android.dbflow.kotlinextensions.propertyString import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.models.SimpleModel import org.junit.Assert.assertEquals diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/TypeConvertedPropertyTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/TypeConvertedPropertyTest.kt index 8289bb323..ea6bc9d09 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/TypeConvertedPropertyTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/TypeConvertedPropertyTest.kt @@ -2,6 +2,7 @@ package com.raizlabs.android.dbflow.sql.language.property import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.converter.DateConverter +import com.raizlabs.android.dbflow.converter.TypeConverter import com.raizlabs.android.dbflow.models.Difficulty import com.raizlabs.android.dbflow.models.EnumTypeConverterModel_Table import com.raizlabs.android.dbflow.models.SimpleModel @@ -16,7 +17,9 @@ class TypeConvertedPropertyTest : BaseUnitTest() { @Test fun testTypeConverter() { val property = TypeConvertedProperty(SimpleModel::class.java, "Prop", true, - TypeConvertedProperty.TypeConverterGetter { DateConverter() }) + object : TypeConvertedProperty.TypeConverterGetter { + override fun getTypeConverter(modelClass: Class<*>): TypeConverter<*, *> = DateConverter() + }) assertEquals("`Prop`", property.toString()) val date = Date() diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/migration/UpdateTableMigrationTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/migration/UpdateTableMigrationTest.kt index 767d35a84..6975e7e82 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/migration/UpdateTableMigrationTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/migration/UpdateTableMigrationTest.kt @@ -1,7 +1,7 @@ package com.raizlabs.android.dbflow.sql.migration import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.kotlinextensions.writableDatabaseForTable +import com.raizlabs.android.dbflow.config.writableDatabaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table import org.junit.Test @@ -15,7 +15,7 @@ class UpdateTableMigrationTest : BaseUnitTest() { @Test fun testUpdateMigrationQuery() { - val update = UpdateTableMigration(SimpleModel::class.java) + val update = UpdateTableMigration(SimpleModel::class.java) update.set(SimpleModel_Table.name.eq("yes")) update.migrate(writableDatabaseForTable()) } diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/queriable/AsyncQueryTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/queriable/AsyncQueryTest.kt index 2bdbd98eb..0606ec077 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/queriable/AsyncQueryTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/queriable/AsyncQueryTest.kt @@ -1,15 +1,11 @@ package com.raizlabs.android.dbflow.sql.queriable import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.kotlinextensions.async -import com.raizlabs.android.dbflow.kotlinextensions.cursorResult -import com.raizlabs.android.dbflow.sql.language.from -import com.raizlabs.android.dbflow.kotlinextensions.list -import com.raizlabs.android.dbflow.kotlinextensions.result -import com.raizlabs.android.dbflow.kotlinextensions.save -import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.sql.language.CursorResult +import com.raizlabs.android.dbflow.sql.language.from +import com.raizlabs.android.dbflow.sql.language.select +import com.raizlabs.android.dbflow.structure.save import org.junit.Assert.assertEquals import org.junit.Assert.assertNotNull import org.junit.Test @@ -35,7 +31,7 @@ class AsyncQueryTest : BaseUnitTest() { var list = mutableListOf() (select from SimpleModel::class).async list { _, mutableList -> - list = mutableList + list = mutableList.toMutableList() } assertEquals(2, list.size) } diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/structure/cache/ModelLruCacheTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/structure/cache/ModelLruCacheTest.kt index c3a6a574c..c80503dcc 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/structure/cache/ModelLruCacheTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/structure/cache/ModelLruCacheTest.kt @@ -13,7 +13,7 @@ class ModelLruCacheTest : BaseUnitTest() { val cache = SimpleMapCache(10) cache.addModel(1, NumberModel(1)) - Assert.assertEquals(1, cache[1].id) + Assert.assertEquals(1, cache[1]!!.id) Assert.assertEquals(1, cache.cache.size) cache.removeModel(1) diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/structure/cache/SimpleMapCacheTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/structure/cache/SimpleMapCacheTest.kt index c6c48ae6c..1de1d9e15 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/structure/cache/SimpleMapCacheTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/structure/cache/SimpleMapCacheTest.kt @@ -13,7 +13,7 @@ class SimpleMapCacheTest : BaseUnitTest() { val cache = SimpleMapCache(10) cache.addModel("1", SimpleModel("1")) - assertEquals("1", cache["1"].name) + assertEquals("1", cache["1"]!!.name) assertEquals(1, cache.cache.size) cache.removeModel("1") diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.kt index 365b273c6..f2327ca70 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.kt @@ -78,6 +78,12 @@ class DatabaseConfig( this.transactionManagerCreator = transactionManager } + inline fun transactionManagerCreator(crossinline function: (DatabaseDefinition) -> BaseTransactionManager) + = transactionManagerCreator(object : TransactionManagerCreator { + override fun createManager(databaseDefinition: DatabaseDefinition) = function(databaseDefinition) + }) + + fun helperListener(helperListener: DatabaseHelperListener) = apply { this.helperListener = helperListener } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Case.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Case.kt index 2836b4763..7024c7748 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Case.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Case.kt @@ -16,7 +16,7 @@ class Case(private val caseColumn: IProperty<*>? = null) : Query { private var elseSpecified = false // when true, only WHEN value is supported. Not WHEN condition - internal var isEfficientCase = false + var isEfficientCase = false private set private var endSpecified = false diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/NameAlias.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/NameAlias.kt index 71ce94491..89f291529 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/NameAlias.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/NameAlias.kt @@ -9,10 +9,10 @@ import com.raizlabs.android.dbflow.sql.QueryBuilder */ class NameAlias(private val name: String, private val aliasName: String? = null, - private val tableName: String? = null, - private val keyword: String? = null, - private val shouldStripIdentifier: Boolean = true, - private val shouldStripAliasName: Boolean = true, + val tableName: String? = null, + val keyword: String? = null, + val shouldStripIdentifier: Boolean = true, + val shouldStripAliasName: Boolean = true, private val shouldAddIdentifierToQuery: Boolean = true, private val shouldAddIdentifierToAliasName: Boolean = true) : Query { diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Operator.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Operator.kt index 11f0a79d6..7906d32cf 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Operator.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Operator.kt @@ -18,7 +18,7 @@ import java.util.* */ class Operator : BaseOperator, IOperator { - private var typeConverter: TypeConverter<*, Any?>? = null + private var typeConverter: TypeConverter<*, *>? = null private var convertToDB: Boolean = false override val query: String @@ -35,7 +35,7 @@ class Operator : BaseOperator, IOperator { */ internal constructor(nameAlias: NameAlias) : super(nameAlias) - internal constructor(alias: NameAlias, typeConverter: TypeConverter<*, Any?>, convertToDB: Boolean) : super(alias) { + internal constructor(alias: NameAlias, typeConverter: TypeConverter<*, *>, convertToDB: Boolean) : super(alias) { this.typeConverter = typeConverter this.convertToDB = convertToDB } @@ -330,9 +330,9 @@ class Operator : BaseOperator, IOperator { var _value = value operation = QueryBuilder(Operation.EQUALS).append(columnName()).toString() - var typeConverter: TypeConverter<*, Any?>? = this.typeConverter + var typeConverter: TypeConverter<*, Any>? = this.typeConverter as TypeConverter<*, Any>? if (typeConverter == null && _value != null) { - typeConverter = FlowManager.getTypeConverterForClass(_value.javaClass) as TypeConverter<*, Any?>? + typeConverter = FlowManager.getTypeConverterForClass(_value.javaClass) as TypeConverter<*, Any>? } if (typeConverter != null && convertToDB) { _value = typeConverter.getDBValue(_value) @@ -372,7 +372,7 @@ class Operator : BaseOperator, IOperator { override fun notIn(values: Collection): In = In(this, values, false) override fun convertObjectToString(obj: Any?, appendInnerParenthesis: Boolean): String? = - typeConverter?.let { typeConverter -> + (typeConverter as? TypeConverter<*, Any>?)?.let { typeConverter -> var converted = obj try { converted = if (convertToDB) typeConverter.getDBValue(obj) else obj @@ -621,7 +621,7 @@ class Operator : BaseOperator, IOperator { fun op(column: NameAlias): Operator = Operator(column) @JvmStatic - fun op(alias: NameAlias, typeConverter: TypeConverter<*, Any?>, convertToDB: Boolean): Operator = + fun op(alias: NameAlias, typeConverter: TypeConverter<*, *>, convertToDB: Boolean): Operator = Operator(alias, typeConverter, convertToDB) } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/TypeConvertedProperty.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/TypeConvertedProperty.kt index 1b25064f3..5d6ae9d3b 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/TypeConvertedProperty.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/TypeConvertedProperty.kt @@ -28,7 +28,7 @@ class TypeConvertedProperty : Property { */ interface TypeConverterGetter { - fun getTypeConverter(modelClass: Class<*>): TypeConverter<*, Any?> + fun getTypeConverter(modelClass: Class<*>): TypeConverter<*, *> } constructor(table: Class<*>, nameAlias: NameAlias, @@ -53,7 +53,7 @@ class TypeConvertedProperty : Property { if (databaseProperty == null) { databaseProperty = TypeConvertedProperty(getTable(), nameAlias, !convertToDB, object : TypeConverterGetter { - override fun getTypeConverter(modelClass: Class<*>): TypeConverter<*, Any?> = + override fun getTypeConverter(modelClass: Class<*>): TypeConverter<*, *> = getter.getTypeConverter(modelClass) }) } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelAdapter.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelAdapter.kt index 163700834..0f3a3ec08 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelAdapter.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelAdapter.kt @@ -316,7 +316,7 @@ abstract class ModelAdapter(databaseDefinition: DatabaseDefinition) /** * @return A set of columns that represent the caching columns. */ - fun createCachingColumns(): Array = arrayOf(autoIncrementingColumnName) + open fun createCachingColumns(): Array = arrayOf(autoIncrementingColumnName) /** * Loads all primary keys from the [FlowCursor] into the inValues. The size of the array must @@ -379,7 +379,7 @@ abstract class ModelAdapter(databaseDefinition: DatabaseDefinition) else -> null } - fun getCachingId(model: T): Any? = + open fun getCachingId(model: T): Any? = getCachingId(getCachingColumnValuesFromModel(arrayOfNulls(cachingColumns.size), model)) var modelSaver: ModelSaver @@ -427,7 +427,7 @@ abstract class ModelAdapter(databaseDefinition: DatabaseDefinition) * @return When false, this table gets generated and associated with database, however it will not immediately * get created upon startup. This is useful for keeping around legacy tables for migrations. */ - fun createWithDatabase(): Boolean = true + open fun createWithDatabase(): Boolean = true private fun throwCachingError() { throw InvalidDBConfiguration( diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/RetrievalAdapter.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/RetrievalAdapter.kt index 7e9216089..8dffcb4e7 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/RetrievalAdapter.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/RetrievalAdapter.kt @@ -95,7 +95,7 @@ abstract class RetrievalAdapter(databaseDefinition: DatabaseDefinition) * Force loads the model from the DB. Even if caching is enabled it will requery the object. */ @JvmOverloads - fun load(model: T, databaseWrapper: DatabaseWrapper = FlowManager.getDatabaseForTable(modelClass).writableDatabase) { + open fun load(model: T, databaseWrapper: DatabaseWrapper = FlowManager.getDatabaseForTable(modelClass).writableDatabase) { nonCacheableSingleModelLoader.load(databaseWrapper, SQLite.select() .from(modelClass) @@ -133,12 +133,12 @@ abstract class RetrievalAdapter(databaseDefinition: DatabaseDefinition) /** * @return A new [ListModelLoader], caching will override this loader instance. */ - protected fun createListModelLoader(): ListModelLoader = ListModelLoader(modelClass) + protected open fun createListModelLoader(): ListModelLoader = ListModelLoader(modelClass) /** * @return A new [SingleModelLoader], caching will override this loader instance. */ - protected fun createSingleModelLoader(): SingleModelLoader = SingleModelLoader(modelClass) + protected open fun createSingleModelLoader(): SingleModelLoader = SingleModelLoader(modelClass) } /** diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/IMultiKeyCacheConverter.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/IMultiKeyCacheConverter.kt index c0ceafdf4..bd9a0fe92 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/IMultiKeyCacheConverter.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/IMultiKeyCacheConverter.kt @@ -7,7 +7,7 @@ import com.raizlabs.android.dbflow.structure.Model * interface "zips" the complex primary keys into one "representative" key. Also this can be used to * override the default caching key and provide a custom key. */ -interface IMultiKeyCacheConverter { +interface IMultiKeyCacheConverter { /** * Converts the array of values into a singular representative key. The values are in order From 2b61e9b657cc83a52539c8a7b358db495039e04c Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Thu, 23 Nov 2017 14:45:38 -0500 Subject: [PATCH 058/234] [5.0] fixing broken tests. add kotlin functions as substitute for some interfaces --- .../raizlabs/android/dbflow/DBFlowTestRule.kt | 9 +--- .../dbflow/config/DatabaseConfigTest.kt | 34 ++++--------- .../android/dbflow/config/DatabaseConfig.kt | 50 +++++++++---------- .../dbflow/sql/language/BaseOperator.kt | 4 +- .../android/dbflow/sql/language/Insert.kt | 10 ++-- .../android/dbflow/sql/language/Method.kt | 1 - .../android/dbflow/sql/language/NameAlias.kt | 2 +- .../sql/language/property/IProperty.java | 3 +- .../dbflow/sql/language/property/Property.kt | 35 +++++-------- .../property/TypeConvertedProperty.kt | 6 +-- .../sql/language/property/WrapperProperty.kt | 2 +- 11 files changed, 63 insertions(+), 93 deletions(-) diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/DBFlowTestRule.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/DBFlowTestRule.kt index cd450e6ec..f253afadb 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/DBFlowTestRule.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/DBFlowTestRule.kt @@ -1,7 +1,6 @@ package com.raizlabs.android.dbflow import com.raizlabs.android.dbflow.config.DatabaseConfig -import com.raizlabs.android.dbflow.config.DatabaseDefinition import com.raizlabs.android.dbflow.config.FlowConfig import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.contentprovider.ContentDatabase @@ -18,12 +17,8 @@ class DBFlowTestRule : TestRule { @Throws(Throwable::class) override fun evaluate() { FlowManager.init(FlowConfig.Builder(RuntimeEnvironment.application) - .addDatabaseConfig(DatabaseConfig.Builder(AppDatabase::class.java) - .transactionManagerCreator( - object : DatabaseConfig.TransactionManagerCreator { - override fun createManager(databaseDefinition: DatabaseDefinition) - = ImmediateTransactionManager2(databaseDefinition) - }) + .addDatabaseConfig(DatabaseConfig.Builder(TestDatabase::class.java) + .transactionManagerCreator(::ImmediateTransactionManager2) .build()) .addDatabaseConfig(DatabaseConfig.builder(ContentDatabase::class.java) .databaseName("content") diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/config/DatabaseConfigTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/config/DatabaseConfigTest.kt index e5a22efc8..414fb899e 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/config/DatabaseConfigTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/config/DatabaseConfigTest.kt @@ -29,9 +29,16 @@ class DatabaseConfigTest : BaseUnitTest() { fun test_databaseConfig() { val helperListener = mock() + val customOpenHelper = mock() - val openHelperCreator = CustomOpenHelperCreator() - val managerCreator = CustomTransactionManagerCreator() + val openHelperCreator: ((DatabaseDefinition, DatabaseHelperListener?) -> OpenHelper) = { _, _ -> + customOpenHelper + } + var testTransactionManager: TestTransactionManager? = null + val managerCreator: (DatabaseDefinition) -> BaseTransactionManager = { databaseDefinition -> + testTransactionManager = TestTransactionManager(databaseDefinition) + testTransactionManager!! + } FlowManager.init(builder .addDatabaseConfig(DatabaseConfig.Builder(TestDatabase::class.java) @@ -56,9 +63,8 @@ class DatabaseConfigTest : BaseUnitTest() { val databaseDefinition = FlowManager.getDatabase(TestDatabase::class.java) - Assert.assertEquals(databaseDefinition.transactionManager, - managerCreator.testTransactionManager) - Assert.assertEquals(databaseDefinition.helper, openHelperCreator.customOpenHelper) + Assert.assertEquals(databaseDefinition.transactionManager, testTransactionManager) + Assert.assertEquals(databaseDefinition.helper, customOpenHelper) } @Test @@ -75,24 +81,6 @@ class DatabaseConfigTest : BaseUnitTest() { Assert.assertEquals("", databaseConfig.databaseExtensionName) } - class CustomTransactionManagerCreator : DatabaseConfig.TransactionManagerCreator { - - lateinit var testTransactionManager: TestTransactionManager - - override fun createManager(databaseDefinition: DatabaseDefinition): BaseTransactionManager { - testTransactionManager = TestTransactionManager(databaseDefinition) - return testTransactionManager - } - } - - class CustomOpenHelperCreator : DatabaseConfig.OpenHelperCreator { - - val customOpenHelper = mock() - - override fun createHelper(databaseDefinition: DatabaseDefinition, - helperListener: DatabaseHelperListener?) = customOpenHelper - } - } class TestTransactionManager(databaseDefinition: DatabaseDefinition) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.kt index f2327ca70..52573b713 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.kt @@ -34,17 +34,9 @@ class DatabaseConfig( internal constructor(builder: Builder) : this( // convert java interface to kotlin function. - openHelperCreator = builder.openHelperCreator?.let { - { databaseDefinition: DatabaseDefinition, helperListener: DatabaseHelperListener? -> - it.createHelper(databaseDefinition, helperListener) - } - }, + openHelperCreator = builder.openHelperCreator, databaseClass = builder.databaseClass, - transactionManagerCreator = builder.transactionManagerCreator?.let { - { databaseDefinition: DatabaseDefinition -> - it.createManager(databaseDefinition) - } - }, + transactionManagerCreator = builder.transactionManagerCreator, helperListener = builder.helperListener, tableConfigMap = builder.tableConfigMap, modelNotifier = builder.modelNotifier, @@ -65,8 +57,8 @@ class DatabaseConfig( */ class Builder(internal val databaseClass: Class<*>) { - internal var openHelperCreator: OpenHelperCreator? = null - internal var transactionManagerCreator: TransactionManagerCreator? = null + internal var openHelperCreator: ((DatabaseDefinition, DatabaseHelperListener?) -> OpenHelper)? = null + internal var transactionManagerCreator: ((DatabaseDefinition) -> BaseTransactionManager)? = null internal var helperListener: DatabaseHelperListener? = null internal val tableConfigMap: MutableMap, TableConfig<*>> = HashMap() internal var modelNotifier: ModelNotifier? = null @@ -74,14 +66,27 @@ class DatabaseConfig( internal var databaseName: String? = null internal var databaseExtensionName: String? = null - fun transactionManagerCreator(transactionManager: TransactionManagerCreator) = apply { - this.transactionManagerCreator = transactionManager + fun transactionManagerCreator(transactionManager: TransactionManagerCreator) = + transactionManagerCreator { databaseDefinition -> transactionManager.createManager(databaseDefinition) } + + fun transactionManagerCreator(creator: (DatabaseDefinition) -> BaseTransactionManager) = apply { + this.transactionManagerCreator = creator + } + + /** + * Overrides the default [OpenHelper] for a [DatabaseDefinition]. + * + * @param openHelper The openhelper to use. + */ + fun openHelper(openHelper: (DatabaseDefinition, DatabaseHelperListener?) -> OpenHelper) = apply { + openHelperCreator = openHelper } - inline fun transactionManagerCreator(crossinline function: (DatabaseDefinition) -> BaseTransactionManager) - = transactionManagerCreator(object : TransactionManagerCreator { - override fun createManager(databaseDefinition: DatabaseDefinition) = function(databaseDefinition) - }) + fun openHelper(openHelper: OpenHelperCreator) = apply { + openHelperCreator = { databaseDefinition, databaseHelperListener -> + openHelper.createHelper(databaseDefinition, databaseHelperListener) + } + } fun helperListener(helperListener: DatabaseHelperListener) = apply { @@ -115,15 +120,6 @@ class DatabaseConfig( databaseExtensionName = name } - /** - * Overrides the default [OpenHelper] for a [DatabaseDefinition]. - * - * @param openHelper The openhelper to use. - */ - fun openHelper(openHelper: OpenHelperCreator) = apply { - openHelperCreator = openHelper - } - fun build() = DatabaseConfig(this) } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseOperator.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseOperator.kt index c0ca39479..3e603de85 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseOperator.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseOperator.kt @@ -207,7 +207,7 @@ abstract class BaseOperator internal constructor( * @return A joined string */ @JvmStatic - fun joinArguments(delimiter: CharSequence, tokens: Array): String = + fun joinArguments(delimiter: CharSequence, tokens: Array): String = tokens.joinToString(separator = delimiter) { convertValueToString(it, false, true) ?: "" } @@ -221,7 +221,7 @@ abstract class BaseOperator internal constructor( * @return A joined string */ @JvmStatic - fun joinArguments(delimiter: CharSequence, tokens: Iterable): String = + fun joinArguments(delimiter: CharSequence, tokens: Iterable): String = tokens.joinToString(separator = delimiter) { convertValueToString(it, false, true) ?: "" } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Insert.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Insert.kt index 7d15b6faf..7dc2e7993 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Insert.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Insert.kt @@ -30,7 +30,7 @@ class Insert /** * The values to specify in this query */ - private var valuesList: MutableList> = arrayListOf() + private var valuesList: MutableList> = arrayListOf() /** * The conflict algorithm to use to resolve inserts. @@ -50,9 +50,9 @@ class Insert .appendSpace() .append(FlowManager.getTableName(table)) - if (columns != null) { + columns?.let { columns -> queryBuilder.append("(") - .appendArray(columns?.toTypedArray()) + .appendArray(*columns.toTypedArray()) .append(")") } if (selectFrom != null) { @@ -119,7 +119,7 @@ class Insert fun asColumnValues() = apply { asColumns() if (columns != null) { - val values = arrayListOf() + val values = arrayListOf() for (i in columns!!.indices) { values.add("?") } @@ -143,7 +143,7 @@ class Insert * * @param values The non type-converted values */ - fun values(values: Collection) = apply { + fun values(values: List) = apply { valuesList.add(values.toMutableList()) } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Method.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Method.kt index 13a3640bb..7c502427e 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Method.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Method.kt @@ -101,7 +101,6 @@ class Method(methodName: String, vararg properties: IProperty<*>) : Property { - val newProperty = Property(property.table, property.nameAlias .newBuilder() diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/NameAlias.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/NameAlias.kt index 89f291529..b868da846 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/NameAlias.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/NameAlias.kt @@ -108,7 +108,7 @@ class NameAlias(private val name: String, * @return The `{tableName}`.`{name}`. If [.tableName] specified. */ fun fullName(): String = - (if (StringUtils.isNotNullOrEmpty(tableName)) "$tableName." else "") + name + (if (StringUtils.isNotNullOrEmpty(tableName)) "$tableName." else "") + name() override fun toString(): String = fullQuery diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/IProperty.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/IProperty.java index 59119f80c..5f4305b53 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/IProperty.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/IProperty.java @@ -1,6 +1,7 @@ package com.raizlabs.android.dbflow.sql.language.property; import android.support.annotation.NonNull; +import android.support.annotation.Nullable; import com.raizlabs.android.dbflow.sql.Query; import com.raizlabs.android.dbflow.sql.language.Join; @@ -116,7 +117,7 @@ public interface IProperty

extends Query { /** * @return the table this property belongs to. */ - @NonNull + @Nullable Class getTable(); @NonNull diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/Property.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/Property.kt index 13c8b6140..f614de45a 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/Property.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/Property.kt @@ -150,14 +150,12 @@ open class Property : IProperty>, IConditional, IOperator { operator.between(baseModelQueriable) override fun `in`(firstBaseModelQueriable: BaseModelQueriable<*>, - vararg baseModelQueriables: BaseModelQueriable<*>): Operator.In<*> { - return operator.`in`(firstBaseModelQueriable, *baseModelQueriables) - } + vararg baseModelQueriables: BaseModelQueriable<*>): Operator.In<*> = + operator.`in`(firstBaseModelQueriable, *baseModelQueriables) override fun notIn(firstBaseModelQueriable: BaseModelQueriable<*>, - vararg baseModelQueriables: BaseModelQueriable<*>): Operator.In<*> { - return operator.notIn(firstBaseModelQueriable, *baseModelQueriables) - } + vararg baseModelQueriables: BaseModelQueriable<*>): Operator.In<*> = + operator.notIn(firstBaseModelQueriable, *baseModelQueriables) override fun concatenate(conditional: IConditional): Operator<*> = operator.concatenate(conditional) @@ -172,9 +170,7 @@ open class Property : IProperty>, IConditional, IOperator { override fun rem(value: BaseModelQueriable<*>): Operator<*> = operator.rem(value) - override fun getTable(): Class<*> { - return table!! - } + override fun getTable(): Class<*>? = table override fun plus(property: IProperty<*>): Property { return Property(table, NameAlias.joinNames(Operator.Operation.PLUS, @@ -275,9 +271,8 @@ open class Property : IProperty>, IConditional, IOperator { val WILDCARD: Property<*> = Property(null, NameAlias.rawBuilder("?").build()) @JvmStatic - fun allProperty(table: Class<*>): Property { - return Property(table, NameAlias.rawBuilder("*").build()).withTable() - } + fun allProperty(table: Class<*>): Property = + Property(table, NameAlias.rawBuilder("*").build()).withTable() } } @@ -304,18 +299,14 @@ infix fun Property.lessThanOrEq(value: T) = this.lessThanOrEq(value infix fun Property.between(value: T) = this.between(value) -infix fun Property.`in`(values: Array): Operator.In { - return when (values.size) { - 1 -> `in`(values[0]) - else -> this.`in`(values[0], *values.sliceArray(IntRange(1, values.size))) - } +infix fun Property.`in`(values: Array): Operator.In = when (values.size) { + 1 -> `in`(values[0]) + else -> this.`in`(values[0], *values.sliceArray(IntRange(1, values.size))) } -infix fun Property.notIn(values: Array): Operator.In { - return when (values.size) { - 1 -> notIn(values[0]) - else -> this.notIn(values[0], *values.sliceArray(IntRange(1, values.size))) - } +infix fun Property.notIn(values: Array): Operator.In = when (values.size) { + 1 -> notIn(values[0]) + else -> this.notIn(values[0], *values.sliceArray(IntRange(1, values.size))) } infix fun Property.`in`(values: Collection) = this.`in`(values) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/TypeConvertedProperty.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/TypeConvertedProperty.kt index 5d6ae9d3b..6b67606cd 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/TypeConvertedProperty.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/TypeConvertedProperty.kt @@ -20,7 +20,7 @@ class TypeConvertedProperty : Property { private val getter: TypeConverterGetter override val operator: Operator - get() = Operator.op(nameAlias, getter.getTypeConverter(getTable()), convertToDB) + get() = Operator.op(nameAlias, getter.getTypeConverter(getTable()!!), convertToDB) /** * Generated by the compiler, looks up the type converter based on [ModelAdapter] when needed. @@ -51,7 +51,7 @@ class TypeConvertedProperty : Property { */ fun invertProperty(): Property { if (databaseProperty == null) { - databaseProperty = TypeConvertedProperty(getTable(), nameAlias, + databaseProperty = TypeConvertedProperty(getTable()!!, nameAlias, !convertToDB, object : TypeConverterGetter { override fun getTypeConverter(modelClass: Class<*>): TypeConverter<*, *> = getter.getTypeConverter(modelClass) @@ -65,6 +65,6 @@ class TypeConvertedProperty : Property { .newBuilder() .withTable(tableNameAlias.query) .build() - return TypeConvertedProperty(this.getTable(), nameAlias, this.convertToDB, this.getter) + return TypeConvertedProperty(this.getTable()!!, nameAlias, this.convertToDB, this.getter) } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/WrapperProperty.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/WrapperProperty.kt index 24b0dfefd..b3e653c11 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/WrapperProperty.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/WrapperProperty.kt @@ -21,7 +21,7 @@ class WrapperProperty : Property { */ fun invertProperty(): Property { if (databaseProperty == null) { - databaseProperty = WrapperProperty(getTable(), nameAlias) + databaseProperty = WrapperProperty(getTable()!!, nameAlias) } return databaseProperty!! } From 665472d25db8ab77905178a56ff67119e31cac54 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Thu, 23 Nov 2017 14:53:07 -0500 Subject: [PATCH 059/234] [5.0] pass all tests. --- .../android/dbflow/list/FlowCursorListTest.kt | 19 ------------------- .../android/dbflow/list/FlowCursorList.kt | 16 +++++++--------- 2 files changed, 7 insertions(+), 28 deletions(-) diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorListTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorListTest.kt index b0155a6f6..34f017f26 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorListTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorListTest.kt @@ -10,7 +10,6 @@ import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.sql.queriable.cursor import com.raizlabs.android.dbflow.structure.save import org.junit.Assert.assertEquals -import org.junit.Assert.assertNotEquals import org.junit.Test /** @@ -37,21 +36,6 @@ class FlowCursorListTest : BaseUnitTest() { assertEquals(modelQueriable, list.modelQueriable) } - @Test - fun validateSpecialModelCache() { - (0..9).forEach { - SimpleModel("$it").save() - } - - val list = (select from SimpleModel::class).cursorList() - assertEquals(10, list.count) - val firsItem = list[0] - assertEquals(firsItem, firsItem) - assertEquals(list[2], list[2]) - - assertNotEquals(firsItem, list[0]) - } - @Test fun validateGetAll() { (0..9).forEach { @@ -61,9 +45,6 @@ class FlowCursorListTest : BaseUnitTest() { val list = (select from SimpleModel::class).cursorList() val all = list.all assertEquals(list.count, all.size.toLong()) - all.indices.forEach { - assertEquals(all[it], list[it]) - } } @Test diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorList.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorList.kt index 6b011958e..384caf633 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorList.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorList.kt @@ -48,6 +48,7 @@ class FlowCursorList private constructor(builder: Builder) : IFlowCu */ val all: List get() { + unpackCursor() throwIfCursorClosed() warnEmptyCursor() return cursor?.let { cursor -> @@ -73,13 +74,10 @@ class FlowCursorList private constructor(builder: Builder) : IFlowCu instanceAdapter = FlowManager.getInstanceAdapter(builder.modelClass) } - override operator fun iterator(): FlowCursorIterator { - return FlowCursorIterator(this) - } + override operator fun iterator(): FlowCursorIterator = FlowCursorIterator(this) - override fun iterator(startingLocation: Int, limit: Long): FlowCursorIterator { - return FlowCursorIterator(this, startingLocation, limit) - } + override fun iterator(startingLocation: Int, limit: Long): FlowCursorIterator = + FlowCursorIterator(this, startingLocation, limit) /** * Register listener for when cursor refreshes. @@ -133,6 +131,7 @@ class FlowCursorList private constructor(builder: Builder) : IFlowCu */ override val count: Long get() { + unpackCursor() throwIfCursorClosed() warnEmptyCursor() return (cursor?.count ?: 0).toLong() @@ -148,6 +147,7 @@ class FlowCursorList private constructor(builder: Builder) : IFlowCu } override fun cursor(): Cursor? { + unpackCursor() throwIfCursorClosed() warnEmptyCursor() return cursor @@ -176,9 +176,7 @@ class FlowCursorList private constructor(builder: Builder) : IFlowCu * @return A new [Builder] that contains the same cache, query statement, and other * underlying data, but allows for modification. */ - fun newBuilder(): Builder { - return Builder(modelQueriable).cursor(unpackCursor()) - } + fun newBuilder(): Builder = Builder(modelQueriable).cursor(cursor()) /** * Provides easy way to construct a [FlowCursorList]. From a5da0b2f1a2048832b223cbc749ef744c6fdb8a6 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Thu, 23 Nov 2017 15:42:46 -0500 Subject: [PATCH 060/234] [5.0] begin removing QueryBuilder in favor of StringBuilder and extension methods. --- .../raizlabs/android/dbflow/StringUtils.kt | 102 ++++++++++++++++++ .../dbflow/sql/language/BaseOperator.kt | 4 +- .../dbflow/sql/language/CaseCondition.kt | 18 ++-- .../dbflow/sql/language/ExistenceOperator.kt | 10 +- .../android/dbflow/sql/language/Operator.kt | 39 +++---- .../dbflow/sql/language/OperatorGroup.kt | 19 ++-- .../dbflow/sql/language/SQLOperator.kt | 8 +- .../dbflow/sql/language/TriggerMethod.kt | 20 ++-- .../sql/language/UnSafeStringOperator.kt | 9 +- .../sql/migration/AlterTableMigration.kt | 66 ++++++------ .../structure/database/BaseDatabaseHelper.kt | 25 ++--- 11 files changed, 196 insertions(+), 124 deletions(-) diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/StringUtils.kt b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/StringUtils.kt index e32be2b76..9dddb85ac 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/StringUtils.kt +++ b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/StringUtils.kt @@ -1,5 +1,8 @@ package com.raizlabs.android.dbflow +import com.raizlabs.android.dbflow.sql.SQLiteType +import java.util.regex.Pattern + /** * Description: Provides handy method for strings */ @@ -19,3 +22,102 @@ object StringUtils { fun isNullOrEmpty(inString: String?): Boolean = inString == null || inString == "" || inString.isEmpty() } + +fun StringBuilder.appendQuotedIfNeeded(string: String?) = apply { + if (string == "*") + return append(string) + + append(string.quoteIfNeeded()) + return this +} + +private val QUOTE = '`' +private val QUOTE_PATTERN = Pattern.compile(QUOTE + ".*" + QUOTE) + +/** + * Helper method to check if name is quoted. + * + * @return true if the name is quoted. We may not want to quote something if its already so. + */ +fun String?.isQuoted(): Boolean = QUOTE_PATTERN.matcher(this).find() + +/** + * @param columnName The column name to use. + * @return A name in quotes. E.G. index => `index` so we can use keywords as column names without fear + * of clashing. + */ +fun String?.quote(): String = "$QUOTE${this?.replace(".", "`.`")}$QUOTE" + +fun String?.quoteIfNeeded() = if (this != null && !isQuoted()) { + quote() +} else { + this +} + +/** + * Appends the [SQLiteType] to [StringBuilder] + */ +fun StringBuilder.appendSQLiteType(sqLiteType: SQLiteType): StringBuilder = append(sqLiteType.name) + +/** + * Strips quotes out of a identifier if need to do so. + * + * @param name The name ot strip the quotes from. + * @return A non-quoted name. + */ +fun String?.stripQuotes(): String? { + var ret: String? = this + if (ret != null && ret.isQuoted()) { + ret = ret.replace("`", "") + } + return ret +} + + +/** + * Appends a value only if it's not empty or null + * + * @param name The name of the qualifier + * @param value The value to append after the name + * @return This instance + */ +fun StringBuilder.appendQualifier(name: String?, value: String?): StringBuilder { + if (value != null && value.isNotEmpty()) { + if (name != null) { + append(name) + } + append(" $value ") + } + return this +} + +/** + * Appends the value only if its not null + * + * @param value If not null, its string representation. + * @return This instance + */ +fun StringBuilder.appendOptional(value: Any?): StringBuilder { + if (value != null) { + append(value) + } + return this +} + +/** + * Appends an array of these objects by joining them with a comma with + * [.join] + * + * @param objects The array of objects to pass in + * @return This instance + */ +fun StringBuilder.appendArray(vararg objects: Any): StringBuilder = append(objects.joinToString()) + +/** + * Appends a list of objects by joining them with a comma with + * [.join] + * + * @param objects The list of objects to pass in + * @return This instance + */ +fun StringBuilder.appendList(objects: List<*>): StringBuilder = append(objects.joinToString()) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseOperator.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseOperator.kt index 3e603de85..7a21f9f0e 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseOperator.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseOperator.kt @@ -1,12 +1,10 @@ package com.raizlabs.android.dbflow.sql.language import android.database.DatabaseUtils - import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.converter.TypeConverter import com.raizlabs.android.dbflow.data.Blob import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.sql.QueryBuilder import com.raizlabs.android.dbflow.sql.SqlUtils /** @@ -147,7 +145,7 @@ abstract class BaseOperator internal constructor( } else if (_value is NameAlias) { stringVal = _value.query } else if (_value is SQLOperator) { - val queryBuilder = QueryBuilder() + val queryBuilder = StringBuilder() _value.appendConditionToQuery(queryBuilder) stringVal = queryBuilder.toString() } else if (_value is Query) { diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CaseCondition.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CaseCondition.kt index 09e0c2008..313a2b176 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CaseCondition.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CaseCondition.kt @@ -1,7 +1,6 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.sql.QueryBuilder import com.raizlabs.android.dbflow.sql.language.property.IProperty /** @@ -18,19 +17,16 @@ class CaseCondition : Query { private var isThenPropertySet: Boolean = false override val query: String - get() { - val queryBuilder = QueryBuilder(" WHEN ") + get() = buildString { + append(" WHEN ") if (caze.isEfficientCase) { - queryBuilder.append(BaseOperator.convertValueToString(property ?: whenValue, false)) + append(BaseOperator.convertValueToString(property ?: whenValue, false)) } else { - sqlOperator?.appendConditionToQuery(queryBuilder) + sqlOperator?.appendConditionToQuery(this) } - queryBuilder.append(" THEN ") - .append(BaseOperator.convertValueToString(if (isThenPropertySet) - thenProperty - else - thenValue, false)) - return queryBuilder.query + append(" THEN ") + append(BaseOperator.convertValueToString( + if (isThenPropertySet) thenProperty else thenValue, false)) } internal constructor(caze: Case, sqlOperator: SQLOperator) { diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/ExistenceOperator.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/ExistenceOperator.kt index d12a75bb9..6424a74be 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/ExistenceOperator.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/ExistenceOperator.kt @@ -1,7 +1,7 @@ package com.raizlabs.android.dbflow.sql.language +import com.raizlabs.android.dbflow.appendQualifier import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.sql.QueryBuilder /** * Description: The condition that represents EXISTS in a SQL statement. @@ -9,13 +9,9 @@ import com.raizlabs.android.dbflow.sql.QueryBuilder class ExistenceOperator(private val innerWhere: Where<*>) : SQLOperator, Query { override val query: String - get() { - val queryBuilder = QueryBuilder() - appendConditionToQuery(queryBuilder) - return queryBuilder.query - } + get() = appendToQuery() - override fun appendConditionToQuery(queryBuilder: QueryBuilder) { + override fun appendConditionToQuery(queryBuilder: StringBuilder) { queryBuilder.appendQualifier("EXISTS", "(" + innerWhere.query.trim({ it <= ' ' }) + ")") } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Operator.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Operator.kt index 7906d32cf..6f9c74eb5 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Operator.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Operator.kt @@ -3,6 +3,7 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.annotation.Collate +import com.raizlabs.android.dbflow.appendOptional import com.raizlabs.android.dbflow.config.FlowLog import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.converter.TypeConverter @@ -22,11 +23,7 @@ class Operator : BaseOperator, IOperator { private var convertToDB: Boolean = false override val query: String - get() { - val queryBuilder = QueryBuilder() - appendConditionToQuery(queryBuilder) - return queryBuilder.query - } + get() = appendToQuery() /** * Creates a new instance @@ -46,7 +43,7 @@ class Operator : BaseOperator, IOperator { this.value = operator.value } - override fun appendConditionToQuery(queryBuilder: QueryBuilder) { + override fun appendConditionToQuery(queryBuilder: StringBuilder) { queryBuilder.append(columnName()).append(operation()) // Do not use value for certain operators @@ -56,7 +53,7 @@ class Operator : BaseOperator, IOperator { } if (postArgument() != null) { - queryBuilder.appendSpace().append(postArgument()) + queryBuilder.append(" ${postArgument()}") } } @@ -530,11 +527,7 @@ class Operator : BaseOperator, IOperator { private var secondValue: T? = null override val query: String - get() { - val builder = QueryBuilder() - appendConditionToQuery(builder) - return builder.query - } + get() = appendToQuery() init { this.operation = " ${Operation.BETWEEN} " @@ -549,12 +542,13 @@ class Operator : BaseOperator, IOperator { fun secondValue(): T? = secondValue - override fun appendConditionToQuery(queryBuilder: QueryBuilder) { + override fun appendConditionToQuery(queryBuilder: StringBuilder) { queryBuilder.append(columnName()).append(operation()) .append(convertObjectToString(value(), true)) - .appendSpaceSeparated(Operation.AND) + .append(" ${Operation.AND} ") .append(convertObjectToString(secondValue(), true)) - .appendSpace().appendOptional(postArgument()) + .append(" ") + .appendOptional(postArgument()) } } @@ -567,11 +561,7 @@ class Operator : BaseOperator, IOperator { private val inArguments = ArrayList() override val query: String - get() { - val builder = QueryBuilder() - appendConditionToQuery(builder) - return builder.query - } + get() = appendToQuery() /** * Creates a new instance @@ -605,9 +595,12 @@ class Operator : BaseOperator, IOperator { return this } - override fun appendConditionToQuery(queryBuilder: QueryBuilder) { - queryBuilder.append(columnName()).append(operation()) - .append("(").append(BaseOperator.joinArguments(",", inArguments, this)).append(")") + override fun appendConditionToQuery(queryBuilder: StringBuilder) { + queryBuilder.append(columnName()) + .append(operation()) + .append("(") + .append(BaseOperator.joinArguments(",", inArguments, this)) + .append(")") } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/OperatorGroup.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/OperatorGroup.kt index 39708436a..4e5f6fe7c 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/OperatorGroup.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/OperatorGroup.kt @@ -1,7 +1,6 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.sql.QueryBuilder import com.raizlabs.android.dbflow.sql.language.Operator.Operation import java.util.* @@ -14,7 +13,7 @@ constructor(columnName: NameAlias? = null) : BaseOperator(columnName), Query, It private val conditionsList = ArrayList() - private var internalQuery: QueryBuilder? = null + private var internalQuery: String? = null private var isChanged: Boolean = false private var allCommaSeparated: Boolean = false private var useParenthesis = true @@ -22,12 +21,8 @@ constructor(columnName: NameAlias? = null) : BaseOperator(columnName), Query, It val conditions: List get() = conditionsList - private val querySafe: QueryBuilder - get() { - val query = QueryBuilder() - appendConditionToQuery(query) - return query - } + private val querySafe: String + get() = appendToQuery() init { @@ -114,7 +109,7 @@ constructor(columnName: NameAlias? = null) : BaseOperator(columnName), Query, It } } - override fun appendConditionToQuery(queryBuilder: QueryBuilder) { + override fun appendConditionToQuery(queryBuilder: StringBuilder) { val conditionListSize = conditionsList.size if (useParenthesis && conditionListSize > 0) { queryBuilder.append("(") @@ -123,7 +118,7 @@ constructor(columnName: NameAlias? = null) : BaseOperator(columnName), Query, It val condition = conditionsList[i] condition.appendConditionToQuery(queryBuilder) if (!allCommaSeparated && condition.hasSeparator() && i < conditionListSize - 1) { - queryBuilder.appendSpaceSeparated(condition.separator()) + queryBuilder.append(" ${condition.separator()} ") } else if (i < conditionListSize - 1) { queryBuilder.append(", ") } @@ -150,10 +145,10 @@ constructor(columnName: NameAlias? = null) : BaseOperator(columnName), Query, It if (isChanged) { internalQuery = querySafe } - return if (internalQuery == null) "" else internalQuery.toString() + return internalQuery ?: "" } - override fun toString(): String = querySafe.toString() + override fun toString(): String = querySafe val size: Int get() = conditionsList.size diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/SQLOperator.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/SQLOperator.kt index 50a025fc8..46dfbd77e 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/SQLOperator.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/SQLOperator.kt @@ -12,7 +12,7 @@ interface SQLOperator { * * @param queryBuilder The builder to append to. */ - fun appendConditionToQuery(queryBuilder: QueryBuilder) + fun appendConditionToQuery(queryBuilder: StringBuilder) /** * The name of the column. @@ -52,3 +52,9 @@ interface SQLOperator { fun value(): Any? } + +fun SQLOperator.appendToQuery(): String { + val queryBuilder = StringBuilder() + appendConditionToQuery(queryBuilder) + return queryBuilder.toString() +} \ No newline at end of file diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/TriggerMethod.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/TriggerMethod.kt index 282fb70aa..9f75b1f2c 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/TriggerMethod.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/TriggerMethod.kt @@ -1,8 +1,8 @@ package com.raizlabs.android.dbflow.sql.language +import com.raizlabs.android.dbflow.appendArray import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.sql.QueryBuilder import com.raizlabs.android.dbflow.sql.language.property.IProperty /** @@ -17,27 +17,27 @@ internal constructor(internal val trigger: Trigger, private val methodName: Stri override val query: String get() { - val queryBuilder = QueryBuilder(trigger.query) + val queryBuilder = StringBuilder(trigger.query) .append(methodName) if (properties.isNotEmpty()) { - queryBuilder.appendSpaceSeparated("OF") + queryBuilder.append(" OF ") .appendArray(properties.toTypedArray()) } - queryBuilder.appendSpaceSeparated("ON").append(FlowManager.getTableName(onTable)) + queryBuilder.append(" ON ").append(FlowManager.getTableName(onTable)) if (forEachRow) { - queryBuilder.appendSpaceSeparated("FOR EACH ROW") + queryBuilder.append(" FOR EACH ROW ") } - if (whenCondition != null) { + whenCondition?.let { whenCondition -> queryBuilder.append(" WHEN ") - whenCondition!!.appendConditionToQuery(queryBuilder) - queryBuilder.appendSpace() + whenCondition.appendConditionToQuery(queryBuilder) + queryBuilder.append(" ") } - queryBuilder.appendSpace() + queryBuilder.append(" ") - return queryBuilder.query + return queryBuilder.toString() } init { diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/UnSafeStringOperator.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/UnSafeStringOperator.kt index f780c9a30..2ece33f96 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/UnSafeStringOperator.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/UnSafeStringOperator.kt @@ -2,7 +2,6 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.StringUtils import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.sql.QueryBuilder /** * Description: This class will use a String to describe its condition. @@ -14,11 +13,7 @@ class UnSafeStringOperator(selection: String, selectionArgs: Array) : SQ private var separator = "" override val query: String - get() { - val queryBuilder = QueryBuilder() - appendConditionToQuery(queryBuilder) - return queryBuilder.query - } + get() = appendToQuery() init { var newSelection: String? = selection @@ -31,7 +26,7 @@ class UnSafeStringOperator(selection: String, selectionArgs: Array) : SQ this.conditionString = newSelection } - override fun appendConditionToQuery(queryBuilder: QueryBuilder) { + override fun appendConditionToQuery(queryBuilder: StringBuilder) { queryBuilder.append(conditionString) } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/AlterTableMigration.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/AlterTableMigration.kt index 38fb1a2c5..deb7b00f3 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/AlterTableMigration.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/AlterTableMigration.kt @@ -1,10 +1,12 @@ package com.raizlabs.android.dbflow.sql.migration import android.support.annotation.CallSuper +import com.raizlabs.android.dbflow.appendQuotedIfNeeded import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.sql.QueryBuilder +import com.raizlabs.android.dbflow.quoteIfNeeded import com.raizlabs.android.dbflow.sql.SQLiteType import com.raizlabs.android.dbflow.sql.language.SQLite +import com.raizlabs.android.dbflow.stripQuotes import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper /** @@ -16,20 +18,15 @@ class AlterTableMigration( */ private val table: Class) : BaseMigration() { - /** - * The query we use - */ - private val query by lazy { QueryBuilder().append("ALTER").appendSpaceSeparated("TABLE") } - /** * The query to rename the table with */ - private var renameQuery: QueryBuilder? = null + private var renameQuery: String? = null /** * The columns to ALTER within a table */ - private val internalColumnDefinitions: MutableList by lazy { mutableListOf() } + private val internalColumnDefinitions: MutableList by lazy { mutableListOf() } private val columnNames: MutableList by lazy { arrayListOf() } @@ -38,34 +35,32 @@ class AlterTableMigration( */ private var oldTableName: String? = null - val alterTableQueryBuilder: QueryBuilder - get() = query - override fun migrate(database: DatabaseWrapper) { // "ALTER TABLE " - var sql = alterTableQueryBuilder.query + var sql = ALTER_TABLE val tableName = FlowManager.getTableName(table) // "{oldName} RENAME TO {newName}" // Since the structure has been updated already, the manager knows only the new name. - if (renameQuery != null) { - val renameQuery = QueryBuilder(sql).appendQuotedIfNeeded(oldTableName) - .append(this.renameQuery!!.query) - .append(tableName) - .toString() - database.execSQL(renameQuery) + renameQuery?.let { renameQuery -> + database.execSQL(buildString { + append(sql) + appendQuotedIfNeeded(oldTableName) + append(renameQuery) + append(tableName) + }) } // We have column definitions to add here // ADD COLUMN columnName {type} if (internalColumnDefinitions.isNotEmpty()) { SQLite.select().from(table).limit(0).query(database)?.use { cursor -> - sql = QueryBuilder(sql).append(tableName).toString() + sql = "$sql$tableName" for (i in internalColumnDefinitions.indices) { val columnDefinition = internalColumnDefinitions[i] - val columnName = QueryBuilder.stripQuotes(columnNames!![i]) + val columnName = columnNames[i].stripQuotes() if (cursor.getColumnIndex(columnName) == -1) { - database.execSQL("$sql ADD COLUMN ${columnDefinition.query}") + database.execSQL("$sql ADD COLUMN $columnDefinition") } } } @@ -89,7 +84,7 @@ class AlterTableMigration( */ fun renameFrom(oldName: String) = apply { oldTableName = oldName - renameQuery = QueryBuilder().append(" RENAME").appendSpaceSeparated("TO") + renameQuery = " RENAME TO " } /** @@ -101,9 +96,7 @@ class AlterTableMigration( * @return This instance */ fun addColumn(sqLiteType: SQLiteType, columnName: String) = apply { - val queryBuilder = QueryBuilder() - .append(QueryBuilder.quoteIfNeeded(columnName)).appendSpace().appendSQLiteType(sqLiteType) - internalColumnDefinitions.add(queryBuilder) + internalColumnDefinitions.add("${columnName.quoteIfNeeded()} ${sqLiteType.name}") columnNames.add(columnName) } @@ -117,27 +110,30 @@ class AlterTableMigration( * @return This instance */ fun addForeignKeyColumn(sqLiteType: SQLiteType, columnName: String, referenceClause: String) = apply { - val queryBuilder = QueryBuilder() - .append(QueryBuilder.quoteIfNeeded(columnName)).appendSpace().appendSQLiteType(sqLiteType) - .appendSpace().append("REFERENCES ").append(referenceClause) - internalColumnDefinitions.add(queryBuilder) + internalColumnDefinitions.add("${columnName.quoteIfNeeded()} ${sqLiteType.name} REFERENCES $referenceClause") columnNames.add(columnName) } /** * @return The query that renames the table. */ - fun getRenameQuery(): String { - val queryBuilder = QueryBuilder(alterTableQueryBuilder.query).appendQuotedIfNeeded(oldTableName) - .append(renameQuery).append(FlowManager.getTableName(table)) - return queryBuilder.query + fun getRenameQuery(): String = buildString { + append(ALTER_TABLE) + appendQuotedIfNeeded(oldTableName) + append(renameQuery) + append(FlowManager.getTableName(table)) } /** * @return A List of column definitions that add op to a table in the DB. */ fun getColumnDefinitions(): List { - val sql = QueryBuilder(alterTableQueryBuilder).append(FlowManager.getTableName(table)).toString() - return internalColumnDefinitions.map { QueryBuilder(sql).appendSpaceSeparated("ADD COLUMN").append(it.query).query } + val sql = "$ALTER_TABLE${FlowManager.getTableName(table)}" + return internalColumnDefinitions.map { "$sql ADD COLUMN $it" } + } + + companion object { + + const val ALTER_TABLE = "ALTER TABLE " } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/BaseDatabaseHelper.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/BaseDatabaseHelper.kt index ebd096f78..30a2e22a1 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/BaseDatabaseHelper.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/BaseDatabaseHelper.kt @@ -5,7 +5,6 @@ import com.raizlabs.android.dbflow.config.DatabaseDefinition import com.raizlabs.android.dbflow.config.FlowLog import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.config.NaturalOrderComparator -import com.raizlabs.android.dbflow.sql.QueryBuilder import java.io.BufferedReader import java.io.IOException import java.io.InputStreamReader @@ -72,23 +71,19 @@ open class BaseDatabaseHelper(val databaseDefinition: DatabaseDefinition) { * This method executes CREATE TABLE statements as well as CREATE VIEW on the database passed. */ protected fun executeViewCreations(database: DatabaseWrapper) { - try { database.beginTransaction() val modelViews = databaseDefinition.modelViewAdapters - for (modelView in modelViews) { - val queryBuilder = QueryBuilder() - .append("CREATE VIEW IF NOT EXISTS") - .appendSpaceSeparated(modelView.viewName) - .append("AS ") - .append(modelView.creationQuery) - try { - database.execSQL(queryBuilder.query) - } catch (e: SQLiteException) { - FlowLog.logError(e) - } - - } + modelViews + .asSequence() + .map { "CREATE VIEW IF NOT EXISTS ${it.viewName} AS ${it.creationQuery}" } + .forEach { + try { + database.execSQL(it) + } catch (e: SQLiteException) { + FlowLog.logError(e) + } + } database.setTransactionSuccessful() } finally { database.endTransaction() From b7bdccc16d0ecdd1942dd1133e4670e7a2620cf5 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Thu, 23 Nov 2017 16:24:42 -0500 Subject: [PATCH 061/234] [5.0] finish removing querybuilder. --- .../raizlabs/android/dbflow/StringUtils.kt | 29 +- .../android/dbflow/sql/QueryBuilder.java | 318 ------------------ .../android/dbflow/processor/ClassNames.kt | 2 + .../definition/InternalAdapterHelper.kt | 4 +- .../dbflow/processor/definition/Methods.kt | 32 +- .../processor/definition/TableDefinition.kt | 12 +- .../definition/UniqueGroupsDefinition.kt | 6 +- .../definition/column/ColumnAccessCombiner.kt | 18 +- .../definition/column/ColumnDefinition.kt | 17 +- .../definition/column/DefinitionUtils.kt | 4 +- .../column/ReferenceColumnDefinition.kt | 65 ++-- .../definition/column/ReferenceDefinition.kt | 28 +- .../android/dbflow/config/DatabaseConfig.kt | 4 +- .../android/dbflow/config/FlowManager.kt | 6 +- .../raizlabs/android/dbflow/sql/SqlUtils.java | 64 +--- .../android/dbflow/sql/language/Case.kt | 13 +- .../dbflow/sql/language/CompletedTrigger.kt | 10 +- .../android/dbflow/sql/language/Delete.kt | 5 +- .../android/dbflow/sql/language/From.kt | 13 +- .../android/dbflow/sql/language/Index.kt | 17 +- .../android/dbflow/sql/language/IndexedBy.kt | 13 +- .../android/dbflow/sql/language/Insert.kt | 12 +- .../android/dbflow/sql/language/Join.kt | 20 +- .../android/dbflow/sql/language/NameAlias.kt | 37 +- .../android/dbflow/sql/language/Operator.kt | 3 +- .../dbflow/sql/language/SQLOperator.kt | 4 +- .../android/dbflow/sql/language/Select.kt | 11 +- .../android/dbflow/sql/language/Set.kt | 9 +- .../android/dbflow/sql/language/Trigger.kt | 9 +- .../sql/language/UnSafeStringOperator.kt | 4 +- .../android/dbflow/sql/language/Update.kt | 9 +- .../android/dbflow/sql/language/Where.kt | 10 +- .../sql/language/property/IndexProperty.kt | 7 +- 33 files changed, 225 insertions(+), 590 deletions(-) delete mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/sql/QueryBuilder.java diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/StringUtils.kt b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/StringUtils.kt index 9dddb85ac..1e8a47a81 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/StringUtils.kt +++ b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/StringUtils.kt @@ -1,27 +1,22 @@ +@file:JvmName("StringUtils") + package com.raizlabs.android.dbflow import com.raizlabs.android.dbflow.sql.SQLiteType import java.util.regex.Pattern + /** - * Description: Provides handy method for strings + * @return true if the string is not null, empty string "", or the length is greater than 0 */ -object StringUtils { - - /** - * @return true if the string is not null, empty string "", or the length is greater than 0 - */ - @JvmStatic - fun isNotNullOrEmpty(inString: String?): Boolean = - inString != null && inString != "" && inString.isNotEmpty() - - /** - * @return true if the string is null, empty string "", or the length is less than equal to 0 - */ - @JvmStatic - fun isNullOrEmpty(inString: String?): Boolean = - inString == null || inString == "" || inString.isEmpty() -} +fun String?.isNullOrEmpty(): Boolean = + this == null || this == "" || isEmpty() + +/** + * @return true if the string is null, empty string "", or the length is less than equal to 0 + */ +fun String?.isNotNullOrEmpty(): Boolean = + this != null && this != "" && isNotEmpty() fun StringBuilder.appendQuotedIfNeeded(string: String?) = apply { if (string == "*") diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/sql/QueryBuilder.java b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/sql/QueryBuilder.java deleted file mode 100644 index b695463c0..000000000 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/sql/QueryBuilder.java +++ /dev/null @@ -1,318 +0,0 @@ -package com.raizlabs.android.dbflow.sql; - -import java.util.List; -import java.util.regex.Pattern; - -/** - * Description: This is used as a wrapper around {@link StringBuilder} in order to provide more - * database focused methods and to assist in generating queries to the DB using our SQL wrappers. - */ -public class QueryBuilder implements Query { - - private static final char QUOTE = '`'; - - private static final Pattern QUOTE_PATTERN = Pattern.compile(QUOTE + ".*" + QUOTE); - - /** - * This query is backed by a {@link StringBuilder} - */ - protected StringBuilder query = new StringBuilder(); - - /** - * Constructs this item with an empty {@link StringBuilder} - */ - public QueryBuilder() { - super(); - } - - /** - * Constructs this class with the specified String - * - * @param object The string to append - */ - public QueryBuilder(Object object) { - append(object); - } - - /** - * Appends a space to this query - * - * @return This instance - */ - public QueryBuilder appendSpace() { - return append(" "); - } - - /** - * Appends the string with spaces on the front and end of the string - * - * @param object The object to append - * @return This instance - */ - @SuppressWarnings("unchecked") - public QueryBuilder appendSpaceSeparated(Object object) { - return appendSpace().append(object).appendSpace(); - } - - /** - * Appends the string as (string) - * - * @param string The string to append - * @return This instance - */ - @SuppressWarnings("unchecked") - public QueryBuilder appendParenthesisEnclosed(Object string) { - return append("(").append(string).append(")"); - } - - /** - * Appends an object to this query - * - * @param object The object to append - * @return This instance - */ - public QueryBuilder append(Object object) { - query.append(object); - return this; - } - - /** - * Appends the object only if its not null - * - * @param object If not null, its string representation. - * @return This instance - */ - public QueryBuilder appendOptional(Object object) { - if (object != null) { - append(object); - } - return this; - } - - /** - * Appends an {@link SQLiteType} to this query based on the class - * passed in. - * - * @param type The Class to look up from {@link SQLiteType} - * @return This instance - */ - public QueryBuilder appendType(String type) { - return appendSQLiteType(SQLiteType.Companion.get(type)); - } - - /** - * Appends the {@link SQLiteType} to this query - * - * @param sqLiteType The {@link SQLiteType} to append - * @return This instance - */ - public QueryBuilder appendSQLiteType(SQLiteType sqLiteType) { - return append(sqLiteType.name()); - } - - /** - * Appends an array of these objects by joining them with a comma with - * {@link #join(CharSequence, Object[])} - * - * @param objects The array of objects to pass in - * @return This instance - */ - public QueryBuilder appendArray(Object... objects) { - return append(join(", ", objects)); - } - - /** - * Appends a list of objects by joining them with a comma with - * {@link #join(CharSequence, Iterable)} - * - * @param objects The list of objects to pass in - * @return This instance - */ - public QueryBuilder appendList(List objects) { - return append(join(", ", objects)); - } - - /** - * Appends a value only if it's not empty or null - * - * @param name The name of the qualifier - * @param value The value to append after the name - * @return This instance - */ - public QueryBuilder appendQualifier(String name, String value) { - if (value != null && value.length() > 0) { - if (name != null) { - append(name); - } - appendSpaceSeparated(value); - } - return this; - } - - /** - * Only appends the text if it is not null or empty - * - * @param string The string to append - * @return This instance - */ - public QueryBuilder appendNotEmpty(String string) { - if (string != null && !string.isEmpty()) { - append(string); - } - return this; - } - - /** - * Appends a quoted string. If the string is the all symbol '*', we do not quote it. - * - * @param string The string to append - * @return This instance - */ - @SuppressWarnings("unchecked") - public QueryBuilder appendQuoted(String string) { - if (string.equals("*")) - return append(string); - - append(quote(string)); - return this; - } - - /** - * Appends a quoted string if needed. If the string is the all symbol '*', we do not quote it. - * - * @param string The string to append - * @return This instance - */ - @SuppressWarnings("unchecked") - public QueryBuilder appendQuotedIfNeeded(String string) { - if (string.equals("*")) - return append(string); - - append(quoteIfNeeded(string)); - return this; - } - - /** - * Appends a list of objects by quoting and joining them with a comma with - * {@link #join(CharSequence, Iterable)} - * - * @param objects The list of objects to pass in - * @return This instance - */ - @SuppressWarnings("unchecked") - public QueryBuilder appendQuotedList(List objects) { - return appendQuoted(join("`, `", objects)); - } - - /** - * Appends an array of these objects by quoting and joining them with a comma with - * {@link #join(CharSequence, Object[])} - * - * @param objects The array of objects to pass in - * @return This instance - */ - public QueryBuilder appendQuotedArray(Object... objects) { - return appendQuoted(join("`, `", objects)); - } - - @Override - public String toString() { - return getQuery(); - } - - @Override - public String getQuery() { - return query.toString(); - } - - /** - * @param columnName The column name to use. - * @return A name in quotes. E.G. index => `index` so we can use keywords as column names without fear - * of clashing. - */ - public static String quote(String columnName) { - return QUOTE + columnName.replace(".", "`.`") + QUOTE; - } - - /** - * Quotes the identifier if its not already quoted. - * - * @param name The name of the column or table. - * @return Quoted only once. - */ - public static String quoteIfNeeded(String name) { - if (name != null && !isQuoted(name)) { - return quote(name); - } else { - return name; - } - } - - /** - * Helper method to check if name is quoted. - * - * @param name The name of a column or table. - * @return true if the name is quoted. We may not want to quote something if its already so. - */ - public static boolean isQuoted(String name) { - return (QUOTE_PATTERN.matcher(name).find()); - } - - /** - * Strips quotes out of a identifier if need to do so. - * - * @param name The name ot strip the quotes from. - * @return A non-quoted name. - */ - public static String stripQuotes(String name) { - String ret = name; - if (ret != null && isQuoted(ret)) { - ret = ret.replace("`", ""); - } - return ret; - } - - /** - * Returns a string containing the tokens joined by delimiters. - * - * @param delimiter The text to join the text with. - * @param tokens an array objects to be joined. Strings will be formed from - * the objects by calling object.toString(). - * @return A joined string - */ - public static String join(CharSequence delimiter, Object[] tokens) { - StringBuilder sb = new StringBuilder(); - boolean firstTime = true; - for (Object token : tokens) { - if (firstTime) { - firstTime = false; - } else { - sb.append(delimiter); - } - sb.append(token); - } - return sb.toString(); - } - - /** - * Returns a string containing the tokens joined by delimiters. - * - * @param delimiter The text to join the text with. - * @param tokens an array objects to be joined. Strings will be formed from - * the objects by calling object.toString(). - * @return A joined string - */ - public static String join(CharSequence delimiter, Iterable tokens) { - StringBuilder sb = new StringBuilder(); - boolean firstTime = true; - for (Object token : tokens) { - if (firstTime) { - firstTime = false; - } else { - sb.append(delimiter); - } - sb.append(token); - } - return sb.toString(); - } -} diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/ClassNames.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/ClassNames.kt index 409802bf2..4875035ff 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/ClassNames.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/ClassNames.kt @@ -96,4 +96,6 @@ object ClassNames { val NON_NULL = ClassName.get("android.support.annotation", "NonNull") val GENERATED = ClassName.get("javax.annotation", "Generated") + + val STRING_UTILS = ClassName.get(BASE_PACKAGE, "StringUtils") } diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/InternalAdapterHelper.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/InternalAdapterHelper.kt index 5df837639..e1b50d3ef 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/InternalAdapterHelper.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/InternalAdapterHelper.kt @@ -4,7 +4,7 @@ import com.raizlabs.android.dbflow.processor.ClassNames import com.raizlabs.android.dbflow.processor.definition.column.ColumnDefinition import com.raizlabs.android.dbflow.processor.definition.column.DefinitionUtils import com.raizlabs.android.dbflow.processor.utils.ModelUtils -import com.raizlabs.android.dbflow.sql.QueryBuilder +import com.raizlabs.android.dbflow.quote import com.squareup.javapoet.ArrayTypeName import com.squareup.javapoet.ClassName import com.squareup.javapoet.MethodSpec @@ -30,7 +30,7 @@ object InternalAdapterHelper { fun writeGetTableName(typeBuilder: TypeSpec.Builder, tableName: String?) { typeBuilder.addMethod(MethodSpec.methodBuilder("getTableName") .addModifiers(Modifier.PUBLIC, Modifier.FINAL) - .addStatement("return \$S", QueryBuilder.quote(tableName)) + .addStatement("return \$S", tableName.quote()) .returns(ClassName.get(String::class.java)) .build()) } diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/Methods.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/Methods.kt index 48ab60d03..13b0e3e4c 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/Methods.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/Methods.kt @@ -1,14 +1,28 @@ package com.raizlabs.android.dbflow.processor.definition -import com.grosner.kpoet.* +import com.grosner.kpoet.S +import com.grosner.kpoet.`=` +import com.grosner.kpoet.`private final field` +import com.grosner.kpoet.`return` +import com.grosner.kpoet.code +import com.grosner.kpoet.final +import com.grosner.kpoet.modifiers +import com.grosner.kpoet.param +import com.grosner.kpoet.public +import com.grosner.kpoet.statement import com.raizlabs.android.dbflow.processor.ClassNames import com.raizlabs.android.dbflow.processor.definition.column.wrapperCommaIfBaseModel import com.raizlabs.android.dbflow.processor.utils.ModelUtils import com.raizlabs.android.dbflow.processor.utils.`override fun` import com.raizlabs.android.dbflow.processor.utils.codeBlock import com.raizlabs.android.dbflow.processor.utils.isNullOrEmpty -import com.raizlabs.android.dbflow.sql.QueryBuilder -import com.squareup.javapoet.* +import com.raizlabs.android.dbflow.quote +import com.squareup.javapoet.ClassName +import com.squareup.javapoet.CodeBlock +import com.squareup.javapoet.MethodSpec +import com.squareup.javapoet.NameAllocator +import com.squareup.javapoet.TypeName +import com.squareup.javapoet.TypeSpec import java.util.* import java.util.concurrent.atomic.AtomicInteger import javax.lang.model.element.Modifier @@ -198,7 +212,7 @@ class CreationQueryMethod(private val tableDefinition: TableDefinition) : Method val foreignSize = tableDefinition.foreignKeyDefinitions.size val creationBuilder = codeBlock { - add("CREATE TABLE IF NOT EXISTS ${QueryBuilder.quote(tableDefinition.tableName)}(") + add("CREATE TABLE IF NOT EXISTS ${tableDefinition.tableName.quote()}(") add(tableDefinition.columnDefinitions.joinToString { it.creationName.toString() }) tableDefinition.uniqueGroupsDefinitions.forEach { if (!it.columnDefinitionList.isEmpty()) add(it.creationName) @@ -233,7 +247,7 @@ class CreationQueryMethod(private val tableDefinition: TableDefinition) : Method foreignKeyBlocks.add(foreignKeyBuilder.apply { add(", FOREIGN KEY(") - add(fk._referenceDefinitionList.joinToString { QueryBuilder.quote(it.columnName) }) + add(fk._referenceDefinitionList.joinToString { it.columnName.quote() }) add(") REFERENCES ") }.build()) @@ -241,7 +255,7 @@ class CreationQueryMethod(private val tableDefinition: TableDefinition) : Method referenceKeyBlocks.add(referenceBuilder.apply { add("(") - add(fk._referenceDefinitionList.joinToString { QueryBuilder.quote(it.foreignColumnName) }) + add(fk._referenceDefinitionList.joinToString { it.foreignColumnName.quote() }) add(") ON UPDATE ${fk.onUpdate.name.replace("_", " ")} ON DELETE ${fk.onDelete.name.replace("_", " ")}") if (fk.deferred) { add(" DEFERRABLE INITIALLY DEFERRED") @@ -337,7 +351,7 @@ class InsertStatementQueryMethod(private val tableDefinition: TableDefinition, p if (!tableDefinition.insertConflictActionName.isEmpty()) { add("OR ${tableDefinition.insertConflictActionName} ") } - add("INTO ${QueryBuilder.quote(tableDefinition.tableName)}(") + add("INTO ${tableDefinition.tableName.quote()}(") tableDefinition.columnDefinitions.filter { !it.isPrimaryKeyAutoIncrement && !it.isRowId || !isInsert || isSingleAutoincrement @@ -373,7 +387,7 @@ class UpdateStatementQueryMethod(private val tableDefinition: TableDefinition) : if (!tableDefinition.updateConflictActionName.isEmpty()) { add(" OR ${tableDefinition.updateConflictActionName}") } - add(" ${QueryBuilder.quote(tableDefinition.tableName)} SET ") + add(" ${tableDefinition.tableName.quote()} SET ") // can only change non primary key values. tableDefinition.columnDefinitions.filter { @@ -405,7 +419,7 @@ class DeleteStatementQueryMethod(private val tableDefinition: TableDefinition) : return `override fun`(String::class, "getDeleteStatementQuery") { modifiers(public, final) `return`(codeBlock { - add("DELETE FROM ${QueryBuilder.quote(tableDefinition.tableName)} WHERE ") + add("DELETE FROM ${tableDefinition.tableName.quote()} WHERE ") // primary key values used as WHERE tableDefinition.columnDefinitions.filter { diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/TableDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/TableDefinition.kt index 182ddc996..6936cb825 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/TableDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/TableDefinition.kt @@ -43,7 +43,9 @@ import com.raizlabs.android.dbflow.processor.utils.annotation import com.raizlabs.android.dbflow.processor.utils.ensureVisibleStatic import com.raizlabs.android.dbflow.processor.utils.implementsClass import com.raizlabs.android.dbflow.processor.utils.isNullOrEmpty -import com.raizlabs.android.dbflow.sql.QueryBuilder +import com.raizlabs.android.dbflow.quote +import com.raizlabs.android.dbflow.quoteIfNeeded +import com.raizlabs.android.dbflow.stripQuotes import com.squareup.javapoet.ArrayTypeName import com.squareup.javapoet.ClassName import com.squareup.javapoet.CodeBlock @@ -387,7 +389,7 @@ class TableDefinition(manager: ProcessorManager, element: TypeElement) : BaseTab `override fun`(String::class, "getTableName") { modifiers(public, final) - `return`(QueryBuilder.quote(tableName).S) + `return`(tableName.quote().S) } `override fun`(elementClassName!!, "newInstance") { @@ -415,7 +417,7 @@ class TableDefinition(manager: ProcessorManager, element: TypeElement) : BaseTab `override fun`(ClassNames.PROPERTY, "getProperty", param(String::class, paramColumnName)) { modifiers(public, final) - statement("$paramColumnName = \$T.quoteIfNeeded($paramColumnName)", ClassName.get(QueryBuilder::class.java)) + statement("$paramColumnName = \$T.quoteIfNeeded($paramColumnName)", ClassNames.STRING_UTILS) switch("($paramColumnName)") { columnDefinitions.indices.forEach { i -> @@ -458,7 +460,7 @@ class TableDefinition(manager: ProcessorManager, element: TypeElement) : BaseTab } `override fun`(String::class, "getAutoIncrementingColumnName") { modifiers(public, final) - `return`(QueryBuilder.stripQuotes(autoIncrement.columnName).S) + `return`(autoIncrement.columnName.stripQuotes().S) } `override fun`(ParameterizedTypeName.get(ClassNames.SINGLE_MODEL_SAVER, elementClassName!!), "createSingleModelSaver") { @@ -593,7 +595,7 @@ class TableDefinition(manager: ProcessorManager, element: TypeElement) : BaseTab `override fun`(ArrayTypeName.of(ClassName.get(String::class.java)), "createCachingColumns") { modifiers(public, final) - `return`("new String[]{${primaryColumns.joinToString { QueryBuilder.quoteIfNeeded(it.columnName).S }}}") + `return`("new String[]{${primaryColumns.joinToString { it.columnName.quoteIfNeeded().S }}}") } if (cacheSize != DEFAULT_CACHE_SIZE) { diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/UniqueGroupsDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/UniqueGroupsDefinition.kt index eebeffd9a..92068afb4 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/UniqueGroupsDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/UniqueGroupsDefinition.kt @@ -4,7 +4,7 @@ import com.raizlabs.android.dbflow.annotation.ConflictAction import com.raizlabs.android.dbflow.annotation.UniqueGroup import com.raizlabs.android.dbflow.processor.definition.column.ColumnDefinition import com.raizlabs.android.dbflow.processor.definition.column.ReferenceColumnDefinition -import com.raizlabs.android.dbflow.sql.QueryBuilder +import com.raizlabs.android.dbflow.quote import com.squareup.javapoet.CodeBlock import java.util.* @@ -33,10 +33,10 @@ class UniqueGroupsDefinition(uniqueGroup: UniqueGroup) { } if (it is ReferenceColumnDefinition) { for (reference in it._referenceDefinitionList) { - codeBuilder.add(QueryBuilder.quote(reference.columnName)) + codeBuilder.add(reference.columnName.quote()) } } else { - codeBuilder.add(QueryBuilder.quote(it.columnName)) + codeBuilder.add(it.columnName.quote()) } count++ } diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ColumnAccessCombiner.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ColumnAccessCombiner.kt index 5b4143ddb..a2175e94f 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ColumnAccessCombiner.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ColumnAccessCombiner.kt @@ -1,13 +1,17 @@ package com.raizlabs.android.dbflow.processor.definition.column -import com.grosner.kpoet.* +import com.grosner.kpoet.S +import com.grosner.kpoet.`else` +import com.grosner.kpoet.`if` +import com.grosner.kpoet.end +import com.grosner.kpoet.statement import com.raizlabs.android.dbflow.processor.ClassNames import com.raizlabs.android.dbflow.processor.SQLiteHelper import com.raizlabs.android.dbflow.processor.utils.ModelUtils import com.raizlabs.android.dbflow.processor.utils.catch import com.raizlabs.android.dbflow.processor.utils.isNullOrEmpty import com.raizlabs.android.dbflow.processor.utils.statement -import com.raizlabs.android.dbflow.sql.QueryBuilder +import com.raizlabs.android.dbflow.quote import com.squareup.javapoet.ClassName import com.squareup.javapoet.CodeBlock import com.squareup.javapoet.NameAllocator @@ -126,7 +130,7 @@ class ContentValuesCombiner(combiner: Combiner) combiner.apply { val fieldAccess: CodeBlock = getFieldAccessBlock(this@addCode, modelBlock) if (fieldTypeName.isPrimitive) { - statement("values.put(\$1S, \$2L)", QueryBuilder.quote(columnRepresentation), fieldAccess) + statement("values.put(\$1S, \$2L)", columnRepresentation.quote(), fieldAccess) } else { if (defaultValue != null) { val storedFieldAccess = fieldAccess @@ -137,22 +141,22 @@ class ContentValuesCombiner(combiner: Combiner) if (storedFieldAccess.toString() != subWrapperFieldAccess.toString() || defaultValue.toString() != "null") { statement("values.put(\$S, \$L != null ? \$L : \$L)", - QueryBuilder.quote(columnRepresentation), storedFieldAccess, subWrapperFieldAccess, defaultValue) + columnRepresentation.quote(), storedFieldAccess, subWrapperFieldAccess, defaultValue) } else { // if same default value is null and object reference is same as subwrapper. statement("values.put(\$S, \$L)", - QueryBuilder.quote(columnRepresentation), storedFieldAccess) + columnRepresentation.quote(), storedFieldAccess) } } else { statement("values.put(\$S, \$L)", - QueryBuilder.quote(columnRepresentation), fieldAccess) + columnRepresentation.quote(), fieldAccess) } } } } override fun addNull(code: CodeBlock.Builder, columnRepresentation: String, index: Int) { - code.addStatement("values.putNull(\$S)", QueryBuilder.quote(columnRepresentation)) + code.addStatement("values.putNull(\$S)", columnRepresentation.quote()) } } diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ColumnDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ColumnDefinition.kt index 6deb4ac8a..481fbbe59 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ColumnDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ColumnDefinition.kt @@ -22,7 +22,7 @@ import com.raizlabs.android.dbflow.processor.utils.getTypeElement import com.raizlabs.android.dbflow.processor.utils.isNullOrEmpty import com.raizlabs.android.dbflow.processor.utils.toClassName import com.raizlabs.android.dbflow.processor.utils.toTypeElement -import com.raizlabs.android.dbflow.sql.QueryBuilder +import com.raizlabs.android.dbflow.quote import com.squareup.javapoet.ArrayTypeName import com.squareup.javapoet.ClassName import com.squareup.javapoet.CodeBlock @@ -32,7 +32,6 @@ import com.squareup.javapoet.NameAllocator import com.squareup.javapoet.ParameterizedTypeName import com.squareup.javapoet.TypeName import com.squareup.javapoet.TypeSpec -import java.util.* import java.util.concurrent.atomic.AtomicInteger import java.util.regex.Pattern import javax.lang.model.element.Element @@ -70,8 +69,8 @@ constructor(processorManager: ProcessorManager, element: Element, var onUniqueConflict: ConflictAction? = null var unique = false - var uniqueGroups: MutableList = ArrayList() - var indexGroups: MutableList = ArrayList() + var uniqueGroups: MutableList = arrayListOf() + var indexGroups: MutableList = arrayListOf() var collate = Collate.NONE var defaultValue: String? = null @@ -90,10 +89,10 @@ constructor(processorManager: ProcessorManager, element: Element, var typeConverterDefinition: TypeConverterDefinition? = null open val updateStatementBlock: CodeBlock - get() = CodeBlock.of("${QueryBuilder.quote(columnName)}=?") + get() = CodeBlock.of("${columnName.quote()}=?") open val insertStatementColumnName: CodeBlock - get() = CodeBlock.of("\$L", QueryBuilder.quote(columnName)) + get() = CodeBlock.of("\$L", columnName.quote()) open val insertStatementValuesString: CodeBlock? = CodeBlock.of("?") @@ -101,7 +100,7 @@ constructor(processorManager: ProcessorManager, element: Element, get() = arrayListOf(elementTypeName) open val primaryKeyName: String? - get() = QueryBuilder.quote(columnName) + get() = columnName.quote() init { element.annotation()?.let { notNullAnno -> @@ -305,7 +304,7 @@ constructor(processorManager: ProcessorManager, element: Element, if (tableDef is TableDefinition) { tableName = tableDef.tableName ?: "" } - return "${baseTableDefinition.databaseDefinition?.databaseClassName}.$tableName.${QueryBuilder.quote(columnName)}" + return "${baseTableDefinition.databaseDefinition?.databaseClassName}.$tableName.${columnName.quote()}" } open fun addPropertyDefinition(typeBuilder: TypeSpec.Builder, tableClass: TypeName) { @@ -352,7 +351,7 @@ constructor(processorManager: ProcessorManager, element: Element, open fun addPropertyCase(methodBuilder: MethodSpec.Builder) { methodBuilder.apply { - beginControlFlow("case \$S: ", QueryBuilder.quote(columnName)) + beginControlFlow("case \$S: ", columnName.quote()) addStatement("return \$L", propertyFieldName) endControlFlow() } diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/DefinitionUtils.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/DefinitionUtils.kt index 2e2f50826..9901044c4 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/DefinitionUtils.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/DefinitionUtils.kt @@ -1,7 +1,7 @@ package com.raizlabs.android.dbflow.processor.definition.column import com.raizlabs.android.dbflow.processor.SQLiteHelper -import com.raizlabs.android.dbflow.sql.QueryBuilder +import com.raizlabs.android.dbflow.quote import com.squareup.javapoet.CodeBlock import com.squareup.javapoet.TypeName @@ -19,7 +19,7 @@ object DefinitionUtils { statement = SQLiteHelper[elementTypeName].toString() } - return CodeBlock.builder().add("\$L \$L", QueryBuilder.quote(columnName), statement) + return CodeBlock.builder().add("\$L \$L", columnName.quote(), statement) } diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ReferenceColumnDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ReferenceColumnDefinition.kt index 0dc5676a7..37d99a802 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ReferenceColumnDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ReferenceColumnDefinition.kt @@ -22,7 +22,8 @@ import com.raizlabs.android.dbflow.processor.utils.isNullOrEmpty import com.raizlabs.android.dbflow.processor.utils.isSubclass import com.raizlabs.android.dbflow.processor.utils.toTypeElement import com.raizlabs.android.dbflow.processor.utils.toTypeErasedElement -import com.raizlabs.android.dbflow.sql.QueryBuilder +import com.raizlabs.android.dbflow.quote +import com.raizlabs.android.dbflow.quoteIfNeeded import com.squareup.javapoet.ClassName import com.squareup.javapoet.CodeBlock import com.squareup.javapoet.FieldSpec @@ -91,8 +92,8 @@ class ReferenceColumnDefinition(manager: ProcessorManager, tableDefinition: Base references = it.references.map { ReferenceSpecificationDefinition(columnName = it.columnName, - referenceName = it.columnMapFieldName, - onNullConflictAction = it.notNull.onNullConflict) + referenceName = it.columnMapFieldName, + onNullConflictAction = it.notNull.onNullConflict) } } @@ -134,14 +135,14 @@ class ReferenceColumnDefinition(manager: ProcessorManager, tableDefinition: Base references = foreignKey.references.map { ReferenceSpecificationDefinition(columnName = it.columnName, - referenceName = it.foreignKeyColumnName, - onNullConflictAction = it.notNull.onNullConflict) + referenceName = it.foreignKeyColumnName, + onNullConflictAction = it.notNull.onNullConflict) } } if (isNotNullType) { manager.logError("Foreign Keys must be nullable. Please remove the non-null annotation if using " + - "Java, or add ? to the type for Kotlin.") + "Java, or add ? to the type for Kotlin.") } } @@ -168,19 +169,19 @@ class ReferenceColumnDefinition(manager: ProcessorManager, tableDefinition: Base } if (it.columnName.isNullOrEmpty()) { manager.logError("Found empty reference name at ${it.foreignColumnName}" + - " from table ${baseTableDefinition.elementName}") + " from table ${baseTableDefinition.elementName}") } typeBuilder.addField(FieldSpec.builder(propParam, it.columnName, - Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL) - .initializer("new \$T(\$T.class, \$S)", propParam, tableClass, it.columnName) - .addJavadoc(if (isColumnMap) "Column Mapped Field" else ("Foreign Key" + if (isPrimaryKey) " / Primary Key" else "")).build()) + Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL) + .initializer("new \$T(\$T.class, \$S)", propParam, tableClass, it.columnName) + .addJavadoc(if (isColumnMap) "Column Mapped Field" else ("Foreign Key" + if (isPrimaryKey) " / Primary Key" else "")).build()) } } override fun addPropertyCase(methodBuilder: MethodSpec.Builder) { checkNeedsReferences() _referenceDefinitionList.forEach { - methodBuilder.case(QueryBuilder.quoteIfNeeded(it.columnName).S) { + methodBuilder.case(it.columnName.quoteIfNeeded().S) { `return`(it.columnName) } } @@ -221,7 +222,7 @@ class ReferenceColumnDefinition(manager: ProcessorManager, tableDefinition: Base builder.add(",") } val referenceDefinition = _referenceDefinitionList[i] - builder.add(CodeBlock.of("${QueryBuilder.quote(referenceDefinition.columnName)}=?")) + builder.add(CodeBlock.of("${referenceDefinition.columnName.quote()}=?")) } return builder.build() } @@ -235,7 +236,7 @@ class ReferenceColumnDefinition(manager: ProcessorManager, tableDefinition: Base builder.add(",") } val referenceDefinition = _referenceDefinitionList[i] - builder.add(QueryBuilder.quote(referenceDefinition.columnName)) + builder.add(referenceDefinition.columnName.quote()) } return builder.build() } @@ -329,11 +330,11 @@ class ReferenceColumnDefinition(manager: ProcessorManager, tableDefinition: Base referencedClassName?.let { referencedTableClassName -> val tableDefinition = manager.getReferenceDefinition( - baseTableDefinition.databaseDefinition?.elementTypeName, referencedTableClassName) + baseTableDefinition.databaseDefinition?.elementTypeName, referencedTableClassName) val outputClassName = tableDefinition?.outputClassName outputClassName?.let { val foreignKeyCombiner = ForeignKeyLoadFromCursorCombiner(columnAccessor, - referencedTableClassName, outputClassName, isStubbedRelationship, nameAllocator) + referencedTableClassName, outputClassName, isStubbedRelationship, nameAllocator) _referenceDefinitionList.forEach { foreignKeyCombiner.fieldAccesses += it.partialAccessor } @@ -363,8 +364,8 @@ class ReferenceColumnDefinition(manager: ProcessorManager, tableDefinition: Base if (!nonModelColumn && columnAccessor !is TypeConverterScopeColumnAccessor) { referencedClassName?.let { referencedTableClassName -> val saveAccessor = ForeignKeyAccessField(columnName, - SaveModelAccessCombiner(Combiner(columnAccessor, referencedTableClassName, wrapperAccessor, - wrapperTypeName, subWrapperAccessor), implementsModel, extendsBaseModel)) + SaveModelAccessCombiner(Combiner(columnAccessor, referencedTableClassName, wrapperAccessor, + wrapperTypeName, subWrapperAccessor), implementsModel, extendsBaseModel)) saveAccessor.addCode(codeBuilder, 0, modelBlock) } } @@ -374,8 +375,8 @@ class ReferenceColumnDefinition(manager: ProcessorManager, tableDefinition: Base if (!nonModelColumn && columnAccessor !is TypeConverterScopeColumnAccessor) { referencedClassName?.let { referencedTableClassName -> val deleteAccessor = ForeignKeyAccessField(columnName, - DeleteModelAccessCombiner(Combiner(columnAccessor, referencedTableClassName, wrapperAccessor, - wrapperTypeName, subWrapperAccessor), implementsModel, extendsBaseModel)) + DeleteModelAccessCombiner(Combiner(columnAccessor, referencedTableClassName, wrapperAccessor, + wrapperTypeName, subWrapperAccessor), implementsModel, extendsBaseModel)) deleteAccessor.addCode(codeBuilder, 0, modelBlock) } } @@ -390,18 +391,18 @@ class ReferenceColumnDefinition(manager: ProcessorManager, tableDefinition: Base val referencedTableDefinition = manager.getReferenceDefinition(tableDefinition.databaseTypeName, referencedClassName) if (referencedTableDefinition == null) { manager.logError(ReferenceColumnDefinition::class, - "Could not find the referenced ${Table::class.java.simpleName} " + - "or ${QueryModel::class.java.simpleName} definition $referencedClassName" + - " from ${tableDefinition.elementName}. " + - "Ensure it exists in the same database as ${tableDefinition.databaseTypeName}") + "Could not find the referenced ${Table::class.java.simpleName} " + + "or ${QueryModel::class.java.simpleName} definition $referencedClassName" + + " from ${tableDefinition.elementName}. " + + "Ensure it exists in the same database as ${tableDefinition.databaseTypeName}") } else if (needsReferences) { val primaryColumns = - if (isColumnMap) referencedTableDefinition.columnDefinitions - else referencedTableDefinition.primaryColumnDefinitions + if (isColumnMap) referencedTableDefinition.columnDefinitions + else referencedTableDefinition.primaryColumnDefinitions if (references?.isEmpty() ?: true) { primaryColumns.forEach { val foreignKeyReferenceDefinition = ReferenceDefinition(manager, - elementName, it.elementName, it, this, primaryColumns.size, + elementName, it.elementName, it, this, primaryColumns.size, if (isColumnMap) it.elementName else "") _referenceDefinitionList.add(foreignKeyReferenceDefinition) } @@ -411,14 +412,14 @@ class ReferenceColumnDefinition(manager: ProcessorManager, tableDefinition: Base val foundDefinition = primaryColumns.find { it.columnName == reference.referenceName } if (foundDefinition == null) { manager.logError(ReferenceColumnDefinition::class, - "Could not find referenced column ${reference.referenceName} " + - "from reference named ${reference.columnName}") + "Could not find referenced column ${reference.referenceName} " + + "from reference named ${reference.columnName}") } else { _referenceDefinitionList.add( - ReferenceDefinition(manager, elementName, - foundDefinition.elementName, foundDefinition, this, - primaryColumns.size, reference.columnName, - reference.onNullConflictAction)) + ReferenceDefinition(manager, elementName, + foundDefinition.elementName, foundDefinition, this, + primaryColumns.size, reference.columnName, + reference.onNullConflictAction)) } } needsReferences = false diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ReferenceDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ReferenceDefinition.kt index bf69f6104..ba00b72be 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ReferenceDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ReferenceDefinition.kt @@ -6,7 +6,7 @@ import com.raizlabs.android.dbflow.processor.ProcessorManager import com.raizlabs.android.dbflow.processor.definition.TypeConverterDefinition import com.raizlabs.android.dbflow.processor.utils.ElementUtility import com.raizlabs.android.dbflow.processor.utils.isNullOrEmpty -import com.raizlabs.android.dbflow.sql.QueryBuilder +import com.raizlabs.android.dbflow.quote import com.squareup.javapoet.ClassName import com.squareup.javapoet.CodeBlock import com.squareup.javapoet.TypeName @@ -34,7 +34,7 @@ class ReferenceDefinition(private val manager: ProcessorManager, get() = DefinitionUtils.getCreationStatement(columnClassName, wrapperTypeName, columnName).build() internal val primaryKeyName: String - get() = QueryBuilder.quote(columnName) + get() = columnName.quote() private var isReferencedFieldPrivate: Boolean = false private var isReferencedFieldPackagePrivate: Boolean = false @@ -56,12 +56,12 @@ class ReferenceDefinition(private val manager: ProcessorManager, columnAccessor = PrivateScopeColumnAccessor(foreignKeyFieldName, getterSetter, false) } else if (isReferencedFieldPackagePrivate) { columnAccessor = PackagePrivateScopeColumnAccessor(foreignKeyFieldName, packageName, - referenceColumnDefinition.baseTableDefinition.databaseDefinition?.classSeparator, - name) + referenceColumnDefinition.baseTableDefinition.databaseDefinition?.classSeparator, + name) PackagePrivateScopeColumnAccessor.putElement( - (columnAccessor as PackagePrivateScopeColumnAccessor).helperClassName, - foreignKeyFieldName) + (columnAccessor as PackagePrivateScopeColumnAccessor).helperClassName, + foreignKeyFieldName) } else { columnAccessor = VisibleScopeColumnAccessor(foreignKeyFieldName) } @@ -73,10 +73,10 @@ class ReferenceDefinition(private val manager: ProcessorManager, evaluateTypeConverter(typeConverterDefinition) val combiner = Combiner(columnAccessor, columnClassName!!, wrapperAccessor, - wrapperTypeName, subWrapperAccessor, referenceColumnDefinition.elementName) + wrapperTypeName, subWrapperAccessor, referenceColumnDefinition.elementName) partialAccessor = PartialLoadFromCursorAccessCombiner(columnName, foreignColumnName, - columnClassName, referenceColumnDefinition.baseTableDefinition.orderedCursorLookUp, - columnAccessor, wrapperAccessor, wrapperTypeName) + columnClassName, referenceColumnDefinition.baseTableDefinition.orderedCursorLookUp, + columnAccessor, wrapperAccessor, wrapperTypeName) primaryReferenceField = ForeignKeyAccessField(columnName, PrimaryReferenceAccessCombiner(combiner)) @@ -92,12 +92,12 @@ class ReferenceDefinition(private val manager: ProcessorManager, if (it.modelTypeName != columnClassName) { manager.logError("The specified custom TypeConverter's Model Value %1s from %1s must match the type of the column %1s. ", - it.modelTypeName, it.className, columnClassName) + it.modelTypeName, it.className, columnClassName) } else { hasTypeConverter = true val fieldName = referenceColumnDefinition.baseTableDefinition - .addColumnForTypeConverter(referenceColumnDefinition, it.className) + .addColumnForTypeConverter(referenceColumnDefinition, it.className) wrapperAccessor = TypeConverterScopeColumnAccessor(fieldName) wrapperTypeName = it.dbTypeName @@ -113,7 +113,7 @@ class ReferenceDefinition(private val manager: ProcessorManager, if (!localColumnName.isNullOrEmpty()) { this.columnName = localColumnName } else if (!referenceColumnDefinition.isPrimaryKey && !referenceColumnDefinition.isPrimaryKeyAutoIncrement - && !referenceColumnDefinition.isRowId || referenceCount > 0) { + && !referenceColumnDefinition.isRowId || referenceCount > 0) { this.columnName = "${foreignKeyFieldName}_${referencedColumn.columnName}" } else { this.columnName = foreignKeyFieldName @@ -124,8 +124,8 @@ class ReferenceDefinition(private val manager: ProcessorManager, isReferencedFieldPackagePrivate = referencedColumn.columnAccessor is PackagePrivateScopeColumnAccessor val isPackagePrivate = ElementUtility.isPackagePrivate(referencedColumn.element) val isPackagePrivateNotInSamePackage = isPackagePrivate && - !ElementUtility.isInSamePackage(manager, referencedColumn.element, - referenceColumnDefinition.element) + !ElementUtility.isInSamePackage(manager, referencedColumn.element, + referenceColumnDefinition.element) isReferencedFieldPackagePrivate = isReferencedFieldPackagePrivate || isPackagePrivateNotInSamePackage val packageName = referencedColumn.packageName val name = ClassName.get(referencedColumn.element.enclosingElement as TypeElement).simpleName() diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.kt index 52573b713..3d86271af 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.kt @@ -1,6 +1,6 @@ package com.raizlabs.android.dbflow.config -import com.raizlabs.android.dbflow.StringUtils +import com.raizlabs.android.dbflow.isNotNullOrEmpty import com.raizlabs.android.dbflow.runtime.BaseTransactionManager import com.raizlabs.android.dbflow.runtime.ModelNotifier import com.raizlabs.android.dbflow.structure.database.DatabaseHelperListener @@ -44,7 +44,7 @@ class DatabaseConfig( databaseName = builder.databaseName ?: builder.databaseClass.simpleName, databaseExtensionName = when { builder.databaseExtensionName == null -> ".db" - StringUtils.isNotNullOrEmpty(builder.databaseExtensionName) -> ".${builder.databaseExtensionName}" + builder.databaseExtensionName.isNotNullOrEmpty() -> ".${builder.databaseExtensionName}" else -> "" }) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt index 0f05d08a0..b60c3a180 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt @@ -3,9 +3,9 @@ package com.raizlabs.android.dbflow.config import android.content.Context import com.raizlabs.android.dbflow.annotation.Table import com.raizlabs.android.dbflow.converter.TypeConverter +import com.raizlabs.android.dbflow.quote import com.raizlabs.android.dbflow.runtime.ModelNotifier import com.raizlabs.android.dbflow.runtime.TableNotifierRegister -import com.raizlabs.android.dbflow.sql.QueryBuilder import com.raizlabs.android.dbflow.sql.migration.Migration import com.raizlabs.android.dbflow.structure.BaseModel import com.raizlabs.android.dbflow.structure.BaseModelView @@ -87,7 +87,7 @@ object FlowManager { fun getTableClassForName(databaseName: String, tableName: String): Class<*> { val databaseDefinition = getDatabase(databaseName) return databaseDefinition.getModelClassForName(tableName) - ?: databaseDefinition.getModelClassForName(QueryBuilder.quote(tableName)) + ?: databaseDefinition.getModelClassForName(tableName.quote()) ?: throw IllegalArgumentException("The specified table $tableName was not found." + " Did you forget to add the @Table annotation and point it to $databaseName?") } @@ -101,7 +101,7 @@ object FlowManager { fun getTableClassForName(databaseClass: Class<*>, tableName: String): Class<*> { val databaseDefinition = getDatabase(databaseClass) return databaseDefinition.getModelClassForName(tableName) - ?: databaseDefinition.getModelClassForName(QueryBuilder.quote(tableName)) + ?: databaseDefinition.getModelClassForName(tableName.quote()) ?: throw IllegalArgumentException("The specified table $tableName was not found." + " Did you forget to add the @Table annotation and point it to $databaseClass?") } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/SqlUtils.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/SqlUtils.java index 57c90a32b..4bf3c6d04 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/SqlUtils.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/SqlUtils.java @@ -1,21 +1,18 @@ package com.raizlabs.android.dbflow.sql; import android.content.ContentValues; -import android.database.ContentObserver; import android.net.Uri; import android.support.annotation.NonNull; import android.support.annotation.Nullable; import com.raizlabs.android.dbflow.StringUtils; import com.raizlabs.android.dbflow.config.FlowManager; -import com.raizlabs.android.dbflow.runtime.NotifyDistributor; import com.raizlabs.android.dbflow.sql.language.NameAlias; import com.raizlabs.android.dbflow.sql.language.Operator; import com.raizlabs.android.dbflow.sql.language.OperatorGroup; import com.raizlabs.android.dbflow.sql.language.SQLOperator; import com.raizlabs.android.dbflow.structure.BaseModel.Action; import com.raizlabs.android.dbflow.structure.Model; -import com.raizlabs.android.dbflow.structure.ModelAdapter; import com.raizlabs.android.dbflow.structure.database.DatabaseStatement; import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; @@ -29,40 +26,6 @@ public class SqlUtils { private static final char[] hexArray = "0123456789ABCDEF".toCharArray(); - /** - * Notifies the {@link ContentObserver} that the model has changed. - */ - @Deprecated - public static void notifyModelChanged(Class table, Action action, - Iterable sqlOperators) { - FlowManager.getContext().getContentResolver().notifyChange( - getNotificationUri(table, action, sqlOperators), null, true); - } - - /** - * Performs necessary logic to notify of {@link Model} changes. - * - * @see NotifyDistributor - */ - @SuppressWarnings("unchecked") - @Deprecated - public static void notifyModelChanged(@Nullable TModel model, - @NonNull ModelAdapter modelAdapter, - @NonNull Action action) { - NotifyDistributor.Companion.get().notifyModelChanged(model, modelAdapter, action); - } - - /** - * Notifies listeners of table-level changes from the SQLite-wrapper language. - * - * @see NotifyDistributor - */ - @Deprecated - public static void notifyTableChanged(@NonNull Class table, - @NonNull Action action) { - NotifyDistributor.Companion.get().notifyTableChanged(table, action); - } - /** * Constructs a {@link Uri} from a set of {@link SQLOperator} for specific table. * @@ -75,7 +38,7 @@ public static Uri getNotificationUri(@NonNull Class modelClass, @Nullable Action action, @Nullable Iterable conditions) { Uri.Builder uriBuilder = new Uri.Builder().scheme("dbflow") - .authority(FlowManager.getTableName(modelClass)); + .authority(FlowManager.getTableName(modelClass)); if (action != null) { uriBuilder.fragment(action.name()); } @@ -100,10 +63,8 @@ public static Uri getNotificationUri(@NonNull Class modelClass, @NonNull Action action, @Nullable SQLOperator[] conditions) { Uri.Builder uriBuilder = new Uri.Builder().scheme("dbflow") - .authority(FlowManager.getTableName(modelClass)); - if (action != null) { - uriBuilder.fragment(action.name()); - } + .authority(FlowManager.getTableName(modelClass)); + uriBuilder.fragment(action.name()); if (conditions != null && conditions.length > 0) { for (SQLOperator condition : conditions) { if (condition != null) { @@ -129,7 +90,7 @@ public static Uri getNotificationUri(@NonNull Class modelClass, @NonNull String notifyKey, @Nullable Object notifyValue) { Operator operator = null; - if (StringUtils.INSTANCE.isNotNullOrEmpty(notifyKey)) { + if (StringUtils.isNotNullOrEmpty(notifyKey)) { operator = Operator.Companion.op(new NameAlias.Builder(notifyKey).build()).value(notifyValue); } return getNotificationUri(modelClass, action, new SQLOperator[]{operator}); @@ -152,9 +113,8 @@ public static Uri getNotificationUri(@NonNull Class modelClass, @NonNull Acti * @param triggerName The name of the trigger */ public static void dropTrigger(@NonNull Class mOnTable, @NonNull String triggerName) { - QueryBuilder queryBuilder = new QueryBuilder("DROP TRIGGER IF EXISTS ") - .append(triggerName); - FlowManager.getDatabaseForTable(mOnTable).getWritableDatabase().execSQL(queryBuilder.getQuery()); + FlowManager.getDatabaseForTable(mOnTable).getWritableDatabase() + .execSQL("DROP TRIGGER IF EXISTS " + triggerName); } /** @@ -164,9 +124,7 @@ public static void dropTrigger(@NonNull Class mOnTable, @NonNull String trigg */ public static void dropIndex(@NonNull DatabaseWrapper databaseWrapper, @NonNull String indexName) { - QueryBuilder queryBuilder = new QueryBuilder("DROP INDEX IF EXISTS ") - .append(QueryBuilder.quoteIfNeeded(indexName)); - databaseWrapper.execSQL(queryBuilder.getQuery()); + databaseWrapper.execSQL("DROP INDEX IF EXISTS " + StringUtils.quoteIfNeeded(indexName)); } public static void dropIndex(@NonNull Class onTable, @@ -186,7 +144,7 @@ public static void addContentValues(@NonNull ContentValues contentValues, @NonNu for (Map.Entry entry : entries) { String key = entry.getKey(); operatorGroup.and(Operator.Companion.op(new NameAlias.Builder(key).build()) - .is(contentValues.get(key))); + .is(contentValues.get(key))); } } @@ -197,11 +155,11 @@ public static void addContentValues(@NonNull ContentValues contentValues, @NonNu */ @NonNull public static String getContentValuesKey(ContentValues contentValues, String key) { - String quoted = QueryBuilder.quoteIfNeeded(key); + String quoted = StringUtils.quoteIfNeeded(key); if (contentValues.containsKey(quoted)) { return quoted; } else { - String stripped = QueryBuilder.stripQuotes(key); + String stripped = StringUtils.stripQuotes(key); if (contentValues.containsKey(stripped)) { return stripped; } else { @@ -221,7 +179,7 @@ public static long longForQuery(@NonNull DatabaseWrapper wrapper, } public static double doubleForQuery(@NonNull DatabaseWrapper wrapper, - @NonNull String query) { + @NonNull String query) { DatabaseStatement statement = wrapper.compileStatement(query); try { return statement.simpleQueryForLong(); diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Case.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Case.kt index 7024c7748..072ca4b6a 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Case.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Case.kt @@ -1,7 +1,7 @@ package com.raizlabs.android.dbflow.sql.language +import com.raizlabs.android.dbflow.quoteIfNeeded import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.sql.QueryBuilder import com.raizlabs.android.dbflow.sql.language.property.IProperty import com.raizlabs.android.dbflow.sql.language.property.Property @@ -23,12 +23,12 @@ class Case(private val caseColumn: IProperty<*>? = null) : Query { override val query: String get() { - val queryBuilder = QueryBuilder(" CASE") + val queryBuilder = StringBuilder(" CASE") if (isEfficientCase) { queryBuilder.append(" " + BaseOperator.convertValueToString(caseColumn, false)!!) } - queryBuilder.append(QueryBuilder.join("", caseConditions)) + queryBuilder.append(caseConditions.joinToString(separator = "")) if (elseSpecified) { queryBuilder.append(" ELSE ").append(BaseOperator.convertValueToString(elseValue, false)) @@ -36,7 +36,7 @@ class Case(private val caseColumn: IProperty<*>? = null) : Query { if (endSpecified) { queryBuilder.append(" END " + if (columnName != null) columnName else "") } - return queryBuilder.query + return queryBuilder.toString() } internal constructor() : this(null) @@ -90,10 +90,9 @@ class Case(private val caseColumn: IProperty<*>? = null) : Query { fun end(columnName: String? = null): Property> { endSpecified = true if (columnName != null) { - this.columnName = QueryBuilder.quoteIfNeeded(columnName) + this.columnName = columnName.quoteIfNeeded() } - return Property(null, NameAlias.rawBuilder(query) - .build()) + return Property(null, NameAlias.rawBuilder(query).build()) } /** diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CompletedTrigger.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CompletedTrigger.kt index 28347a2aa..fa18b6617 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CompletedTrigger.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CompletedTrigger.kt @@ -2,7 +2,6 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.sql.QueryBuilder import com.raizlabs.android.dbflow.sql.SqlUtils import java.util.* @@ -21,13 +20,8 @@ class CompletedTrigger internal constructor( private val triggerLogicQuery = ArrayList() override val query: String - get() { - val queryBuilder = QueryBuilder(triggerMethod.query) - queryBuilder.append("\nBEGIN") - .append("\n").append(QueryBuilder.join(";\n", triggerLogicQuery)).append(";") - .append("\nEND") - return queryBuilder.query - } + get() = + "${triggerMethod.query}\nBEGIN\n${triggerLogicQuery.joinToString(separator = ";\n")};\nEND" init { this.triggerLogicQuery.add(triggerLogicQuery) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Delete.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Delete.kt index c74ea081b..10e7bd84b 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Delete.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Delete.kt @@ -1,7 +1,6 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.sql.QueryBuilder /** * Description: Constructs the beginning of a SQL DELETE query @@ -9,9 +8,7 @@ import com.raizlabs.android.dbflow.sql.QueryBuilder class Delete : Query { override val query: String - get() = QueryBuilder() - .append("DELETE") - .appendSpace().query + get() = "DELETE " /** * Returns the new SQL FROM statement wrapper diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/From.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/From.kt index 93eb7585d..42ed7f341 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/From.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/From.kt @@ -2,7 +2,6 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.sql.QueryBuilder import com.raizlabs.android.dbflow.sql.language.Join.JoinType import com.raizlabs.android.dbflow.sql.language.property.IndexProperty import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable @@ -44,7 +43,7 @@ class From override val query: String get() { - val queryBuilder = QueryBuilder() + val queryBuilder = StringBuilder() .append(queryBuilderBase.query) if (queryBuilderBase !is Update<*>) { queryBuilder.append("FROM ") @@ -54,16 +53,14 @@ class From if (queryBuilderBase is Select) { if (!joins.isEmpty()) { - queryBuilder.appendSpace() - } - for (join in joins) { - queryBuilder.append(join.query) + queryBuilder.append(" ") } + joins.forEach { queryBuilder.append(it.query) } } else { - queryBuilder.appendSpace() + queryBuilder.append(" ") } - return queryBuilder.query + return queryBuilder.toString() } /** diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Index.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Index.kt index 543bb9e0d..4f83d025e 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Index.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Index.kt @@ -1,8 +1,9 @@ package com.raizlabs.android.dbflow.sql.language +import com.raizlabs.android.dbflow.appendList +import com.raizlabs.android.dbflow.appendQuotedIfNeeded import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.sql.QueryBuilder import com.raizlabs.android.dbflow.sql.SqlUtils import com.raizlabs.android.dbflow.sql.language.property.IProperty import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper @@ -36,12 +37,14 @@ class Index private set override val query: String - get() = QueryBuilder("CREATE ") - .append(if (isUnique) "UNIQUE " else "") - .append("INDEX IF NOT EXISTS ") - .appendQuotedIfNeeded(indexName) - .append(" ON ").append(FlowManager.getTableName(table!!)) - .append("(").appendList(columns).append(")").query + get() = buildString { + append("CREATE ") + append(if (isUnique) "UNIQUE " else "") + append("INDEX IF NOT EXISTS ") + appendQuotedIfNeeded(indexName) + append(" ON ").append(FlowManager.getTableName(table!!)) + append("(").appendList(columns).append(")") + } /** * If true, will append the UNIQUE statement to this trigger. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IndexedBy.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IndexedBy.kt index ae63ead29..3c2e07a85 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IndexedBy.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IndexedBy.kt @@ -1,7 +1,7 @@ package com.raizlabs.android.dbflow.sql.language +import com.raizlabs.android.dbflow.quoteIfNeeded import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.sql.QueryBuilder import com.raizlabs.android.dbflow.sql.language.property.IndexProperty import com.raizlabs.android.dbflow.structure.BaseModel @@ -22,12 +22,11 @@ class IndexedBy get() = whereBase.queryBuilderBase override val query: String - get() { - val queryBuilder = QueryBuilder(whereBase.query) - .append(" INDEXED BY ") - .append(QueryBuilder.quoteIfNeeded(indexProperty.indexName)) - .appendSpace() - return queryBuilder.query + get() = buildString { + append(whereBase.query) + append(" INDEXED BY ") + append(indexProperty.indexName.quoteIfNeeded()) + append(" ") } override val primaryAction: BaseModel.Action diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Insert.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Insert.kt index 7dc2e7993..7d38e978d 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Insert.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Insert.kt @@ -2,9 +2,9 @@ package com.raizlabs.android.dbflow.sql.language import android.content.ContentValues import com.raizlabs.android.dbflow.annotation.ConflictAction +import com.raizlabs.android.dbflow.appendArray import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.sql.QueryBuilder import com.raizlabs.android.dbflow.sql.language.property.IProperty import com.raizlabs.android.dbflow.structure.BaseModel import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper @@ -42,12 +42,12 @@ class Insert override// append FROM, which overrides values val query: String get() { - val queryBuilder = QueryBuilder("INSERT ") + val queryBuilder = StringBuilder("INSERT ") if (conflictAction != null && conflictAction != ConflictAction.NONE) { - queryBuilder.append("OR").appendSpaceSeparated(conflictAction) + queryBuilder.append("OR").append(" $conflictAction ") } queryBuilder.append("INTO") - .appendSpace() + .append(" ") .append(FlowManager.getTableName(table)) columns?.let { columns -> @@ -56,7 +56,7 @@ class Insert .append(")") } if (selectFrom != null) { - queryBuilder.appendSpace().append(selectFrom!!.query) + queryBuilder.append(" ").append(selectFrom!!.query) } else { if (valuesList.size < 1) { throw IllegalStateException("The insert of " + FlowManager.getTableName(table) + " should have" + @@ -81,7 +81,7 @@ class Insert } } - return queryBuilder.query + return queryBuilder.toString() } override val primaryAction: BaseModel.Action diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Join.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Join.kt index bb6c3c2a2..39792dfcb 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Join.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Join.kt @@ -1,8 +1,8 @@ package com.raizlabs.android.dbflow.sql.language +import com.raizlabs.android.dbflow.appendList import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.sql.QueryBuilder import com.raizlabs.android.dbflow.sql.language.property.IProperty import com.raizlabs.android.dbflow.sql.language.property.PropertyFactory import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable @@ -44,27 +44,27 @@ class Join : Query { override// natural joins do no have on or using clauses. val query: String get() { - val queryBuilder = QueryBuilder() + val queryBuilder = StringBuilder() - queryBuilder.append(type.name.replace("_", " ")).appendSpace() + queryBuilder.append(type.name.replace("_", " ")).append(" ") queryBuilder.append("JOIN") - .appendSpace() - .append(alias!!.fullQuery) - .appendSpace() + .append(" ") + .append(alias.fullQuery) + .append(" ") if (JoinType.NATURAL != type) { onGroup?.let { onGroup -> queryBuilder.append("ON") - .appendSpace() + .append(" ") .append(onGroup.query) - .appendSpace() + .append(" ") } ?: if (!using.isEmpty()) { queryBuilder.append("USING (") .appendList(using) - .append(")").appendSpace() + .append(") ") } } - return queryBuilder.query + return queryBuilder.toString() } /** diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/NameAlias.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/NameAlias.kt index b868da846..bcf5433a3 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/NameAlias.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/NameAlias.kt @@ -1,8 +1,9 @@ package com.raizlabs.android.dbflow.sql.language -import com.raizlabs.android.dbflow.StringUtils +import com.raizlabs.android.dbflow.isNotNullOrEmpty +import com.raizlabs.android.dbflow.quoteIfNeeded import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.sql.QueryBuilder +import com.raizlabs.android.dbflow.stripQuotes /** * Description: Rewritten from the ground up, this class makes it easier to build an alias. @@ -22,8 +23,8 @@ class NameAlias(private val name: String, */ override val query: String get() = when { - StringUtils.isNotNullOrEmpty(aliasName) -> aliasName!! - StringUtils.isNotNullOrEmpty(name) -> fullName() + aliasName.isNotNullOrEmpty() -> aliasName!! + name.isNotNullOrEmpty() -> fullName() else -> "" } @@ -32,7 +33,7 @@ class NameAlias(private val name: String, * or the [.nameRaw], depending on what's specified. */ val nameAsKey: String? - get() = if (StringUtils.isNotNullOrEmpty(aliasName)) { + get() = if (aliasName.isNotNullOrEmpty()) { aliasNameRaw() } else { nameRaw() @@ -44,10 +45,10 @@ class NameAlias(private val name: String, val fullQuery: String get() { var query = fullName() - if (StringUtils.isNotNullOrEmpty(aliasName)) { + if (aliasName.isNotNullOrEmpty()) { query += " AS ${aliasName()}" } - if (StringUtils.isNotNullOrEmpty(keyword)) { + if (keyword.isNotNullOrEmpty()) { query = "$keyword $query" } return query @@ -55,18 +56,18 @@ class NameAlias(private val name: String, private constructor(builder: Builder) : this( name = if (builder.shouldStripIdentifier) { - QueryBuilder.stripQuotes(builder.name) + builder.name.stripQuotes() ?: "" } else { builder.name }, keyword = builder.keyword, aliasName = if (builder.shouldStripAliasName) { - QueryBuilder.stripQuotes(builder.aliasName) + builder.aliasName.stripQuotes() } else { builder.aliasName }, - tableName = if (StringUtils.isNotNullOrEmpty(builder.tableName)) { - QueryBuilder.quoteIfNeeded(builder.tableName) + tableName = if (builder.tableName.isNotNullOrEmpty()) { + builder.tableName.quoteIfNeeded() } else { null }, @@ -79,22 +80,22 @@ class NameAlias(private val name: String, * @return The real column name. */ fun name(): String? { - return if (StringUtils.isNotNullOrEmpty(name) && shouldAddIdentifierToQuery) - QueryBuilder.quoteIfNeeded(name) + return if (name.isNotNullOrEmpty() && shouldAddIdentifierToQuery) + name.quoteIfNeeded() else name } /** * @return The name, stripped from identifier syntax completely. */ - fun nameRaw(): String = if (shouldStripIdentifier) name else QueryBuilder.stripQuotes(name) + fun nameRaw(): String = if (shouldStripIdentifier) name else name.stripQuotes() ?: "" /** * @return The name used as part of the AS query. */ fun aliasName(): String? { - return if (StringUtils.isNotNullOrEmpty(aliasName) && shouldAddIdentifierToAliasName) - QueryBuilder.quoteIfNeeded(aliasName) + return if (aliasName.isNotNullOrEmpty() && shouldAddIdentifierToAliasName) + aliasName.quoteIfNeeded() else aliasName } @@ -102,13 +103,13 @@ class NameAlias(private val name: String, * @return The alias name, stripped from identifier syntax completely. */ fun aliasNameRaw(): String? = - if (shouldStripAliasName) aliasName else QueryBuilder.stripQuotes(aliasName) + if (shouldStripAliasName) aliasName else aliasName.stripQuotes() /** * @return The `{tableName}`.`{name}`. If [.tableName] specified. */ fun fullName(): String = - (if (StringUtils.isNotNullOrEmpty(tableName)) "$tableName." else "") + name() + (if (tableName.isNotNullOrEmpty()) "$tableName." else "") + name() override fun toString(): String = fullQuery diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Operator.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Operator.kt index 6f9c74eb5..0b3734d69 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Operator.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Operator.kt @@ -8,7 +8,6 @@ import com.raizlabs.android.dbflow.config.FlowLog import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.converter.TypeConverter import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.sql.QueryBuilder import com.raizlabs.android.dbflow.sql.language.property.Property import java.util.* @@ -325,7 +324,7 @@ class Operator : BaseOperator, IOperator { override fun concatenate(value: Any?): Operator { var _value = value - operation = QueryBuilder(Operation.EQUALS).append(columnName()).toString() + operation = "${Operation.EQUALS} ${columnName()}" var typeConverter: TypeConverter<*, Any>? = this.typeConverter as TypeConverter<*, Any>? if (typeConverter == null && _value != null) { diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/SQLOperator.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/SQLOperator.kt index 46dfbd77e..2520bd20b 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/SQLOperator.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/SQLOperator.kt @@ -1,14 +1,12 @@ package com.raizlabs.android.dbflow.sql.language -import com.raizlabs.android.dbflow.sql.QueryBuilder - /** * Description: Basic interface for all of the Operator classes. */ interface SQLOperator { /** - * Appends itself to the [QueryBuilder] + * Appends itself to the [StringBuilder] * * @param queryBuilder The builder to append to. */ diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Select.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Select.kt index 672c4f30a..cfd6ad1ba 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Select.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Select.kt @@ -1,7 +1,6 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.sql.QueryBuilder import com.raizlabs.android.dbflow.sql.language.property.IProperty import com.raizlabs.android.dbflow.sql.language.property.Property import java.util.* @@ -25,7 +24,7 @@ class Select override val query: String get() { - val queryBuilder = QueryBuilder("SELECT ") + val queryBuilder = StringBuilder("SELECT ") if (selectQualifier != NONE) { if (selectQualifier == DISTINCT) { @@ -33,12 +32,12 @@ class Select } else if (selectQualifier == ALL) { queryBuilder.append("ALL") } - queryBuilder.appendSpace() + queryBuilder.append(" ") } - queryBuilder.append(QueryBuilder.join(",", propertyList)) - queryBuilder.appendSpace() - return queryBuilder.query + queryBuilder.append(propertyList.joinToString(separator = ",")) + queryBuilder.append(" ") + return queryBuilder.toString() } init { diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Set.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Set.kt index f2147d4c5..bf5c53b5d 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Set.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Set.kt @@ -1,9 +1,7 @@ package com.raizlabs.android.dbflow.sql.language import android.content.ContentValues - import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.sql.QueryBuilder import com.raizlabs.android.dbflow.sql.SqlUtils import com.raizlabs.android.dbflow.structure.BaseModel @@ -16,12 +14,7 @@ class Set(override val queryBuilderBase: Query, table: Class) private val operatorGroup: OperatorGroup = OperatorGroup.nonGroupingClause().setAllCommaSeparated(true) override val query: String - get() { - val queryBuilder = QueryBuilder(queryBuilderBase.query) - .append("SET ") - .append(operatorGroup.query).appendSpace() - return queryBuilder.query - } + get() = " ${queryBuilderBase.query}SET ${operatorGroup.query} " override val primaryAction: BaseModel.Action get() = BaseModel.Action.UPDATE diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Trigger.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Trigger.kt index 86ed12fe9..2694d9d75 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Trigger.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Trigger.kt @@ -1,7 +1,8 @@ package com.raizlabs.android.dbflow.sql.language +import com.raizlabs.android.dbflow.appendOptional +import com.raizlabs.android.dbflow.appendQuotedIfNeeded import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.sql.QueryBuilder import com.raizlabs.android.dbflow.sql.language.property.IProperty import kotlin.reflect.KClass @@ -33,15 +34,15 @@ private constructor( override val query: String get() { - val queryBuilder = QueryBuilder("CREATE ") + val queryBuilder = StringBuilder("CREATE ") if (temporary) { queryBuilder.append("TEMP ") } queryBuilder.append("TRIGGER IF NOT EXISTS ") - .appendQuotedIfNeeded(name).appendSpace() + .appendQuotedIfNeeded(name).append(" ") .appendOptional(beforeOrAfter + " ") - return queryBuilder.query + return queryBuilder.toString() } /** diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/UnSafeStringOperator.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/UnSafeStringOperator.kt index 2ece33f96..c10e14f29 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/UnSafeStringOperator.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/UnSafeStringOperator.kt @@ -1,6 +1,6 @@ package com.raizlabs.android.dbflow.sql.language -import com.raizlabs.android.dbflow.StringUtils +import com.raizlabs.android.dbflow.isNotNullOrEmpty import com.raizlabs.android.dbflow.sql.Query /** @@ -38,7 +38,7 @@ class UnSafeStringOperator(selection: String, selectionArgs: Array) : SQ this.separator = separator } - override fun hasSeparator(): Boolean = StringUtils.isNotNullOrEmpty(separator) + override fun hasSeparator(): Boolean = separator.isNotNullOrEmpty() override fun operation(): String = "" diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Update.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Update.kt index cbd5a812f..8e27f6346 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Update.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Update.kt @@ -3,7 +3,6 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.annotation.ConflictAction import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.sql.QueryBuilder /** * Description: The SQLite UPDATE query. Will update rows in the DB. @@ -23,14 +22,14 @@ internal constructor(val table: Class) : Query { override val query: String get() { - val queryBuilder = QueryBuilder("UPDATE ") + val queryBuilder = StringBuilder("UPDATE ") conflictAction?.let { conflictAction -> if (conflictAction != ConflictAction.NONE) { - queryBuilder.append("OR").appendSpaceSeparated(conflictAction.name) + queryBuilder.append("OR").append(" ${conflictAction.name} ") } } - queryBuilder.append(FlowManager.getTableName(table)).appendSpace() - return queryBuilder.query + queryBuilder.append(FlowManager.getTableName(table)).append(" ") + return queryBuilder.toString() } fun conflictAction(conflictAction: ConflictAction) = apply { diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Where.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Where.kt index 4da3a24ba..a3db99133 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Where.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Where.kt @@ -2,8 +2,8 @@ package com.raizlabs.android.dbflow.sql.language import android.database.Cursor import com.raizlabs.android.dbflow.annotation.provider.ContentProvider +import com.raizlabs.android.dbflow.appendQualifier import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.sql.QueryBuilder import com.raizlabs.android.dbflow.sql.language.property.IProperty import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable import com.raizlabs.android.dbflow.structure.BaseModel @@ -51,11 +51,11 @@ class Where override val query: String get() { val fromQuery = whereBase.query.trim { it <= ' ' } - val queryBuilder = QueryBuilder().append(fromQuery).appendSpace() + val queryBuilder = StringBuilder(fromQuery).append(" ") .appendQualifier("WHERE", operatorGroup.query) - .appendQualifier("GROUP BY", QueryBuilder.join(",", groupByList)) + .appendQualifier("GROUP BY", groupByList.joinToString(separator = ",")) .appendQualifier("HAVING", havingGroup.query) - .appendQualifier("ORDER BY", QueryBuilder.join(",", orderByList)) + .appendQualifier("ORDER BY", orderByList.joinToString(separator = ",")) if (limit > VALUE_UNSET) { queryBuilder.appendQualifier("LIMIT", limit.toString()) @@ -64,7 +64,7 @@ class Where queryBuilder.appendQualifier("OFFSET", offset.toString()) } - return queryBuilder.query + return queryBuilder.toString() } init { diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/IndexProperty.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/IndexProperty.kt index 4308e0f7e..b48ddd12a 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/IndexProperty.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/IndexProperty.kt @@ -1,7 +1,7 @@ package com.raizlabs.android.dbflow.sql.language.property import com.raizlabs.android.dbflow.annotation.Table -import com.raizlabs.android.dbflow.sql.QueryBuilder +import com.raizlabs.android.dbflow.quoteIfNeeded import com.raizlabs.android.dbflow.sql.language.Index import com.raizlabs.android.dbflow.sql.language.SQLite import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper @@ -17,11 +17,10 @@ class IndexProperty(indexName: String, unique: Boolean, table: Class, val index: Index = SQLite.index(indexName) val indexName: String - get() = QueryBuilder.quoteIfNeeded(index.indexName) + get() = index.indexName.quoteIfNeeded() ?: "" init { - index.on(table, *properties) - .unique(unique) + index.on(table, *properties).unique(unique) } fun createIfNotExists(wrapper: DatabaseWrapper) { From fd7632231e854f0f88b9fbd22805d9f39a99ec04 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Thu, 23 Nov 2017 16:26:44 -0500 Subject: [PATCH 062/234] [5.0] remove kotlin extensions. --- dbflow-kotlinextensions/.gitignore | 1 - dbflow-kotlinextensions/build.gradle | 36 ------------------- dbflow-kotlinextensions/gradle.properties | 3 -- dbflow-kotlinextensions/proguard-rules.pro | 17 --------- .../src/main/AndroidManifest.xml | 5 --- dbflow-tests/build.gradle | 3 +- settings.gradle | 1 - 7 files changed, 1 insertion(+), 65 deletions(-) delete mode 100644 dbflow-kotlinextensions/.gitignore delete mode 100644 dbflow-kotlinextensions/build.gradle delete mode 100644 dbflow-kotlinextensions/gradle.properties delete mode 100644 dbflow-kotlinextensions/proguard-rules.pro delete mode 100644 dbflow-kotlinextensions/src/main/AndroidManifest.xml diff --git a/dbflow-kotlinextensions/.gitignore b/dbflow-kotlinextensions/.gitignore deleted file mode 100644 index 796b96d1c..000000000 --- a/dbflow-kotlinextensions/.gitignore +++ /dev/null @@ -1 +0,0 @@ -/build diff --git a/dbflow-kotlinextensions/build.gradle b/dbflow-kotlinextensions/build.gradle deleted file mode 100644 index 4de4f19a1..000000000 --- a/dbflow-kotlinextensions/build.gradle +++ /dev/null @@ -1,36 +0,0 @@ -apply plugin: 'com.android.library' -apply plugin: 'kotlin-android' - -project.ext.artifactId = bt_name - - -android { - compileSdkVersion Integer.valueOf(dbflow_target_sdk) - buildToolsVersion dbflow_build_tools_version - - defaultConfig { - minSdkVersion dbflow_min_sdk - targetSdkVersion Integer.valueOf(dbflow_target_sdk) - } - buildTypes { - debug { - minifyEnabled false - } - release { - minifyEnabled false - } - } - sourceSets { - main.java.srcDirs += 'src/main/kotlin' - } -} - -dependencies { - api "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version" - api project("${dbflow_project_prefix}dbflow-core") - api project("${dbflow_project_prefix}dbflow") -} - -apply from: '../kotlin-artifacts.gradle' - - diff --git a/dbflow-kotlinextensions/gradle.properties b/dbflow-kotlinextensions/gradle.properties deleted file mode 100644 index bca645ff5..000000000 --- a/dbflow-kotlinextensions/gradle.properties +++ /dev/null @@ -1,3 +0,0 @@ -bt_name=dbflow-kotlinextensions -bt_packaging=aar -bt_artifact_id=dbflow-kotlinextensions \ No newline at end of file diff --git a/dbflow-kotlinextensions/proguard-rules.pro b/dbflow-kotlinextensions/proguard-rules.pro deleted file mode 100644 index d31a3fb13..000000000 --- a/dbflow-kotlinextensions/proguard-rules.pro +++ /dev/null @@ -1,17 +0,0 @@ -# Add project specific ProGuard rules here. -# By default, the flags in this file are appended to flags specified -# in /Users/andrewgrosner/Documents/sdk/tools/proguard/proguard-android.txt -# You can edit the include path and order by changing the proguardFiles -# directive in build.gradle. -# -# For more details, see -# http://developer.android.com/guide/developing/tools/proguard.html - -# Add any project specific keep options here: - -# If your project uses WebView with JS, uncomment the following -# and specify the fully qualified class name to the JavaScript interface -# class: -#-keepclassmembers class fqcn.of.javascript.interface.for.webview { -# public *; -#} diff --git a/dbflow-kotlinextensions/src/main/AndroidManifest.xml b/dbflow-kotlinextensions/src/main/AndroidManifest.xml deleted file mode 100644 index e1050c1a7..000000000 --- a/dbflow-kotlinextensions/src/main/AndroidManifest.xml +++ /dev/null @@ -1,5 +0,0 @@ - - - - - diff --git a/dbflow-tests/build.gradle b/dbflow-tests/build.gradle index d1ec2f4d7..3a9e11ae8 100644 --- a/dbflow-tests/build.gradle +++ b/dbflow-tests/build.gradle @@ -47,10 +47,9 @@ dependencies { kapt project("${dbflow_project_prefix}dbflow-processor") implementation project(':dbflow') - implementation 'com.android.support:appcompat-v7:26.0.1' + implementation 'com.android.support:appcompat-v7:26.1.0' implementation project("${dbflow_project_prefix}dbflow") implementation project("${dbflow_project_prefix}dbflow-sqlcipher") - implementation project("${dbflow_project_prefix}dbflow-kotlinextensions") implementation project("${dbflow_project_prefix}dbflow-rx") implementation project("${dbflow_project_prefix}dbflow-rx-kotlinextensions") implementation project("${dbflow_project_prefix}dbflow-rx2") diff --git a/settings.gradle b/settings.gradle index 09f1e2058..2c7fb4fd5 100644 --- a/settings.gradle +++ b/settings.gradle @@ -2,7 +2,6 @@ include ':dbflow', ':dbflow-rx-kotlinextensions', ':dbflow-rx2', ':dbflow-rx2-ko ':dbflow-processor', ':dbflow-core', ':dbflow-sqlcipher', - ':dbflow-kotlinextensions', ':dbflow-rx', ':dbflow-tests' From f18aea1bf1d662811e0936984cf37afd441d8359 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Thu, 23 Nov 2017 17:35:00 -0500 Subject: [PATCH 063/234] [5.0] sqlutils moved to kotlin package funcs and java support. --- .../contentobserver/ContentObserverTest.kt | 4 +- .../dbflow/prepackaged/PrepackagedDBTest.kt | 1 - .../android/dbflow/sqlcipher/CipherTest.kt | 1 - .../dbflow/ImmediateTransactionManager.kt | 6 +- .../contentprovider/ContentProviderTests.kt | 1 - .../contentprovider/TestContentProvider.kt | 6 +- .../FastStoreModelTransactionTest.kt | 1 - .../dbflow/list/FlowCursorIteratorTest.kt | 1 - .../android/dbflow/list/FlowCursorListTest.kt | 1 - .../android/dbflow/list/FlowQueryListTest.kt | 1 - .../dbflow/models/CachingModelsTest.kt | 1 - .../dbflow/models/DontCreateModelTest.kt | 1 - .../android/dbflow/models/ForeignKeyModels.kt | 8 +- .../android/dbflow/models/IndexModels.kt | 4 +- .../android/dbflow/models/ModelViewTest.kt | 2 +- .../android/dbflow/models/ModelViews.kt | 1 - .../dbflow/models/OneToManyModelTest.kt | 1 - .../android/dbflow/models/OneToManyModels.kt | 1 - .../dbflow/models/ParentChildCachingTest.kt | 1 - .../android/dbflow/models/QueryModelTest.kt | 1 - .../android/dbflow/models/issue/Issue.java | 6 +- .../rx/language/CursorResultSubscriberTest.kt | 1 - .../dbflow/rx/language/RXQueryTests.kt | 1 - .../android/dbflow/sql/language/CaseTest.kt | 18 +- .../dbflow/sql/language/CursorResultTest.kt | 4 +- .../android/dbflow/sql/language/FromTest.kt | 8 +- .../dbflow/sql/language/IndexedByTest.kt | 2 +- .../android/dbflow/sql/language/InsertTest.kt | 22 +- .../android/dbflow/sql/language/JoinTest.kt | 32 +-- .../sql/language/UnsafeStringOperatorTest.kt | 2 +- .../sql/language/property/BytePropertyTest.kt | 10 +- .../sql/language/property/CharPropertyTest.kt | 10 +- .../language/property/DoublePropertyTest.kt | 10 +- .../language/property/FloatPropertyTest.kt | 10 +- .../language/property/IndexPropertyTest.kt | 2 +- .../sql/language/property/IntPropertyTest.kt | 10 +- .../sql/language/property/LongPropertyTest.kt | 10 +- .../language/property/PropertyFactoryTest.kt | 3 +- .../sql/language/property/PropertyTest.kt | 10 +- .../language/property/ShortPropertyTest.kt | 10 +- .../dbflow/sql/queriable/AsyncQueryTest.kt | 1 - .../dbflow/runtime/ContentResolverNotifier.kt | 6 +- .../dbflow/runtime/FlowContentObserver.java | 4 +- .../raizlabs/android/dbflow/sql/SqlUtils.java | 205 ------------------ .../raizlabs/android/dbflow/sql/SqlUtils.kt | 193 +++++++++++++++++ .../dbflow/sql/language/BaseOperator.kt | 4 +- .../dbflow/sql/language/BaseQueriable.kt | 4 +- .../dbflow/sql/language/BaseTransformable.kt | 5 + .../android/dbflow/sql/language/Case.kt | 17 +- .../dbflow/sql/language/CaseCondition.kt | 4 +- .../dbflow/sql/language/CompletedTrigger.kt | 4 +- .../android/dbflow/sql/language/Delete.kt | 5 +- .../android/dbflow/sql/language/From.kt | 3 +- .../android/dbflow/sql/language/Index.kt | 12 +- .../android/dbflow/sql/language/Insert.kt | 4 +- .../dbflow/sql/language/QueryExtensions.kt | 55 ----- .../android/dbflow/sql/language/SQLite.kt | 6 +- .../android/dbflow/sql/language/Select.kt | 11 +- .../android/dbflow/sql/language/Set.kt | 4 +- .../android/dbflow/sql/language/Where.kt | 4 +- 60 files changed, 357 insertions(+), 419 deletions(-) delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/SqlUtils.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/SqlUtils.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/QueryExtensions.kt diff --git a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/contentobserver/ContentObserverTest.kt b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/contentobserver/ContentObserverTest.kt index 18ad24eda..09c28d61d 100644 --- a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/contentobserver/ContentObserverTest.kt +++ b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/contentobserver/ContentObserverTest.kt @@ -7,7 +7,7 @@ import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.contentobserver.User_Table.id import com.raizlabs.android.dbflow.contentobserver.User_Table.name import com.raizlabs.android.dbflow.runtime.FlowContentObserver -import com.raizlabs.android.dbflow.sql.SqlUtils +import com.raizlabs.android.dbflow.sql.getNotificationUri import com.raizlabs.android.dbflow.sql.language.Delete import com.raizlabs.android.dbflow.sql.language.SQLOperator import com.raizlabs.android.dbflow.structure.BaseModel @@ -35,7 +35,7 @@ class ContentObserverTest : BaseInstrumentedUnitTest() { fun testSpecificUris() { val conditionGroup = FlowManager.getModelAdapter(User::class.java) .getPrimaryConditionClause(user) - val uri = SqlUtils.getNotificationUri(User::class.java, BaseModel.Action.DELETE, + val uri = getNotificationUri(User::class.java, BaseModel.Action.DELETE, conditionGroup.conditions.toTypedArray()) assertEquals(uri.authority, FlowManager.getTableName(User::class.java)) diff --git a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/prepackaged/PrepackagedDBTest.kt b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/prepackaged/PrepackagedDBTest.kt index cf9d362b4..ca368af96 100644 --- a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/prepackaged/PrepackagedDBTest.kt +++ b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/prepackaged/PrepackagedDBTest.kt @@ -1,7 +1,6 @@ package com.raizlabs.android.dbflow.prepackaged import com.raizlabs.android.dbflow.BaseInstrumentedUnitTest -import com.raizlabs.android.dbflow.sql.language.from import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.sql.queriable.list import org.junit.Assert.assertTrue diff --git a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/sqlcipher/CipherTest.kt b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/sqlcipher/CipherTest.kt index 4fd129a52..e95b7fe0e 100644 --- a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/sqlcipher/CipherTest.kt +++ b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/sqlcipher/CipherTest.kt @@ -2,7 +2,6 @@ package com.raizlabs.android.dbflow.sqlcipher import com.raizlabs.android.dbflow.BaseInstrumentedUnitTest import com.raizlabs.android.dbflow.sql.language.Delete -import com.raizlabs.android.dbflow.sql.language.from import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.sql.language.where import com.raizlabs.android.dbflow.sql.queriable.result diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/ImmediateTransactionManager.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/ImmediateTransactionManager.kt index ed8245ef7..5d815a65f 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/ImmediateTransactionManager.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/ImmediateTransactionManager.kt @@ -16,9 +16,9 @@ class ImmediateTransactionQueue2 : ITransactionQueue { override fun add(transaction: Transaction) { transaction.newBuilder() - .runCallbacksOnSameThread(true) - .build() - .executeSync() + .runCallbacksOnSameThread(true) + .build() + .executeSync() } override fun cancel(transaction: Transaction) { diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/contentprovider/ContentProviderTests.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/contentprovider/ContentProviderTests.kt index ae1ad4b50..3c39d8cd3 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/contentprovider/ContentProviderTests.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/contentprovider/ContentProviderTests.kt @@ -4,7 +4,6 @@ import android.content.ContentResolver import android.content.pm.ProviderInfo import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.sql.language.Delete -import com.raizlabs.android.dbflow.sql.language.from import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.sql.language.where import com.raizlabs.android.dbflow.sql.queriable.result diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/contentprovider/TestContentProvider.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/contentprovider/TestContentProvider.kt index f1ade3003..2e5441280 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/contentprovider/TestContentProvider.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/contentprovider/TestContentProvider.kt @@ -10,7 +10,7 @@ import com.raizlabs.android.dbflow.annotation.provider.Notify import com.raizlabs.android.dbflow.annotation.provider.NotifyMethod import com.raizlabs.android.dbflow.annotation.provider.PathSegment import com.raizlabs.android.dbflow.annotation.provider.TableEndpoint -import com.raizlabs.android.dbflow.sql.SqlUtils +import com.raizlabs.android.dbflow.sql.getContentValuesKey @ContentProvider(authority = TestContentProvider.AUTHORITY, database = ContentDatabase::class, baseContentUri = TestContentProvider.BASE_CONTENT_URI) @@ -90,14 +90,14 @@ object TestContentProvider { @JvmStatic @Notify(notifyMethod = NotifyMethod.INSERT, paths = arrayOf(ENDPOINT)) fun onInsert(contentValues: ContentValues): Array { - val listId = contentValues.getAsLong(SqlUtils.getContentValuesKey(contentValues, "providerModel"))!! + val listId = contentValues.getAsLong(getContentValuesKey(contentValues, "providerModel"))!! return arrayOf(ContentProviderModel.withId(listId), fromList(listId)) } @JvmStatic @Notify(notifyMethod = NotifyMethod.INSERT, paths = arrayOf(ENDPOINT)) fun onInsert2(contentValues: ContentValues): Uri { - val listId = contentValues.getAsLong(SqlUtils.getContentValuesKey(contentValues, "providerModel"))!! + val listId = contentValues.getAsLong(getContentValuesKey(contentValues, "providerModel"))!! return fromList(listId) } diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/FastStoreModelTransactionTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/FastStoreModelTransactionTest.kt index 7419d563d..ce4a631a1 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/FastStoreModelTransactionTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/FastStoreModelTransactionTest.kt @@ -5,7 +5,6 @@ import com.raizlabs.android.dbflow.TestDatabase import com.raizlabs.android.dbflow.config.database import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.TwoColumnModel -import com.raizlabs.android.dbflow.sql.language.from import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.sql.queriable.list import com.raizlabs.android.dbflow.structure.database.transaction.fastInsert diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorIteratorTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorIteratorTest.kt index e50b5c19d..be0a93d09 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorIteratorTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorIteratorTest.kt @@ -2,7 +2,6 @@ package com.raizlabs.android.dbflow.list import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.sql.language.from import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.structure.save import org.junit.Assert.assertEquals diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorListTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorListTest.kt index 34f017f26..c696192e0 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorListTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorListTest.kt @@ -5,7 +5,6 @@ import com.nhaarman.mockito_kotlin.times import com.nhaarman.mockito_kotlin.verify import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.sql.language.from import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.sql.queriable.cursor import com.raizlabs.android.dbflow.structure.save diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowQueryListTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowQueryListTest.kt index 34a464703..445a81439 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowQueryListTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowQueryListTest.kt @@ -2,7 +2,6 @@ package com.raizlabs.android.dbflow.list import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.sql.language.from import com.raizlabs.android.dbflow.sql.language.select import org.junit.Assert.assertTrue import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/CachingModelsTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/CachingModelsTest.kt index 65c452add..fe396eb08 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/CachingModelsTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/CachingModelsTest.kt @@ -1,7 +1,6 @@ package com.raizlabs.android.dbflow.models import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.sql.language.from import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.sql.queriable.list import com.raizlabs.android.dbflow.sql.queriable.result diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/DontCreateModelTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/DontCreateModelTest.kt index ea7e56fb3..d645f619e 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/DontCreateModelTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/DontCreateModelTest.kt @@ -3,7 +3,6 @@ package com.raizlabs.android.dbflow.models import android.database.sqlite.SQLiteException import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.assertThrowsException -import com.raizlabs.android.dbflow.sql.language.from import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.sql.queriable.list import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ForeignKeyModels.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ForeignKeyModels.kt index 781a98df7..7e1c84237 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ForeignKeyModels.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ForeignKeyModels.kt @@ -50,7 +50,7 @@ class BlogRef(@PrimaryKey(autoincrement = true) var id: Int = 0, @Column var nam @Table(database = TestDatabase::class) class BlogRefNoModel(@PrimaryKey(autoincrement = true) var id: Int = 0, @Column var name: String = "", @ForeignKey(references = arrayOf(ForeignKeyReference(columnName = "authorId", foreignKeyColumnName = "id", notNull = NotNull(onNullConflict = ConflictAction.FAIL))), - tableClass = Author::class) + tableClass = Author::class) var authorId: String? = null) @@ -67,7 +67,7 @@ class BlogPrimary(@PrimaryKey @ForeignKey var author: Author? = null, @Column va @Table(database = TestDatabase::class) class BlogStubbed(@PrimaryKey(autoincrement = true) var id: Int = 0, @Column var name: String = "", @ForeignKey(stubbedRelationship = true, deleteForeignKeyModel = true, saveForeignKeyModel = true, - onDelete = ForeignKeyAction.CASCADE, onUpdate = ForeignKeyAction.RESTRICT) + onDelete = ForeignKeyAction.CASCADE, onUpdate = ForeignKeyAction.RESTRICT) var author: Author? = null) : LoadFromCursorListener { override fun onLoadFromCursor(cursor: Cursor) { @@ -82,6 +82,6 @@ class Position(@PrimaryKey var id: Int = 0, @ColumnMap var location: Location? = @Table(database = TestDatabase::class) class Position2(@PrimaryKey var id: Int = 0, @ColumnMap(references = arrayOf( - ColumnMapReference(columnName = "latitude", columnMapFieldName = "latitude"), - ColumnMapReference(columnName = "longitude", columnMapFieldName = "longitude"))) + ColumnMapReference(columnName = "latitude", columnMapFieldName = "latitude"), + ColumnMapReference(columnName = "longitude", columnMapFieldName = "longitude"))) var location: Location? = null) diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/IndexModels.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/IndexModels.kt index ca6206d24..d1938222b 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/IndexModels.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/IndexModels.kt @@ -13,8 +13,8 @@ import java.util.* */ @Table(database = TestDatabase::class, indexGroups = arrayOf(IndexGroup(number = 1, name = "firstIndex"), - IndexGroup(number = 2, name = "secondIndex"), - IndexGroup(number = 3, name = "thirdIndex"))) + IndexGroup(number = 2, name = "secondIndex"), + IndexGroup(number = 3, name = "thirdIndex"))) class IndexModel { @Index(indexGroups = intArrayOf(1, 2, 3)) @PrimaryKey diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ModelViewTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ModelViewTest.kt index a1f58630b..cf56447cb 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ModelViewTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ModelViewTest.kt @@ -10,7 +10,7 @@ class ModelViewTest : BaseUnitTest() { @Test fun validateModelViewQuery() { assertEquals("SELECT `id` AS `authorId`,`first_name` || ' ' || `last_name` AS `authorName` FROM `Author`", - AuthorView.query) + AuthorView.query) } @Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ModelViews.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ModelViews.kt index 1835486ab..c36ce2a1a 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ModelViews.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ModelViews.kt @@ -7,7 +7,6 @@ import com.raizlabs.android.dbflow.annotation.ModelView import com.raizlabs.android.dbflow.annotation.ModelViewQuery import com.raizlabs.android.dbflow.models.Author_Table.* import com.raizlabs.android.dbflow.sql.language.SQLite.select -import com.raizlabs.android.dbflow.sql.language.from import com.raizlabs.android.dbflow.sql.language.property.IProperty import com.raizlabs.android.dbflow.sql.language.property.property diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModelTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModelTest.kt index 844f17ecd..4744520b3 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModelTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModelTest.kt @@ -1,7 +1,6 @@ package com.raizlabs.android.dbflow.models import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.sql.language.from import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.sql.queriable.list import com.raizlabs.android.dbflow.sql.queriable.result diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModels.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModels.kt index 3b10ff0c4..6d473a559 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModels.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModels.kt @@ -6,7 +6,6 @@ import com.raizlabs.android.dbflow.annotation.OneToManyMethod import com.raizlabs.android.dbflow.annotation.PrimaryKey import com.raizlabs.android.dbflow.annotation.Table import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id -import com.raizlabs.android.dbflow.sql.language.from import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.sql.language.where import com.raizlabs.android.dbflow.structure.BaseModel diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ParentChildCachingTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ParentChildCachingTest.kt index 589617731..91a9ac558 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ParentChildCachingTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ParentChildCachingTest.kt @@ -1,7 +1,6 @@ package com.raizlabs.android.dbflow.models import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.sql.language.from import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.sql.queriable.result import org.junit.Assert.assertEquals diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/QueryModelTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/QueryModelTest.kt index 2d8be3e7a..4182cb3f0 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/QueryModelTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/QueryModelTest.kt @@ -6,7 +6,6 @@ import com.raizlabs.android.dbflow.models.Blog_Table.author_id import com.raizlabs.android.dbflow.models.Blog_Table.name import com.raizlabs.android.dbflow.sql.language.SQLite.select import com.raizlabs.android.dbflow.sql.language.eq -import com.raizlabs.android.dbflow.sql.language.from import com.raizlabs.android.dbflow.sql.language.innerJoin import com.raizlabs.android.dbflow.sql.language.on import com.raizlabs.android.dbflow.structure.exists diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/Issue.java b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/Issue.java index 837bd2908..9e96f77c0 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/Issue.java +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/Issue.java @@ -26,9 +26,9 @@ public class Issue extends BaseModel { public List getDbSubIssueList() { if (subIssueList == null || subIssueList.isEmpty()) { subIssueList = SQLite.INSTANCE.select() - .from(SubIssue.class) - .where(SubIssue_Table.owningIssueId.eq(id)) - .queryList(); + .from(SubIssue.class) + .where(SubIssue_Table.owningIssueId.eq(id)) + .queryList(); } return subIssueList; } diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriberTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriberTest.kt index 12df4fd03..e1947bd24 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriberTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriberTest.kt @@ -3,7 +3,6 @@ package com.raizlabs.android.dbflow.rx.language import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.rx.kotlinextensions.rx -import com.raizlabs.android.dbflow.sql.language.from import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.structure.save import org.junit.Assert.assertEquals diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/RXQueryTests.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/RXQueryTests.kt index 53ca2cc8c..35307cb3b 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/RXQueryTests.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/RXQueryTests.kt @@ -7,7 +7,6 @@ import com.raizlabs.android.dbflow.models.SimpleModel_Table.name import com.raizlabs.android.dbflow.rx.kotlinextensions.rx import com.raizlabs.android.dbflow.rx.kotlinextensions.rxBaseQueriable import com.raizlabs.android.dbflow.sql.language.SQLite.selectCountOf -import com.raizlabs.android.dbflow.sql.language.from import com.raizlabs.android.dbflow.sql.language.insert import com.raizlabs.android.dbflow.sql.language.property.Property import com.raizlabs.android.dbflow.sql.language.select diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CaseTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CaseTest.kt index eb09e2a10..2ce9041c7 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CaseTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CaseTest.kt @@ -3,9 +3,7 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.models.SimpleModel_Table import com.raizlabs.android.dbflow.sql.language.property.propertyString -import org.junit.Assert.assertEquals -import org.junit.Assert.assertFalse -import org.junit.Assert.assertTrue +import org.junit.Assert.* import org.junit.Test class CaseTest : BaseUnitTest() { @@ -13,21 +11,21 @@ class CaseTest : BaseUnitTest() { @Test fun simpleCaseTest() { val case = case(propertyString("country")) - .`when`("USA") - .then("Domestic") - .`else`("Foreign") + .whenever("USA") + .then("Domestic") + .`else`("Foreign") assertEquals("CASE country WHEN 'USA' THEN 'Domestic' ELSE 'Foreign' END `Country`", - case.end("Country").query.trim()) + case.end("Country").query.trim()) assertTrue(case.isEfficientCase) } @Test fun searchedCaseTest() { val case = caseWhen(SimpleModel_Table.name.eq("USA")).then("Domestic") - .`when`(SimpleModel_Table.name.eq("CA")).then("Canada") - .`else`("Foreign") + .whenever(SimpleModel_Table.name.eq("CA")).then("Canada") + .`else`("Foreign") assertEquals("CASE WHEN `name`='USA' THEN 'Domestic' WHEN `name`='CA' THEN 'Canada' ELSE 'Foreign'", - case.query.trim()) + case.query.trim()) assertFalse(case.isEfficientCase) } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CursorResultTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CursorResultTest.kt index 907ee3cfa..98aff2271 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CursorResultTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CursorResultTest.kt @@ -6,9 +6,7 @@ import com.raizlabs.android.dbflow.models.SimpleCustomModel import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.sql.queriable.cursorResult import com.raizlabs.android.dbflow.structure.save -import org.junit.Assert.assertEquals -import org.junit.Assert.assertNotNull -import org.junit.Assert.assertTrue +import org.junit.Assert.* import org.junit.Before import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/FromTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/FromTest.kt index 3c205a9e5..228ffd8a7 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/FromTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/FromTest.kt @@ -26,7 +26,7 @@ class FromTest : BaseUnitTest() { @Test fun validateMultipleProjection() { assertEquals("SELECT `name`,`name`,`id` FROM `SimpleModel`", - (select(name, TwoColumnModel_Table.name, id) from SimpleModel::class).query.trim()) + (select(name, TwoColumnModel_Table.name, id) from SimpleModel::class).query.trim()) } @Test @@ -37,10 +37,10 @@ class FromTest : BaseUnitTest() { @Test fun validateJoins() { val from = (select from SimpleModel::class - innerJoin TwoColumnModel::class - on name.eq(TwoColumnModel_Table.name.withTable())) + innerJoin TwoColumnModel::class + on name.eq(TwoColumnModel_Table.name.withTable())) assertEquals("SELECT * FROM `SimpleModel` INNER JOIN `TwoColumnModel` ON `name`=`TwoColumnModel`.`name`", - from.query.trim()) + from.query.trim()) assertTrue(from.associatedTables.isNotEmpty()) } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexedByTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexedByTest.kt index f2aab60e2..ead32d9ad 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexedByTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexedByTest.kt @@ -12,7 +12,7 @@ class IndexedByTest : BaseUnitTest() { @Test fun validateQuery() { val indexed = (select from SimpleModel::class) - .indexedBy(IndexProperty("Index", false, SimpleModel::class.java, SimpleModel_Table.name)) + .indexedBy(IndexProperty("Index", false, SimpleModel::class.java, SimpleModel_Table.name)) assertEquals("SELECT * FROM `SimpleModel` INDEXED BY `Index`", indexed.query.trim()) } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/InsertTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/InsertTest.kt index 9f36c1163..198631194 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/InsertTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/InsertTest.kt @@ -2,11 +2,11 @@ package com.raizlabs.android.dbflow.sql.language import android.content.ContentValues import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.structure.database.set import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.TwoColumnModel import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.name +import com.raizlabs.android.dbflow.structure.database.set import org.junit.Assert.assertEquals import org.junit.Test @@ -30,41 +30,41 @@ class InsertTest : BaseUnitTest() { @Test fun validateInsertProjection() { assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 'id')", - insert().columns(name, id).values("name", "id").query.trim()) + insert().columns(name, id).values("name", "id").query.trim()) } @Test fun validateSelect() { assertEquals("INSERT INTO `TwoColumnModel` SELECT * FROM `SimpleModel`", - insert().select(select from SimpleModel::class).query.trim()) + insert().select(select from SimpleModel::class).query.trim()) } @Test fun validateColumns() { assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 'id')", - insert().asColumns().values("name", "id").query.trim()) + insert().asColumns().values("name", "id").query.trim()) assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 'id')", - insert().columns("name", "id").values("name", "id").query.trim()) + insert().columns("name", "id").values("name", "id").query.trim()) assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 'id')", - insert().columns(listOf(name, id)).values("name", "id").query.trim()) + insert().columns(listOf(name, id)).values("name", "id").query.trim()) } @Test fun validateColumnValues() { assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 0)", - insert().columnValues(name.eq("name"), id.eq(0)).query.trim()) + insert().columnValues(name.eq("name"), id.eq(0)).query.trim()) assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 0)", - insert().columnValues(Operator.op(NameAlias.builder("name").build()).eq("name"), - id.eq(0)).query.trim()) + insert().columnValues(Operator.op(NameAlias.builder("name").build()).eq("name"), + id.eq(0)).query.trim()) assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 0)", - insert().columnValues(OperatorGroup.clause().andAll(name.eq("name"), id.eq(0))).query.trim()) + insert().columnValues(OperatorGroup.clause().andAll(name.eq("name"), id.eq(0))).query.trim()) val contentValues = ContentValues() contentValues["name"] = "name" contentValues["id"] = 0.toInt() assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 0)", - insert().columnValues(contentValues).query.trim()) + insert().columnValues(contentValues).query.trim()) } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/JoinTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/JoinTest.kt index c1b0aa4a2..bcbbc1e21 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/JoinTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/JoinTest.kt @@ -14,57 +14,57 @@ class JoinTest : BaseUnitTest() { @Test fun validateAliasJoin() { assertEquals("SELECT * FROM `SimpleModel` INNER JOIN `TwoColumnModel` AS `Name` ON `TwoColumnModel`.`name`=`name`", - ((select from SimpleModel::class innerJoin - TwoColumnModel::class).`as`("Name") on TwoColumnModel_Table.name.withTable().eq(SimpleModel_Table.name)).query.trim()) + ((select from SimpleModel::class innerJoin + TwoColumnModel::class).`as`("Name") on TwoColumnModel_Table.name.withTable().eq(SimpleModel_Table.name)).query.trim()) } @Test fun testInnerJoin() { val join = select from SimpleModel::class innerJoin - TwoColumnModel::class on TwoColumnModel_Table.name.withTable().eq(SimpleModel_Table.name) + TwoColumnModel::class on TwoColumnModel_Table.name.withTable().eq(SimpleModel_Table.name) assertEquals("SELECT * FROM `SimpleModel` INNER JOIN `TwoColumnModel` ON `TwoColumnModel`.`name`=`name`", - join.query.trim()) + join.query.trim()) } @Test fun testLeftOuterJoin() { val join = select from SimpleModel::class leftOuterJoin - TwoColumnModel::class on TwoColumnModel_Table.name.withTable().eq(SimpleModel_Table.name) + TwoColumnModel::class on TwoColumnModel_Table.name.withTable().eq(SimpleModel_Table.name) assertEquals("SELECT * FROM `SimpleModel` LEFT OUTER JOIN `TwoColumnModel` ON `TwoColumnModel`.`name`=`name`", - join.query.trim()) + join.query.trim()) } @Test fun testCrossJoin() { val join = select from SimpleModel::class crossJoin - TwoColumnModel::class on TwoColumnModel_Table.name.withTable().eq(SimpleModel_Table.name) + TwoColumnModel::class on TwoColumnModel_Table.name.withTable().eq(SimpleModel_Table.name) assertEquals("SELECT * FROM `SimpleModel` CROSS JOIN `TwoColumnModel` ON `TwoColumnModel`.`name`=`name`", - join.query.trim()) + join.query.trim()) } @Test fun testMultiJoin() { val join = select from SimpleModel::class innerJoin - TwoColumnModel::class on TwoColumnModel_Table.name.withTable().eq(SimpleModel_Table.name) crossJoin - TwoColumnModel::class on TwoColumnModel_Table.id.withTable().eq(SimpleModel_Table.name) + TwoColumnModel::class on TwoColumnModel_Table.name.withTable().eq(SimpleModel_Table.name) crossJoin + TwoColumnModel::class on TwoColumnModel_Table.id.withTable().eq(SimpleModel_Table.name) assertEquals("SELECT * FROM `SimpleModel` INNER JOIN `TwoColumnModel` ON `TwoColumnModel`.`name`=`name`" + - " CROSS JOIN `TwoColumnModel` ON `TwoColumnModel`.`id`=`name`", - join.query.trim()) + " CROSS JOIN `TwoColumnModel` ON `TwoColumnModel`.`id`=`name`", + join.query.trim()) } @Test fun testInnerJoinOnUsing() { val join = select from SimpleModel::class innerJoin - TwoColumnModel::class using SimpleModel_Table.name.withTable() + TwoColumnModel::class using SimpleModel_Table.name.withTable() assertEquals("SELECT * FROM `SimpleModel` INNER JOIN `TwoColumnModel` USING (`SimpleModel`.`name`)", - join.query.trim()) + join.query.trim()) } @Test fun testNaturalJoin() { val join = (select from SimpleModel::class naturalJoin - TwoColumnModel::class).end() + TwoColumnModel::class).end() assertEquals("SELECT * FROM `SimpleModel` NATURAL JOIN `TwoColumnModel`", - join.query.trim()) + join.query.trim()) } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UnsafeStringOperatorTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UnsafeStringOperatorTest.kt index 9c121a7a7..04ae255f5 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UnsafeStringOperatorTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UnsafeStringOperatorTest.kt @@ -12,6 +12,6 @@ class UnsafeStringOperatorTest : BaseUnitTest() { val op = UnSafeStringOperator("name = ?, id = ?, test = ?", arrayOf("'name'", "0", "'test'")) assertEquals("name = 'name', id = 0, test = 'test'", op) assertEquals("SELECT * FROM `SimpleModel` WHERE name = 'name', id = 0, test = 'test'", - select from SimpleModel::class where op) + select from SimpleModel::class where op) } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/BytePropertyTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/BytePropertyTest.kt index b299253c4..7c79ce63c 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/BytePropertyTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/BytePropertyTest.kt @@ -31,11 +31,11 @@ class BytePropertyTest : BaseUnitTest() { assertEquals("`Prop` AS `Alias`", prop.toString().trim()) val prop2 = Property(SimpleModel::class.java, - NameAlias.builder("Prop") - .shouldAddIdentifierToName(false) - .`as`("Alias") - .shouldAddIdentifierToAliasName(false) - .build()) + NameAlias.builder("Prop") + .shouldAddIdentifierToName(false) + .`as`("Alias") + .shouldAddIdentifierToAliasName(false) + .build()) assertEquals("Prop AS Alias", prop2.toString().trim()) } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/CharPropertyTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/CharPropertyTest.kt index a10dbbf07..927115057 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/CharPropertyTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/CharPropertyTest.kt @@ -31,11 +31,11 @@ class CharPropertyTest : BaseUnitTest() { assertEquals("`Prop` AS `Alias`", prop.toString().trim()) val prop2 = Property(SimpleModel::class.java, - NameAlias.builder("Prop") - .shouldAddIdentifierToName(false) - .`as`("Alias") - .shouldAddIdentifierToAliasName(false) - .build()) + NameAlias.builder("Prop") + .shouldAddIdentifierToName(false) + .`as`("Alias") + .shouldAddIdentifierToAliasName(false) + .build()) assertEquals("Prop AS Alias", prop2.toString().trim()) } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/DoublePropertyTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/DoublePropertyTest.kt index 1c3b8b774..bc4ebd524 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/DoublePropertyTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/DoublePropertyTest.kt @@ -31,11 +31,11 @@ class DoublePropertyTest : BaseUnitTest() { assertEquals("`Prop` AS `Alias`", prop.toString().trim()) val prop2 = Property(SimpleModel::class.java, - NameAlias.builder("Prop") - .shouldAddIdentifierToName(false) - .`as`("Alias") - .shouldAddIdentifierToAliasName(false) - .build()) + NameAlias.builder("Prop") + .shouldAddIdentifierToName(false) + .`as`("Alias") + .shouldAddIdentifierToAliasName(false) + .build()) assertEquals("Prop AS Alias", prop2.toString().trim()) } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/FloatPropertyTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/FloatPropertyTest.kt index 158fb96e0..dd792a227 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/FloatPropertyTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/FloatPropertyTest.kt @@ -31,11 +31,11 @@ class FloatPropertyTest : BaseUnitTest() { assertEquals("`Prop` AS `Alias`", prop.toString().trim()) val prop2 = Property(SimpleModel::class.java, - NameAlias.builder("Prop") - .shouldAddIdentifierToName(false) - .`as`("Alias") - .shouldAddIdentifierToAliasName(false) - .build()) + NameAlias.builder("Prop") + .shouldAddIdentifierToName(false) + .`as`("Alias") + .shouldAddIdentifierToAliasName(false) + .build()) assertEquals("Prop AS Alias", prop2.toString().trim()) } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/IndexPropertyTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/IndexPropertyTest.kt index 5c0cb127f..5ab2f9097 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/IndexPropertyTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/IndexPropertyTest.kt @@ -13,7 +13,7 @@ class IndexPropertyTest : BaseUnitTest() { fun validateIndexProperty() { val prop = IndexProperty("Index", true, SimpleModel::class.java, - SimpleModel_Table.name) + SimpleModel_Table.name) prop.createIfNotExists() prop.drop() assertEquals("`Index`", prop.indexName) diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/IntPropertyTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/IntPropertyTest.kt index b3334598e..57bb10e8a 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/IntPropertyTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/IntPropertyTest.kt @@ -31,11 +31,11 @@ class IntPropertyTest : BaseUnitTest() { assertEquals("`Prop` AS `Alias`", prop.toString().trim()) val prop2 = Property(SimpleModel::class.java, - NameAlias.builder("Prop") - .shouldAddIdentifierToName(false) - .`as`("Alias") - .shouldAddIdentifierToAliasName(false) - .build()) + NameAlias.builder("Prop") + .shouldAddIdentifierToName(false) + .`as`("Alias") + .shouldAddIdentifierToAliasName(false) + .build()) assertEquals("Prop AS Alias", prop2.toString().trim()) } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/LongPropertyTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/LongPropertyTest.kt index 0205b4c6d..e30d72937 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/LongPropertyTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/LongPropertyTest.kt @@ -31,11 +31,11 @@ class LongPropertyTest : BaseUnitTest() { assertEquals("`Prop` AS `Alias`", prop.toString().trim()) val prop2 = Property(SimpleModel::class.java, - NameAlias.builder("Prop") - .shouldAddIdentifierToName(false) - .`as`("Alias") - .shouldAddIdentifierToAliasName(false) - .build()) + NameAlias.builder("Prop") + .shouldAddIdentifierToName(false) + .`as`("Alias") + .shouldAddIdentifierToAliasName(false) + .build()) assertEquals("Prop AS Alias", prop2.toString().trim()) } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/PropertyFactoryTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/PropertyFactoryTest.kt index bdcc567a0..ecd37f2a2 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/PropertyFactoryTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/PropertyFactoryTest.kt @@ -1,9 +1,8 @@ package com.raizlabs.android.dbflow.sql.language.property import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.sql.language.from -import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.models.SimpleModel +import com.raizlabs.android.dbflow.sql.language.select import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/PropertyTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/PropertyTest.kt index 68183ba14..74699af17 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/PropertyTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/PropertyTest.kt @@ -34,11 +34,11 @@ class PropertyTest : BaseUnitTest() { Assert.assertEquals("`Prop` AS `Alias`", prop.toString().trim()) val prop2 = Property(SimpleModel::class.java, - NameAlias.builder("Prop") - .shouldAddIdentifierToName(false) - .`as`("Alias") - .shouldAddIdentifierToAliasName(false) - .build()) + NameAlias.builder("Prop") + .shouldAddIdentifierToName(false) + .`as`("Alias") + .shouldAddIdentifierToAliasName(false) + .build()) Assert.assertEquals("Prop AS Alias", prop2.toString().trim()) } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/ShortPropertyTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/ShortPropertyTest.kt index be1921287..3dc213bcd 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/ShortPropertyTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/ShortPropertyTest.kt @@ -31,11 +31,11 @@ class ShortPropertyTest : BaseUnitTest() { assertEquals("`Prop` AS `Alias`", prop.toString().trim()) val prop2 = Property(SimpleModel::class.java, - NameAlias.builder("Prop") - .shouldAddIdentifierToName(false) - .`as`("Alias") - .shouldAddIdentifierToAliasName(false) - .build()) + NameAlias.builder("Prop") + .shouldAddIdentifierToName(false) + .`as`("Alias") + .shouldAddIdentifierToAliasName(false) + .build()) assertEquals("Prop AS Alias", prop2.toString().trim()) } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/queriable/AsyncQueryTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/queriable/AsyncQueryTest.kt index 0606ec077..452269707 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/queriable/AsyncQueryTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/queriable/AsyncQueryTest.kt @@ -3,7 +3,6 @@ package com.raizlabs.android.dbflow.sql.queriable import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.sql.language.CursorResult -import com.raizlabs.android.dbflow.sql.language.from import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.structure.save import org.junit.Assert.assertEquals diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ContentResolverNotifier.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ContentResolverNotifier.kt index 63889cef5..5f1ea4711 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ContentResolverNotifier.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ContentResolverNotifier.kt @@ -3,7 +3,7 @@ package com.raizlabs.android.dbflow.runtime import android.content.ContentResolver import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.sql.SqlUtils +import com.raizlabs.android.dbflow.sql.getNotificationUri import com.raizlabs.android.dbflow.sql.language.SQLOperator import com.raizlabs.android.dbflow.structure.BaseModel import com.raizlabs.android.dbflow.structure.ModelAdapter @@ -17,7 +17,7 @@ class ContentResolverNotifier : ModelNotifier { action: BaseModel.Action) { if (FlowContentObserver.shouldNotify()) { FlowManager.context.contentResolver - .notifyChange(SqlUtils.getNotificationUri(adapter.modelClass, action, + .notifyChange(getNotificationUri(adapter.modelClass, action, adapter.getPrimaryConditionClause(model).conditions), null, true) } } @@ -25,7 +25,7 @@ class ContentResolverNotifier : ModelNotifier { override fun notifyTableChanged(table: Class, action: BaseModel.Action) { if (FlowContentObserver.shouldNotify()) { FlowManager.context.contentResolver - .notifyChange(SqlUtils.getNotificationUri(table, action, + .notifyChange(getNotificationUri(table, action, null as Array?), null, true) } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/FlowContentObserver.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/FlowContentObserver.java index 4853d4e5c..9d82b2bb0 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/FlowContentObserver.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/FlowContentObserver.java @@ -145,7 +145,7 @@ public void endTransactionAndNotify() { for (Uri uri : tableUris) { for (OnTableChangedListener onTableChangedListener : onTableChangedListeners) { onTableChangedListener.onTableChanged(registeredTables.get(uri.getAuthority()), - Action.valueOf(uri.getFragment())); + Action.valueOf(uri.getFragment())); } } tableUris.clear(); @@ -266,7 +266,7 @@ private void onChange(boolean selfChanges, Uri uri, boolean calledInternally) { param = Uri.decode(uri.getQueryParameter(key)); columnName = Uri.decode(key); columnsChanged[index] = Operator.Companion.op(new NameAlias.Builder(columnName).build()) - .eq(param); + .eq(param); index++; } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/SqlUtils.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/SqlUtils.java deleted file mode 100644 index 4bf3c6d04..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/SqlUtils.java +++ /dev/null @@ -1,205 +0,0 @@ -package com.raizlabs.android.dbflow.sql; - -import android.content.ContentValues; -import android.net.Uri; -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.StringUtils; -import com.raizlabs.android.dbflow.config.FlowManager; -import com.raizlabs.android.dbflow.sql.language.NameAlias; -import com.raizlabs.android.dbflow.sql.language.Operator; -import com.raizlabs.android.dbflow.sql.language.OperatorGroup; -import com.raizlabs.android.dbflow.sql.language.SQLOperator; -import com.raizlabs.android.dbflow.structure.BaseModel.Action; -import com.raizlabs.android.dbflow.structure.Model; -import com.raizlabs.android.dbflow.structure.database.DatabaseStatement; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; - -import java.util.Map; - -/** - * Description: Provides some handy methods for dealing with SQL statements. It's purpose is to move the - * methods away from the {@link Model} class and let any class use these. - */ -public class SqlUtils { - - private static final char[] hexArray = "0123456789ABCDEF".toCharArray(); - - /** - * Constructs a {@link Uri} from a set of {@link SQLOperator} for specific table. - * - * @param modelClass The class of table, - * @param action The action to use. - * @param conditions The set of key-value {@link SQLOperator} to construct into a uri. - * @return The {@link Uri}. - */ - public static Uri getNotificationUri(@NonNull Class modelClass, - @Nullable Action action, - @Nullable Iterable conditions) { - Uri.Builder uriBuilder = new Uri.Builder().scheme("dbflow") - .authority(FlowManager.getTableName(modelClass)); - if (action != null) { - uriBuilder.fragment(action.name()); - } - if (conditions != null) { - for (SQLOperator condition : conditions) { - uriBuilder.appendQueryParameter(Uri.encode(condition.columnName()), Uri.encode(String.valueOf(condition.value()))); - } - } - return uriBuilder.build(); - } - - - /** - * Constructs a {@link Uri} from a set of {@link SQLOperator} for specific table. - * - * @param modelClass The class of table, - * @param action The action to use. - * @param conditions The set of key-value {@link SQLOperator} to construct into a uri. - * @return The {@link Uri}. - */ - public static Uri getNotificationUri(@NonNull Class modelClass, - @NonNull Action action, - @Nullable SQLOperator[] conditions) { - Uri.Builder uriBuilder = new Uri.Builder().scheme("dbflow") - .authority(FlowManager.getTableName(modelClass)); - uriBuilder.fragment(action.name()); - if (conditions != null && conditions.length > 0) { - for (SQLOperator condition : conditions) { - if (condition != null) { - uriBuilder.appendQueryParameter(Uri.encode(condition.columnName()), Uri.encode(String.valueOf(condition.value()))); - } - } - } - return uriBuilder.build(); - } - - /** - * Returns the uri for notifications from model changes - * - * @param modelClass The class to get table from. - * @param action the action changed. - * @param notifyKey The column key. - * @param notifyValue The column value that gets turned into a String. - * @return Notification uri. - */ - - public static Uri getNotificationUri(@NonNull Class modelClass, - @NonNull Action action, - @NonNull String notifyKey, - @Nullable Object notifyValue) { - Operator operator = null; - if (StringUtils.isNotNullOrEmpty(notifyKey)) { - operator = Operator.Companion.op(new NameAlias.Builder(notifyKey).build()).value(notifyValue); - } - return getNotificationUri(modelClass, action, new SQLOperator[]{operator}); - } - - /** - * @param modelClass The model class to use. - * @param action The {@link Action} to use. - * @return The uri for updates to {@link Model}, meant for general changes. - */ - public static Uri getNotificationUri(@NonNull Class modelClass, @NonNull Action action) { - return getNotificationUri(modelClass, action, null, null); - } - - - /** - * Drops an active TRIGGER by specifying the onTable and triggerName - * - * @param mOnTable The table that this trigger runs on - * @param triggerName The name of the trigger - */ - public static void dropTrigger(@NonNull Class mOnTable, @NonNull String triggerName) { - FlowManager.getDatabaseForTable(mOnTable).getWritableDatabase() - .execSQL("DROP TRIGGER IF EXISTS " + triggerName); - } - - /** - * Drops an active INDEX by specifying the onTable and indexName - * - * @param indexName The name of the index. - */ - public static void dropIndex(@NonNull DatabaseWrapper databaseWrapper, - @NonNull String indexName) { - databaseWrapper.execSQL("DROP INDEX IF EXISTS " + StringUtils.quoteIfNeeded(indexName)); - } - - public static void dropIndex(@NonNull Class onTable, - @NonNull String indexName) { - dropIndex(FlowManager.getDatabaseForTable(onTable).getWritableDatabase(), indexName); - } - - /** - * Adds {@link ContentValues} to the specified {@link OperatorGroup}. - * - * @param contentValues The content values to convert. - * @param operatorGroup The group to put them into as {@link Operator}. - */ - public static void addContentValues(@NonNull ContentValues contentValues, @NonNull OperatorGroup operatorGroup) { - java.util.Set> entries = contentValues.valueSet(); - - for (Map.Entry entry : entries) { - String key = entry.getKey(); - operatorGroup.and(Operator.Companion.op(new NameAlias.Builder(key).build()) - .is(contentValues.get(key))); - } - } - - /** - * @param contentValues The object to check existence of. - * @param key The key to check. - * @return The key, whether it's quoted or not. - */ - @NonNull - public static String getContentValuesKey(ContentValues contentValues, String key) { - String quoted = StringUtils.quoteIfNeeded(key); - if (contentValues.containsKey(quoted)) { - return quoted; - } else { - String stripped = StringUtils.stripQuotes(key); - if (contentValues.containsKey(stripped)) { - return stripped; - } else { - throw new IllegalArgumentException("Could not find the specified key in the Content Values object."); - } - } - } - - public static long longForQuery(@NonNull DatabaseWrapper wrapper, - @NonNull String query) { - DatabaseStatement statement = wrapper.compileStatement(query); - try { - return statement.simpleQueryForLong(); - } finally { - statement.close(); - } - } - - public static double doubleForQuery(@NonNull DatabaseWrapper wrapper, - @NonNull String query) { - DatabaseStatement statement = wrapper.compileStatement(query); - try { - return statement.simpleQueryForLong(); - } finally { - statement.close(); - } - } - - /** - * Converts a byte[] to a String hex representation for within wrapper queries. - */ - @NonNull - public static String byteArrayToHexString(byte[] bytes) { - char[] hexChars = new char[bytes.length * 2]; - for (int j = 0; j < bytes.length; j++) { - int v = bytes[j] & 0xFF; - hexChars[j * 2] = hexArray[v >>> 4]; - hexChars[j * 2 + 1] = hexArray[v & 0x0F]; - } - return new String(hexChars); - } -} - diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/SqlUtils.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/SqlUtils.kt new file mode 100644 index 000000000..39bbf4ac3 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/SqlUtils.kt @@ -0,0 +1,193 @@ +@file:JvmName("SqlUtils") + +package com.raizlabs.android.dbflow.sql + +import android.content.ContentValues +import android.net.Uri +import com.raizlabs.android.dbflow.config.FlowManager +import com.raizlabs.android.dbflow.isNotNullOrEmpty +import com.raizlabs.android.dbflow.quoteIfNeeded +import com.raizlabs.android.dbflow.sql.language.NameAlias +import com.raizlabs.android.dbflow.sql.language.Operator +import com.raizlabs.android.dbflow.sql.language.OperatorGroup +import com.raizlabs.android.dbflow.sql.language.SQLOperator +import com.raizlabs.android.dbflow.stripQuotes +import com.raizlabs.android.dbflow.structure.BaseModel.Action +import com.raizlabs.android.dbflow.structure.Model +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper + +/** + * Description: Provides some handy methods for dealing with SQL statements. It's purpose is to move the + * methods away from the [Model] class and let any class use these. + */ +private val hexArray = "0123456789ABCDEF".toCharArray() + +/** + * Constructs a [Uri] from a set of [SQLOperator] for specific table. + * + * @param modelClass The class of table, + * @param action The action to use. + * @param conditions The set of key-value [SQLOperator] to construct into a uri. + * @return The [Uri]. + */ +fun getNotificationUri(modelClass: Class<*>, + action: Action?, + conditions: Iterable?): Uri { + val uriBuilder = Uri.Builder().scheme("dbflow") + .authority(FlowManager.getTableName(modelClass)) + if (action != null) { + uriBuilder.fragment(action.name) + } + if (conditions != null) { + for (condition in conditions) { + uriBuilder.appendQueryParameter(Uri.encode(condition.columnName()), Uri.encode(condition.value().toString())) + } + } + return uriBuilder.build() +} + + +/** + * Constructs a [Uri] from a set of [SQLOperator] for specific table. + * + * @param modelClass The class of table, + * @param action The action to use. + * @param conditions The set of key-value [SQLOperator] to construct into a uri. + * @return The [Uri]. + */ +fun getNotificationUri(modelClass: Class<*>, + action: Action, + conditions: Array?): Uri { + val uriBuilder = Uri.Builder().scheme("dbflow") + .authority(FlowManager.getTableName(modelClass)) + uriBuilder.fragment(action.name) + if (conditions != null && conditions.isNotEmpty()) { + for (condition in conditions) { + uriBuilder.appendQueryParameter(Uri.encode(condition.columnName()), + Uri.encode(condition.value().toString())) + } + } + return uriBuilder.build() +} + +/** + * Returns the uri for notifications from model changes + * + * @param modelClass The class to get table from. + * @param action the action changed. + * @param notifyKey The column key. + * @param notifyValue The column value that gets turned into a String. + * @return Notification uri. + */ +@JvmOverloads +fun getNotificationUri(modelClass: Class<*>, + action: Action, + notifyKey: String = "", + notifyValue: Any? = null): Uri { + var operator: Operator? = null + if (notifyKey.isNotNullOrEmpty()) { + operator = Operator.op(NameAlias.Builder(notifyKey).build()).value(notifyValue) + } + return getNotificationUri(modelClass, action, if (operator != null) arrayOf(operator) else null) +} + + +/** + * Drops an active TRIGGER by specifying the onTable and triggerName + * + * @param mOnTable The table that this trigger runs on + * @param triggerName The name of the trigger + */ +fun dropTrigger(mOnTable: Class<*>, triggerName: String) { + FlowManager.getDatabaseForTable(mOnTable).writableDatabase + .execSQL("DROP TRIGGER IF EXISTS " + triggerName) +} + +/** + * Drops an active INDEX by specifying the onTable and indexName + * + * @param indexName The name of the index. + */ +fun dropIndex(databaseWrapper: DatabaseWrapper, + indexName: String) { + databaseWrapper.execSQL("DROP INDEX IF EXISTS " + indexName.quoteIfNeeded()!!) +} + +fun dropIndex(onTable: Class<*>, + indexName: String) { + dropIndex(FlowManager.getDatabaseForTable(onTable).writableDatabase, indexName) +} + +/** + * Adds [ContentValues] to the specified [OperatorGroup]. + * + * @param contentValues The content values to convert. + * @param operatorGroup The group to put them into as [Operator]. + */ +fun addContentValues(contentValues: ContentValues, operatorGroup: OperatorGroup) { + val entries = contentValues.valueSet() + + for ((key) in entries) { + operatorGroup.and(Operator.op(NameAlias.Builder(key).build()) + .`is`(contentValues.get(key))) + } +} + +/** + * @param contentValues The object to check existence of. + * @param key The key to check. + * @return The key, whether it's quoted or not. + */ +fun getContentValuesKey(contentValues: ContentValues, key: String): String { + val quoted = key.quoteIfNeeded() + return when { + contentValues.containsKey(quoted) -> quoted ?: "" + else -> { + val stripped = key.stripQuotes() + when { + contentValues.containsKey(stripped) -> stripped ?: "" + else -> throw IllegalArgumentException("Could not find the specified key in the Content Values object.") + } + } + } +} + +fun longForQuery(wrapper: DatabaseWrapper, + query: String): Long { + val statement = wrapper.compileStatement(query) + try { + return statement.simpleQueryForLong() + } finally { + statement.close() + } +} + +fun doubleForQuery(wrapper: DatabaseWrapper, + query: String): Double { + val statement = wrapper.compileStatement(query) + try { + return statement.simpleQueryForLong().toDouble() + } finally { + statement.close() + } +} + +/** + * Converts a byte[] to a String hex representation for within wrapper queries. + */ +fun byteArrayToHexString(bytes: ByteArray?): String { + if (bytes == null) return "" + val hexChars = CharArray(bytes.size * 2) + for (j in bytes.indices) { + val v = bytes[j].toInt() and 0xFF + hexChars[j * 2] = hexArray[v.ushr(4)] + hexChars[j * 2 + 1] = hexArray[v and 0x0F] + } + return String(hexChars) +} +/** + * @param modelClass The model class to use. + * @param action The [Action] to use. + * @return The uri for updates to [Model], meant for general changes. + */ + diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseOperator.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseOperator.kt index 7a21f9f0e..8b6a19259 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseOperator.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseOperator.kt @@ -5,7 +5,7 @@ import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.converter.TypeConverter import com.raizlabs.android.dbflow.data.Blob import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.sql.SqlUtils +import com.raizlabs.android.dbflow.sql.byteArrayToHexString /** * Description: Base class for all kinds of [SQLOperator] @@ -157,7 +157,7 @@ abstract class BaseOperator internal constructor( } else { bytes = _value as ByteArray? } - stringVal = "X" + DatabaseUtils.sqlEscapeString(SqlUtils.byteArrayToHexString(bytes)) + stringVal = "X" + DatabaseUtils.sqlEscapeString(byteArrayToHexString(bytes)) } else { stringVal = _value.toString() if (stringVal != Operator.Operation.EMPTY_PARAM) { diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseQueriable.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseQueriable.kt index 316ff1293..027af3e29 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseQueriable.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseQueriable.kt @@ -4,7 +4,7 @@ import android.database.sqlite.SQLiteDoneException import com.raizlabs.android.dbflow.config.FlowLog import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.runtime.NotifyDistributor -import com.raizlabs.android.dbflow.sql.SqlUtils +import com.raizlabs.android.dbflow.sql.longForQuery import com.raizlabs.android.dbflow.sql.queriable.Queriable import com.raizlabs.android.dbflow.structure.BaseModel import com.raizlabs.android.dbflow.structure.database.DatabaseStatement @@ -29,7 +29,7 @@ abstract class BaseQueriable protected constructor( try { val query = query FlowLog.log(FlowLog.Level.V, "Executing query: " + query) - return SqlUtils.longForQuery(databaseWrapper, query) + return longForQuery(databaseWrapper, query) } catch (sde: SQLiteDoneException) { // catch exception here, log it but return 0; FlowLog.logWarning(sde) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseTransformable.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseTransformable.kt index c7e8f82ac..2293e6cea 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseTransformable.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseTransformable.kt @@ -16,6 +16,9 @@ abstract class BaseTransformable protected constructor(table: Class) : BaseModelQueriable(table), Transformable, WhereBase { + + infix fun whereExists(where: Where) = where().exists(where) + fun where(vararg conditions: SQLOperator): Where = Where(this, *conditions) override fun query(): FlowCursor? = where().query() @@ -62,3 +65,5 @@ protected constructor(table: Class) } } } + +infix fun BaseTransformable.where(sqlOperator: SQLOperator) = where(sqlOperator) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Case.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Case.kt index 072ca4b6a..43ca85228 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Case.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Case.kt @@ -47,7 +47,8 @@ class Case(private val caseColumn: IProperty<*>? = null) : Query { } } - fun `when`(sqlOperator: SQLOperator): CaseCondition { + @JvmName("when") + infix fun whenever(sqlOperator: SQLOperator): CaseCondition { if (isEfficientCase) { throw IllegalStateException("When using the efficient CASE method," + "you must pass in value only, not condition.") } @@ -56,7 +57,8 @@ class Case(private val caseColumn: IProperty<*>? = null) : Query { return caseCondition } - fun `when`(whenValue: TReturn?): CaseCondition { + @JvmName("when") + infix fun whenever(whenValue: TReturn?): CaseCondition { if (!isEfficientCase) { throw IllegalStateException("When not using the efficient CASE method, " + "you must pass in the SQLOperator as a parameter") } @@ -65,7 +67,8 @@ class Case(private val caseColumn: IProperty<*>? = null) : Query { return caseCondition } - fun `when`(property: IProperty<*>): CaseCondition { + @JvmName("when") + infix fun whenever(property: IProperty<*>): CaseCondition { if (!isEfficientCase) { throw IllegalStateException("When not using the efficient CASE method, " + "you must pass in the SQLOperator as a parameter") } @@ -77,7 +80,8 @@ class Case(private val caseColumn: IProperty<*>? = null) : Query { /** * Default case here. If not specified, value will be NULL. */ - fun _else(elseValue: TReturn?) = apply { + @JvmName("_else") + infix fun `else`(elseValue: TReturn?) = apply { this.elseValue = elseValue elseSpecified = true // ensure its set especially if null specified. } @@ -100,6 +104,5 @@ class Case(private val caseColumn: IProperty<*>? = null) : Query { */ fun endAsOperator(): Operator = Operator.op(end().nameAlias) } -/** - * @return The case completed as a property. - */ + +infix fun Case.end(columnName: String) = end(columnName) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CaseCondition.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CaseCondition.kt index 313a2b176..bb569fde4 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CaseCondition.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CaseCondition.kt @@ -53,9 +53,9 @@ class CaseCondition : Query { /** * THEN part of this query, the value that gets set on column if condition is true. */ - fun then(value: TReturn?): Case = caze.apply { thenValue = value } + infix fun then(value: TReturn?): Case = caze.apply { thenValue = value } - fun then(value: IProperty<*>): Case = caze.apply { + infix fun then(value: IProperty<*>): Case = caze.apply { thenProperty = value // in case values are null in some sense. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CompletedTrigger.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CompletedTrigger.kt index fa18b6617..9e3f7ed50 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CompletedTrigger.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CompletedTrigger.kt @@ -2,7 +2,7 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.sql.SqlUtils +import com.raizlabs.android.dbflow.sql.dropTrigger import java.util.* /** @@ -47,6 +47,6 @@ class CompletedTrigger internal constructor( * Disables this trigger */ fun disable() { - SqlUtils.dropTrigger(triggerMethod.onTable, triggerMethod.trigger.name) + dropTrigger(triggerMethod.onTable, triggerMethod.trigger.name) } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Delete.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Delete.kt index 10e7bd84b..3189debd6 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Delete.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Delete.kt @@ -1,6 +1,7 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.sql.Query +import kotlin.reflect.KClass /** * Description: Constructs the beginning of a SQL DELETE query @@ -44,8 +45,6 @@ class Delete : Query { } } +fun delete(modelClass: KClass) = SQLite.delete(modelClass.java) inline fun delete() = SQLite.delete(T::class.java) - -inline fun delete(deleteClause: From.() -> BaseModelQueriable) - = deleteClause(SQLite.delete(T::class.java)) \ No newline at end of file diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/From.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/From.kt index 42ed7f341..2107b5f37 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/From.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/From.kt @@ -84,7 +84,7 @@ class From /** * Set an alias to the table name of this [From]. */ - fun `as`(alias: String): From { + infix fun `as`(alias: String): From { tableAlias = getTableAlias() .newBuilder() .`as`(alias) @@ -194,4 +194,5 @@ class From */ fun indexedBy(indexProperty: IndexProperty): IndexedBy = IndexedBy(indexProperty, this) + } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Index.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Index.kt index 4f83d025e..dd699f780 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Index.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Index.kt @@ -4,7 +4,7 @@ import com.raizlabs.android.dbflow.appendList import com.raizlabs.android.dbflow.appendQuotedIfNeeded import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.sql.SqlUtils +import com.raizlabs.android.dbflow.sql.dropIndex import com.raizlabs.android.dbflow.sql.language.property.IProperty import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper @@ -116,10 +116,16 @@ class Index } fun disable() { - SqlUtils.dropIndex(FlowManager.getDatabaseForTable(table!!).writableDatabase, indexName) + dropIndex(FlowManager.getDatabaseForTable(table!!).writableDatabase, indexName) } fun disable(databaseWrapper: DatabaseWrapper) { - SqlUtils.dropIndex(databaseWrapper, indexName) + dropIndex(databaseWrapper, indexName) } } + + +inline fun indexOn(indexName: String, vararg property: IProperty<*>) = Index(indexName).on(T::class.java, *property) + +inline fun indexOn(indexName: String, firstNameAlias: NameAlias, vararg arrayOfNameAlias: NameAlias) = Index(indexName).on(T::class.java, firstNameAlias, *arrayOfNameAlias) + diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Insert.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Insert.kt index 7d38e978d..2cc2c8292 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Insert.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Insert.kt @@ -272,6 +272,8 @@ class Insert } } +inline fun insert() = Insert(T::class.java) + fun insert(modelClass: KClass) = SQLite.insert(modelClass.java) infix fun Insert.orReplace(into: Array, *>>) = orReplace().columnValues(*into) @@ -297,4 +299,4 @@ fun Insert.columnValues(vararg pairs: Pair, *>): Inser } this.columns(columns).values(values) return this -} \ No newline at end of file +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/QueryExtensions.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/QueryExtensions.kt deleted file mode 100644 index d6c04b47a..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/QueryExtensions.kt +++ /dev/null @@ -1,55 +0,0 @@ -package com.raizlabs.android.dbflow.sql.language - -import com.raizlabs.android.dbflow.sql.language.property.IProperty -import kotlin.reflect.KClass - -/** - * Description: A file containing extensions for adding query syntactic sugar. - */ - -inline val select: Select - get() = SQLite.select() - -inline fun Select.from() = from(T::class.java) - -fun delete(modelClass: KClass) = SQLite.delete(modelClass.java) - -infix fun Select.from(modelClass: KClass) = from(modelClass.java) - -infix fun From.whereExists(where: Where) = where().exists(where) - -infix fun From.where(sqlOperator: SQLOperator) = where(sqlOperator) - -infix fun From.`as`(alias: String) = `as`(alias) - -infix fun Set.where(sqlOperator: SQLOperator) = where(sqlOperator) - -infix fun Where.and(sqlOperator: SQLOperator) = and(sqlOperator) - -infix fun Where.or(sqlOperator: SQLOperator) = or(sqlOperator) - -infix fun Case.`when`(sqlOperator: SQLOperator) = `when`(sqlOperator) - -infix fun Case.`when`(property: IProperty<*>) = `when`(property) - -infix fun Case.`when`(value: T?) = `when`(value) - -infix fun CaseCondition.then(value: T?) = then(value) - -infix fun CaseCondition.then(property: IProperty<*>) = then(property) - -infix fun Case.`else`(value: T?) = _else(value) - -infix fun Case.end(columnName: String) = end(columnName) - -fun case(caseColumn: IProperty<*>) = SQLite._case(caseColumn) - -fun caseWhen(operator: SQLOperator) = SQLite.caseWhen(operator) - -inline fun insert() = Insert(T::class.java) - -inline fun indexOn(indexName: String, vararg property: IProperty<*>) = Index(indexName).on(T::class.java, *property) - -inline fun indexOn(indexName: String, firstNameAlias: NameAlias, vararg arrayOfNameAlias: NameAlias) = Index(indexName).on(T::class.java, firstNameAlias, *arrayOfNameAlias) - - diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/SQLite.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/SQLite.kt index c13562c49..b13693e4d 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/SQLite.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/SQLite.kt @@ -85,7 +85,7 @@ object SQLite { */ @JvmStatic fun caseWhen(operator: SQLOperator): CaseCondition = - Case().`when`(operator) + Case().whenever(operator) /** * Starts an efficient CASE statement. The value passed here is only evaulated once. A non-efficient @@ -105,3 +105,7 @@ object SQLite { @JvmStatic fun _case(caseColumn: IProperty<*>): Case = Case(caseColumn) } + +fun case(caseColumn: IProperty<*>) = SQLite._case(caseColumn) + +fun caseWhen(operator: SQLOperator) = SQLite.caseWhen(operator) \ No newline at end of file diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Select.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Select.kt index cfd6ad1ba..a76934e01 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Select.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Select.kt @@ -3,7 +3,7 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.sql.Query import com.raizlabs.android.dbflow.sql.language.property.IProperty import com.raizlabs.android.dbflow.sql.language.property.Property -import java.util.* +import kotlin.reflect.KClass /** * Description: A SQL SELECT statement generator. It generates the SELECT part of the statement. @@ -20,7 +20,7 @@ class Select */ private var selectQualifier = NONE - private val propertyList = ArrayList>() + private val propertyList = arrayListOf>() override val query: String get() { @@ -56,6 +56,10 @@ class Select */ fun from(table: Class): From = From(this, table) + inline fun from() = from(T::class.java) + + infix fun from(table: KClass) = from(table.java) + /** * appends [.DISTINCT] to the query * @@ -95,3 +99,6 @@ class Select val ALL = 1 } } + +inline val select: Select + get() = SQLite.select() diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Set.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Set.kt index bf5c53b5d..eb720bc5a 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Set.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Set.kt @@ -2,7 +2,7 @@ package com.raizlabs.android.dbflow.sql.language import android.content.ContentValues import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.sql.SqlUtils +import com.raizlabs.android.dbflow.sql.addContentValues import com.raizlabs.android.dbflow.structure.BaseModel /** @@ -30,6 +30,6 @@ class Set(override val queryBuilderBase: Query, table: Class) } fun conditionValues(contentValues: ContentValues) = apply { - SqlUtils.addContentValues(contentValues, operatorGroup) + addContentValues(contentValues, operatorGroup) } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Where.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Where.kt index a3db99133..622551f23 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Where.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Where.kt @@ -74,14 +74,14 @@ class Where /** * Joins the [SQLOperator] by the prefix of "AND" (unless its the first condition). */ - fun and(condition: SQLOperator) = apply { + infix fun and(condition: SQLOperator) = apply { operatorGroup.and(condition) } /** * Joins the [SQLOperator] by the prefix of "OR" (unless its the first condition). */ - fun or(condition: SQLOperator) = apply { + infix fun or(condition: SQLOperator) = apply { operatorGroup.or(condition) } From 8e4dbac612f0fbae5da47fb2dda2d3f0ef346323 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Thu, 23 Nov 2017 17:44:23 -0500 Subject: [PATCH 064/234] [5.0] convert more remaining java classes. --- .../dbflow/runtime/BaseContentProvider.java | 82 ----- .../dbflow/runtime/BaseContentProvider.kt | 62 ++++ .../dbflow/runtime/FlowContentObserver.java | 304 ------------------ .../dbflow/runtime/FlowContentObserver.kt | 285 ++++++++++++++++ .../raizlabs/android/dbflow/sql/SqlUtils.kt | 6 +- 5 files changed, 350 insertions(+), 389 deletions(-) delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/BaseContentProvider.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/BaseContentProvider.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/FlowContentObserver.java create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/FlowContentObserver.kt diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/BaseContentProvider.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/BaseContentProvider.java deleted file mode 100644 index c15a761bf..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/BaseContentProvider.java +++ /dev/null @@ -1,82 +0,0 @@ -package com.raizlabs.android.dbflow.runtime; - -import android.content.ContentProvider; -import android.content.ContentValues; -import android.net.Uri; -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.config.DatabaseDefinition; -import com.raizlabs.android.dbflow.config.DatabaseHolder; -import com.raizlabs.android.dbflow.config.FlowManager; -import com.raizlabs.android.dbflow.sql.language.property.IProperty; -import com.raizlabs.android.dbflow.sql.language.property.Property; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; -import com.raizlabs.android.dbflow.structure.database.transaction.ITransaction; - -/** - * Description: The base provider class that {@link com.raizlabs.android.dbflow.annotation.provider.ContentProvider} - * extend when generated. - */ -public abstract class BaseContentProvider extends ContentProvider { - - protected Class moduleClass; - - /** - * Converts the column into a {@link Property}. This exists since the property method is static and cannot - * be referenced easily. - */ - public interface PropertyConverter { - IProperty fromName(String columnName); - } - - protected BaseContentProvider() { - } - - protected BaseContentProvider(@NonNull Class databaseHolderClass) { - this.moduleClass = databaseHolderClass; - } - - protected DatabaseDefinition database; - - @Override - public boolean onCreate() { - // If this is a module, then we need to initialize the module as part - // of the creation process. We can assume the framework has been general - // framework has been initialized. - if (moduleClass != null) { - FlowManager.initModule(moduleClass); - } else if (getContext() != null) { - FlowManager.init(getContext()); - } - - return true; - } - - @Override - public int bulkInsert(@NonNull final Uri uri, @NonNull final ContentValues[] values) { - final int[] count = {0}; - getDatabase().executeTransaction(new ITransaction() { - @Override - public void execute(DatabaseWrapper databaseWrapper) { - for (ContentValues contentValues : values) { - count[0] += bulkInsert(uri, contentValues); - } - } - }); - //noinspection ConstantConditions - getContext().getContentResolver().notifyChange(uri, null); - return count[0]; - } - - protected abstract String getDatabaseName(); - - protected abstract int bulkInsert(@NonNull Uri uri, @NonNull ContentValues contentValues); - - @NonNull - protected DatabaseDefinition getDatabase() { - if (database == null) { - database = FlowManager.getDatabase(getDatabaseName()); - } - return database; - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/BaseContentProvider.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/BaseContentProvider.kt new file mode 100644 index 000000000..f0f1a6c20 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/BaseContentProvider.kt @@ -0,0 +1,62 @@ +package com.raizlabs.android.dbflow.runtime + +import android.content.ContentProvider +import android.content.ContentValues +import android.net.Uri + +import com.raizlabs.android.dbflow.config.DatabaseDefinition +import com.raizlabs.android.dbflow.config.DatabaseHolder +import com.raizlabs.android.dbflow.config.FlowManager +import com.raizlabs.android.dbflow.sql.language.property.IProperty +import com.raizlabs.android.dbflow.sql.language.property.Property +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.structure.database.transaction.ITransaction + +/** + * Description: The base provider class that [com.raizlabs.android.dbflow.annotation.provider.ContentProvider] + * extend when generated. + */ +abstract class BaseContentProvider +protected constructor(databaseHolderClass: Class? = null) : ContentProvider() { + + protected open var moduleClass: Class? = databaseHolderClass + + protected val database: DatabaseDefinition by lazy { FlowManager.getDatabase(databaseName) } + + protected abstract val databaseName: String + + /** + * Converts the column into a [Property]. This exists since the property method is static and cannot + * be referenced easily. + */ + interface PropertyConverter { + fun fromName(columnName: String): IProperty<*> + } + + override fun onCreate(): Boolean { + // If this is a module, then we need to initialize the module as part + // of the creation process. We can assume the framework has been general + // framework has been initialized. + moduleClass + ?.let { FlowManager.initModule(it) } + ?: context?.let { FlowManager.init(it) } + return true + } + + override fun bulkInsert(uri: Uri, values: Array): Int { + val count = intArrayOf(0) + database.executeTransaction(object : ITransaction { + override fun execute(databaseWrapper: DatabaseWrapper) { + for (contentValues in values) { + count[0] += bulkInsert(uri, contentValues) + } + } + }) + + context?.contentResolver?.notifyChange(uri, null) + return count[0] + } + + protected abstract fun bulkInsert(uri: Uri, contentValues: ContentValues): Int + +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/FlowContentObserver.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/FlowContentObserver.java deleted file mode 100644 index 9d82b2bb0..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/FlowContentObserver.java +++ /dev/null @@ -1,304 +0,0 @@ -package com.raizlabs.android.dbflow.runtime; - -import android.annotation.TargetApi; -import android.content.ContentResolver; -import android.content.Context; -import android.database.ContentObserver; -import android.net.Uri; -import android.os.Build; -import android.os.Build.VERSION_CODES; -import android.os.Handler; -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.config.DatabaseConfig; -import com.raizlabs.android.dbflow.config.FlowManager; -import com.raizlabs.android.dbflow.sql.SqlUtils; -import com.raizlabs.android.dbflow.sql.language.NameAlias; -import com.raizlabs.android.dbflow.sql.language.Operator; -import com.raizlabs.android.dbflow.sql.language.SQLOperator; -import com.raizlabs.android.dbflow.structure.BaseModel.Action; -import com.raizlabs.android.dbflow.structure.Model; - -import java.util.HashMap; -import java.util.HashSet; -import java.util.Map; -import java.util.Set; -import java.util.concurrent.CopyOnWriteArraySet; -import java.util.concurrent.atomic.AtomicInteger; - -/** - * Description: Listens for {@link Model} changes. Register for specific - * tables with {@link #addModelChangeListener(FlowContentObserver.OnModelStateChangedListener)}. - * Provides ability to register and deregister listeners for when data is inserted, deleted, updated, and saved if the device is - * above {@link VERSION_CODES#JELLY_BEAN}. If below it will only provide one callback. This is to be paired - * with the {@link ContentResolverNotifier} specified in the {@link DatabaseConfig} by default. - */ -public class FlowContentObserver extends ContentObserver { - - private static final AtomicInteger REGISTERED_COUNT = new AtomicInteger(0); - private static boolean forceNotify = false; - - /** - * @return true if we have registered for content changes. Otherwise we do not notify - * in {@link SqlUtils} - * for efficiency purposes. - */ - public static boolean shouldNotify() { - return forceNotify || REGISTERED_COUNT.get() > 0; - } - - /** - * Removes count of observers registered, so we do not send out calls when {@link Model} changes. - */ - public static void clearRegisteredObserverCount() { - REGISTERED_COUNT.set(0); - } - - /** - * @param forceNotify if true, this will force itself to notify whenever a model changes even though - * an observer (appears to be) is not registered. - */ - public static void setShouldForceNotify(boolean forceNotify) { - FlowContentObserver.forceNotify = forceNotify; - } - - /** - * Listens for specific model changes. This is only available in {@link VERSION_CODES#JELLY_BEAN} - * or higher due to the api of {@link ContentObserver}. - */ - public interface OnModelStateChangedListener { - - /** - * Notifies that the state of a {@link Model} - * has changed for the table this is registered for. - * - * @param table The table that this change occurred on. This is ONLY available on {@link VERSION_CODES#JELLY_BEAN} - * and up. - * @param action The action on the model. for versions prior to {@link VERSION_CODES#JELLY_BEAN} , - * the {@link Action#CHANGE} will always be called for any action. - * @param primaryKeyValues The array of primary {@link SQLOperator} of what changed. Call {@link SQLOperator#columnName()} - * and {@link SQLOperator#value()} to get each information. - */ - void onModelStateChanged(@Nullable Class table, Action action, @NonNull SQLOperator[] primaryKeyValues); - } - - public interface ContentChangeListener extends OnModelStateChangedListener, OnTableChangedListener { - - } - - private final Set modelChangeListeners = new CopyOnWriteArraySet<>(); - private final Set onTableChangedListeners = new CopyOnWriteArraySet<>(); - private final Map> registeredTables = new HashMap<>(); - private final Set notificationUris = new HashSet<>(); - private final Set tableUris = new HashSet<>(); - - protected boolean isInTransaction = false; - private boolean notifyAllUris = false; - - public FlowContentObserver() { - super(null); - } - - public FlowContentObserver(@Nullable Handler handler) { - super(handler); - } - - /** - * If true, this class will get specific when it needs to, such as using all {@link Action} qualifiers. - * If false, it only uses the {@link Action#CHANGE} action in callbacks. - * - * @param notifyAllUris - */ - public void setNotifyAllUris(boolean notifyAllUris) { - this.notifyAllUris = notifyAllUris; - } - - /** - * Starts a transaction where when it is finished, this class will receive a notification of all of the changes by - * calling {@link #endTransactionAndNotify()}. Note it may lead to unexpected behavior if called from different threads. - */ - public void beginTransaction() { - if (!isInTransaction) { - isInTransaction = true; - } - } - - /** - * Ends the transaction where it finishes, and will call {@link #onChange(boolean, Uri)} for Jelly Bean and up for - * every URI called (if set), or {@link #onChange(boolean)} once for lower than Jelly bean. - */ - public void endTransactionAndNotify() { - if (isInTransaction) { - isInTransaction = false; - - if (Build.VERSION.SDK_INT < VERSION_CODES.JELLY_BEAN) { - onChange(true); - } else { - synchronized (notificationUris) { - for (Uri uri : notificationUris) { - onChange(true, uri, true); - } - notificationUris.clear(); - } - synchronized (tableUris) { - for (Uri uri : tableUris) { - for (OnTableChangedListener onTableChangedListener : onTableChangedListeners) { - onTableChangedListener.onTableChanged(registeredTables.get(uri.getAuthority()), - Action.valueOf(uri.getFragment())); - } - } - tableUris.clear(); - } - } - } - } - - /** - * Add a listener for model changes - * - * @param modelChangeListener Generic model change events from an {@link Action} - */ - public void addModelChangeListener(@NonNull OnModelStateChangedListener modelChangeListener) { - modelChangeListeners.add(modelChangeListener); - } - - /** - * Removes a listener for model changes - * - * @param modelChangeListener Generic model change events from a {@link Action} - */ - public void removeModelChangeListener(@NonNull OnModelStateChangedListener modelChangeListener) { - modelChangeListeners.remove(modelChangeListener); - } - - public void addOnTableChangedListener(@NonNull OnTableChangedListener onTableChangedListener) { - onTableChangedListeners.add(onTableChangedListener); - } - - public void removeTableChangedListener(@NonNull OnTableChangedListener onTableChangedListener) { - onTableChangedListeners.remove(onTableChangedListener); - } - - /** - * Add a listener for model + table changes - * - * @param contentChangeListener Generic model change events from an {@link Action} - */ - public void addContentChangeListener(@NonNull ContentChangeListener contentChangeListener) { - modelChangeListeners.add(contentChangeListener); - onTableChangedListeners.add(contentChangeListener); - } - - /** - * Removes a listener for model + table changes - * - * @param contentChangeListener Generic model change events from a {@link Action} - */ - public void removeContentChangeListener(@NonNull ContentChangeListener contentChangeListener) { - modelChangeListeners.remove(contentChangeListener); - onTableChangedListeners.remove(contentChangeListener); - } - - /** - * Registers the observer for model change events for specific class. - */ - public void registerForContentChanges(@NonNull Context context, - @NonNull Class table) { - registerForContentChanges(context.getContentResolver(), table); - } - - /** - * Registers the observer for model change events for specific class. - */ - public void registerForContentChanges(@NonNull ContentResolver contentResolver, - @NonNull Class table) { - contentResolver.registerContentObserver(SqlUtils.getNotificationUri(table, null), true, this); - REGISTERED_COUNT.incrementAndGet(); - if (!registeredTables.containsValue(table)) { - registeredTables.put(FlowManager.getTableName(table), table); - } - } - - /** - * Unregisters this list for model change events - */ - public void unregisterForContentChanges(@NonNull Context context) { - context.getContentResolver().unregisterContentObserver(this); - REGISTERED_COUNT.decrementAndGet(); - registeredTables.clear(); - } - - public boolean isSubscribed() { - return !registeredTables.isEmpty(); - } - - @Override - public void onChange(boolean selfChange) { - for (OnModelStateChangedListener modelChangeListener : modelChangeListeners) { - modelChangeListener.onModelStateChanged(null, Action.CHANGE, new SQLOperator[0]); - } - - for (OnTableChangedListener onTableChangedListener : onTableChangedListeners) { - onTableChangedListener.onTableChanged(null, Action.CHANGE); - } - } - - @TargetApi(VERSION_CODES.JELLY_BEAN) - @Override - public void onChange(boolean selfChange, Uri uri) { - onChange(selfChange, uri, false); - } - - @TargetApi(VERSION_CODES.JELLY_BEAN) - private void onChange(boolean selfChanges, Uri uri, boolean calledInternally) { - String fragment = uri.getFragment(); - String tableName = uri.getAuthority(); - - String columnName; - String param; - - Set queryNames = uri.getQueryParameterNames(); - SQLOperator[] columnsChanged = new SQLOperator[queryNames.size()]; - if (!queryNames.isEmpty()) { - int index = 0; - for (String key : queryNames) { - param = Uri.decode(uri.getQueryParameter(key)); - columnName = Uri.decode(key); - columnsChanged[index] = Operator.Companion.op(new NameAlias.Builder(columnName).build()) - .eq(param); - index++; - } - } - - Class table = registeredTables.get(tableName); - Action action = Action.valueOf(fragment); - if (!isInTransaction) { - - for (OnModelStateChangedListener modelChangeListener : modelChangeListeners) { - modelChangeListener.onModelStateChanged(table, action, columnsChanged); - } - - if (!calledInternally) { - for (OnTableChangedListener onTableChangeListener : onTableChangedListeners) { - onTableChangeListener.onTableChanged(table, action); - } - } - } else { - // convert this uri to a CHANGE op if we don't care about individual changes. - if (!notifyAllUris) { - action = Action.CHANGE; - uri = SqlUtils.getNotificationUri(table, action); - } - synchronized (notificationUris) { - // add and keep track of unique notification uris for when transaction completes. - notificationUris.add(uri); - } - - synchronized (tableUris) { - tableUris.add(SqlUtils.getNotificationUri(table, action)); - } - } - } - -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/FlowContentObserver.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/FlowContentObserver.kt new file mode 100644 index 000000000..a0250af8a --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/FlowContentObserver.kt @@ -0,0 +1,285 @@ +package com.raizlabs.android.dbflow.runtime + +import android.annotation.TargetApi +import android.content.ContentResolver +import android.content.Context +import android.database.ContentObserver +import android.net.Uri +import android.os.Build +import android.os.Build.VERSION_CODES +import android.os.Handler +import com.raizlabs.android.dbflow.config.DatabaseConfig +import com.raizlabs.android.dbflow.config.FlowManager +import com.raizlabs.android.dbflow.sql.getNotificationUri +import com.raizlabs.android.dbflow.sql.language.NameAlias +import com.raizlabs.android.dbflow.sql.language.Operator +import com.raizlabs.android.dbflow.sql.language.SQLOperator +import com.raizlabs.android.dbflow.structure.BaseModel.Action +import com.raizlabs.android.dbflow.structure.Model +import java.util.* +import java.util.concurrent.CopyOnWriteArraySet +import java.util.concurrent.atomic.AtomicInteger + +/** + * Description: Listens for [Model] changes. Register for specific + * tables with [.addModelChangeListener]. + * Provides ability to register and deregister listeners for when data is inserted, deleted, updated, and saved if the device is + * above [VERSION_CODES.JELLY_BEAN]. If below it will only provide one callback. This is to be paired + * with the [ContentResolverNotifier] specified in the [DatabaseConfig] by default. + */ +open class FlowContentObserver(handler: Handler? = null) : ContentObserver(handler) { + + private val modelChangeListeners = CopyOnWriteArraySet() + private val onTableChangedListeners = CopyOnWriteArraySet() + private val registeredTables = HashMap>() + private val notificationUris = HashSet() + private val tableUris = HashSet() + + protected var isInTransaction = false + private var notifyAllUris = false + + val isSubscribed: Boolean + get() = !registeredTables.isEmpty() + + /** + * Listens for specific model changes. This is only available in [VERSION_CODES.JELLY_BEAN] + * or higher due to the api of [ContentObserver]. + */ + interface OnModelStateChangedListener { + + /** + * Notifies that the state of a [Model] + * has changed for the table this is registered for. + * + * @param table The table that this change occurred on. This is ONLY available on [VERSION_CODES.JELLY_BEAN] + * and up. + * @param action The action on the model. for versions prior to [VERSION_CODES.JELLY_BEAN] , + * the [Action.CHANGE] will always be called for any action. + * @param primaryKeyValues The array of primary [SQLOperator] of what changed. Call [SQLOperator.columnName] + * and [SQLOperator.value] to get each information. + */ + fun onModelStateChanged(table: Class<*>?, action: Action, primaryKeyValues: Array) + } + + interface ContentChangeListener : OnModelStateChangedListener, OnTableChangedListener + + /** + * If true, this class will get specific when it needs to, such as using all [Action] qualifiers. + * If false, it only uses the [Action.CHANGE] action in callbacks. + * + * @param notifyAllUris + */ + fun setNotifyAllUris(notifyAllUris: Boolean) { + this.notifyAllUris = notifyAllUris + } + + /** + * Starts a transaction where when it is finished, this class will receive a notification of all of the changes by + * calling [.endTransactionAndNotify]. Note it may lead to unexpected behavior if called from different threads. + */ + fun beginTransaction() { + if (!isInTransaction) { + isInTransaction = true + } + } + + /** + * Ends the transaction where it finishes, and will call [.onChange] for Jelly Bean and up for + * every URI called (if set), or [.onChange] once for lower than Jelly bean. + */ + open fun endTransactionAndNotify() { + if (isInTransaction) { + isInTransaction = false + + if (Build.VERSION.SDK_INT < VERSION_CODES.JELLY_BEAN) { + onChange(true) + } else { + synchronized(notificationUris) { + for (uri in notificationUris) { + onChange(true, uri, true) + } + notificationUris.clear() + } + synchronized(tableUris) { + for (uri in tableUris) { + for (onTableChangedListener in onTableChangedListeners) { + onTableChangedListener.onTableChanged(registeredTables[uri.authority], + Action.valueOf(uri.fragment)) + } + } + tableUris.clear() + } + } + } + } + + /** + * Add a listener for model changes + * + * @param modelChangeListener Generic model change events from an [Action] + */ + fun addModelChangeListener(modelChangeListener: OnModelStateChangedListener) { + modelChangeListeners.add(modelChangeListener) + } + + /** + * Removes a listener for model changes + * + * @param modelChangeListener Generic model change events from a [Action] + */ + fun removeModelChangeListener(modelChangeListener: OnModelStateChangedListener) { + modelChangeListeners.remove(modelChangeListener) + } + + fun addOnTableChangedListener(onTableChangedListener: OnTableChangedListener) { + onTableChangedListeners.add(onTableChangedListener) + } + + fun removeTableChangedListener(onTableChangedListener: OnTableChangedListener) { + onTableChangedListeners.remove(onTableChangedListener) + } + + /** + * Add a listener for model + table changes + * + * @param contentChangeListener Generic model change events from an [Action] + */ + fun addContentChangeListener(contentChangeListener: ContentChangeListener) { + modelChangeListeners.add(contentChangeListener) + onTableChangedListeners.add(contentChangeListener) + } + + /** + * Removes a listener for model + table changes + * + * @param contentChangeListener Generic model change events from a [Action] + */ + fun removeContentChangeListener(contentChangeListener: ContentChangeListener) { + modelChangeListeners.remove(contentChangeListener) + onTableChangedListeners.remove(contentChangeListener) + } + + /** + * Registers the observer for model change events for specific class. + */ + open fun registerForContentChanges(context: Context, + table: Class<*>) { + registerForContentChanges(context.contentResolver, table) + } + + /** + * Registers the observer for model change events for specific class. + */ + fun registerForContentChanges(contentResolver: ContentResolver, + table: Class<*>) { + contentResolver.registerContentObserver(getNotificationUri(table, null), true, this) + REGISTERED_COUNT.incrementAndGet() + if (!registeredTables.containsValue(table)) { + registeredTables.put(FlowManager.getTableName(table), table) + } + } + + /** + * Unregisters this list for model change events + */ + fun unregisterForContentChanges(context: Context) { + context.contentResolver.unregisterContentObserver(this) + REGISTERED_COUNT.decrementAndGet() + registeredTables.clear() + } + + override fun onChange(selfChange: Boolean) { + for (modelChangeListener in modelChangeListeners) { + modelChangeListener.onModelStateChanged(null, Action.CHANGE, arrayOf()) + } + + for (onTableChangedListener in onTableChangedListeners) { + onTableChangedListener.onTableChanged(null, Action.CHANGE) + } + } + + @TargetApi(VERSION_CODES.JELLY_BEAN) + override fun onChange(selfChange: Boolean, uri: Uri) { + onChange(selfChange, uri, false) + } + + @TargetApi(VERSION_CODES.JELLY_BEAN) + private fun onChange(selfChanges: Boolean, uri: Uri, calledInternally: Boolean) { + var uri = uri + val fragment = uri.fragment + val tableName = uri.authority + + var columnName: String + var param: String + + val queryNames = uri.queryParameterNames + val columnsChanged = arrayListOf() + if (!queryNames.isEmpty()) { + for (key in queryNames) { + param = Uri.decode(uri.getQueryParameter(key)) + columnName = Uri.decode(key) + columnsChanged += Operator.op(NameAlias.Builder(columnName).build()).eq(param) + } + } + + val table = registeredTables[tableName] + var action = Action.valueOf(fragment) + if (!isInTransaction) { + + for (modelChangeListener in modelChangeListeners) { + modelChangeListener.onModelStateChanged(table, action, columnsChanged.toTypedArray()) + } + + if (!calledInternally) { + for (onTableChangeListener in onTableChangedListeners) { + onTableChangeListener.onTableChanged(table, action) + } + } + } else { + // convert this uri to a CHANGE op if we don't care about individual changes. + if (!notifyAllUris) { + action = Action.CHANGE + uri = getNotificationUri(table!!, action) + } + synchronized(notificationUris) { + // add and keep track of unique notification uris for when transaction completes. + notificationUris.add(uri) + } + + synchronized(tableUris) { + tableUris.add(getNotificationUri(table!!, action)) + } + } + } + + companion object { + + private val REGISTERED_COUNT = AtomicInteger(0) + private var forceNotify = false + + /** + * @return true if we have registered for content changes. Otherwise we do not notify + * in [SqlUtils] + * for efficiency purposes. + */ + fun shouldNotify(): Boolean { + return forceNotify || REGISTERED_COUNT.get() > 0 + } + + /** + * Removes count of observers registered, so we do not send out calls when [Model] changes. + */ + fun clearRegisteredObserverCount() { + REGISTERED_COUNT.set(0) + } + + /** + * @param forceNotify if true, this will force itself to notify whenever a model changes even though + * an observer (appears to be) is not registered. + */ + fun setShouldForceNotify(forceNotify: Boolean) { + FlowContentObserver.forceNotify = forceNotify + } + } + +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/SqlUtils.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/SqlUtils.kt index 39bbf4ac3..0d4f9f379 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/SqlUtils.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/SqlUtils.kt @@ -56,11 +56,11 @@ fun getNotificationUri(modelClass: Class<*>, * @return The [Uri]. */ fun getNotificationUri(modelClass: Class<*>, - action: Action, + action: Action?, conditions: Array?): Uri { val uriBuilder = Uri.Builder().scheme("dbflow") .authority(FlowManager.getTableName(modelClass)) - uriBuilder.fragment(action.name) + action?.let { uriBuilder.fragment(action.name) } if (conditions != null && conditions.isNotEmpty()) { for (condition in conditions) { uriBuilder.appendQueryParameter(Uri.encode(condition.columnName()), @@ -81,7 +81,7 @@ fun getNotificationUri(modelClass: Class<*>, */ @JvmOverloads fun getNotificationUri(modelClass: Class<*>, - action: Action, + action: Action?, notifyKey: String = "", notifyValue: Any? = null): Uri { var operator: Operator? = null From 725f1359b0c6c6a4f2b9bad8528d720503cec0ae Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Thu, 23 Nov 2017 22:37:07 -0500 Subject: [PATCH 065/234] [5.0] remove nondatabasewrapper methods by storing wrapper in sql classes. make wrapper entry points require database. --- .../android/dbflow/list/FlowCursorListTest.kt | 2 +- dbflow/build.gradle | 9 +- .../android/dbflow/list/FlowCursorList.kt | 17 +- .../android/dbflow/list/FlowQueryList.kt | 6 - .../dbflow/runtime/DBBatchSaveQueue.kt | 1 + .../dbflow/sql/language/BaseModelQueriable.kt | 30 +-- .../dbflow/sql/language/BaseQueriable.kt | 33 +-- .../dbflow/sql/language/BaseTransformable.kt | 9 +- .../android/dbflow/sql/language/Delete.kt | 58 ++--- .../android/dbflow/sql/language/From.kt | 11 +- .../android/dbflow/sql/language/Index.kt | 16 +- .../android/dbflow/sql/language/IndexedBy.kt | 5 +- .../android/dbflow/sql/language/Insert.kt | 13 +- .../android/dbflow/sql/language/SQLite.kt | 205 +++++++++--------- .../android/dbflow/sql/language/Select.kt | 10 +- .../android/dbflow/sql/language/Set.kt | 7 +- .../dbflow/sql/language/Transformable.kt | 12 +- .../android/dbflow/sql/language/Trigger.kt | 2 - .../android/dbflow/sql/language/Update.kt | 9 +- .../android/dbflow/sql/language/Where.kt | 13 +- .../android/dbflow/sql/language/WhereBase.kt | 3 + .../sql/language/property/IndexProperty.kt | 32 +-- .../sql/migration/AlterTableMigration.kt | 4 +- .../sql/migration/UpdateTableMigration.kt | 8 +- .../dbflow/sql/queriable/ModelLoader.kt | 28 +-- .../dbflow/sql/queriable/ModelQueriable.kt | 14 -- .../android/dbflow/sql/queriable/Queriable.kt | 45 ---- .../dbflow/sql/queriable/StringQuery.kt | 19 +- .../android/dbflow/structure/AsyncModel.kt | 118 ---------- .../android/dbflow/structure/BaseModel.kt | 37 +--- .../dbflow/structure/BaseQueryModel.kt | 5 +- .../android/dbflow/structure/Model.kt | 45 +--- .../dbflow/structure/NoModificationModel.kt | 13 +- .../android/dbflow/structure/ReadOnlyModel.kt | 18 +- .../dbflow/structure/RetrievalAdapter.kt | 12 +- .../database/transaction/Couroutines.kt | 14 ++ .../database/transaction/ITransaction.kt | 2 + .../structure/provider/BaseProviderModel.kt | 17 +- .../provider/BaseSyncableProviderModel.kt | 9 +- 39 files changed, 287 insertions(+), 624 deletions(-) delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/AsyncModel.kt create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Couroutines.kt diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorListTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorListTest.kt index c696192e0..609ccb0f6 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorListTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorListTest.kt @@ -19,7 +19,7 @@ class FlowCursorListTest : BaseUnitTest() { @Test fun validateCursorPassed() { val cursor = (select from SimpleModel::class).cursor - val list = FlowCursorList.Builder(SimpleModel::class.java) + val list = FlowCursorList.Builder(select from SimpleModel::class) .cursor(cursor) .build() diff --git a/dbflow/build.gradle b/dbflow/build.gradle index 256de16f2..eaf60fac6 100644 --- a/dbflow/build.gradle +++ b/dbflow/build.gradle @@ -27,7 +27,14 @@ android { dependencies { api project("${dbflow_project_prefix}dbflow-core") api "com.android.support:support-annotations:27.0.1" - compile "org.jetbrains.kotlin:kotlin-stdlib-jre7:$kotlin_version" + api "org.jetbrains.kotlin:kotlin-stdlib-jre7:$kotlin_version" + api "org.jetbrains.kotlinx:kotlinx-coroutines-core:0.19.2" +} + +kotlin { + experimental { + coroutines 'enable' + } } apply from: '../android-artifacts.gradle' diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorList.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorList.kt index 384caf633..c02084e92 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorList.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorList.kt @@ -4,7 +4,6 @@ import android.database.Cursor import android.widget.ListView import com.raizlabs.android.dbflow.config.FlowLog import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.sql.language.SQLite import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable import com.raizlabs.android.dbflow.structure.InstanceAdapter import com.raizlabs.android.dbflow.structure.ModelAdapter @@ -183,27 +182,17 @@ class FlowCursorList private constructor(builder: Builder) : IFlowCu * * @param [T] */ - class Builder { + class Builder(internal var modelQueriable: ModelQueriable) { - internal val modelClass: Class + internal val modelClass: Class = modelQueriable.table internal var cursor: FlowCursor? = null - internal var modelQueriable: ModelQueriable - - constructor(modelClass: Class) { - this.modelClass = modelClass - this.modelQueriable = SQLite.select().from(modelClass) - } - - constructor(modelQueriable: ModelQueriable) { - this.modelClass = modelQueriable.table - this.modelQueriable = modelQueriable - } fun cursor(cursor: Cursor?) = apply { cursor?.let { this.cursor = FlowCursor.from(cursor) } } fun build() = FlowCursorList(this) + } companion object { diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowQueryList.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowQueryList.kt index 588690cc6..31f4b2f6f 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowQueryList.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowQueryList.kt @@ -9,7 +9,6 @@ import android.os.Handler import android.os.Looper import com.raizlabs.android.dbflow.list.FlowCursorList.OnCursorRefreshListener import com.raizlabs.android.dbflow.runtime.FlowContentObserver -import com.raizlabs.android.dbflow.sql.language.SQLite import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable import com.raizlabs.android.dbflow.structure.InstanceAdapter import com.raizlabs.android.dbflow.structure.ModelAdapter @@ -268,11 +267,6 @@ class FlowQueryList( modelQueriable = cursorList.modelQueriable } - constructor(table: Class) { - this.table = table - modelQueriable = SQLite.select().from(table) - } - constructor(modelQueriable: ModelQueriable) { this.table = modelQueriable.table this.modelQueriable = modelQueriable diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DBBatchSaveQueue.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DBBatchSaveQueue.kt index 7e159395a..56143876d 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DBBatchSaveQueue.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DBBatchSaveQueue.kt @@ -10,6 +10,7 @@ import com.raizlabs.android.dbflow.structure.database.transaction.Transaction import com.raizlabs.android.dbflow.structure.database.transaction.processModel import com.raizlabs.android.dbflow.structure.database.transaction.transactionError import com.raizlabs.android.dbflow.structure.database.transaction.transactionSuccess +import com.raizlabs.android.dbflow.structure.save import java.util.* /** diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseModelQueriable.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseModelQueriable.kt index 7ec3dba3a..adef16344 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseModelQueriable.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseModelQueriable.kt @@ -23,8 +23,9 @@ abstract class BaseModelQueriable * * @param table the table that belongs to this query. */ -protected constructor(table: Class) - : BaseQueriable(table), ModelQueriable, Query { +protected constructor(val databaseWrapper: DatabaseWrapper, + table: Class) + : BaseQueriable(databaseWrapper, table), ModelQueriable, Query { private val retrievalAdapter: InstanceAdapter by lazy { FlowManager.getInstanceAdapter(table) } @@ -39,25 +40,13 @@ protected constructor(table: Class) override fun queryList(): MutableList { val query = query FlowLog.log(FlowLog.Level.V, "Executing query: " + query) - return listModelLoader.load(query)!! + return listModelLoader.load(databaseWrapper, query)!! } override fun querySingle(): TModel? { val query = query FlowLog.log(FlowLog.Level.V, "Executing query: " + query) - return singleModelLoader.load(query) - } - - override fun querySingle(wrapper: DatabaseWrapper): TModel? { - val query = query - FlowLog.log(FlowLog.Level.V, "Executing query: " + query) - return singleModelLoader.load(wrapper, query) - } - - override fun queryList(wrapper: DatabaseWrapper): MutableList { - val query = query - FlowLog.log(FlowLog.Level.V, "Executing query: " + query) - return listModelLoader.load(wrapper, query)!! + return singleModelLoader.load(databaseWrapper, query) } override fun cursorList(): FlowCursorList = FlowCursorList.Builder(this).build() @@ -65,10 +54,7 @@ protected constructor(table: Class) override fun flowQueryList(): FlowQueryList = FlowQueryList.Builder(modelQueriable = this).build() - override fun executeUpdateDelete(): Long = - executeUpdateDelete(FlowManager.getWritableDatabaseForTable(table)) - - override fun executeUpdateDelete(databaseWrapper: DatabaseWrapper): Long { + override fun executeUpdateDelete(): Long { val affected = databaseWrapper.compileStatement(query).executeUpdateDelete() // only notify for affected. @@ -84,14 +70,14 @@ protected constructor(table: Class) val query = query FlowLog.log(FlowLog.Level.V, "Executing query: " + query) val adapter = FlowManager.getQueryModelAdapter(queryModelClass) - return adapter.listModelLoader.load(query)!! + return adapter.listModelLoader.load(databaseWrapper, query)!! } override fun queryCustomSingle(queryModelClass: Class): QueryClass? { val query = query FlowLog.log(FlowLog.Level.V, "Executing query: " + query) val adapter = FlowManager.getQueryModelAdapter(queryModelClass) - return adapter.singleModelLoader.load(query) + return adapter.singleModelLoader.load(databaseWrapper, query) } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseQueriable.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseQueriable.kt index 027af3e29..0fe4e3c16 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseQueriable.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseQueriable.kt @@ -2,7 +2,6 @@ package com.raizlabs.android.dbflow.sql.language import android.database.sqlite.SQLiteDoneException import com.raizlabs.android.dbflow.config.FlowLog -import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.runtime.NotifyDistributor import com.raizlabs.android.dbflow.sql.longForQuery import com.raizlabs.android.dbflow.sql.queriable.Queriable @@ -16,6 +15,7 @@ import com.raizlabs.android.dbflow.structure.database.FlowCursor * Description: Base implementation of something that can be queried from the database. */ abstract class BaseQueriable protected constructor( + private val databaseWrapper: DatabaseWrapper, /** * @return The table associated with this INSERT */ @@ -23,9 +23,7 @@ abstract class BaseQueriable protected constructor( abstract override val primaryAction: BaseModel.Action - override fun longValue(): Long = longValue(FlowManager.getWritableDatabaseForTable(table)) - - override fun longValue(databaseWrapper: DatabaseWrapper): Long { + override fun longValue(): Long { try { val query = query FlowLog.log(FlowLog.Level.V, "Executing query: " + query) @@ -40,17 +38,10 @@ abstract class BaseQueriable protected constructor( override fun hasData(): Boolean = longValue() > 0 - override fun hasData(databaseWrapper: DatabaseWrapper): Boolean = longValue(databaseWrapper) > 0 - override fun query(): FlowCursor? { - query(FlowManager.getWritableDatabaseForTable(table)) - return null - } - - override fun query(databaseWrapper: DatabaseWrapper): FlowCursor? { if (primaryAction == BaseModel.Action.INSERT) { // inserting, let's compile and insert - val databaseStatement = compileStatement(databaseWrapper) + val databaseStatement = compileStatement() databaseStatement.executeInsert() databaseStatement.close() } else { @@ -62,9 +53,6 @@ abstract class BaseQueriable protected constructor( } override fun executeInsert(): Long = - executeInsert(FlowManager.getWritableDatabaseForTable(table)) - - override fun executeInsert(databaseWrapper: DatabaseWrapper): Long = compileStatement().executeInsert() override fun execute() { @@ -77,20 +65,7 @@ abstract class BaseQueriable protected constructor( } } - override fun execute(databaseWrapper: DatabaseWrapper) { - val cursor = query(databaseWrapper) - if (cursor != null) { - cursor.close() - } else { - // we dont query, we're executing something here. - NotifyDistributor.get().notifyTableChanged(table, primaryAction) - } - } - - override fun compileStatement(): DatabaseStatement = - compileStatement(FlowManager.getWritableDatabaseForTable(table)) - - override fun compileStatement(databaseWrapper: DatabaseWrapper): DatabaseStatement { + override fun compileStatement(): DatabaseStatement { val query = query FlowLog.log(FlowLog.Level.V, "Compiling Query Into Statement: " + query) return DatabaseStatementWrapper(databaseWrapper.compileStatement(query), this) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseTransformable.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseTransformable.kt index 2293e6cea..a38ec5008 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseTransformable.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseTransformable.kt @@ -13,9 +13,9 @@ abstract class BaseTransformable * * @param table the table that belongs to this query. */ -protected constructor(table: Class) - : BaseModelQueriable(table), Transformable, WhereBase { - +protected constructor(databaseWrapper: DatabaseWrapper, + table: Class) + : BaseModelQueriable(databaseWrapper, table), Transformable, WhereBase { infix fun whereExists(where: Where) = where().exists(where) @@ -23,9 +23,6 @@ protected constructor(table: Class) override fun query(): FlowCursor? = where().query() - override fun query(databaseWrapper: DatabaseWrapper): FlowCursor? = - where().query(databaseWrapper) - override fun groupBy(vararg nameAliases: NameAlias): Where = where().groupBy(*nameAliases) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Delete.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Delete.kt index 3189debd6..b71d9001b 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Delete.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Delete.kt @@ -1,12 +1,16 @@ +@file:JvmName("Delete") +@file:JvmMultifileClass + package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.sql.Query +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper import kotlin.reflect.KClass /** * Description: Constructs the beginning of a SQL DELETE query */ -class Delete : Query { +class Delete internal constructor(private val databaseWrapper: DatabaseWrapper) : Query { override val query: String get() = "DELETE " @@ -18,33 +22,31 @@ class Delete : Query { * @param [T] The table class * @return [T] **/ - fun from(table: Class): From = From(this, table) - - companion object { - - /** - * Deletes the specified table - * - * @param table The table to delete - * @param conditions The list of conditions to use to delete from the specified table - * @param [T] The class that implements [com.raizlabs.android.dbflow.structure.Model] - */ - fun table(table: Class, vararg conditions: SQLOperator) { - Delete().from(table).where(*conditions).executeUpdateDelete() - } - - /** - * Deletes the list of tables specified. - * WARNING: this will completely clear all rows from each table. - * - * @param tables The list of tables to wipe. - */ - fun tables(vararg tables: Class<*>) { - tables.forEach { table(it) } - } - } + fun from(table: Class): From = From(databaseWrapper, this, table) + } -fun delete(modelClass: KClass) = SQLite.delete(modelClass.java) +fun DatabaseWrapper.delete(modelClass: KClass) = delete(modelClass.java) + +inline fun DatabaseWrapper.delete() = delete(T::class) + +/** + * Deletes the specified table + * + * @param table The table to delete + * @param conditions The list of conditions to use to delete from the specified table + * @param [T] The class that implements [com.raizlabs.android.dbflow.structure.Model] + */ +fun DatabaseWrapper.table(table: Class, vararg conditions: SQLOperator) { + Delete(this).from(table).where(*conditions).executeUpdateDelete() +} -inline fun delete() = SQLite.delete(T::class.java) +/** + * Deletes the list of tables specified. + * WARNING: this will completely clear all rows from each table. + * + * @param tables The list of tables to wipe. + */ +fun DatabaseWrapper.tables(vararg tables: Class<*>) { + tables.forEach { table(it) } +} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/From.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/From.kt index 2107b5f37..dd1c699a8 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/From.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/From.kt @@ -6,6 +6,7 @@ import com.raizlabs.android.dbflow.sql.language.Join.JoinType import com.raizlabs.android.dbflow.sql.language.property.IndexProperty import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable import com.raizlabs.android.dbflow.structure.BaseModel +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper import java.util.* import kotlin.collections.Set as KSet @@ -19,14 +20,14 @@ class From * @param querybase The base query we append this query to * @param table The table this corresponds to */ -( - /** - * The base such as [Delete], [Select] and more! - */ +internal constructor( + databaseWrapper: DatabaseWrapper, + /** * @return The base query, usually a [Delete], [Select], or [Update] */ - override val queryBuilderBase: Query, table: Class) : BaseTransformable(table) { + override val queryBuilderBase: Query, table: Class) + : BaseTransformable(databaseWrapper, table) { /** * An alias for the table diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Index.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Index.kt index dd699f780..1050cb512 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Index.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Index.kt @@ -19,6 +19,7 @@ class Index * @param indexName The name of this index. */ ( + private val databaseWrapper: DatabaseWrapper, /** * @return The name of this index. */ @@ -105,8 +106,7 @@ class Index } } - @JvmOverloads - fun enable(databaseWrapper: DatabaseWrapper = FlowManager.getDatabaseForTable(table!!).writableDatabase) { + fun enable() { if (table == null) { throw IllegalStateException("Please call on() to set a table to use this index on.") } else if (columns.isEmpty()) { @@ -116,16 +116,16 @@ class Index } fun disable() { - dropIndex(FlowManager.getDatabaseForTable(table!!).writableDatabase, indexName) - } - - fun disable(databaseWrapper: DatabaseWrapper) { dropIndex(databaseWrapper, indexName) } } -inline fun indexOn(indexName: String, vararg property: IProperty<*>) = Index(indexName).on(T::class.java, *property) +inline fun DatabaseWrapper.indexOn(indexName: String, + vararg property: IProperty<*>) + = index(indexName).on(T::class.java, *property) -inline fun indexOn(indexName: String, firstNameAlias: NameAlias, vararg arrayOfNameAlias: NameAlias) = Index(indexName).on(T::class.java, firstNameAlias, *arrayOfNameAlias) +inline fun DatabaseWrapper.indexOn(indexName: String, firstNameAlias: NameAlias, + vararg arrayOfNameAlias: NameAlias) + = index(indexName).on(T::class.java, firstNameAlias, *arrayOfNameAlias) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IndexedBy.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IndexedBy.kt index 3c2e07a85..863b94a29 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IndexedBy.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IndexedBy.kt @@ -15,8 +15,9 @@ class IndexedBy * @param indexProperty The index property generated. * @param whereBase The base piece of this query */ -(private val indexProperty: IndexProperty, private val whereBase: WhereBase) - : BaseTransformable(whereBase.table) { +(private val indexProperty: IndexProperty, + private val whereBase: WhereBase) + : BaseTransformable(whereBase.databaseWrapper, whereBase.table) { override val queryBuilderBase: Query get() = whereBase.queryBuilderBase diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Insert.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Insert.kt index 2cc2c8292..46973fd45 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Insert.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Insert.kt @@ -19,8 +19,9 @@ class Insert * * @param table The table to insert into */ -(table: Class) : BaseQueriable(table), Query { - +internal constructor(databaseWrapper: DatabaseWrapper, + table: Class) + : BaseQueriable(databaseWrapper, table), Query { /** * The columns to specify in this query (optional) @@ -263,19 +264,11 @@ class Insert return or(ConflictAction.IGNORE) } - override fun executeUpdateDelete(databaseWrapper: DatabaseWrapper): Long { - throw IllegalStateException("Cannot call executeUpdateDelete() from an Insert") - } - override fun executeUpdateDelete(): Long { throw IllegalStateException("Cannot call executeUpdateDelete() from an Insert") } } -inline fun insert() = Insert(T::class.java) - -fun insert(modelClass: KClass) = SQLite.insert(modelClass.java) - infix fun Insert.orReplace(into: Array, *>>) = orReplace().columnValues(*into) infix fun Insert.orRollback(into: Array, *>>) = orRollback().columnValues(*into) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/SQLite.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/SQLite.kt index b13693e4d..2dc3ceca2 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/SQLite.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/SQLite.kt @@ -1,111 +1,110 @@ +@file:JvmName("SQLite") + + package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.sql.language.property.IProperty import com.raizlabs.android.dbflow.sql.language.property.Property import com.raizlabs.android.dbflow.structure.Model +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import kotlin.reflect.KClass + + +/** + * @param properties The properties/columns to SELECT. + * @return A beginning of the SELECT statement. + */ +fun DatabaseWrapper.select(vararg properties: IProperty<*>): Select = Select(this, *properties) + +/** + * Starts a new SELECT COUNT(property1, property2, propertyn) (if properties specified) or + * SELECT COUNT(*). + * + * @param properties Optional, if specified returns the count of non-null ROWs from a specific single/group of columns. + * @return A new select statement SELECT COUNT(expression) + */ +fun DatabaseWrapper.selectCountOf(vararg properties: IProperty<*>): Select = Select(this, count(*properties)) + +inline fun DatabaseWrapper.update() = update(T::class.java) + +/** + * @param table The tablet to update. + * @return A new UPDATE statement. + */ +infix fun DatabaseWrapper.update(table: Class): Update = Update(this, table) + +/** + * @param table The table to update. + * @return A new UPDATE statement. + */ +infix fun DatabaseWrapper.update(modelClass: KClass) = update(modelClass.java) + +inline fun DatabaseWrapper.insert() = insert(T::class.java) + +/** + * @param table The table to insert. + * @return A new INSERT statement. + */ +infix fun DatabaseWrapper.insert(table: Class): Insert = Insert(this, table) + +/** + * @param table The table to insert. + * @return A new INSERT statement. + */ +infix fun DatabaseWrapper.insert(modelClass: KClass) = insert(modelClass.java) + +/** + * @return Begins a DELETE statement. + */ +fun DatabaseWrapper.delete(): Delete = Delete(this) + +/** + * Starts a DELETE statement on the specified table. + * + * @param table The table to delete from. + * @param [T] The class that implements [Model]. + * @return A [From] with specified DELETE on table. + */ +infix fun DatabaseWrapper.delete(table: Class): From = delete().from(table) + +/** + * Starts an INDEX statement on specified table. + * + * @param name The name of the index. + * @param [T] The class that implements [Model]. + * @return A new INDEX statement. + */ +fun DatabaseWrapper.index(name: String): Index = Index(this, name) + +/** + * Starts a TRIGGER statement. + * + * @param name The name of the trigger. + * @return A new TRIGGER statement. + */ +fun createTrigger(name: String): Trigger = Trigger.create(name) + +/** + * Starts a CASE statement. + * + * @param operator The condition to check for in the WHEN. + * @return A new [CaseCondition]. + */ +fun caseWhen(operator: SQLOperator): CaseCondition = Case().whenever(operator) + +/** + * Starts an efficient CASE statement. The value passed here is only evaulated once. A non-efficient + * case statement will evaluate all of its [SQLOperator]. + * + * @param caseColumn The value + */ +fun _case(caseColumn: Property): Case = Case(caseColumn) /** - * Description: The main entry point into SQLite queries. + * Starts an efficient CASE statement. The value passed here is only evaulated once. A non-efficient + * case statement will evaluate all of its [SQLOperator]. + * + * @param caseColumn The value */ -object SQLite { - - /** - * @param properties The properties/columns to SELECT. - * @return A beginning of the SELECT statement. - */ - @JvmStatic - fun select(vararg properties: IProperty<*>): Select = Select(*properties) - - /** - * Starts a new SELECT COUNT(property1, property2, propertyn) (if properties specified) or - * SELECT COUNT(*). - * - * @param properties Optional, if specified returns the count of non-null ROWs from a specific single/group of columns. - * @return A new select statement SELECT COUNT(expression) - */ - @JvmStatic - fun selectCountOf(vararg properties: IProperty<*>): Select = Select(count(*properties)) - - /** - * @param table The tablet to update. - * @param [T] The class that implements [Model]. - * @return A new UPDATE statement. - */ - @JvmStatic - fun update(table: Class): Update = Update(table) - - /** - * @param table The table to insert. - * @param [T] The class that implements [Model]. - * @return A new INSERT statement. - */ - @JvmStatic - fun insert(table: Class): Insert = Insert(table) - - /** - * @return Begins a DELETE statement. - */ - @JvmStatic - fun delete(): Delete = Delete() - - /** - * Starts a DELETE statement on the specified table. - * - * @param table The table to delete from. - * @param [T] The class that implements [Model]. - * @return A [From] with specified DELETE on table. - */ - @JvmStatic - fun delete(table: Class): From = delete().from(table) - - /** - * Starts an INDEX statement on specified table. - * - * @param name The name of the index. - * @param [T] The class that implements [Model]. - * @return A new INDEX statement. - */ - @JvmStatic - fun index(name: String): Index = Index(name) - - /** - * Starts a TRIGGER statement. - * - * @param name The name of the trigger. - * @return A new TRIGGER statement. - */ - @JvmStatic - fun createTrigger(name: String): Trigger = Trigger.create(name) - - /** - * Starts a CASE statement. - * - * @param operator The condition to check for in the WHEN. - * @return A new [CaseCondition]. - */ - @JvmStatic - fun caseWhen(operator: SQLOperator): CaseCondition = - Case().whenever(operator) - - /** - * Starts an efficient CASE statement. The value passed here is only evaulated once. A non-efficient - * case statement will evaluate all of its [SQLOperator]. - * - * @param caseColumn The value - */ - @JvmStatic - fun _case(caseColumn: Property): Case = Case(caseColumn) - - /** - * Starts an efficient CASE statement. The value passed here is only evaulated once. A non-efficient - * case statement will evaluate all of its [SQLOperator]. - * - * @param caseColumn The value - */ - @JvmStatic - fun _case(caseColumn: IProperty<*>): Case = Case(caseColumn) -} - -fun case(caseColumn: IProperty<*>) = SQLite._case(caseColumn) - -fun caseWhen(operator: SQLOperator) = SQLite.caseWhen(operator) \ No newline at end of file +@JvmName("_case") +fun case(caseColumn: IProperty<*>): Case = Case(caseColumn) \ No newline at end of file diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Select.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Select.kt index a76934e01..66a1818a0 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Select.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Select.kt @@ -3,6 +3,7 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.sql.Query import com.raizlabs.android.dbflow.sql.language.property.IProperty import com.raizlabs.android.dbflow.sql.language.property.Property +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper import kotlin.reflect.KClass /** @@ -14,7 +15,8 @@ class Select * * @param properties The properties to select from. */ -(vararg properties: IProperty<*>) : Query { +internal constructor(private val databaseWrapper: DatabaseWrapper, + vararg properties: IProperty<*>) : Query { /** * The select qualifier to append to the SELECT statement */ @@ -54,7 +56,7 @@ class Select * @param [T] The class that implements [com.raizlabs.android.dbflow.structure.Model] * @return the From part of this query */ - fun from(table: Class): From = From(this, table) + infix fun from(table: Class): From = From(databaseWrapper,this, table) inline fun from() = from(T::class.java) @@ -100,5 +102,5 @@ class Select } } -inline val select: Select - get() = SQLite.select() +inline val DatabaseWrapper.select: Select + get() = select() diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Set.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Set.kt index eb720bc5a..effae4a8e 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Set.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Set.kt @@ -4,12 +4,15 @@ import android.content.ContentValues import com.raizlabs.android.dbflow.sql.Query import com.raizlabs.android.dbflow.sql.addContentValues import com.raizlabs.android.dbflow.structure.BaseModel +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper /** * Description: Used to specify the SET part of an [com.raizlabs.android.dbflow.sql.language.Update] query. */ -class Set(override val queryBuilderBase: Query, table: Class) - : BaseTransformable(table), WhereBase { +class Set internal constructor( + databaseWrapper: DatabaseWrapper, + override val queryBuilderBase: Query, table: Class) + : BaseTransformable(databaseWrapper, table), WhereBase { private val operatorGroup: OperatorGroup = OperatorGroup.nonGroupingClause().setAllCommaSeparated(true) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Transformable.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Transformable.kt index 0252f7cc0..5faf29bfb 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Transformable.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Transformable.kt @@ -16,11 +16,11 @@ interface Transformable { fun orderBy(property: IProperty<*>, ascending: Boolean): Where - fun orderBy(orderBy: OrderBy): Where + infix fun orderBy(orderBy: OrderBy): Where - fun limit(count: Int): Where + infix fun limit(count: Int): Where - fun offset(offset: Int): Where + infix fun offset(offset: Int): Where fun having(vararg conditions: SQLOperator): Where @@ -32,10 +32,4 @@ infix fun Transformable.groupBy(nameAlias: NameAlias): Where = g infix fun Transformable.groupBy(property: IProperty<*>): Where = groupBy(property) -infix fun Transformable.orderBy(orderBy: OrderBy): Where = orderBy(orderBy) - -infix fun Transformable.limit(limit: Int): Where = limit(limit) - -infix fun Transformable.offset(offset: Int): Where = offset(offset) - infix fun Transformable.having(sqlOperator: SQLOperator): Where = having(sqlOperator) \ No newline at end of file diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Trigger.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Trigger.kt index 2694d9d75..64fa7d708 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Trigger.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Trigger.kt @@ -128,8 +128,6 @@ private constructor( } } -fun createTrigger(name: String) = Trigger.create(name) - infix fun Trigger.deleteOn(kClass: KClass) = deleteOn(kClass.java) infix fun Trigger.insertOn(kClass: KClass) = insertOn(kClass.java) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Update.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Update.kt index 8e27f6346..fab05f600 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Update.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Update.kt @@ -3,6 +3,7 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.annotation.ConflictAction import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.sql.Query +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper /** * Description: The SQLite UPDATE query. Will update rows in the DB. @@ -13,7 +14,8 @@ class Update * * @param table The table to use. */ -internal constructor(val table: Class) : Query { +internal constructor(private val databaseWrapper: DatabaseWrapper, + val table: Class) : Query { /** * The conflict action to resolve updates. @@ -74,10 +76,9 @@ internal constructor(val table: Class) : Query { * @param conditions The array of conditions that define this SET statement * @return A SET query piece of this statement */ - fun set(vararg conditions: SQLOperator): Set = Set(this, table).conditions(*conditions) + fun set(vararg conditions: SQLOperator): Set = Set(databaseWrapper, this, table) + .conditions(*conditions) } -inline fun update() = SQLite.update(T::class.java) - infix fun Update.set(sqlOperator: SQLOperator) = set(sqlOperator) \ No newline at end of file diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Where.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Where.kt index 622551f23..5e0f08e77 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Where.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Where.kt @@ -3,11 +3,9 @@ package com.raizlabs.android.dbflow.sql.language import android.database.Cursor import com.raizlabs.android.dbflow.annotation.provider.ContentProvider import com.raizlabs.android.dbflow.appendQualifier -import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.sql.language.property.IProperty import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable import com.raizlabs.android.dbflow.structure.BaseModel -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper import com.raizlabs.android.dbflow.structure.database.FlowCursor import java.util.* @@ -21,12 +19,13 @@ class Where * * @param whereBase The FROM or SET statement chunk */ -( +internal constructor( /** * The first chunk of the SQL statement before this query. */ val whereBase: WhereBase, vararg conditions: SQLOperator) - : BaseModelQueriable(whereBase.table), ModelQueriable, Transformable { + : BaseModelQueriable(whereBase.databaseWrapper, whereBase.table), + ModelQueriable, Transformable { /** * Helps to build the where statement easily @@ -160,14 +159,12 @@ class Where /** * @return the result of the query as a [Cursor]. */ - override fun query(databaseWrapper: DatabaseWrapper): FlowCursor? =// Query the sql here + override fun query(): FlowCursor? =// Query the sql here when { whereBase.queryBuilderBase is Select -> databaseWrapper.rawQuery(query, null) - else -> super.query(databaseWrapper) + else -> super.query() } - override fun query(): FlowCursor? = query(FlowManager.getDatabaseForTable(table).writableDatabase) - /** * Queries for all of the results this statement returns from a DB cursor in the form of the [T] * diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/WhereBase.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/WhereBase.kt index fde4c9e7d..9d9f77d4a 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/WhereBase.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/WhereBase.kt @@ -1,6 +1,7 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.sql.Query +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper /** * Description: The base for a [Where] statement. @@ -17,4 +18,6 @@ interface WhereBase : Query, Actionable { */ val queryBuilderBase: Query + val databaseWrapper: DatabaseWrapper + } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/IndexProperty.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/IndexProperty.kt index b48ddd12a..ed66822a9 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/IndexProperty.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/IndexProperty.kt @@ -3,7 +3,6 @@ package com.raizlabs.android.dbflow.sql.language.property import com.raizlabs.android.dbflow.annotation.Table import com.raizlabs.android.dbflow.quoteIfNeeded import com.raizlabs.android.dbflow.sql.language.Index -import com.raizlabs.android.dbflow.sql.language.SQLite import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper /** @@ -11,31 +10,24 @@ import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper * It gets generated from [Table.indexGroups], but also can be manually constructed. These are activated * and deactivated manually. */ -class IndexProperty(indexName: String, unique: Boolean, table: Class, - vararg properties: IProperty<*>) { +class IndexProperty(indexName: String, + private val unique: Boolean, + private val table: Class, + vararg properties: IProperty<*>) { - val index: Index = SQLite.index(indexName) + @Suppress("UNCHECKED_CAST") + private val properties: Array> = properties as Array> - val indexName: String - get() = index.indexName.quoteIfNeeded() ?: "" + val DatabaseWrapper.index: Index + get() = Index(this, indexName).on(table, *properties).unique(unique) - init { - index.on(table, *properties).unique(unique) - } + val indexName = indexName.quoteIfNeeded() ?: "" fun createIfNotExists(wrapper: DatabaseWrapper) { - index.enable(wrapper) - } - - fun createIfNotExists() { - index.enable() - } - - fun drop() { - index.disable() + wrapper.index.enable() } - fun drop(writableDatabase: DatabaseWrapper) { - index.disable(writableDatabase) + fun drop(wrapper: DatabaseWrapper) { + wrapper.index.disable() } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/AlterTableMigration.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/AlterTableMigration.kt index deb7b00f3..3eb5a4c9e 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/AlterTableMigration.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/AlterTableMigration.kt @@ -5,7 +5,7 @@ import com.raizlabs.android.dbflow.appendQuotedIfNeeded import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.quoteIfNeeded import com.raizlabs.android.dbflow.sql.SQLiteType -import com.raizlabs.android.dbflow.sql.language.SQLite +import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.stripQuotes import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper @@ -54,7 +54,7 @@ class AlterTableMigration( // We have column definitions to add here // ADD COLUMN columnName {type} if (internalColumnDefinitions.isNotEmpty()) { - SQLite.select().from(table).limit(0).query(database)?.use { cursor -> + (database.select from table limit 0).query()?.use { cursor -> sql = "$sql$tableName" for (i in internalColumnDefinitions.indices) { val columnDefinition = internalColumnDefinitions[i] diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/UpdateTableMigration.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/UpdateTableMigration.kt index b1392fc4a..d9a38de42 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/UpdateTableMigration.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/UpdateTableMigration.kt @@ -3,7 +3,7 @@ package com.raizlabs.android.dbflow.sql.migration import com.raizlabs.android.dbflow.sql.language.BaseQueriable import com.raizlabs.android.dbflow.sql.language.OperatorGroup import com.raizlabs.android.dbflow.sql.language.SQLOperator -import com.raizlabs.android.dbflow.sql.language.SQLite +import com.raizlabs.android.dbflow.sql.language.update import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper /** @@ -33,8 +33,8 @@ open class UpdateTableMigration */ private val setOperatorGroup: OperatorGroup by lazy { OperatorGroup.nonGroupingClause() } - val updateStatement: BaseQueriable - get() = SQLite.update(table) + val DatabaseWrapper.updateStatement: BaseQueriable + get() = update(table) .set(setOperatorGroup) .where(whereOperatorGroup) @@ -53,6 +53,6 @@ open class UpdateTableMigration } override fun migrate(database: DatabaseWrapper) { - updateStatement.execute(database) + database.updateStatement.execute() } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ModelLoader.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ModelLoader.kt index bef399ffb..434d0e9f1 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ModelLoader.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ModelLoader.kt @@ -2,8 +2,6 @@ package com.raizlabs.android.dbflow.sql.queriable import android.database.Cursor import android.database.sqlite.SQLiteDatabase - -import com.raizlabs.android.dbflow.config.DatabaseDefinition import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.structure.InstanceAdapter import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper @@ -15,23 +13,8 @@ import com.raizlabs.android.dbflow.structure.database.FlowCursor */ abstract class ModelLoader(val modelClass: Class) { - val databaseDefinition: DatabaseDefinition by lazy { FlowManager.getDatabaseForTable(modelClass) } val instanceAdapter: InstanceAdapter by lazy { FlowManager.getInstanceAdapter(modelClass) } - /** - * Loads the data from a query and returns it as a [TReturn]. - * - * @param query The query to call. - * @return The data loaded from the database. - */ - open fun load(query: String): TReturn? { - return load(databaseDefinition.writableDatabase, query) - } - - open fun load(query: String, data: TReturn?): TReturn? { - return load(databaseDefinition.writableDatabase, query, data) - } - /** * Loads the data from a query and returns it as a [TReturn]. * @@ -39,14 +22,11 @@ abstract class ModelLoader(val modelClass: Class : Queriable { */ fun queryList(): MutableList - /** - * Allows you to specify a DB, useful for migrations. - * - * @return a list of model converted items - */ - fun queryList(wrapper: DatabaseWrapper): MutableList - /** * @return Single model, the first of potentially many results */ fun querySingle(): T? - /** - * Allows you to specify a DB, useful for migrations. - * - * @return Single model, the first of potentially many results - */ - fun querySingle(wrapper: DatabaseWrapper): T? - /** * @return A cursor-backed list that handles conversion, retrieval, and caching of lists. Can * cache models dynamically by setting [FlowCursorList.setCacheModels] to true. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/Queriable.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/Queriable.kt index 4ff3d6a86..8026c0a32 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/Queriable.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/Queriable.kt @@ -7,7 +7,6 @@ import com.raizlabs.android.dbflow.sql.language.Set import com.raizlabs.android.dbflow.structure.BaseModel import com.raizlabs.android.dbflow.structure.Model import com.raizlabs.android.dbflow.structure.database.DatabaseStatement -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper import com.raizlabs.android.dbflow.structure.database.FlowCursor /** @@ -23,42 +22,16 @@ interface Queriable : Query { */ fun query(): FlowCursor? - /** - * Allows you to pass in a [DatabaseWrapper] manually. - * - * @param databaseWrapper The wrapper to pass in. - * @return A cursor from the DB based on this query - */ - fun query(databaseWrapper: DatabaseWrapper): FlowCursor? - - /** * @return A new [DatabaseStatement] from this query. */ fun compileStatement(): DatabaseStatement - /** - * @param databaseWrapper The wrapper to use. - * @return A new [DatabaseStatement] from this query with database specified. - */ - fun compileStatement(databaseWrapper: DatabaseWrapper): DatabaseStatement - /** * @return the long value of the results of query. */ fun longValue(): Long - /** - * @return the long value of the results of query. - */ - fun longValue(databaseWrapper: DatabaseWrapper): Long - - /** - * @return This may return the number of rows affected from a [Set] or [Delete] statement. - * If not, returns [Model.INVALID_ROW_ID] - */ - fun executeUpdateDelete(databaseWrapper: DatabaseWrapper): Long - /** * @return This may return the number of rows affected from a [Set] or [Delete] statement. * If not, returns [Model.INVALID_ROW_ID] @@ -71,35 +44,17 @@ interface Queriable : Query { */ fun executeInsert(): Long - /** - * @return This may return the number of rows affected from a [Insert] statement. - * If not, returns [Model.INVALID_ROW_ID] - */ - fun executeInsert(databaseWrapper: DatabaseWrapper): Long - /** * @return True if this query has data. It will run a [.count] greater than 0. */ fun hasData(): Boolean - /** - * Allows you to pass in a [DatabaseWrapper] manually. - * - * @return True if this query has data. It will run a [.count] greater than 0. - */ - fun hasData(databaseWrapper: DatabaseWrapper): Boolean - /** * Will not return a result, rather simply will execute a SQL statement. Use this for non-SELECT statements or when * you're not interested in the result. */ fun execute() - /** - * Will not return a result, rather simply will execute a SQL statement. Use this for non-SELECT statements or when - * you're not interested in the result. - */ - fun execute(databaseWrapper: DatabaseWrapper) } inline val Queriable.cursor diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/StringQuery.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/StringQuery.kt index f42e8c1bd..9eb1518b9 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/StringQuery.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/StringQuery.kt @@ -1,8 +1,6 @@ package com.raizlabs.android.dbflow.sql.queriable import android.database.sqlite.SQLiteDatabase - -import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.sql.Query import com.raizlabs.android.dbflow.sql.language.BaseModelQueriable import com.raizlabs.android.dbflow.sql.language.Delete @@ -23,24 +21,17 @@ class StringQuery * @param sql The sql statement to query the DB with. Does not work with [Delete], * this must be done with [SQLiteDatabase.execSQL] */ -(table: Class, - /** - * The full SQLite query to use - */ - override val query: String) : BaseModelQueriable(table), Query, ModelQueriable { +(databaseWrapper: DatabaseWrapper, + table: Class, + override val query: String) + : BaseModelQueriable(databaseWrapper, table), Query, ModelQueriable { private var args: Array? = null override// we don't explicitly know the change, but something changed. val primaryAction: BaseModel.Action get() = BaseModel.Action.CHANGE - override fun query(): FlowCursor? { - return query(FlowManager.getDatabaseForTable(table).writableDatabase) - } - - override fun query(databaseWrapper: DatabaseWrapper): FlowCursor? { - return databaseWrapper.rawQuery(query, args) - } + override fun query(): FlowCursor? = databaseWrapper.rawQuery(query, args) /** * Set selection arguments to execute on this raw query. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/AsyncModel.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/AsyncModel.kt deleted file mode 100644 index e85175a4a..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/AsyncModel.kt +++ /dev/null @@ -1,118 +0,0 @@ -package com.raizlabs.android.dbflow.structure - -import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.sql.BaseAsyncObject -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper -import com.raizlabs.android.dbflow.structure.database.transaction.DefaultTransactionQueue -import com.raizlabs.android.dbflow.structure.database.transaction.ProcessModelTransaction -import com.raizlabs.android.dbflow.structure.database.transaction.Transaction - -import java.lang.ref.WeakReference - -/** - * Description: Called from a [BaseModel], this places the current [Model] interaction on the background. - */ -@Deprecated("use Transactions instead") -class AsyncModel(private val model: TModel) : BaseAsyncObject>(model.javaClass), Model { - - @Transient - private var onModelChangedListener: WeakReference>? = null - - private val modelAdapter: ModelAdapter by lazy { FlowManager.getModelAdapter(model.javaClass) } - - /** - * Listens for when this [Model] modification completes. - */ - interface OnModelChangedListener { - - /** - * Called when the change finishes on the [DefaultTransactionQueue]. This method is called on the UI thread. - */ - fun onModelChanged(model: T) - } - - /** - * Call before [.save], [.delete], [.update], or [.insert]. - * - * @param onModelChangedListener The listener to use for a corresponding call to a method. - */ - fun withListener(onModelChangedListener: OnModelChangedListener?): AsyncModel { - this.onModelChangedListener = WeakReference>(onModelChangedListener) - return this - } - - override fun save(wrapper: DatabaseWrapper): Boolean = save() - - override fun save(): Boolean { - executeTransaction(ProcessModelTransaction.Builder( - object : ProcessModelTransaction.ProcessModel { - override fun processModel(model: TModel, wrapper: DatabaseWrapper) { - modelAdapter.save(model, wrapper) - } - }).add(model).build()) - return false - } - - override fun delete(wrapper: DatabaseWrapper): Boolean = delete() - - override fun delete(): Boolean { - executeTransaction(ProcessModelTransaction.Builder( - object : ProcessModelTransaction.ProcessModel { - override fun processModel(model: TModel, wrapper: DatabaseWrapper) { - modelAdapter.delete(model, wrapper) - } - }).add(model).build()) - return false - } - - override fun update(wrapper: DatabaseWrapper): Boolean = update() - - override fun update(): Boolean { - executeTransaction(ProcessModelTransaction.Builder( - object : ProcessModelTransaction.ProcessModel { - override fun processModel(model: TModel, wrapper: DatabaseWrapper) { - modelAdapter.update(model, wrapper) - } - }).add(model).build()) - return false - } - - override fun insert(wrapper: DatabaseWrapper): Long = insert() - - override fun insert(): Long { - executeTransaction(ProcessModelTransaction.Builder( - object : ProcessModelTransaction.ProcessModel { - override fun processModel(model: TModel, wrapper: DatabaseWrapper) { - modelAdapter.insert(model, wrapper) - } - }).add(model).build()) - return Model.INVALID_ROW_ID - } - - override fun load(wrapper: DatabaseWrapper) { - load() - } - - override fun load() { - executeTransaction(ProcessModelTransaction.Builder( - object : ProcessModelTransaction.ProcessModel { - override fun processModel(model: TModel, wrapper: DatabaseWrapper) { - modelAdapter.load(model, wrapper) - } - }).add(model).build()) - } - - override fun exists(wrapper: DatabaseWrapper): Boolean = exists() - - override fun exists(): Boolean = modelAdapter.exists(model) - - /** - * @return Itself since it's already async. - */ - @Suppress("UNCHECKED_CAST") - override fun async(): AsyncModel = this as AsyncModel - - override fun onSuccess(transaction: Transaction) { - onModelChangedListener?.get()?.onModelChanged(model) - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseModel.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseModel.kt index c5756ec97..4a0902d2f 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseModel.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseModel.kt @@ -51,41 +51,18 @@ open class BaseModel : Model { CHANGE } - override fun load() { - modelAdapter.load(this) + override fun DatabaseWrapper.load() { + modelAdapter.load(this@BaseModel, this) } - override fun load(wrapper: DatabaseWrapper) { - modelAdapter.load(this, wrapper) - } - - override fun save(): Boolean = modelAdapter.save(this) - - - override fun save(wrapper: DatabaseWrapper): Boolean = - modelAdapter.save(this, wrapper) - - override fun delete(): Boolean = modelAdapter.delete(this) - - override fun delete(wrapper: DatabaseWrapper): Boolean = - modelAdapter.delete(this, wrapper) - - override fun update(): Boolean = modelAdapter.update(this) - - override fun update(wrapper: DatabaseWrapper): Boolean = - modelAdapter.update(this, wrapper) - - override fun insert(): Long = modelAdapter.insert(this) - - override fun insert(wrapper: DatabaseWrapper): Long = - modelAdapter.insert(this, wrapper) + override fun DatabaseWrapper.save(): Boolean = modelAdapter.save(this@BaseModel, this) - override fun exists(): Boolean = modelAdapter.exists(this) + override fun DatabaseWrapper.delete(): Boolean = modelAdapter.delete(this@BaseModel, this) - override fun exists(wrapper: DatabaseWrapper): Boolean = - modelAdapter.exists(this, wrapper) + override fun DatabaseWrapper.update(): Boolean = modelAdapter.update(this@BaseModel, this) - override fun async(): AsyncModel = AsyncModel(this) + override fun DatabaseWrapper.insert(): Long = modelAdapter.insert(this@BaseModel, this) + override fun DatabaseWrapper.exists(): Boolean = modelAdapter.exists(this@BaseModel, this) } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseQueryModel.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseQueryModel.kt index 7c25b9fcf..b4cdcfe0f 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseQueryModel.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseQueryModel.kt @@ -9,11 +9,8 @@ import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper @Deprecated("No subclass needed. Use extension methods instead.") class BaseQueryModel : NoModificationModel() { - override fun exists(): Boolean { + override fun DatabaseWrapper.exists(): Boolean { throw NoModificationModel.InvalidSqlViewOperationException("Query " + javaClass.name + " does not exist as a table." + "It's a convenient representation of a complex SQLite query.") } - - override fun exists(wrapper: DatabaseWrapper): Boolean = exists() - } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/Model.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/Model.kt index cc4bc227a..d084bde44 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/Model.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/Model.kt @@ -3,7 +3,6 @@ package com.raizlabs.android.dbflow.structure import com.raizlabs.android.dbflow.config.modelAdapter import com.raizlabs.android.dbflow.config.writableDatabaseForTable import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper -import com.raizlabs.android.dbflow.structure.database.transaction.DefaultTransactionQueue interface Model : ReadOnlyModel { @@ -12,62 +11,28 @@ interface Model : ReadOnlyModel { * * @return true if successful */ - fun save(): Boolean - - /** - * Saves the object in the DB. - * - * @return true if successful - */ - fun save(wrapper: DatabaseWrapper): Boolean - - /** - * Deletes the object in the DB - * - * @return true if successful - */ - fun delete(): Boolean + fun DatabaseWrapper.save(): Boolean /** * Deletes the object in the DB * * @return true if successful */ - fun delete(wrapper: DatabaseWrapper): Boolean - - /** - * Updates an object in the DB. Does not insert on failure. - * - * @return true if successful - */ - fun update(): Boolean + fun DatabaseWrapper.delete(): Boolean /** * Updates an object in the DB. Does not insert on failure. * * @return true if successful */ - fun update(wrapper: DatabaseWrapper): Boolean - - /** - * Inserts the object into the DB - * - * @return the count of the rows affected, should only be 1 here, or -1 if failed. - */ - fun insert(): Long + fun DatabaseWrapper.update(): Boolean /** * Inserts the object into the DB * * @return the count of the rows affected, should only be 1 here, or -1 if failed. */ - fun insert(wrapper: DatabaseWrapper): Long - - /** - * @return An async instance of this model where all transactions are on the [DefaultTransactionQueue] - */ - @Deprecated("Use Transactions and extensions.") - fun async(): AsyncModel + fun DatabaseWrapper.insert(): Long companion object { @@ -88,5 +53,3 @@ inline fun T.update(databaseWrapper: DatabaseWrapper = writabl inline fun T.delete(databaseWrapper: DatabaseWrapper = writableDatabaseForTable()) = modelAdapter().delete(this, databaseWrapper) inline fun T.exists(databaseWrapper: DatabaseWrapper = writableDatabaseForTable()) = modelAdapter().exists(this, databaseWrapper) - -inline fun T.async() = AsyncModel(this) \ No newline at end of file diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/NoModificationModel.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/NoModificationModel.kt index 21ee210e1..521db4eec 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/NoModificationModel.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/NoModificationModel.kt @@ -11,17 +11,10 @@ abstract class NoModificationModel : ReadOnlyModel { @delegate:Transient private val retrievalAdapter: RetrievalAdapter by lazy { FlowManager.getInstanceAdapter(javaClass) } - override fun exists(): Boolean = retrievalAdapter.exists(this) + override fun DatabaseWrapper.exists(): Boolean = retrievalAdapter.exists(this@NoModificationModel, this) - override fun exists(wrapper: DatabaseWrapper): Boolean = - retrievalAdapter.exists(this, wrapper) - - override fun load() { - retrievalAdapter.load(this) - } - - override fun load(wrapper: DatabaseWrapper) { - retrievalAdapter.load(this, wrapper) + override fun DatabaseWrapper.load() { + retrievalAdapter.load(this@NoModificationModel, this) } /** diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ReadOnlyModel.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ReadOnlyModel.kt index d36b9f528..e6c419fb1 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ReadOnlyModel.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ReadOnlyModel.kt @@ -1,6 +1,5 @@ package com.raizlabs.android.dbflow.structure -import com.raizlabs.android.dbflow.sql.migration.Migration import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper interface ReadOnlyModel { @@ -8,25 +7,12 @@ interface ReadOnlyModel { /** * Loads from the database the most recent version of the model based on it's primary keys. */ - fun load() - - /** - * Loads from the database the most recent version of the model based on it's primary keys. - * - * @param wrapper Database object to use. Useful for [Migration] classes. - */ - fun load(wrapper: DatabaseWrapper) + fun DatabaseWrapper.load() /** * @return true if this object exists in the DB. It combines all of it's primary key fields * into a SELECT query and checks to see if any results occur. */ - fun exists(): Boolean + fun DatabaseWrapper.exists(): Boolean - /** - * @param wrapper Database object to use. Useful for [Migration] classes. - * @return true if this object exists in the DB. It combines all of it's primary key fields - * into a SELECT query and checks to see if any results occur. - */ - fun exists(wrapper: DatabaseWrapper): Boolean } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/RetrievalAdapter.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/RetrievalAdapter.kt index 8dffcb4e7..a3d154db9 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/RetrievalAdapter.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/RetrievalAdapter.kt @@ -5,7 +5,8 @@ import com.raizlabs.android.dbflow.config.DatabaseDefinition import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.config.TableConfig import com.raizlabs.android.dbflow.sql.language.OperatorGroup -import com.raizlabs.android.dbflow.sql.language.SQLite +import com.raizlabs.android.dbflow.sql.language.select +import com.raizlabs.android.dbflow.sql.language.where import com.raizlabs.android.dbflow.sql.queriable.ListModelLoader import com.raizlabs.android.dbflow.sql.queriable.SingleModelLoader import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper @@ -94,12 +95,11 @@ abstract class RetrievalAdapter(databaseDefinition: DatabaseDefinition) /** * Force loads the model from the DB. Even if caching is enabled it will requery the object. */ - @JvmOverloads - open fun load(model: T, databaseWrapper: DatabaseWrapper = FlowManager.getDatabaseForTable(modelClass).writableDatabase) { + open fun load(model: T, databaseWrapper: DatabaseWrapper) { nonCacheableSingleModelLoader.load(databaseWrapper, - SQLite.select() - .from(modelClass) - .where(getPrimaryConditionClause(model)).query, + (databaseWrapper.select + from modelClass + where getPrimaryConditionClause(model)).query, model) } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Couroutines.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Couroutines.kt new file mode 100644 index 000000000..33250bd4e --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Couroutines.kt @@ -0,0 +1,14 @@ +package com.raizlabs.android.dbflow.structure.database.transaction + +import com.raizlabs.android.dbflow.config.database +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import kotlinx.coroutines.experimental.async + +/** + * Performs database operations on the background in coroutines. + */ +inline suspend fun db(crossinline function: DatabaseWrapper.() -> Unit) { + async { + function(database().writableDatabase) + } +} \ No newline at end of file diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ITransaction.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ITransaction.kt index 7b671f232..2623ed012 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ITransaction.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ITransaction.kt @@ -1,8 +1,10 @@ package com.raizlabs.android.dbflow.structure.database.transaction import android.database.sqlite.SQLiteDatabaseLockedException +import com.raizlabs.android.dbflow.config.database import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import kotlinx.coroutines.experimental.async /** * Description: Simplest form of a transaction. It represents an interface by which code is executed diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/BaseProviderModel.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/BaseProviderModel.kt index ca3d2924b..5144af262 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/BaseProviderModel.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/BaseProviderModel.kt @@ -5,6 +5,7 @@ import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.sql.language.OperatorGroup import com.raizlabs.android.dbflow.structure.BaseModel import com.raizlabs.android.dbflow.structure.Model +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper import com.raizlabs.android.dbflow.structure.database.FlowCursor /** @@ -15,20 +16,20 @@ import com.raizlabs.android.dbflow.structure.database.FlowCursor */ abstract class BaseProviderModel : BaseModel(), ModelProvider { - override fun delete(): Boolean = ContentUtils.delete(deleteUri, this) > 0 + override fun DatabaseWrapper.delete(): Boolean = ContentUtils.delete(deleteUri, this@BaseProviderModel) > 0 - override fun save(): Boolean { - val count = ContentUtils.update(updateUri, this) + override fun DatabaseWrapper.save(): Boolean { + val count = ContentUtils.update(updateUri, this@BaseProviderModel) return if (count == 0) { - ContentUtils.insert(insertUri, this) != null + ContentUtils.insert(insertUri, this@BaseProviderModel) != null } else { count > 0 } } - override fun update(): Boolean = ContentUtils.update(updateUri, this) > 0 + override fun DatabaseWrapper.update(): Boolean = ContentUtils.update(updateUri, this@BaseProviderModel) > 0 - override fun insert(): Long { + override fun DatabaseWrapper.insert(): Long { ContentUtils.insert(insertUri, this) return 0 } @@ -38,9 +39,9 @@ abstract class BaseProviderModel : BaseModel(), ModelProvider { * * @return true if this model exists in the [ContentProvider] based on its primary keys. */ - override fun exists(): Boolean { + override fun DatabaseWrapper.exists(): Boolean { val cursor = ContentUtils.query(FlowManager.context.contentResolver, - queryUri, modelAdapter.getPrimaryConditionClause(this), "") + queryUri, modelAdapter.getPrimaryConditionClause(this@BaseProviderModel), "") val exists = cursor != null && cursor.count > 0 cursor?.close() return exists diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/BaseSyncableProviderModel.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/BaseSyncableProviderModel.kt index 2ce27e614..b5cf85514 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/BaseSyncableProviderModel.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/BaseSyncableProviderModel.kt @@ -6,6 +6,7 @@ import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.sql.language.OperatorGroup import com.raizlabs.android.dbflow.structure.BaseModel import com.raizlabs.android.dbflow.structure.Model +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper import com.raizlabs.android.dbflow.structure.database.FlowCursor /** @@ -14,13 +15,13 @@ import com.raizlabs.android.dbflow.structure.database.FlowCursor */ abstract class BaseSyncableProviderModel : BaseModel(), ModelProvider { - override fun insert(): Long { + override fun DatabaseWrapper.insert(): Long { val rowId = super.insert() ContentUtils.insert(insertUri, this) return rowId } - override fun save(): Boolean { + override fun DatabaseWrapper.save(): Boolean { return if (exists()) { super.save() && ContentUtils.update(updateUri, this) > 0 } else { @@ -28,9 +29,9 @@ abstract class BaseSyncableProviderModel : BaseModel(), ModelProvider { } } - override fun delete(): Boolean = super.delete() && ContentUtils.delete(deleteUri, this) > 0 + override fun DatabaseWrapper.delete(): Boolean = super.delete() && ContentUtils.delete(deleteUri, this) > 0 - override fun update(): Boolean = super.update() && ContentUtils.update(updateUri, this) > 0 + override fun DatabaseWrapper.update(): Boolean = super.update() && ContentUtils.update(updateUri, this) > 0 override fun load(whereOperatorGroup: OperatorGroup, orderBy: String?, vararg columns: String?) { From 1a55ccaf8adfe6c950898a8a93ef27f4ae7e7aac Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Thu, 23 Nov 2017 22:46:32 -0500 Subject: [PATCH 066/234] [5.0] finish conversion from using wrapper directly. --- .../android/dbflow/sql/language/Delete.kt | 58 ++++++++++--------- .../dbflow/sql/migration/IndexMigration.kt | 21 +++---- .../android/dbflow/structure/BaseModel.kt | 14 ++++- .../provider/BaseSyncableProviderModel.kt | 10 ++-- 4 files changed, 56 insertions(+), 47 deletions(-) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Delete.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Delete.kt index b71d9001b..9399bd4b1 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Delete.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Delete.kt @@ -1,6 +1,3 @@ -@file:JvmName("Delete") -@file:JvmMultifileClass - package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.sql.Query @@ -24,29 +21,36 @@ class Delete internal constructor(private val databaseWrapper: DatabaseWrapper) **/ fun from(table: Class): From = From(databaseWrapper, this, table) + companion object { + + @JvmStatic + fun DatabaseWrapper.delete(modelClass: KClass) = delete(modelClass.java) + + @JvmStatic + inline fun DatabaseWrapper.delete() = delete(T::class) + + /** + * Deletes the specified table + * + * @param table The table to delete + * @param conditions The list of conditions to use to delete from the specified table + * @param [T] The class that implements [com.raizlabs.android.dbflow.structure.Model] + */ + @JvmStatic + fun DatabaseWrapper.table(table: Class, vararg conditions: SQLOperator) { + Delete(this).from(table).where(*conditions).executeUpdateDelete() + } + + /** + * Deletes the list of tables specified. + * WARNING: this will completely clear all rows from each table. + * + * @param tables The list of tables to wipe. + */ + @JvmStatic + fun DatabaseWrapper.tables(vararg tables: Class<*>) { + tables.forEach { table(it) } + } + } } -fun DatabaseWrapper.delete(modelClass: KClass) = delete(modelClass.java) - -inline fun DatabaseWrapper.delete() = delete(T::class) - -/** - * Deletes the specified table - * - * @param table The table to delete - * @param conditions The list of conditions to use to delete from the specified table - * @param [T] The class that implements [com.raizlabs.android.dbflow.structure.Model] - */ -fun DatabaseWrapper.table(table: Class, vararg conditions: SQLOperator) { - Delete(this).from(table).where(*conditions).executeUpdateDelete() -} - -/** - * Deletes the list of tables specified. - * WARNING: this will completely clear all rows from each table. - * - * @param tables The list of tables to wipe. - */ -fun DatabaseWrapper.tables(vararg tables: Class<*>) { - tables.forEach { table(it) } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/IndexMigration.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/IndexMigration.kt index 45fa78f28..8e8113396 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/IndexMigration.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/IndexMigration.kt @@ -1,8 +1,9 @@ package com.raizlabs.android.dbflow.sql.migration -import com.raizlabs.android.dbflow.sql.language.Index +import com.raizlabs.android.dbflow.sql.language.index import com.raizlabs.android.dbflow.sql.language.property.IProperty import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import java.util.* /** * Description: Defines and enables an Index structurally through a migration. @@ -13,20 +14,14 @@ abstract class IndexMigration( */ private var onTable: Class) : BaseMigration() { - /** - * The underlying index object. - */ - val index: Index by lazy { Index(name).on(onTable) } + private var unique: Boolean = false + private val columns: ArrayList> = arrayListOf() abstract val name: String - /** - * @return the query backing this migration. - */ - val indexQuery: String - get() = index.query - override fun migrate(database: DatabaseWrapper) { + val index = database.index(name).on(onTable).unique(unique) + columns.forEach { index.and(it) } database.execSQL(index.query) } @@ -37,7 +32,7 @@ abstract class IndexMigration( * @return This migration */ fun addColumn(property: IProperty<*>) = apply { - index.and(property) + columns.add(property) } /** @@ -46,7 +41,7 @@ abstract class IndexMigration( * @return This migration. */ fun unique() = apply { - index.unique(true) + unique = true } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseModel.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseModel.kt index 4a0902d2f..be7b79d43 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseModel.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseModel.kt @@ -55,9 +55,9 @@ open class BaseModel : Model { modelAdapter.load(this@BaseModel, this) } - override fun DatabaseWrapper.save(): Boolean = modelAdapter.save(this@BaseModel, this) + override fun DatabaseWrapper.save(): Boolean = saveModel() - override fun DatabaseWrapper.delete(): Boolean = modelAdapter.delete(this@BaseModel, this) + override fun DatabaseWrapper.delete(): Boolean = deleteModel() override fun DatabaseWrapper.update(): Boolean = modelAdapter.update(this@BaseModel, this) @@ -65,4 +65,14 @@ open class BaseModel : Model { override fun DatabaseWrapper.exists(): Boolean = modelAdapter.exists(this@BaseModel, this) + protected fun DatabaseWrapper.saveModel(): Boolean = modelAdapter.save(this@BaseModel, this) + + protected fun DatabaseWrapper.deleteModel(): Boolean = modelAdapter.delete(this@BaseModel, this) + + protected fun DatabaseWrapper.updateModel(): Boolean = modelAdapter.update(this@BaseModel, this) + + protected fun DatabaseWrapper.insertModel(): Long = modelAdapter.insert(this@BaseModel, this) + + protected fun DatabaseWrapper.existsModel(): Boolean = modelAdapter.exists(this@BaseModel, this) + } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/BaseSyncableProviderModel.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/BaseSyncableProviderModel.kt index b5cf85514..3c379cde1 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/BaseSyncableProviderModel.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/BaseSyncableProviderModel.kt @@ -16,22 +16,22 @@ import com.raizlabs.android.dbflow.structure.database.FlowCursor abstract class BaseSyncableProviderModel : BaseModel(), ModelProvider { override fun DatabaseWrapper.insert(): Long { - val rowId = super.insert() + val rowId = insertModel() ContentUtils.insert(insertUri, this) return rowId } override fun DatabaseWrapper.save(): Boolean { return if (exists()) { - super.save() && ContentUtils.update(updateUri, this) > 0 + saveModel() && ContentUtils.update(updateUri, this) > 0 } else { - super.save() && ContentUtils.insert(insertUri, this) != null + saveModel() && ContentUtils.insert(insertUri, this) != null } } - override fun DatabaseWrapper.delete(): Boolean = super.delete() && ContentUtils.delete(deleteUri, this) > 0 + override fun DatabaseWrapper.delete(): Boolean = deleteModel() && ContentUtils.delete(deleteUri, this) > 0 - override fun DatabaseWrapper.update(): Boolean = super.update() && ContentUtils.update(updateUri, this) > 0 + override fun DatabaseWrapper.update(): Boolean = updateModel() && ContentUtils.update(updateUri, this) > 0 override fun load(whereOperatorGroup: OperatorGroup, orderBy: String?, vararg columns: String?) { From ed42bd54285a11d52184108ef4463e1b626c3795 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Fri, 24 Nov 2017 16:38:30 -0500 Subject: [PATCH 067/234] [5.0] use wrapper everywhere in db and fix compilation. --- build.gradle | 2 +- .../dbflow/annotation/ModelViewQuery.kt | 2 +- .../dbflow/processor/definition/Methods.kt | 44 ++-- .../definition/ModelViewDefinition.kt | 28 ++- .../definition/OneToManyDefinition.kt | 29 ++- .../processor/definition/TableDefinition.kt | 20 +- .../definition/column/ColumnAccessCombiner.kt | 4 +- .../column/ForeignKeyAccessCombiner.kt | 2 +- .../dbflow/processor/utils/ProcessorUtils.kt | 1 + dbflow-rx-kotlinextensions/build.gradle | 22 -- dbflow-rx-kotlinextensions/gradle.properties | 3 - .../src/main/AndroidManifest.xml | 5 - .../rx/kotlinextensions/QueryExtensions.kt | 82 -------- dbflow-rx/build.gradle | 2 + .../rx/language/CursorResultSubscriber.java | 99 --------- .../rx/language/CursorResultSubscriber.kt | 76 +++++++ .../dbflow/rx/language/RXModelQueriable.java | 98 --------- .../dbflow/rx/language/RXModelQueriable.kt | 81 ++++++++ .../rx/language/RXModelQueriableImpl.java | 156 -------------- .../rx/language/RXModelQueriableImpl.kt | 48 +++++ .../dbflow/rx/language/RXQueriable.java | 117 ----------- .../android/dbflow/rx/language/RXQueriable.kt | 64 ++++++ .../dbflow/rx/language/RXQueriableImpl.java | 190 ----------------- .../dbflow/rx/language/RXQueriableImpl.kt | 37 ++++ .../android/dbflow/rx/language/RXSQLite.java | 22 -- .../android/dbflow/rx/language/RXSQLite.kt | 13 ++ .../dbflow/rx/structure/BaseRXModel.java | 96 --------- .../dbflow/rx/structure/BaseRXModel.kt | 44 ++++ .../dbflow/rx/structure/RXModelAdapter.java | 189 ----------------- .../dbflow/rx/structure/RXModelAdapter.kt | 90 +++++++++ .../rx/structure/RXRetrievalAdapter.java | 77 ------- .../dbflow/rx/structure/RXRetrievalAdapter.kt | 41 ++++ dbflow-rx2-kotlinextensions/build.gradle | 22 -- dbflow-rx2-kotlinextensions/gradle.properties | 3 - .../src/main/AndroidManifest.xml | 5 - .../rx2/kotlinextensions/QueryExtensions.kt | 79 -------- dbflow-rx2/build.gradle | 2 + .../rx2/language/CursorResultFlowable.java | 110 ---------- .../rx2/language/CursorResultFlowable.kt | 84 ++++++++ .../dbflow/rx2/language/RXModelQueriable.java | 100 --------- .../dbflow/rx2/language/RXModelQueriable.kt | 88 ++++++++ .../rx2/language/RXModelQueriableImpl.java | 157 -------------- .../rx2/language/RXModelQueriableImpl.kt | 48 +++++ .../dbflow/rx2/language/RXQueriable.java | 119 ----------- .../dbflow/rx2/language/RXQueriable.kt | 67 ++++++ .../dbflow/rx2/language/RXQueriableImpl.java | 191 ------------------ .../dbflow/rx2/language/RXQueriableImpl.kt | 34 ++++ .../android/dbflow/rx2/language/RXSQLite.java | 25 --- .../android/dbflow/rx2/language/RXSQLite.kt | 11 + .../rx2/language/TableChangeOnSubscribe.java | 78 ------- .../rx2/language/TableChangeOnSubscribe.kt | 61 ++++++ .../dbflow/rx2/structure/BaseRXModel.java | 82 -------- .../dbflow/rx2/structure/BaseRXModel.kt | 44 ++++ .../dbflow/rx2/structure/RXModelAdapter.java | 191 ------------------ .../dbflow/rx2/structure/RXModelAdapter.kt | 91 +++++++++ .../rx2/structure/RXRetrievalAdapter.java | 77 ------- .../rx2/structure/RXRetrievalAdapter.kt | 41 ++++ dbflow-tests/build.gradle | 2 - .../contentobserver/ContentObserverTest.kt | 7 +- .../dbflow/prepackaged/PrepackagedDBTest.kt | 8 +- .../android/dbflow/sqlcipher/CipherTest.kt | 18 +- .../contentprovider/ContentProviderTests.kt | 35 ++-- .../FastStoreModelTransactionTest.kt | 56 ++--- .../dbflow/list/FlowCursorIteratorTest.kt | 54 ++--- .../android/dbflow/list/FlowCursorListTest.kt | 67 +++--- .../android/dbflow/list/FlowQueryListTest.kt | 16 +- .../dbflow/models/CachingModelsTest.kt | 6 +- .../dbflow/models/DontCreateModelTest.kt | 3 +- .../android/dbflow/models/ModelViewTest.kt | 10 +- .../android/dbflow/models/ModelViews.kt | 12 +- .../dbflow/models/OneToManyModelTest.kt | 10 +- .../android/dbflow/models/OneToManyModels.kt | 16 +- .../dbflow/models/ParentChildCachingTest.kt | 6 +- .../android/dbflow/models/QueryModelTest.kt | 6 +- .../android/dbflow/models/issue/Issue.java | 7 +- .../android/dbflow/models/issue/SubIssue.java | 8 +- .../dbflow/models/java/JavaModelView.java | 8 +- .../dbflow/runtime/DirectNotifierTest.kt | 3 +- .../rx/language/CursorResultSubscriberTest.kt | 4 +- .../dbflow/rx/language/RXQueryTests.kt | 13 +- .../dbflow/sql/language/CursorResultTest.kt | 3 +- .../android/dbflow/sql/language/DeleteTest.kt | 9 +- .../sql/language/ExistenceOperatorTest.kt | 3 +- .../android/dbflow/sql/language/FromTest.kt | 12 +- .../android/dbflow/sql/language/IndexTest.kt | 7 +- .../dbflow/sql/language/IndexedByTest.kt | 3 +- .../android/dbflow/sql/language/InsertTest.kt | 34 ++-- .../android/dbflow/sql/language/JoinTest.kt | 15 +- .../dbflow/sql/language/OperatorTest.kt | 6 +- .../android/dbflow/sql/language/SelectTest.kt | 12 +- .../android/dbflow/sql/language/SetTest.kt | 17 +- .../dbflow/sql/language/TriggerTest.kt | 7 +- .../sql/language/UnsafeStringOperatorTest.kt | 3 +- .../android/dbflow/sql/language/UpdateTest.kt | 15 +- .../android/dbflow/sql/language/WhereTest.kt | 30 +-- .../language/property/IndexPropertyTest.kt | 9 +- .../language/property/PropertyFactoryTest.kt | 5 +- .../dbflow/sql/queriable/AsyncQueryTest.kt | 7 +- dbflow/build.gradle | 2 +- .../android/dbflow/config/FlowManager.kt | 28 ++- .../android/dbflow/list/FlowCursorList.kt | 7 +- .../dbflow/sql/language/BaseModelQueriable.kt | 2 +- .../dbflow/sql/language/CursorResult.kt | 22 +- .../android/dbflow/sql/language/Delete.kt | 5 +- .../android/dbflow/sql/language/SQLite.kt | 2 + .../android/dbflow/sql/language/Set.kt | 10 + .../sql/queriable/CacheableListModelLoader.kt | 10 +- .../sql/queriable/CacheableModelLoader.kt | 8 +- .../dbflow/sql/queriable/ListModelLoader.kt | 11 +- .../dbflow/sql/queriable/ModelLoader.kt | 10 +- .../SingleKeyCacheableListModelLoader.kt | 8 +- .../SingleKeyCacheableModelLoader.kt | 8 +- .../dbflow/sql/queriable/SingleModelLoader.kt | 10 +- .../android/dbflow/structure/BaseModel.kt | 14 +- .../dbflow/structure/BaseQueryModel.kt | 4 +- .../android/dbflow/structure/Model.kt | 11 +- .../android/dbflow/structure/ModelAdapter.kt | 6 +- .../dbflow/structure/ModelViewAdapter.kt | 3 +- .../dbflow/structure/NoModificationModel.kt | 6 +- .../android/dbflow/structure/ReadOnlyModel.kt | 4 +- .../dbflow/structure/RetrievalAdapter.kt | 2 +- .../structure/database/BaseDatabaseHelper.kt | 2 +- .../structure/provider/BaseProviderModel.kt | 28 +-- .../provider/BaseSyncableProviderModel.kt | 28 +-- .../dbflow/structure/provider/ContentUtils.kt | 19 +- .../structure/provider/ModelProvider.kt | 7 +- settings.gradle | 2 +- 127 files changed, 1624 insertions(+), 2821 deletions(-) delete mode 100644 dbflow-rx-kotlinextensions/build.gradle delete mode 100644 dbflow-rx-kotlinextensions/gradle.properties delete mode 100644 dbflow-rx-kotlinextensions/src/main/AndroidManifest.xml delete mode 100644 dbflow-rx-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/rx/kotlinextensions/QueryExtensions.kt delete mode 100644 dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriber.java create mode 100644 dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriber.kt delete mode 100644 dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXModelQueriable.java create mode 100644 dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXModelQueriable.kt delete mode 100644 dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXModelQueriableImpl.java create mode 100644 dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXModelQueriableImpl.kt delete mode 100644 dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXQueriable.java create mode 100644 dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXQueriable.kt delete mode 100644 dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXQueriableImpl.java create mode 100644 dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXQueriableImpl.kt delete mode 100644 dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXSQLite.java create mode 100644 dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXSQLite.kt delete mode 100644 dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/structure/BaseRXModel.java create mode 100644 dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/structure/BaseRXModel.kt delete mode 100644 dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/structure/RXModelAdapter.java create mode 100644 dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/structure/RXModelAdapter.kt delete mode 100644 dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/structure/RXRetrievalAdapter.java create mode 100644 dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/structure/RXRetrievalAdapter.kt delete mode 100644 dbflow-rx2-kotlinextensions/build.gradle delete mode 100644 dbflow-rx2-kotlinextensions/gradle.properties delete mode 100644 dbflow-rx2-kotlinextensions/src/main/AndroidManifest.xml delete mode 100644 dbflow-rx2-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/rx2/kotlinextensions/QueryExtensions.kt delete mode 100644 dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/CursorResultFlowable.java create mode 100644 dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/CursorResultFlowable.kt delete mode 100644 dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXModelQueriable.java create mode 100644 dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXModelQueriable.kt delete mode 100644 dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXModelQueriableImpl.java create mode 100644 dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXModelQueriableImpl.kt delete mode 100644 dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXQueriable.java create mode 100644 dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXQueriable.kt delete mode 100644 dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXQueriableImpl.java create mode 100644 dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXQueriableImpl.kt delete mode 100644 dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXSQLite.java create mode 100644 dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXSQLite.kt delete mode 100644 dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/TableChangeOnSubscribe.java create mode 100644 dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/TableChangeOnSubscribe.kt delete mode 100644 dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/structure/BaseRXModel.java create mode 100644 dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/structure/BaseRXModel.kt delete mode 100644 dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/structure/RXModelAdapter.java create mode 100644 dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/structure/RXModelAdapter.kt delete mode 100644 dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/structure/RXRetrievalAdapter.java create mode 100644 dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/structure/RXRetrievalAdapter.kt diff --git a/build.gradle b/build.gradle index 38276b36e..1a47b29b4 100644 --- a/build.gradle +++ b/build.gradle @@ -1,5 +1,5 @@ buildscript { - ext.kotlin_version = '1.1.60' + ext.kotlin_version = '1.1.61' repositories { jcenter() google() diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ModelViewQuery.kt b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ModelViewQuery.kt index 241a7c678..c748ba946 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ModelViewQuery.kt +++ b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ModelViewQuery.kt @@ -7,6 +7,6 @@ import com.raizlabs.android.dbflow.sql.Query * reference in [ModelView]. This is so the annotation processor knows how to access the query of * the view. */ -@Target(AnnotationTarget.FIELD) +@Target(AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER) @Retention(AnnotationRetention.SOURCE) annotation class ModelViewQuery diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/Methods.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/Methods.kt index 13b0e3e4c..63180e710 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/Methods.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/Methods.kt @@ -442,7 +442,8 @@ class LoadFromCursorMethod(private val baseTableDefinition: BaseTableDefinition) override val methodSpec: MethodSpec get() = `override fun`(TypeName.VOID, "loadFromCursor", param(ClassNames.FLOW_CURSOR, PARAM_CURSOR), - param(baseTableDefinition.parameterClassName!!, ModelUtils.variable)) { + param(baseTableDefinition.parameterClassName!!, ModelUtils.variable), + param(ClassNames.DATABASE_WRAPPER, ModelUtils.wrapper)) { modifiers(public, final) val index = AtomicInteger(0) val nameAllocator = NameAllocator() // unique names @@ -452,9 +453,6 @@ class LoadFromCursorMethod(private val baseTableDefinition: BaseTableDefinition) } if (baseTableDefinition is TableDefinition) { - val foundDef = baseTableDefinition.oneToManyDefinitions.find { it.hasWrapper } - foundDef?.let { foundDef.writeWrapperStatement(this) } - code { baseTableDefinition.oneToManyDefinitions .filter { it.isLoad } @@ -479,8 +477,7 @@ class LoadFromCursorMethod(private val baseTableDefinition: BaseTableDefinition) /** * Description: */ -class OneToManyDeleteMethod(private val tableDefinition: TableDefinition, - private val useWrapper: Boolean) : MethodDefinition { +class OneToManyDeleteMethod(private val tableDefinition: TableDefinition) : MethodDefinition { override val methodSpec: MethodSpec? get() { @@ -489,21 +486,14 @@ class OneToManyDeleteMethod(private val tableDefinition: TableDefinition, return `override fun`(TypeName.BOOLEAN, "delete", param(tableDefinition.elementClassName!!, ModelUtils.variable)) { modifiers(public, final) - if (useWrapper) { - addParameter(ClassNames.DATABASE_WRAPPER, ModelUtils.wrapper) - } + addParameter(ClassNames.DATABASE_WRAPPER, ModelUtils.wrapper) if (tableDefinition.cachingEnabled) { statement("getModelCache().removeModel(getCachingId(${ModelUtils.variable}))") } - statement("boolean successful = super.delete(${ModelUtils.variable}${wrapperCommaIfBaseModel(useWrapper)})") - - if (!useWrapper) { - val foundDef = tableDefinition.oneToManyDefinitions.find { it.hasWrapper } - foundDef?.let { foundDef.writeWrapperStatement(this) } - } + statement("boolean successful = super.delete(${ModelUtils.variable}${wrapperCommaIfBaseModel(true)})") - tableDefinition.oneToManyDefinitions.forEach { it.writeDelete(this, useWrapper) } + tableDefinition.oneToManyDefinitions.forEach { it.writeDelete(this) } `return`("successful") } @@ -516,8 +506,7 @@ class OneToManyDeleteMethod(private val tableDefinition: TableDefinition, * Description: Overrides the save, update, and insert methods if the [com.raizlabs.android.dbflow.annotation.OneToMany.Method.SAVE] is used. */ class OneToManySaveMethod(private val tableDefinition: TableDefinition, - private val methodName: String, - private val useWrapper: Boolean) : MethodDefinition { + private val methodName: String) : MethodDefinition { override val methodSpec: MethodSpec? get() { @@ -534,17 +523,14 @@ class OneToManySaveMethod(private val tableDefinition: TableDefinition, return `override fun`(retType, methodName, param(tableDefinition.elementClassName!!, ModelUtils.variable)) { modifiers(public, final) - - if (useWrapper) { - addParameter(ClassNames.DATABASE_WRAPPER, ModelUtils.wrapper) - } + addParameter(ClassNames.DATABASE_WRAPPER, ModelUtils.wrapper) code { if (methodName == METHOD_INSERT) { add("long rowId = ") } else if (methodName == METHOD_UPDATE || methodName == METHOD_SAVE) { add("boolean successful = ") } - statement("super.$methodName(${ModelUtils.variable}${wrapperCommaIfBaseModel(useWrapper)})") + statement("super.$methodName(${ModelUtils.variable}${wrapperCommaIfBaseModel(true)})") if (tableDefinition.cachingEnabled) { statement("getModelCache().addModel(getCachingId(${ModelUtils.variable}), ${ModelUtils.variable})") @@ -552,17 +538,11 @@ class OneToManySaveMethod(private val tableDefinition: TableDefinition, this } - // need wrapper access if we have wrapper param here. - if (!useWrapper) { - val foundDef = tableDefinition.oneToManyDefinitions.find { it.hasWrapper } - foundDef?.let { foundDef.writeWrapperStatement(this) } - } - for (oneToManyDefinition in tableDefinition.oneToManyDefinitions) { when (methodName) { - METHOD_SAVE -> oneToManyDefinition.writeSave(this, useWrapper) - METHOD_UPDATE -> oneToManyDefinition.writeUpdate(this, useWrapper) - METHOD_INSERT -> oneToManyDefinition.writeInsert(this, useWrapper) + METHOD_SAVE -> oneToManyDefinition.writeSave(this) + METHOD_UPDATE -> oneToManyDefinition.writeUpdate(this) + METHOD_INSERT -> oneToManyDefinition.writeInsert(this) } } diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/ModelViewDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/ModelViewDefinition.kt index d5d6eabfc..dbd44ec79 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/ModelViewDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/ModelViewDefinition.kt @@ -6,6 +6,7 @@ import com.grosner.kpoet.`public static final field` import com.grosner.kpoet.`return` import com.grosner.kpoet.final import com.grosner.kpoet.modifiers +import com.grosner.kpoet.param import com.grosner.kpoet.public import com.raizlabs.android.dbflow.annotation.Column import com.raizlabs.android.dbflow.annotation.ColumnMap @@ -17,17 +18,20 @@ import com.raizlabs.android.dbflow.processor.ProcessorManager import com.raizlabs.android.dbflow.processor.definition.column.ColumnDefinition import com.raizlabs.android.dbflow.processor.definition.column.ReferenceColumnDefinition import com.raizlabs.android.dbflow.processor.utils.ElementUtility +import com.raizlabs.android.dbflow.processor.utils.ModelUtils import com.raizlabs.android.dbflow.processor.utils.`override fun` import com.raizlabs.android.dbflow.processor.utils.annotation import com.raizlabs.android.dbflow.processor.utils.ensureVisibleStatic import com.raizlabs.android.dbflow.processor.utils.implementsClass import com.raizlabs.android.dbflow.processor.utils.isNullOrEmpty import com.raizlabs.android.dbflow.processor.utils.simpleString +import com.raizlabs.android.dbflow.processor.utils.toTypeElement import com.raizlabs.android.dbflow.processor.utils.toTypeErasedElement import com.squareup.javapoet.ParameterizedTypeName import com.squareup.javapoet.TypeName import com.squareup.javapoet.TypeSpec import javax.lang.model.element.Element +import javax.lang.model.element.ExecutableElement import javax.lang.model.element.TypeElement import javax.lang.model.type.MirroredTypeException @@ -43,7 +47,7 @@ class ModelViewDefinition(manager: ProcessorManager, element: Element) : BaseTab private var name: String? = null private val methods: Array = - arrayOf(LoadFromCursorMethod(this), ExistenceMethod(this), PrimaryConditionMethod(this)) + arrayOf(LoadFromCursorMethod(this), ExistenceMethod(this), PrimaryConditionMethod(this)) var allFields: Boolean = false @@ -69,7 +73,7 @@ class ModelViewDefinition(manager: ProcessorManager, element: Element) : BaseTab if (element is TypeElement) { implementsLoadFromCursorListener = element.implementsClass(manager.processingEnvironment, - ClassNames.LOAD_FROM_CURSOR_LISTENER) + ClassNames.LOAD_FROM_CURSOR_LISTENER) } else { implementsLoadFromCursorListener = false } @@ -106,7 +110,7 @@ class ModelViewDefinition(manager: ProcessorManager, element: Element) : BaseTab val isColumnMap = variableElement.annotation() != null if (variableElement.annotation() != null || isValidAllFields - || isColumnMap) { + || isColumnMap) { // package private, will generate helper val isPackagePrivate = ElementUtility.isPackagePrivate(variableElement) @@ -133,11 +137,14 @@ class ModelViewDefinition(manager: ProcessorManager, element: Element) : BaseTab if (!queryFieldName.isNullOrEmpty()) { manager.logError("Found duplicate queryField name: $queryFieldName for $elementClassName") } - ensureVisibleStatic(variableElement, typeElement, "ModelViewQuery") - val element = variableElement.toTypeErasedElement() - if (!element.implementsClass(manager.processingEnvironment, ClassNames.QUERY)) { - manager.logError("The field ${variableElement.simpleName} must implement ${ClassNames.QUERY}") + val element = variableElement.toTypeErasedElement() as? ExecutableElement + if (element != null) { + val returnElement = element.returnType.toTypeElement() + ensureVisibleStatic(element, typeElement, "ModelViewQuery") + if (!returnElement.implementsClass(manager.processingEnvironment, ClassNames.QUERY)) { + manager.logError("The function ${variableElement.simpleName} must return ${ClassNames.QUERY} from $elementName") + } } queryFieldName = variableElement.simpleString @@ -167,9 +174,10 @@ class ModelViewDefinition(manager: ProcessorManager, element: Element) : BaseTab writeGetModelClass(typeBuilder, elementClassName) - `override fun`(String::class, "getCreationQuery") { + `override fun`(String::class, "getCreationQuery", + param(ClassNames.DATABASE_WRAPPER, ModelUtils.wrapper)) { modifiers(public, final) - `return`("\$T.\$L.getQuery()", elementClassName, queryFieldName) + `return`("\$T.\$L(${ModelUtils.wrapper}).getQuery()", elementClassName, queryFieldName) } `override fun`(String::class, "getViewName") { modifiers(public, final) @@ -183,7 +191,7 @@ class ModelViewDefinition(manager: ProcessorManager, element: Element) : BaseTab } methods.mapNotNull { it.methodSpec } - .forEach { typeBuilder.addMethod(it) } + .forEach { typeBuilder.addMethod(it) } } } \ No newline at end of file diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/OneToManyDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/OneToManyDefinition.kt index 515414a53..4cd191fbe 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/OneToManyDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/OneToManyDefinition.kt @@ -142,11 +142,6 @@ class OneToManyDefinition(executableElement: ExecutableElement, private val methodName = "${ModelUtils.variable}.$_methodName(${wrapperIfBaseModel(hasWrapper)})" - fun writeWrapperStatement(method: MethodSpec.Builder) { - method.statement("\$T ${ModelUtils.wrapper} = \$T.getWritableDatabaseForTable(\$T.class)", - ClassNames.DATABASE_WRAPPER, ClassNames.FLOW_MANAGER, referencedTableType) - } - /** * Writes the method to the specified builder for loading from DB. */ @@ -159,26 +154,26 @@ class OneToManyDefinition(executableElement: ExecutableElement, /** * Writes a delete method that will delete all related objects. */ - fun writeDelete(method: MethodSpec.Builder, useWrapper: Boolean) { + fun writeDelete(method: MethodSpec.Builder) { if (isDelete) { - writeLoopWithMethod(method, "delete", useWrapper) + writeLoopWithMethod(method, "delete") method.statement(columnAccessor.set(CodeBlock.of("null"), modelBlock)) } } - fun writeSave(codeBuilder: MethodSpec.Builder, useWrapper: Boolean) { - if (isSave) writeLoopWithMethod(codeBuilder, "save", useWrapper) + fun writeSave(codeBuilder: MethodSpec.Builder) { + if (isSave) writeLoopWithMethod(codeBuilder, "save") } - fun writeUpdate(codeBuilder: MethodSpec.Builder, useWrapper: Boolean) { - if (isSave) writeLoopWithMethod(codeBuilder, "update", useWrapper) + fun writeUpdate(codeBuilder: MethodSpec.Builder) { + if (isSave) writeLoopWithMethod(codeBuilder, "update") } - fun writeInsert(codeBuilder: MethodSpec.Builder, useWrapper: Boolean) { - if (isSave) writeLoopWithMethod(codeBuilder, "insert", useWrapper) + fun writeInsert(codeBuilder: MethodSpec.Builder) { + if (isSave) writeLoopWithMethod(codeBuilder, "insert") } - private fun writeLoopWithMethod(codeBuilder: MethodSpec.Builder, methodName: String, useWrapper: Boolean) { + private fun writeLoopWithMethod(codeBuilder: MethodSpec.Builder, methodName: String) { val oneToManyMethodName = this@OneToManyDefinition.methodName codeBuilder.apply { `if`("$oneToManyMethodName != null") { @@ -190,13 +185,13 @@ class OneToManyDefinition(executableElement: ExecutableElement, } if (efficientCodeMethods) { - statement("adapter.${methodName}All($oneToManyMethodName${wrapperCommaIfBaseModel(useWrapper)})") + statement("adapter.${methodName}All($oneToManyMethodName${wrapperCommaIfBaseModel(true)})") } else { `for`("\$T value: $oneToManyMethodName", ClassName.get(referencedType)) { if (!extendsModel) { - statement("adapter.$methodName(value${wrapperCommaIfBaseModel(useWrapper)})") + statement("adapter.$methodName(value${wrapperCommaIfBaseModel(true)})") } else { - statement("value.$methodName(${wrapperIfBaseModel(useWrapper)})") + statement("value.$methodName(${wrapperIfBaseModel(true)})") } this } diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/TableDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/TableDefinition.kt index 6936cb825..e8d83169d 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/TableDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/TableDefinition.kt @@ -174,15 +174,14 @@ class TableDefinition(manager: ProcessorManager, element: TypeElement) : BaseTab BindToStatementMethod(this, UPDATE), BindToStatementMethod(this, DELETE), InsertStatementQueryMethod(this, true), InsertStatementQueryMethod(this, false), UpdateStatementQueryMethod(this), DeleteStatementQueryMethod(this), - CreationQueryMethod(this), LoadFromCursorMethod(this), ExistenceMethod(this), - PrimaryConditionMethod(this), OneToManyDeleteMethod(this, false), - OneToManyDeleteMethod(this, true), - OneToManySaveMethod(this, OneToManySaveMethod.METHOD_SAVE, false), - OneToManySaveMethod(this, OneToManySaveMethod.METHOD_INSERT, false), - OneToManySaveMethod(this, OneToManySaveMethod.METHOD_UPDATE, false), - OneToManySaveMethod(this, OneToManySaveMethod.METHOD_SAVE, true), - OneToManySaveMethod(this, OneToManySaveMethod.METHOD_INSERT, true), - OneToManySaveMethod(this, OneToManySaveMethod.METHOD_UPDATE, true)) + CreationQueryMethod(this), + LoadFromCursorMethod(this), + ExistenceMethod(this), + PrimaryConditionMethod(this), + OneToManyDeleteMethod(this), + OneToManySaveMethod(this, OneToManySaveMethod.METHOD_SAVE), + OneToManySaveMethod(this, OneToManySaveMethod.METHOD_INSERT), + OneToManySaveMethod(this, OneToManySaveMethod.METHOD_UPDATE)) } override fun prepareForWrite() { @@ -624,7 +623,8 @@ class TableDefinition(manager: ProcessorManager, element: TypeElement) : BaseTab if (foreignKeyDefinitions.isNotEmpty()) { `override fun`(TypeName.VOID, "reloadRelationships", param(elementClassName!!, ModelUtils.variable), - param(ClassNames.FLOW_CURSOR, LoadFromCursorMethod.PARAM_CURSOR)) { + param(ClassNames.FLOW_CURSOR, LoadFromCursorMethod.PARAM_CURSOR), + param(ClassNames.DATABASE_WRAPPER, ModelUtils.wrapper)) { modifiers(public, final) code { val noIndex = AtomicInteger(-1) diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ColumnAccessCombiner.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ColumnAccessCombiner.kt index a2175e94f..3a69b80fd 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ColumnAccessCombiner.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ColumnAccessCombiner.kt @@ -110,9 +110,9 @@ class ExistenceAccessCombiner(combiner: Combiner, add("return ") } - add("\$T.selectCountOf()\n.from(\$T.class)\n" + + add("\$T.selectCountOf(wrapper)\n.from(\$T.class)\n" + ".where(getPrimaryConditionClause(\$L))\n" + - ".hasData(wrapper)", + ".hasData()", ClassNames.SQLITE, tableClassName, modelBlock) } add(";\n") diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ForeignKeyAccessCombiner.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ForeignKeyAccessCombiner.kt index 3d99419ce..3b0969111 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ForeignKeyAccessCombiner.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ForeignKeyAccessCombiner.kt @@ -69,7 +69,7 @@ class ForeignKeyLoadFromCursorCombiner(val fieldAccessor: ColumnAccessor, val setterBlock = CodeBlock.builder() if (!isStubbed) { - setterBlock.add("\$T.select().from(\$T.class).where()", + setterBlock.add("\$T.select(wrapper).from(\$T.class).where()", ClassNames.SQLITE, referencedTypeName) } else { setterBlock.statement( diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/utils/ProcessorUtils.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/utils/ProcessorUtils.kt index 9d35a41c9..b1832ccb9 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/utils/ProcessorUtils.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/utils/ProcessorUtils.kt @@ -108,3 +108,4 @@ fun ensureVisibleStatic(element: Element, typeElement: TypeElement, manager.logError("The $name must be final") } } + diff --git a/dbflow-rx-kotlinextensions/build.gradle b/dbflow-rx-kotlinextensions/build.gradle deleted file mode 100644 index 225aeaadc..000000000 --- a/dbflow-rx-kotlinextensions/build.gradle +++ /dev/null @@ -1,22 +0,0 @@ -apply plugin: 'com.android.library' -apply plugin: 'kotlin-android' - -project.ext.artifactId = bt_name - -android { - compileSdkVersion Integer.valueOf(dbflow_target_sdk) - buildToolsVersion dbflow_build_tools_version - - defaultConfig { - minSdkVersion dbflow_min_sdk_rx - targetSdkVersion Integer.valueOf(dbflow_target_sdk) - } -} - -dependencies { - api project("${dbflow_project_prefix}dbflow") - api project("${dbflow_project_prefix}dbflow-rx") - api "org.jetbrains.kotlin:kotlin-stdlib-jre7:$kotlin_version" -} - -apply from: '../kotlin-artifacts.gradle' diff --git a/dbflow-rx-kotlinextensions/gradle.properties b/dbflow-rx-kotlinextensions/gradle.properties deleted file mode 100644 index c06522005..000000000 --- a/dbflow-rx-kotlinextensions/gradle.properties +++ /dev/null @@ -1,3 +0,0 @@ -bt_name=dbflow-rx-kotlinextensions -bt_packaging=aar -bt_artifact_id=dbflow-rx-kotlinextensions diff --git a/dbflow-rx-kotlinextensions/src/main/AndroidManifest.xml b/dbflow-rx-kotlinextensions/src/main/AndroidManifest.xml deleted file mode 100644 index 903cee5f9..000000000 --- a/dbflow-rx-kotlinextensions/src/main/AndroidManifest.xml +++ /dev/null @@ -1,5 +0,0 @@ - - - - - diff --git a/dbflow-rx-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/rx/kotlinextensions/QueryExtensions.kt b/dbflow-rx-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/rx/kotlinextensions/QueryExtensions.kt deleted file mode 100644 index f9d144a8f..000000000 --- a/dbflow-rx-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/rx/kotlinextensions/QueryExtensions.kt +++ /dev/null @@ -1,82 +0,0 @@ -package com.raizlabs.android.dbflow.rx.kotlinextensions - -import android.database.Cursor -import com.raizlabs.android.dbflow.rx.language.RXModelQueriable -import com.raizlabs.android.dbflow.rx.language.RXQueriable -import com.raizlabs.android.dbflow.rx.language.RXSQLite -import com.raizlabs.android.dbflow.rx.structure.BaseRXModel -import com.raizlabs.android.dbflow.sql.language.BaseQueriable -import com.raizlabs.android.dbflow.sql.language.CursorResult -import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable -import com.raizlabs.android.dbflow.sql.queriable.Queriable -import com.raizlabs.android.dbflow.structure.database.DatabaseStatement -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper -import rx.Subscription - -fun ModelQueriable.rx() = RXSQLite.rx(this) - -fun BaseQueriable.rxBaseQueriable() = RXSQLite.rx(table, this) - -inline fun Queriable.rx() = RXSQLite.rx(T::class.java, this) - -// queriable extensions - -inline val RXQueriable.cursor - get() = query() - -inline val RXQueriable.hasData - get() = hasData() - -inline val RXQueriable.statement - get() = compileStatement() - -inline val RXModelQueriable.list - get() = queryList() - -inline val RXModelQueriable.result - get() = querySingle() - -inline val RXModelQueriable.cursorResult - get() = queryResults() - -inline val RXModelQueriable.streamResults - get() = queryStreamResults() - -inline val RXModelQueriable.tableChanges - get() = observeOnTableChanges() - -// model extensions - -fun BaseRXModel.save(databaseWrapper: DatabaseWrapper, func: (Boolean) -> Unit): Subscription = save(databaseWrapper).subscribe { func(it) } - -infix inline fun BaseRXModel.save(crossinline func: (Boolean) -> Unit): Subscription = save().subscribe { func(it) } - -fun BaseRXModel.insert(databaseWrapper: DatabaseWrapper, func: (Long) -> Unit): Subscription = insert(databaseWrapper).subscribe { func(it) } - -infix inline fun BaseRXModel.insert(crossinline func: (Long) -> Unit): Subscription = insert().subscribe { func(it) } - -fun BaseRXModel.update(databaseWrapper: DatabaseWrapper, func: (Boolean) -> Unit): Subscription = update(databaseWrapper).subscribe { func(it) } - -infix inline fun BaseRXModel.update(crossinline func: (Boolean) -> Unit): Subscription = update().subscribe { func(it) } - -fun BaseRXModel.delete(databaseWrapper: DatabaseWrapper, func: (Boolean) -> Unit): Subscription = delete(databaseWrapper).subscribe { func(it) } - -infix inline fun BaseRXModel.delete(crossinline func: (Boolean) -> Unit): Subscription = delete().subscribe { func(it) } - -// async extensions - -infix inline fun RXModelQueriable.list(crossinline func: (MutableList) -> Unit): Subscription = list.subscribe { func(it) } - -infix inline fun RXModelQueriable.result(crossinline func: (T?) -> Unit): Subscription = result.subscribe { func(it) } - -infix inline fun RXModelQueriable.streamResults(crossinline func: (T?) -> Unit): Subscription = streamResults.subscribe { func(it) } - -infix inline fun RXModelQueriable.cursorResult(crossinline func: (CursorResult) -> Unit): Subscription = cursorResult.subscribe { func(it) } - -infix inline fun RXModelQueriable.tableChanges(crossinline func: (ModelQueriable) -> Unit): Subscription = tableChanges.subscribe { func(it) } - -infix inline fun RXQueriable.statement(crossinline func: (DatabaseStatement) -> Unit): Subscription = statement.subscribe { func(it) } - -infix inline fun RXQueriable.hasData(crossinline func: (Boolean) -> Unit): Subscription = hasData.subscribe { func(it) } - -infix inline fun RXQueriable.cursor(crossinline func: (Cursor) -> Unit): Subscription = cursor.subscribe { func(it) } diff --git a/dbflow-rx/build.gradle b/dbflow-rx/build.gradle index 0ba3716bd..cc6f35f92 100644 --- a/dbflow-rx/build.gradle +++ b/dbflow-rx/build.gradle @@ -1,4 +1,5 @@ apply plugin: 'com.android.library' +apply plugin: 'kotlin-android' project.ext.artifactId = bt_name @@ -20,6 +21,7 @@ android { dependencies { api project("${dbflow_project_prefix}dbflow") api 'io.reactivex:rxjava:1.2.7' + api "org.jetbrains.kotlin:kotlin-stdlib-jre8:$kotlin_version" } apply from: '../android-artifacts.gradle' diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriber.java b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriber.java deleted file mode 100644 index db0f5fd63..000000000 --- a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriber.java +++ /dev/null @@ -1,99 +0,0 @@ -package com.raizlabs.android.dbflow.rx.language; - -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.config.FlowLog; -import com.raizlabs.android.dbflow.list.FlowCursorIterator; -import com.raizlabs.android.dbflow.sql.language.CursorResult; - -import java.util.concurrent.atomic.AtomicLong; - -import rx.Observable; -import rx.Producer; -import rx.Subscriber; -import rx.functions.Action1; -import rx.internal.operators.BackpressureUtils; - -/** - * Description: Wraps a {@link RXModelQueriable} into a {@link Observable.OnSubscribe} - * for each element represented by the query. - */ -public class CursorResultSubscriber implements Observable.OnSubscribe { - - @NonNull - private final RXModelQueriable modelQueriable; - - public CursorResultSubscriber(@NonNull RXModelQueriable modelQueriable) { - this.modelQueriable = modelQueriable; - } - - @Override - public void call(Subscriber subscriber) { - subscriber.setProducer(new ElementProducer(subscriber)); - } - - private class ElementProducer implements Producer { - - private final Subscriber subscriber; - private final AtomicLong emitted; - private final AtomicLong requested; - - ElementProducer(Subscriber subscriber) { - this.subscriber = subscriber; - requested = new AtomicLong(); - emitted = new AtomicLong(); - } - - @Override - public void request(final long n) { - if (n == Long.MAX_VALUE && requested.compareAndSet(0, Long.MAX_VALUE) - || n > 0 && BackpressureUtils.getAndAddRequest(requested, n) == 0) { - // emitting all elements - modelQueriable.queryResults().subscribe(new CursorResultAction(n)); - } - } - - private class CursorResultAction implements Action1> { - - private final long limit; - - private CursorResultAction(long limit) { - this.limit = limit; - } - - @Override - public void call(CursorResult ts) { - final int starting = limit == Long.MAX_VALUE && requested.compareAndSet(0, Long.MAX_VALUE) - ? 0 : emitted.intValue(); - long limit = this.limit + starting; - - while (limit > 0) { - FlowCursorIterator iterator = ts.iterator(starting, limit); - try { - long i = 0; - while (!subscriber.isUnsubscribed() && iterator.hasNext() && i++ < limit) { - subscriber.onNext(iterator.next()); - } - emitted.addAndGet(i); - // no more items - if (!subscriber.isUnsubscribed() && i < limit) { - subscriber.onCompleted(); - break; - } - limit = requested.addAndGet(-limit); - } catch (Exception e) { - FlowLog.logError(e); - subscriber.onError(e); - } finally { - try { - iterator.close(); - } catch (Exception e) { - FlowLog.logError(e); - subscriber.onError(e); - } - } - } - } - } - } -} diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriber.kt b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriber.kt new file mode 100644 index 000000000..4408f95a7 --- /dev/null +++ b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriber.kt @@ -0,0 +1,76 @@ +package com.raizlabs.android.dbflow.rx.language + +import com.raizlabs.android.dbflow.config.FlowLog +import com.raizlabs.android.dbflow.sql.language.CursorResult +import rx.Observable +import rx.Producer +import rx.Subscriber +import rx.functions.Action1 +import rx.internal.operators.BackpressureUtils +import java.util.concurrent.atomic.AtomicLong + +/** + * Description: Wraps a [RXModelQueriable] into a [Observable.OnSubscribe] + * for each element represented by the query. + */ +class CursorResultSubscriber(private val modelQueriable: RXModelQueriable) : Observable.OnSubscribe { + + override fun call(subscriber: Subscriber) { + subscriber.setProducer(ElementProducer(subscriber)) + } + + private inner class ElementProducer internal constructor(private val subscriber: Subscriber) : Producer { + private val emitted: AtomicLong = AtomicLong() + private val requested: AtomicLong = AtomicLong() + + override fun request(n: Long) { + if (n == java.lang.Long.MAX_VALUE + && requested.compareAndSet(0, java.lang.Long.MAX_VALUE) + || n > 0 && BackpressureUtils.getAndAddRequest(requested, n) == 0L) { + // emitting all elements + modelQueriable.queryResults().subscribe(CursorResultAction(n)) + } + } + + private inner class CursorResultAction + internal constructor(private val limit: Long) : Action1> { + + override fun call(ts: CursorResult) { + val starting = when { + limit == java.lang.Long.MAX_VALUE + && requested.compareAndSet(0, java.lang.Long.MAX_VALUE) -> 0 + else -> emitted.toInt() + } + var limit = this.limit + starting + + while (limit > 0) { + val iterator = ts.iterator(starting, limit) + try { + var i: Long = 0 + while (!subscriber.isUnsubscribed && iterator.hasNext() && i++ < limit) { + subscriber.onNext(iterator.next()) + } + emitted.addAndGet(i) + // no more items + if (!subscriber.isUnsubscribed && i < limit) { + subscriber.onCompleted() + break + } + limit = requested.addAndGet(-limit) + } catch (e: Exception) { + FlowLog.logError(e) + subscriber.onError(e) + } finally { + try { + iterator.close() + } catch (e: Exception) { + FlowLog.logError(e) + subscriber.onError(e) + } + + } + } + } + } + } +} diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXModelQueriable.java b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXModelQueriable.java deleted file mode 100644 index ae39d35ce..000000000 --- a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXModelQueriable.java +++ /dev/null @@ -1,98 +0,0 @@ -package com.raizlabs.android.dbflow.rx.language; - -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.list.FlowCursorList; -import com.raizlabs.android.dbflow.list.FlowQueryList; -import com.raizlabs.android.dbflow.sql.language.CursorResult; -import com.raizlabs.android.dbflow.sql.language.Join; -import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable; -import com.raizlabs.android.dbflow.structure.BaseQueryModel; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; - -import java.util.List; - -import rx.Observable; -import rx.Single; - -/** - * Description: Mirrors {@link ModelQueriable} with RX constructs. - */ -public interface RXModelQueriable extends RXQueriable { - - @NonNull - Single> queryResults(); - - @NonNull - Single> queryList(); - - @NonNull - Single> queryList(DatabaseWrapper wrapper); - - /** - * @return Single model, the first of potentially many results - */ - @NonNull - Single querySingle(); - - /** - * Allows you to specify a DB, useful for migrations. - * - * @return Single model, the first of potentially many results - */ - @NonNull - Single querySingle(DatabaseWrapper wrapper); - - /** - * @return Queries for {@link #queryResults()}, and returns one at a time from this {@link Observable} - */ - @NonNull - Observable queryStreamResults(); - - /** - * @return the table that this query comes from. - */ - @NonNull - Class getTable(); - - /** - * @return A cursor-backed list that handles conversion, retrieval, and caching of lists. Can - * cache models dynamically by setting {@link FlowCursorList#setCacheModels(boolean)} to true. - */ - @NonNull - Single> cursorList(); - - /** - * @return A cursor-backed {@link List} that handles conversion, retrieval, caching, content changes, - * and more. - */ - @NonNull - Single> flowQueryList(); - - /** - * Returns a {@link List} based on the custom {@link TQueryModel} you pass in. - * - * @param queryModelClass The query model class to use. - * @param The class that extends {@link BaseQueryModel} - * @return A list of custom models that are not tied to a table. - */ - @NonNull - Single> queryCustomList(Class queryModelClass); - - /** - * Returns a single {@link TQueryModel} from this query. - * - * @param queryModelClass The class to use. - * @param The class that extends {@link BaseQueryModel} - * @return A single model from the query. - */ - @NonNull - Single queryCustomSingle(Class queryModelClass); - - /** - * @return A new {@link Observable} that observes when the {@link TModel} table changes. - * This can also be multiple tables, given if it results from a {@link Join} (one for each join table). - */ - @NonNull - Observable> observeOnTableChanges(); -} \ No newline at end of file diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXModelQueriable.kt b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXModelQueriable.kt new file mode 100644 index 000000000..64b80ca5e --- /dev/null +++ b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXModelQueriable.kt @@ -0,0 +1,81 @@ +package com.raizlabs.android.dbflow.rx.language + +import com.raizlabs.android.dbflow.list.FlowCursorList +import com.raizlabs.android.dbflow.list.FlowQueryList +import com.raizlabs.android.dbflow.sql.language.CursorResult +import com.raizlabs.android.dbflow.sql.language.Join +import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable +import com.raizlabs.android.dbflow.structure.BaseQueryModel +import rx.Observable +import rx.Single + +/** + * Description: Mirrors [ModelQueriable] with RX constructs. + */ +interface RXModelQueriable : RXQueriable { + + fun queryResults(): Single> + + fun queryList(): Single> + + /** + * @return Single model, the first of potentially many results + */ + fun querySingle(): Single + + /** + * @return Queries for [.queryResults], and returns one at a time from this [Observable] + */ + fun queryStreamResults(): Observable + + /** + * @return A cursor-backed list that handles conversion, retrieval, and caching of lists. Can + * cache models dynamically by setting [FlowCursorList.setCacheModels] to true. + */ + fun cursorList(): Single> + + /** + * @return A cursor-backed [List] that handles conversion, retrieval, caching, content changes, + * and more. + */ + fun flowQueryList(): Single> + + /** + * Returns a [List] based on the custom [TQueryModel] you pass in. + * + * @param queryModelClass The query model class to use. + * @param The class that extends [BaseQueryModel] + * @return A list of custom models that are not tied to a table. + */ + fun queryCustomList(queryModelClass: Class): Single> + + /** + * Returns a single [TQueryModel] from this query. + * + * @param queryModelClass The class to use. + * @param The class that extends [BaseQueryModel] + * @return A single model from the query. + */ + fun queryCustomSingle(queryModelClass: Class): Single + + /** + * @return A new [Observable] that observes when the [T] table changes. + * This can also be multiple tables, given if it results from a [Join] (one for each join table). + */ + fun observeOnTableChanges(): Observable> +} + +inline val RXModelQueriable.list + get() = queryList() + +inline val RXModelQueriable.result + get() = querySingle() + +inline val RXModelQueriable.cursorResult + get() = queryResults() + +inline val RXModelQueriable.streamResults + get() = queryStreamResults() + +inline val RXModelQueriable.tableChanges + get() = observeOnTableChanges() \ No newline at end of file diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXModelQueriableImpl.java b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXModelQueriableImpl.java deleted file mode 100644 index 724786959..000000000 --- a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXModelQueriableImpl.java +++ /dev/null @@ -1,156 +0,0 @@ -package com.raizlabs.android.dbflow.rx.language; - -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.list.FlowCursorList; -import com.raizlabs.android.dbflow.list.FlowQueryList; -import com.raizlabs.android.dbflow.sql.language.BaseModelQueriable; -import com.raizlabs.android.dbflow.sql.language.CursorResult; -import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; - -import java.util.List; -import java.util.concurrent.Callable; - -import rx.Emitter; -import rx.Observable; -import rx.Single; - -import static rx.Single.fromCallable; - -/** - * Description: Represents {@link BaseModelQueriable} in RX form. - */ -public class RXModelQueriableImpl extends RXQueriableImpl implements RXModelQueriable { - - private final ModelQueriable modelQueriable; - - RXModelQueriableImpl(ModelQueriable modelQueriable) { - super(modelQueriable.getTable(), modelQueriable); - this.modelQueriable = modelQueriable; - } - - private ModelQueriable getInnerModelQueriable() { - return modelQueriable; - } - - @NonNull - @Override - public Observable queryStreamResults() { - return Observable.create(new CursorResultSubscriber<>(this)); - } - - @NonNull - @Override - public Single> queryResults() { - return fromCallable(new Callable>() { - @Override - public CursorResult call() throws Exception { - return getInnerModelQueriable().queryResults(); - } - }); - } - - @NonNull - @Override - public Single> queryList() { - return fromCallable(new Callable>() { - @Override - public List call() throws Exception { - return getInnerModelQueriable().queryList(); - } - }); - } - - @NonNull - @Override - public Single> queryList(final DatabaseWrapper wrapper) { - return fromCallable(new Callable>() { - @Override - public List call() throws Exception { - return getInnerModelQueriable().queryList(wrapper); - } - }); - } - - @NonNull - @Override - public Single querySingle() { - return fromCallable(new Callable() { - @Override - public T call() throws Exception { - return getInnerModelQueriable().querySingle(); - } - }); - } - - @NonNull - @Override - public Single querySingle(final DatabaseWrapper wrapper) { - return fromCallable(new Callable() { - @Override - public T call() throws Exception { - return getInnerModelQueriable().querySingle(wrapper); - } - }); - } - - @NonNull - @Override - public Class getTable() { - return getInnerModelQueriable().getTable(); - } - - @NonNull - @Override - public Single> cursorList() { - return fromCallable(new Callable>() { - @Override - public FlowCursorList call() throws Exception { - return getInnerModelQueriable().cursorList(); - } - }); - } - - @NonNull - @Override - public Single> flowQueryList() { - return fromCallable(new Callable>() { - @Override - public FlowQueryList call() throws Exception { - return getInnerModelQueriable().flowQueryList(); - } - }); - } - - @NonNull - @Override - public Single> queryCustomList( - final Class tQueryModelClass) { - return fromCallable(new Callable>() { - @Override - public List call() throws Exception { - return getInnerModelQueriable().queryCustomList(tQueryModelClass); - } - }); - } - - @NonNull - @Override - public Single queryCustomSingle( - final Class tQueryModelClass) { - return fromCallable(new Callable() { - @Override - public TQueryModel call() throws Exception { - return getInnerModelQueriable().queryCustomSingle(tQueryModelClass); - } - }); - } - - @NonNull - @Override - public Observable> observeOnTableChanges() { - return Observable.create(new TableChangeListenerEmitter<>(getInnerModelQueriable()), - Emitter.BackpressureMode.LATEST); - } -} diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXModelQueriableImpl.kt b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXModelQueriableImpl.kt new file mode 100644 index 000000000..793c39ca1 --- /dev/null +++ b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXModelQueriableImpl.kt @@ -0,0 +1,48 @@ +package com.raizlabs.android.dbflow.rx.language + +import com.raizlabs.android.dbflow.list.FlowCursorList +import com.raizlabs.android.dbflow.list.FlowQueryList +import com.raizlabs.android.dbflow.sql.language.BaseModelQueriable +import com.raizlabs.android.dbflow.sql.language.CursorResult +import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable +import rx.Emitter +import rx.Observable +import rx.Single +import rx.Single.fromCallable + +/** + * Description: Represents [BaseModelQueriable] in RX form. + */ +class RXModelQueriableImpl internal +constructor(private val innerModelQueriable: ModelQueriable) + : RXQueriableImpl(innerModelQueriable), RXModelQueriable { + + override fun queryStreamResults(): Observable = + Observable.create(CursorResultSubscriber(this)) + + override fun queryResults(): Single> = + fromCallable { innerModelQueriable.queryResults() } + + override fun queryList(): Single> = fromCallable { innerModelQueriable.queryList() } + + override fun querySingle(): Single = fromCallable { innerModelQueriable.querySingle() } + + override fun cursorList(): Single> = + fromCallable { innerModelQueriable.cursorList() } + + override fun flowQueryList(): Single> = + fromCallable { innerModelQueriable.flowQueryList() } + + override fun queryCustomList( + queryModelClass: Class): Single> = + fromCallable { innerModelQueriable.queryCustomList(queryModelClass) } + + override fun queryCustomSingle( + queryModelClass: Class): Single = + fromCallable { innerModelQueriable.queryCustomSingle(queryModelClass) } + + override fun observeOnTableChanges(): Observable> { + return Observable.create(TableChangeListenerEmitter(innerModelQueriable), + Emitter.BackpressureMode.LATEST) + } +} diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXQueriable.java b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXQueriable.java deleted file mode 100644 index ce97de927..000000000 --- a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXQueriable.java +++ /dev/null @@ -1,117 +0,0 @@ -package com.raizlabs.android.dbflow.rx.language; - -import android.database.Cursor; -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.sql.language.Delete; -import com.raizlabs.android.dbflow.sql.language.Insert; -import com.raizlabs.android.dbflow.sql.language.Set; -import com.raizlabs.android.dbflow.sql.queriable.Queriable; -import com.raizlabs.android.dbflow.structure.Model; -import com.raizlabs.android.dbflow.structure.database.DatabaseStatement; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; - -import rx.Single; - -/** - * Description: Mirrors {@link Queriable} with RX constructs. - */ -public interface RXQueriable { - - /** - * @return An {@link Single} from the DB based on this query - */ - @NonNull - Single query(); - - /** - * Allows you to pass in a {@link DatabaseWrapper} manually. - * - * @param databaseWrapper The wrapper to pass in. - * @return An {@link Single} from the DB based on this query - */ - @NonNull - Single query(DatabaseWrapper databaseWrapper); - - - /** - * @return An {@link Single} of {@link DatabaseStatement} from this query. - */ - @NonNull - Single compileStatement(); - - /** - * @param databaseWrapper The wrapper to use. - * @return An {@link Single} of {@link DatabaseStatement} from this query with database specified. - */ - @NonNull - Single compileStatement(DatabaseWrapper databaseWrapper); - - /** - * @return the long value of this query. - **/ - @NonNull - Single longValue(); - - /** - * @return the long value of this query. - **/ - @NonNull - Single longValue(DatabaseWrapper databaseWrapper); - - /** - * @return This may return the number of rows affected from a {@link Insert} statement. - * If not, returns {@link Model#INVALID_ROW_ID} - */ - @NonNull - Single executeInsert(); - - /** - * @return This may return the number of rows affected from a {@link Insert} statement. - * If not, returns {@link Model#INVALID_ROW_ID} - */ - @NonNull - Single executeInsert(DatabaseWrapper databaseWrapper); - - /** - * @return This may return the number of rows affected from a {@link Set} or {@link Delete} statement. - * If not, returns {@link Model#INVALID_ROW_ID} - */ - @NonNull - Single executeUpdateDelete(DatabaseWrapper databaseWrapper); - - /** - * @return This may return the number of rows affected from a {@link Set} or {@link Delete} statement. - * If not, returns {@link Model#INVALID_ROW_ID} - */ - @NonNull - Single executeUpdateDelete(); - - /** - * @return True if this query has data. It will run a {@link #count()} greater than 0. - */ - @NonNull - Single hasData(); - - /** - * Allows you to pass in a {@link DatabaseWrapper} manually. - * - * @return True if this query has data. It will run a {@link #count()} greater than 0. - */ - @NonNull - Single hasData(DatabaseWrapper databaseWrapper); - - /** - * Will not return a result, rather simply will execute a SQL statement. Use this for non-SELECT statements or when - * you're not interested in the result. - */ - @NonNull - Single execute(); - - /** - * Will not return a result, rather simply will execute a SQL statement. Use this for non-SELECT statements or when - * you're not interested in the result. - */ - @NonNull - Single execute(DatabaseWrapper databaseWrapper); -} diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXQueriable.kt b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXQueriable.kt new file mode 100644 index 000000000..e5fdea760 --- /dev/null +++ b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXQueriable.kt @@ -0,0 +1,64 @@ +package com.raizlabs.android.dbflow.rx.language + +import android.database.Cursor +import com.raizlabs.android.dbflow.sql.language.Delete +import com.raizlabs.android.dbflow.sql.language.Insert +import com.raizlabs.android.dbflow.sql.language.Set +import com.raizlabs.android.dbflow.sql.queriable.Queriable +import com.raizlabs.android.dbflow.structure.Model +import com.raizlabs.android.dbflow.structure.database.DatabaseStatement +import rx.Single + +/** + * Description: Mirrors [Queriable] with RX constructs. + */ +interface RXQueriable { + + /** + * @return An [Single] from the DB based on this query + */ + fun query(): Single + + /** + * @return An [Single] of [DatabaseStatement] from this query. + */ + fun compileStatement(): Single + + /** + * @return the long value of this query. + */ + fun longValue(): Single + + /** + * @return This may return the number of rows affected from a [Insert] statement. + * If not, returns [Model.INVALID_ROW_ID] + */ + fun executeInsert(): Single + + /** + * @return This may return the number of rows affected from a [Set] or [Delete] statement. + * If not, returns [Model.INVALID_ROW_ID] + */ + fun executeUpdateDelete(): Single + + /** + * @return True if this query has data. It will run a [.count] greater than 0. + */ + fun hasData(): Single + + /** + * Will not return a result, rather simply will execute a SQL statement. Use this for non-SELECT statements or when + * you're not interested in the result. + */ + fun execute(): Single + +} + +inline val RXQueriable.cursor + get() = query() + +inline val RXQueriable.hasData + get() = hasData() + +inline val RXQueriable.statement + get() = compileStatement() \ No newline at end of file diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXQueriableImpl.java b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXQueriableImpl.java deleted file mode 100644 index cb51f5f9e..000000000 --- a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXQueriableImpl.java +++ /dev/null @@ -1,190 +0,0 @@ -package com.raizlabs.android.dbflow.rx.language; - -import android.database.Cursor; -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.config.FlowManager; -import com.raizlabs.android.dbflow.sql.language.BaseQueriable; -import com.raizlabs.android.dbflow.sql.queriable.Queriable; -import com.raizlabs.android.dbflow.structure.database.DatabaseStatement; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; - -import java.util.concurrent.Callable; - -import rx.Single; - -import static rx.Single.fromCallable; - -/** - * Description: Represents {@link BaseQueriable} with RX constructs. - */ -public class RXQueriableImpl implements RXQueriable { - - private final Class table; - private final Queriable queriable; - - RXQueriableImpl(Class table, Queriable queriable) { - this.table = table; - this.queriable = queriable; - } - - private Queriable getInnerQueriable() { - return queriable; - } - - @NonNull - @Override - public Single query() { - return fromCallable(new Callable() { - @Override - public Cursor call() throws Exception { - return getInnerQueriable().query(); - } - }); - } - - @NonNull - @Override - public Single query(final DatabaseWrapper databaseWrapper) { - return fromCallable(new Callable() { - @Override - public Cursor call() throws Exception { - return getInnerQueriable().query(databaseWrapper); - } - }); - } - - @NonNull - @Override - public Single compileStatement() { - return fromCallable(new Callable() { - @Override - public DatabaseStatement call() throws Exception { - return getInnerQueriable().compileStatement(); - } - }); - } - - @NonNull - @Override - public Single compileStatement(final DatabaseWrapper databaseWrapper) { - return fromCallable(new Callable() { - @Override - public DatabaseStatement call() throws Exception { - return getInnerQueriable().compileStatement(databaseWrapper); - } - }); - } - - @NonNull - @Override - public Single longValue() { - return fromCallable(new Callable() { - @Override - public Long call() throws Exception { - return getInnerQueriable().longValue(); - } - }); - } - - @NonNull - @Override - public Single longValue(final DatabaseWrapper databaseWrapper) { - return fromCallable(new Callable() { - @Override - public Long call() throws Exception { - return getInnerQueriable().longValue(databaseWrapper); - } - }); - } - - @NonNull - @Override - public Single executeInsert() { - return fromCallable(new Callable() { - @Override - public Long call() throws Exception { - return getInnerQueriable().executeInsert(FlowManager.getWritableDatabaseForTable(table)); - } - }); - } - - @NonNull - @Override - public Single executeInsert(final DatabaseWrapper databaseWrapper) { - return fromCallable(new Callable() { - @Override - public Long call() throws Exception { - return getInnerQueriable().executeInsert(databaseWrapper); - } - }); - } - - @NonNull - @Override - public Single executeUpdateDelete(final DatabaseWrapper databaseWrapper) { - return fromCallable(new Callable() { - @Override - public Long call() throws Exception { - return getInnerQueriable().executeUpdateDelete(databaseWrapper); - } - }); - } - - @NonNull - @Override - public Single executeUpdateDelete() { - return fromCallable(new Callable() { - @Override - public Long call() throws Exception { - return getInnerQueriable().executeUpdateDelete(); - } - }); - } - - @NonNull - @Override - public Single hasData() { - return fromCallable(new Callable() { - @Override - public Boolean call() throws Exception { - return getInnerQueriable().hasData(); - } - }); - } - - @NonNull - @Override - public Single hasData(final DatabaseWrapper databaseWrapper) { - return fromCallable(new Callable() { - @Override - public Boolean call() throws Exception { - return getInnerQueriable().hasData(databaseWrapper); - } - }); - } - - @NonNull - @Override - public Single execute() { - return fromCallable(new Callable() { - @Override - public Void call() throws Exception { - getInnerQueriable().execute(); - return null; - } - }); - } - - @NonNull - @Override - public Single execute(final DatabaseWrapper databaseWrapper) { - return fromCallable(new Callable() { - @Override - public Void call() throws Exception { - getInnerQueriable().execute(databaseWrapper); - return null; - } - }); - } -} diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXQueriableImpl.kt b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXQueriableImpl.kt new file mode 100644 index 000000000..7e19d61c8 --- /dev/null +++ b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXQueriableImpl.kt @@ -0,0 +1,37 @@ +package com.raizlabs.android.dbflow.rx.language + +import android.database.Cursor +import com.raizlabs.android.dbflow.sql.language.BaseQueriable +import com.raizlabs.android.dbflow.sql.queriable.Queriable +import com.raizlabs.android.dbflow.structure.database.DatabaseStatement +import rx.Single +import rx.Single.fromCallable + +/** + * Description: Represents [BaseQueriable] with RX constructs. + */ +open class RXQueriableImpl internal constructor( + private val innerQueriable: Queriable) : RXQueriable { + + override fun query(): Single = fromCallable { innerQueriable.query() } + + override fun compileStatement(): Single = + fromCallable { innerQueriable.compileStatement() } + + override fun longValue(): Single = fromCallable { innerQueriable.longValue() } + + override fun executeInsert(): Single = + fromCallable { innerQueriable.executeInsert() } + + override fun executeUpdateDelete(): Single = + fromCallable { innerQueriable.executeUpdateDelete() } + + override fun hasData(): Single = fromCallable { innerQueriable.hasData() } + + override fun execute(): Single { + return fromCallable { + innerQueriable.execute() + null + } + } +} diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXSQLite.java b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXSQLite.java deleted file mode 100644 index aeafc9fbf..000000000 --- a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXSQLite.java +++ /dev/null @@ -1,22 +0,0 @@ -package com.raizlabs.android.dbflow.rx.language; - -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable; -import com.raizlabs.android.dbflow.sql.queriable.Queriable; - -/** - * Description: Main entry point to wrap our queries in RX. - */ -public class RXSQLite { - - @NonNull - public static RXModelQueriableImpl rx(ModelQueriable modelQueriable) { - return new RXModelQueriableImpl<>(modelQueriable); - } - - @NonNull - public static RXQueriableImpl rx(Class table, Queriable queriable) { - return new RXQueriableImpl(table, queriable); - } -} diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXSQLite.kt b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXSQLite.kt new file mode 100644 index 000000000..606caa1d4 --- /dev/null +++ b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXSQLite.kt @@ -0,0 +1,13 @@ +@file:JvmName("RXSQLite") + +package com.raizlabs.android.dbflow.rx.language + +import com.raizlabs.android.dbflow.sql.language.BaseQueriable +import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable +import com.raizlabs.android.dbflow.sql.queriable.Queriable + +fun ModelQueriable.rx(): RXModelQueriableImpl = RXModelQueriableImpl(this) + +fun Queriable.rx(): RXQueriableImpl = RXQueriableImpl(this) + +fun BaseQueriable.rxBaseQueriable() = rx() diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/structure/BaseRXModel.java b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/structure/BaseRXModel.java deleted file mode 100644 index be2d94817..000000000 --- a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/structure/BaseRXModel.java +++ /dev/null @@ -1,96 +0,0 @@ -package com.raizlabs.android.dbflow.rx.structure; - -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.annotation.ColumnIgnore; -import com.raizlabs.android.dbflow.config.FlowManager; -import com.raizlabs.android.dbflow.structure.BaseModel; -import com.raizlabs.android.dbflow.structure.InvalidDBConfiguration; -import com.raizlabs.android.dbflow.structure.ModelAdapter; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; - -import rx.Completable; -import rx.Single; - -/** - * Description: Similar to {@link BaseModel} with RX constructs. Extend this for convenience methods. - */ -@SuppressWarnings("unchecked") -public class BaseRXModel { - - @ColumnIgnore - private transient RXModelAdapter modelAdapter; - - @NonNull - public Single save() { - return getRXModelAdapter().save(this); - } - - @NonNull - public Single save(DatabaseWrapper databaseWrapper) { - return getRXModelAdapter().save(this, databaseWrapper); - } - - @NonNull - public Completable load() { - return getRXModelAdapter().load(this); - } - - @NonNull - public Completable load(DatabaseWrapper databaseWrapper) { - return getRXModelAdapter().load(this, databaseWrapper); - } - - @NonNull - public Single delete() { - return getRXModelAdapter().delete(this); - } - - @NonNull - public Single delete(DatabaseWrapper databaseWrapper) { - return getRXModelAdapter().delete(this, databaseWrapper); - } - - @NonNull - public Single update() { - return getRXModelAdapter().update(this); - } - - @NonNull - public Single update(DatabaseWrapper databaseWrapper) { - return getRXModelAdapter().update(this, databaseWrapper); - } - - @NonNull - public Single insert() { - return getRXModelAdapter().insert(this); - } - - @NonNull - public Single insert(DatabaseWrapper databaseWrapper) { - return getRXModelAdapter().insert(this, databaseWrapper); - } - - @NonNull - public Single exists() { - return getRXModelAdapter().exists(this); - } - - @NonNull - public Single exists(DatabaseWrapper databaseWrapper) { - return getRXModelAdapter().exists(this, databaseWrapper); - } - - /** - * @return The associated {@link ModelAdapter}. The {@link FlowManager} - * may throw a {@link InvalidDBConfiguration} for this call if this class - * is not associated with a table, so be careful when using this method. - */ - @NonNull - private RXModelAdapter getRXModelAdapter() { - if (modelAdapter == null) { - modelAdapter = new RXModelAdapter<>(getClass()); - } - return modelAdapter; - } -} diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/structure/BaseRXModel.kt b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/structure/BaseRXModel.kt new file mode 100644 index 000000000..2883e0529 --- /dev/null +++ b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/structure/BaseRXModel.kt @@ -0,0 +1,44 @@ +package com.raizlabs.android.dbflow.rx.structure + +import com.raizlabs.android.dbflow.annotation.ColumnIgnore +import com.raizlabs.android.dbflow.config.FlowManager +import com.raizlabs.android.dbflow.structure.BaseModel +import com.raizlabs.android.dbflow.structure.InvalidDBConfiguration +import com.raizlabs.android.dbflow.structure.ModelAdapter +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper + +import rx.Completable +import rx.Single + +/** + * Description: Similar to [BaseModel] with RX constructs. Extend this for convenience methods. + */ +open class BaseRXModel { + + /** + * @return The associated [ModelAdapter]. The [FlowManager] + * may throw a [InvalidDBConfiguration] for this call if this class + * is not associated with a table, so be careful when using this method. + */ + @delegate:ColumnIgnore + @delegate:Transient + private val rxModelAdapter: RXModelAdapter by lazy { RXModelAdapter(javaClass) } + + fun DatabaseWrapper.save(): Single = + rxModelAdapter.save(this@BaseRXModel, this) + + fun DatabaseWrapper.load(): Completable = + rxModelAdapter.load(this@BaseRXModel, this) + + fun DatabaseWrapper.delete(): Single = + rxModelAdapter.delete(this@BaseRXModel, this) + + fun DatabaseWrapper.update(): Single = + rxModelAdapter.update(this@BaseRXModel, this) + + fun DatabaseWrapper.insert(): Single = + rxModelAdapter.insert(this@BaseRXModel, this) + + fun DatabaseWrapper.exists(): Single = + rxModelAdapter.exists(this@BaseRXModel, this) +} diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/structure/RXModelAdapter.java b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/structure/RXModelAdapter.java deleted file mode 100644 index 0b53d99cb..000000000 --- a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/structure/RXModelAdapter.java +++ /dev/null @@ -1,189 +0,0 @@ -package com.raizlabs.android.dbflow.rx.structure; - -import com.raizlabs.android.dbflow.config.FlowManager; -import com.raizlabs.android.dbflow.structure.ModelAdapter; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; - -import java.util.Collection; -import java.util.concurrent.Callable; - -import rx.Completable; -import rx.Single; - -/** - * Description: Wraps most {@link ModelAdapter} modification operations into RX-style constructs. - */ -public class RXModelAdapter extends RXRetrievalAdapter { - - public static RXModelAdapter from(ModelAdapter modelAdapter) { - return new RXModelAdapter<>(modelAdapter); - } - - public static RXModelAdapter from(Class table) { - return new RXModelAdapter<>(table); - } - - private final ModelAdapter modelAdapter; - - RXModelAdapter(ModelAdapter modelAdapter) { - super(modelAdapter); - this.modelAdapter = modelAdapter; - } - - public RXModelAdapter(Class table) { - this(FlowManager.getModelAdapter(table)); - } - - public Single save(final T model) { - return Single.fromCallable(new Callable() { - @Override - public Boolean call() throws Exception { - return modelAdapter.save(model); - } - }); - } - - public Single save(final T model, final DatabaseWrapper databaseWrapper) { - return Single.fromCallable(new Callable() { - @Override - public Boolean call() throws Exception { - return modelAdapter.save(model, databaseWrapper); - } - }); - } - - public Completable saveAll(final Collection models) { - return Completable.fromCallable(new Callable() { - @Override - public Void call() throws Exception { - modelAdapter.saveAll(models); - return null; - } - }); - } - - public Completable saveAll(final Collection models, final DatabaseWrapper databaseWrapper) { - return Completable.fromCallable(new Callable() { - @Override - public Void call() throws Exception { - modelAdapter.saveAll(models, databaseWrapper); - return null; - } - }); - } - - public Single insert(final T model) { - return Single.fromCallable(new Callable() { - @Override - public Long call() throws Exception { - return modelAdapter.insert(model); - } - }); - } - - public Single insert(final T model, final DatabaseWrapper databaseWrapper) { - return Single.fromCallable(new Callable() { - @Override - public Long call() throws Exception { - return modelAdapter.insert(model, databaseWrapper); - } - }); - } - - public Completable insertAll(final Collection models) { - return Completable.fromCallable(new Callable() { - @Override - public Void call() throws Exception { - modelAdapter.insertAll(models); - return null; - } - }); - } - - public Completable insertAll(final Collection models, - final DatabaseWrapper databaseWrapper) { - return Completable.fromCallable(new Callable() { - @Override - public Void call() throws Exception { - modelAdapter.insertAll(models, databaseWrapper); - return null; - } - }); - } - - public Single update(final T model) { - return Single.fromCallable(new Callable() { - @Override - public Boolean call() throws Exception { - return modelAdapter.update(model); - } - }); - } - - public Single update(final T model, final DatabaseWrapper databaseWrapper) { - return Single.fromCallable(new Callable() { - @Override - public Boolean call() throws Exception { - return modelAdapter.update(model, databaseWrapper); - } - }); - } - - public Completable updateAll(final Collection models) { - return Completable.fromCallable(new Callable() { - @Override - public Void call() throws Exception { - modelAdapter.updateAll(models); - return null; - } - }); - } - - public Completable updateAll(final Collection models, final DatabaseWrapper databaseWrapper) { - return Completable.fromCallable(new Callable() { - @Override - public Void call() throws Exception { - modelAdapter.updateAll(models, databaseWrapper); - return null; - } - }); - } - - public Single delete(final T model) { - return Single.fromCallable(new Callable() { - @Override - public Boolean call() throws Exception { - return modelAdapter.delete(model); - } - }); - } - - public Single delete(final T model, final DatabaseWrapper databaseWrapper) { - return Single.fromCallable(new Callable() { - @Override - public Boolean call() throws Exception { - return modelAdapter.delete(model, databaseWrapper); - } - }); - } - - public Completable deleteAll(final Collection models) { - return Completable.fromCallable(new Callable() { - @Override - public Void call() throws Exception { - modelAdapter.deleteAll(models); - return null; - } - }); - } - - public Completable deleteAll(final Collection models, final DatabaseWrapper databaseWrapper) { - return Completable.fromCallable(new Callable() { - @Override - public Void call() throws Exception { - modelAdapter.deleteAll(models, databaseWrapper); - return null; - } - }); - } -} diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/structure/RXModelAdapter.kt b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/structure/RXModelAdapter.kt new file mode 100644 index 000000000..e0ae3065d --- /dev/null +++ b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/structure/RXModelAdapter.kt @@ -0,0 +1,90 @@ +package com.raizlabs.android.dbflow.rx.structure + +import com.raizlabs.android.dbflow.config.FlowManager +import com.raizlabs.android.dbflow.structure.ModelAdapter +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import rx.Completable +import rx.Single + +/** + * Description: Wraps most [ModelAdapter] modification operations into RX-style constructs. + */ +class RXModelAdapter internal constructor(private val modelAdapter: ModelAdapter) + : RXRetrievalAdapter(modelAdapter) { + + constructor(table: Class) : this(FlowManager.getModelAdapter(table)) + + fun save(model: T): Single = Single.fromCallable { modelAdapter.save(model) } + + fun save(model: T, databaseWrapper: DatabaseWrapper): Single = + Single.fromCallable { modelAdapter.save(model, databaseWrapper) } + + fun saveAll(models: Collection): Completable = Completable.fromCallable { + modelAdapter.saveAll(models) + null + } + + fun saveAll(models: Collection, databaseWrapper: DatabaseWrapper): Completable = + Completable.fromCallable { + modelAdapter.saveAll(models, databaseWrapper) + null + } + + fun insert(model: T): Single = Single.fromCallable { modelAdapter.insert(model) } + + fun insert(model: T, databaseWrapper: DatabaseWrapper): Single = + Single.fromCallable { modelAdapter.insert(model, databaseWrapper) } + + fun insertAll(models: Collection): Completable = Completable.fromCallable { + modelAdapter.insertAll(models) + null + } + + fun insertAll(models: Collection, + databaseWrapper: DatabaseWrapper): Completable = Completable.fromCallable { + modelAdapter.insertAll(models, databaseWrapper) + null + } + + fun update(model: T): Single = Single.fromCallable { modelAdapter.update(model) } + + fun update(model: T, databaseWrapper: DatabaseWrapper): Single = + Single.fromCallable { modelAdapter.update(model, databaseWrapper) } + + fun updateAll(models: Collection): Completable = Completable.fromCallable { + modelAdapter.updateAll(models) + null + } + + fun updateAll(models: Collection, databaseWrapper: DatabaseWrapper): Completable = + Completable.fromCallable { + modelAdapter.updateAll(models, databaseWrapper) + null + } + + fun delete(model: T): Single = Single.fromCallable { modelAdapter.delete(model) } + + fun delete(model: T, databaseWrapper: DatabaseWrapper): Single = + Single.fromCallable { modelAdapter.delete(model, databaseWrapper) } + + fun deleteAll(models: Collection): Completable = Completable.fromCallable { + modelAdapter.deleteAll(models) + null + } + + fun deleteAll(models: Collection, databaseWrapper: DatabaseWrapper): Completable = + Completable.fromCallable { + modelAdapter.deleteAll(models, databaseWrapper) + null + } + + companion object { + + @JvmStatic + fun from(modelAdapter: ModelAdapter): RXModelAdapter = + RXModelAdapter(modelAdapter) + + @JvmStatic + fun from(table: Class): RXModelAdapter = RXModelAdapter(table) + } +} diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/structure/RXRetrievalAdapter.java b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/structure/RXRetrievalAdapter.java deleted file mode 100644 index fba7e7329..000000000 --- a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/structure/RXRetrievalAdapter.java +++ /dev/null @@ -1,77 +0,0 @@ -package com.raizlabs.android.dbflow.rx.structure; - -import com.raizlabs.android.dbflow.config.FlowManager; -import com.raizlabs.android.dbflow.structure.RetrievalAdapter; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; - -import java.util.concurrent.Callable; - -import rx.Completable; -import rx.Single; - -/** - * Description: Mirrors the {@link RetrievalAdapter} with subset of exposed methods, mostly for - * {@link #load(Object)} and {@link #exists(Object)} - */ -public class RXRetrievalAdapter { - - public static RXRetrievalAdapter from(RetrievalAdapter modelAdapter) { - return new RXRetrievalAdapter<>(modelAdapter); - } - - public static RXRetrievalAdapter from(Class table) { - return new RXRetrievalAdapter<>(table); - } - - private final RetrievalAdapter retrievalAdapter; - - RXRetrievalAdapter(RetrievalAdapter retrievalAdapter) { - this.retrievalAdapter = retrievalAdapter; - } - - RXRetrievalAdapter(Class table) { - this(FlowManager.getInstanceAdapter(table)); - } - - public Completable load(final TModel model) { - return Completable.fromCallable(new Callable() { - @Override - public Void call() throws Exception { - retrievalAdapter.load(model); - return null; - } - }); - } - - public Completable load(final TModel model, final DatabaseWrapper databaseWrapper) { - return Completable.fromCallable(new Callable() { - @Override - public Void call() throws Exception { - retrievalAdapter.load(model, databaseWrapper); - return null; - } - }); - } - - /** - * @param model The model to query values from - * @return True if it exists as a row in the corresponding database table - */ - public Single exists(final TModel model) { - return Single.fromCallable(new Callable() { - @Override - public Boolean call() throws Exception { - return retrievalAdapter.exists(model); - } - }); - } - - public Single exists(final TModel model, final DatabaseWrapper wrapper) { - return Single.fromCallable(new Callable() { - @Override - public Boolean call() throws Exception { - return retrievalAdapter.exists(model, wrapper); - } - }); - } -} diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/structure/RXRetrievalAdapter.kt b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/structure/RXRetrievalAdapter.kt new file mode 100644 index 000000000..965bc2a48 --- /dev/null +++ b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/structure/RXRetrievalAdapter.kt @@ -0,0 +1,41 @@ +package com.raizlabs.android.dbflow.rx.structure + +import com.raizlabs.android.dbflow.config.FlowManager +import com.raizlabs.android.dbflow.structure.RetrievalAdapter +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import rx.Completable +import rx.Single + +/** + * Description: Mirrors the [RetrievalAdapter] with subset of exposed methods, mostly for + * [.load] and [.exists] + */ +open class RXRetrievalAdapter +internal constructor(private val retrievalAdapter: RetrievalAdapter) { + + internal constructor(table: Class) : this(FlowManager.getInstanceAdapter(table)) + + fun load(model: T, databaseWrapper: DatabaseWrapper): Completable = Completable.fromCallable { + retrievalAdapter.load(model, databaseWrapper) + null + } + + /** + * @param model The model to query values from + * @return True if it exists as a row in the corresponding database table + */ + fun exists(model: T): Single = Single.fromCallable { retrievalAdapter.exists(model) } + + fun exists(model: T, wrapper: DatabaseWrapper): Single = + Single.fromCallable { retrievalAdapter.exists(model, wrapper) } + + companion object { + + @JvmStatic + fun from(modelAdapter: RetrievalAdapter): RXRetrievalAdapter = + RXRetrievalAdapter(modelAdapter) + + @JvmStatic + fun from(table: Class): RXRetrievalAdapter = RXRetrievalAdapter(table) + } +} diff --git a/dbflow-rx2-kotlinextensions/build.gradle b/dbflow-rx2-kotlinextensions/build.gradle deleted file mode 100644 index 415af0113..000000000 --- a/dbflow-rx2-kotlinextensions/build.gradle +++ /dev/null @@ -1,22 +0,0 @@ -apply plugin: 'com.android.library' -apply plugin: 'kotlin-android' - -project.ext.artifactId = bt_name - -android { - compileSdkVersion Integer.valueOf(dbflow_target_sdk) - buildToolsVersion dbflow_build_tools_version - - defaultConfig { - minSdkVersion dbflow_min_sdk_rx - targetSdkVersion Integer.valueOf(dbflow_target_sdk) - } -} - -dependencies { - api project("${dbflow_project_prefix}dbflow") - api project("${dbflow_project_prefix}dbflow-rx2") - api "org.jetbrains.kotlin:kotlin-stdlib-jre7:$kotlin_version" -} - -apply from: '../kotlin-artifacts.gradle' diff --git a/dbflow-rx2-kotlinextensions/gradle.properties b/dbflow-rx2-kotlinextensions/gradle.properties deleted file mode 100644 index af7922ebc..000000000 --- a/dbflow-rx2-kotlinextensions/gradle.properties +++ /dev/null @@ -1,3 +0,0 @@ -bt_name=dbflow-rx2-kotlinextensions -bt_packaging=aar -bt_artifact_id=dbflow-rx2-kotlinextensions diff --git a/dbflow-rx2-kotlinextensions/src/main/AndroidManifest.xml b/dbflow-rx2-kotlinextensions/src/main/AndroidManifest.xml deleted file mode 100644 index 816732f3f..000000000 --- a/dbflow-rx2-kotlinextensions/src/main/AndroidManifest.xml +++ /dev/null @@ -1,5 +0,0 @@ - - - - - diff --git a/dbflow-rx2-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/rx2/kotlinextensions/QueryExtensions.kt b/dbflow-rx2-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/rx2/kotlinextensions/QueryExtensions.kt deleted file mode 100644 index 26af93c30..000000000 --- a/dbflow-rx2-kotlinextensions/src/main/java/com/raizlabs/android/dbflow/rx2/kotlinextensions/QueryExtensions.kt +++ /dev/null @@ -1,79 +0,0 @@ -package com.raizlabs.android.dbflow.rx2.kotlinextensions - -import android.database.Cursor -import com.raizlabs.android.dbflow.rx2.language.RXModelQueriable -import com.raizlabs.android.dbflow.rx2.language.RXQueriable -import com.raizlabs.android.dbflow.rx2.language.RXSQLite -import com.raizlabs.android.dbflow.rx2.structure.BaseRXModel -import com.raizlabs.android.dbflow.sql.language.CursorResult -import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable -import com.raizlabs.android.dbflow.sql.queriable.Queriable -import com.raizlabs.android.dbflow.structure.database.DatabaseStatement -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper -import io.reactivex.disposables.Disposable - -fun ModelQueriable.rx() = RXSQLite.rx(this) - -inline fun Queriable.rx() = RXSQLite.rx(T::class.java, this) - -// queriable extensions - -inline val RXQueriable.cursor - get() = query() - -inline val RXQueriable.hasData - get() = hasData() - -inline val RXQueriable.statement - get() = compileStatement() - -inline val RXModelQueriable.list - get() = queryList() - -inline val RXModelQueriable.result - get() = querySingle() - -inline val RXModelQueriable.cursorResult - get() = queryResults() - -inline val RXModelQueriable.streamResults - get() = queryStreamResults() - -inline val RXModelQueriable.tableChanges - get() = observeOnTableChanges() - -// model extensions - -fun BaseRXModel.save(databaseWrapper: DatabaseWrapper, func: (Boolean) -> Unit): Disposable = save(databaseWrapper).subscribe { success -> func(success) } - -infix inline fun BaseRXModel.save(crossinline func: (Boolean) -> Unit): Disposable = save().subscribe { success -> func(success) } - -fun BaseRXModel.insert(databaseWrapper: DatabaseWrapper, func: (Long) -> Unit): Disposable = insert(databaseWrapper).subscribe { rowId -> func(rowId) } - -infix inline fun BaseRXModel.insert(crossinline func: (Long) -> Unit): Disposable = insert().subscribe { rowId -> func(rowId) } - -fun BaseRXModel.update(databaseWrapper: DatabaseWrapper, func: (Boolean) -> Unit): Disposable = update(databaseWrapper).subscribe { success -> func(success) } - -infix inline fun BaseRXModel.update(crossinline func: (Boolean) -> Unit): Disposable = update().subscribe { success -> func(success) } - -fun BaseRXModel.delete(databaseWrapper: DatabaseWrapper, func: (Boolean) -> Unit): Disposable = delete(databaseWrapper).subscribe { success -> func(success) } - -infix inline fun BaseRXModel.delete(crossinline func: (Boolean) -> Unit): Disposable = delete().subscribe { success -> func(success) } - -// async extensions - -infix inline fun RXModelQueriable.list(crossinline func: (MutableList) -> Unit): Disposable = list.subscribe { modelList -> func(modelList) } - -infix inline fun RXModelQueriable.result(crossinline func: (T?) -> Unit): Disposable = result.subscribe { result -> func(result) } - -infix inline fun RXModelQueriable.streamResults(crossinline func: (T?) -> Unit): Disposable = streamResults.subscribe { model -> func(model) } - -infix inline fun RXModelQueriable.cursorResult(crossinline func: (CursorResult) -> Unit): Disposable = cursorResult.subscribe { result -> func(result) } - -infix inline fun RXModelQueriable.tableChanges(crossinline func: (ModelQueriable) -> Unit): Disposable = tableChanges.subscribe { queriable -> func(queriable) } - -infix inline fun RXQueriable.statement(crossinline func: (DatabaseStatement) -> Unit): Disposable = statement.subscribe { statement -> func(statement) } - -infix inline fun RXQueriable.hasData(crossinline func: (Boolean) -> Unit): Disposable = hasData.subscribe { hasData -> func(hasData) } - -infix inline fun RXQueriable.cursor(crossinline func: (Cursor) -> Unit): Disposable = cursor.subscribe { cursor -> func(cursor) } diff --git a/dbflow-rx2/build.gradle b/dbflow-rx2/build.gradle index 311006990..21ac122dc 100644 --- a/dbflow-rx2/build.gradle +++ b/dbflow-rx2/build.gradle @@ -1,4 +1,5 @@ apply plugin: 'com.android.library' +apply plugin: 'kotlin-android' project.ext.artifactId = bt_name @@ -20,6 +21,7 @@ android { dependencies { api project("${dbflow_project_prefix}dbflow") api 'io.reactivex.rxjava2:rxjava:2.1.3' + api "org.jetbrains.kotlin:kotlin-stdlib-jre8:$kotlin_version" } apply from: '../android-artifacts.gradle' diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/CursorResultFlowable.java b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/CursorResultFlowable.java deleted file mode 100644 index d6922f376..000000000 --- a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/CursorResultFlowable.java +++ /dev/null @@ -1,110 +0,0 @@ -package com.raizlabs.android.dbflow.rx2.language; - -import android.support.annotation.NonNull; -import android.support.annotation.VisibleForTesting; - -import com.raizlabs.android.dbflow.config.FlowLog; -import com.raizlabs.android.dbflow.list.FlowCursorIterator; -import com.raizlabs.android.dbflow.sql.language.CursorResult; - -import org.reactivestreams.Subscriber; -import org.reactivestreams.Subscription; - -import java.util.concurrent.atomic.AtomicLong; - -import io.reactivex.Flowable; -import io.reactivex.SingleObserver; -import io.reactivex.disposables.Disposable; - -/** - * Description: Wraps a {@link RXModelQueriable} into a {@link Flowable} - * for each element represented by the query. - */ -public class CursorResultFlowable extends Flowable { - - - @NonNull - private final RXModelQueriable modelQueriable; - - public CursorResultFlowable(@NonNull RXModelQueriable modelQueriable) { - this.modelQueriable = modelQueriable; - - } - - @Override - protected void subscribeActual(final Subscriber subscriber) { - subscriber.onSubscribe(new Subscription() { - @Override - public void request(final long n) { - modelQueriable.queryResults().subscribe(new CursorResultObserver<>(subscriber, n)); - } - - @Override - public void cancel() { - - } - }); - } - - @VisibleForTesting - static class CursorResultObserver implements SingleObserver> { - - private final Subscriber subscriber; - private final long count; - private final AtomicLong emitted; - private final AtomicLong requested; - private Disposable disposable; - - CursorResultObserver(Subscriber subscriber, long count) { - this.subscriber = subscriber; - this.count = count; - requested = new AtomicLong(); - emitted = new AtomicLong(); - } - - @Override - public void onSubscribe(Disposable disposable) { - this.disposable = disposable; - } - - @Override - public void onSuccess(CursorResult ts) { - int starting = this.count == Long.MAX_VALUE && requested.compareAndSet(0, Long.MAX_VALUE) - ? 0 : emitted.intValue(); - long limit = this.count + starting; - - while (limit > 0) { - FlowCursorIterator iterator = ts.iterator(starting, limit); - try { - long i = 0; - while (!disposable.isDisposed() && iterator.hasNext() && i++ < limit) { - subscriber.onNext(iterator.next()); - } - emitted.addAndGet(i); - // no more items - if (!disposable.isDisposed() && i < limit) { - subscriber.onComplete(); - break; - } - limit = requested.addAndGet(-limit); - } catch (Exception e) { - FlowLog.logError(e); - subscriber.onError(e); - } finally { - try { - iterator.close(); - } catch (Exception e) { - FlowLog.logError(e); - subscriber.onError(e); - } - } - } - } - - @Override - public void onError(Throwable e) { - subscriber.onError(e); - } - - } -} diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/CursorResultFlowable.kt b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/CursorResultFlowable.kt new file mode 100644 index 000000000..cebf12bdf --- /dev/null +++ b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/CursorResultFlowable.kt @@ -0,0 +1,84 @@ +package com.raizlabs.android.dbflow.rx2.language + +import com.raizlabs.android.dbflow.config.FlowLog +import com.raizlabs.android.dbflow.sql.language.CursorResult +import io.reactivex.Flowable +import io.reactivex.SingleObserver +import io.reactivex.disposables.Disposable +import org.reactivestreams.Subscriber +import org.reactivestreams.Subscription +import java.util.concurrent.atomic.AtomicLong + +/** + * Description: Wraps a [RXModelQueriable] into a [Flowable] + * for each element represented by the query. + */ +class CursorResultFlowable(private val modelQueriable: RXModelQueriable) + : Flowable() { + + override fun subscribeActual(subscriber: Subscriber) { + subscriber.onSubscribe(object : Subscription { + override fun request(n: Long) { + modelQueriable.queryResults().subscribe(CursorResultObserver(subscriber, n)) + } + + override fun cancel() { + + } + }) + } + + internal class CursorResultObserver( + private val subscriber: Subscriber, private val count: Long) + : SingleObserver> { + private val emitted: AtomicLong = AtomicLong() + private val requested: AtomicLong = AtomicLong() + private var disposable: Disposable? = null + + override fun onSubscribe(disposable: Disposable) { + this.disposable = disposable + } + + override fun onSuccess(ts: CursorResult) { + val starting = when { + this.count == java.lang.Long.MAX_VALUE + && requested.compareAndSet(0, java.lang.Long.MAX_VALUE) -> 0 + else -> emitted.toInt() + } + var limit = this.count + starting + + while (limit > 0) { + val iterator = ts.iterator(starting, limit) + try { + var i: Long = 0 + while (!disposable!!.isDisposed && iterator.hasNext() && i++ < limit) { + subscriber.onNext(iterator.next()) + } + emitted.addAndGet(i) + // no more items + if (disposable?.isDisposed == false && i < limit) { + subscriber.onComplete() + break + } + limit = requested.addAndGet(-limit) + } catch (e: Exception) { + FlowLog.logError(e) + subscriber.onError(e) + } finally { + try { + iterator.close() + } catch (e: Exception) { + FlowLog.logError(e) + subscriber.onError(e) + } + + } + } + } + + override fun onError(e: Throwable) { + subscriber.onError(e) + } + + } +} diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXModelQueriable.java b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXModelQueriable.java deleted file mode 100644 index 1c760a05c..000000000 --- a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXModelQueriable.java +++ /dev/null @@ -1,100 +0,0 @@ -package com.raizlabs.android.dbflow.rx2.language; - -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.list.FlowCursorList; -import com.raizlabs.android.dbflow.list.FlowQueryList; -import com.raizlabs.android.dbflow.sql.language.CursorResult; -import com.raizlabs.android.dbflow.sql.language.Join; -import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable; -import com.raizlabs.android.dbflow.structure.BaseQueryModel; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; - -import java.util.List; - -import io.reactivex.Flowable; -import io.reactivex.Maybe; -import io.reactivex.Observable; -import io.reactivex.Single; - -/** - * Description: Mirrors {@link ModelQueriable} with RX constructs. - */ -public interface RXModelQueriable extends RXQueriable { - - @NonNull - Single> queryResults(); - - @NonNull - Single> queryList(); - - @NonNull - Single> queryList(DatabaseWrapper wrapper); - - /** - * @return Single model, the first of potentially many results - */ - @NonNull - Maybe querySingle(); - - /** - * Allows you to specify a DB, useful for migrations. - * - * @return Single model, the first of potentially many results - */ - @NonNull - Maybe querySingle(DatabaseWrapper wrapper); - - /** - * @return Queries for {@link #queryResults()}, and returns one at a time from this {@link Observable} - */ - @NonNull - Flowable queryStreamResults(); - - /** - * @return the table that this query comes from. - */ - @NonNull - Class getTable(); - - /** - * @return A cursor-backed list that handles conversion, retrieval, and caching of lists. Can - * cache models dynamically by setting {@link FlowCursorList#setCacheModels(boolean)} to true. - */ - @NonNull - Single> cursorList(); - - /** - * @return A cursor-backed {@link List} that handles conversion, retrieval, caching, content changes, - * and more. - */ - @NonNull - Single> flowQueryList(); - - /** - * Returns a {@link List} based on the custom {@link TQueryModel} you pass in. - * - * @param queryModelClass The query model class to use. - * @param The class that extends {@link BaseQueryModel} - * @return A list of custom models that are not tied to a table. - */ - @NonNull - Single> queryCustomList(Class queryModelClass); - - /** - * Returns a single {@link TQueryModel} from this query. - * - * @param queryModelClass The class to use. - * @param The class that extends {@link BaseQueryModel} - * @return A single model from the query. - */ - @NonNull - Maybe queryCustomSingle(Class queryModelClass); - - /** - * @return A new {@link Observable} that observes when the {@link TModel} table changes. - * This can also be multiple tables, given if it results from a {@link Join} (one for each join table). - */ - @NonNull - Flowable> observeOnTableChanges(); -} \ No newline at end of file diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXModelQueriable.kt b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXModelQueriable.kt new file mode 100644 index 000000000..17cb518d9 --- /dev/null +++ b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXModelQueriable.kt @@ -0,0 +1,88 @@ +package com.raizlabs.android.dbflow.rx2.language + +import com.raizlabs.android.dbflow.list.FlowCursorList +import com.raizlabs.android.dbflow.list.FlowQueryList +import com.raizlabs.android.dbflow.sql.language.CursorResult +import com.raizlabs.android.dbflow.sql.language.Join +import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable +import com.raizlabs.android.dbflow.structure.BaseQueryModel +import io.reactivex.Flowable +import io.reactivex.Maybe +import io.reactivex.Observable +import io.reactivex.Single + +/** + * Description: Mirrors [ModelQueriable] with RX constructs. + */ +interface RXModelQueriable : RXQueriable { + + /** + * @return the table that this query comes from. + */ + val table: Class + + fun queryResults(): Single> + + fun queryList(): Single> + + /** + * @return Single model, the first of potentially many results + */ + fun querySingle(): Maybe + + /** + * @return Queries for [.queryResults], and returns one at a time from this [Observable] + */ + fun queryStreamResults(): Flowable + + /** + * @return A cursor-backed list that handles conversion, retrieval, and caching of lists. Can + * cache models dynamically by setting [FlowCursorList.setCacheModels] to true. + */ + fun cursorList(): Single> + + /** + * @return A cursor-backed [List] that handles conversion, retrieval, caching, content changes, + * and more. + */ + fun flowQueryList(): Single> + + /** + * Returns a [List] based on the custom [TQueryModel] you pass in. + * + * @param queryModelClass The query model class to use. + * @param The class that extends [BaseQueryModel] + * @return A list of custom models that are not tied to a table. + */ + fun queryCustomList(queryModelClass: Class): Single> + + /** + * Returns a single [TQueryModel] from this query. + * + * @param queryModelClass The class to use. + * @param The class that extends [BaseQueryModel] + * @return A single model from the query. + */ + fun queryCustomSingle(queryModelClass: Class): Maybe + + /** + * @return A new [Observable] that observes when the [T] table changes. + * This can also be multiple tables, given if it results from a [Join] (one for each join table). + */ + fun observeOnTableChanges(): Flowable> +} + +inline val RXModelQueriable.list + get() = queryList() + +inline val RXModelQueriable.result + get() = querySingle() + +inline val RXModelQueriable.cursorResult + get() = queryResults() + +inline val RXModelQueriable.streamResults + get() = queryStreamResults() + +inline val RXModelQueriable.tableChanges + get() = observeOnTableChanges() \ No newline at end of file diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXModelQueriableImpl.java b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXModelQueriableImpl.java deleted file mode 100644 index edf88c1d7..000000000 --- a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXModelQueriableImpl.java +++ /dev/null @@ -1,157 +0,0 @@ -package com.raizlabs.android.dbflow.rx2.language; - -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.list.FlowCursorList; -import com.raizlabs.android.dbflow.list.FlowQueryList; -import com.raizlabs.android.dbflow.sql.language.BaseModelQueriable; -import com.raizlabs.android.dbflow.sql.language.CursorResult; -import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; - -import java.util.List; -import java.util.concurrent.Callable; - -import io.reactivex.BackpressureStrategy; -import io.reactivex.Flowable; -import io.reactivex.Maybe; -import io.reactivex.Single; - -import static io.reactivex.Single.fromCallable; - -/** - * Description: Represents {@link BaseModelQueriable} in RX form. - */ -public class RXModelQueriableImpl extends RXQueriableImpl implements RXModelQueriable { - - private final ModelQueriable modelQueriable; - - public RXModelQueriableImpl(ModelQueriable modelQueriable) { - super(modelQueriable.getTable(), modelQueriable); - this.modelQueriable = modelQueriable; - } - - private ModelQueriable getInnerModelQueriable() { - return modelQueriable; - } - - @NonNull - @Override - public Flowable queryStreamResults() { - return new CursorResultFlowable<>(this); - } - - @NonNull - @Override - public Single> queryResults() { - return fromCallable(new Callable>() { - @Override - public CursorResult call() throws Exception { - return getInnerModelQueriable().queryResults(); - } - }); - } - - @NonNull - @Override - public Single> queryList() { - return fromCallable(new Callable>() { - @Override - public List call() throws Exception { - return getInnerModelQueriable().queryList(); - } - }); - } - - @NonNull - @Override - public Single> queryList(final DatabaseWrapper wrapper) { - return fromCallable(new Callable>() { - @Override - public List call() throws Exception { - return getInnerModelQueriable().queryList(wrapper); - } - }); - } - - @NonNull - @Override - public Maybe querySingle() { - return Maybe.fromCallable(new Callable() { - @Override - public T call() throws Exception { - return getInnerModelQueriable().querySingle(); - } - }); - } - - @NonNull - @Override - public Maybe querySingle(final DatabaseWrapper wrapper) { - return Maybe.fromCallable(new Callable() { - @Override - public T call() throws Exception { - return getInnerModelQueriable().querySingle(wrapper); - } - }); - } - - @NonNull - @Override - public Class getTable() { - return getInnerModelQueriable().getTable(); - } - - @NonNull - @Override - public Single> cursorList() { - return fromCallable(new Callable>() { - @Override - public FlowCursorList call() throws Exception { - return getInnerModelQueriable().cursorList(); - } - }); - } - - @NonNull - @Override - public Single> flowQueryList() { - return fromCallable(new Callable>() { - @Override - public FlowQueryList call() throws Exception { - return getInnerModelQueriable().flowQueryList(); - } - }); - } - - @NonNull - @Override - public Single> queryCustomList( - final Class tQueryModelClass) { - return fromCallable(new Callable>() { - @Override - public List call() throws Exception { - return getInnerModelQueriable().queryCustomList(tQueryModelClass); - } - }); - } - - @NonNull - @Override - public Maybe queryCustomSingle( - final Class tQueryModelClass) { - return Maybe.fromCallable(new Callable() { - @Override - public TQueryModel call() throws Exception { - return getInnerModelQueriable().queryCustomSingle(tQueryModelClass); - } - }); - } - - @NonNull - @Override - public Flowable> observeOnTableChanges() { - return Flowable.create(new TableChangeOnSubscribe<>(getInnerModelQueriable()), - BackpressureStrategy.LATEST); - } -} diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXModelQueriableImpl.kt b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXModelQueriableImpl.kt new file mode 100644 index 000000000..76c465415 --- /dev/null +++ b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXModelQueriableImpl.kt @@ -0,0 +1,48 @@ +package com.raizlabs.android.dbflow.rx2.language + +import com.raizlabs.android.dbflow.list.FlowCursorList +import com.raizlabs.android.dbflow.list.FlowQueryList +import com.raizlabs.android.dbflow.sql.language.BaseModelQueriable +import com.raizlabs.android.dbflow.sql.language.CursorResult +import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable +import io.reactivex.BackpressureStrategy +import io.reactivex.Flowable +import io.reactivex.Maybe +import io.reactivex.Single +import io.reactivex.Single.fromCallable + +/** + * Description: Represents [BaseModelQueriable] in RX form. + */ +class RXModelQueriableImpl(private val innerModelQueriable: ModelQueriable) + : RXQueriableImpl(innerModelQueriable), RXModelQueriable { + + override val table: Class + get() = innerModelQueriable.table + + override fun queryStreamResults(): Flowable = CursorResultFlowable(this) + + override fun queryResults(): Single> = + fromCallable { innerModelQueriable.queryResults() } + + override fun queryList(): Single> = fromCallable { innerModelQueriable.queryList() } + + override fun querySingle(): Maybe = Maybe.fromCallable { innerModelQueriable.querySingle() } + + override fun cursorList(): Single> = + fromCallable { innerModelQueriable.cursorList() } + + override fun flowQueryList(): Single> = + fromCallable { innerModelQueriable.flowQueryList() } + + override fun queryCustomList( + queryModelClass: Class): Single> = + fromCallable { innerModelQueriable.queryCustomList(queryModelClass) } + + override fun queryCustomSingle( + queryModelClass: Class): Maybe = + Maybe.fromCallable { innerModelQueriable.queryCustomSingle(queryModelClass) } + + override fun observeOnTableChanges(): Flowable> = + Flowable.create(TableChangeOnSubscribe(innerModelQueriable), BackpressureStrategy.LATEST) +} diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXQueriable.java b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXQueriable.java deleted file mode 100644 index 55e07880c..000000000 --- a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXQueriable.java +++ /dev/null @@ -1,119 +0,0 @@ -package com.raizlabs.android.dbflow.rx2.language; - -import android.database.Cursor; -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.sql.language.Delete; -import com.raizlabs.android.dbflow.sql.language.Insert; -import com.raizlabs.android.dbflow.sql.language.Set; -import com.raizlabs.android.dbflow.sql.queriable.Queriable; -import com.raizlabs.android.dbflow.structure.Model; -import com.raizlabs.android.dbflow.structure.database.DatabaseStatement; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; - -import io.reactivex.Completable; -import io.reactivex.Maybe; -import io.reactivex.Single; - -/** - * Description: Mirrors {@link Queriable} with RX constructs. - */ -public interface RXQueriable { - - /** - * @return An {@link Single} from the DB based on this query - */ - @NonNull - Maybe query(); - - /** - * Allows you to pass in a {@link DatabaseWrapper} manually. - * - * @param databaseWrapper The wrapper to pass in. - * @return An {@link Single} from the DB based on this query - */ - @NonNull - Maybe query(DatabaseWrapper databaseWrapper); - - - /** - * @return An {@link Single} of {@link DatabaseStatement} from this query. - */ - @NonNull - Single compileStatement(); - - /** - * @param databaseWrapper The wrapper to use. - * @return An {@link Single} of {@link DatabaseStatement} from this query with database specified. - */ - @NonNull - Single compileStatement(DatabaseWrapper databaseWrapper); - - /** - * @return the long value of this query. - **/ - @NonNull - Single longValue(); - - /** - * @return the long value of this query. - **/ - @NonNull - Single longValue(DatabaseWrapper databaseWrapper); - - /** - * @return This may return the number of rows affected from a {@link Insert} statement. - * If not, returns {@link Model#INVALID_ROW_ID} - */ - @NonNull - Single executeInsert(); - - /** - * @return This may return the number of rows affected from a {@link Insert} statement. - * If not, returns {@link Model#INVALID_ROW_ID} - */ - @NonNull - Single executeInsert(DatabaseWrapper databaseWrapper); - - /** - * @return This may return the number of rows affected from a {@link Set} or {@link Delete} statement. - * If not, returns {@link Model#INVALID_ROW_ID} - */ - @NonNull - Single executeUpdateDelete(DatabaseWrapper databaseWrapper); - - /** - * @return This may return the number of rows affected from a {@link Set} or {@link Delete} statement. - * If not, returns {@link Model#INVALID_ROW_ID} - */ - @NonNull - Single executeUpdateDelete(); - - /** - * @return True if this query has data. It will run a {@link #count()} greater than 0. - */ - @NonNull - Single hasData(); - - /** - * Allows you to pass in a {@link DatabaseWrapper} manually. - * - * @return True if this query has data. It will run a {@link #count()} greater than 0. - */ - @NonNull - Single hasData(DatabaseWrapper databaseWrapper); - - /** - * Will not return a result, rather simply will execute a SQL statement. Use this for non-SELECT statements or when - * you're not interested in the result. - */ - @NonNull - Completable execute(); - - /** - * Will not return a result, rather simply will execute a SQL statement. Use this for non-SELECT statements or when - * you're not interested in the result. - */ - @NonNull - Completable execute(DatabaseWrapper databaseWrapper); -} diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXQueriable.kt b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXQueriable.kt new file mode 100644 index 000000000..18948c260 --- /dev/null +++ b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXQueriable.kt @@ -0,0 +1,67 @@ +package com.raizlabs.android.dbflow.rx2.language + +import android.database.Cursor +import com.raizlabs.android.dbflow.sql.language.Delete +import com.raizlabs.android.dbflow.sql.language.Insert +import com.raizlabs.android.dbflow.sql.language.Set +import com.raizlabs.android.dbflow.sql.queriable.Queriable +import com.raizlabs.android.dbflow.structure.Model +import com.raizlabs.android.dbflow.structure.database.DatabaseStatement +import io.reactivex.Completable +import io.reactivex.Maybe +import io.reactivex.Single + +/** + * Description: Mirrors [Queriable] with RX constructs. + */ +interface RXQueriable { + + /** + * @return An [Single] from the DB based on this query + */ + fun query(): Maybe + + /** + * @return An [Single] of [DatabaseStatement] from this query. + */ + fun compileStatement(): Single + + /** + * @return the long value of this query. + */ + fun longValue(): Single + + /** + * @return This may return the number of rows affected from a [Insert] statement. + * If not, returns [Model.INVALID_ROW_ID] + */ + fun executeInsert(): Single + + /** + * @return This may return the number of rows affected from a [Set] or [Delete] statement. + * If not, returns [Model.INVALID_ROW_ID] + */ + fun executeUpdateDelete(): Single + + /** + * @return True if this query has data. It will run a [.count] greater than 0. + */ + fun hasData(): Single + + /** + * Will not return a result, rather simply will execute a SQL statement. Use this for non-SELECT statements or when + * you're not interested in the result. + */ + fun execute(): Completable + +} + + +inline val RXQueriable.cursor + get() = query() + +inline val RXQueriable.hasData + get() = hasData() + +inline val RXQueriable.statement + get() = compileStatement() diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXQueriableImpl.java b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXQueriableImpl.java deleted file mode 100644 index 125ab09dd..000000000 --- a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXQueriableImpl.java +++ /dev/null @@ -1,191 +0,0 @@ -package com.raizlabs.android.dbflow.rx2.language; - -import android.database.Cursor; -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.config.FlowManager; -import com.raizlabs.android.dbflow.sql.language.BaseQueriable; -import com.raizlabs.android.dbflow.sql.queriable.Queriable; -import com.raizlabs.android.dbflow.structure.database.DatabaseStatement; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; - -import java.util.concurrent.Callable; - -import io.reactivex.Completable; -import io.reactivex.Maybe; -import io.reactivex.Single; - -import static io.reactivex.Single.fromCallable; - -/** - * Description: Represents {@link BaseQueriable} with RX constructs. - */ -public class RXQueriableImpl implements RXQueriable { - - private final Class table; - private final Queriable queriable; - - public RXQueriableImpl(Class table, Queriable queriable) { - this.table = table; - this.queriable = queriable; - } - - @NonNull - private Queriable getInnerQueriable() { - return queriable; - } - - @NonNull - @Override - public Maybe query() { - return Maybe.fromCallable(new Callable() { - @Override - public Cursor call() throws Exception { - return getInnerQueriable().query(); - } - }); - } - - @NonNull - @Override - public Maybe query(final DatabaseWrapper databaseWrapper) { - return Maybe.fromCallable(new Callable() { - @Override - public Cursor call() throws Exception { - return getInnerQueriable().query(databaseWrapper); - } - }); - } - - @NonNull - @Override - public Single compileStatement() { - return fromCallable(new Callable() { - @Override - public DatabaseStatement call() throws Exception { - return getInnerQueriable().compileStatement(); - } - }); - } - - @NonNull - @Override - public Single compileStatement(final DatabaseWrapper databaseWrapper) { - return fromCallable(new Callable() { - @Override - public DatabaseStatement call() throws Exception { - return getInnerQueriable().compileStatement(databaseWrapper); - } - }); - } - - @NonNull - @Override - public Single longValue() { - return fromCallable(new Callable() { - @Override - public Long call() throws Exception { - return getInnerQueriable().longValue(); - } - }); - } - - @NonNull - @Override - public Single longValue(final DatabaseWrapper databaseWrapper) { - return fromCallable(new Callable() { - @Override - public Long call() throws Exception { - return getInnerQueriable().longValue(databaseWrapper); - } - }); - } - - @NonNull - @Override - public Single executeInsert() { - return fromCallable(new Callable() { - @Override - public Long call() throws Exception { - return getInnerQueriable().executeInsert(FlowManager.getWritableDatabaseForTable(table)); - } - }); - } - - @NonNull - @Override - public Single executeInsert(final DatabaseWrapper databaseWrapper) { - return fromCallable(new Callable() { - @Override - public Long call() throws Exception { - return getInnerQueriable().executeInsert(databaseWrapper); - } - }); - } - - @NonNull - @Override - public Single executeUpdateDelete(final DatabaseWrapper databaseWrapper) { - return fromCallable(new Callable() { - @Override - public Long call() throws Exception { - return getInnerQueriable().executeUpdateDelete(databaseWrapper); - } - }); - } - - @NonNull - @Override - public Single executeUpdateDelete() { - return fromCallable(new Callable() { - @Override - public Long call() throws Exception { - return getInnerQueriable().executeUpdateDelete(); - } - }); - } - - @NonNull - @Override - public Single hasData() { - return fromCallable(new Callable() { - @Override - public Boolean call() throws Exception { - return getInnerQueriable().hasData(); - } - }); - } - - @NonNull - @Override - public Single hasData(final DatabaseWrapper databaseWrapper) { - return fromCallable(new Callable() { - @Override - public Boolean call() throws Exception { - return getInnerQueriable().hasData(databaseWrapper); - } - }); - } - - @NonNull - @Override - public Completable execute() { - return Completable.fromRunnable(new Runnable() { - @Override - public void run() { - getInnerQueriable().execute(); - } - }); - } - - @NonNull - @Override - public Completable execute(final DatabaseWrapper databaseWrapper) { - return Completable.fromRunnable(new Runnable() { - @Override - public void run() { - getInnerQueriable().execute(databaseWrapper); - } - }); - } -} diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXQueriableImpl.kt b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXQueriableImpl.kt new file mode 100644 index 000000000..1c660f891 --- /dev/null +++ b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXQueriableImpl.kt @@ -0,0 +1,34 @@ +package com.raizlabs.android.dbflow.rx2.language + +import android.database.Cursor +import com.raizlabs.android.dbflow.sql.language.BaseQueriable +import com.raizlabs.android.dbflow.sql.queriable.Queriable +import com.raizlabs.android.dbflow.structure.database.DatabaseStatement +import io.reactivex.Completable +import io.reactivex.Maybe +import io.reactivex.Single +import io.reactivex.Single.fromCallable + +/** + * Description: Represents [BaseQueriable] with RX constructs. + */ +open class RXQueriableImpl(private val innerQueriable: Queriable) : RXQueriable { + + override fun query(): Maybe = Maybe.fromCallable { innerQueriable.query() } + + override fun compileStatement(): Single = + fromCallable { innerQueriable.compileStatement() } + + override fun longValue(): Single = fromCallable { innerQueriable.longValue() } + + override fun executeInsert(): Single = + fromCallable { innerQueriable.executeInsert() } + + override fun executeUpdateDelete(): Single = + fromCallable { innerQueriable.executeUpdateDelete() } + + override fun hasData(): Single = fromCallable { innerQueriable.hasData() } + + override fun execute(): Completable = Completable.fromRunnable { innerQueriable.execute() } + +} diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXSQLite.java b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXSQLite.java deleted file mode 100644 index ad710392b..000000000 --- a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXSQLite.java +++ /dev/null @@ -1,25 +0,0 @@ -package com.raizlabs.android.dbflow.rx2.language; - -import android.support.annotation.NonNull; - -import com.raizlabs.android.dbflow.sql.language.SQLite; -import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable; -import com.raizlabs.android.dbflow.sql.queriable.Queriable; - -/** - * Description: The RX implementation of SQLite language queries. Meant to be interchangeable - * with {@link SQLite}. - */ -public class RXSQLite { - - @NonNull - public static RXModelQueriableImpl rx(ModelQueriable modelQueriable) { - return new RXModelQueriableImpl<>(modelQueriable); - } - - @NonNull - public static RXQueriableImpl rx(Class table, Queriable queriable) { - return new RXQueriableImpl(table, queriable); - } - -} diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXSQLite.kt b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXSQLite.kt new file mode 100644 index 000000000..0b40a6546 --- /dev/null +++ b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXSQLite.kt @@ -0,0 +1,11 @@ +@file:JvmName("RXSQLite") + +package com.raizlabs.android.dbflow.rx2.language + +import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable +import com.raizlabs.android.dbflow.sql.queriable.Queriable + +fun ModelQueriable.rx(): RXModelQueriableImpl = RXModelQueriableImpl(this) + +fun Queriable.rx(): RXQueriableImpl = RXQueriableImpl(this) + diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/TableChangeOnSubscribe.java b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/TableChangeOnSubscribe.java deleted file mode 100644 index 63c127fde..000000000 --- a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/TableChangeOnSubscribe.java +++ /dev/null @@ -1,78 +0,0 @@ -package com.raizlabs.android.dbflow.rx2.language; - -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.config.FlowManager; -import com.raizlabs.android.dbflow.runtime.OnTableChangedListener; -import com.raizlabs.android.dbflow.runtime.TableNotifierRegister; -import com.raizlabs.android.dbflow.sql.language.From; -import com.raizlabs.android.dbflow.sql.language.Join; -import com.raizlabs.android.dbflow.sql.language.Where; -import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable; -import com.raizlabs.android.dbflow.structure.BaseModel; - -import io.reactivex.FlowableEmitter; -import io.reactivex.FlowableOnSubscribe; -import io.reactivex.disposables.Disposables; - -/** - * Description: Emits when table changes occur for the related table on the {@link ModelQueriable}. - * If the {@link ModelQueriable} relates to a {@link Join}, this can be multiple tables. - */ -public class TableChangeOnSubscribe implements FlowableOnSubscribe> { - - private final ModelQueriable modelQueriable; - - private final TableNotifierRegister register; - private FlowableEmitter> flowableEmitter; - - public TableChangeOnSubscribe(ModelQueriable modelQueriable) { - this.modelQueriable = modelQueriable; - register = FlowManager.newRegisterForTable(modelQueriable.getTable()); - } - - @Override - public void subscribe(FlowableEmitter> e) throws Exception { - flowableEmitter = e; - flowableEmitter.setDisposable(Disposables.fromRunnable(new Runnable() { - @Override - public void run() { - register.unregisterAll(); - } - })); - - From from = null; - if (modelQueriable instanceof From) { - from = (From) modelQueriable; - } else if (modelQueriable instanceof Where - && ((Where) modelQueriable).getWhereBase() instanceof From) { - //noinspection unchecked - from = (From) ((Where) modelQueriable).getWhereBase(); - } - - // From could be part of many joins, so we register for all affected tables here. - if (from != null) { - java.util.Set> associatedTables = from.getAssociatedTables(); - for (Class table : associatedTables) { - register.register(table); - } - } else { - register.register(modelQueriable.getTable()); - } - - register.setListener(onTableChangedListener); - flowableEmitter.onNext(modelQueriable); - } - - private final OnTableChangedListener onTableChangedListener - = new OnTableChangedListener() { - @Override - public void onTableChanged(@Nullable Class table, @NonNull BaseModel.Action action) { - if (modelQueriable.getTable().equals(table)) { - flowableEmitter.onNext(modelQueriable); - } - } - }; - -} diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/TableChangeOnSubscribe.kt b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/TableChangeOnSubscribe.kt new file mode 100644 index 000000000..12eb6ecc0 --- /dev/null +++ b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/TableChangeOnSubscribe.kt @@ -0,0 +1,61 @@ +package com.raizlabs.android.dbflow.rx2.language + +import com.raizlabs.android.dbflow.config.FlowManager +import com.raizlabs.android.dbflow.runtime.OnTableChangedListener +import com.raizlabs.android.dbflow.runtime.TableNotifierRegister +import com.raizlabs.android.dbflow.sql.language.From +import com.raizlabs.android.dbflow.sql.language.Join +import com.raizlabs.android.dbflow.sql.language.Where +import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable +import com.raizlabs.android.dbflow.structure.BaseModel + +import io.reactivex.FlowableEmitter +import io.reactivex.FlowableOnSubscribe +import io.reactivex.disposables.Disposables + +/** + * Description: Emits when table changes occur for the related table on the [ModelQueriable]. + * If the [ModelQueriable] relates to a [Join], this can be multiple tables. + */ +class TableChangeOnSubscribe(private val modelQueriable: ModelQueriable) + : FlowableOnSubscribe> { + + private val register: TableNotifierRegister = FlowManager.newRegisterForTable(modelQueriable.table) + private var flowableEmitter: FlowableEmitter>? = null + + private val onTableChangedListener = object : OnTableChangedListener { + override fun onTableChanged(table: Class<*>?, action: BaseModel.Action) { + if (modelQueriable.table == table) { + flowableEmitter!!.onNext(modelQueriable) + } + } + } + + @Suppress("UNCHECKED_CAST") + @Throws(Exception::class) + override fun subscribe(e: FlowableEmitter>) { + flowableEmitter = e + e.setDisposable(Disposables.fromRunnable { register.unregisterAll() }) + + var from: From? = null + if (modelQueriable is From<*>) { + from = modelQueriable as From + } else if (modelQueriable is Where<*> && (modelQueriable as Where<*>).whereBase is From<*>) { + from = (modelQueriable as Where<*>).whereBase as From + } + + // From could be part of many joins, so we register for all affected tables here. + if (from != null) { + val associatedTables = from.associatedTables + for (table in associatedTables) { + register.register(table) + } + } else { + register.register(modelQueriable.table) + } + + register.setListener(onTableChangedListener) + flowableEmitter?.onNext(modelQueriable) + } + +} diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/structure/BaseRXModel.java b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/structure/BaseRXModel.java deleted file mode 100644 index 274a2fea7..000000000 --- a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/structure/BaseRXModel.java +++ /dev/null @@ -1,82 +0,0 @@ -package com.raizlabs.android.dbflow.rx2.structure; - -import com.raizlabs.android.dbflow.annotation.ColumnIgnore; -import com.raizlabs.android.dbflow.config.FlowManager; -import com.raizlabs.android.dbflow.structure.BaseModel; -import com.raizlabs.android.dbflow.structure.InvalidDBConfiguration; -import com.raizlabs.android.dbflow.structure.ModelAdapter; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; - -import io.reactivex.Completable; -import io.reactivex.Single; - -/** - * Description: Similar to {@link BaseModel} with RX constructs. Extend this for convenience methods. - */ -@SuppressWarnings("unchecked") -public class BaseRXModel { - - @ColumnIgnore - private transient RXModelAdapter modelAdapter; - - public Single save() { - return getRXModelAdapter().save(this); - } - - public Single save(DatabaseWrapper databaseWrapper) { - return getRXModelAdapter().save(this, databaseWrapper); - } - - public Completable load() { - return getRXModelAdapter().load(this); - } - - public Completable load(DatabaseWrapper databaseWrapper) { - return getRXModelAdapter().load(this, databaseWrapper); - } - - public Single delete() { - return getRXModelAdapter().delete(this); - } - - public Single delete(DatabaseWrapper databaseWrapper) { - return getRXModelAdapter().delete(this, databaseWrapper); - } - - public Single update() { - return getRXModelAdapter().update(this); - } - - public Single update(DatabaseWrapper databaseWrapper) { - return getRXModelAdapter().update(this, databaseWrapper); - } - - public Single insert() { - return getRXModelAdapter().insert(this); - } - - public Single insert(DatabaseWrapper databaseWrapper) { - return getRXModelAdapter().insert(this, databaseWrapper); - } - - public Single exists() { - return getRXModelAdapter().exists(this); - } - - - public Single exists(DatabaseWrapper databaseWrapper) { - return getRXModelAdapter().exists(this, databaseWrapper); - } - - /** - * @return The associated {@link ModelAdapter}. The {@link FlowManager} - * may throw a {@link InvalidDBConfiguration} for this call if this class - * is not associated with a table, so be careful when using this method. - */ - private RXModelAdapter getRXModelAdapter() { - if (modelAdapter == null) { - modelAdapter = new RXModelAdapter<>(getClass()); - } - return modelAdapter; - } -} diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/structure/BaseRXModel.kt b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/structure/BaseRXModel.kt new file mode 100644 index 000000000..755af8910 --- /dev/null +++ b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/structure/BaseRXModel.kt @@ -0,0 +1,44 @@ +package com.raizlabs.android.dbflow.rx2.structure + +import com.raizlabs.android.dbflow.annotation.ColumnIgnore +import com.raizlabs.android.dbflow.config.FlowManager +import com.raizlabs.android.dbflow.structure.BaseModel +import com.raizlabs.android.dbflow.structure.InvalidDBConfiguration +import com.raizlabs.android.dbflow.structure.ModelAdapter +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper + +import io.reactivex.Completable +import io.reactivex.Single + +/** + * Description: Similar to [BaseModel] with RX constructs. Extend this for convenience methods. + */ +open class BaseRXModel { + + /** + * @return The associated [ModelAdapter]. The [FlowManager] + * may throw a [InvalidDBConfiguration] for this call if this class + * is not associated with a table, so be careful when using this method. + */ + @delegate:ColumnIgnore + @delegate:Transient + private val rxModelAdapter: RXModelAdapter by lazy { RXModelAdapter(javaClass) } + + fun DatabaseWrapper.save(): Single = + rxModelAdapter.save(this@BaseRXModel, this) + + fun DatabaseWrapper.load(): Completable = + rxModelAdapter.load(this@BaseRXModel, this) + + fun DatabaseWrapper.delete(): Single = + rxModelAdapter.delete(this@BaseRXModel, this) + + fun DatabaseWrapper.update(): Single = + rxModelAdapter.update(this@BaseRXModel, this) + + fun DatabaseWrapper.insert(): Single = + rxModelAdapter.insert(this@BaseRXModel, this) + + fun DatabaseWrapper.exists(): Single = + rxModelAdapter.exists(this@BaseRXModel, this) +} diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/structure/RXModelAdapter.java b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/structure/RXModelAdapter.java deleted file mode 100644 index 406934ee2..000000000 --- a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/structure/RXModelAdapter.java +++ /dev/null @@ -1,191 +0,0 @@ -package com.raizlabs.android.dbflow.rx2.structure; - -import com.raizlabs.android.dbflow.config.FlowManager; -import com.raizlabs.android.dbflow.structure.ModelAdapter; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; - -import java.util.Collection; -import java.util.concurrent.Callable; - -import io.reactivex.Completable; -import io.reactivex.Single; - -import static io.reactivex.Completable.fromCallable; - -/** - * Description: Wraps most {@link ModelAdapter} modification operations into RX-style constructs. - */ -public class RXModelAdapter extends RXRetrievalAdapter { - - public static RXModelAdapter from(ModelAdapter modelAdapter) { - return new RXModelAdapter<>(modelAdapter); - } - - public static RXModelAdapter from(Class table) { - return new RXModelAdapter<>(table); - } - - private final ModelAdapter modelAdapter; - - RXModelAdapter(ModelAdapter modelAdapter) { - super(modelAdapter); - this.modelAdapter = modelAdapter; - } - - public RXModelAdapter(Class table) { - this(FlowManager.getModelAdapter(table)); - } - - public Single save(final T model) { - return Single.fromCallable(new Callable() { - @Override - public Boolean call() throws Exception { - return modelAdapter.save(model); - } - }); - } - - public Single save(final T model, final DatabaseWrapper databaseWrapper) { - return Single.fromCallable(new Callable() { - @Override - public Boolean call() throws Exception { - return modelAdapter.save(model, databaseWrapper); - } - }); - } - - public Completable saveAll(final Collection models) { - return fromCallable(new Callable() { - @Override - public Void call() throws Exception { - modelAdapter.saveAll(models); - return null; - } - }); - } - - public Completable saveAll(final Collection models, final DatabaseWrapper databaseWrapper) { - return fromCallable(new Callable() { - @Override - public Void call() throws Exception { - modelAdapter.saveAll(models, databaseWrapper); - return null; - } - }); - } - - public Single insert(final T model) { - return Single.fromCallable(new Callable() { - @Override - public Long call() throws Exception { - return modelAdapter.insert(model); - } - }); - } - - public Single insert(final T model, final DatabaseWrapper databaseWrapper) { - return Single.fromCallable(new Callable() { - @Override - public Long call() throws Exception { - return modelAdapter.insert(model, databaseWrapper); - } - }); - } - - public Completable insertAll(final Collection models) { - return fromCallable(new Callable() { - @Override - public Void call() throws Exception { - modelAdapter.insertAll(models); - return null; - } - }); - } - - public Completable insertAll(final Collection models, - final DatabaseWrapper databaseWrapper) { - return fromCallable(new Callable() { - @Override - public Void call() throws Exception { - modelAdapter.insertAll(models, databaseWrapper); - return null; - } - }); - } - - public Single update(final T model) { - return Single.fromCallable(new Callable() { - @Override - public Boolean call() throws Exception { - return modelAdapter.update(model); - } - }); - } - - public Single update(final T model, final DatabaseWrapper databaseWrapper) { - return Single.fromCallable(new Callable() { - @Override - public Boolean call() throws Exception { - return modelAdapter.update(model, databaseWrapper); - } - }); - } - - public Completable updateAll(final Collection models) { - return fromCallable(new Callable() { - @Override - public Void call() throws Exception { - modelAdapter.updateAll(models); - return null; - } - }); - } - - public Completable updateAll(final Collection models, final DatabaseWrapper databaseWrapper) { - return fromCallable(new Callable() { - @Override - public Void call() throws Exception { - modelAdapter.updateAll(models, databaseWrapper); - return null; - } - }); - } - - public Single delete(final T model) { - return Single.fromCallable(new Callable() { - @Override - public Boolean call() throws Exception { - return modelAdapter.delete(model); - } - }); - } - - public Single delete(final T model, final DatabaseWrapper databaseWrapper) { - return Single.fromCallable(new Callable() { - @Override - public Boolean call() throws Exception { - return modelAdapter.delete(model, databaseWrapper); - } - }); - } - - public Completable deleteAll(final Collection models) { - return fromCallable(new Callable() { - @Override - public Void call() throws Exception { - modelAdapter.deleteAll(models); - return null; - } - }); - } - - public Completable deleteAll(final Collection models, final DatabaseWrapper databaseWrapper) { - return fromCallable(new Callable() { - @Override - public Void call() throws Exception { - modelAdapter.deleteAll(models, databaseWrapper); - return null; - } - }); - } -} diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/structure/RXModelAdapter.kt b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/structure/RXModelAdapter.kt new file mode 100644 index 000000000..eca1322f0 --- /dev/null +++ b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/structure/RXModelAdapter.kt @@ -0,0 +1,91 @@ +package com.raizlabs.android.dbflow.rx2.structure + +import com.raizlabs.android.dbflow.config.FlowManager +import com.raizlabs.android.dbflow.structure.ModelAdapter +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import io.reactivex.Completable +import io.reactivex.Completable.fromCallable +import io.reactivex.Single + +/** + * Description: Wraps most [ModelAdapter] modification operations into RX-style constructs. + */ +class RXModelAdapter internal constructor(private val modelAdapter: ModelAdapter) + : RXRetrievalAdapter(modelAdapter) { + + constructor(table: Class) : this(FlowManager.getModelAdapter(table)) + + fun save(model: T): Single = Single.fromCallable { modelAdapter.save(model) } + + fun save(model: T, databaseWrapper: DatabaseWrapper): Single = + Single.fromCallable { modelAdapter.save(model, databaseWrapper) } + + fun saveAll(models: Collection): Completable = fromCallable { + modelAdapter.saveAll(models) + null + } + + fun saveAll(models: Collection, databaseWrapper: DatabaseWrapper): Completable = + fromCallable { + modelAdapter.saveAll(models, databaseWrapper) + null + } + + fun insert(model: T): Single = Single.fromCallable { modelAdapter.insert(model) } + + fun insert(model: T, databaseWrapper: DatabaseWrapper): Single = + Single.fromCallable { modelAdapter.insert(model, databaseWrapper) } + + fun insertAll(models: Collection): Completable = fromCallable { + modelAdapter.insertAll(models) + null + } + + fun insertAll(models: Collection, + databaseWrapper: DatabaseWrapper): Completable = fromCallable { + modelAdapter.insertAll(models, databaseWrapper) + null + } + + fun update(model: T): Single = Single.fromCallable { modelAdapter.update(model) } + + fun update(model: T, databaseWrapper: DatabaseWrapper): Single = + Single.fromCallable { modelAdapter.update(model, databaseWrapper) } + + fun updateAll(models: Collection): Completable = fromCallable { + modelAdapter.updateAll(models) + null + } + + fun updateAll(models: Collection, databaseWrapper: DatabaseWrapper): Completable = + fromCallable { + modelAdapter.updateAll(models, databaseWrapper) + null + } + + fun delete(model: T): Single = Single.fromCallable { modelAdapter.delete(model) } + + fun delete(model: T, databaseWrapper: DatabaseWrapper): Single = + Single.fromCallable { modelAdapter.delete(model, databaseWrapper) } + + fun deleteAll(models: Collection): Completable = fromCallable { + modelAdapter.deleteAll(models) + null + } + + fun deleteAll(models: Collection, databaseWrapper: DatabaseWrapper): Completable = + fromCallable { + modelAdapter.deleteAll(models, databaseWrapper) + null + } + + companion object { + + @JvmStatic + fun from(modelAdapter: ModelAdapter): RXModelAdapter = + RXModelAdapter(modelAdapter) + + @JvmStatic + fun from(table: Class): RXModelAdapter = RXModelAdapter(table) + } +} diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/structure/RXRetrievalAdapter.java b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/structure/RXRetrievalAdapter.java deleted file mode 100644 index 16a46d891..000000000 --- a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/structure/RXRetrievalAdapter.java +++ /dev/null @@ -1,77 +0,0 @@ -package com.raizlabs.android.dbflow.rx2.structure; - -import com.raizlabs.android.dbflow.config.FlowManager; -import com.raizlabs.android.dbflow.structure.RetrievalAdapter; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; - -import java.util.concurrent.Callable; - -import io.reactivex.Completable; -import io.reactivex.Single; - -/** - * Description: Mirrors the {@link RetrievalAdapter} with subset of exposed methods, mostly for - * {@link #load(Object)} and {@link #exists(Object)} - */ -public class RXRetrievalAdapter { - - public static RXRetrievalAdapter from(RetrievalAdapter modelAdapter) { - return new RXRetrievalAdapter<>(modelAdapter); - } - - public static RXRetrievalAdapter from(Class table) { - return new RXRetrievalAdapter<>(table); - } - - private final RetrievalAdapter retrievalAdapter; - - RXRetrievalAdapter(RetrievalAdapter retrievalAdapter) { - this.retrievalAdapter = retrievalAdapter; - } - - RXRetrievalAdapter(Class table) { - this(FlowManager.getInstanceAdapter(table)); - } - - public Completable load(final TModel model) { - return Completable.fromCallable(new Callable() { - @Override - public Void call() throws Exception { - retrievalAdapter.load(model); - return null; - } - }); - } - - public Completable load(final TModel model, final DatabaseWrapper databaseWrapper) { - return Completable.fromCallable(new Callable() { - @Override - public Void call() throws Exception { - retrievalAdapter.load(model, databaseWrapper); - return null; - } - }); - } - - /** - * @param model The model to query values from - * @return True if it exists as a row in the corresponding database table - */ - public Single exists(final TModel model) { - return Single.fromCallable(new Callable() { - @Override - public Boolean call() throws Exception { - return retrievalAdapter.exists(model); - } - }); - } - - public Single exists(final TModel model, final DatabaseWrapper wrapper) { - return Single.fromCallable(new Callable() { - @Override - public Boolean call() throws Exception { - return retrievalAdapter.exists(model, wrapper); - } - }); - } -} diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/structure/RXRetrievalAdapter.kt b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/structure/RXRetrievalAdapter.kt new file mode 100644 index 000000000..fbeac4994 --- /dev/null +++ b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/structure/RXRetrievalAdapter.kt @@ -0,0 +1,41 @@ +package com.raizlabs.android.dbflow.rx2.structure + +import com.raizlabs.android.dbflow.config.FlowManager +import com.raizlabs.android.dbflow.structure.RetrievalAdapter +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import io.reactivex.Completable +import io.reactivex.Single + +/** + * Description: Mirrors the [RetrievalAdapter] with subset of exposed methods, mostly for + * [.load] and [.exists] + */ +open class RXRetrievalAdapter +internal constructor(private val retrievalAdapter: RetrievalAdapter) { + + internal constructor(table: Class) : this(FlowManager.getInstanceAdapter(table)) + + fun load(model: T, databaseWrapper: DatabaseWrapper): Completable = Completable.fromCallable { + retrievalAdapter.load(model, databaseWrapper) + null + } + + /** + * @param model The model to query values from + * @return True if it exists as a row in the corresponding database table + */ + fun exists(model: T): Single = Single.fromCallable { retrievalAdapter.exists(model) } + + fun exists(model: T, wrapper: DatabaseWrapper): Single = + Single.fromCallable { retrievalAdapter.exists(model, wrapper) } + + companion object { + + @JvmStatic + fun from(modelAdapter: RetrievalAdapter): RXRetrievalAdapter = + RXRetrievalAdapter(modelAdapter) + + @JvmStatic + fun from(table: Class): RXRetrievalAdapter = RXRetrievalAdapter(table) + } +} diff --git a/dbflow-tests/build.gradle b/dbflow-tests/build.gradle index 3a9e11ae8..64b03de46 100644 --- a/dbflow-tests/build.gradle +++ b/dbflow-tests/build.gradle @@ -51,9 +51,7 @@ dependencies { implementation project("${dbflow_project_prefix}dbflow") implementation project("${dbflow_project_prefix}dbflow-sqlcipher") implementation project("${dbflow_project_prefix}dbflow-rx") - implementation project("${dbflow_project_prefix}dbflow-rx-kotlinextensions") implementation project("${dbflow_project_prefix}dbflow-rx2") - implementation project("${dbflow_project_prefix}dbflow-rx2-kotlinextensions") kaptTest project("${dbflow_project_prefix}dbflow-processor") kaptAndroidTest project("${dbflow_project_prefix}dbflow-processor") diff --git a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/contentobserver/ContentObserverTest.kt b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/contentobserver/ContentObserverTest.kt index 09c28d61d..0ad534751 100644 --- a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/contentobserver/ContentObserverTest.kt +++ b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/contentobserver/ContentObserverTest.kt @@ -4,12 +4,13 @@ import android.net.Uri import com.raizlabs.android.dbflow.BaseInstrumentedUnitTest import com.raizlabs.android.dbflow.DemoApp import com.raizlabs.android.dbflow.config.FlowManager +import com.raizlabs.android.dbflow.config.writableDatabaseForTable import com.raizlabs.android.dbflow.contentobserver.User_Table.id import com.raizlabs.android.dbflow.contentobserver.User_Table.name import com.raizlabs.android.dbflow.runtime.FlowContentObserver import com.raizlabs.android.dbflow.sql.getNotificationUri -import com.raizlabs.android.dbflow.sql.language.Delete import com.raizlabs.android.dbflow.sql.language.SQLOperator +import com.raizlabs.android.dbflow.sql.language.delete import com.raizlabs.android.dbflow.structure.BaseModel import com.raizlabs.android.dbflow.structure.delete import com.raizlabs.android.dbflow.structure.insert @@ -27,7 +28,9 @@ class ContentObserverTest : BaseInstrumentedUnitTest() { @Before fun setupUser() { - Delete.table(User::class.java) + writableDatabaseForTable { + (delete() from User::class).execute() + } user = User(5, "Something", 55) } diff --git a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/prepackaged/PrepackagedDBTest.kt b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/prepackaged/PrepackagedDBTest.kt index ca368af96..1bbc5468a 100644 --- a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/prepackaged/PrepackagedDBTest.kt +++ b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/prepackaged/PrepackagedDBTest.kt @@ -1,6 +1,7 @@ package com.raizlabs.android.dbflow.prepackaged import com.raizlabs.android.dbflow.BaseInstrumentedUnitTest +import com.raizlabs.android.dbflow.config.writableDatabaseForTable import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.sql.queriable.list import org.junit.Assert.assertTrue @@ -13,8 +14,9 @@ class PrepackagedDBTest : BaseInstrumentedUnitTest() { @Test fun assertWeCanLoadFromDB() { - val list = (select from Dog::class).list - - assertTrue(!list.isEmpty()) + writableDatabaseForTable { + val list = (select from Dog::class).list + assertTrue(!list.isEmpty()) + } } } diff --git a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/sqlcipher/CipherTest.kt b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/sqlcipher/CipherTest.kt index e95b7fe0e..4e2062a52 100644 --- a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/sqlcipher/CipherTest.kt +++ b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/sqlcipher/CipherTest.kt @@ -1,7 +1,8 @@ package com.raizlabs.android.dbflow.sqlcipher import com.raizlabs.android.dbflow.BaseInstrumentedUnitTest -import com.raizlabs.android.dbflow.sql.language.Delete +import com.raizlabs.android.dbflow.config.writableDatabase +import com.raizlabs.android.dbflow.sql.language.delete import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.sql.language.where import com.raizlabs.android.dbflow.sql.queriable.result @@ -14,15 +15,16 @@ import org.junit.Test class CipherTest : BaseInstrumentedUnitTest() { @Test - fun testCipherModel() { - Delete.table(CipherModel::class.java) + fun testCipherModel() = writableDatabase(CipherDatabase::class) { + (delete() from CipherModel::class).execute() val model = CipherModel(name = "name") - model.save() + model.save(this) + assertTrue(model.exists(this)) - assertTrue(model.exists()) - - val retrieval = (select from CipherModel::class where CipherModel_Table.name.eq("name")).result + val retrieval = (select from CipherModel::class + where CipherModel_Table.name.eq("name")) + .result assertTrue(retrieval!!.id == model.id) - Delete.table(CipherModel::class.java) + (delete() from CipherModel::class).execute() } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/contentprovider/ContentProviderTests.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/contentprovider/ContentProviderTests.kt index 3c39d8cd3..20109adfb 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/contentprovider/ContentProviderTests.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/contentprovider/ContentProviderTests.kt @@ -3,11 +3,18 @@ package com.raizlabs.android.dbflow.contentprovider import android.content.ContentResolver import android.content.pm.ProviderInfo import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.sql.language.Delete +import com.raizlabs.android.dbflow.config.writableDatabase +import com.raizlabs.android.dbflow.sql.language.Delete.Companion.table +import com.raizlabs.android.dbflow.sql.language.Delete.Companion.tables import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.sql.language.where import com.raizlabs.android.dbflow.sql.queriable.result +import com.raizlabs.android.dbflow.structure.delete +import com.raizlabs.android.dbflow.structure.exists +import com.raizlabs.android.dbflow.structure.insert import com.raizlabs.android.dbflow.structure.provider.ContentUtils +import com.raizlabs.android.dbflow.structure.save +import com.raizlabs.android.dbflow.structure.update import org.junit.Assert.* import org.junit.Before import org.junit.Test @@ -29,8 +36,8 @@ class ContentProviderTests : BaseUnitTest() { } @Test - fun testContentProviderUtils() { - Delete.tables(NoteModel::class.java, ContentProviderModel::class.java) + fun testContentProviderUtils() = writableDatabase(ContentDatabase::class) { + tables(NoteModel::class.java, ContentProviderModel::class.java) val contentProviderModel = ContentProviderModel() contentProviderModel.notes = "Test" @@ -42,7 +49,7 @@ class ContentProviderTests : BaseUnitTest() { val update = ContentUtils.update(mockContentResolver, TestContentProvider.ContentProviderModel.CONTENT_URI, contentProviderModel) assertEquals(update.toLong(), 1) assertTrue(contentProviderModel.exists()) - contentProviderModel.load() + contentProviderModel.load(this) assertEquals("NewTest", contentProviderModel.notes) val noteModel = NoteModel() @@ -58,12 +65,12 @@ class ContentProviderTests : BaseUnitTest() { assertTrue(ContentUtils.delete(mockContentResolver, TestContentProvider.ContentProviderModel.CONTENT_URI, contentProviderModel) > 0) assertTrue(!contentProviderModel.exists()) - Delete.tables(NoteModel::class.java, ContentProviderModel::class.java) + tables(NoteModel::class.java, ContentProviderModel::class.java) } @Test - fun testContentProviderNative() { - Delete.tables(NoteModel::class.java, ContentProviderModel::class.java) + fun testContentProviderNative() = writableDatabase(ContentDatabase::class) { + tables(NoteModel::class.java, ContentProviderModel::class.java) val contentProviderModel = ContentProviderModel(notes = "Test") contentProviderModel.insert() @@ -71,7 +78,7 @@ class ContentProviderTests : BaseUnitTest() { contentProviderModel.notes = "NewTest" contentProviderModel.update() - contentProviderModel.load() + contentProviderModel.load(this) assertEquals("NewTest", contentProviderModel.notes) val noteModel = NoteModel(note = "Test", contentProviderModel = contentProviderModel) @@ -79,7 +86,7 @@ class ContentProviderTests : BaseUnitTest() { noteModel.note = "NewTest" noteModel.update() - noteModel.load() + noteModel.load(this) assertEquals("NewTest", noteModel.note) assertTrue(noteModel.exists()) @@ -90,12 +97,12 @@ class ContentProviderTests : BaseUnitTest() { contentProviderModel.delete() assertTrue(!contentProviderModel.exists()) - Delete.tables(NoteModel::class.java, ContentProviderModel::class.java) + tables(NoteModel::class.java, ContentProviderModel::class.java) } @Test - fun testSyncableModel() { - Delete.table(TestSyncableModel::class.java) + fun testSyncableModel() = writableDatabase(ContentDatabase::class) { + table(TestSyncableModel::class.java) var testSyncableModel = TestSyncableModel(name = "Name") testSyncableModel.save() @@ -110,7 +117,7 @@ class ContentProviderTests : BaseUnitTest() { where (TestSyncableModel_Table.id.`is`(testSyncableModel.id))).result!! val fromContentProvider = TestSyncableModel(id = testSyncableModel.id) - fromContentProvider.load() + fromContentProvider.load(this) assertEquals(fromContentProvider.name, testSyncableModel.name) assertEquals(fromContentProvider.id, testSyncableModel.id) @@ -118,7 +125,7 @@ class ContentProviderTests : BaseUnitTest() { testSyncableModel.delete() assertFalse(testSyncableModel.exists()) - Delete.table(TestSyncableModel::class.java) + table(TestSyncableModel::class.java) } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/FastStoreModelTransactionTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/FastStoreModelTransactionTest.kt index ce4a631a1..48e7e14d2 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/FastStoreModelTransactionTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/FastStoreModelTransactionTest.kt @@ -20,46 +20,46 @@ class FastStoreModelTransactionTest : BaseUnitTest() { @Test fun testSaveBuilder() { - database() - .beginTransactionAsync((0..9) - .map { SimpleModel("$it") } - .fastSave().build()) - .execute() + database(TestDatabase::class) { + beginTransactionAsync((0..9) + .map { SimpleModel("$it") } + .fastSave().build()) + .execute() - val list = (select from SimpleModel::class).list - assertEquals(10, list.size) + val list = (writableDatabase.select from SimpleModel::class).list + assertEquals(10, list.size) + } } @Test fun testInsertBuilder() { + database(TestDatabase::class) { + beginTransactionAsync((0..9) + .map { SimpleModel("$it") } + .fastInsert().build()) + .execute() - database() - .beginTransactionAsync((0..9) - .map { SimpleModel("$it") } - .fastInsert().build()) - .execute() - - val list = (select from SimpleModel::class).list - assertEquals(10, list.size) + val list = (writableDatabase.select from SimpleModel::class).list + assertEquals(10, list.size) + } } @Test fun testUpdateBuilder() { + database(TestDatabase::class) { + val oldList = (0..9).map { TwoColumnModel("$it", Random().nextInt()) } + beginTransactionAsync(oldList.fastInsert().build()) + .execute() - val oldList = (0..9).map { TwoColumnModel("$it", Random().nextInt()) } - database() - .beginTransactionAsync(oldList.fastInsert().build()) - .execute() - - database() - .beginTransactionAsync((0..9).map { TwoColumnModel("$it", Random().nextInt()) } - .fastUpdate().build()) - .execute() + beginTransactionAsync((0..9).map { TwoColumnModel("$it", Random().nextInt()) } + .fastUpdate().build()) + .execute() - val list = (select from TwoColumnModel::class).list - assertEquals(10, list.size) - list.forEachIndexed { index, model -> - assertNotEquals(model, oldList[index]) + val list = (writableDatabase.select from TwoColumnModel::class).list + assertEquals(10, list.size) + list.forEachIndexed { index, model -> + assertNotEquals(model, oldList[index]) + } } } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorIteratorTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorIteratorTest.kt index be0a93d09..135f57c92 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorIteratorTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorIteratorTest.kt @@ -1,6 +1,7 @@ package com.raizlabs.android.dbflow.list import com.raizlabs.android.dbflow.BaseUnitTest +import com.raizlabs.android.dbflow.config.writableDatabaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.structure.save @@ -15,44 +16,49 @@ class FlowCursorIteratorTest : BaseUnitTest() { @Test fun testCanIterateFullList() { - (0..9).forEach { - SimpleModel("$it").save() - } + writableDatabaseForTable { + (0..9).forEach { + SimpleModel("$it").save() + } - var count = 0 - (select from SimpleModel::class).cursorList().iterator().forEach { - assertEquals("$count", it.name) - count++ + var count = 0 + (select from SimpleModel::class).cursorList().iterator().forEach { + assertEquals("$count", it.name) + count++ + } } - } @Test fun testCanIteratePartialList() { - (0..9).forEach { - SimpleModel("$it").save() - } + writableDatabaseForTable { + (0..9).forEach { + SimpleModel("$it").save() + } - var count = 2 - (select from SimpleModel::class).cursorList().iterator(2, 7).forEach { - assertEquals("$count", it.name) - count++ + var count = 2 + (select from SimpleModel::class).cursorList().iterator(2, 7).forEach { + assertEquals("$count", it.name) + count++ + } + assertEquals(7, count) } - assertEquals(7, count) } @Test fun testCanSupplyBadMaximumValue() { - (0..9).forEach { - SimpleModel("$it").save() - } + writableDatabaseForTable { + (0..9).forEach { + SimpleModel("$it").save() + } - var count = 2 - (select from SimpleModel::class).cursorList().iterator(2, Long.MAX_VALUE).forEach { - assertEquals("$count", it.name) - count++ + var count = 2 + (select from SimpleModel::class).cursorList().iterator(2, Long.MAX_VALUE).forEach { + assertEquals("$count", it.name) + count++ + } + assertEquals(8, count) } - assertEquals(8, count) } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorListTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorListTest.kt index 609ccb0f6..168362ff8 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorListTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorListTest.kt @@ -4,6 +4,7 @@ import com.nhaarman.mockito_kotlin.mock import com.nhaarman.mockito_kotlin.times import com.nhaarman.mockito_kotlin.verify import com.raizlabs.android.dbflow.BaseUnitTest +import com.raizlabs.android.dbflow.config.writableDatabaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.sql.queriable.cursor @@ -18,55 +19,63 @@ class FlowCursorListTest : BaseUnitTest() { @Test fun validateCursorPassed() { - val cursor = (select from SimpleModel::class).cursor - val list = FlowCursorList.Builder(select from SimpleModel::class) - .cursor(cursor) - .build() + writableDatabaseForTable { + val cursor = (select from SimpleModel::class).cursor + val list = FlowCursorList.Builder(select from SimpleModel::class) + .cursor(cursor) + .build() - assertEquals(cursor, list.cursor()) + assertEquals(cursor, list.cursor()) + } } @Test fun validateModelQueriable() { - val modelQueriable = (select from SimpleModel::class) - val list = FlowCursorList.Builder(modelQueriable) - .build() + writableDatabaseForTable { + val modelQueriable = (select from SimpleModel::class) + val list = FlowCursorList.Builder(modelQueriable) + .build() - assertEquals(modelQueriable, list.modelQueriable) + assertEquals(modelQueriable, list.modelQueriable) + } } @Test fun validateGetAll() { - (0..9).forEach { - SimpleModel("$it").save() - } + writableDatabaseForTable { + (0..9).forEach { + SimpleModel("$it").save() + } - val list = (select from SimpleModel::class).cursorList() - val all = list.all - assertEquals(list.count, all.size.toLong()) + val list = (select from SimpleModel::class).cursorList() + val all = list.all + assertEquals(list.count, all.size.toLong()) + } } @Test fun validateCursorChange() { - (0..9).forEach { - SimpleModel("$it").save() - } + writableDatabaseForTable { + (0..9).forEach { + SimpleModel("$it").save() + } - val list = (select from SimpleModel::class).cursorList() + val list = (select from SimpleModel::class).cursorList() - val listener = mock>() - list.addOnCursorRefreshListener(listener) - assertEquals(10, list.count) - SimpleModel("10").save() - list.refresh() - assertEquals(11, list.count) + val listener = mock>() + list.addOnCursorRefreshListener(listener) + assertEquals(10, list.count) + SimpleModel("10").save() + list.refresh() + assertEquals(11, list.count) - verify(listener).onCursorRefreshed(list) + verify(listener).onCursorRefreshed(list) - list.removeOnCursorRefreshListener(listener) + list.removeOnCursorRefreshListener(listener) - list.refresh() - verify(listener, times(1)).onCursorRefreshed(list) + list.refresh() + verify(listener, times(1)).onCursorRefreshed(list) + } } } diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowQueryListTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowQueryListTest.kt index 445a81439..3932c454d 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowQueryListTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowQueryListTest.kt @@ -1,6 +1,7 @@ package com.raizlabs.android.dbflow.list import com.raizlabs.android.dbflow.BaseUnitTest +import com.raizlabs.android.dbflow.config.writableDatabaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.sql.language.select import org.junit.Assert.assertTrue @@ -10,13 +11,14 @@ class FlowQueryListTest : BaseUnitTest() { @Test fun validateBuilder() { + writableDatabaseForTable { + val list = FlowQueryList.Builder(select from SimpleModel::class) + .transact(true) + .changeInTransaction(true) + .build() - val list = FlowQueryList.Builder(select from SimpleModel::class) - .transact(true) - .changeInTransaction(true) - .build() - - assertTrue(list.transact) - assertTrue(list.changeInTransaction()) + assertTrue(list.transact) + assertTrue(list.changeInTransaction()) + } } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/CachingModelsTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/CachingModelsTest.kt index fe396eb08..b74cf5023 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/CachingModelsTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/CachingModelsTest.kt @@ -1,6 +1,8 @@ package com.raizlabs.android.dbflow.models import com.raizlabs.android.dbflow.BaseUnitTest +import com.raizlabs.android.dbflow.TestDatabase +import com.raizlabs.android.dbflow.config.writableDatabase import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.sql.queriable.list import com.raizlabs.android.dbflow.sql.queriable.result @@ -15,7 +17,7 @@ import org.junit.Test class CachingModelsTest : BaseUnitTest() { @Test - fun testSimpleCache() { + fun testSimpleCache() = writableDatabase(TestDatabase::class) { val list = arrayListOf() (0..9).forEach { val simpleCacheObject = SimpleCacheObject("$it") @@ -31,7 +33,7 @@ class CachingModelsTest : BaseUnitTest() { } @Test - fun testComplexObject() { + fun testComplexObject() = writableDatabase(TestDatabase::class) { val path = Path("1", "Path") path.save() diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/DontCreateModelTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/DontCreateModelTest.kt index d645f619e..46b253e34 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/DontCreateModelTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/DontCreateModelTest.kt @@ -3,6 +3,7 @@ package com.raizlabs.android.dbflow.models import android.database.sqlite.SQLiteException import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.assertThrowsException +import com.raizlabs.android.dbflow.config.writableDatabaseForTable import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.sql.queriable.list import org.junit.Test @@ -13,7 +14,7 @@ import org.junit.Test class DontCreateModelTest : BaseUnitTest() { @Test - fun testModelNotCreated() { + fun testModelNotCreated() = writableDatabaseForTable { assertThrowsException(SQLiteException::class) { (select from DontCreateModel::class).list } diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ModelViewTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ModelViewTest.kt index cf56447cb..cf5558f07 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ModelViewTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ModelViewTest.kt @@ -1,20 +1,22 @@ package com.raizlabs.android.dbflow.models import com.raizlabs.android.dbflow.BaseUnitTest +import com.raizlabs.android.dbflow.TestDatabase import com.raizlabs.android.dbflow.assertEquals +import com.raizlabs.android.dbflow.config.writableDatabase import com.raizlabs.android.dbflow.models.java.JavaModelView import org.junit.Test class ModelViewTest : BaseUnitTest() { @Test - fun validateModelViewQuery() { + fun validateModelViewQuery() = writableDatabase(TestDatabase::class) { assertEquals("SELECT `id` AS `authorId`,`first_name` || ' ' || `last_name` AS `authorName` FROM `Author`", - AuthorView.query) + AuthorView.getQuery(this)) } @Test - fun validateJavaModelViewQuery() { - assertEquals("SELECT `first_name` AS `firstName`,`id` AS `id`", JavaModelView.QUERY) + fun validateJavaModelViewQuery() = writableDatabase(TestDatabase::class) { + assertEquals("SELECT `first_name` AS `firstName`,`id` AS `id`", JavaModelView.getQuery(this)) } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ModelViews.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ModelViews.kt index c36ce2a1a..4aeb27eef 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ModelViews.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ModelViews.kt @@ -6,9 +6,10 @@ import com.raizlabs.android.dbflow.annotation.ColumnMap import com.raizlabs.android.dbflow.annotation.ModelView import com.raizlabs.android.dbflow.annotation.ModelViewQuery import com.raizlabs.android.dbflow.models.Author_Table.* -import com.raizlabs.android.dbflow.sql.language.SQLite.select import com.raizlabs.android.dbflow.sql.language.property.IProperty import com.raizlabs.android.dbflow.sql.language.property.property +import com.raizlabs.android.dbflow.sql.language.select +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper class AuthorName(var name: String = "", var age: Int = 0) @@ -18,9 +19,9 @@ class AuthorView(@Column var authorId: Int = 0, @Column var authorName: String = @ColumnMap var author: AuthorName? = null) { companion object { - @JvmField + @JvmStatic @ModelViewQuery - val query = (select(id.`as`("authorId"), + fun getQuery(wrapper: DatabaseWrapper) = (wrapper.select(id.`as`("authorId"), first_name.concatenate(" ".property as IProperty>) .concatenate(last_name as IProperty>) .`as`("authorName")) @@ -32,8 +33,9 @@ class AuthorView(@Column var authorId: Int = 0, @Column var authorName: String = class PriorityView(var name: String = "") { companion object { - @JvmField + @JvmStatic @ModelViewQuery - val query = select((first_name + last_name).`as`("name")) from Author::class + fun getQuery(wrapper: DatabaseWrapper) = + wrapper.select((first_name + last_name).`as`("name")) from Author::class } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModelTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModelTest.kt index 4744520b3..ba1b6bb50 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModelTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModelTest.kt @@ -1,6 +1,8 @@ package com.raizlabs.android.dbflow.models import com.raizlabs.android.dbflow.BaseUnitTest +import com.raizlabs.android.dbflow.TestDatabase +import com.raizlabs.android.dbflow.config.writableDatabase import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.sql.queriable.list import com.raizlabs.android.dbflow.sql.queriable.result @@ -13,8 +15,7 @@ import org.junit.Test class OneToManyModelTest : BaseUnitTest() { @Test - fun testOneToManyModel() { - + fun testOneToManyModel() = writableDatabase(TestDatabase::class) { var testModel2 = TwoColumnModel("Greater", 4) testModel2.save() @@ -28,8 +29,8 @@ class OneToManyModelTest : BaseUnitTest() { // assert loading works as expected. oneToManyModel = (select from OneToManyModel::class).result!! - assertNotNull(oneToManyModel.getRelatedOrders()) - assertTrue(!oneToManyModel.getRelatedOrders().isEmpty()) + assertNotNull(oneToManyModel.getRelatedOrders(this)) + assertTrue(!oneToManyModel.getRelatedOrders(this).isEmpty()) // assert the deletion cleared the variable oneToManyModel.delete() @@ -39,6 +40,5 @@ class OneToManyModelTest : BaseUnitTest() { // assert singular relationship was deleted. val list = (select from TwoColumnModel::class).list assertTrue(list.size == 1) - } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModels.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModels.kt index 6d473a559..dea5f0bc5 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModels.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModels.kt @@ -5,10 +5,12 @@ import com.raizlabs.android.dbflow.annotation.OneToMany import com.raizlabs.android.dbflow.annotation.OneToManyMethod import com.raizlabs.android.dbflow.annotation.PrimaryKey import com.raizlabs.android.dbflow.annotation.Table +import com.raizlabs.android.dbflow.config.writableDatabase import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.sql.language.where import com.raizlabs.android.dbflow.structure.BaseModel +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper import com.raizlabs.android.dbflow.structure.oneToMany @Table(database = TestDatabase::class) @@ -19,14 +21,18 @@ class OneToManyModel(@PrimaryKey var name: String? = null) { var models: List? = null @get:OneToMany(oneToManyMethods = arrayOf(OneToManyMethod.ALL)) - var simpleModels by oneToMany { select from OneToManyBaseModel::class } + var simpleModels by oneToMany { + writableDatabase(OneToManyBaseModel::class) { + select from OneToManyBaseModel::class + } + } @OneToMany(oneToManyMethods = arrayOf(OneToManyMethod.ALL), isVariablePrivate = true, variableName = "orders", efficientMethods = false) - fun getRelatedOrders(): List { + fun getRelatedOrders(wrapper: DatabaseWrapper): List { var localOrders = orders if (localOrders == null) { - localOrders = (select from TwoColumnModel::class where id.greaterThan(3)) + localOrders = (wrapper.select from TwoColumnModel::class where id.greaterThan(3)) .queryList() } orders = localOrders @@ -35,10 +41,10 @@ class OneToManyModel(@PrimaryKey var name: String? = null) { @OneToMany(oneToManyMethods = arrayOf(OneToManyMethod.DELETE), isVariablePrivate = true, variableName = "models") - fun getRelatedModels(): List { + fun getRelatedModels(wrapper: DatabaseWrapper): List { var localModels = models if (localModels == null) { - localModels = (select from OneToManyBaseModel::class).queryList() + localModels = (wrapper.select from OneToManyBaseModel::class).queryList() } models = localModels return localModels diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ParentChildCachingTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ParentChildCachingTest.kt index 91a9ac558..ec2ce4d85 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ParentChildCachingTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ParentChildCachingTest.kt @@ -1,8 +1,12 @@ package com.raizlabs.android.dbflow.models import com.raizlabs.android.dbflow.BaseUnitTest +import com.raizlabs.android.dbflow.TestDatabase +import com.raizlabs.android.dbflow.config.writableDatabase import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.sql.queriable.result +import com.raizlabs.android.dbflow.structure.load +import com.raizlabs.android.dbflow.structure.save import org.junit.Assert.assertEquals import org.junit.Test @@ -13,7 +17,7 @@ class ParentChildCachingTest : BaseUnitTest() { @Test - fun testCanLoadChildFromCache() { + fun testCanLoadChildFromCache() = writableDatabase(TestDatabase::class) { val child = TestModelChild() child.id = 1 child.name = "Test child" diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/QueryModelTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/QueryModelTest.kt index 4182cb3f0..5aeb0e3ae 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/QueryModelTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/QueryModelTest.kt @@ -1,13 +1,15 @@ package com.raizlabs.android.dbflow.models import com.raizlabs.android.dbflow.BaseUnitTest +import com.raizlabs.android.dbflow.TestDatabase +import com.raizlabs.android.dbflow.config.writableDatabase import com.raizlabs.android.dbflow.models.Author_Table.id import com.raizlabs.android.dbflow.models.Blog_Table.author_id import com.raizlabs.android.dbflow.models.Blog_Table.name -import com.raizlabs.android.dbflow.sql.language.SQLite.select import com.raizlabs.android.dbflow.sql.language.eq import com.raizlabs.android.dbflow.sql.language.innerJoin import com.raizlabs.android.dbflow.sql.language.on +import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.structure.exists import com.raizlabs.android.dbflow.structure.save import org.junit.Assert.assertEquals @@ -20,7 +22,7 @@ class QueryModelTest : BaseUnitTest() { @Test - fun testCanLoadAuthorBlogs() { + fun testCanLoadAuthorBlogs() = writableDatabase(TestDatabase::class) { val author = Author(0, "Andrew", "Grosner") author.save() val blog = Blog(0, "My First Blog", author) diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/Issue.java b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/Issue.java index 9e96f77c0..e3cacf45e 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/Issue.java +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/Issue.java @@ -7,9 +7,12 @@ import com.raizlabs.android.dbflow.annotation.Table; import com.raizlabs.android.dbflow.sql.language.SQLite; import com.raizlabs.android.dbflow.structure.BaseModel; +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; import java.util.List; +import static com.raizlabs.android.dbflow.sql.language.SQLite.select; + /** * Description: */ @@ -23,9 +26,9 @@ public class Issue extends BaseModel { List subIssueList; @OneToMany(oneToManyMethods = {OneToManyMethod.SAVE, OneToManyMethod.DELETE}, variableName = "subIssueList") - public List getDbSubIssueList() { + public List getDbSubIssueList(DatabaseWrapper databaseWrapper) { if (subIssueList == null || subIssueList.isEmpty()) { - subIssueList = SQLite.INSTANCE.select() + subIssueList = select(databaseWrapper) .from(SubIssue.class) .where(SubIssue_Table.owningIssueId.eq(id)) .queryList(); diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/SubIssue.java b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/SubIssue.java index dc7c1e32f..67cce6d10 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/SubIssue.java +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/SubIssue.java @@ -5,12 +5,14 @@ import com.raizlabs.android.dbflow.annotation.OneToManyMethod; import com.raizlabs.android.dbflow.annotation.PrimaryKey; import com.raizlabs.android.dbflow.annotation.Table; -import com.raizlabs.android.dbflow.sql.language.SQLite; import com.raizlabs.android.dbflow.structure.BaseModel; +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; import java.util.ArrayList; import java.util.List; +import static com.raizlabs.android.dbflow.sql.language.SQLite.select; + /** * Description: */ @@ -27,12 +29,12 @@ public class SubIssue extends BaseModel { List pageList; @OneToMany(oneToManyMethods = {OneToManyMethod.SAVE, OneToManyMethod.DELETE}, variableName = "pageList") - public List getDbPageList() { + public List getDbPageList(DatabaseWrapper databaseWrapper) { if (pageList == null) { pageList = new ArrayList<>(); } if (pageList.isEmpty()) { - pageList = SQLite.INSTANCE.select() + pageList = select(databaseWrapper) .from(Page.class) .where(Page_Table.owningIssueId.eq(owningIssueId), Page_Table.subIssue_id.eq(id)) .queryList(); diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/java/JavaModelView.java b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/java/JavaModelView.java index ba0e31884..c9acb8887 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/java/JavaModelView.java +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/java/JavaModelView.java @@ -7,12 +7,15 @@ import com.raizlabs.android.dbflow.models.Author_Table; import com.raizlabs.android.dbflow.sql.Query; import com.raizlabs.android.dbflow.sql.language.SQLite; +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; @ModelView(database = TestDatabase.class) public class JavaModelView { @ModelViewQuery - public static final Query QUERY = getQuery(); + public static Query getQuery(DatabaseWrapper databaseWrapper) { + return SQLite.select(databaseWrapper, Author_Table.first_name.as("firstName"), Author_Table.id.as("id")); + } @Column String id; @@ -20,7 +23,4 @@ public class JavaModelView { @Column Integer firstName; - private static Query getQuery() { - return SQLite.INSTANCE.select(Author_Table.first_name.as("firstName"), Author_Table.id.as("id")); - } } diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/runtime/DirectNotifierTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/runtime/DirectNotifierTest.kt index bedb2aea0..2a3a30419 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/runtime/DirectNotifierTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/runtime/DirectNotifierTest.kt @@ -9,6 +9,7 @@ import com.raizlabs.android.dbflow.TestDatabase import com.raizlabs.android.dbflow.config.DatabaseConfig import com.raizlabs.android.dbflow.config.FlowConfig import com.raizlabs.android.dbflow.config.FlowManager +import com.raizlabs.android.dbflow.config.writableDatabaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table import com.raizlabs.android.dbflow.sql.language.columnValues @@ -67,7 +68,7 @@ class DirectNotifierTest { } @Test - fun validateCanNotifyWrapperClasses() { + fun validateCanNotifyWrapperClasses() = writableDatabaseForTable { val modelChange = Mockito.mock(OnTableChangedListener::class.java) DirectModelNotifier.get().registerForTableChanges(SimpleModel::class.java, modelChange) diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriberTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriberTest.kt index e1947bd24..7aa3bce12 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriberTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriberTest.kt @@ -1,8 +1,8 @@ package com.raizlabs.android.dbflow.rx.language import com.raizlabs.android.dbflow.BaseUnitTest +import com.raizlabs.android.dbflow.config.writableDatabaseForTable import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.rx.kotlinextensions.rx import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.structure.save import org.junit.Assert.assertEquals @@ -12,7 +12,7 @@ class CursorResultSubscriberTest : BaseUnitTest() { @Test - fun testCanQueryStreamResults() { + fun testCanQueryStreamResults() = writableDatabaseForTable { (0..9).forEach { SimpleModel("$it").save() } var count = 0 diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/RXQueryTests.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/RXQueryTests.kt index 35307cb3b..baffc6433 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/RXQueryTests.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/RXQueryTests.kt @@ -2,14 +2,13 @@ package com.raizlabs.android.dbflow.rx.language import android.database.Cursor import com.raizlabs.android.dbflow.BaseUnitTest +import com.raizlabs.android.dbflow.config.writableDatabaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table.name -import com.raizlabs.android.dbflow.rx.kotlinextensions.rx -import com.raizlabs.android.dbflow.rx.kotlinextensions.rxBaseQueriable -import com.raizlabs.android.dbflow.sql.language.SQLite.selectCountOf import com.raizlabs.android.dbflow.sql.language.insert import com.raizlabs.android.dbflow.sql.language.property.Property import com.raizlabs.android.dbflow.sql.language.select +import com.raizlabs.android.dbflow.sql.language.selectCountOf import com.raizlabs.android.dbflow.structure.database.DatabaseStatement import com.raizlabs.android.dbflow.structure.save import org.junit.Assert.assertEquals @@ -19,7 +18,7 @@ import org.junit.Test class RXQueryTests : BaseUnitTest() { @Test - fun testCanQuery() { + fun testCanQuery() = writableDatabaseForTable { SimpleModel("Name").save() var cursor: Cursor? = null @@ -34,7 +33,7 @@ class RXQueryTests : BaseUnitTest() { } @Test - fun testCanCompileStatement() { + fun testCanCompileStatement() = writableDatabaseForTable { var databaseStatement: DatabaseStatement? = null (insert().columnValues(name.`is`("name"))) .rxBaseQueriable().compileStatement() @@ -46,7 +45,7 @@ class RXQueryTests : BaseUnitTest() { } @Test - fun testCountMethod() { + fun testCountMethod() = writableDatabaseForTable{ SimpleModel("name").save() SimpleModel("name2").save() var count = 0L @@ -59,7 +58,7 @@ class RXQueryTests : BaseUnitTest() { } @Test - fun testInsertMethod() { + fun testInsertMethod() = writableDatabaseForTable { var count = 0L (insert().columnValues(name.eq("name"))) .rxBaseQueriable() diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CursorResultTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CursorResultTest.kt index 98aff2271..af93e0972 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CursorResultTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CursorResultTest.kt @@ -2,6 +2,7 @@ package com.raizlabs.android.dbflow.sql.language import android.database.StaleDataException import com.raizlabs.android.dbflow.BaseUnitTest +import com.raizlabs.android.dbflow.config.writableDatabaseForTable import com.raizlabs.android.dbflow.models.SimpleCustomModel import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.sql.queriable.cursorResult @@ -15,7 +16,7 @@ class CursorResultTest : BaseUnitTest() { lateinit var result: CursorResult @Before - fun prepareList() { + fun prepareList() = writableDatabaseForTable { (0..9).forEach { SimpleModel("$it").save() } result = (select from SimpleModel::class).cursorResult } diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/DeleteTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/DeleteTest.kt index f10768835..3cc8b5c3b 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/DeleteTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/DeleteTest.kt @@ -1,6 +1,7 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest +import com.raizlabs.android.dbflow.config.writableDatabaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table import com.raizlabs.android.dbflow.sql.queriable.list @@ -12,19 +13,19 @@ import org.junit.Test class DeleteTest : BaseUnitTest() { @Test - fun validateQuery() { - assertEquals("DELETE ", Delete().query) + fun validateQuery() = writableDatabaseForTable { + assertEquals("DELETE ", delete().query) } @Test - fun validateDeletion() { + fun validateDeletion() = writableDatabaseForTable { SimpleModel("name").save() delete().execute() assertFalse((select from SimpleModel::class).hasData()) } @Test - fun validateDeletionWithQuery() { + fun validateDeletionWithQuery() = writableDatabaseForTable { SimpleModel("name").save() SimpleModel("another name").save() diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/ExistenceOperatorTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/ExistenceOperatorTest.kt index e83068fae..a63a705e7 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/ExistenceOperatorTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/ExistenceOperatorTest.kt @@ -1,6 +1,7 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest +import com.raizlabs.android.dbflow.config.writableDatabaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table import org.junit.Assert.assertEquals @@ -10,7 +11,7 @@ class ExistenceOperatorTest : BaseUnitTest() { @Test - fun validateQuery() { + fun validateQuery() = writableDatabaseForTable { assertEquals("EXISTS (SELECT * FROM `SimpleModel` WHERE `name`='name')", ExistenceOperator( (select from SimpleModel::class diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/FromTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/FromTest.kt index 228ffd8a7..ddb30d734 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/FromTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/FromTest.kt @@ -1,12 +1,12 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest +import com.raizlabs.android.dbflow.config.writableDatabaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table.name import com.raizlabs.android.dbflow.models.TwoColumnModel import com.raizlabs.android.dbflow.models.TwoColumnModel_Table import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id -import com.raizlabs.android.dbflow.sql.language.SQLite.select import org.junit.Assert.assertEquals import org.junit.Assert.assertTrue import org.junit.Test @@ -14,28 +14,28 @@ import org.junit.Test class FromTest : BaseUnitTest() { @Test - fun validateSimpleFrom() { + fun validateSimpleFrom() = writableDatabaseForTable { assertEquals("SELECT * FROM `SimpleModel`", (select from SimpleModel::class).query.trim()) } @Test - fun validateProjectionFrom() { + fun validateProjectionFrom() = writableDatabaseForTable { assertEquals("SELECT `name` FROM `SimpleModel`", (select(name) from SimpleModel::class).query.trim()) } @Test - fun validateMultipleProjection() { + fun validateMultipleProjection() = writableDatabaseForTable { assertEquals("SELECT `name`,`name`,`id` FROM `SimpleModel`", (select(name, TwoColumnModel_Table.name, id) from SimpleModel::class).query.trim()) } @Test - fun validateAlias() { + fun validateAlias() = writableDatabaseForTable { assertEquals("SELECT * FROM `SimpleModel` AS `Simple`", (select from SimpleModel::class `as` "Simple").query.trim()) } @Test - fun validateJoins() { + fun validateJoins() = writableDatabaseForTable { val from = (select from SimpleModel::class innerJoin TwoColumnModel::class on name.eq(TwoColumnModel_Table.name.withTable())) diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexTest.kt index 82f6d738a..9efd5e277 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexTest.kt @@ -1,6 +1,7 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest +import com.raizlabs.android.dbflow.config.writableDatabaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table import org.junit.Assert.assertEquals @@ -9,20 +10,20 @@ import org.junit.Test class IndexTest : BaseUnitTest() { @Test - fun validateBasicIndex() { + fun validateBasicIndex() = writableDatabaseForTable { assertEquals("CREATE INDEX IF NOT EXISTS `index` ON `SimpleModel`(`name`)", indexOn("index", SimpleModel_Table.name).query) } @Test - fun validateUniqueIndex() { + fun validateUniqueIndex() = writableDatabaseForTable { assertEquals("CREATE UNIQUE INDEX IF NOT EXISTS `index` ON `SimpleModel`(`name`, `test`)", indexOn("index").unique(true).and(SimpleModel_Table.name) .and("test".nameAlias).query) } @Test - fun validateBasicIndexNameAlias() { + fun validateBasicIndexNameAlias() = writableDatabaseForTable { assertEquals("CREATE INDEX IF NOT EXISTS `index` ON `SimpleModel`(`name`, `test`)", indexOn("index", "name".nameAlias, "test".nameAlias).query) } diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexedByTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexedByTest.kt index ead32d9ad..02abe7dc4 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexedByTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexedByTest.kt @@ -1,6 +1,7 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest +import com.raizlabs.android.dbflow.config.writableDatabaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table import com.raizlabs.android.dbflow.sql.language.property.IndexProperty @@ -10,7 +11,7 @@ import org.junit.Test class IndexedByTest : BaseUnitTest() { @Test - fun validateQuery() { + fun validateQuery() = writableDatabaseForTable { val indexed = (select from SimpleModel::class) .indexedBy(IndexProperty("Index", false, SimpleModel::class.java, SimpleModel_Table.name)) assertEquals("SELECT * FROM `SimpleModel` INDEXED BY `Index`", indexed.query.trim()) diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/InsertTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/InsertTest.kt index 198631194..aa3eb031f 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/InsertTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/InsertTest.kt @@ -2,6 +2,7 @@ package com.raizlabs.android.dbflow.sql.language import android.content.ContentValues import com.raizlabs.android.dbflow.BaseUnitTest +import com.raizlabs.android.dbflow.config.writableDatabaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.TwoColumnModel import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id @@ -13,34 +14,41 @@ import org.junit.Test class InsertTest : BaseUnitTest() { @Test - fun validateInsert() { - assertEquals("INSERT INTO `SimpleModel` VALUES('something')", insert().values("something").query.trim()) + fun validateInsert() = writableDatabaseForTable{ + assertEquals("INSERT INTO `SimpleModel` VALUES('something')", + insert().values("something").query.trim()) } @Test - fun validateInsertOr() { - assertEquals("INSERT OR REPLACE INTO `SimpleModel` VALUES('something')", insert().orReplace().values("something").query.trim()) - assertEquals("INSERT OR FAIL INTO `SimpleModel` VALUES('something')", insert().orFail().values("something").query.trim()) - assertEquals("INSERT OR IGNORE INTO `SimpleModel` VALUES('something')", insert().orIgnore().values("something").query.trim()) - assertEquals("INSERT OR REPLACE INTO `SimpleModel` VALUES('something')", insert().orReplace().values("something").query.trim()) - assertEquals("INSERT OR ROLLBACK INTO `SimpleModel` VALUES('something')", insert().orRollback().values("something").query.trim()) - assertEquals("INSERT OR ABORT INTO `SimpleModel` VALUES('something')", insert().orAbort().values("something").query.trim()) + fun validateInsertOr() = writableDatabaseForTable { + assertEquals("INSERT OR REPLACE INTO `SimpleModel` VALUES('something')", + insert().orReplace().values("something").query.trim()) + assertEquals("INSERT OR FAIL INTO `SimpleModel` VALUES('something')", + insert().orFail().values("something").query.trim()) + assertEquals("INSERT OR IGNORE INTO `SimpleModel` VALUES('something')", + insert().orIgnore().values("something").query.trim()) + assertEquals("INSERT OR REPLACE INTO `SimpleModel` VALUES('something')", + insert().orReplace().values("something").query.trim()) + assertEquals("INSERT OR ROLLBACK INTO `SimpleModel` VALUES('something')", + insert().orRollback().values("something").query.trim()) + assertEquals("INSERT OR ABORT INTO `SimpleModel` VALUES('something')", + insert().orAbort().values("something").query.trim()) } @Test - fun validateInsertProjection() { + fun validateInsertProjection()= writableDatabaseForTable { assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 'id')", insert().columns(name, id).values("name", "id").query.trim()) } @Test - fun validateSelect() { + fun validateSelect()= writableDatabaseForTable { assertEquals("INSERT INTO `TwoColumnModel` SELECT * FROM `SimpleModel`", insert().select(select from SimpleModel::class).query.trim()) } @Test - fun validateColumns() { + fun validateColumns()= writableDatabaseForTable { assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 'id')", insert().asColumns().values("name", "id").query.trim()) assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 'id')", @@ -50,7 +58,7 @@ class InsertTest : BaseUnitTest() { } @Test - fun validateColumnValues() { + fun validateColumnValues()= writableDatabaseForTable { assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 0)", insert().columnValues(name.eq("name"), id.eq(0)).query.trim()) assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 0)", diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/JoinTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/JoinTest.kt index bcbbc1e21..a9030ca3d 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/JoinTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/JoinTest.kt @@ -1,6 +1,7 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest +import com.raizlabs.android.dbflow.config.writableDatabaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table import com.raizlabs.android.dbflow.models.TwoColumnModel @@ -12,14 +13,14 @@ import org.junit.Test class JoinTest : BaseUnitTest() { @Test - fun validateAliasJoin() { + fun validateAliasJoin()= writableDatabaseForTable { assertEquals("SELECT * FROM `SimpleModel` INNER JOIN `TwoColumnModel` AS `Name` ON `TwoColumnModel`.`name`=`name`", ((select from SimpleModel::class innerJoin TwoColumnModel::class).`as`("Name") on TwoColumnModel_Table.name.withTable().eq(SimpleModel_Table.name)).query.trim()) } @Test - fun testInnerJoin() { + fun testInnerJoin() = writableDatabaseForTable{ val join = select from SimpleModel::class innerJoin TwoColumnModel::class on TwoColumnModel_Table.name.withTable().eq(SimpleModel_Table.name) assertEquals("SELECT * FROM `SimpleModel` INNER JOIN `TwoColumnModel` ON `TwoColumnModel`.`name`=`name`", @@ -27,7 +28,7 @@ class JoinTest : BaseUnitTest() { } @Test - fun testLeftOuterJoin() { + fun testLeftOuterJoin()= writableDatabaseForTable { val join = select from SimpleModel::class leftOuterJoin TwoColumnModel::class on TwoColumnModel_Table.name.withTable().eq(SimpleModel_Table.name) assertEquals("SELECT * FROM `SimpleModel` LEFT OUTER JOIN `TwoColumnModel` ON `TwoColumnModel`.`name`=`name`", @@ -35,7 +36,7 @@ class JoinTest : BaseUnitTest() { } @Test - fun testCrossJoin() { + fun testCrossJoin()= writableDatabaseForTable { val join = select from SimpleModel::class crossJoin TwoColumnModel::class on TwoColumnModel_Table.name.withTable().eq(SimpleModel_Table.name) assertEquals("SELECT * FROM `SimpleModel` CROSS JOIN `TwoColumnModel` ON `TwoColumnModel`.`name`=`name`", @@ -43,7 +44,7 @@ class JoinTest : BaseUnitTest() { } @Test - fun testMultiJoin() { + fun testMultiJoin()= writableDatabaseForTable { val join = select from SimpleModel::class innerJoin TwoColumnModel::class on TwoColumnModel_Table.name.withTable().eq(SimpleModel_Table.name) crossJoin TwoColumnModel::class on TwoColumnModel_Table.id.withTable().eq(SimpleModel_Table.name) @@ -53,7 +54,7 @@ class JoinTest : BaseUnitTest() { } @Test - fun testInnerJoinOnUsing() { + fun testInnerJoinOnUsing() = writableDatabaseForTable{ val join = select from SimpleModel::class innerJoin TwoColumnModel::class using SimpleModel_Table.name.withTable() assertEquals("SELECT * FROM `SimpleModel` INNER JOIN `TwoColumnModel` USING (`SimpleModel`.`name`)", @@ -61,7 +62,7 @@ class JoinTest : BaseUnitTest() { } @Test - fun testNaturalJoin() { + fun testNaturalJoin()= writableDatabaseForTable { val join = (select from SimpleModel::class naturalJoin TwoColumnModel::class).end() assertEquals("SELECT * FROM `SimpleModel` NATURAL JOIN `TwoColumnModel`", diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OperatorTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OperatorTest.kt index 3db544ced..3ecd40ab9 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OperatorTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OperatorTest.kt @@ -3,6 +3,7 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.annotation.Collate import com.raizlabs.android.dbflow.assertEquals +import com.raizlabs.android.dbflow.config.writableDatabaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id import org.junit.Test @@ -53,8 +54,9 @@ class OperatorTest : BaseUnitTest() { } @Test - fun testIn() { + fun testIn() = writableDatabaseForTable { assertEquals("`id` IN (5,6,7,8,9)", id.`in`(5, 6, 7, 8) and 9) - assertEquals("`id` NOT IN (SELECT * FROM `SimpleModel`)", id.notIn(select from SimpleModel::class)) + assertEquals("`id` NOT IN (SELECT * FROM `SimpleModel`)", + id.notIn(select from SimpleModel::class)) } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/SelectTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/SelectTest.kt index 8ed426f37..75d6a4664 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/SelectTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/SelectTest.kt @@ -2,22 +2,24 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.assertEquals +import com.raizlabs.android.dbflow.config.writableDatabaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.TwoColumnModel import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.name -import com.raizlabs.android.dbflow.sql.language.SQLite.select import org.junit.Test class SelectTest : BaseUnitTest() { @Test - fun validateSelect() { - assertEquals("SELECT `name`,`id` FROM `TwoColumnModel`", select(name, id) from TwoColumnModel::class) + fun validateSelect() = writableDatabaseForTable { + assertEquals("SELECT `name`,`id` FROM `TwoColumnModel`", + select(name, id) from TwoColumnModel::class) } @Test - fun validateSelectDistinct() { - assertEquals("SELECT DISTINCT `name` FROM `SimpleModel`", select(name).distinct() from SimpleModel::class) + fun validateSelectDistinct() = writableDatabaseForTable { + assertEquals("SELECT DISTINCT `name` FROM `SimpleModel`", + select(name).distinct() from SimpleModel::class) } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/SetTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/SetTest.kt index c80bcc591..246807364 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/SetTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/SetTest.kt @@ -2,28 +2,23 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.assertEquals +import com.raizlabs.android.dbflow.config.writableDatabaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table.name import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id -import com.raizlabs.android.dbflow.sql.Query import org.junit.Test class SetTest : BaseUnitTest() { @Test - fun validateSetWithConditions() { - assertEquals("SET `name`='name'", - Set(object : Query { - override val query = "" - }, SimpleModel::class.java).conditions(name.`is`("name"))) + fun validateSetWithConditions() = writableDatabaseForTable { + assertEquals("UPDATE `SimpleModel` SET `name`='name'", + update() set name.`is`("name")) } @Test - fun validateMultipleConditions() { + fun validateMultipleConditions() = writableDatabaseForTable { assertEquals("SET `name`='name', `id`=0", - Set(object : Query { - override val query = "" - }, SimpleModel::class.java) - .conditions(name.`is`("name"), id.`is`(0))) + update() set name.eq("name") and id.eq(0)) } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/TriggerTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/TriggerTest.kt index 6fff30dac..371dcfd14 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/TriggerTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/TriggerTest.kt @@ -2,6 +2,7 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.assertEquals +import com.raizlabs.android.dbflow.config.writableDatabaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table.name import com.raizlabs.android.dbflow.models.TwoColumnModel @@ -16,7 +17,7 @@ import org.junit.Test class TriggerTest : BaseUnitTest() { @Test - fun validateBasicTrigger() { + fun validateBasicTrigger()= writableDatabaseForTable { assertEquals("CREATE TRIGGER IF NOT EXISTS `MyTrigger` AFTER INSERT ON `SimpleModel` " + "\nBEGIN" + "\nINSERT INTO `TwoColumnModel`(`name`) VALUES(`new`.`name`);" + @@ -26,7 +27,7 @@ class TriggerTest : BaseUnitTest() { } @Test - fun validateUpdateTriggerMultiline() { + fun validateUpdateTriggerMultiline() = writableDatabaseForTable { assertEquals("CREATE TEMP TRIGGER IF NOT EXISTS `MyTrigger` BEFORE UPDATE ON `SimpleModel` " + "\nBEGIN" + "\nINSERT INTO `TwoColumnModel`(`name`) VALUES(`new`.`name`);" + @@ -41,7 +42,7 @@ class TriggerTest : BaseUnitTest() { } @Test - fun validateTriggerWorks() { + fun validateTriggerWorks() = writableDatabaseForTable{ val trigger = createTrigger("MyTrigger").after() insertOn SimpleModel::class begin insert(TwoColumnModel::class).columnValues(name to NameAlias.ofTable("new", "name")) trigger.enable() diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UnsafeStringOperatorTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UnsafeStringOperatorTest.kt index 04ae255f5..0b772851a 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UnsafeStringOperatorTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UnsafeStringOperatorTest.kt @@ -2,13 +2,14 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.assertEquals +import com.raizlabs.android.dbflow.config.writableDatabaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import org.junit.Test class UnsafeStringOperatorTest : BaseUnitTest() { @Test - fun testCanIncludeInQuery() { + fun testCanIncludeInQuery() = writableDatabaseForTable{ val op = UnSafeStringOperator("name = ?, id = ?, test = ?", arrayOf("'name'", "0", "'test'")) assertEquals("name = 'name', id = 0, test = 'test'", op) assertEquals("SELECT * FROM `SimpleModel` WHERE name = 'name', id = 0, test = 'test'", diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UpdateTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UpdateTest.kt index 9e8507717..5032cc940 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UpdateTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UpdateTest.kt @@ -3,6 +3,7 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.annotation.ConflictAction import com.raizlabs.android.dbflow.assertEquals +import com.raizlabs.android.dbflow.config.writableDatabaseForTable import com.raizlabs.android.dbflow.models.NumberModel import com.raizlabs.android.dbflow.models.NumberModel_Table.id import com.raizlabs.android.dbflow.models.SimpleModel @@ -14,37 +15,37 @@ import org.junit.Test class UpdateTest : BaseUnitTest() { @Test - fun validateUpdateRollback() { + fun validateUpdateRollback() = writableDatabaseForTable{ assertEquals("UPDATE OR ROLLBACK `SimpleModel`", update().orRollback()) } @Test - fun validateUpdateFail() { + fun validateUpdateFail()= writableDatabaseForTable { assertEquals("UPDATE OR FAIL `SimpleModel`", update().orFail()) } @Test - fun validateUpdateIgnore() { + fun validateUpdateIgnore()= writableDatabaseForTable { assertEquals("UPDATE OR IGNORE `SimpleModel`", update().orIgnore()) } @Test - fun validateUpdateReplace() { + fun validateUpdateReplace()= writableDatabaseForTable { assertEquals("UPDATE OR REPLACE `SimpleModel`", update().orReplace()) } @Test - fun validateUpdateAbort() { + fun validateUpdateAbort() = writableDatabaseForTable{ assertEquals("UPDATE OR ABORT `SimpleModel`", update().orAbort()) } @Test - fun validateSetQuery() { + fun validateSetQuery() = writableDatabaseForTable{ assertEquals("UPDATE `SimpleModel` SET `name`='name'", update() set (name eq "name")) } @Test - fun validateWildcardQuery() { + fun validateWildcardQuery() = writableDatabaseForTable{ assertEquals("UPDATE OR FAIL `NumberModel` SET `id`=? WHERE `id`=?", update().or(ConflictAction.FAIL) .set(id.eq(Property.WILDCARD)) diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/WhereTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/WhereTest.kt index 2e0603ef9..9bd604a08 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/WhereTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/WhereTest.kt @@ -2,12 +2,12 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.assertEquals +import com.raizlabs.android.dbflow.config.writableDatabaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table.name import com.raizlabs.android.dbflow.models.TwoColumnModel import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id import com.raizlabs.android.dbflow.sql.language.OrderBy.Companion.fromNameAlias -import com.raizlabs.android.dbflow.sql.language.SQLite.select import com.raizlabs.android.dbflow.sql.queriable.list import com.raizlabs.android.dbflow.sql.queriable.result import org.junit.Assert.fail @@ -16,55 +16,55 @@ import org.junit.Test class WhereTest : BaseUnitTest() { @Test - fun validateBasicWhere() { + fun validateBasicWhere()= writableDatabaseForTable { assertEquals("SELECT * FROM `SimpleModel` WHERE `name`='name'", select from SimpleModel::class where name.`is`("name")) } @Test - fun validateComplexQueryWhere() { + fun validateComplexQueryWhere() = writableDatabaseForTable{ assertEquals("SELECT * FROM `SimpleModel` WHERE `name`='name' OR `id`=1 AND (`id`=0 OR `name`='hi')", select from SimpleModel::class where name.`is`("name") or id.eq(1) and (id.`is`(0) or name.eq("hi"))) } @Test - fun validateGroupBy() { + fun validateGroupBy()= writableDatabaseForTable { assertEquals("SELECT * FROM `SimpleModel` WHERE `name`='name' GROUP BY `name`", select from SimpleModel::class where name.`is`("name") groupBy name) } @Test - fun validateGroupByNameAlias() { + fun validateGroupByNameAlias()= writableDatabaseForTable { assertEquals("SELECT * FROM `SimpleModel` WHERE `name`='name' GROUP BY `name`,`id`", (select from SimpleModel::class where name.`is`("name")).groupBy("name".nameAlias, "id".nameAlias)) } @Test - fun validateGroupByNameProps() { + fun validateGroupByNameProps()= writableDatabaseForTable { assertEquals("SELECT * FROM `SimpleModel` WHERE `name`='name' GROUP BY `name`,`id`", (select from SimpleModel::class where name.`is`("name")).groupBy(name, id)) } @Test - fun validateHaving() { + fun validateHaving()= writableDatabaseForTable { assertEquals("SELECT * FROM `SimpleModel` WHERE `name`='name' HAVING `name` LIKE 'That'", select from SimpleModel::class where name.`is`("name") having name.like("That")) } @Test - fun validateLimit() { + fun validateLimit()= writableDatabaseForTable { assertEquals("SELECT * FROM `SimpleModel` WHERE `name`='name' LIMIT 10", select from SimpleModel::class where name.`is`("name") limit 10) } @Test - fun validateOffset() { + fun validateOffset()= writableDatabaseForTable { assertEquals("SELECT * FROM `SimpleModel` WHERE `name`='name' OFFSET 10", select from SimpleModel::class where name.`is`("name") offset 10) } @Test - fun validateWhereExists() { + fun validateWhereExists()= writableDatabaseForTable { assertEquals("SELECT * FROM `SimpleModel` " + "WHERE EXISTS (SELECT `name` FROM `SimpleModel` WHERE `name` LIKE 'Andrew')", select from SimpleModel::class @@ -72,7 +72,7 @@ class WhereTest : BaseUnitTest() { } @Test - fun validateOrderByWhere() { + fun validateOrderByWhere()= writableDatabaseForTable { assertEquals("SELECT * FROM `SimpleModel` " + "WHERE `name`='name' ORDER BY `name` ASC", (select from SimpleModel::class @@ -80,7 +80,7 @@ class WhereTest : BaseUnitTest() { } @Test - fun validateOrderByWhereAlias() { + fun validateOrderByWhereAlias()= writableDatabaseForTable { assertEquals("SELECT * FROM `SimpleModel` " + "WHERE `name`='name' ORDER BY `name` ASC", (select from SimpleModel::class @@ -88,7 +88,7 @@ class WhereTest : BaseUnitTest() { } @Test - fun validateOrderBy() { + fun validateOrderBy()= writableDatabaseForTable { assertEquals("SELECT * FROM `SimpleModel` " + "WHERE `name`='name' ORDER BY `name` ASC", select from SimpleModel::class @@ -96,7 +96,7 @@ class WhereTest : BaseUnitTest() { } @Test - fun validateOrderByAll() { + fun validateOrderByAll()= writableDatabaseForTable { assertEquals("SELECT * FROM `TwoColumnModel` " + "WHERE `name`='name' ORDER BY `name` ASC,`id` DESC", (select from TwoColumnModel::class @@ -107,7 +107,7 @@ class WhereTest : BaseUnitTest() { } @Test - fun validateNonSelectThrowError() { + fun validateNonSelectThrowError()= writableDatabaseForTable { try { update().set(name.`is`("name")).result fail("Non select passed") diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/IndexPropertyTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/IndexPropertyTest.kt index 5ab2f9097..46105d908 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/IndexPropertyTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/IndexPropertyTest.kt @@ -1,6 +1,7 @@ package com.raizlabs.android.dbflow.sql.language.property import com.raizlabs.android.dbflow.BaseUnitTest +import com.raizlabs.android.dbflow.config.writableDatabaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table import org.junit.Assert.assertEquals @@ -10,12 +11,12 @@ class IndexPropertyTest : BaseUnitTest() { @Test - fun validateIndexProperty() { + fun validateIndexProperty() = writableDatabaseForTable { - val prop = IndexProperty("Index", true, SimpleModel::class.java, + val prop = IndexProperty("Index", true, SimpleModel::class.java, SimpleModel_Table.name) - prop.createIfNotExists() - prop.drop() + prop.createIfNotExists(this) + prop.drop(this) assertEquals("`Index`", prop.indexName) } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/PropertyFactoryTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/PropertyFactoryTest.kt index ecd37f2a2..8bbedb810 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/PropertyFactoryTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/PropertyFactoryTest.kt @@ -1,6 +1,7 @@ package com.raizlabs.android.dbflow.sql.language.property import com.raizlabs.android.dbflow.BaseUnitTest +import com.raizlabs.android.dbflow.config.writableDatabaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.sql.language.select import org.junit.Assert.assertEquals @@ -19,7 +20,9 @@ class PropertyFactoryTest : BaseUnitTest() { assertEquals("5", 5.toByte().property.query) val nullable: Any? = null assertEquals("NULL", nullable.property.query) - assertEquals("(SELECT * FROM `SimpleModel`)", (select from SimpleModel::class).property.query) + writableDatabaseForTable { + assertEquals("(SELECT * FROM `SimpleModel`)", (select from SimpleModel::class).property.query) + } assertEquals("SomethingCool", propertyString("SomethingCool").query) } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/queriable/AsyncQueryTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/queriable/AsyncQueryTest.kt index 452269707..45b75c95a 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/queriable/AsyncQueryTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/queriable/AsyncQueryTest.kt @@ -1,6 +1,7 @@ package com.raizlabs.android.dbflow.sql.queriable import com.raizlabs.android.dbflow.BaseUnitTest +import com.raizlabs.android.dbflow.config.writableDatabaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.sql.language.CursorResult import com.raizlabs.android.dbflow.sql.language.select @@ -12,7 +13,7 @@ import org.junit.Test class AsyncQueryTest : BaseUnitTest() { @Test - fun testQueryResult() { + fun testQueryResult() = writableDatabaseForTable{ SimpleModel("name").save() var model: SimpleModel? = null @@ -24,7 +25,7 @@ class AsyncQueryTest : BaseUnitTest() { } @Test - fun testQueryListResult() { + fun testQueryListResult() = writableDatabaseForTable{ SimpleModel("name").save() SimpleModel("name2").save() @@ -36,7 +37,7 @@ class AsyncQueryTest : BaseUnitTest() { } @Test - fun testQueryListCursorResult() { + fun testQueryListCursorResult() = writableDatabaseForTable{ SimpleModel("name").save() SimpleModel("name2").save() diff --git a/dbflow/build.gradle b/dbflow/build.gradle index eaf60fac6..5ce0e0ad1 100644 --- a/dbflow/build.gradle +++ b/dbflow/build.gradle @@ -27,7 +27,7 @@ android { dependencies { api project("${dbflow_project_prefix}dbflow-core") api "com.android.support:support-annotations:27.0.1" - api "org.jetbrains.kotlin:kotlin-stdlib-jre7:$kotlin_version" + api "org.jetbrains.kotlin:kotlin-stdlib-jre8:$kotlin_version" api "org.jetbrains.kotlinx:kotlinx-coroutines-core:0.19.2" } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt index b60c3a180..ca5aa4221 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt @@ -19,6 +19,7 @@ import com.raizlabs.android.dbflow.structure.QueryModelAdapter import com.raizlabs.android.dbflow.structure.RetrievalAdapter import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper import java.util.* +import kotlin.reflect.KClass /** * Description: The main entry point into the generated database code. It uses reflection to look up @@ -425,19 +426,38 @@ object FlowManager { /** * Easily get access to its [DatabaseDefinition] directly. */ -inline fun database() = FlowManager.getDatabase(T::class.java) +inline fun database(): DatabaseDefinition + = FlowManager.getDatabase(T::class.java) -inline fun writableDatabaseForTable() = FlowManager.getWritableDatabaseForTable(T::class.java) +/** + * Easily get access to its [DatabaseDefinition] directly. + */ +inline fun database(kClass: KClass, f: DatabaseDefinition.() -> R): R + = FlowManager.getDatabase(kClass.java).f() + +inline fun writableDatabaseForTable(f: DatabaseWrapper.() -> Unit): DatabaseWrapper + = FlowManager.getWritableDatabaseForTable(T::class.java).apply(f) + +inline fun writableDatabaseForTable(): DatabaseWrapper + = FlowManager.getWritableDatabaseForTable(T::class.java) + +fun writableDatabase(kClass: KClass, f: DatabaseWrapper.() -> R): R + = FlowManager.getWritableDatabase(kClass.java).f() + +inline fun writableDatabase(): DatabaseWrapper + = FlowManager.getWritableDatabase(T::class.java) /** * Easily get access to its [DatabaseDefinition] directly. */ -inline fun databaseForTable() = FlowManager.getDatabaseForTable(T::class.java) +inline fun databaseForTable(): DatabaseDefinition + = FlowManager.getDatabaseForTable(T::class.java) /** * Easily get its table name. */ -inline fun tableName() = FlowManager.getTableName(T::class.java) +inline fun tableName(): String + = FlowManager.getTableName(T::class.java) /** * Easily get its [ModelAdapter]. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorList.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorList.kt index c02084e92..f23bbbe90 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorList.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorList.kt @@ -52,7 +52,8 @@ class FlowCursorList private constructor(builder: Builder) : IFlowCu warnEmptyCursor() return cursor?.let { cursor -> FlowManager.getModelAdapter(table) - .listModelLoader.convertToData(cursor, null) + .listModelLoader.convertToData(cursor, null, + FlowManager.getWritableDatabaseForTable(table)) } ?: listOf() } @@ -118,7 +119,9 @@ class FlowCursorList private constructor(builder: Builder) : IFlowCu val cursor = unpackCursor() return if (cursor.moveToPosition(position.toInt())) { - instanceAdapter.singleModelLoader.convertToData(FlowCursor.from(cursor), null, false) + instanceAdapter.singleModelLoader.convertToData( + FlowCursor.from(cursor), null, false, + FlowManager.getWritableDatabaseForTable(table)) ?: throw IndexOutOfBoundsException("Invalid item at position $position. Check your cursor data.") } else { throw IndexOutOfBoundsException("Invalid item at position $position. Check your cursor data.") diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseModelQueriable.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseModelQueriable.kt index adef16344..e939d739e 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseModelQueriable.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseModelQueriable.kt @@ -35,7 +35,7 @@ protected constructor(val databaseWrapper: DatabaseWrapper, private val singleModelLoader: SingleModelLoader get() = retrievalAdapter.singleModelLoader - override fun queryResults(): CursorResult = CursorResult(retrievalAdapter.modelClass, query()) + override fun queryResults(): CursorResult = CursorResult(retrievalAdapter.modelClass, query(), databaseWrapper) override fun queryList(): MutableList { val query = query diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CursorResult.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CursorResult.kt index 524f4c46c..d6bdc565a 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CursorResult.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CursorResult.kt @@ -5,13 +5,15 @@ import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.list.FlowCursorIterator import com.raizlabs.android.dbflow.list.IFlowCursorIterator import com.raizlabs.android.dbflow.structure.InstanceAdapter +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper import com.raizlabs.android.dbflow.structure.database.FlowCursor /** * Description: A class that contains a [Cursor] and handy methods for retrieving data from it. * You must close this object post use via [.close]. */ -class CursorResult internal constructor(modelClass: Class, cursor: Cursor?) +class CursorResult internal constructor(modelClass: Class, cursor: Cursor?, + private val databaseWrapper: DatabaseWrapper) : IFlowCursorIterator { private val retrievalAdapter: InstanceAdapter @@ -44,14 +46,14 @@ class CursorResult internal constructor(modelClass: Class, cursor: C * @return A [List] of items from this object. You must call [.close] when finished. */ fun toList(): List = cursor?.let { cursor -> - retrievalAdapter.listModelLoader.convertToData(cursor, null) + retrievalAdapter.listModelLoader.convertToData(cursor, null, databaseWrapper) } ?: arrayListOf() /** * @return Converts the [Cursor] to a [List] of [T] and then closes it. */ fun toListClose(): List { - val list = retrievalAdapter.listModelLoader.load(cursor) ?: arrayListOf() + val list = retrievalAdapter.listModelLoader.load(cursor, databaseWrapper) ?: arrayListOf() close() return list } @@ -62,7 +64,7 @@ class CursorResult internal constructor(modelClass: Class, cursor: C fun toCustomList(customClass: Class): List { return cursor?.let { cursor -> return@let FlowManager.getQueryModelAdapter(customClass) - .listModelLoader.convertToData(cursor, null) + .listModelLoader.convertToData(cursor, null, databaseWrapper) } ?: arrayListOf() } @@ -70,7 +72,7 @@ class CursorResult internal constructor(modelClass: Class, cursor: C * @return Converts the [Cursor] to a [List] of [T] and then closes it. */ fun toCustomListClose(customClass: Class): List { - val customList = FlowManager.getQueryModelAdapter(customClass).listModelLoader.load(cursor) ?: arrayListOf() + val customList = FlowManager.getQueryModelAdapter(customClass).listModelLoader.load(cursor, databaseWrapper) ?: arrayListOf() close() return customList } @@ -78,13 +80,13 @@ class CursorResult internal constructor(modelClass: Class, cursor: C /** * @return The first [T] of items from the contained [Cursor]. You must call [.close] when finished. */ - fun toModel(): T? = cursor?.let { cursor -> retrievalAdapter.singleModelLoader.convertToData(cursor, null) } + fun toModel(): T? = cursor?.let { cursor -> retrievalAdapter.singleModelLoader.convertToData(cursor, null, databaseWrapper) } /** * @return Converts the [Cursor] into the first [T] from the cursor and then closes it. */ fun toModelClose(): T? { - val model = retrievalAdapter.singleModelLoader.load(cursor) + val model = retrievalAdapter.singleModelLoader.load(cursor, databaseWrapper) close() return model } @@ -95,7 +97,7 @@ class CursorResult internal constructor(modelClass: Class, cursor: C fun toCustomModel(customClass: Class): TCustom? { return if (cursor != null) FlowManager.getQueryModelAdapter(customClass) - .singleModelLoader.convertToData(cursor!!, null) + .singleModelLoader.convertToData(cursor!!, null, databaseWrapper) else null } @@ -103,7 +105,7 @@ class CursorResult internal constructor(modelClass: Class, cursor: C * @return Converts the [Cursor] to a [T] and then closes it. */ fun toCustomModelClose(customClass: Class): TCustom? { - val customList = FlowManager.getQueryModelAdapter(customClass).singleModelLoader.load(cursor) + val customList = FlowManager.getQueryModelAdapter(customClass).singleModelLoader.load(cursor, databaseWrapper) close() return customList } @@ -112,7 +114,7 @@ class CursorResult internal constructor(modelClass: Class, cursor: C var model: T? = null cursor?.let { cursor -> if (cursor.moveToPosition(position.toInt())) { - model = retrievalAdapter.singleModelLoader.convertToData(cursor, null, false) + model = retrievalAdapter.singleModelLoader.convertToData(cursor, null, false, databaseWrapper) } } return model!! diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Delete.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Delete.kt index 9399bd4b1..129c1d5d2 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Delete.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Delete.kt @@ -19,7 +19,10 @@ class Delete internal constructor(private val databaseWrapper: DatabaseWrapper) * @param [T] The table class * @return [T] **/ - fun from(table: Class): From = From(databaseWrapper, this, table) + infix fun from(table: Class): From = From(databaseWrapper, this, table) + + infix fun from(table: KClass): From = from(table.java) + companion object { diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/SQLite.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/SQLite.kt index 2dc3ceca2..8fe803f18 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/SQLite.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/SQLite.kt @@ -58,6 +58,8 @@ infix fun DatabaseWrapper.insert(modelClass: KClass) = insert(model */ fun DatabaseWrapper.delete(): Delete = Delete(this) +inline fun DatabaseWrapper.delete() = delete(T::class.java) + /** * Starts a DELETE statement on the specified table. * diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Set.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Set.kt index effae4a8e..a7bacdb50 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Set.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Set.kt @@ -32,6 +32,16 @@ class Set internal constructor( operatorGroup.andAll(*conditions) } + /** + * Specifies a varg of conditions to append to this SET + * + * @param condition The varg of conditions + * @return This instance. + */ + infix fun and(condition: SQLOperator) = apply { + operatorGroup.and(condition) + } + fun conditionValues(contentValues: ContentValues) = apply { addContentValues(contentValues, operatorGroup) } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/CacheableListModelLoader.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/CacheableListModelLoader.kt index 3437bc1cf..dec02da2b 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/CacheableListModelLoader.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/CacheableListModelLoader.kt @@ -3,6 +3,7 @@ package com.raizlabs.android.dbflow.sql.queriable import com.raizlabs.android.dbflow.annotation.Table import com.raizlabs.android.dbflow.structure.ModelAdapter import com.raizlabs.android.dbflow.structure.cache.ModelCache +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper import com.raizlabs.android.dbflow.structure.database.FlowCursor /** @@ -24,20 +25,21 @@ open class CacheableListModelLoader(modelClass: Class) val modelCache: ModelCache by lazy { modelAdapter.modelCache } - override fun convertToData(cursor: FlowCursor, data: MutableList?): MutableList { + override fun convertToData(cursor: FlowCursor, data: MutableList?, + databaseWrapper: DatabaseWrapper): MutableList { val _data = data ?: arrayListOf() val cacheValues = arrayOfNulls(modelAdapter.cachingColumns.size) // Ensure that we aren't iterating over this cursor concurrently from different threads if (cursor.moveToFirst()) { do { val values = modelAdapter.getCachingColumnValuesFromCursor(cacheValues, cursor) - var model: T? = modelCache.get(modelAdapter.getCachingId(values)) + var model: T? = modelCache[modelAdapter.getCachingId(values)] if (model != null) { - modelAdapter.reloadRelationships(model, cursor) + modelAdapter.reloadRelationships(model, cursor, databaseWrapper) _data.add(model) } else { model = modelAdapter.newInstance() - modelAdapter.loadFromCursor(cursor, model!!) + modelAdapter.loadFromCursor(cursor, model, databaseWrapper) modelCache.addModel(modelAdapter.getCachingId(values), model) _data.add(model) } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/CacheableModelLoader.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/CacheableModelLoader.kt index a6a63332a..7ff52bc19 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/CacheableModelLoader.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/CacheableModelLoader.kt @@ -3,6 +3,7 @@ package com.raizlabs.android.dbflow.sql.queriable import com.raizlabs.android.dbflow.annotation.Table import com.raizlabs.android.dbflow.structure.ModelAdapter import com.raizlabs.android.dbflow.structure.cache.ModelCache +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper import com.raizlabs.android.dbflow.structure.database.FlowCursor /** @@ -31,18 +32,19 @@ open class CacheableModelLoader(modelClass: Class) * * @return A model from cache. */ - override fun convertToData(cursor: FlowCursor, data: T?, moveToFirst: Boolean): T? { + override fun convertToData(cursor: FlowCursor, data: T?, moveToFirst: Boolean, + databaseWrapper: DatabaseWrapper): T? { if (!moveToFirst || cursor.moveToFirst()) { val values = modelAdapter.getCachingColumnValuesFromCursor( arrayOfNulls(modelAdapter.cachingColumns.size), cursor) var model: T? = modelCache[modelAdapter.getCachingId(values)] if (model == null) { model = (data ?: modelAdapter.newInstance()).apply { - modelAdapter.loadFromCursor(cursor, this) + modelAdapter.loadFromCursor(cursor, this, databaseWrapper) modelCache.addModel(modelAdapter.getCachingId(values), this) } } else { - modelAdapter.reloadRelationships(model, cursor) + modelAdapter.reloadRelationships(model, cursor, databaseWrapper) } return model } else { diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ListModelLoader.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ListModelLoader.kt index c431c72d4..2083bee63 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ListModelLoader.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ListModelLoader.kt @@ -1,5 +1,6 @@ package com.raizlabs.android.dbflow.sql.queriable +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper import com.raizlabs.android.dbflow.structure.database.FlowCursor /** @@ -8,17 +9,19 @@ import com.raizlabs.android.dbflow.structure.database.FlowCursor open class ListModelLoader(modelClass: Class) : ModelLoader>(modelClass) { - override fun load(cursor: FlowCursor?, data: MutableList?): MutableList? { + override fun load(cursor: FlowCursor?, data: MutableList?, + databaseWrapper: DatabaseWrapper): MutableList? { var _data = data if (_data == null) { _data = arrayListOf() } else { _data.clear() } - return super.load(cursor, _data) + return super.load(cursor, _data, databaseWrapper) } - override fun convertToData(cursor: FlowCursor, data: MutableList?): MutableList { + override fun convertToData(cursor: FlowCursor, data: MutableList?, + databaseWrapper: DatabaseWrapper): MutableList { var _data = data if (_data == null) { _data = arrayListOf() @@ -29,7 +32,7 @@ open class ListModelLoader(modelClass: Class) if (cursor.moveToFirst()) { do { val model = instanceAdapter.newInstance() - instanceAdapter.loadFromCursor(cursor, model) + instanceAdapter.loadFromCursor(cursor, model, databaseWrapper) _data.add(model) } while (cursor.moveToNext()) } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ModelLoader.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ModelLoader.kt index 434d0e9f1..ec06d426b 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ModelLoader.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ModelLoader.kt @@ -26,13 +26,13 @@ abstract class ModelLoader(val modelClass: Class(val modelClass: Class(tModelClass: Class) : CacheableListModelLoader(tModelClass) { - override fun convertToData(cursor: FlowCursor, data: MutableList?): MutableList { + override fun convertToData(cursor: FlowCursor, data: MutableList?, + databaseWrapper: DatabaseWrapper): MutableList { val _data = data ?: arrayListOf() var cacheValue: Any? // Ensure that we aren't iterating over this cursor concurrently from different threads @@ -17,10 +19,10 @@ class SingleKeyCacheableListModelLoader(tModelClass: Class) cacheValue = modelAdapter.getCachingColumnValueFromCursor(cursor) var model: T? = modelCache[cacheValue] if (model != null) { - modelAdapter.reloadRelationships(model, cursor) + modelAdapter.reloadRelationships(model, cursor, databaseWrapper) } else { model = modelAdapter.newInstance() - modelAdapter.loadFromCursor(cursor, model!!) + modelAdapter.loadFromCursor(cursor, model, databaseWrapper) modelCache.addModel(cacheValue, model) } _data.add(model) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleKeyCacheableModelLoader.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleKeyCacheableModelLoader.kt index 5a89e2c92..8d7e0763a 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleKeyCacheableModelLoader.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleKeyCacheableModelLoader.kt @@ -1,6 +1,7 @@ package com.raizlabs.android.dbflow.sql.queriable import com.raizlabs.android.dbflow.structure.Model +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper import com.raizlabs.android.dbflow.structure.database.FlowCursor /** @@ -17,17 +18,18 @@ class SingleKeyCacheableModelLoader(modelClass: Class) * @return A model from cache. */ override fun convertToData(cursor: FlowCursor, data: T?, - moveToFirst: Boolean): T? { + moveToFirst: Boolean, + databaseWrapper: DatabaseWrapper): T? { if (!moveToFirst || cursor.moveToFirst()) { val value = modelAdapter.getCachingColumnValueFromCursor(cursor) var model: T? = modelCache.get(value) if (model == null) { model = (data ?: modelAdapter.newInstance()).apply { - modelAdapter.loadFromCursor(cursor, this) + modelAdapter.loadFromCursor(cursor, this, databaseWrapper) modelCache.addModel(value, this) } } else { - modelAdapter.reloadRelationships(model, cursor) + modelAdapter.reloadRelationships(model, cursor, databaseWrapper) } return model } else { diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleModelLoader.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleModelLoader.kt index 061834980..8a75faffb 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleModelLoader.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleModelLoader.kt @@ -1,5 +1,6 @@ package com.raizlabs.android.dbflow.sql.queriable +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper import com.raizlabs.android.dbflow.structure.database.FlowCursor /** @@ -9,18 +10,19 @@ open class SingleModelLoader(modelClass: Class) : ModelLoader(modelClass) { open fun convertToData(cursor: FlowCursor, data: T?, - moveToFirst: Boolean): T? { + moveToFirst: Boolean, + databaseWrapper: DatabaseWrapper): T? { var _data = data if (!moveToFirst || cursor.moveToFirst()) { if (_data == null) { _data = instanceAdapter.newInstance() } - instanceAdapter.loadFromCursor(cursor, _data!!) + instanceAdapter.loadFromCursor(cursor, _data, databaseWrapper) } return _data } - override fun convertToData(cursor: FlowCursor, data: T?): T? { - return convertToData(cursor, data, true) + override fun convertToData(cursor: FlowCursor, data: T?, databaseWrapper: DatabaseWrapper): T? { + return convertToData(cursor, data, true, databaseWrapper) } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseModel.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseModel.kt index be7b79d43..bfa27d40d 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseModel.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseModel.kt @@ -51,19 +51,19 @@ open class BaseModel : Model { CHANGE } - override fun DatabaseWrapper.load() { - modelAdapter.load(this@BaseModel, this) + override fun load(wrapper: DatabaseWrapper) { + modelAdapter.load(this, wrapper) } - override fun DatabaseWrapper.save(): Boolean = saveModel() + override fun save(wrapper: DatabaseWrapper): Boolean = wrapper.saveModel() - override fun DatabaseWrapper.delete(): Boolean = deleteModel() + override fun delete(wrapper: DatabaseWrapper): Boolean = wrapper.deleteModel() - override fun DatabaseWrapper.update(): Boolean = modelAdapter.update(this@BaseModel, this) + override fun update(wrapper: DatabaseWrapper): Boolean = modelAdapter.update(this, wrapper) - override fun DatabaseWrapper.insert(): Long = modelAdapter.insert(this@BaseModel, this) + override fun insert(wrapper: DatabaseWrapper): Long = modelAdapter.insert(this, wrapper) - override fun DatabaseWrapper.exists(): Boolean = modelAdapter.exists(this@BaseModel, this) + override fun exists(wrapper: DatabaseWrapper): Boolean = modelAdapter.exists(this, wrapper) protected fun DatabaseWrapper.saveModel(): Boolean = modelAdapter.save(this@BaseModel, this) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseQueryModel.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseQueryModel.kt index b4cdcfe0f..036ec0de6 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseQueryModel.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseQueryModel.kt @@ -9,8 +9,8 @@ import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper @Deprecated("No subclass needed. Use extension methods instead.") class BaseQueryModel : NoModificationModel() { - override fun DatabaseWrapper.exists(): Boolean { - throw NoModificationModel.InvalidSqlViewOperationException("Query " + javaClass.name + + override fun exists(wrapper: DatabaseWrapper): Boolean { + throw NoModificationModel.InvalidSqlViewOperationException("Query " + wrapper.javaClass.name + " does not exist as a table." + "It's a convenient representation of a complex SQLite query.") } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/Model.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/Model.kt index d084bde44..c57405f3f 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/Model.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/Model.kt @@ -11,28 +11,28 @@ interface Model : ReadOnlyModel { * * @return true if successful */ - fun DatabaseWrapper.save(): Boolean + fun save(wrapper: DatabaseWrapper): Boolean /** * Deletes the object in the DB * * @return true if successful */ - fun DatabaseWrapper.delete(): Boolean + fun delete(wrapper: DatabaseWrapper): Boolean /** * Updates an object in the DB. Does not insert on failure. * * @return true if successful */ - fun DatabaseWrapper.update(): Boolean + fun update(wrapper: DatabaseWrapper): Boolean /** * Inserts the object into the DB * * @return the count of the rows affected, should only be 1 here, or -1 if failed. */ - fun DatabaseWrapper.insert(): Long + fun insert(wrapper: DatabaseWrapper): Long companion object { @@ -53,3 +53,6 @@ inline fun T.update(databaseWrapper: DatabaseWrapper = writabl inline fun T.delete(databaseWrapper: DatabaseWrapper = writableDatabaseForTable()) = modelAdapter().delete(this, databaseWrapper) inline fun T.exists(databaseWrapper: DatabaseWrapper = writableDatabaseForTable()) = modelAdapter().exists(this, databaseWrapper) + +inline fun T.load(databaseWrapper: DatabaseWrapper = writableDatabaseForTable()) = modelAdapter().load(this, databaseWrapper) + diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelAdapter.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelAdapter.kt index 0f3a3ec08..b3234fced 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelAdapter.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelAdapter.kt @@ -200,9 +200,9 @@ abstract class ModelAdapter(databaseDefinition: DatabaseDefinition) * @param cursor The cursor to load * @return A new [T] */ - fun loadFromCursor(cursor: FlowCursor): T { + fun loadFromCursor(cursor: FlowCursor, databaseWrapper: DatabaseWrapper): T { val model = newInstance() - loadFromCursor(cursor, model) + loadFromCursor(cursor, model, databaseWrapper) return model } @@ -404,7 +404,7 @@ abstract class ModelAdapter(databaseDefinition: DatabaseDefinition) * * @param cursor The cursor to reload from. */ - open fun reloadRelationships(model: T, cursor: FlowCursor) { + open fun reloadRelationships(model: T, cursor: FlowCursor, databaseWrapper: DatabaseWrapper) { if (!cachingEnabled()) { throwCachingError() } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelViewAdapter.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelViewAdapter.kt index 7cd6c03dc..9407ec183 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelViewAdapter.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelViewAdapter.kt @@ -1,6 +1,7 @@ package com.raizlabs.android.dbflow.structure import com.raizlabs.android.dbflow.config.DatabaseDefinition +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper /** * Description: The base class for a [T] adapter that defines how it interacts with the DB. @@ -11,7 +12,7 @@ abstract class ModelViewAdapter(databaseDefinition: DatabaseDefinition) /** * @return a string of the query that is used to create this model view. */ - abstract val creationQuery: String + abstract fun getCreationQuery(wrapper: DatabaseWrapper): String /** * @return The name of this view in the database diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/NoModificationModel.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/NoModificationModel.kt index 521db4eec..3d6821a59 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/NoModificationModel.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/NoModificationModel.kt @@ -11,10 +11,10 @@ abstract class NoModificationModel : ReadOnlyModel { @delegate:Transient private val retrievalAdapter: RetrievalAdapter by lazy { FlowManager.getInstanceAdapter(javaClass) } - override fun DatabaseWrapper.exists(): Boolean = retrievalAdapter.exists(this@NoModificationModel, this) + override fun exists(wrapper: DatabaseWrapper): Boolean = retrievalAdapter.exists(this, wrapper) - override fun DatabaseWrapper.load() { - retrievalAdapter.load(this@NoModificationModel, this) + override fun load(wrapper: DatabaseWrapper) { + retrievalAdapter.load(this, wrapper) } /** diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ReadOnlyModel.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ReadOnlyModel.kt index e6c419fb1..f5c303047 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ReadOnlyModel.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ReadOnlyModel.kt @@ -7,12 +7,12 @@ interface ReadOnlyModel { /** * Loads from the database the most recent version of the model based on it's primary keys. */ - fun DatabaseWrapper.load() + fun load(wrapper: DatabaseWrapper) /** * @return true if this object exists in the DB. It combines all of it's primary key fields * into a SELECT query and checks to see if any results occur. */ - fun DatabaseWrapper.exists(): Boolean + fun exists(wrapper: DatabaseWrapper): Boolean } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/RetrievalAdapter.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/RetrievalAdapter.kt index a3d154db9..d999b0b7f 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/RetrievalAdapter.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/RetrievalAdapter.kt @@ -109,7 +109,7 @@ abstract class RetrievalAdapter(databaseDefinition: DatabaseDefinition) * @param model The model to assign cursor data to * @param cursor The cursor to load into the model */ - abstract fun loadFromCursor(cursor: FlowCursor, model: T) + abstract fun loadFromCursor(cursor: FlowCursor, model: T, wrapper: DatabaseWrapper) /** * @param model The model to query values from diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/BaseDatabaseHelper.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/BaseDatabaseHelper.kt index 30a2e22a1..151e93355 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/BaseDatabaseHelper.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/BaseDatabaseHelper.kt @@ -76,7 +76,7 @@ open class BaseDatabaseHelper(val databaseDefinition: DatabaseDefinition) { val modelViews = databaseDefinition.modelViewAdapters modelViews .asSequence() - .map { "CREATE VIEW IF NOT EXISTS ${it.viewName} AS ${it.creationQuery}" } + .map { "CREATE VIEW IF NOT EXISTS ${it.viewName} AS ${it.getCreationQuery(database)}" } .forEach { try { database.execSQL(it) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/BaseProviderModel.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/BaseProviderModel.kt index 5144af262..1d60e9c4c 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/BaseProviderModel.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/BaseProviderModel.kt @@ -16,21 +16,21 @@ import com.raizlabs.android.dbflow.structure.database.FlowCursor */ abstract class BaseProviderModel : BaseModel(), ModelProvider { - override fun DatabaseWrapper.delete(): Boolean = ContentUtils.delete(deleteUri, this@BaseProviderModel) > 0 + override fun delete(wrapper: DatabaseWrapper): Boolean = ContentUtils.delete(deleteUri, this) > 0 - override fun DatabaseWrapper.save(): Boolean { - val count = ContentUtils.update(updateUri, this@BaseProviderModel) + override fun save(wrapper: DatabaseWrapper): Boolean { + val count = ContentUtils.update(updateUri, this) return if (count == 0) { - ContentUtils.insert(insertUri, this@BaseProviderModel) != null + ContentUtils.insert(insertUri, this) != null } else { count > 0 } } - override fun DatabaseWrapper.update(): Boolean = ContentUtils.update(updateUri, this@BaseProviderModel) > 0 + override fun update(wrapper: DatabaseWrapper): Boolean = ContentUtils.update(updateUri, this) > 0 - override fun DatabaseWrapper.insert(): Long { - ContentUtils.insert(insertUri, this) + override fun insert(wrapper: DatabaseWrapper): Long { + ContentUtils.insert(insertUri, wrapper) return 0 } @@ -39,29 +39,31 @@ abstract class BaseProviderModel : BaseModel(), ModelProvider { * * @return true if this model exists in the [ContentProvider] based on its primary keys. */ - override fun DatabaseWrapper.exists(): Boolean { + override fun exists(wrapper: DatabaseWrapper): Boolean { val cursor = ContentUtils.query(FlowManager.context.contentResolver, - queryUri, modelAdapter.getPrimaryConditionClause(this@BaseProviderModel), "") + queryUri, modelAdapter.getPrimaryConditionClause(this), "") val exists = cursor != null && cursor.count > 0 cursor?.close() return exists } override fun load(whereOperatorGroup: OperatorGroup, - orderBy: String?, vararg columns: String?) { + orderBy: String?, + wrapper: DatabaseWrapper, + vararg columns: String?) { val cursor = ContentUtils.query(FlowManager.context.contentResolver, queryUri, whereOperatorGroup, orderBy, *columns) if (cursor != null) { val flowCursor = FlowCursor.from(cursor) if (flowCursor.moveToFirst()) { - modelAdapter.loadFromCursor(flowCursor, this) + modelAdapter.loadFromCursor(flowCursor, this, wrapper) flowCursor.close() } } } - override fun load() { - load(modelAdapter.getPrimaryConditionClause(this), "") + override fun load(wrapper: DatabaseWrapper) { + load(modelAdapter.getPrimaryConditionClause(this), "", wrapper) } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/BaseSyncableProviderModel.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/BaseSyncableProviderModel.kt index 3c379cde1..6af45ea2a 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/BaseSyncableProviderModel.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/BaseSyncableProviderModel.kt @@ -15,38 +15,40 @@ import com.raizlabs.android.dbflow.structure.database.FlowCursor */ abstract class BaseSyncableProviderModel : BaseModel(), ModelProvider { - override fun DatabaseWrapper.insert(): Long { - val rowId = insertModel() - ContentUtils.insert(insertUri, this) + override fun insert(wrapper: DatabaseWrapper): Long { + val rowId = wrapper.insertModel() + ContentUtils.insert(insertUri, wrapper) return rowId } - override fun DatabaseWrapper.save(): Boolean { - return if (exists()) { - saveModel() && ContentUtils.update(updateUri, this) > 0 + override fun save(wrapper: DatabaseWrapper): Boolean { + return if (exists(wrapper)) { + wrapper.saveModel() && ContentUtils.update(updateUri, wrapper) > 0 } else { - saveModel() && ContentUtils.insert(insertUri, this) != null + wrapper.saveModel() && ContentUtils.insert(insertUri, wrapper) != null } } - override fun DatabaseWrapper.delete(): Boolean = deleteModel() && ContentUtils.delete(deleteUri, this) > 0 + override fun delete(wrapper: DatabaseWrapper): Boolean = wrapper.deleteModel() && ContentUtils.delete(deleteUri, wrapper) > 0 - override fun DatabaseWrapper.update(): Boolean = updateModel() && ContentUtils.update(updateUri, this) > 0 + override fun update(wrapper: DatabaseWrapper): Boolean = wrapper.updateModel() && ContentUtils.update(updateUri, wrapper) > 0 override fun load(whereOperatorGroup: OperatorGroup, - orderBy: String?, vararg columns: String?) { + orderBy: String?, + wrapper: DatabaseWrapper, + vararg columns: String?) { val cursor = ContentUtils.query(FlowManager.context.contentResolver, queryUri, whereOperatorGroup, orderBy, *columns) cursor?.let { val flowCursor = FlowCursor.from(cursor) if (flowCursor.moveToFirst()) { - modelAdapter.loadFromCursor(flowCursor, this) + modelAdapter.loadFromCursor(flowCursor, this, wrapper) flowCursor.close() } } } - override fun load() { - load(modelAdapter.getPrimaryConditionClause(this), "") + override fun load(wrapper: DatabaseWrapper) { + load(modelAdapter.getPrimaryConditionClause(this), "", wrapper) } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/ContentUtils.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/ContentUtils.kt index 29a4e7aa9..ab7facd80 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/ContentUtils.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/ContentUtils.kt @@ -10,6 +10,7 @@ import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.sql.language.Operator import com.raizlabs.android.dbflow.sql.language.OperatorGroup import com.raizlabs.android.dbflow.structure.ModelAdapter +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper import com.raizlabs.android.dbflow.structure.database.FlowCursor /** @@ -227,9 +228,11 @@ object ContentUtils { */ @JvmStatic fun queryList(queryUri: Uri, table: Class, + databaseWrapper: DatabaseWrapper, whereConditions: OperatorGroup, orderBy: String, vararg columns: String): List? = - queryList(FlowManager.context.contentResolver, queryUri, table, whereConditions, orderBy, *columns) + queryList(FlowManager.context.contentResolver, queryUri, table, + databaseWrapper, whereConditions, orderBy, *columns) /** @@ -247,12 +250,13 @@ object ContentUtils { @JvmStatic fun queryList(contentResolver: ContentResolver, queryUri: Uri, table: Class, + databaseWrapper: DatabaseWrapper, whereConditions: OperatorGroup, orderBy: String, vararg columns: String): List? { val cursor = FlowCursor.from(contentResolver.query(queryUri, columns, whereConditions.query, null, orderBy)!!) return FlowManager.getModelAdapter(table) .listModelLoader - .load(cursor) + .load(cursor, databaseWrapper) } /** @@ -268,9 +272,11 @@ object ContentUtils { */ @JvmStatic fun querySingle(queryUri: Uri, table: Class, + databaseWrapper: DatabaseWrapper, whereConditions: OperatorGroup, orderBy: String, vararg columns: String): TableClass? = - querySingle(FlowManager.context.contentResolver, queryUri, table, whereConditions, orderBy, *columns) + querySingle(FlowManager.context.contentResolver, queryUri, table, + databaseWrapper, whereConditions, orderBy, *columns) /** * Queries the [android.content.ContentResolver] with the specified queryUri. It will generate @@ -285,10 +291,13 @@ object ContentUtils { * @return The first [TableClass] of the list query from the content provider. */ @JvmStatic - fun querySingle(contentResolver: ContentResolver, queryUri: Uri, table: Class, + fun querySingle(contentResolver: ContentResolver, + queryUri: Uri, table: Class, + databaseWrapper: DatabaseWrapper, whereConditions: OperatorGroup, orderBy: String, vararg columns: String): TableClass? { - val list = queryList(contentResolver, queryUri, table, whereConditions, orderBy, *columns) + val list = queryList(contentResolver, queryUri, table, + databaseWrapper, whereConditions, orderBy, *columns) return list?.let { if (list.isNotEmpty()) list[0] else null } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/ModelProvider.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/ModelProvider.kt index ec83cbfe7..37fe9c78b 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/ModelProvider.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/ModelProvider.kt @@ -5,6 +5,7 @@ import android.net.Uri import com.raizlabs.android.dbflow.sql.language.Operator import com.raizlabs.android.dbflow.sql.language.OperatorGroup +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper /** * Description: A base interface for Models that are connected to providers. @@ -40,11 +41,13 @@ interface ModelProvider { * @param columns The list of columns to select. Leave blank for * */ fun load(whereOperatorGroup: OperatorGroup, - orderBy: String?, vararg columns: String?) + orderBy: String?, + wrapper: DatabaseWrapper, + vararg columns: String?) /** * Queries the [ContentResolver] of the app based on the primary keys of the object and populates * this object with the first row from the returned data. */ - fun load() + fun load(wrapper: DatabaseWrapper) } diff --git a/settings.gradle b/settings.gradle index 2c7fb4fd5..07d1e7b2e 100644 --- a/settings.gradle +++ b/settings.gradle @@ -1,4 +1,4 @@ -include ':dbflow', ':dbflow-rx-kotlinextensions', ':dbflow-rx2', ':dbflow-rx2-kotlinextensions', +include ':dbflow', ':dbflow-rx2', ':dbflow-processor', ':dbflow-core', ':dbflow-sqlcipher', From 7ef1e7ea9d38a721e71ce3bfdc7826dee454f06b Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Fri, 24 Nov 2017 17:24:51 -0500 Subject: [PATCH 068/234] [5.0] fix broken unit tests. --- .../dbflow/models/DontCreateModelTest.kt | 8 +- .../dbflow/models/OneToManyModelTest.kt | 52 +++--- .../android/dbflow/models/OneToManyModels.kt | 3 +- .../dbflow/runtime/DirectNotifierTest.kt | 20 ++- .../rx/language/CursorResultSubscriberTest.kt | 25 +-- .../dbflow/rx/language/RXQueryTests.kt | 82 +++++---- .../dbflow/sql/language/CursorResultTest.kt | 8 +- .../android/dbflow/sql/language/DeleteTest.kt | 32 ++-- .../sql/language/ExistenceOperatorTest.kt | 14 +- .../android/dbflow/sql/language/FromTest.kt | 42 +++-- .../android/dbflow/sql/language/IndexTest.kt | 26 +-- .../dbflow/sql/language/IndexedByTest.kt | 10 +- .../android/dbflow/sql/language/InsertTest.kt | 96 ++++++----- .../android/dbflow/sql/language/JoinTest.kt | 86 ++++++---- .../dbflow/sql/language/OperatorTest.kt | 10 +- .../android/dbflow/sql/language/SelectTest.kt | 16 +- .../android/dbflow/sql/language/SetTest.kt | 16 +- .../dbflow/sql/language/TriggerTest.kt | 57 ++++--- .../sql/language/UnsafeStringOperatorTest.kt | 12 +- .../android/dbflow/sql/language/UpdateTest.kt | 48 ++++-- .../android/dbflow/sql/language/WhereTest.kt | 158 +++++++++++------- .../language/property/IndexPropertyTest.kt | 15 +- .../dbflow/sql/queriable/AsyncQueryTest.kt | 58 ++++--- .../android/dbflow/config/FlowManager.kt | 6 + .../android/dbflow/sql/language/Operator.kt | 9 +- 25 files changed, 525 insertions(+), 384 deletions(-) diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/DontCreateModelTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/DontCreateModelTest.kt index 46b253e34..7277b5115 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/DontCreateModelTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/DontCreateModelTest.kt @@ -14,9 +14,11 @@ import org.junit.Test class DontCreateModelTest : BaseUnitTest() { @Test - fun testModelNotCreated() = writableDatabaseForTable { - assertThrowsException(SQLiteException::class) { - (select from DontCreateModel::class).list + fun testModelNotCreated() { + writableDatabaseForTable { + assertThrowsException(SQLiteException::class) { + (select from DontCreateModel::class).list + } } } } diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModelTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModelTest.kt index ba1b6bb50..95b51ce05 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModelTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModelTest.kt @@ -15,30 +15,32 @@ import org.junit.Test class OneToManyModelTest : BaseUnitTest() { @Test - fun testOneToManyModel() = writableDatabase(TestDatabase::class) { - var testModel2 = TwoColumnModel("Greater", 4) - testModel2.save() - - testModel2 = TwoColumnModel("Lesser", 1) - testModel2.save() - - // assert we save - var oneToManyModel = OneToManyModel("HasOrders") - oneToManyModel.save() - assertTrue(oneToManyModel.exists()) - - // assert loading works as expected. - oneToManyModel = (select from OneToManyModel::class).result!! - assertNotNull(oneToManyModel.getRelatedOrders(this)) - assertTrue(!oneToManyModel.getRelatedOrders(this).isEmpty()) - - // assert the deletion cleared the variable - oneToManyModel.delete() - assertFalse(oneToManyModel.exists()) - assertNull(oneToManyModel.orders) - - // assert singular relationship was deleted. - val list = (select from TwoColumnModel::class).list - assertTrue(list.size == 1) + fun testOneToManyModel(){ + writableDatabase(TestDatabase::class) { + var testModel2 = TwoColumnModel("Greater", 4) + testModel2.save() + + testModel2 = TwoColumnModel("Lesser", 1) + testModel2.save() + + // assert we save + var oneToManyModel = OneToManyModel("HasOrders") + oneToManyModel.save() + assertTrue(oneToManyModel.exists()) + + // assert loading works as expected. + oneToManyModel = (select from OneToManyModel::class).result!! + assertNotNull(oneToManyModel.getRelatedOrders(this)) + assertTrue(!oneToManyModel.getRelatedOrders(this).isEmpty()) + + // assert the deletion cleared the variable + oneToManyModel.delete() + assertFalse(oneToManyModel.exists()) + assertNull(oneToManyModel.orders) + + // assert singular relationship was deleted. + val list = (select from TwoColumnModel::class).list + assertTrue(list.size == 1) + } } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModels.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModels.kt index dea5f0bc5..da24909b3 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModels.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModels.kt @@ -6,6 +6,7 @@ import com.raizlabs.android.dbflow.annotation.OneToManyMethod import com.raizlabs.android.dbflow.annotation.PrimaryKey import com.raizlabs.android.dbflow.annotation.Table import com.raizlabs.android.dbflow.config.writableDatabase +import com.raizlabs.android.dbflow.config.writableDatabaseForTable import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.sql.language.where @@ -22,7 +23,7 @@ class OneToManyModel(@PrimaryKey var name: String? = null) { @get:OneToMany(oneToManyMethods = arrayOf(OneToManyMethod.ALL)) var simpleModels by oneToMany { - writableDatabase(OneToManyBaseModel::class) { + writableDatabaseForTable(OneToManyBaseModel::class) { select from OneToManyBaseModel::class } } diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/runtime/DirectNotifierTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/runtime/DirectNotifierTest.kt index 2a3a30419..653f09d89 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/runtime/DirectNotifierTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/runtime/DirectNotifierTest.kt @@ -68,21 +68,23 @@ class DirectNotifierTest { } @Test - fun validateCanNotifyWrapperClasses() = writableDatabaseForTable { - val modelChange = Mockito.mock(OnTableChangedListener::class.java) - DirectModelNotifier.get().registerForTableChanges(SimpleModel::class.java, modelChange) + fun validateCanNotifyWrapperClasses() { + writableDatabaseForTable { + val modelChange = Mockito.mock(OnTableChangedListener::class.java) + DirectModelNotifier.get().registerForTableChanges(SimpleModel::class.java, modelChange) - insert().columnValues(SimpleModel_Table.name to "name").executeInsert() + insert().columnValues(SimpleModel_Table.name to "name").executeInsert() - verify(modelChange).onTableChanged(SimpleModel::class.java, BaseModel.Action.INSERT) + verify(modelChange).onTableChanged(SimpleModel::class.java, BaseModel.Action.INSERT) - (update() set SimpleModel_Table.name.eq("name2")).executeUpdateDelete() + (update() set SimpleModel_Table.name.eq("name2")).executeUpdateDelete() - verify(modelChange).onTableChanged(SimpleModel::class.java, BaseModel.Action.UPDATE) + verify(modelChange).onTableChanged(SimpleModel::class.java, BaseModel.Action.UPDATE) - delete().executeUpdateDelete() + delete().executeUpdateDelete() - verify(modelChange).onTableChanged(SimpleModel::class.java, BaseModel.Action.DELETE) + verify(modelChange).onTableChanged(SimpleModel::class.java, BaseModel.Action.DELETE) + } } @After diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriberTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriberTest.kt index 7aa3bce12..15b4f7db8 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriberTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriberTest.kt @@ -10,21 +10,22 @@ import org.junit.Test class CursorResultSubscriberTest : BaseUnitTest() { - @Test - fun testCanQueryStreamResults() = writableDatabaseForTable { - (0..9).forEach { SimpleModel("$it").save() } + fun testCanQueryStreamResults() { + writableDatabaseForTable { + (0..9).forEach { SimpleModel("$it").save() } - var count = 0 - (select from SimpleModel::class).rx() - .queryStreamResults() - .toBlocking() - .subscribe { - count++ - assert(it != null) - } + var count = 0 + (select from SimpleModel::class).rx() + .queryStreamResults() + .toBlocking() + .subscribe { + count++ + assert(it != null) + } - assertEquals(10, count) + assertEquals(10, count) + } } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/RXQueryTests.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/RXQueryTests.kt index baffc6433..2a9af8058 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/RXQueryTests.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/RXQueryTests.kt @@ -18,56 +18,64 @@ import org.junit.Test class RXQueryTests : BaseUnitTest() { @Test - fun testCanQuery() = writableDatabaseForTable { - SimpleModel("Name").save() + fun testCanQuery() { + writableDatabaseForTable { + SimpleModel("Name").save() - var cursor: Cursor? = null - (select from SimpleModel::class).rx() - .query() - .subscribe { - cursor = it - } + var cursor: Cursor? = null + (select from SimpleModel::class).rx() + .query() + .subscribe { + cursor = it + } - assertEquals(1, cursor!!.count) - cursor!!.close() + assertEquals(1, cursor!!.count) + cursor!!.close() + } } @Test - fun testCanCompileStatement() = writableDatabaseForTable { - var databaseStatement: DatabaseStatement? = null - (insert().columnValues(name.`is`("name"))) - .rxBaseQueriable().compileStatement() - .subscribe { - databaseStatement = it - } - assertNotNull(databaseStatement) - databaseStatement!!.close() + fun testCanCompileStatement() { + writableDatabaseForTable { + var databaseStatement: DatabaseStatement? = null + (insert().columnValues(name.`is`("name"))) + .rxBaseQueriable().compileStatement() + .subscribe { + databaseStatement = it + } + assertNotNull(databaseStatement) + databaseStatement!!.close() + } } @Test - fun testCountMethod() = writableDatabaseForTable{ - SimpleModel("name").save() - SimpleModel("name2").save() - var count = 0L - (selectCountOf(Property.ALL_PROPERTY) from SimpleModel::class).rx() - .longValue().subscribe { - count = it - } + fun testCountMethod() { + writableDatabaseForTable { + SimpleModel("name").save() + SimpleModel("name2").save() + var count = 0L + (selectCountOf(Property.ALL_PROPERTY) from SimpleModel::class).rx() + .longValue().subscribe { + count = it + } - assertEquals(2, count) + assertEquals(2, count) + } } @Test - fun testInsertMethod() = writableDatabaseForTable { - var count = 0L - (insert().columnValues(name.eq("name"))) - .rxBaseQueriable() - .executeInsert() - .subscribe { - count = it - } + fun testInsertMethod() { + writableDatabaseForTable { + var count = 0L + (insert().columnValues(name.eq("name"))) + .rxBaseQueriable() + .executeInsert() + .subscribe { + count = it + } - assertEquals(1, count) + assertEquals(1, count) + } } @Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CursorResultTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CursorResultTest.kt index af93e0972..980ab44c3 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CursorResultTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CursorResultTest.kt @@ -16,9 +16,11 @@ class CursorResultTest : BaseUnitTest() { lateinit var result: CursorResult @Before - fun prepareList() = writableDatabaseForTable { - (0..9).forEach { SimpleModel("$it").save() } - result = (select from SimpleModel::class).cursorResult + fun prepareList() { + writableDatabaseForTable { + (0..9).forEach { SimpleModel("$it").save() } + result = (select from SimpleModel::class).cursorResult + } } @Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/DeleteTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/DeleteTest.kt index 3cc8b5c3b..d90162048 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/DeleteTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/DeleteTest.kt @@ -13,26 +13,32 @@ import org.junit.Test class DeleteTest : BaseUnitTest() { @Test - fun validateQuery() = writableDatabaseForTable { - assertEquals("DELETE ", delete().query) + fun validateQuery() { + writableDatabaseForTable { + assertEquals("DELETE ", delete().query) + } } @Test - fun validateDeletion() = writableDatabaseForTable { - SimpleModel("name").save() - delete().execute() - assertFalse((select from SimpleModel::class).hasData()) + fun validateDeletion() { + writableDatabaseForTable { + SimpleModel("name").save() + delete().execute() + assertFalse((select from SimpleModel::class).hasData()) + } } @Test - fun validateDeletionWithQuery() = writableDatabaseForTable { - SimpleModel("name").save() - SimpleModel("another name").save() + fun validateDeletionWithQuery() { + writableDatabaseForTable { + SimpleModel("name").save() + SimpleModel("another name").save() - val where = delete().where(SimpleModel_Table.name.`is`("name")) - assertEquals("DELETE FROM `SimpleModel` WHERE `name`='name'", where.query.trim()) - where.execute() + val where = delete().where(SimpleModel_Table.name.`is`("name")) + assertEquals("DELETE FROM `SimpleModel` WHERE `name`='name'", where.query.trim()) + where.execute() - assertEquals(1, (select from SimpleModel::class).list.size) + assertEquals(1, (select from SimpleModel::class).list.size) + } } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/ExistenceOperatorTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/ExistenceOperatorTest.kt index a63a705e7..bf897c03f 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/ExistenceOperatorTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/ExistenceOperatorTest.kt @@ -11,11 +11,13 @@ class ExistenceOperatorTest : BaseUnitTest() { @Test - fun validateQuery() = writableDatabaseForTable { - assertEquals("EXISTS (SELECT * FROM `SimpleModel` WHERE `name`='name')", - ExistenceOperator( - (select from SimpleModel::class - where SimpleModel_Table.name.eq("name"))) - .query.trim()) + fun validateQuery() { + writableDatabaseForTable { + assertEquals("EXISTS (SELECT * FROM `SimpleModel` WHERE `name`='name')", + ExistenceOperator( + (select from SimpleModel::class + where SimpleModel_Table.name.eq("name"))) + .query.trim()) + } } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/FromTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/FromTest.kt index ddb30d734..3dfe791b0 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/FromTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/FromTest.kt @@ -14,33 +14,43 @@ import org.junit.Test class FromTest : BaseUnitTest() { @Test - fun validateSimpleFrom() = writableDatabaseForTable { - assertEquals("SELECT * FROM `SimpleModel`", (select from SimpleModel::class).query.trim()) + fun validateSimpleFrom() { + writableDatabaseForTable { + assertEquals("SELECT * FROM `SimpleModel`", (select from SimpleModel::class).query.trim()) + } } @Test - fun validateProjectionFrom() = writableDatabaseForTable { - assertEquals("SELECT `name` FROM `SimpleModel`", (select(name) from SimpleModel::class).query.trim()) + fun validateProjectionFrom() { + writableDatabaseForTable { + assertEquals("SELECT `name` FROM `SimpleModel`", (select(name) from SimpleModel::class).query.trim()) + } } @Test - fun validateMultipleProjection() = writableDatabaseForTable { - assertEquals("SELECT `name`,`name`,`id` FROM `SimpleModel`", - (select(name, TwoColumnModel_Table.name, id) from SimpleModel::class).query.trim()) + fun validateMultipleProjection() { + writableDatabaseForTable { + assertEquals("SELECT `name`,`name`,`id` FROM `SimpleModel`", + (select(name, TwoColumnModel_Table.name, id) from SimpleModel::class).query.trim()) + } } @Test - fun validateAlias() = writableDatabaseForTable { - assertEquals("SELECT * FROM `SimpleModel` AS `Simple`", (select from SimpleModel::class `as` "Simple").query.trim()) + fun validateAlias() { + writableDatabaseForTable { + assertEquals("SELECT * FROM `SimpleModel` AS `Simple`", (select from SimpleModel::class `as` "Simple").query.trim()) + } } @Test - fun validateJoins() = writableDatabaseForTable { - val from = (select from SimpleModel::class - innerJoin TwoColumnModel::class - on name.eq(TwoColumnModel_Table.name.withTable())) - assertEquals("SELECT * FROM `SimpleModel` INNER JOIN `TwoColumnModel` ON `name`=`TwoColumnModel`.`name`", - from.query.trim()) - assertTrue(from.associatedTables.isNotEmpty()) + fun validateJoins() { + writableDatabaseForTable { + val from = (select from SimpleModel::class + innerJoin TwoColumnModel::class + on name.eq(TwoColumnModel_Table.name.withTable())) + assertEquals("SELECT * FROM `SimpleModel` INNER JOIN `TwoColumnModel` ON `name`=`TwoColumnModel`.`name`", + from.query.trim()) + assertTrue(from.associatedTables.isNotEmpty()) + } } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexTest.kt index 9efd5e277..10ddd6d10 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexTest.kt @@ -10,21 +10,27 @@ import org.junit.Test class IndexTest : BaseUnitTest() { @Test - fun validateBasicIndex() = writableDatabaseForTable { - assertEquals("CREATE INDEX IF NOT EXISTS `index` ON `SimpleModel`(`name`)", - indexOn("index", SimpleModel_Table.name).query) + fun validateBasicIndex() { + writableDatabaseForTable { + assertEquals("CREATE INDEX IF NOT EXISTS `index` ON `SimpleModel`(`name`)", + indexOn("index", SimpleModel_Table.name).query) + } } @Test - fun validateUniqueIndex() = writableDatabaseForTable { - assertEquals("CREATE UNIQUE INDEX IF NOT EXISTS `index` ON `SimpleModel`(`name`, `test`)", - indexOn("index").unique(true).and(SimpleModel_Table.name) - .and("test".nameAlias).query) + fun validateUniqueIndex() { + writableDatabaseForTable { + assertEquals("CREATE UNIQUE INDEX IF NOT EXISTS `index` ON `SimpleModel`(`name`, `test`)", + indexOn("index").unique(true).and(SimpleModel_Table.name) + .and("test".nameAlias).query) + } } @Test - fun validateBasicIndexNameAlias() = writableDatabaseForTable { - assertEquals("CREATE INDEX IF NOT EXISTS `index` ON `SimpleModel`(`name`, `test`)", - indexOn("index", "name".nameAlias, "test".nameAlias).query) + fun validateBasicIndexNameAlias() { + writableDatabaseForTable { + assertEquals("CREATE INDEX IF NOT EXISTS `index` ON `SimpleModel`(`name`, `test`)", + indexOn("index", "name".nameAlias, "test".nameAlias).query) + } } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexedByTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexedByTest.kt index 02abe7dc4..6cdc575bd 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexedByTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexedByTest.kt @@ -11,9 +11,11 @@ import org.junit.Test class IndexedByTest : BaseUnitTest() { @Test - fun validateQuery() = writableDatabaseForTable { - val indexed = (select from SimpleModel::class) - .indexedBy(IndexProperty("Index", false, SimpleModel::class.java, SimpleModel_Table.name)) - assertEquals("SELECT * FROM `SimpleModel` INDEXED BY `Index`", indexed.query.trim()) + fun validateQuery() { + writableDatabaseForTable { + val indexed = (select from SimpleModel::class) + .indexedBy(IndexProperty("Index", false, SimpleModel::class.java, SimpleModel_Table.name)) + assertEquals("SELECT * FROM `SimpleModel` INDEXED BY `Index`", indexed.query.trim()) + } } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/InsertTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/InsertTest.kt index aa3eb031f..bda35bb8a 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/InsertTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/InsertTest.kt @@ -14,65 +14,77 @@ import org.junit.Test class InsertTest : BaseUnitTest() { @Test - fun validateInsert() = writableDatabaseForTable{ - assertEquals("INSERT INTO `SimpleModel` VALUES('something')", - insert().values("something").query.trim()) + fun validateInsert(){ + writableDatabaseForTable{ + assertEquals("INSERT INTO `SimpleModel` VALUES('something')", + insert().values("something").query.trim()) + } } @Test - fun validateInsertOr() = writableDatabaseForTable { - assertEquals("INSERT OR REPLACE INTO `SimpleModel` VALUES('something')", - insert().orReplace().values("something").query.trim()) - assertEquals("INSERT OR FAIL INTO `SimpleModel` VALUES('something')", - insert().orFail().values("something").query.trim()) - assertEquals("INSERT OR IGNORE INTO `SimpleModel` VALUES('something')", - insert().orIgnore().values("something").query.trim()) - assertEquals("INSERT OR REPLACE INTO `SimpleModel` VALUES('something')", - insert().orReplace().values("something").query.trim()) - assertEquals("INSERT OR ROLLBACK INTO `SimpleModel` VALUES('something')", - insert().orRollback().values("something").query.trim()) - assertEquals("INSERT OR ABORT INTO `SimpleModel` VALUES('something')", - insert().orAbort().values("something").query.trim()) + fun validateInsertOr(){ + writableDatabaseForTable { + assertEquals("INSERT OR REPLACE INTO `SimpleModel` VALUES('something')", + insert().orReplace().values("something").query.trim()) + assertEquals("INSERT OR FAIL INTO `SimpleModel` VALUES('something')", + insert().orFail().values("something").query.trim()) + assertEquals("INSERT OR IGNORE INTO `SimpleModel` VALUES('something')", + insert().orIgnore().values("something").query.trim()) + assertEquals("INSERT OR REPLACE INTO `SimpleModel` VALUES('something')", + insert().orReplace().values("something").query.trim()) + assertEquals("INSERT OR ROLLBACK INTO `SimpleModel` VALUES('something')", + insert().orRollback().values("something").query.trim()) + assertEquals("INSERT OR ABORT INTO `SimpleModel` VALUES('something')", + insert().orAbort().values("something").query.trim()) + } } @Test - fun validateInsertProjection()= writableDatabaseForTable { - assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 'id')", - insert().columns(name, id).values("name", "id").query.trim()) + fun validateInsertProjection(){ + writableDatabaseForTable { + assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 'id')", + insert().columns(name, id).values("name", "id").query.trim()) + } } @Test - fun validateSelect()= writableDatabaseForTable { - assertEquals("INSERT INTO `TwoColumnModel` SELECT * FROM `SimpleModel`", - insert().select(select from SimpleModel::class).query.trim()) + fun validateSelect(){ + writableDatabaseForTable { + assertEquals("INSERT INTO `TwoColumnModel` SELECT * FROM `SimpleModel`", + insert().select(select from SimpleModel::class).query.trim()) + } } @Test - fun validateColumns()= writableDatabaseForTable { - assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 'id')", - insert().asColumns().values("name", "id").query.trim()) - assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 'id')", - insert().columns("name", "id").values("name", "id").query.trim()) - assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 'id')", - insert().columns(listOf(name, id)).values("name", "id").query.trim()) + fun validateColumns(){ + writableDatabaseForTable { + assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 'id')", + insert().asColumns().values("name", "id").query.trim()) + assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 'id')", + insert().columns("name", "id").values("name", "id").query.trim()) + assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 'id')", + insert().columns(listOf(name, id)).values("name", "id").query.trim()) + } } @Test - fun validateColumnValues()= writableDatabaseForTable { - assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 0)", - insert().columnValues(name.eq("name"), id.eq(0)).query.trim()) - assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 0)", - insert().columnValues(Operator.op(NameAlias.builder("name").build()).eq("name"), - id.eq(0)).query.trim()) - assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 0)", - insert().columnValues(OperatorGroup.clause().andAll(name.eq("name"), id.eq(0))).query.trim()) + fun validateColumnValues(){ + writableDatabaseForTable { + assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 0)", + insert().columnValues(name.eq("name"), id.eq(0)).query.trim()) + assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 0)", + insert().columnValues(Operator.op(NameAlias.builder("name").build()).eq("name"), + id.eq(0)).query.trim()) + assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 0)", + insert().columnValues(OperatorGroup.clause().andAll(name.eq("name"), id.eq(0))).query.trim()) - val contentValues = ContentValues() - contentValues["name"] = "name" - contentValues["id"] = 0.toInt() + val contentValues = ContentValues() + contentValues["name"] = "name" + contentValues["id"] = 0.toInt() - assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 0)", - insert().columnValues(contentValues).query.trim()) + assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 0)", + insert().columnValues(contentValues).query.trim()) + } } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/JoinTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/JoinTest.kt index a9030ca3d..ebd46a822 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/JoinTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/JoinTest.kt @@ -13,59 +13,73 @@ import org.junit.Test class JoinTest : BaseUnitTest() { @Test - fun validateAliasJoin()= writableDatabaseForTable { - assertEquals("SELECT * FROM `SimpleModel` INNER JOIN `TwoColumnModel` AS `Name` ON `TwoColumnModel`.`name`=`name`", - ((select from SimpleModel::class innerJoin - TwoColumnModel::class).`as`("Name") on TwoColumnModel_Table.name.withTable().eq(SimpleModel_Table.name)).query.trim()) + fun validateAliasJoin() { + writableDatabaseForTable { + assertEquals("SELECT * FROM `SimpleModel` INNER JOIN `TwoColumnModel` AS `Name` ON `TwoColumnModel`.`name`=`name`", + ((select from SimpleModel::class innerJoin + TwoColumnModel::class).`as`("Name") on TwoColumnModel_Table.name.withTable().eq(SimpleModel_Table.name)).query.trim()) + } } @Test - fun testInnerJoin() = writableDatabaseForTable{ - val join = select from SimpleModel::class innerJoin - TwoColumnModel::class on TwoColumnModel_Table.name.withTable().eq(SimpleModel_Table.name) - assertEquals("SELECT * FROM `SimpleModel` INNER JOIN `TwoColumnModel` ON `TwoColumnModel`.`name`=`name`", - join.query.trim()) + fun testInnerJoin() { + writableDatabaseForTable { + val join = select from SimpleModel::class innerJoin + TwoColumnModel::class on TwoColumnModel_Table.name.withTable().eq(SimpleModel_Table.name) + assertEquals("SELECT * FROM `SimpleModel` INNER JOIN `TwoColumnModel` ON `TwoColumnModel`.`name`=`name`", + join.query.trim()) + } } @Test - fun testLeftOuterJoin()= writableDatabaseForTable { - val join = select from SimpleModel::class leftOuterJoin - TwoColumnModel::class on TwoColumnModel_Table.name.withTable().eq(SimpleModel_Table.name) - assertEquals("SELECT * FROM `SimpleModel` LEFT OUTER JOIN `TwoColumnModel` ON `TwoColumnModel`.`name`=`name`", - join.query.trim()) + fun testLeftOuterJoin() { + writableDatabaseForTable { + val join = select from SimpleModel::class leftOuterJoin + TwoColumnModel::class on TwoColumnModel_Table.name.withTable().eq(SimpleModel_Table.name) + assertEquals("SELECT * FROM `SimpleModel` LEFT OUTER JOIN `TwoColumnModel` ON `TwoColumnModel`.`name`=`name`", + join.query.trim()) + } } @Test - fun testCrossJoin()= writableDatabaseForTable { - val join = select from SimpleModel::class crossJoin - TwoColumnModel::class on TwoColumnModel_Table.name.withTable().eq(SimpleModel_Table.name) - assertEquals("SELECT * FROM `SimpleModel` CROSS JOIN `TwoColumnModel` ON `TwoColumnModel`.`name`=`name`", - join.query.trim()) + fun testCrossJoin() { + writableDatabaseForTable { + val join = select from SimpleModel::class crossJoin + TwoColumnModel::class on TwoColumnModel_Table.name.withTable().eq(SimpleModel_Table.name) + assertEquals("SELECT * FROM `SimpleModel` CROSS JOIN `TwoColumnModel` ON `TwoColumnModel`.`name`=`name`", + join.query.trim()) + } } @Test - fun testMultiJoin()= writableDatabaseForTable { - val join = select from SimpleModel::class innerJoin - TwoColumnModel::class on TwoColumnModel_Table.name.withTable().eq(SimpleModel_Table.name) crossJoin - TwoColumnModel::class on TwoColumnModel_Table.id.withTable().eq(SimpleModel_Table.name) - assertEquals("SELECT * FROM `SimpleModel` INNER JOIN `TwoColumnModel` ON `TwoColumnModel`.`name`=`name`" + - " CROSS JOIN `TwoColumnModel` ON `TwoColumnModel`.`id`=`name`", - join.query.trim()) + fun testMultiJoin() { + writableDatabaseForTable { + val join = select from SimpleModel::class innerJoin + TwoColumnModel::class on TwoColumnModel_Table.name.withTable().eq(SimpleModel_Table.name) crossJoin + TwoColumnModel::class on TwoColumnModel_Table.id.withTable().eq(SimpleModel_Table.name) + assertEquals("SELECT * FROM `SimpleModel` INNER JOIN `TwoColumnModel` ON `TwoColumnModel`.`name`=`name`" + + " CROSS JOIN `TwoColumnModel` ON `TwoColumnModel`.`id`=`name`", + join.query.trim()) + } } @Test - fun testInnerJoinOnUsing() = writableDatabaseForTable{ - val join = select from SimpleModel::class innerJoin - TwoColumnModel::class using SimpleModel_Table.name.withTable() - assertEquals("SELECT * FROM `SimpleModel` INNER JOIN `TwoColumnModel` USING (`SimpleModel`.`name`)", - join.query.trim()) + fun testInnerJoinOnUsing() { + writableDatabaseForTable { + val join = select from SimpleModel::class innerJoin + TwoColumnModel::class using SimpleModel_Table.name.withTable() + assertEquals("SELECT * FROM `SimpleModel` INNER JOIN `TwoColumnModel` USING (`SimpleModel`.`name`)", + join.query.trim()) + } } @Test - fun testNaturalJoin()= writableDatabaseForTable { - val join = (select from SimpleModel::class naturalJoin - TwoColumnModel::class).end() - assertEquals("SELECT * FROM `SimpleModel` NATURAL JOIN `TwoColumnModel`", - join.query.trim()) + fun testNaturalJoin() { + writableDatabaseForTable { + val join = (select from SimpleModel::class naturalJoin + TwoColumnModel::class).end() + assertEquals("SELECT * FROM `SimpleModel` NATURAL JOIN `TwoColumnModel`", + join.query.trim()) + } } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OperatorTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OperatorTest.kt index 3ecd40ab9..2d53652c0 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OperatorTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OperatorTest.kt @@ -54,9 +54,11 @@ class OperatorTest : BaseUnitTest() { } @Test - fun testIn() = writableDatabaseForTable { - assertEquals("`id` IN (5,6,7,8,9)", id.`in`(5, 6, 7, 8) and 9) - assertEquals("`id` NOT IN (SELECT * FROM `SimpleModel`)", - id.notIn(select from SimpleModel::class)) + fun testIn() { + writableDatabaseForTable { + assertEquals("`id` IN (5,6,7,8,9)", id.`in`(5, 6, 7, 8) and 9) + assertEquals("`id` NOT IN (SELECT * FROM `SimpleModel`)", + id.notIn(select from SimpleModel::class)) + } } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/SelectTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/SelectTest.kt index 75d6a4664..91fd2a6b6 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/SelectTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/SelectTest.kt @@ -12,14 +12,18 @@ import org.junit.Test class SelectTest : BaseUnitTest() { @Test - fun validateSelect() = writableDatabaseForTable { - assertEquals("SELECT `name`,`id` FROM `TwoColumnModel`", - select(name, id) from TwoColumnModel::class) + fun validateSelect() { + writableDatabaseForTable { + assertEquals("SELECT `name`,`id` FROM `TwoColumnModel`", + select(name, id) from TwoColumnModel::class) + } } @Test - fun validateSelectDistinct() = writableDatabaseForTable { - assertEquals("SELECT DISTINCT `name` FROM `SimpleModel`", - select(name).distinct() from SimpleModel::class) + fun validateSelectDistinct() { + writableDatabaseForTable { + assertEquals("SELECT DISTINCT `name` FROM `SimpleModel`", + select(name).distinct() from SimpleModel::class) + } } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/SetTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/SetTest.kt index 246807364..f79683fa2 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/SetTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/SetTest.kt @@ -11,14 +11,18 @@ import org.junit.Test class SetTest : BaseUnitTest() { @Test - fun validateSetWithConditions() = writableDatabaseForTable { - assertEquals("UPDATE `SimpleModel` SET `name`='name'", - update() set name.`is`("name")) + fun validateSetWithConditions() { + writableDatabaseForTable { + assertEquals("UPDATE `SimpleModel` SET `name`='name'", + update() set name.`is`("name")) + } } @Test - fun validateMultipleConditions() = writableDatabaseForTable { - assertEquals("SET `name`='name', `id`=0", - update() set name.eq("name") and id.eq(0)) + fun validateMultipleConditions() { + writableDatabaseForTable { + assertEquals("UPDATE `SimpleModel` SET `name`='name', `id`=0", + update() set name.eq("name") and id.eq(0)) + } } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/TriggerTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/TriggerTest.kt index 371dcfd14..3a333a451 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/TriggerTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/TriggerTest.kt @@ -17,38 +17,43 @@ import org.junit.Test class TriggerTest : BaseUnitTest() { @Test - fun validateBasicTrigger()= writableDatabaseForTable { - assertEquals("CREATE TRIGGER IF NOT EXISTS `MyTrigger` AFTER INSERT ON `SimpleModel` " + - "\nBEGIN" + - "\nINSERT INTO `TwoColumnModel`(`name`) VALUES(`new`.`name`);" + - "\nEND", - createTrigger("MyTrigger").after() insertOn SimpleModel::class begin - insert(TwoColumnModel::class).columnValues(name to NameAlias.ofTable("new", "name"))) + fun validateBasicTrigger() { + writableDatabaseForTable { + assertEquals("CREATE TRIGGER IF NOT EXISTS `MyTrigger` AFTER INSERT ON `SimpleModel` " + + "\nBEGIN" + + "\nINSERT INTO `TwoColumnModel`(`name`) VALUES(`new`.`name`);" + + "\nEND", + createTrigger("MyTrigger").after() insertOn SimpleModel::class begin + insert(TwoColumnModel::class).columnValues(name to NameAlias.ofTable("new", "name"))) + } } @Test - fun validateUpdateTriggerMultiline() = writableDatabaseForTable { - assertEquals("CREATE TEMP TRIGGER IF NOT EXISTS `MyTrigger` BEFORE UPDATE ON `SimpleModel` " + - "\nBEGIN" + - "\nINSERT INTO `TwoColumnModel`(`name`) VALUES(`new`.`name`);" + - "\nINSERT INTO `TwoColumnModel`(`id`) VALUES(CAST(`new`.`name` AS INTEGER));" + - "\nEND", - createTrigger("MyTrigger").temporary().before() updateOn SimpleModel::class begin - insert(TwoColumnModel::class).columnValues(name to NameAlias.ofTable("new", "name")) and - insert(TwoColumnModel::class) - .columnValues(id to cast(NameAlias.ofTable("new", "name").property) - .`as`(SQLiteType.INTEGER))) - + fun validateUpdateTriggerMultiline() { + writableDatabaseForTable { + assertEquals("CREATE TEMP TRIGGER IF NOT EXISTS `MyTrigger` BEFORE UPDATE ON `SimpleModel` " + + "\nBEGIN" + + "\nINSERT INTO `TwoColumnModel`(`name`) VALUES(`new`.`name`);" + + "\nINSERT INTO `TwoColumnModel`(`id`) VALUES(CAST(`new`.`name` AS INTEGER));" + + "\nEND", + createTrigger("MyTrigger").temporary().before() updateOn SimpleModel::class begin + insert(TwoColumnModel::class).columnValues(name to NameAlias.ofTable("new", "name")) and + insert(TwoColumnModel::class) + .columnValues(id to cast(NameAlias.ofTable("new", "name").property) + .`as`(SQLiteType.INTEGER))) + } } @Test - fun validateTriggerWorks() = writableDatabaseForTable{ - val trigger = createTrigger("MyTrigger").after() insertOn SimpleModel::class begin - insert(TwoColumnModel::class).columnValues(name to NameAlias.ofTable("new", "name")) - trigger.enable() - SimpleModel("Test").insert() + fun validateTriggerWorks() { + writableDatabaseForTable { + val trigger = createTrigger("MyTrigger").after() insertOn SimpleModel::class begin + insert(TwoColumnModel::class).columnValues(name to NameAlias.ofTable("new", "name")) + trigger.enable() + SimpleModel("Test").insert() - val result = select from TwoColumnModel::class where (name eq "Test") - assertNotNull(result) + val result = select from TwoColumnModel::class where (name eq "Test") + assertNotNull(result) + } } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UnsafeStringOperatorTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UnsafeStringOperatorTest.kt index 0b772851a..aa27ff86c 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UnsafeStringOperatorTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UnsafeStringOperatorTest.kt @@ -9,10 +9,12 @@ import org.junit.Test class UnsafeStringOperatorTest : BaseUnitTest() { @Test - fun testCanIncludeInQuery() = writableDatabaseForTable{ - val op = UnSafeStringOperator("name = ?, id = ?, test = ?", arrayOf("'name'", "0", "'test'")) - assertEquals("name = 'name', id = 0, test = 'test'", op) - assertEquals("SELECT * FROM `SimpleModel` WHERE name = 'name', id = 0, test = 'test'", - select from SimpleModel::class where op) + fun testCanIncludeInQuery() { + writableDatabaseForTable { + val op = UnSafeStringOperator("name = ?, id = ?, test = ?", arrayOf("'name'", "0", "'test'")) + assertEquals("name = 'name', id = 0, test = 'test'", op) + assertEquals("SELECT * FROM `SimpleModel` WHERE name = 'name', id = 0, test = 'test'", + select from SimpleModel::class where op) + } } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UpdateTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UpdateTest.kt index 5032cc940..f877932fc 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UpdateTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UpdateTest.kt @@ -15,40 +15,54 @@ import org.junit.Test class UpdateTest : BaseUnitTest() { @Test - fun validateUpdateRollback() = writableDatabaseForTable{ - assertEquals("UPDATE OR ROLLBACK `SimpleModel`", update().orRollback()) + fun validateUpdateRollback() { + writableDatabaseForTable { + assertEquals("UPDATE OR ROLLBACK `SimpleModel`", update().orRollback()) + } } @Test - fun validateUpdateFail()= writableDatabaseForTable { - assertEquals("UPDATE OR FAIL `SimpleModel`", update().orFail()) + fun validateUpdateFail() { + writableDatabaseForTable { + assertEquals("UPDATE OR FAIL `SimpleModel`", update().orFail()) + } } @Test - fun validateUpdateIgnore()= writableDatabaseForTable { - assertEquals("UPDATE OR IGNORE `SimpleModel`", update().orIgnore()) + fun validateUpdateIgnore() { + writableDatabaseForTable { + assertEquals("UPDATE OR IGNORE `SimpleModel`", update().orIgnore()) + } } @Test - fun validateUpdateReplace()= writableDatabaseForTable { - assertEquals("UPDATE OR REPLACE `SimpleModel`", update().orReplace()) + fun validateUpdateReplace() { + writableDatabaseForTable { + assertEquals("UPDATE OR REPLACE `SimpleModel`", update().orReplace()) + } } @Test - fun validateUpdateAbort() = writableDatabaseForTable{ - assertEquals("UPDATE OR ABORT `SimpleModel`", update().orAbort()) + fun validateUpdateAbort() { + writableDatabaseForTable { + assertEquals("UPDATE OR ABORT `SimpleModel`", update().orAbort()) + } } @Test - fun validateSetQuery() = writableDatabaseForTable{ - assertEquals("UPDATE `SimpleModel` SET `name`='name'", update() set (name eq "name")) + fun validateSetQuery() { + writableDatabaseForTable { + assertEquals("UPDATE `SimpleModel` SET `name`='name'", update() set (name eq "name")) + } } @Test - fun validateWildcardQuery() = writableDatabaseForTable{ - assertEquals("UPDATE OR FAIL `NumberModel` SET `id`=? WHERE `id`=?", - update().or(ConflictAction.FAIL) - .set(id.eq(Property.WILDCARD)) - .where(id.eq(Property.WILDCARD))) + fun validateWildcardQuery() { + writableDatabaseForTable { + assertEquals("UPDATE OR FAIL `NumberModel` SET `id`=? WHERE `id`=?", + update().or(ConflictAction.FAIL) + .set(id.eq(Property.WILDCARD)) + .where(id.eq(Property.WILDCARD))) + } } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/WhereTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/WhereTest.kt index 9bd604a08..fab8524fe 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/WhereTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/WhereTest.kt @@ -16,110 +16,138 @@ import org.junit.Test class WhereTest : BaseUnitTest() { @Test - fun validateBasicWhere()= writableDatabaseForTable { - assertEquals("SELECT * FROM `SimpleModel` WHERE `name`='name'", - select from SimpleModel::class where name.`is`("name")) + fun validateBasicWhere() { + writableDatabaseForTable { + assertEquals("SELECT * FROM `SimpleModel` WHERE `name`='name'", + select from SimpleModel::class where name.`is`("name")) + } } @Test - fun validateComplexQueryWhere() = writableDatabaseForTable{ - assertEquals("SELECT * FROM `SimpleModel` WHERE `name`='name' OR `id`=1 AND (`id`=0 OR `name`='hi')", - select from SimpleModel::class where name.`is`("name") or id.eq(1) and (id.`is`(0) or name.eq("hi"))) + fun validateComplexQueryWhere() { + writableDatabaseForTable { + assertEquals("SELECT * FROM `SimpleModel` WHERE `name`='name' OR `id`=1 AND (`id`=0 OR `name`='hi')", + select from SimpleModel::class where name.`is`("name") or id.eq(1) and (id.`is`(0) or name.eq("hi"))) + } } @Test - fun validateGroupBy()= writableDatabaseForTable { - assertEquals("SELECT * FROM `SimpleModel` WHERE `name`='name' GROUP BY `name`", - select from SimpleModel::class where name.`is`("name") groupBy name) + fun validateGroupBy() { + writableDatabaseForTable { + assertEquals("SELECT * FROM `SimpleModel` WHERE `name`='name' GROUP BY `name`", + select from SimpleModel::class where name.`is`("name") groupBy name) + } } @Test - fun validateGroupByNameAlias()= writableDatabaseForTable { - assertEquals("SELECT * FROM `SimpleModel` WHERE `name`='name' GROUP BY `name`,`id`", - (select from SimpleModel::class where name.`is`("name")).groupBy("name".nameAlias, "id".nameAlias)) + fun validateGroupByNameAlias() { + writableDatabaseForTable { + assertEquals("SELECT * FROM `SimpleModel` WHERE `name`='name' GROUP BY `name`,`id`", + (select from SimpleModel::class where name.`is`("name")).groupBy("name".nameAlias, "id".nameAlias)) + } } @Test - fun validateGroupByNameProps()= writableDatabaseForTable { - assertEquals("SELECT * FROM `SimpleModel` WHERE `name`='name' GROUP BY `name`,`id`", - (select from SimpleModel::class where name.`is`("name")).groupBy(name, id)) + fun validateGroupByNameProps() { + writableDatabaseForTable { + assertEquals("SELECT * FROM `SimpleModel` WHERE `name`='name' GROUP BY `name`,`id`", + (select from SimpleModel::class where name.`is`("name")).groupBy(name, id)) + } } @Test - fun validateHaving()= writableDatabaseForTable { - assertEquals("SELECT * FROM `SimpleModel` WHERE `name`='name' HAVING `name` LIKE 'That'", - select from SimpleModel::class where name.`is`("name") having name.like("That")) + fun validateHaving() { + writableDatabaseForTable { + assertEquals("SELECT * FROM `SimpleModel` WHERE `name`='name' HAVING `name` LIKE 'That'", + select from SimpleModel::class where name.`is`("name") having name.like("That")) + } } @Test - fun validateLimit()= writableDatabaseForTable { - assertEquals("SELECT * FROM `SimpleModel` WHERE `name`='name' LIMIT 10", - select from SimpleModel::class where name.`is`("name") limit 10) + fun validateLimit() { + writableDatabaseForTable { + assertEquals("SELECT * FROM `SimpleModel` WHERE `name`='name' LIMIT 10", + select from SimpleModel::class where name.`is`("name") limit 10) + } } @Test - fun validateOffset()= writableDatabaseForTable { - assertEquals("SELECT * FROM `SimpleModel` WHERE `name`='name' OFFSET 10", - select from SimpleModel::class where name.`is`("name") offset 10) + fun validateOffset() { + writableDatabaseForTable { + assertEquals("SELECT * FROM `SimpleModel` WHERE `name`='name' OFFSET 10", + select from SimpleModel::class where name.`is`("name") offset 10) + } } @Test - fun validateWhereExists()= writableDatabaseForTable { - assertEquals("SELECT * FROM `SimpleModel` " + - "WHERE EXISTS (SELECT `name` FROM `SimpleModel` WHERE `name` LIKE 'Andrew')", - select from SimpleModel::class - whereExists (select(name) from SimpleModel::class where name.like("Andrew"))) + fun validateWhereExists() { + writableDatabaseForTable { + assertEquals("SELECT * FROM `SimpleModel` " + + "WHERE EXISTS (SELECT `name` FROM `SimpleModel` WHERE `name` LIKE 'Andrew')", + select from SimpleModel::class + whereExists (select(name) from SimpleModel::class where name.like("Andrew"))) + } } @Test - fun validateOrderByWhere()= writableDatabaseForTable { - assertEquals("SELECT * FROM `SimpleModel` " + - "WHERE `name`='name' ORDER BY `name` ASC", - (select from SimpleModel::class - where name.eq("name")).orderBy(name, true)) + fun validateOrderByWhere() { + writableDatabaseForTable { + assertEquals("SELECT * FROM `SimpleModel` " + + "WHERE `name`='name' ORDER BY `name` ASC", + (select from SimpleModel::class + where name.eq("name")).orderBy(name, true)) + } } @Test - fun validateOrderByWhereAlias()= writableDatabaseForTable { - assertEquals("SELECT * FROM `SimpleModel` " + - "WHERE `name`='name' ORDER BY `name` ASC", - (select from SimpleModel::class - where name.eq("name")).orderBy("name".nameAlias, true)) + fun validateOrderByWhereAlias() { + writableDatabaseForTable { + assertEquals("SELECT * FROM `SimpleModel` " + + "WHERE `name`='name' ORDER BY `name` ASC", + (select from SimpleModel::class + where name.eq("name")).orderBy("name".nameAlias, true)) + } } @Test - fun validateOrderBy()= writableDatabaseForTable { - assertEquals("SELECT * FROM `SimpleModel` " + - "WHERE `name`='name' ORDER BY `name` ASC", - select from SimpleModel::class - where name.eq("name") orderBy fromNameAlias("name".nameAlias).ascending()) + fun validateOrderBy() { + writableDatabaseForTable { + assertEquals("SELECT * FROM `SimpleModel` " + + "WHERE `name`='name' ORDER BY `name` ASC", + select from SimpleModel::class + where name.eq("name") orderBy fromNameAlias("name".nameAlias).ascending()) + } } @Test - fun validateOrderByAll()= writableDatabaseForTable { - assertEquals("SELECT * FROM `TwoColumnModel` " + - "WHERE `name`='name' ORDER BY `name` ASC,`id` DESC", - (select from TwoColumnModel::class - where name.eq("name")) - .orderByAll(listOf( - fromNameAlias("name".nameAlias).ascending(), - fromNameAlias("id".nameAlias).descending()))) + fun validateOrderByAll() { + writableDatabaseForTable { + assertEquals("SELECT * FROM `TwoColumnModel` " + + "WHERE `name`='name' ORDER BY `name` ASC,`id` DESC", + (select from TwoColumnModel::class + where name.eq("name")) + .orderByAll(listOf( + fromNameAlias("name".nameAlias).ascending(), + fromNameAlias("id".nameAlias).descending()))) + } } @Test - fun validateNonSelectThrowError()= writableDatabaseForTable { - try { - update().set(name.`is`("name")).result - fail("Non select passed") - } catch (i: IllegalArgumentException) { - // expected - } - - try { - update().set(name.`is`("name")).list - fail("Non select passed") - } catch (i: IllegalArgumentException) { - // expected + fun validateNonSelectThrowError() { + writableDatabaseForTable { + try { + update().set(name.`is`("name")).result + fail("Non select passed") + } catch (i: IllegalArgumentException) { + // expected + } + + try { + update().set(name.`is`("name")).list + fail("Non select passed") + } catch (i: IllegalArgumentException) { + // expected + } } } } diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/IndexPropertyTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/IndexPropertyTest.kt index 46105d908..bc7c9b7ca 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/IndexPropertyTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/IndexPropertyTest.kt @@ -11,12 +11,13 @@ class IndexPropertyTest : BaseUnitTest() { @Test - fun validateIndexProperty() = writableDatabaseForTable { - - val prop = IndexProperty("Index", true, SimpleModel::class.java, - SimpleModel_Table.name) - prop.createIfNotExists(this) - prop.drop(this) - assertEquals("`Index`", prop.indexName) + fun validateIndexProperty() { + writableDatabaseForTable { + val prop = IndexProperty("Index", true, SimpleModel::class.java, + SimpleModel_Table.name) + prop.createIfNotExists(this) + prop.drop(this) + assertEquals("`Index`", prop.indexName) + } } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/queriable/AsyncQueryTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/queriable/AsyncQueryTest.kt index 45b75c95a..7decd23b5 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/queriable/AsyncQueryTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/queriable/AsyncQueryTest.kt @@ -13,40 +13,46 @@ import org.junit.Test class AsyncQueryTest : BaseUnitTest() { @Test - fun testQueryResult() = writableDatabaseForTable{ - SimpleModel("name").save() - - var model: SimpleModel? = null - (select from SimpleModel::class).async result { _, result -> - model = result + fun testQueryResult() { + writableDatabaseForTable { + SimpleModel("name").save() + + var model: SimpleModel? = null + (select from SimpleModel::class).async result { _, result -> + model = result + } + assertNotNull(model) + assertEquals("name", model?.name) } - assertNotNull(model) - assertEquals("name", model?.name) } @Test - fun testQueryListResult() = writableDatabaseForTable{ - SimpleModel("name").save() - SimpleModel("name2").save() - - var list = mutableListOf() - (select from SimpleModel::class).async list { _, mutableList -> - list = mutableList.toMutableList() + fun testQueryListResult() { + writableDatabaseForTable { + SimpleModel("name").save() + SimpleModel("name2").save() + + var list = mutableListOf() + (select from SimpleModel::class).async list { _, mutableList -> + list = mutableList.toMutableList() + } + assertEquals(2, list.size) } - assertEquals(2, list.size) } @Test - fun testQueryListCursorResult() = writableDatabaseForTable{ - SimpleModel("name").save() - SimpleModel("name2").save() - - var result: CursorResult? = null - (select from SimpleModel::class).async cursorResult { _, cursorResult -> - result = cursorResult + fun testQueryListCursorResult() { + writableDatabaseForTable { + SimpleModel("name").save() + SimpleModel("name2").save() + + var result: CursorResult? = null + (select from SimpleModel::class).async cursorResult { _, cursorResult -> + result = cursorResult + } + assertNotNull(result) + assertEquals(2L, result?.count) + result?.close() } - assertNotNull(result) - assertEquals(2L, result?.count) - result?.close() } } \ No newline at end of file diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt index ca5aa4221..b694e92bb 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt @@ -435,6 +435,9 @@ inline fun database(): DatabaseDefinition inline fun database(kClass: KClass, f: DatabaseDefinition.() -> R): R = FlowManager.getDatabase(kClass.java).f() +fun writableDatabaseForTable(kClass: KClass, f: DatabaseWrapper.() -> R): R + = FlowManager.getWritableDatabaseForTable(kClass.java).f() + inline fun writableDatabaseForTable(f: DatabaseWrapper.() -> Unit): DatabaseWrapper = FlowManager.getWritableDatabaseForTable(T::class.java).apply(f) @@ -444,6 +447,9 @@ inline fun writableDatabaseForTable(): DatabaseWrapper fun writableDatabase(kClass: KClass, f: DatabaseWrapper.() -> R): R = FlowManager.getWritableDatabase(kClass.java).f() +inline fun writableDatabase(f: DatabaseWrapper.() -> R): R + = FlowManager.getWritableDatabase(T::class.java).f() + inline fun writableDatabase(): DatabaseWrapper = FlowManager.getWritableDatabase(T::class.java) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Operator.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Operator.kt index 0b3734d69..914725c3d 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Operator.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Operator.kt @@ -9,7 +9,6 @@ import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.converter.TypeConverter import com.raizlabs.android.dbflow.sql.Query import com.raizlabs.android.dbflow.sql.language.property.Property -import java.util.* /** * Description: The class that contains a column name, Operator, and value. @@ -324,7 +323,7 @@ class Operator : BaseOperator, IOperator { override fun concatenate(value: Any?): Operator { var _value = value - operation = "${Operation.EQUALS} ${columnName()}" + operation = "${Operation.EQUALS}${columnName()}" var typeConverter: TypeConverter<*, Any>? = this.typeConverter as TypeConverter<*, Any>? if (typeConverter == null && _value != null) { @@ -557,7 +556,7 @@ class Operator : BaseOperator, IOperator { */ class In : BaseOperator, Query { - private val inArguments = ArrayList() + private val inArguments = arrayListOf() override val query: String get() = appendToQuery() @@ -573,7 +572,7 @@ class Operator : BaseOperator, IOperator { @SafeVarargs internal constructor(operator: Operator, firstArgument: T?, isIn: Boolean, vararg arguments: T?) : super(operator.columnAlias()) { inArguments.add(firstArgument) - Collections.addAll(inArguments, *arguments) + inArguments.addAll(arguments) operation = " ${if (isIn) Operation.IN else Operation.NOT_IN} " } @@ -621,7 +620,7 @@ class Operator : BaseOperator, IOperator { fun NameAlias.op() = Operator.op(this) -fun String.op(): Operator = nameAlias.op() +fun String.op(): Operator = nameAlias.op() infix fun Operator.collate(collation: Collate) = collate(collation) From 218d568262d1496e270657e3ca56484cc4f7a34f Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Fri, 24 Nov 2017 17:54:07 -0500 Subject: [PATCH 069/234] [5.0] add a coroutine for db transaction of a modelqueriable. --- .../dbflow/config/DatabaseDefinition.kt | 7 +++++ .../database/transaction/Coroutines.kt | 30 +++++++++++++++++++ .../database/transaction/Couroutines.kt | 14 --------- .../database/transaction/Transaction.kt | 25 ++++++++++++++++ 4 files changed, 62 insertions(+), 14 deletions(-) create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Coroutines.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Couroutines.kt diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.kt index c78420c4c..7afbb9319 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.kt @@ -269,6 +269,13 @@ abstract class DatabaseDefinition { fun beginTransactionAsync(transaction: ITransaction): Transaction.Builder = Transaction.Builder(transaction, this) + fun beginTransactionAsync(transaction: (DatabaseWrapper) -> Unit): Transaction.Builder = + beginTransactionAsync(object : ITransaction { + override fun execute(databaseWrapper: DatabaseWrapper) { + transaction(databaseWrapper) + } + }) + fun executeTransaction(transaction: ITransaction) { val database = writableDatabase try { diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Coroutines.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Coroutines.kt new file mode 100644 index 000000000..3f26add7e --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Coroutines.kt @@ -0,0 +1,30 @@ +package com.raizlabs.android.dbflow.structure.database.transaction + +import com.raizlabs.android.dbflow.config.DatabaseDefinition +import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable +import kotlinx.coroutines.experimental.suspendCancellableCoroutine + +/** + * Description: Puts the [ModelQueriable] operation on the bg. inside the [queriableFunction] call + * the method you wish to execute within a transaction. + */ +suspend fun DatabaseDefinition.transact(modelQueriable: ModelQueriable, + queriableFunction: (ModelQueriable) -> R) + = suspendCancellableCoroutine { continuation -> + var value: R? = null + val transaction = beginTransactionAsync { value = queriableFunction(modelQueriable) } + .success { + continuation.resume(value) + } + .error { _, throwable -> + if (continuation.isCancelled) return@error + continuation.resumeWithException(throwable) + }.build() + transaction.execute() + + continuation.invokeOnCompletion { + if (continuation.isCancelled) { + transaction.cancel() + } + } +} \ No newline at end of file diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Couroutines.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Couroutines.kt deleted file mode 100644 index 33250bd4e..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Couroutines.kt +++ /dev/null @@ -1,14 +0,0 @@ -package com.raizlabs.android.dbflow.structure.database.transaction - -import com.raizlabs.android.dbflow.config.database -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper -import kotlinx.coroutines.experimental.async - -/** - * Performs database operations on the background in coroutines. - */ -inline suspend fun db(crossinline function: DatabaseWrapper.() -> Unit) { - async { - function(database().writableDatabase) - } -} \ No newline at end of file diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Transaction.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Transaction.kt index 0cb6c86e5..83f8686d0 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Transaction.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Transaction.kt @@ -152,6 +152,17 @@ class Transaction(private val transaction: ITransaction, this.errorCallback = errorCallback } + /** + * Specify an error callback to return all and any [Throwable] that occured during a [Transaction]. + */ + fun error(errorCallback: (Transaction, Throwable) -> Unit) = apply { + this.errorCallback = object : Error { + override fun onError(transaction: Transaction, error: Throwable) { + errorCallback(transaction, error) + } + } + } + /** * Specify a listener for successful transactions. This is called when the [ITransaction] * specified is finished and it is posted on the UI thread. @@ -162,6 +173,20 @@ class Transaction(private val transaction: ITransaction, this.successCallback = successCallback } + /** + * Specify a listener for successful transactions. This is called when the [ITransaction] + * specified is finished and it is posted on the UI thread. + * + * @param successCallback The callback, invoked on the UI thread. + */ + fun success(successCallback: (Transaction) -> Unit) = apply { + this.successCallback = object : Success { + override fun onSuccess(transaction: Transaction) { + successCallback(transaction) + } + } + } + /** * Give this transaction a name. This will allow you to call [ITransactionQueue.cancel]. * From a94d79fd120b4a9b54c992fd70d8fa450cd9256e Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sat, 25 Nov 2017 14:54:45 -0500 Subject: [PATCH 070/234] [5.0] make databasedefinition a databasewrapper, simplify kotlin extension methods so you can use same object in same place. --- README.md | 2 +- .../dbflow/sqlcipher/SQLCipherOpenHelper.java | 2 +- dbflow-tests/build.gradle | 5 ++ .../contentobserver/ContentObserverTest.kt | 4 +- .../dbflow/prepackaged/PrepackagedDBTest.kt | 4 +- .../android/dbflow/sqlcipher/CipherTest.kt | 4 +- .../contentprovider/ContentProviderTests.kt | 8 ++-- .../database/transaction/CoroutinesTest.kt | 36 ++++++++++++++ .../dbflow/list/FlowCursorIteratorTest.kt | 8 ++-- .../android/dbflow/list/FlowCursorListTest.kt | 10 ++-- .../android/dbflow/list/FlowQueryListTest.kt | 4 +- .../dbflow/models/CachingModelsTest.kt | 6 +-- .../dbflow/models/DontCreateModelTest.kt | 4 +- .../android/dbflow/models/ModelViewTest.kt | 6 +-- .../dbflow/models/OneToManyModelTest.kt | 4 +- .../android/dbflow/models/OneToManyModels.kt | 5 +- .../dbflow/models/ParentChildCachingTest.kt | 4 +- .../android/dbflow/models/QueryModelTest.kt | 4 +- .../dbflow/runtime/DirectNotifierTest.kt | 4 +- .../rx/language/CursorResultSubscriberTest.kt | 4 +- .../dbflow/rx/language/RXQueryTests.kt | 10 ++-- .../dbflow/sql/language/CursorResultTest.kt | 4 +- .../android/dbflow/sql/language/DeleteTest.kt | 8 ++-- .../sql/language/ExistenceOperatorTest.kt | 4 +- .../android/dbflow/sql/language/FromTest.kt | 12 ++--- .../android/dbflow/sql/language/IndexTest.kt | 8 ++-- .../dbflow/sql/language/IndexedByTest.kt | 4 +- .../android/dbflow/sql/language/InsertTest.kt | 14 +++--- .../android/dbflow/sql/language/JoinTest.kt | 16 +++---- .../dbflow/sql/language/OperatorTest.kt | 4 +- .../android/dbflow/sql/language/SelectTest.kt | 6 +-- .../android/dbflow/sql/language/SetTest.kt | 6 +-- .../dbflow/sql/language/TriggerTest.kt | 8 ++-- .../sql/language/UnsafeStringOperatorTest.kt | 4 +- .../android/dbflow/sql/language/UpdateTest.kt | 16 +++---- .../android/dbflow/sql/language/WhereTest.kt | 30 ++++++------ .../language/property/IndexPropertyTest.kt | 4 +- .../language/property/PropertyFactoryTest.kt | 4 +- .../sql/migration/UpdateTableMigrationTest.kt | 4 +- .../dbflow/sql/queriable/AsyncQueryTest.kt | 8 ++-- .../dbflow/config/DatabaseDefinition.kt | 48 ++++++++++++++++++- .../android/dbflow/config/FlowManager.kt | 35 +++++--------- .../android/dbflow/structure/Model.kt | 14 +++--- .../structure/database/DatabaseWrapper.kt | 2 +- .../database/transaction/Coroutines.kt | 17 +++---- .../transaction/DefaultTransactionQueue.kt | 14 +++--- .../database/transaction/ITransaction.kt | 2 - .../database/transaction/Transaction.kt | 4 +- 48 files changed, 257 insertions(+), 181 deletions(-) create mode 100644 dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/CoroutinesTest.kt diff --git a/README.md b/README.md index 8f6b007eb..4a07021e9 100644 --- a/README.md +++ b/README.md @@ -15,7 +15,7 @@ DBFlow is built from a collection of the best features of many database librarie - **SQLite Query Flow**: The queries in this library adhere as closely as possible to SQLite native queries. `select(name, screenSize).from(Android.class).where(name.is("Nexus 5x")).and(version.is(6.0)).querySingle()` - **Open Source**: This library is fully open source and contributions are not only welcomed, but encouraged. - **Robust**: We support `Trigger`, `ModelView`, `Index`, `Migration`, built-in ways to manage database access, and many more features. SQLCipher, RXJava, and more! -- **Multiple Databases, Multiple Modules**: we seamlessly support multiple database files, database modules using DBFlow in other dependencies, simultaneously. +- **Multiple Databases, Multiple Modules**: we seamlessly support multiple database files, databaseForTable modules using DBFlow in other dependencies, simultaneously. - **Built On SQLite**: SQLite is the most widely used database engine in world and using it as your base, you are not tied to a limited set of platforms or libraries. # Changelog diff --git a/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherOpenHelper.java b/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherOpenHelper.java index 47d32bf64..59a81079d 100644 --- a/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherOpenHelper.java +++ b/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherOpenHelper.java @@ -18,7 +18,7 @@ /** * Description: The replacement {@link OpenHelper} for SQLCipher. Specify a subclass of this is {@link DatabaseConfig#getDatabaseClass()} - * of your database to get it to work with specifying the secret you use for the database. + * of your database to get it to work with specifying the secret you use for the databaseForTable. */ public abstract class SQLCipherOpenHelper extends SQLiteOpenHelper implements OpenHelper { diff --git a/dbflow-tests/build.gradle b/dbflow-tests/build.gradle index 64b03de46..10f92b92f 100644 --- a/dbflow-tests/build.gradle +++ b/dbflow-tests/build.gradle @@ -91,4 +91,9 @@ android.applicationVariants.all { variant -> dexcount { includeClasses = true orderByMethodCount = true +} +kotlin { + experimental { + coroutines "enable" + } } \ No newline at end of file diff --git a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/contentobserver/ContentObserverTest.kt b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/contentobserver/ContentObserverTest.kt index 0ad534751..58143613b 100644 --- a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/contentobserver/ContentObserverTest.kt +++ b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/contentobserver/ContentObserverTest.kt @@ -4,7 +4,7 @@ import android.net.Uri import com.raizlabs.android.dbflow.BaseInstrumentedUnitTest import com.raizlabs.android.dbflow.DemoApp import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.config.writableDatabaseForTable +import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.contentobserver.User_Table.id import com.raizlabs.android.dbflow.contentobserver.User_Table.name import com.raizlabs.android.dbflow.runtime.FlowContentObserver @@ -28,7 +28,7 @@ class ContentObserverTest : BaseInstrumentedUnitTest() { @Before fun setupUser() { - writableDatabaseForTable { + databaseForTable { (delete() from User::class).execute() } user = User(5, "Something", 55) diff --git a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/prepackaged/PrepackagedDBTest.kt b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/prepackaged/PrepackagedDBTest.kt index 1bbc5468a..138eb1973 100644 --- a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/prepackaged/PrepackagedDBTest.kt +++ b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/prepackaged/PrepackagedDBTest.kt @@ -1,7 +1,7 @@ package com.raizlabs.android.dbflow.prepackaged import com.raizlabs.android.dbflow.BaseInstrumentedUnitTest -import com.raizlabs.android.dbflow.config.writableDatabaseForTable +import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.sql.queriable.list import org.junit.Assert.assertTrue @@ -14,7 +14,7 @@ class PrepackagedDBTest : BaseInstrumentedUnitTest() { @Test fun assertWeCanLoadFromDB() { - writableDatabaseForTable { + databaseForTable { val list = (select from Dog::class).list assertTrue(!list.isEmpty()) } diff --git a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/sqlcipher/CipherTest.kt b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/sqlcipher/CipherTest.kt index 4e2062a52..ff43998e0 100644 --- a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/sqlcipher/CipherTest.kt +++ b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/sqlcipher/CipherTest.kt @@ -1,7 +1,7 @@ package com.raizlabs.android.dbflow.sqlcipher import com.raizlabs.android.dbflow.BaseInstrumentedUnitTest -import com.raizlabs.android.dbflow.config.writableDatabase +import com.raizlabs.android.dbflow.config.database import com.raizlabs.android.dbflow.sql.language.delete import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.sql.language.where @@ -15,7 +15,7 @@ import org.junit.Test class CipherTest : BaseInstrumentedUnitTest() { @Test - fun testCipherModel() = writableDatabase(CipherDatabase::class) { + fun testCipherModel() = database(CipherDatabase::class) { (delete() from CipherModel::class).execute() val model = CipherModel(name = "name") model.save(this) diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/contentprovider/ContentProviderTests.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/contentprovider/ContentProviderTests.kt index 20109adfb..91ee77d76 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/contentprovider/ContentProviderTests.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/contentprovider/ContentProviderTests.kt @@ -3,7 +3,7 @@ package com.raizlabs.android.dbflow.contentprovider import android.content.ContentResolver import android.content.pm.ProviderInfo import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.config.writableDatabase +import com.raizlabs.android.dbflow.config.database import com.raizlabs.android.dbflow.sql.language.Delete.Companion.table import com.raizlabs.android.dbflow.sql.language.Delete.Companion.tables import com.raizlabs.android.dbflow.sql.language.select @@ -36,7 +36,7 @@ class ContentProviderTests : BaseUnitTest() { } @Test - fun testContentProviderUtils() = writableDatabase(ContentDatabase::class) { + fun testContentProviderUtils() = database(ContentDatabase::class) { tables(NoteModel::class.java, ContentProviderModel::class.java) val contentProviderModel = ContentProviderModel() @@ -69,7 +69,7 @@ class ContentProviderTests : BaseUnitTest() { } @Test - fun testContentProviderNative() = writableDatabase(ContentDatabase::class) { + fun testContentProviderNative() = database(ContentDatabase::class) { tables(NoteModel::class.java, ContentProviderModel::class.java) val contentProviderModel = ContentProviderModel(notes = "Test") @@ -101,7 +101,7 @@ class ContentProviderTests : BaseUnitTest() { } @Test - fun testSyncableModel() = writableDatabase(ContentDatabase::class) { + fun testSyncableModel() = database(ContentDatabase::class) { table(TestSyncableModel::class.java) var testSyncableModel = TestSyncableModel(name = "Name") diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/CoroutinesTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/CoroutinesTest.kt new file mode 100644 index 000000000..0eaa02803 --- /dev/null +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/CoroutinesTest.kt @@ -0,0 +1,36 @@ +package com.raizlabs.android.dbflow.database.transaction + +import com.raizlabs.android.dbflow.BaseUnitTest +import com.raizlabs.android.dbflow.TestDatabase +import com.raizlabs.android.dbflow.config.database +import com.raizlabs.android.dbflow.models.SimpleModel +import com.raizlabs.android.dbflow.models.SimpleModel_Table +import com.raizlabs.android.dbflow.sql.language.select +import com.raizlabs.android.dbflow.sql.language.where +import com.raizlabs.android.dbflow.sql.queriable.list +import com.raizlabs.android.dbflow.structure.database.transaction.transact +import com.raizlabs.android.dbflow.structure.save +import kotlinx.coroutines.experimental.runBlocking +import org.junit.Test + +/** + * Description: + */ +class CoroutinesTest : BaseUnitTest() { + + @Test + fun testCanRunCoroutines() { + runBlocking { + database { + (0..9).forEach { + SimpleModel("$it").save() + } + + val query = (select from SimpleModel::class where SimpleModel_Table.name.eq("5")) + .transact(this) { list } + + assert(query.size == 1) + } + } + } +} \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorIteratorTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorIteratorTest.kt index 135f57c92..d9181a9b4 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorIteratorTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorIteratorTest.kt @@ -1,7 +1,7 @@ package com.raizlabs.android.dbflow.list import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.config.writableDatabaseForTable +import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.structure.save @@ -16,7 +16,7 @@ class FlowCursorIteratorTest : BaseUnitTest() { @Test fun testCanIterateFullList() { - writableDatabaseForTable { + databaseForTable { (0..9).forEach { SimpleModel("$it").save() } @@ -32,7 +32,7 @@ class FlowCursorIteratorTest : BaseUnitTest() { @Test fun testCanIteratePartialList() { - writableDatabaseForTable { + databaseForTable { (0..9).forEach { SimpleModel("$it").save() } @@ -48,7 +48,7 @@ class FlowCursorIteratorTest : BaseUnitTest() { @Test fun testCanSupplyBadMaximumValue() { - writableDatabaseForTable { + databaseForTable { (0..9).forEach { SimpleModel("$it").save() } diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorListTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorListTest.kt index 168362ff8..476ac79b2 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorListTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorListTest.kt @@ -4,7 +4,7 @@ import com.nhaarman.mockito_kotlin.mock import com.nhaarman.mockito_kotlin.times import com.nhaarman.mockito_kotlin.verify import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.config.writableDatabaseForTable +import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.sql.queriable.cursor @@ -19,7 +19,7 @@ class FlowCursorListTest : BaseUnitTest() { @Test fun validateCursorPassed() { - writableDatabaseForTable { + databaseForTable { val cursor = (select from SimpleModel::class).cursor val list = FlowCursorList.Builder(select from SimpleModel::class) .cursor(cursor) @@ -31,7 +31,7 @@ class FlowCursorListTest : BaseUnitTest() { @Test fun validateModelQueriable() { - writableDatabaseForTable { + databaseForTable { val modelQueriable = (select from SimpleModel::class) val list = FlowCursorList.Builder(modelQueriable) .build() @@ -42,7 +42,7 @@ class FlowCursorListTest : BaseUnitTest() { @Test fun validateGetAll() { - writableDatabaseForTable { + databaseForTable { (0..9).forEach { SimpleModel("$it").save() } @@ -55,7 +55,7 @@ class FlowCursorListTest : BaseUnitTest() { @Test fun validateCursorChange() { - writableDatabaseForTable { + databaseForTable { (0..9).forEach { SimpleModel("$it").save() } diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowQueryListTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowQueryListTest.kt index 3932c454d..a593eb30e 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowQueryListTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowQueryListTest.kt @@ -1,7 +1,7 @@ package com.raizlabs.android.dbflow.list import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.config.writableDatabaseForTable +import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.sql.language.select import org.junit.Assert.assertTrue @@ -11,7 +11,7 @@ class FlowQueryListTest : BaseUnitTest() { @Test fun validateBuilder() { - writableDatabaseForTable { + databaseForTable { val list = FlowQueryList.Builder(select from SimpleModel::class) .transact(true) .changeInTransaction(true) diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/CachingModelsTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/CachingModelsTest.kt index b74cf5023..0b68c4ed7 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/CachingModelsTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/CachingModelsTest.kt @@ -2,7 +2,7 @@ package com.raizlabs.android.dbflow.models import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.TestDatabase -import com.raizlabs.android.dbflow.config.writableDatabase +import com.raizlabs.android.dbflow.config.database import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.sql.queriable.list import com.raizlabs.android.dbflow.sql.queriable.result @@ -17,7 +17,7 @@ import org.junit.Test class CachingModelsTest : BaseUnitTest() { @Test - fun testSimpleCache() = writableDatabase(TestDatabase::class) { + fun testSimpleCache() = database(TestDatabase::class) { val list = arrayListOf() (0..9).forEach { val simpleCacheObject = SimpleCacheObject("$it") @@ -33,7 +33,7 @@ class CachingModelsTest : BaseUnitTest() { } @Test - fun testComplexObject() = writableDatabase(TestDatabase::class) { + fun testComplexObject() = database(TestDatabase::class) { val path = Path("1", "Path") path.save() diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/DontCreateModelTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/DontCreateModelTest.kt index 7277b5115..abd8e4064 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/DontCreateModelTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/DontCreateModelTest.kt @@ -3,7 +3,7 @@ package com.raizlabs.android.dbflow.models import android.database.sqlite.SQLiteException import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.assertThrowsException -import com.raizlabs.android.dbflow.config.writableDatabaseForTable +import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.sql.queriable.list import org.junit.Test @@ -15,7 +15,7 @@ class DontCreateModelTest : BaseUnitTest() { @Test fun testModelNotCreated() { - writableDatabaseForTable { + databaseForTable { assertThrowsException(SQLiteException::class) { (select from DontCreateModel::class).list } diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ModelViewTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ModelViewTest.kt index cf5558f07..c4522d31c 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ModelViewTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ModelViewTest.kt @@ -3,20 +3,20 @@ package com.raizlabs.android.dbflow.models import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.TestDatabase import com.raizlabs.android.dbflow.assertEquals -import com.raizlabs.android.dbflow.config.writableDatabase +import com.raizlabs.android.dbflow.config.database import com.raizlabs.android.dbflow.models.java.JavaModelView import org.junit.Test class ModelViewTest : BaseUnitTest() { @Test - fun validateModelViewQuery() = writableDatabase(TestDatabase::class) { + fun validateModelViewQuery() = database(TestDatabase::class) { assertEquals("SELECT `id` AS `authorId`,`first_name` || ' ' || `last_name` AS `authorName` FROM `Author`", AuthorView.getQuery(this)) } @Test - fun validateJavaModelViewQuery() = writableDatabase(TestDatabase::class) { + fun validateJavaModelViewQuery() = database(TestDatabase::class) { assertEquals("SELECT `first_name` AS `firstName`,`id` AS `id`", JavaModelView.getQuery(this)) } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModelTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModelTest.kt index 95b51ce05..f50c47e54 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModelTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModelTest.kt @@ -2,7 +2,7 @@ package com.raizlabs.android.dbflow.models import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.TestDatabase -import com.raizlabs.android.dbflow.config.writableDatabase +import com.raizlabs.android.dbflow.config.database import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.sql.queriable.list import com.raizlabs.android.dbflow.sql.queriable.result @@ -16,7 +16,7 @@ class OneToManyModelTest : BaseUnitTest() { @Test fun testOneToManyModel(){ - writableDatabase(TestDatabase::class) { + database(TestDatabase::class) { var testModel2 = TwoColumnModel("Greater", 4) testModel2.save() diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModels.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModels.kt index da24909b3..e3ddd4fbb 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModels.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModels.kt @@ -5,8 +5,7 @@ import com.raizlabs.android.dbflow.annotation.OneToMany import com.raizlabs.android.dbflow.annotation.OneToManyMethod import com.raizlabs.android.dbflow.annotation.PrimaryKey import com.raizlabs.android.dbflow.annotation.Table -import com.raizlabs.android.dbflow.config.writableDatabase -import com.raizlabs.android.dbflow.config.writableDatabaseForTable +import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.sql.language.where @@ -23,7 +22,7 @@ class OneToManyModel(@PrimaryKey var name: String? = null) { @get:OneToMany(oneToManyMethods = arrayOf(OneToManyMethod.ALL)) var simpleModels by oneToMany { - writableDatabaseForTable(OneToManyBaseModel::class) { + databaseForTable(OneToManyBaseModel::class) { select from OneToManyBaseModel::class } } diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ParentChildCachingTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ParentChildCachingTest.kt index ec2ce4d85..73ace6c83 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ParentChildCachingTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ParentChildCachingTest.kt @@ -2,7 +2,7 @@ package com.raizlabs.android.dbflow.models import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.TestDatabase -import com.raizlabs.android.dbflow.config.writableDatabase +import com.raizlabs.android.dbflow.config.database import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.sql.queriable.result import com.raizlabs.android.dbflow.structure.load @@ -17,7 +17,7 @@ class ParentChildCachingTest : BaseUnitTest() { @Test - fun testCanLoadChildFromCache() = writableDatabase(TestDatabase::class) { + fun testCanLoadChildFromCache() = database(TestDatabase::class) { val child = TestModelChild() child.id = 1 child.name = "Test child" diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/QueryModelTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/QueryModelTest.kt index 5aeb0e3ae..8cbff9b80 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/QueryModelTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/QueryModelTest.kt @@ -2,7 +2,7 @@ package com.raizlabs.android.dbflow.models import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.TestDatabase -import com.raizlabs.android.dbflow.config.writableDatabase +import com.raizlabs.android.dbflow.config.database import com.raizlabs.android.dbflow.models.Author_Table.id import com.raizlabs.android.dbflow.models.Blog_Table.author_id import com.raizlabs.android.dbflow.models.Blog_Table.name @@ -22,7 +22,7 @@ class QueryModelTest : BaseUnitTest() { @Test - fun testCanLoadAuthorBlogs() = writableDatabase(TestDatabase::class) { + fun testCanLoadAuthorBlogs() = database(TestDatabase::class) { val author = Author(0, "Andrew", "Grosner") author.save() val blog = Blog(0, "My First Blog", author) diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/runtime/DirectNotifierTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/runtime/DirectNotifierTest.kt index 653f09d89..dd217e3bf 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/runtime/DirectNotifierTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/runtime/DirectNotifierTest.kt @@ -9,7 +9,7 @@ import com.raizlabs.android.dbflow.TestDatabase import com.raizlabs.android.dbflow.config.DatabaseConfig import com.raizlabs.android.dbflow.config.FlowConfig import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.config.writableDatabaseForTable +import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table import com.raizlabs.android.dbflow.sql.language.columnValues @@ -69,7 +69,7 @@ class DirectNotifierTest { @Test fun validateCanNotifyWrapperClasses() { - writableDatabaseForTable { + databaseForTable { val modelChange = Mockito.mock(OnTableChangedListener::class.java) DirectModelNotifier.get().registerForTableChanges(SimpleModel::class.java, modelChange) diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriberTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriberTest.kt index 15b4f7db8..ecc5f3bfb 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriberTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriberTest.kt @@ -1,7 +1,7 @@ package com.raizlabs.android.dbflow.rx.language import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.config.writableDatabaseForTable +import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.structure.save @@ -12,7 +12,7 @@ class CursorResultSubscriberTest : BaseUnitTest() { @Test fun testCanQueryStreamResults() { - writableDatabaseForTable { + databaseForTable { (0..9).forEach { SimpleModel("$it").save() } var count = 0 diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/RXQueryTests.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/RXQueryTests.kt index 2a9af8058..76196f18c 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/RXQueryTests.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/RXQueryTests.kt @@ -2,7 +2,7 @@ package com.raizlabs.android.dbflow.rx.language import android.database.Cursor import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.config.writableDatabaseForTable +import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table.name import com.raizlabs.android.dbflow.sql.language.insert @@ -19,7 +19,7 @@ class RXQueryTests : BaseUnitTest() { @Test fun testCanQuery() { - writableDatabaseForTable { + databaseForTable { SimpleModel("Name").save() var cursor: Cursor? = null @@ -36,7 +36,7 @@ class RXQueryTests : BaseUnitTest() { @Test fun testCanCompileStatement() { - writableDatabaseForTable { + databaseForTable { var databaseStatement: DatabaseStatement? = null (insert().columnValues(name.`is`("name"))) .rxBaseQueriable().compileStatement() @@ -50,7 +50,7 @@ class RXQueryTests : BaseUnitTest() { @Test fun testCountMethod() { - writableDatabaseForTable { + databaseForTable { SimpleModel("name").save() SimpleModel("name2").save() var count = 0L @@ -65,7 +65,7 @@ class RXQueryTests : BaseUnitTest() { @Test fun testInsertMethod() { - writableDatabaseForTable { + databaseForTable { var count = 0L (insert().columnValues(name.eq("name"))) .rxBaseQueriable() diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CursorResultTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CursorResultTest.kt index 980ab44c3..d4fa14f18 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CursorResultTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CursorResultTest.kt @@ -2,7 +2,7 @@ package com.raizlabs.android.dbflow.sql.language import android.database.StaleDataException import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.config.writableDatabaseForTable +import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.models.SimpleCustomModel import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.sql.queriable.cursorResult @@ -17,7 +17,7 @@ class CursorResultTest : BaseUnitTest() { @Before fun prepareList() { - writableDatabaseForTable { + databaseForTable { (0..9).forEach { SimpleModel("$it").save() } result = (select from SimpleModel::class).cursorResult } diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/DeleteTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/DeleteTest.kt index d90162048..e06e71845 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/DeleteTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/DeleteTest.kt @@ -1,7 +1,7 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.config.writableDatabaseForTable +import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table import com.raizlabs.android.dbflow.sql.queriable.list @@ -14,14 +14,14 @@ class DeleteTest : BaseUnitTest() { @Test fun validateQuery() { - writableDatabaseForTable { + databaseForTable { assertEquals("DELETE ", delete().query) } } @Test fun validateDeletion() { - writableDatabaseForTable { + databaseForTable { SimpleModel("name").save() delete().execute() assertFalse((select from SimpleModel::class).hasData()) @@ -30,7 +30,7 @@ class DeleteTest : BaseUnitTest() { @Test fun validateDeletionWithQuery() { - writableDatabaseForTable { + databaseForTable { SimpleModel("name").save() SimpleModel("another name").save() diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/ExistenceOperatorTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/ExistenceOperatorTest.kt index bf897c03f..9ee9e87dd 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/ExistenceOperatorTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/ExistenceOperatorTest.kt @@ -1,7 +1,7 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.config.writableDatabaseForTable +import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table import org.junit.Assert.assertEquals @@ -12,7 +12,7 @@ class ExistenceOperatorTest : BaseUnitTest() { @Test fun validateQuery() { - writableDatabaseForTable { + databaseForTable { assertEquals("EXISTS (SELECT * FROM `SimpleModel` WHERE `name`='name')", ExistenceOperator( (select from SimpleModel::class diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/FromTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/FromTest.kt index 3dfe791b0..fab82db5e 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/FromTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/FromTest.kt @@ -1,7 +1,7 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.config.writableDatabaseForTable +import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table.name import com.raizlabs.android.dbflow.models.TwoColumnModel @@ -15,21 +15,21 @@ class FromTest : BaseUnitTest() { @Test fun validateSimpleFrom() { - writableDatabaseForTable { + databaseForTable { assertEquals("SELECT * FROM `SimpleModel`", (select from SimpleModel::class).query.trim()) } } @Test fun validateProjectionFrom() { - writableDatabaseForTable { + databaseForTable { assertEquals("SELECT `name` FROM `SimpleModel`", (select(name) from SimpleModel::class).query.trim()) } } @Test fun validateMultipleProjection() { - writableDatabaseForTable { + databaseForTable { assertEquals("SELECT `name`,`name`,`id` FROM `SimpleModel`", (select(name, TwoColumnModel_Table.name, id) from SimpleModel::class).query.trim()) } @@ -37,14 +37,14 @@ class FromTest : BaseUnitTest() { @Test fun validateAlias() { - writableDatabaseForTable { + databaseForTable { assertEquals("SELECT * FROM `SimpleModel` AS `Simple`", (select from SimpleModel::class `as` "Simple").query.trim()) } } @Test fun validateJoins() { - writableDatabaseForTable { + databaseForTable { val from = (select from SimpleModel::class innerJoin TwoColumnModel::class on name.eq(TwoColumnModel_Table.name.withTable())) diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexTest.kt index 10ddd6d10..370ddbe7d 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexTest.kt @@ -1,7 +1,7 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.config.writableDatabaseForTable +import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table import org.junit.Assert.assertEquals @@ -11,7 +11,7 @@ class IndexTest : BaseUnitTest() { @Test fun validateBasicIndex() { - writableDatabaseForTable { + databaseForTable { assertEquals("CREATE INDEX IF NOT EXISTS `index` ON `SimpleModel`(`name`)", indexOn("index", SimpleModel_Table.name).query) } @@ -19,7 +19,7 @@ class IndexTest : BaseUnitTest() { @Test fun validateUniqueIndex() { - writableDatabaseForTable { + databaseForTable { assertEquals("CREATE UNIQUE INDEX IF NOT EXISTS `index` ON `SimpleModel`(`name`, `test`)", indexOn("index").unique(true).and(SimpleModel_Table.name) .and("test".nameAlias).query) @@ -28,7 +28,7 @@ class IndexTest : BaseUnitTest() { @Test fun validateBasicIndexNameAlias() { - writableDatabaseForTable { + databaseForTable { assertEquals("CREATE INDEX IF NOT EXISTS `index` ON `SimpleModel`(`name`, `test`)", indexOn("index", "name".nameAlias, "test".nameAlias).query) } diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexedByTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexedByTest.kt index 6cdc575bd..eaeb7a7d6 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexedByTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexedByTest.kt @@ -1,7 +1,7 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.config.writableDatabaseForTable +import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table import com.raizlabs.android.dbflow.sql.language.property.IndexProperty @@ -12,7 +12,7 @@ class IndexedByTest : BaseUnitTest() { @Test fun validateQuery() { - writableDatabaseForTable { + databaseForTable { val indexed = (select from SimpleModel::class) .indexedBy(IndexProperty("Index", false, SimpleModel::class.java, SimpleModel_Table.name)) assertEquals("SELECT * FROM `SimpleModel` INDEXED BY `Index`", indexed.query.trim()) diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/InsertTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/InsertTest.kt index bda35bb8a..d8f8bd96b 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/InsertTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/InsertTest.kt @@ -2,7 +2,7 @@ package com.raizlabs.android.dbflow.sql.language import android.content.ContentValues import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.config.writableDatabaseForTable +import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.TwoColumnModel import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id @@ -15,7 +15,7 @@ class InsertTest : BaseUnitTest() { @Test fun validateInsert(){ - writableDatabaseForTable{ + databaseForTable{ assertEquals("INSERT INTO `SimpleModel` VALUES('something')", insert().values("something").query.trim()) } @@ -23,7 +23,7 @@ class InsertTest : BaseUnitTest() { @Test fun validateInsertOr(){ - writableDatabaseForTable { + databaseForTable { assertEquals("INSERT OR REPLACE INTO `SimpleModel` VALUES('something')", insert().orReplace().values("something").query.trim()) assertEquals("INSERT OR FAIL INTO `SimpleModel` VALUES('something')", @@ -41,7 +41,7 @@ class InsertTest : BaseUnitTest() { @Test fun validateInsertProjection(){ - writableDatabaseForTable { + databaseForTable { assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 'id')", insert().columns(name, id).values("name", "id").query.trim()) } @@ -49,7 +49,7 @@ class InsertTest : BaseUnitTest() { @Test fun validateSelect(){ - writableDatabaseForTable { + databaseForTable { assertEquals("INSERT INTO `TwoColumnModel` SELECT * FROM `SimpleModel`", insert().select(select from SimpleModel::class).query.trim()) } @@ -57,7 +57,7 @@ class InsertTest : BaseUnitTest() { @Test fun validateColumns(){ - writableDatabaseForTable { + databaseForTable { assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 'id')", insert().asColumns().values("name", "id").query.trim()) assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 'id')", @@ -69,7 +69,7 @@ class InsertTest : BaseUnitTest() { @Test fun validateColumnValues(){ - writableDatabaseForTable { + databaseForTable { assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 0)", insert().columnValues(name.eq("name"), id.eq(0)).query.trim()) assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 0)", diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/JoinTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/JoinTest.kt index ebd46a822..8e9145a92 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/JoinTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/JoinTest.kt @@ -1,7 +1,7 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.config.writableDatabaseForTable +import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table import com.raizlabs.android.dbflow.models.TwoColumnModel @@ -14,7 +14,7 @@ class JoinTest : BaseUnitTest() { @Test fun validateAliasJoin() { - writableDatabaseForTable { + databaseForTable { assertEquals("SELECT * FROM `SimpleModel` INNER JOIN `TwoColumnModel` AS `Name` ON `TwoColumnModel`.`name`=`name`", ((select from SimpleModel::class innerJoin TwoColumnModel::class).`as`("Name") on TwoColumnModel_Table.name.withTable().eq(SimpleModel_Table.name)).query.trim()) @@ -23,7 +23,7 @@ class JoinTest : BaseUnitTest() { @Test fun testInnerJoin() { - writableDatabaseForTable { + databaseForTable { val join = select from SimpleModel::class innerJoin TwoColumnModel::class on TwoColumnModel_Table.name.withTable().eq(SimpleModel_Table.name) assertEquals("SELECT * FROM `SimpleModel` INNER JOIN `TwoColumnModel` ON `TwoColumnModel`.`name`=`name`", @@ -33,7 +33,7 @@ class JoinTest : BaseUnitTest() { @Test fun testLeftOuterJoin() { - writableDatabaseForTable { + databaseForTable { val join = select from SimpleModel::class leftOuterJoin TwoColumnModel::class on TwoColumnModel_Table.name.withTable().eq(SimpleModel_Table.name) assertEquals("SELECT * FROM `SimpleModel` LEFT OUTER JOIN `TwoColumnModel` ON `TwoColumnModel`.`name`=`name`", @@ -43,7 +43,7 @@ class JoinTest : BaseUnitTest() { @Test fun testCrossJoin() { - writableDatabaseForTable { + databaseForTable { val join = select from SimpleModel::class crossJoin TwoColumnModel::class on TwoColumnModel_Table.name.withTable().eq(SimpleModel_Table.name) assertEquals("SELECT * FROM `SimpleModel` CROSS JOIN `TwoColumnModel` ON `TwoColumnModel`.`name`=`name`", @@ -53,7 +53,7 @@ class JoinTest : BaseUnitTest() { @Test fun testMultiJoin() { - writableDatabaseForTable { + databaseForTable { val join = select from SimpleModel::class innerJoin TwoColumnModel::class on TwoColumnModel_Table.name.withTable().eq(SimpleModel_Table.name) crossJoin TwoColumnModel::class on TwoColumnModel_Table.id.withTable().eq(SimpleModel_Table.name) @@ -65,7 +65,7 @@ class JoinTest : BaseUnitTest() { @Test fun testInnerJoinOnUsing() { - writableDatabaseForTable { + databaseForTable { val join = select from SimpleModel::class innerJoin TwoColumnModel::class using SimpleModel_Table.name.withTable() assertEquals("SELECT * FROM `SimpleModel` INNER JOIN `TwoColumnModel` USING (`SimpleModel`.`name`)", @@ -75,7 +75,7 @@ class JoinTest : BaseUnitTest() { @Test fun testNaturalJoin() { - writableDatabaseForTable { + databaseForTable { val join = (select from SimpleModel::class naturalJoin TwoColumnModel::class).end() assertEquals("SELECT * FROM `SimpleModel` NATURAL JOIN `TwoColumnModel`", diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OperatorTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OperatorTest.kt index 2d53652c0..9dc0eaccb 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OperatorTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OperatorTest.kt @@ -3,7 +3,7 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.annotation.Collate import com.raizlabs.android.dbflow.assertEquals -import com.raizlabs.android.dbflow.config.writableDatabaseForTable +import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id import org.junit.Test @@ -55,7 +55,7 @@ class OperatorTest : BaseUnitTest() { @Test fun testIn() { - writableDatabaseForTable { + databaseForTable { assertEquals("`id` IN (5,6,7,8,9)", id.`in`(5, 6, 7, 8) and 9) assertEquals("`id` NOT IN (SELECT * FROM `SimpleModel`)", id.notIn(select from SimpleModel::class)) diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/SelectTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/SelectTest.kt index 91fd2a6b6..0e16d16fb 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/SelectTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/SelectTest.kt @@ -2,7 +2,7 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.assertEquals -import com.raizlabs.android.dbflow.config.writableDatabaseForTable +import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.TwoColumnModel import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id @@ -13,7 +13,7 @@ class SelectTest : BaseUnitTest() { @Test fun validateSelect() { - writableDatabaseForTable { + databaseForTable { assertEquals("SELECT `name`,`id` FROM `TwoColumnModel`", select(name, id) from TwoColumnModel::class) } @@ -21,7 +21,7 @@ class SelectTest : BaseUnitTest() { @Test fun validateSelectDistinct() { - writableDatabaseForTable { + databaseForTable { assertEquals("SELECT DISTINCT `name` FROM `SimpleModel`", select(name).distinct() from SimpleModel::class) } diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/SetTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/SetTest.kt index f79683fa2..9ffea13e5 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/SetTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/SetTest.kt @@ -2,7 +2,7 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.assertEquals -import com.raizlabs.android.dbflow.config.writableDatabaseForTable +import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table.name import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id @@ -12,7 +12,7 @@ class SetTest : BaseUnitTest() { @Test fun validateSetWithConditions() { - writableDatabaseForTable { + databaseForTable { assertEquals("UPDATE `SimpleModel` SET `name`='name'", update() set name.`is`("name")) } @@ -20,7 +20,7 @@ class SetTest : BaseUnitTest() { @Test fun validateMultipleConditions() { - writableDatabaseForTable { + databaseForTable { assertEquals("UPDATE `SimpleModel` SET `name`='name', `id`=0", update() set name.eq("name") and id.eq(0)) } diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/TriggerTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/TriggerTest.kt index 3a333a451..7259ade35 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/TriggerTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/TriggerTest.kt @@ -2,7 +2,7 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.assertEquals -import com.raizlabs.android.dbflow.config.writableDatabaseForTable +import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table.name import com.raizlabs.android.dbflow.models.TwoColumnModel @@ -18,7 +18,7 @@ class TriggerTest : BaseUnitTest() { @Test fun validateBasicTrigger() { - writableDatabaseForTable { + databaseForTable { assertEquals("CREATE TRIGGER IF NOT EXISTS `MyTrigger` AFTER INSERT ON `SimpleModel` " + "\nBEGIN" + "\nINSERT INTO `TwoColumnModel`(`name`) VALUES(`new`.`name`);" + @@ -30,7 +30,7 @@ class TriggerTest : BaseUnitTest() { @Test fun validateUpdateTriggerMultiline() { - writableDatabaseForTable { + databaseForTable { assertEquals("CREATE TEMP TRIGGER IF NOT EXISTS `MyTrigger` BEFORE UPDATE ON `SimpleModel` " + "\nBEGIN" + "\nINSERT INTO `TwoColumnModel`(`name`) VALUES(`new`.`name`);" + @@ -46,7 +46,7 @@ class TriggerTest : BaseUnitTest() { @Test fun validateTriggerWorks() { - writableDatabaseForTable { + databaseForTable { val trigger = createTrigger("MyTrigger").after() insertOn SimpleModel::class begin insert(TwoColumnModel::class).columnValues(name to NameAlias.ofTable("new", "name")) trigger.enable() diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UnsafeStringOperatorTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UnsafeStringOperatorTest.kt index aa27ff86c..7e451b478 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UnsafeStringOperatorTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UnsafeStringOperatorTest.kt @@ -2,7 +2,7 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.assertEquals -import com.raizlabs.android.dbflow.config.writableDatabaseForTable +import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import org.junit.Test @@ -10,7 +10,7 @@ class UnsafeStringOperatorTest : BaseUnitTest() { @Test fun testCanIncludeInQuery() { - writableDatabaseForTable { + databaseForTable { val op = UnSafeStringOperator("name = ?, id = ?, test = ?", arrayOf("'name'", "0", "'test'")) assertEquals("name = 'name', id = 0, test = 'test'", op) assertEquals("SELECT * FROM `SimpleModel` WHERE name = 'name', id = 0, test = 'test'", diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UpdateTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UpdateTest.kt index f877932fc..88ce9e1ac 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UpdateTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UpdateTest.kt @@ -3,7 +3,7 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.annotation.ConflictAction import com.raizlabs.android.dbflow.assertEquals -import com.raizlabs.android.dbflow.config.writableDatabaseForTable +import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.models.NumberModel import com.raizlabs.android.dbflow.models.NumberModel_Table.id import com.raizlabs.android.dbflow.models.SimpleModel @@ -16,49 +16,49 @@ class UpdateTest : BaseUnitTest() { @Test fun validateUpdateRollback() { - writableDatabaseForTable { + databaseForTable { assertEquals("UPDATE OR ROLLBACK `SimpleModel`", update().orRollback()) } } @Test fun validateUpdateFail() { - writableDatabaseForTable { + databaseForTable { assertEquals("UPDATE OR FAIL `SimpleModel`", update().orFail()) } } @Test fun validateUpdateIgnore() { - writableDatabaseForTable { + databaseForTable { assertEquals("UPDATE OR IGNORE `SimpleModel`", update().orIgnore()) } } @Test fun validateUpdateReplace() { - writableDatabaseForTable { + databaseForTable { assertEquals("UPDATE OR REPLACE `SimpleModel`", update().orReplace()) } } @Test fun validateUpdateAbort() { - writableDatabaseForTable { + databaseForTable { assertEquals("UPDATE OR ABORT `SimpleModel`", update().orAbort()) } } @Test fun validateSetQuery() { - writableDatabaseForTable { + databaseForTable { assertEquals("UPDATE `SimpleModel` SET `name`='name'", update() set (name eq "name")) } } @Test fun validateWildcardQuery() { - writableDatabaseForTable { + databaseForTable { assertEquals("UPDATE OR FAIL `NumberModel` SET `id`=? WHERE `id`=?", update().or(ConflictAction.FAIL) .set(id.eq(Property.WILDCARD)) diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/WhereTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/WhereTest.kt index fab8524fe..6cb102f77 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/WhereTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/WhereTest.kt @@ -2,7 +2,7 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.assertEquals -import com.raizlabs.android.dbflow.config.writableDatabaseForTable +import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table.name import com.raizlabs.android.dbflow.models.TwoColumnModel @@ -17,7 +17,7 @@ class WhereTest : BaseUnitTest() { @Test fun validateBasicWhere() { - writableDatabaseForTable { + databaseForTable { assertEquals("SELECT * FROM `SimpleModel` WHERE `name`='name'", select from SimpleModel::class where name.`is`("name")) } @@ -25,7 +25,7 @@ class WhereTest : BaseUnitTest() { @Test fun validateComplexQueryWhere() { - writableDatabaseForTable { + databaseForTable { assertEquals("SELECT * FROM `SimpleModel` WHERE `name`='name' OR `id`=1 AND (`id`=0 OR `name`='hi')", select from SimpleModel::class where name.`is`("name") or id.eq(1) and (id.`is`(0) or name.eq("hi"))) } @@ -33,7 +33,7 @@ class WhereTest : BaseUnitTest() { @Test fun validateGroupBy() { - writableDatabaseForTable { + databaseForTable { assertEquals("SELECT * FROM `SimpleModel` WHERE `name`='name' GROUP BY `name`", select from SimpleModel::class where name.`is`("name") groupBy name) } @@ -41,7 +41,7 @@ class WhereTest : BaseUnitTest() { @Test fun validateGroupByNameAlias() { - writableDatabaseForTable { + databaseForTable { assertEquals("SELECT * FROM `SimpleModel` WHERE `name`='name' GROUP BY `name`,`id`", (select from SimpleModel::class where name.`is`("name")).groupBy("name".nameAlias, "id".nameAlias)) } @@ -49,7 +49,7 @@ class WhereTest : BaseUnitTest() { @Test fun validateGroupByNameProps() { - writableDatabaseForTable { + databaseForTable { assertEquals("SELECT * FROM `SimpleModel` WHERE `name`='name' GROUP BY `name`,`id`", (select from SimpleModel::class where name.`is`("name")).groupBy(name, id)) } @@ -57,7 +57,7 @@ class WhereTest : BaseUnitTest() { @Test fun validateHaving() { - writableDatabaseForTable { + databaseForTable { assertEquals("SELECT * FROM `SimpleModel` WHERE `name`='name' HAVING `name` LIKE 'That'", select from SimpleModel::class where name.`is`("name") having name.like("That")) } @@ -65,7 +65,7 @@ class WhereTest : BaseUnitTest() { @Test fun validateLimit() { - writableDatabaseForTable { + databaseForTable { assertEquals("SELECT * FROM `SimpleModel` WHERE `name`='name' LIMIT 10", select from SimpleModel::class where name.`is`("name") limit 10) } @@ -73,7 +73,7 @@ class WhereTest : BaseUnitTest() { @Test fun validateOffset() { - writableDatabaseForTable { + databaseForTable { assertEquals("SELECT * FROM `SimpleModel` WHERE `name`='name' OFFSET 10", select from SimpleModel::class where name.`is`("name") offset 10) } @@ -81,7 +81,7 @@ class WhereTest : BaseUnitTest() { @Test fun validateWhereExists() { - writableDatabaseForTable { + databaseForTable { assertEquals("SELECT * FROM `SimpleModel` " + "WHERE EXISTS (SELECT `name` FROM `SimpleModel` WHERE `name` LIKE 'Andrew')", select from SimpleModel::class @@ -91,7 +91,7 @@ class WhereTest : BaseUnitTest() { @Test fun validateOrderByWhere() { - writableDatabaseForTable { + databaseForTable { assertEquals("SELECT * FROM `SimpleModel` " + "WHERE `name`='name' ORDER BY `name` ASC", (select from SimpleModel::class @@ -101,7 +101,7 @@ class WhereTest : BaseUnitTest() { @Test fun validateOrderByWhereAlias() { - writableDatabaseForTable { + databaseForTable { assertEquals("SELECT * FROM `SimpleModel` " + "WHERE `name`='name' ORDER BY `name` ASC", (select from SimpleModel::class @@ -111,7 +111,7 @@ class WhereTest : BaseUnitTest() { @Test fun validateOrderBy() { - writableDatabaseForTable { + databaseForTable { assertEquals("SELECT * FROM `SimpleModel` " + "WHERE `name`='name' ORDER BY `name` ASC", select from SimpleModel::class @@ -121,7 +121,7 @@ class WhereTest : BaseUnitTest() { @Test fun validateOrderByAll() { - writableDatabaseForTable { + databaseForTable { assertEquals("SELECT * FROM `TwoColumnModel` " + "WHERE `name`='name' ORDER BY `name` ASC,`id` DESC", (select from TwoColumnModel::class @@ -134,7 +134,7 @@ class WhereTest : BaseUnitTest() { @Test fun validateNonSelectThrowError() { - writableDatabaseForTable { + databaseForTable { try { update().set(name.`is`("name")).result fail("Non select passed") diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/IndexPropertyTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/IndexPropertyTest.kt index bc7c9b7ca..d21d0913f 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/IndexPropertyTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/IndexPropertyTest.kt @@ -1,7 +1,7 @@ package com.raizlabs.android.dbflow.sql.language.property import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.config.writableDatabaseForTable +import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table import org.junit.Assert.assertEquals @@ -12,7 +12,7 @@ class IndexPropertyTest : BaseUnitTest() { @Test fun validateIndexProperty() { - writableDatabaseForTable { + databaseForTable { val prop = IndexProperty("Index", true, SimpleModel::class.java, SimpleModel_Table.name) prop.createIfNotExists(this) diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/PropertyFactoryTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/PropertyFactoryTest.kt index 8bbedb810..1aded7c7a 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/PropertyFactoryTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/PropertyFactoryTest.kt @@ -1,7 +1,7 @@ package com.raizlabs.android.dbflow.sql.language.property import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.config.writableDatabaseForTable +import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.sql.language.select import org.junit.Assert.assertEquals @@ -20,7 +20,7 @@ class PropertyFactoryTest : BaseUnitTest() { assertEquals("5", 5.toByte().property.query) val nullable: Any? = null assertEquals("NULL", nullable.property.query) - writableDatabaseForTable { + databaseForTable { assertEquals("(SELECT * FROM `SimpleModel`)", (select from SimpleModel::class).property.query) } assertEquals("SomethingCool", propertyString("SomethingCool").query) diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/migration/UpdateTableMigrationTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/migration/UpdateTableMigrationTest.kt index 6975e7e82..507513b54 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/migration/UpdateTableMigrationTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/migration/UpdateTableMigrationTest.kt @@ -1,7 +1,7 @@ package com.raizlabs.android.dbflow.sql.migration import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.config.writableDatabaseForTable +import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table import org.junit.Test @@ -17,6 +17,6 @@ class UpdateTableMigrationTest : BaseUnitTest() { fun testUpdateMigrationQuery() { val update = UpdateTableMigration(SimpleModel::class.java) update.set(SimpleModel_Table.name.eq("yes")) - update.migrate(writableDatabaseForTable()) + update.migrate(databaseForTable()) } } diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/queriable/AsyncQueryTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/queriable/AsyncQueryTest.kt index 7decd23b5..6c64119a0 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/queriable/AsyncQueryTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/queriable/AsyncQueryTest.kt @@ -1,7 +1,7 @@ package com.raizlabs.android.dbflow.sql.queriable import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.config.writableDatabaseForTable +import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.sql.language.CursorResult import com.raizlabs.android.dbflow.sql.language.select @@ -14,7 +14,7 @@ class AsyncQueryTest : BaseUnitTest() { @Test fun testQueryResult() { - writableDatabaseForTable { + databaseForTable { SimpleModel("name").save() var model: SimpleModel? = null @@ -28,7 +28,7 @@ class AsyncQueryTest : BaseUnitTest() { @Test fun testQueryListResult() { - writableDatabaseForTable { + databaseForTable { SimpleModel("name").save() SimpleModel("name2").save() @@ -42,7 +42,7 @@ class AsyncQueryTest : BaseUnitTest() { @Test fun testQueryListCursorResult() { - writableDatabaseForTable { + databaseForTable { SimpleModel("name").save() SimpleModel("name2").save() diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.kt index 7afbb9319..b5c4a9e6b 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.kt @@ -1,5 +1,6 @@ package com.raizlabs.android.dbflow.config +import android.content.ContentValues import android.content.Context import com.raizlabs.android.dbflow.annotation.Database import com.raizlabs.android.dbflow.annotation.QueryModel @@ -16,7 +17,9 @@ import com.raizlabs.android.dbflow.structure.ModelAdapter import com.raizlabs.android.dbflow.structure.ModelViewAdapter import com.raizlabs.android.dbflow.structure.QueryModelAdapter import com.raizlabs.android.dbflow.structure.database.DatabaseHelperListener +import com.raizlabs.android.dbflow.structure.database.DatabaseStatement import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.structure.database.FlowCursor import com.raizlabs.android.dbflow.structure.database.FlowSQLiteOpenHelper import com.raizlabs.android.dbflow.structure.database.OpenHelper import com.raizlabs.android.dbflow.structure.database.transaction.DefaultTransactionManager @@ -29,7 +32,7 @@ import java.util.* * Description: The main interface that all Database implementations extend from. This is for internal usage only * as it will be generated for every [Database]. */ -abstract class DatabaseDefinition { +abstract class DatabaseDefinition : DatabaseWrapper { private val migrationMap = hashMapOf>() @@ -381,4 +384,47 @@ abstract class DatabaseDefinition { helper.backupDB() } + override val version: Int + get() = writableDatabase.version + + override fun execSQL(query: String) = writableDatabase.execSQL(query) + + override fun beginTransaction() = writableDatabase.beginTransaction() + + override fun setTransactionSuccessful() = writableDatabase.setTransactionSuccessful() + + override fun endTransaction() = writableDatabase.endTransaction() + + override fun compileStatement(rawQuery: String): DatabaseStatement + = writableDatabase.compileStatement(rawQuery) + + override fun rawQuery(query: String, selectionArgs: Array?): FlowCursor + = writableDatabase.rawQuery(query, selectionArgs) + + override fun updateWithOnConflict(tableName: String, + contentValues: ContentValues, + where: String?, + whereArgs: Array?, + conflictAlgorithm: Int): Long + = writableDatabase.updateWithOnConflict(tableName, contentValues, where, whereArgs, conflictAlgorithm) + + override fun insertWithOnConflict( + tableName: String, + nullColumnHack: String?, + values: ContentValues, + sqLiteDatabaseAlgorithmInt: Int): Long + = writableDatabase.insertWithOnConflict(tableName, nullColumnHack, values, sqLiteDatabaseAlgorithmInt) + + override fun query( + tableName: String, + columns: Array?, + selection: String?, + selectionArgs: Array?, + groupBy: String?, + having: String?, + orderBy: String?): FlowCursor + = writableDatabase.query(tableName, columns, selection, selectionArgs, groupBy, having, orderBy) + + override fun delete(tableName: String, whereClause: String?, whereArgs: Array?): Int + = writableDatabase.delete(tableName, whereClause, whereArgs) } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt index b694e92bb..badf15464 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt @@ -80,7 +80,7 @@ object FlowManager { } /** - * @param databaseName The name of the database. Will throw an exception if the database doesn't exist. + * @param databaseName The name of the database. Will throw an exception if the databaseForTable doesn't exist. * @param tableName The name of the table in the DB. * @return The associated table class for the specified name. */ @@ -94,7 +94,7 @@ object FlowManager { } /** - * @param databaseClass The class of the database. Will throw an exception if the database doesn't exist. + * @param databaseClass The class of the database. Will throw an exception if the databaseForTable doesn't exist. * @param tableName The name of the table in the DB. * @return The associated table class for the specified name. */ @@ -135,7 +135,7 @@ object FlowManager { getDatabaseForTable(table).writableDatabase /** - * @param databaseName The name of the database. Will throw an exception if the database doesn't exist. + * @param databaseName The name of the database. Will throw an exception if the databaseForTable doesn't exist. * @return the [DatabaseDefinition] for the specified database */ @JvmStatic @@ -379,7 +379,7 @@ object FlowManager { FlowManager.getDatabaseForTable(modelClass).getQueryModelAdapterForQueryClass(modelClass) /** - * @param databaseName The name of the database. Will throw an exception if the database doesn't exist. + * @param databaseName The name of the database. Will throw an exception if the databaseForTable doesn't exist. * @return The map of migrations for the specified database. */ @JvmStatic @@ -400,15 +400,15 @@ object FlowManager { private fun checkDatabaseHolder() { if (!globalDatabaseHolder.isInitialized) { - throw IllegalStateException("The global database holder is not initialized. Ensure you call " - + "FlowManager.init() before accessing the database.") + throw IllegalStateException("The global databaseForTable holder is not initialized. Ensure you call " + + "FlowManager.init() before accessing the databaseForTable.") } } // endregion /** - * Exception thrown when a database holder cannot load the database holder + * Exception thrown when a database holder cannot load the databaseForTable holder * for a module. */ class ModuleNotFoundException : RuntimeException { @@ -435,23 +435,14 @@ inline fun database(): DatabaseDefinition inline fun database(kClass: KClass, f: DatabaseDefinition.() -> R): R = FlowManager.getDatabase(kClass.java).f() -fun writableDatabaseForTable(kClass: KClass, f: DatabaseWrapper.() -> R): R - = FlowManager.getWritableDatabaseForTable(kClass.java).f() +inline fun database(f: DatabaseDefinition.() -> Unit): DatabaseDefinition + = FlowManager.getDatabase(T::class.java).apply(f) -inline fun writableDatabaseForTable(f: DatabaseWrapper.() -> Unit): DatabaseWrapper - = FlowManager.getWritableDatabaseForTable(T::class.java).apply(f) +fun databaseForTable(kClass: KClass, f: DatabaseDefinition.() -> R): R + = FlowManager.getDatabaseForTable(kClass.java).f() -inline fun writableDatabaseForTable(): DatabaseWrapper - = FlowManager.getWritableDatabaseForTable(T::class.java) - -fun writableDatabase(kClass: KClass, f: DatabaseWrapper.() -> R): R - = FlowManager.getWritableDatabase(kClass.java).f() - -inline fun writableDatabase(f: DatabaseWrapper.() -> R): R - = FlowManager.getWritableDatabase(T::class.java).f() - -inline fun writableDatabase(): DatabaseWrapper - = FlowManager.getWritableDatabase(T::class.java) +inline fun databaseForTable(f: DatabaseDefinition.() -> Unit): DatabaseDefinition + = FlowManager.getDatabaseForTable(T::class.java).apply(f) /** * Easily get access to its [DatabaseDefinition] directly. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/Model.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/Model.kt index c57405f3f..a60238ca5 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/Model.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/Model.kt @@ -1,7 +1,7 @@ package com.raizlabs.android.dbflow.structure import com.raizlabs.android.dbflow.config.modelAdapter -import com.raizlabs.android.dbflow.config.writableDatabaseForTable +import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper interface Model : ReadOnlyModel { @@ -44,15 +44,15 @@ interface Model : ReadOnlyModel { } -inline fun T.save(databaseWrapper: DatabaseWrapper = writableDatabaseForTable()) = modelAdapter().save(this, databaseWrapper) +inline fun T.save(databaseWrapper: DatabaseWrapper = databaseForTable()) = modelAdapter().save(this, databaseWrapper) -inline fun T.insert(databaseWrapper: DatabaseWrapper = writableDatabaseForTable()) = modelAdapter().insert(this, databaseWrapper) +inline fun T.insert(databaseWrapper: DatabaseWrapper = databaseForTable()) = modelAdapter().insert(this, databaseWrapper) -inline fun T.update(databaseWrapper: DatabaseWrapper = writableDatabaseForTable()) = modelAdapter().update(this, databaseWrapper) +inline fun T.update(databaseWrapper: DatabaseWrapper = databaseForTable()) = modelAdapter().update(this, databaseWrapper) -inline fun T.delete(databaseWrapper: DatabaseWrapper = writableDatabaseForTable()) = modelAdapter().delete(this, databaseWrapper) +inline fun T.delete(databaseWrapper: DatabaseWrapper = databaseForTable()) = modelAdapter().delete(this, databaseWrapper) -inline fun T.exists(databaseWrapper: DatabaseWrapper = writableDatabaseForTable()) = modelAdapter().exists(this, databaseWrapper) +inline fun T.exists(databaseWrapper: DatabaseWrapper = databaseForTable()) = modelAdapter().exists(this, databaseWrapper) -inline fun T.load(databaseWrapper: DatabaseWrapper = writableDatabaseForTable()) = modelAdapter().load(this, databaseWrapper) +inline fun T.load(databaseWrapper: DatabaseWrapper = databaseForTable()) = modelAdapter().load(this, databaseWrapper) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseWrapper.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseWrapper.kt index c8e3f442d..1b9f6f088 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseWrapper.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseWrapper.kt @@ -3,7 +3,7 @@ package com.raizlabs.android.dbflow.structure.database import android.content.ContentValues /** - * Description: Provides a base implementation that wraps a database, so other database engines potentially can + * Description: Provides a base implementation that wraps a database, so other databaseForTable engines potentially can * be used. */ interface DatabaseWrapper { diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Coroutines.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Coroutines.kt index 3f26add7e..dbb8798ab 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Coroutines.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Coroutines.kt @@ -1,20 +1,21 @@ package com.raizlabs.android.dbflow.structure.database.transaction import com.raizlabs.android.dbflow.config.DatabaseDefinition -import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable +import com.raizlabs.android.dbflow.sql.queriable.Queriable +import kotlinx.coroutines.experimental.CancellableContinuation import kotlinx.coroutines.experimental.suspendCancellableCoroutine /** - * Description: Puts the [ModelQueriable] operation on the bg. inside the [queriableFunction] call - * the method you wish to execute within a transaction. + * Description: Puts this [Queriable] operation inside a coroutine. Inside the [queriableFunction] + * execute the db operation. */ -suspend fun DatabaseDefinition.transact(modelQueriable: ModelQueriable, - queriableFunction: (ModelQueriable) -> R) - = suspendCancellableCoroutine { continuation -> +suspend fun Q.transact(databaseDefinition: DatabaseDefinition, + queriableFunction: Q.() -> R) + = suspendCancellableCoroutine { continuation: CancellableContinuation -> var value: R? = null - val transaction = beginTransactionAsync { value = queriableFunction(modelQueriable) } + val transaction = databaseDefinition.beginTransactionAsync { value = queriableFunction() } .success { - continuation.resume(value) + continuation.resume(value!!) } .error { _, throwable -> if (continuation.isCancelled) return@error diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/DefaultTransactionQueue.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/DefaultTransactionQueue.kt index b4a75c68b..4f92697ff 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/DefaultTransactionQueue.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/DefaultTransactionQueue.kt @@ -58,12 +58,12 @@ class DefaultTransactionQueue /** * Cancels the specified request. * - * @param runnable + * @param transaction */ - override fun cancel(runnable: Transaction) { + override fun cancel(transaction: Transaction) { synchronized(queue) { - if (queue.contains(runnable)) { - queue.remove(runnable) + if (queue.contains(transaction)) { + queue.remove(transaction) } } } @@ -71,14 +71,14 @@ class DefaultTransactionQueue /** * Cancels all requests by a specific tag * - * @param tag + * @param name */ - override fun cancel(tag: String) { + override fun cancel(name: String) { synchronized(queue) { val it = queue.iterator() while (it.hasNext()) { val next = it.next() - if (next.name() != null && next.name() == tag) { + if (next.name() != null && next.name() == name) { it.remove() } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ITransaction.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ITransaction.kt index 2623ed012..7b671f232 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ITransaction.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ITransaction.kt @@ -1,10 +1,8 @@ package com.raizlabs.android.dbflow.structure.database.transaction import android.database.sqlite.SQLiteDatabaseLockedException -import com.raizlabs.android.dbflow.config.database import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper -import kotlinx.coroutines.experimental.async /** * Description: Simplest form of a transaction. It represents an interface by which code is executed diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Transaction.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Transaction.kt index 83f8686d0..90ee4716c 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Transaction.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Transaction.kt @@ -156,9 +156,9 @@ class Transaction(private val transaction: ITransaction, * Specify an error callback to return all and any [Throwable] that occured during a [Transaction]. */ fun error(errorCallback: (Transaction, Throwable) -> Unit) = apply { - this.errorCallback = object : Error { + this.errorCallback = object: Error { override fun onError(transaction: Transaction, error: Throwable) { - errorCallback(transaction, error) + } } } From de495daac5e50cba0f34ef8eec433410fe0dbf0a Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sat, 25 Nov 2017 17:54:10 -0500 Subject: [PATCH 071/234] [5.0] ITransaction now return a result, allowing QueryTransaction now redudant and removed. Remove AsyncQuery, which wil be replaced in favor of transactions. --- .../dbflow/ImmediateTransactionManager.kt | 4 +- .../database/transaction/CoroutinesTest.kt | 6 + .../dbflow/config/DatabaseDefinition.kt | 19 +-- .../dbflow/runtime/BaseContentProvider.kt | 8 +- .../dbflow/runtime/BaseTransactionManager.kt | 4 +- .../dbflow/runtime/DBBatchSaveQueue.kt | 12 +- .../android/dbflow/sql/BaseAsyncObject.kt | 68 -------- .../dbflow/sql/language/BaseModelQueriable.kt | 3 - .../dbflow/sql/queriable/AsyncQuery.kt | 82 --------- .../dbflow/sql/queriable/ModelQueriable.kt | 12 +- .../database/DatabaseHelperDelegate.kt | 2 +- .../database/transaction/Coroutines.kt | 36 +++- .../transaction/DefaultTransactionQueue.kt | 12 +- .../transaction/FastStoreModelTransaction.kt | 2 +- .../database/transaction/ITransaction.kt | 4 +- .../database/transaction/ITransactionQueue.kt | 4 +- .../transaction/PriorityTransactionQueue.kt | 37 ++--- .../transaction/PriorityTransactionWrapper.kt | 6 +- .../transaction/ProcessModelTransaction.kt | 6 +- .../database/transaction/QueryTransaction.kt | 155 ------------------ .../database/transaction/Transaction.kt | 77 ++++----- .../transaction/TransactionWrapper.kt | 8 +- 22 files changed, 130 insertions(+), 437 deletions(-) delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/BaseAsyncObject.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/AsyncQuery.kt delete mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/QueryTransaction.kt diff --git a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/ImmediateTransactionManager.kt b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/ImmediateTransactionManager.kt index 6dcd865c6..7f28424aa 100644 --- a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/ImmediateTransactionManager.kt +++ b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/ImmediateTransactionManager.kt @@ -14,14 +14,14 @@ class ImmediateTransactionManager(databaseDefinition: DatabaseDefinition) class ImmediateTransactionQueue : ITransactionQueue { - override fun add(transaction: Transaction) { + override fun add(transaction: Transaction) { transaction.newBuilder() .runCallbacksOnSameThread(true) .build() .executeSync() } - override fun cancel(transaction: Transaction) { + override fun cancel(transaction: Transaction) { } diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/CoroutinesTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/CoroutinesTest.kt index 0eaa02803..ce80a65fc 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/CoroutinesTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/CoroutinesTest.kt @@ -5,6 +5,7 @@ import com.raizlabs.android.dbflow.TestDatabase import com.raizlabs.android.dbflow.config.database import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table +import com.raizlabs.android.dbflow.sql.language.delete import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.sql.language.where import com.raizlabs.android.dbflow.sql.queriable.list @@ -30,6 +31,11 @@ class CoroutinesTest : BaseUnitTest() { .transact(this) { list } assert(query.size == 1) + + + val result = (delete() where SimpleModel_Table.name.eq("5")) + .transact(this) { executeUpdateDelete() } + assert(result == 1L) } } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.kt index b5c4a9e6b..6dc211b96 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.kt @@ -269,29 +269,28 @@ abstract class DatabaseDefinition : DatabaseWrapper { return modelNotifier!! } - fun beginTransactionAsync(transaction: ITransaction): Transaction.Builder = + fun beginTransactionAsync(transaction: ITransaction): Transaction.Builder = Transaction.Builder(transaction, this) - fun beginTransactionAsync(transaction: (DatabaseWrapper) -> Unit): Transaction.Builder = - beginTransactionAsync(object : ITransaction { - override fun execute(databaseWrapper: DatabaseWrapper) { - transaction(databaseWrapper) - } + fun beginTransactionAsync(transaction: (DatabaseWrapper) -> R): Transaction.Builder = + beginTransactionAsync(object : ITransaction { + override fun execute(databaseWrapper: DatabaseWrapper) = transaction(databaseWrapper) }) - fun executeTransaction(transaction: ITransaction) { + fun executeTransaction(transaction: ITransaction): R { val database = writableDatabase try { database.beginTransaction() - transaction.execute(database) + val result = transaction.execute(database) database.setTransactionSuccessful() + return result } finally { database.endTransaction() } } - inline fun executeTransaction(crossinline transaction: (DatabaseWrapper) -> Unit) - = executeTransaction(object : ITransaction { + inline fun executeTransaction(crossinline transaction: (DatabaseWrapper) -> R) + = executeTransaction(object : ITransaction { override fun execute(databaseWrapper: DatabaseWrapper) = transaction(databaseWrapper) }) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/BaseContentProvider.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/BaseContentProvider.kt index f0f1a6c20..76164ff12 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/BaseContentProvider.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/BaseContentProvider.kt @@ -44,12 +44,14 @@ protected constructor(databaseHolderClass: Class? = null) : } override fun bulkInsert(uri: Uri, values: Array): Int { - val count = intArrayOf(0) - database.executeTransaction(object : ITransaction { - override fun execute(databaseWrapper: DatabaseWrapper) { + + val count = database.executeTransaction(object : ITransaction { + override fun execute(databaseWrapper: DatabaseWrapper) : IntArray { + val count = intArrayOf(0) for (contentValues in values) { count[0] += bulkInsert(uri, contentValues) } + return count } }) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/BaseTransactionManager.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/BaseTransactionManager.kt index cfcadaf51..0a82e3be9 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/BaseTransactionManager.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/BaseTransactionManager.kt @@ -44,12 +44,12 @@ abstract class BaseTransactionManager(val queue: ITransactionQueue, * * @param transaction The transaction to add. */ - fun addTransaction(transaction: Transaction) = queue.add(transaction) + fun addTransaction(transaction: Transaction) = queue.add(transaction) /** * Cancels a transaction on the [ITransactionQueue]. * * @param transaction */ - fun cancelTransaction(transaction: Transaction) = queue.cancel(transaction) + fun cancelTransaction(transaction: Transaction) = queue.cancel(transaction) } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DBBatchSaveQueue.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DBBatchSaveQueue.kt index 56143876d..319b9d7db 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DBBatchSaveQueue.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DBBatchSaveQueue.kt @@ -43,8 +43,8 @@ internal constructor(private val databaseDefinition: DatabaseDefinition) : Threa */ private var isQuitting = false - private var errorListener: Transaction.Error? = null - private var successListener: Transaction.Success? = null + private var errorListener: Transaction.Error? = null + private var successListener: Transaction.Success? = null private var emptyTransactionListener: Runnable? = null private val modelSaver = processModel { model, _ -> @@ -54,8 +54,8 @@ internal constructor(private val databaseDefinition: DatabaseDefinition) : Threa } } - private val successCallback = transactionSuccess { transaction -> successListener?.onSuccess(transaction) } - private val errorCallback = transactionError { transaction, error -> errorListener?.onError(transaction, error) } + private val successCallback = transactionSuccess { transaction, result -> successListener?.onSuccess(transaction, result) } + private val errorCallback = transactionError { transaction, error -> errorListener?.onError(transaction, error) } /** * Sets how many models to save at a time in this queue. @@ -82,7 +82,7 @@ internal constructor(private val databaseDefinition: DatabaseDefinition) : Threa * * @param errorListener The listener to use. */ - fun setErrorListener(errorListener: Transaction.Error?) { + fun setErrorListener(errorListener: Transaction.Error?) { this.errorListener = errorListener } @@ -91,7 +91,7 @@ internal constructor(private val databaseDefinition: DatabaseDefinition) : Threa * * @param successListener The listener to get notified when changes are successful. */ - fun setSuccessListener(successListener: Transaction.Success?) { + fun setSuccessListener(successListener: Transaction.Success?) { this.successListener = successListener } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/BaseAsyncObject.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/BaseAsyncObject.kt deleted file mode 100644 index 3787c1c50..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/BaseAsyncObject.kt +++ /dev/null @@ -1,68 +0,0 @@ -package com.raizlabs.android.dbflow.sql - -import com.raizlabs.android.dbflow.config.DatabaseDefinition -import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.structure.database.transaction.ITransaction -import com.raizlabs.android.dbflow.structure.database.transaction.Transaction -import com.raizlabs.android.dbflow.structure.database.transaction.transactionError -import com.raizlabs.android.dbflow.structure.database.transaction.transactionSuccess - -/** - * Description: Internal use to provide common implementation for async objects. - */ -open class BaseAsyncObject(open val table: Class<*>) { - - private var successCallback: Transaction.Success? = null - private var errorCallback: Transaction.Error? = null - private var currentTransaction: Transaction? = null - private val databaseDefinition: DatabaseDefinition by lazy { FlowManager.getDatabaseForTable(table) } - - private val error = transactionError { transaction, error -> - errorCallback?.onError(transaction, error) - this@BaseAsyncObject.onError(transaction, error) - currentTransaction = null - } - - private val success = transactionSuccess { transaction -> - successCallback?.onSuccess(transaction) - this@BaseAsyncObject.onSuccess(transaction) - currentTransaction = null - } - - /** - * Listen for any errors that occur during operations on this [TAsync]. - */ - fun error(errorCallback: Transaction.Error?): TAsync { - this.errorCallback = errorCallback - return this as TAsync - } - - /** - * Listens for successes on this [TAsync]. Will return the [Transaction]. - */ - fun success(success: Transaction.Success?): TAsync { - this.successCallback = success - return this as TAsync - } - - /** - * Cancels current running transaction. - */ - fun cancel() { - currentTransaction?.cancel() - } - - protected fun executeTransaction(transaction: ITransaction) { - cancel() - currentTransaction = databaseDefinition - .beginTransactionAsync(transaction) - .error(error) - .success(success) - .build() - currentTransaction?.execute() - } - - protected fun onError(transaction: Transaction, error: Throwable) = Unit - - protected open fun onSuccess(transaction: Transaction) = Unit -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseModelQueriable.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseModelQueriable.kt index e939d739e..7ab4ce9a2 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseModelQueriable.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseModelQueriable.kt @@ -6,7 +6,6 @@ import com.raizlabs.android.dbflow.list.FlowCursorList import com.raizlabs.android.dbflow.list.FlowQueryList import com.raizlabs.android.dbflow.runtime.NotifyDistributor import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.sql.queriable.AsyncQuery import com.raizlabs.android.dbflow.sql.queriable.ListModelLoader import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable import com.raizlabs.android.dbflow.sql.queriable.SingleModelLoader @@ -64,8 +63,6 @@ protected constructor(val databaseWrapper: DatabaseWrapper, return affected } - override fun async(): AsyncQuery = AsyncQuery(this) - override fun queryCustomList(queryModelClass: Class): MutableList { val query = query FlowLog.log(FlowLog.Level.V, "Executing query: " + query) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/AsyncQuery.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/AsyncQuery.kt deleted file mode 100644 index 32eb1e63e..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/AsyncQuery.kt +++ /dev/null @@ -1,82 +0,0 @@ -package com.raizlabs.android.dbflow.sql.queriable - -import com.raizlabs.android.dbflow.sql.BaseAsyncObject -import com.raizlabs.android.dbflow.sql.language.CursorResult -import com.raizlabs.android.dbflow.structure.database.transaction.QueryTransaction -import com.raizlabs.android.dbflow.structure.database.transaction.QueryTransaction.* - -/** - * Description: Adds async methods to a [ModelQueriable] - */ -class AsyncQuery -/** - * Constructs an instance of this async query. - * - * @param queriable The queriable object to use to query data. - */ -(private val modelQueriable: ModelQueriable) : BaseAsyncObject>(modelQueriable.table) { - - private var queryResultCallback: QueryResultCallback? = null - private var queryResultListCallback: QueryResultListCallback? = null - private var queryResultSingleCallback: QueryResultSingleCallback? = null - - /** - * @param queryResultCallback Called when query is executed and has a result. - */ - fun queryResultCallback(queryResultCallback: QueryResultCallback) = apply { - this.queryResultCallback = queryResultCallback - } - - /** - * @param queryResultSingleCallback Called when query is executed and has a result. - */ - fun querySingleResultCallback(queryResultSingleCallback: QueryResultSingleCallback) = apply { - this.queryResultSingleCallback = queryResultSingleCallback - } - - /** - * @param queryResultListCallback Called when query is executed and has a result. - */ - fun queryListResultCallback(queryResultListCallback: QueryResultListCallback) = apply { - this.queryResultListCallback = queryResultListCallback - } - - /** - * Runs the specified query in the background. - */ - fun execute() { - executeTransaction(QueryTransaction.Builder(modelQueriable) - .queryResult(queryResultCallback) - .queryListResult(queryResultListCallback) - .querySingleResult(queryResultSingleCallback) - .build()) - } - - /** - * @return The table this Query is associated with. - */ - override val table: Class - get() = modelQueriable.table - -} - -infix inline fun AsyncQuery.list(crossinline callback: (QueryTransaction<*>, List) -> Unit) - = queryListResultCallback(object : QueryResultListCallback { - override fun onListQueryResult(transaction: QueryTransaction<*>, tResult: List) { - callback(transaction, tResult) - } -}).execute() - -infix inline fun AsyncQuery.result(crossinline callback: (QueryTransaction<*>, T?) -> Unit) - = querySingleResultCallback(object : QueryResultSingleCallback { - override fun onSingleQueryResult(transaction: QueryTransaction<*>, tResult: T?) { - callback(transaction, tResult) - } -}).execute() - -infix inline fun AsyncQuery.cursorResult(crossinline callback: (QueryTransaction<*>, CursorResult) -> Unit) - = queryResultCallback(object : QueryResultCallback { - override fun onQueryResult(transaction: QueryTransaction, tResult: CursorResult) { - callback(transaction, tResult) - } -}).execute() \ No newline at end of file diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ModelQueriable.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ModelQueriable.kt index 9ced40725..b3b744d45 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ModelQueriable.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ModelQueriable.kt @@ -1,14 +1,12 @@ package com.raizlabs.android.dbflow.sql.queriable import android.database.Cursor - import com.raizlabs.android.dbflow.list.FlowCursorList import com.raizlabs.android.dbflow.list.FlowQueryList import com.raizlabs.android.dbflow.sql.language.CursorResult import com.raizlabs.android.dbflow.sql.language.From import com.raizlabs.android.dbflow.sql.language.Where import com.raizlabs.android.dbflow.structure.BaseQueryModel -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper /** * Description: An interface for query objects to enable you to query from the database in a structured way. @@ -48,11 +46,6 @@ interface ModelQueriable : Queriable { */ fun flowQueryList(): FlowQueryList - /** - * @return an async version of this query to run. - */ - fun async(): AsyncQuery - /** * Returns a [List] based on the custom [TQueryModel] you pass in. * @@ -86,7 +79,4 @@ inline val ModelQueriable.flowQueryList get() = flowQueryList() inline val ModelQueriable.cursorList - get() = cursorList() - -inline val ModelQueriable.async - get() = async() \ No newline at end of file + get() = cursorList() \ No newline at end of file diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseHelperDelegate.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseHelperDelegate.kt index 87e52d938..a324b1148 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseHelperDelegate.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseHelperDelegate.kt @@ -256,7 +256,7 @@ class DatabaseHelperDelegate( "both backupEnabled and consistency checks enabled to the Database annotation") } - databaseDefinition.beginTransactionAsync(object : ITransaction { + databaseDefinition.beginTransactionAsync(object : ITransaction { override fun execute(databaseWrapper: DatabaseWrapper) { val context = FlowManager.context val backup = context.getDatabasePath(tempDbFileName) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Coroutines.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Coroutines.kt index dbb8798ab..20b2b4006 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Coroutines.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Coroutines.kt @@ -1,6 +1,7 @@ package com.raizlabs.android.dbflow.structure.database.transaction import com.raizlabs.android.dbflow.config.DatabaseDefinition +import com.raizlabs.android.dbflow.config.modelAdapter import com.raizlabs.android.dbflow.sql.queriable.Queriable import kotlinx.coroutines.experimental.CancellableContinuation import kotlinx.coroutines.experimental.suspendCancellableCoroutine @@ -9,14 +10,35 @@ import kotlinx.coroutines.experimental.suspendCancellableCoroutine * Description: Puts this [Queriable] operation inside a coroutine. Inside the [queriableFunction] * execute the db operation. */ -suspend fun Q.transact(databaseDefinition: DatabaseDefinition, - queriableFunction: Q.() -> R) +suspend fun Q.transact(databaseDefinition: DatabaseDefinition, + queriableFunction: Q.() -> R) = suspendCancellableCoroutine { continuation: CancellableContinuation -> - var value: R? = null - val transaction = databaseDefinition.beginTransactionAsync { value = queriableFunction() } - .success { - continuation.resume(value!!) - } + val transaction = databaseDefinition.beginTransactionAsync { queriableFunction() } + .success { _, result -> continuation.resume(result) } + .error { _, throwable -> + if (continuation.isCancelled) return@error + continuation.resumeWithException(throwable) + }.build() + transaction.execute() + + continuation.invokeOnCompletion { + if (continuation.isCancelled) { + transaction.cancel() + } + } +} + + +/** + * Description: Puts a [Model] operation inside a coroutine. Inside the [queriableFunction] + * execute the db operation. + */ +inline suspend fun M.awaitSave(databaseDefinition: DatabaseDefinition) + = suspendCancellableCoroutine { continuation: CancellableContinuation -> + val transaction = databaseDefinition.beginTransactionAsync { + modelAdapter().save(this, databaseDefinition) + } + .success { _, result -> continuation.resume(result) } .error { _, throwable -> if (continuation.isCancelled) return@error continuation.resumeWithException(throwable) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/DefaultTransactionQueue.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/DefaultTransactionQueue.kt index 4f92697ff..066337777 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/DefaultTransactionQueue.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/DefaultTransactionQueue.kt @@ -18,14 +18,14 @@ class DefaultTransactionQueue */ (name: String) : Thread(name), ITransactionQueue { - private val queue = LinkedBlockingQueue() + private val queue = LinkedBlockingQueue>() private var isQuitting = false override fun run() { Looper.prepare() android.os.Process.setThreadPriority(android.os.Process.THREAD_PRIORITY_BACKGROUND) - var transaction: Transaction + var transaction: Transaction while (true) { try { transaction = queue.take() @@ -47,10 +47,10 @@ class DefaultTransactionQueue } } - override fun add(runnable: Transaction) { + override fun add(transaction: Transaction) { synchronized(queue) { - if (!queue.contains(runnable)) { - queue.add(runnable) + if (!queue.contains(transaction)) { + queue.add(transaction) } } } @@ -60,7 +60,7 @@ class DefaultTransactionQueue * * @param transaction */ - override fun cancel(transaction: Transaction) { + override fun cancel(transaction: Transaction) { synchronized(queue) { if (queue.contains(transaction)) { queue.remove(transaction) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/FastStoreModelTransaction.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/FastStoreModelTransaction.kt index 048435152..5deef54f6 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/FastStoreModelTransaction.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/FastStoreModelTransaction.kt @@ -11,7 +11,7 @@ import java.util.* * [Model], except that it performs it as efficiently as possible. Also due to way the class operates, * only one kind of [TModel] is allowed. */ -class FastStoreModelTransaction internal constructor(builder: Builder) : ITransaction { +class FastStoreModelTransaction internal constructor(builder: Builder) : ITransaction { internal val models: List? internal val processModelList: ProcessModelList diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ITransaction.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ITransaction.kt index 7b671f232..b1b664c55 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ITransaction.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ITransaction.kt @@ -8,7 +8,7 @@ import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper * Description: Simplest form of a transaction. It represents an interface by which code is executed * inside a database transaction. */ -interface ITransaction { +interface ITransaction { /** * Called within a database transaction. @@ -16,5 +16,5 @@ interface ITransaction { * @param databaseWrapper The database to save data into. Use this access to operate on the DB * without causing [SQLiteDatabaseLockedException]. */ - fun execute(databaseWrapper: DatabaseWrapper) + fun execute(databaseWrapper: DatabaseWrapper): R } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ITransactionQueue.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ITransactionQueue.kt index 51c49f1c2..41924c720 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ITransactionQueue.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ITransactionQueue.kt @@ -10,14 +10,14 @@ interface ITransactionQueue { * * @param transaction The transaction to run on the queue. */ - fun add(transaction: Transaction) + fun add(transaction: Transaction) /** * Cancels a transaction. * * @param transaction The transaction to cancel on the queue. */ - fun cancel(transaction: Transaction) + fun cancel(transaction: Transaction) /** * Starts if not alive. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/PriorityTransactionQueue.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/PriorityTransactionQueue.kt index 105eb7256..63e148a6b 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/PriorityTransactionQueue.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/PriorityTransactionQueue.kt @@ -17,14 +17,14 @@ class PriorityTransactionQueue */ (name: String) : Thread(name), ITransactionQueue { - private val queue = PriorityBlockingQueue>() + private val queue = PriorityBlockingQueue>>() private var isQuitting = false override fun run() { Looper.prepare() android.os.Process.setThreadPriority(android.os.Process.THREAD_PRIORITY_BACKGROUND) - var transaction: PriorityEntry + var transaction: PriorityEntry> while (true) { try { transaction = queue.take() @@ -42,7 +42,7 @@ class PriorityTransactionQueue } } - override fun add(transaction: Transaction) { + override fun add(transaction: Transaction) { synchronized(queue) { val priorityEntry = PriorityEntry(transaction) if (!queue.contains(priorityEntry)) { @@ -56,7 +56,7 @@ class PriorityTransactionQueue * * @param transaction The transaction to cancel (if still in the queue). */ - override fun cancel(transaction: Transaction) { + override fun cancel(transaction: Transaction) { synchronized(queue) { val priorityEntry = PriorityEntry(transaction) if (queue.contains(priorityEntry)) { @@ -68,14 +68,14 @@ class PriorityTransactionQueue /** * Cancels all requests by a specific tag * - * @param tag + * @param name */ - override fun cancel(tag: String) { + override fun cancel(name: String) { synchronized(queue) { val it = queue.iterator() while (it.hasNext()) { val next = it.next().entry - if (next.name() != null && next.name() == tag) { + if (next.name() != null && next.name() == name) { it.remove() } } @@ -104,14 +104,9 @@ class PriorityTransactionQueue interrupt() } - private fun throwInvalidTransactionType(transaction: Transaction?) { - throw IllegalArgumentException("Transaction of type:" + - (transaction?.transaction()?.javaClass ?: "Unknown") - + " should be of type PriorityTransactionWrapper") - } - - internal inner class PriorityEntry(val entry: E) : Comparable> { - val transactionWrapper: PriorityTransactionWrapper? = + internal inner class PriorityEntry>(val entry: E) + : Comparable>> { + private val transactionWrapper: PriorityTransactionWrapper = if (entry.transaction() is PriorityTransactionWrapper) { entry.transaction() as PriorityTransactionWrapper } else { @@ -119,8 +114,8 @@ class PriorityTransactionQueue .build() } - override fun compareTo(other: PriorityEntry): Int = - transactionWrapper!!.compareTo(other.transactionWrapper!!) + override fun compareTo(other: PriorityEntry>): Int = + transactionWrapper.compareTo(other.transactionWrapper) override fun equals(other: Any?): Boolean { if (this === other) { @@ -131,15 +126,11 @@ class PriorityTransactionQueue } val that = other as PriorityEntry<*>? - - return if (transactionWrapper != null) - transactionWrapper == that!!.transactionWrapper - else - that!!.transactionWrapper == null + return transactionWrapper == that!!.transactionWrapper } - override fun hashCode(): Int = transactionWrapper?.hashCode() ?: 0 + override fun hashCode(): Int = transactionWrapper.hashCode() } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/PriorityTransactionWrapper.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/PriorityTransactionWrapper.kt index 0c43013e5..b106a6ca1 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/PriorityTransactionWrapper.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/PriorityTransactionWrapper.kt @@ -7,8 +7,8 @@ import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper /** * Description: Provides transaction with priority. Meant to be used in a [PriorityTransactionQueue]. */ -class PriorityTransactionWrapper(private val priority: Int, private val transaction: ITransaction) - : ITransaction, Comparable { +class PriorityTransactionWrapper(private val priority: Int, private val transaction: ITransaction<*>) + : ITransaction, Comparable { @Retention(AnnotationRetention.SOURCE) @IntDef(PRIORITY_LOW.toLong(), PRIORITY_NORMAL.toLong(), PRIORITY_HIGH.toLong(), PRIORITY_UI.toLong()) @@ -28,7 +28,7 @@ class PriorityTransactionWrapper(private val priority: Int, private val transact override fun compareTo(other: PriorityTransactionWrapper): Int = other.priority - priority - class Builder(internal val transaction: ITransaction) { + class Builder(internal val transaction: ITransaction<*>) { internal var priority: Int = 0 /** diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ProcessModelTransaction.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ProcessModelTransaction.kt index 58d7384b4..f87986a14 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ProcessModelTransaction.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ProcessModelTransaction.kt @@ -12,7 +12,7 @@ class ProcessModelTransaction( private val models: List = arrayListOf(), private val processListener: OnModelProcessListener? = null, private val processModel: ProcessModel, - private val runProcessListenerOnSameThread: Boolean) : ITransaction { + private val runProcessListenerOnSameThread: Boolean) : ITransaction { /** @@ -166,8 +166,8 @@ inline fun processModel(crossinline function: (T, DatabaseWrapper) -> Unit) */ inline fun Collection.processInTransactionAsync( crossinline processFunction: ProcessFunction, - success: Transaction.Success? = null, - error: Transaction.Error? = null, + success: Transaction.Success? = null, + error: Transaction.Error? = null, processListener: ProcessModelTransaction.OnModelProcessListener? = null) { val builder = this.processTransaction(processFunction) processListener?.let { builder.processListener(processListener) } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/QueryTransaction.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/QueryTransaction.kt deleted file mode 100644 index d1d15ebd9..000000000 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/QueryTransaction.kt +++ /dev/null @@ -1,155 +0,0 @@ -package com.raizlabs.android.dbflow.structure.database.transaction - -import com.raizlabs.android.dbflow.sql.language.CursorResult -import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper - -/** - * Description: Provides an easy way to query for data asynchronously. - */ -class QueryTransaction( - private val modelQueriable: ModelQueriable, - private val queryResultCallback: QueryResultCallback? = null, - private val queryResultListCallback: QueryResultListCallback? = null, - private val queryResultSingleCallback: QueryResultSingleCallback? = null, - private val runResultCallbacksOnSameThread: Boolean = true) : ITransaction { - - /** - * Simple interface that provides callback on result. - * - * @param The result that we got from querying. - */ - interface QueryResultCallback { - - /** - * Called when the query completes. - * - * @param transaction The transaction that ran. - * @param tResult The result of the query. Use this object to get data that you need. - */ - fun onQueryResult(transaction: QueryTransaction, - tResult: CursorResult) - } - - /** - * Simple interface that provides [List] callback on result. - * - * @param The result that we got from querying. - */ - interface QueryResultListCallback { - - /** - * Called when the query completes. - * - * @param transaction The transaction that ran. - * @param tResult The [List] result of the query. - */ - fun onListQueryResult(transaction: QueryTransaction<*>, tResult: List) - } - - /** - * Simple interface that provides single [T] callback on result. - * - * @param The result that we got from querying. - */ - interface QueryResultSingleCallback { - - /** - * Called when the query completes. - * - * @param transaction The transaction that ran. - * @param tResult The single result of the query. - */ - fun onSingleQueryResult(transaction: QueryTransaction<*>, tResult: TResult?) - } - - internal constructor(builder: Builder) : this( - modelQueriable = builder.modelQueriable, - queryResultCallback = builder.queryResultCallback, - queryResultListCallback = builder.queryResultListCallback, - queryResultSingleCallback = builder.queryResultSingleCallback, - runResultCallbacksOnSameThread = builder.runResultCallbacksOnSameThread - ) - - override fun execute(databaseWrapper: DatabaseWrapper) { - val cursorResult = modelQueriable.queryResults() - if (queryResultCallback != null) { - if (runResultCallbacksOnSameThread) { - queryResultCallback.onQueryResult(this, cursorResult) - } else { - Transaction.transactionHandler.post { - queryResultCallback.onQueryResult(this@QueryTransaction, cursorResult) - } - } - } - - if (queryResultListCallback != null) { - val resultList = cursorResult.toListClose() - if (runResultCallbacksOnSameThread) { - queryResultListCallback.onListQueryResult(this, resultList) - } else { - Transaction.transactionHandler.post { - queryResultListCallback.onListQueryResult(this@QueryTransaction, resultList) - } - } - } - - if (queryResultSingleCallback != null) { - val result = cursorResult.toModelClose() - if (runResultCallbacksOnSameThread) { - queryResultSingleCallback.onSingleQueryResult(this, result) - } else { - Transaction.transactionHandler.post { - queryResultSingleCallback.onSingleQueryResult(this@QueryTransaction, result) - } - } - } - } - - /** - * Provides easy way to build a [QueryTransaction]. - * - * @param - */ - class Builder(internal val modelQueriable: ModelQueriable) { - internal var queryResultCallback: QueryResultCallback? = null - internal var queryResultListCallback: QueryResultListCallback? = null - internal var queryResultSingleCallback: QueryResultSingleCallback? = null - internal var runResultCallbacksOnSameThread: Boolean = false - - /** - * Called when transaction completes and use this to get results. - */ - fun queryResult(queryResultCallback: QueryResultCallback?) = apply { - this.queryResultCallback = queryResultCallback - } - - /** - * Called when transaction completes, which returns a [List] result. - */ - fun queryListResult(queryResultListCallback: QueryResultListCallback?) = apply { - this.queryResultListCallback = queryResultListCallback - } - - /** - * Called when transaction completes, which returns a single [T]. - */ - fun querySingleResult(queryResultSingleCallback: QueryResultSingleCallback?) = apply { - this.queryResultSingleCallback = queryResultSingleCallback - } - - /** - * Runs result callback on UI thread by default. setting this to true would run the callback - * synchrously on the same thread this transaction executes from. - */ - fun runResultCallbacksOnSameThread(runResultCallbacksOnSameThread: Boolean) = apply { - this.runResultCallbacksOnSameThread = runResultCallbacksOnSameThread - } - - /** - * @return A new [QueryTransaction]. Subsequent calls to this method produce new - * instances. - */ - fun build(): QueryTransaction = QueryTransaction(this) - } -} diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Transaction.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Transaction.kt index 90ee4716c..bbc8f28aa 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Transaction.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Transaction.kt @@ -16,19 +16,19 @@ import com.raizlabs.android.dbflow.runtime.BaseTransactionManager * * To create one, the recommended method is to use the [DatabaseDefinition.beginTransactionAsync]. */ -class Transaction(private val transaction: ITransaction, - private val databaseDefinition: DatabaseDefinition, - private val errorCallback: Error? = null, - private val successCallback: Success? = null, - private val name: String?, - private val shouldRunInTransaction: Boolean = true, - private val runCallbacksOnSameThread: Boolean = true) { +class Transaction(private val transaction: ITransaction, + private val databaseDefinition: DatabaseDefinition, + private val errorCallback: Error? = null, + private val successCallback: Success? = null, + private val name: String?, + private val shouldRunInTransaction: Boolean = true, + private val runCallbacksOnSameThread: Boolean = true) { /** * Callback when a [ITransaction] failed because of an exception. */ - interface Error { + interface Error { /** * Called when transaction fails. @@ -36,25 +36,24 @@ class Transaction(private val transaction: ITransaction, * @param transaction The transaction that failed. * @param error The error that was thrown. */ - fun onError(transaction: Transaction, - error: Throwable) + fun onError(transaction: Transaction, error: Throwable) } /** * Interface callback when a [ITransaction] was successful. */ - interface Success { + interface Success { /** * Called when a transaction succeeded. * * @param transaction The transaction that succeeded. */ - fun onSuccess(transaction: Transaction) + fun onSuccess(transaction: Transaction, result: R) } - internal constructor(builder: Builder) : this( + internal constructor(builder: Builder) : this( databaseDefinition = builder.databaseDefinition, errorCallback = builder.errorCallback, successCallback = builder.successCallback, @@ -64,11 +63,11 @@ class Transaction(private val transaction: ITransaction, runCallbacksOnSameThread = builder.runCallbacksOnSameThread ) - fun error(): Error? = errorCallback + fun error(): Error? = errorCallback - fun success(): Success? = successCallback + fun success(): Success? = successCallback - fun transaction(): ITransaction = transaction + fun transaction(): ITransaction = transaction fun name(): String? = name @@ -93,16 +92,16 @@ class Transaction(private val transaction: ITransaction, */ fun executeSync() { try { - if (shouldRunInTransaction) { + val result = if (shouldRunInTransaction) { databaseDefinition.executeTransaction(transaction) } else { transaction.execute(databaseDefinition.writableDatabase) } if (successCallback != null) { if (runCallbacksOnSameThread) { - successCallback.onSuccess(this) + successCallback.onSuccess(this, result) } else { - transactionHandler.post { successCallback.onSuccess(this@Transaction) } + transactionHandler.post { successCallback.onSuccess(this@Transaction, result) } } } } catch (throwable: Throwable) { @@ -120,7 +119,7 @@ class Transaction(private val transaction: ITransaction, } - fun newBuilder(): Builder { + fun newBuilder(): Builder { return Builder(transaction, databaseDefinition) .error(errorCallback) .success(successCallback) @@ -132,15 +131,15 @@ class Transaction(private val transaction: ITransaction, /** * The main entry point into [Transaction], this provides an easy way to build up transactions. */ - class Builder + class Builder /** * @param transaction The interface that actually executes the transaction. * @param databaseDefinition The database this transaction will run on. Should be the same * DB as the code that the transaction runs in. */ - (internal val transaction: ITransaction, internal val databaseDefinition: DatabaseDefinition) { - internal var errorCallback: Error? = null - internal var successCallback: Success? = null + (internal val transaction: ITransaction, internal val databaseDefinition: DatabaseDefinition) { + internal var errorCallback: Error? = null + internal var successCallback: Success? = null internal var name: String? = null internal var shouldRunInTransaction = true internal var runCallbacksOnSameThread: Boolean = false @@ -148,19 +147,15 @@ class Transaction(private val transaction: ITransaction, /** * Specify an error callback to return all and any [Throwable] that occured during a [Transaction]. */ - fun error(errorCallback: Error?) = apply { + fun error(errorCallback: Error?) = apply { this.errorCallback = errorCallback } /** * Specify an error callback to return all and any [Throwable] that occured during a [Transaction]. */ - fun error(errorCallback: (Transaction, Throwable) -> Unit) = apply { - this.errorCallback = object: Error { - override fun onError(transaction: Transaction, error: Throwable) { - - } - } + fun error(errorCallback: (Transaction, Throwable) -> Unit) = apply { + this.errorCallback = transactionError { transaction, throwable -> errorCallback(transaction, throwable) } } /** @@ -169,7 +164,7 @@ class Transaction(private val transaction: ITransaction, * * @param successCallback The callback, invoked on the UI thread. */ - fun success(successCallback: Success?) = apply { + fun success(successCallback: Success?) = apply { this.successCallback = successCallback } @@ -179,12 +174,8 @@ class Transaction(private val transaction: ITransaction, * * @param successCallback The callback, invoked on the UI thread. */ - fun success(successCallback: (Transaction) -> Unit) = apply { - this.successCallback = object : Success { - override fun onSuccess(transaction: Transaction) { - successCallback(transaction) - } - } + fun success(successCallback: (Transaction, R) -> Unit) = apply { + this.successCallback = transactionSuccess { transaction, r -> successCallback(transaction, r) } } /** @@ -220,7 +211,7 @@ class Transaction(private val transaction: ITransaction, * @return A new instance of [Transaction]. Subsequent calls to this method produce * new instances. */ - fun build(): Transaction = Transaction(this) + fun build(): Transaction = Transaction(this) /** * Convenience method to simply execute a transaction. @@ -236,10 +227,10 @@ class Transaction(private val transaction: ITransaction, } } -inline fun transactionSuccess(crossinline function: (Transaction) -> Unit) = object : Transaction.Success { - override fun onSuccess(transaction: Transaction) = function(transaction) +inline fun transactionSuccess(crossinline function: (Transaction, R) -> Unit) = object : Transaction.Success { + override fun onSuccess(transaction: Transaction, result: R) = function(transaction, result) } -inline fun transactionError(crossinline function: (Transaction, Throwable) -> Unit) = object : Transaction.Error { - override fun onError(transaction: Transaction, error: Throwable) = function(transaction, error) +inline fun transactionError(crossinline function: (Transaction, Throwable) -> Unit) = object : Transaction.Error { + override fun onError(transaction: Transaction, error: Throwable) = function(transaction, error) } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/TransactionWrapper.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/TransactionWrapper.kt index 4da0ac00b..5642a7370 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/TransactionWrapper.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/TransactionWrapper.kt @@ -6,15 +6,15 @@ import java.util.* /** * Description: Wraps multiple transactions together. */ -class TransactionWrapper : ITransaction { +class TransactionWrapper : ITransaction { - private val transactions = ArrayList() + private val transactions = ArrayList>() - constructor(vararg transactions: ITransaction) { + constructor(vararg transactions: ITransaction) { this.transactions.addAll(Arrays.asList(*transactions)) } - constructor(transactions: Collection) { + constructor(transactions: Collection>) { this.transactions.addAll(transactions) } From d0913e4c02a36d4f0a80b2b2da3b42d0c8a3c365 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sat, 25 Nov 2017 18:22:23 -0500 Subject: [PATCH 072/234] [5.0] transact method should be simpler with extension on database definition instead. --- .../dbflow/ImmediateTransactionManager.kt | 4 +- .../dbflow/ImmediateTransactionManager.kt | 4 +- .../database/transaction/CoroutinesTest.kt | 59 +++++++++++++-- .../dbflow/sql/queriable/AsyncQueryTest.kt | 58 --------------- .../dbflow/config/DatabaseDefinition.kt | 4 +- .../dbflow/runtime/BaseTransactionManager.kt | 4 +- .../database/transaction/Coroutines.kt | 73 ++++++++++++++----- .../transaction/DefaultTransactionQueue.kt | 8 +- .../database/transaction/ITransactionQueue.kt | 4 +- .../transaction/PriorityTransactionQueue.kt | 14 ++-- .../database/transaction/Transaction.kt | 12 +-- 11 files changed, 134 insertions(+), 110 deletions(-) delete mode 100644 dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/queriable/AsyncQueryTest.kt diff --git a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/ImmediateTransactionManager.kt b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/ImmediateTransactionManager.kt index 7f28424aa..777365fc5 100644 --- a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/ImmediateTransactionManager.kt +++ b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/ImmediateTransactionManager.kt @@ -14,14 +14,14 @@ class ImmediateTransactionManager(databaseDefinition: DatabaseDefinition) class ImmediateTransactionQueue : ITransactionQueue { - override fun add(transaction: Transaction) { + override fun add(transaction: Transaction) { transaction.newBuilder() .runCallbacksOnSameThread(true) .build() .executeSync() } - override fun cancel(transaction: Transaction) { + override fun cancel(transaction: Transaction) { } diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/ImmediateTransactionManager.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/ImmediateTransactionManager.kt index 5d815a65f..1d45c9947 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/ImmediateTransactionManager.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/ImmediateTransactionManager.kt @@ -14,14 +14,14 @@ class ImmediateTransactionManager2(databaseDefinition: DatabaseDefinition) class ImmediateTransactionQueue2 : ITransactionQueue { - override fun add(transaction: Transaction) { + override fun add(transaction: Transaction) { transaction.newBuilder() .runCallbacksOnSameThread(true) .build() .executeSync() } - override fun cancel(transaction: Transaction) { + override fun cancel(transaction: Transaction) { } diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/CoroutinesTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/CoroutinesTest.kt index ce80a65fc..b0ad4b09c 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/CoroutinesTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/CoroutinesTest.kt @@ -9,6 +9,10 @@ import com.raizlabs.android.dbflow.sql.language.delete import com.raizlabs.android.dbflow.sql.language.select import com.raizlabs.android.dbflow.sql.language.where import com.raizlabs.android.dbflow.sql.queriable.list +import com.raizlabs.android.dbflow.structure.database.transaction.awaitDelete +import com.raizlabs.android.dbflow.structure.database.transaction.awaitInsert +import com.raizlabs.android.dbflow.structure.database.transaction.awaitSave +import com.raizlabs.android.dbflow.structure.database.transaction.awaitUpdate import com.raizlabs.android.dbflow.structure.database.transaction.transact import com.raizlabs.android.dbflow.structure.save import kotlinx.coroutines.experimental.runBlocking @@ -20,23 +24,68 @@ import org.junit.Test class CoroutinesTest : BaseUnitTest() { @Test - fun testCanRunCoroutines() { + fun testTransact() { runBlocking { database { (0..9).forEach { SimpleModel("$it").save() } - val query = (select from SimpleModel::class where SimpleModel_Table.name.eq("5")) - .transact(this) { list } + val query = transact( + select from SimpleModel::class + where SimpleModel_Table.name.eq("5")) { list } assert(query.size == 1) - val result = (delete() where SimpleModel_Table.name.eq("5")) - .transact(this) { executeUpdateDelete() } + val result = transact( + delete() + where SimpleModel_Table.name.eq("5")) { executeUpdateDelete() } assert(result == 1L) } } } + + @Test + fun testAwaitSaveAndDelete() { + runBlocking { + database { + val simpleModel = SimpleModel("Name") + val result = simpleModel.awaitSave(this) + assert(result) + + assert(simpleModel.awaitDelete(this)) + } + } + } + + @Test + fun testAwaitInsertAndDelete() { + runBlocking { + database { + val simpleModel = SimpleModel("Name") + val result = simpleModel.awaitInsert(this) + assert(result > 0) + assert(simpleModel.awaitDelete(this)) + } + } + } + + @Test + fun testAwaitUpdate() { + runBlocking { + database { + val simpleModel = SimpleModel("Name") + val result = simpleModel.awaitSave(this) + assert(result) + + simpleModel.name = "NewName" + assert(simpleModel.awaitUpdate(this)) + + val loadedModel = transact(select from SimpleModel::class + where SimpleModel_Table.name.eq("NewName")) { querySingle() }!! + assert(loadedModel.name == "NewName") + } + } + } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/queriable/AsyncQueryTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/queriable/AsyncQueryTest.kt deleted file mode 100644 index 6c64119a0..000000000 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/queriable/AsyncQueryTest.kt +++ /dev/null @@ -1,58 +0,0 @@ -package com.raizlabs.android.dbflow.sql.queriable - -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.config.databaseForTable -import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.sql.language.CursorResult -import com.raizlabs.android.dbflow.sql.language.select -import com.raizlabs.android.dbflow.structure.save -import org.junit.Assert.assertEquals -import org.junit.Assert.assertNotNull -import org.junit.Test - -class AsyncQueryTest : BaseUnitTest() { - - @Test - fun testQueryResult() { - databaseForTable { - SimpleModel("name").save() - - var model: SimpleModel? = null - (select from SimpleModel::class).async result { _, result -> - model = result - } - assertNotNull(model) - assertEquals("name", model?.name) - } - } - - @Test - fun testQueryListResult() { - databaseForTable { - SimpleModel("name").save() - SimpleModel("name2").save() - - var list = mutableListOf() - (select from SimpleModel::class).async list { _, mutableList -> - list = mutableList.toMutableList() - } - assertEquals(2, list.size) - } - } - - @Test - fun testQueryListCursorResult() { - databaseForTable { - SimpleModel("name").save() - SimpleModel("name2").save() - - var result: CursorResult? = null - (select from SimpleModel::class).async cursorResult { _, cursorResult -> - result = cursorResult - } - assertNotNull(result) - assertEquals(2L, result?.count) - result?.close() - } - } -} \ No newline at end of file diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.kt index 6dc211b96..2c76073d1 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.kt @@ -269,10 +269,10 @@ abstract class DatabaseDefinition : DatabaseWrapper { return modelNotifier!! } - fun beginTransactionAsync(transaction: ITransaction): Transaction.Builder = + fun beginTransactionAsync(transaction: ITransaction): Transaction.Builder = Transaction.Builder(transaction, this) - fun beginTransactionAsync(transaction: (DatabaseWrapper) -> R): Transaction.Builder = + fun beginTransactionAsync(transaction: (DatabaseWrapper) -> R): Transaction.Builder = beginTransactionAsync(object : ITransaction { override fun execute(databaseWrapper: DatabaseWrapper) = transaction(databaseWrapper) }) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/BaseTransactionManager.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/BaseTransactionManager.kt index 0a82e3be9..84320082e 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/BaseTransactionManager.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/BaseTransactionManager.kt @@ -44,12 +44,12 @@ abstract class BaseTransactionManager(val queue: ITransactionQueue, * * @param transaction The transaction to add. */ - fun addTransaction(transaction: Transaction) = queue.add(transaction) + fun addTransaction(transaction: Transaction) = queue.add(transaction) /** * Cancels a transaction on the [ITransactionQueue]. * * @param transaction */ - fun cancelTransaction(transaction: Transaction) = queue.cancel(transaction) + fun cancelTransaction(transaction: Transaction) = queue.cancel(transaction) } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Coroutines.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Coroutines.kt index 20b2b4006..eb169f580 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Coroutines.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Coroutines.kt @@ -1,8 +1,12 @@ package com.raizlabs.android.dbflow.structure.database.transaction import com.raizlabs.android.dbflow.config.DatabaseDefinition -import com.raizlabs.android.dbflow.config.modelAdapter import com.raizlabs.android.dbflow.sql.queriable.Queriable +import com.raizlabs.android.dbflow.structure.delete +import com.raizlabs.android.dbflow.structure.insert +import com.raizlabs.android.dbflow.structure.load +import com.raizlabs.android.dbflow.structure.save +import com.raizlabs.android.dbflow.structure.update import kotlinx.coroutines.experimental.CancellableContinuation import kotlinx.coroutines.experimental.suspendCancellableCoroutine @@ -10,10 +14,17 @@ import kotlinx.coroutines.experimental.suspendCancellableCoroutine * Description: Puts this [Queriable] operation inside a coroutine. Inside the [queriableFunction] * execute the db operation. */ -suspend fun Q.transact(databaseDefinition: DatabaseDefinition, - queriableFunction: Q.() -> R) - = suspendCancellableCoroutine { continuation: CancellableContinuation -> - val transaction = databaseDefinition.beginTransactionAsync { queriableFunction() } +inline suspend fun DatabaseDefinition.transact( + modelQueriable: Q, + crossinline queriableFunction: Q.() -> R) + = suspendCancellableCoroutine { continuation -> + constructCoroutine(continuation, this) { queriableFunction(modelQueriable) } +} + +inline fun constructCoroutine(continuation: CancellableContinuation, + databaseDefinition: DatabaseDefinition, + crossinline fn: () -> R) { + val transaction = databaseDefinition.beginTransactionAsync { fn() } .success { _, result -> continuation.resume(result) } .error { _, throwable -> if (continuation.isCancelled) return@error @@ -34,20 +45,42 @@ suspend fun Q.transact(databaseDefinition: DatabaseDefi * execute the db operation. */ inline suspend fun M.awaitSave(databaseDefinition: DatabaseDefinition) - = suspendCancellableCoroutine { continuation: CancellableContinuation -> - val transaction = databaseDefinition.beginTransactionAsync { - modelAdapter().save(this, databaseDefinition) - } - .success { _, result -> continuation.resume(result) } - .error { _, throwable -> - if (continuation.isCancelled) return@error - continuation.resumeWithException(throwable) - }.build() - transaction.execute() + = suspendCancellableCoroutine { continuation -> + constructCoroutine(continuation, databaseDefinition) { save(databaseDefinition) } +} - continuation.invokeOnCompletion { - if (continuation.isCancelled) { - transaction.cancel() - } - } +/** + * Description: Puts a [Model] operation inside a coroutine. Inside the [queriableFunction] + * execute the db operation. + */ +inline suspend fun M.awaitInsert(databaseDefinition: DatabaseDefinition) + = suspendCancellableCoroutine { continuation -> + constructCoroutine(continuation, databaseDefinition) { insert(databaseDefinition) } +} + +/** + * Description: Puts a [Model] operation inside a coroutine. Inside the [queriableFunction] + * execute the db operation. + */ +inline suspend fun M.awaitDelete(databaseDefinition: DatabaseDefinition) + = suspendCancellableCoroutine { continuation -> + constructCoroutine(continuation, databaseDefinition) { delete(databaseDefinition) } +} + +/** + * Description: Puts a [Model] operation inside a coroutine. Inside the [queriableFunction] + * execute the db operation. + */ +inline suspend fun M.awaitUpdate(databaseDefinition: DatabaseDefinition) + = suspendCancellableCoroutine { continuation -> + constructCoroutine(continuation, databaseDefinition) { update(databaseDefinition) } +} + +/** + * Description: Puts a [Model] operation inside a coroutine. Inside the [queriableFunction] + * execute the db operation. + */ +inline suspend fun M.awaitLoad(databaseDefinition: DatabaseDefinition) + = suspendCancellableCoroutine { continuation -> + constructCoroutine(continuation, databaseDefinition) { load(databaseDefinition) } } \ No newline at end of file diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/DefaultTransactionQueue.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/DefaultTransactionQueue.kt index 066337777..eefc9d5d5 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/DefaultTransactionQueue.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/DefaultTransactionQueue.kt @@ -18,14 +18,14 @@ class DefaultTransactionQueue */ (name: String) : Thread(name), ITransactionQueue { - private val queue = LinkedBlockingQueue>() + private val queue = LinkedBlockingQueue>() private var isQuitting = false override fun run() { Looper.prepare() android.os.Process.setThreadPriority(android.os.Process.THREAD_PRIORITY_BACKGROUND) - var transaction: Transaction + var transaction: Transaction while (true) { try { transaction = queue.take() @@ -47,7 +47,7 @@ class DefaultTransactionQueue } } - override fun add(transaction: Transaction) { + override fun add(transaction: Transaction) { synchronized(queue) { if (!queue.contains(transaction)) { queue.add(transaction) @@ -60,7 +60,7 @@ class DefaultTransactionQueue * * @param transaction */ - override fun cancel(transaction: Transaction) { + override fun cancel(transaction: Transaction) { synchronized(queue) { if (queue.contains(transaction)) { queue.remove(transaction) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ITransactionQueue.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ITransactionQueue.kt index 41924c720..ea390ea06 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ITransactionQueue.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ITransactionQueue.kt @@ -10,14 +10,14 @@ interface ITransactionQueue { * * @param transaction The transaction to run on the queue. */ - fun add(transaction: Transaction) + fun add(transaction: Transaction) /** * Cancels a transaction. * * @param transaction The transaction to cancel on the queue. */ - fun cancel(transaction: Transaction) + fun cancel(transaction: Transaction) /** * Starts if not alive. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/PriorityTransactionQueue.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/PriorityTransactionQueue.kt index 63e148a6b..757f15e73 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/PriorityTransactionQueue.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/PriorityTransactionQueue.kt @@ -17,14 +17,14 @@ class PriorityTransactionQueue */ (name: String) : Thread(name), ITransactionQueue { - private val queue = PriorityBlockingQueue>>() + private val queue = PriorityBlockingQueue>>() private var isQuitting = false override fun run() { Looper.prepare() android.os.Process.setThreadPriority(android.os.Process.THREAD_PRIORITY_BACKGROUND) - var transaction: PriorityEntry> + var transaction: PriorityEntry> while (true) { try { transaction = queue.take() @@ -42,7 +42,7 @@ class PriorityTransactionQueue } } - override fun add(transaction: Transaction) { + override fun add(transaction: Transaction) { synchronized(queue) { val priorityEntry = PriorityEntry(transaction) if (!queue.contains(priorityEntry)) { @@ -56,7 +56,7 @@ class PriorityTransactionQueue * * @param transaction The transaction to cancel (if still in the queue). */ - override fun cancel(transaction: Transaction) { + override fun cancel(transaction: Transaction) { synchronized(queue) { val priorityEntry = PriorityEntry(transaction) if (queue.contains(priorityEntry)) { @@ -104,8 +104,8 @@ class PriorityTransactionQueue interrupt() } - internal inner class PriorityEntry>(val entry: E) - : Comparable>> { + internal inner class PriorityEntry>(val entry: E) + : Comparable>> { private val transactionWrapper: PriorityTransactionWrapper = if (entry.transaction() is PriorityTransactionWrapper) { entry.transaction() as PriorityTransactionWrapper @@ -114,7 +114,7 @@ class PriorityTransactionQueue .build() } - override fun compareTo(other: PriorityEntry>): Int = + override fun compareTo(other: PriorityEntry>): Int = transactionWrapper.compareTo(other.transactionWrapper) override fun equals(other: Any?): Boolean { diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Transaction.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Transaction.kt index bbc8f28aa..672be62db 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Transaction.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Transaction.kt @@ -16,7 +16,7 @@ import com.raizlabs.android.dbflow.runtime.BaseTransactionManager * * To create one, the recommended method is to use the [DatabaseDefinition.beginTransactionAsync]. */ -class Transaction(private val transaction: ITransaction, +class Transaction(private val transaction: ITransaction, private val databaseDefinition: DatabaseDefinition, private val errorCallback: Error? = null, private val successCallback: Success? = null, @@ -28,7 +28,7 @@ class Transaction(private val transaction: ITransaction, /** * Callback when a [ITransaction] failed because of an exception. */ - interface Error { + interface Error { /** * Called when transaction fails. @@ -42,7 +42,7 @@ class Transaction(private val transaction: ITransaction, /** * Interface callback when a [ITransaction] was successful. */ - interface Success { + interface Success { /** * Called when a transaction succeeded. @@ -131,7 +131,7 @@ class Transaction(private val transaction: ITransaction, /** * The main entry point into [Transaction], this provides an easy way to build up transactions. */ - class Builder + class Builder /** * @param transaction The interface that actually executes the transaction. * @param databaseDefinition The database this transaction will run on. Should be the same @@ -227,10 +227,10 @@ class Transaction(private val transaction: ITransaction, } } -inline fun transactionSuccess(crossinline function: (Transaction, R) -> Unit) = object : Transaction.Success { +inline fun transactionSuccess(crossinline function: (Transaction, R) -> Unit) = object : Transaction.Success { override fun onSuccess(transaction: Transaction, result: R) = function(transaction, result) } -inline fun transactionError(crossinline function: (Transaction, Throwable) -> Unit) = object : Transaction.Error { +inline fun transactionError(crossinline function: (Transaction, Throwable) -> Unit) = object : Transaction.Error { override fun onError(transaction: Transaction, error: Throwable) = function(transaction, error) } From 22daf412d17c81a90a756f1ec6e5be96ede16368 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sun, 26 Nov 2017 08:36:01 -0500 Subject: [PATCH 073/234] [5.0] remove modeladapter usage in query/cursor lists. --- .../database/transaction/CoroutinesTest.kt | 4 ++-- .../android/dbflow/list/FlowCursorList.kt | 21 +------------------ .../android/dbflow/list/FlowQueryList.kt | 3 --- 3 files changed, 3 insertions(+), 25 deletions(-) diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/CoroutinesTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/CoroutinesTest.kt index b0ad4b09c..02e5bfe10 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/CoroutinesTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/CoroutinesTest.kt @@ -83,8 +83,8 @@ class CoroutinesTest : BaseUnitTest() { assert(simpleModel.awaitUpdate(this)) val loadedModel = transact(select from SimpleModel::class - where SimpleModel_Table.name.eq("NewName")) { querySingle() }!! - assert(loadedModel.name == "NewName") + where SimpleModel_Table.name.eq("NewName")) { querySingle() } + assert(loadedModel?.name == "NewName") } } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorList.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorList.kt index f23bbbe90..539c735c5 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorList.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorList.kt @@ -6,7 +6,6 @@ import com.raizlabs.android.dbflow.config.FlowLog import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable import com.raizlabs.android.dbflow.structure.InstanceAdapter -import com.raizlabs.android.dbflow.structure.ModelAdapter import com.raizlabs.android.dbflow.structure.database.FlowCursor import java.util.* @@ -38,9 +37,6 @@ class FlowCursorList private constructor(builder: Builder) : IFlowCu private val cursorRefreshListenerSet = HashSet>() - internal val modelAdapter: ModelAdapter - get() = instanceAdapter as ModelAdapter - /** * @return the full, converted [T] list from the database on this list. For large * data sets that require a large conversion, consider calling this on a BG thread. @@ -51,8 +47,7 @@ class FlowCursorList private constructor(builder: Builder) : IFlowCu throwIfCursorClosed() warnEmptyCursor() return cursor?.let { cursor -> - FlowManager.getModelAdapter(table) - .listModelLoader.convertToData(cursor, null, + instanceAdapter.listModelLoader.convertToData(cursor, null, FlowManager.getWritableDatabaseForTable(table)) } ?: listOf() } @@ -198,18 +193,4 @@ class FlowCursorList private constructor(builder: Builder) : IFlowCu } - companion object { - - /** - * The default size of the cache if cache size is 0 or not specified. - */ - @JvmStatic - val DEFAULT_CACHE_SIZE = 50 - - /** - * Minimum size that we make the cache (if size is supported in cache) - */ - @JvmStatic - val MIN_CACHE_SIZE = 20 - } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowQueryList.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowQueryList.kt index 31f4b2f6f..745cb1706 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowQueryList.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowQueryList.kt @@ -43,9 +43,6 @@ class FlowQueryList( val copy: List get() = internalCursorList.all - internal val modelAdapter: ModelAdapter - get() = internalCursorList.modelAdapter - internal val instanceAdapter: InstanceAdapter get() = internalCursorList.instanceAdapter From 85d0f51505d66c4af6fd2a29c04284e3b12ca279 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sun, 26 Nov 2017 09:36:24 -0500 Subject: [PATCH 074/234] [5.0] fix content uris so that they can work with 8.0 changes. Will add a stub contentprovider class. --- .../dbflow/DBFlowInstrumentedTestRule.kt | 23 ++++++----- .../contentobserver/ContentObserverTest.kt | 7 +++- dbflow-tests/src/main/AndroidManifest.xml | 4 ++ .../android/dbflow/StubContentProvider.kt | 38 +++++++++++++++++++ .../android/dbflow/config/DatabaseConfig.kt | 10 ++++- .../android/dbflow/config/FlowManager.kt | 25 ++++++++++-- .../android/dbflow/list/FlowCursorList.kt | 5 +-- .../dbflow/runtime/BaseContentProvider.kt | 13 +------ .../dbflow/runtime/FlowContentObserver.kt | 17 +++++---- .../raizlabs/android/dbflow/sql/SqlUtils.kt | 8 +++- .../android/dbflow/structure/ModelAdapter.kt | 8 ++-- 11 files changed, 111 insertions(+), 47 deletions(-) create mode 100644 dbflow-tests/src/main/java/com/raizlabs/android/dbflow/StubContentProvider.kt diff --git a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/DBFlowInstrumentedTestRule.kt b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/DBFlowInstrumentedTestRule.kt index 362b1da22..891028f74 100644 --- a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/DBFlowInstrumentedTestRule.kt +++ b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/DBFlowInstrumentedTestRule.kt @@ -5,6 +5,7 @@ import com.raizlabs.android.dbflow.config.DatabaseDefinition import com.raizlabs.android.dbflow.config.FlowConfig import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.prepackaged.PrepackagedDB +import com.raizlabs.android.dbflow.sqlcipher.CipherDatabase import org.junit.rules.TestRule import org.junit.runner.Description import org.junit.runners.model.Statement @@ -17,16 +18,18 @@ class DBFlowInstrumentedTestRule : TestRule { @Throws(Throwable::class) override fun evaluate() { FlowManager.init(FlowConfig.Builder(DemoApp.context) - .addDatabaseConfig(DatabaseConfig.Builder(AppDatabase::class.java) - .transactionManagerCreator( - object : DatabaseConfig.TransactionManagerCreator { - override fun createManager(databaseDefinition: DatabaseDefinition) - = ImmediateTransactionManager(databaseDefinition) - }) - .build()) - .addDatabaseConfig(DatabaseConfig.builder(PrepackagedDB::class.java) - .databaseName("prepackaged") - .build()) + .addDatabaseConfig(DatabaseConfig( + databaseClass = AppDatabase::class.java, + contentAuthority = "com.grosner.content", + transactionManagerCreator = { databaseDefinition: DatabaseDefinition -> + ImmediateTransactionManager(databaseDefinition) + })) + .addDatabaseConfig(DatabaseConfig( + databaseClass = PrepackagedDB::class.java, + databaseName = "prepackaged")) + .addDatabaseConfig(DatabaseConfig( + databaseClass = CipherDatabase::class.java, + contentAuthority = "com.grosner.content")) .build()) try { base.evaluate() diff --git a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/contentobserver/ContentObserverTest.kt b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/contentobserver/ContentObserverTest.kt index 58143613b..3ff0e2abe 100644 --- a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/contentobserver/ContentObserverTest.kt +++ b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/contentobserver/ContentObserverTest.kt @@ -5,9 +5,11 @@ import com.raizlabs.android.dbflow.BaseInstrumentedUnitTest import com.raizlabs.android.dbflow.DemoApp import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.config.databaseForTable +import com.raizlabs.android.dbflow.config.tableName import com.raizlabs.android.dbflow.contentobserver.User_Table.id import com.raizlabs.android.dbflow.contentobserver.User_Table.name import com.raizlabs.android.dbflow.runtime.FlowContentObserver +import com.raizlabs.android.dbflow.sql.TABLE_QUERY_PARAM import com.raizlabs.android.dbflow.sql.getNotificationUri import com.raizlabs.android.dbflow.sql.language.SQLOperator import com.raizlabs.android.dbflow.sql.language.delete @@ -41,7 +43,8 @@ class ContentObserverTest : BaseInstrumentedUnitTest() { val uri = getNotificationUri(User::class.java, BaseModel.Action.DELETE, conditionGroup.conditions.toTypedArray()) - assertEquals(uri.authority, FlowManager.getTableName(User::class.java)) + assertEquals(uri.authority, "com.grosner.content") + assertEquals(tableName(), uri.getQueryParameter(TABLE_QUERY_PARAM)) assertEquals(uri.fragment, BaseModel.Action.DELETE.name) assertEquals(Uri.decode(uri.getQueryParameter(Uri.encode(id.query))), "5") assertEquals(Uri.decode(uri.getQueryParameter(Uri.encode(name.query))), "Something") @@ -82,7 +85,7 @@ class ContentObserverTest : BaseInstrumentedUnitTest() { countDownLatch.await() val ops = mockOnModelStateChangedListener.operators!! - assertTrue(ops.size == 2) + assertEquals(2, ops.size) assertEquals(ops[0].columnName(), id.query) assertEquals(ops[1].columnName(), name.query) assertEquals(ops[1].value(), "Something") diff --git a/dbflow-tests/src/main/AndroidManifest.xml b/dbflow-tests/src/main/AndroidManifest.xml index 1f4db6ec2..dc5309fa7 100644 --- a/dbflow-tests/src/main/AndroidManifest.xml +++ b/dbflow-tests/src/main/AndroidManifest.xml @@ -5,6 +5,10 @@ + + diff --git a/dbflow-tests/src/main/java/com/raizlabs/android/dbflow/StubContentProvider.kt b/dbflow-tests/src/main/java/com/raizlabs/android/dbflow/StubContentProvider.kt new file mode 100644 index 000000000..78b9a99bd --- /dev/null +++ b/dbflow-tests/src/main/java/com/raizlabs/android/dbflow/StubContentProvider.kt @@ -0,0 +1,38 @@ +package com.raizlabs.android.dbflow + +import android.content.ContentValues +import android.database.Cursor +import android.net.Uri +import com.raizlabs.android.dbflow.runtime.BaseContentProvider + +/** + * Description: + */ +class StubContentProvider : BaseContentProvider() { + override val databaseName: String + get() = TODO("not implemented") + + override fun bulkInsert(uri: Uri, contentValues: ContentValues): Int { + TODO("not implemented") + } + + override fun insert(uri: Uri?, values: ContentValues?): Uri { + TODO("not implemented") + } + + override fun query(uri: Uri?, projection: Array?, selection: String?, selectionArgs: Array?, sortOrder: String?): Cursor { + TODO("not implemented") + } + + override fun update(uri: Uri?, values: ContentValues?, selection: String?, selectionArgs: Array?): Int { + TODO("not implemented") + } + + override fun delete(uri: Uri?, selection: String?, selectionArgs: Array?): Int { + TODO("not implemented") + } + + override fun getType(uri: Uri?): String { + TODO("not implemented") + } +} \ No newline at end of file diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.kt index 3d86271af..c7640370b 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.kt @@ -19,7 +19,8 @@ class DatabaseConfig( val modelNotifier: ModelNotifier? = null, val isInMemory: Boolean = false, val databaseName: String? = null, - val databaseExtensionName: String? = null) { + val databaseExtensionName: String? = null, + val contentAuthority: String? = null) { interface OpenHelperCreator { @@ -46,7 +47,8 @@ class DatabaseConfig( builder.databaseExtensionName == null -> ".db" builder.databaseExtensionName.isNotNullOrEmpty() -> ".${builder.databaseExtensionName}" else -> "" - }) + }, + contentAuthority = builder.contentAuthority) @Suppress("UNCHECKED_CAST") fun getTableConfigForTable(modelClass: Class): TableConfig? = @@ -65,6 +67,7 @@ class DatabaseConfig( internal var inMemory = false internal var databaseName: String? = null internal var databaseExtensionName: String? = null + internal var contentAuthority: String? = null fun transactionManagerCreator(transactionManager: TransactionManagerCreator) = transactionManagerCreator { databaseDefinition -> transactionManager.createManager(databaseDefinition) } @@ -88,6 +91,9 @@ class DatabaseConfig( } } + fun contentUri(contentAuthority: String) = apply { + this.contentAuthority = contentAuthority + } fun helperListener(helperListener: DatabaseHelperListener) = apply { this.helperListener = helperListener diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt index badf15464..e96b67697 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt @@ -130,10 +130,6 @@ object FlowManager { @JvmStatic fun getDatabaseName(database: Class<*>): String = getDatabase(database).databaseName - @JvmStatic - fun getWritableDatabaseForTable(table: Class<*>): DatabaseWrapper = - getDatabaseForTable(table).writableDatabase - /** * @param databaseName The name of the database. Will throw an exception if the databaseForTable doesn't exist. * @return the [DatabaseDefinition] for the specified database @@ -146,14 +142,35 @@ object FlowManager { "Did you forget the @Database annotation?") } + @Deprecated(replaceWith = ReplaceWith("FlowManager.getDatabaseForTable(table)"), + message = "This method is no longer needed. DatabaseDefinition now delegates to the DatabaseWrapper.") + @JvmStatic + fun getWritableDatabaseForTable(table: Class<*>): DatabaseWrapper = + getDatabaseForTable(table).writableDatabase + + @Deprecated(replaceWith = ReplaceWith("FlowManager.getDatabase(databaseName)"), + message = "This method is no longer needed. DatabaseDefinition now delegates to the DatabaseWrapper.") @JvmStatic fun getWritableDatabase(databaseName: String): DatabaseWrapper = getDatabase(databaseName).writableDatabase + @Deprecated(replaceWith = ReplaceWith("FlowManager.getDatabase(databaseClass)"), + message = "This method is no longer needed. DatabaseDefinition now delegates to the DatabaseWrapper.") @JvmStatic fun getWritableDatabase(databaseClass: Class<*>): DatabaseWrapper = getDatabase(databaseClass).writableDatabase + fun getContentAuthorityForDatabase(clazz: Class<*>): String { + val databaseConfig = getConfig().getConfigForDatabase(clazz) + if (databaseConfig?.contentAuthority == null) { + throw IllegalStateException("Please specify a valid content authority for database $clazz via ${DatabaseConfig::class}") + } + return databaseConfig.contentAuthority + } + + fun getContentAuthorityForTable(table: Class<*>) + = getContentAuthorityForDatabase(getDatabaseForTable(table).associatedDatabaseClassFile) + /** * Loading the module Database holder via reflection. * diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorList.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorList.kt index 539c735c5..5606ea965 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorList.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorList.kt @@ -27,7 +27,6 @@ class FlowCursorList private constructor(builder: Builder) : IFlowCu fun onCursorRefreshed(cursorList: FlowCursorList) } - val table: Class val modelQueriable: ModelQueriable private var cursor: FlowCursor? = null @@ -48,7 +47,7 @@ class FlowCursorList private constructor(builder: Builder) : IFlowCu warnEmptyCursor() return cursor?.let { cursor -> instanceAdapter.listModelLoader.convertToData(cursor, null, - FlowManager.getWritableDatabaseForTable(table)) + FlowManager.getDatabaseForTable(table)) } ?: listOf() } @@ -116,7 +115,7 @@ class FlowCursorList private constructor(builder: Builder) : IFlowCu return if (cursor.moveToPosition(position.toInt())) { instanceAdapter.singleModelLoader.convertToData( FlowCursor.from(cursor), null, false, - FlowManager.getWritableDatabaseForTable(table)) + FlowManager.getDatabaseForTable(table)) ?: throw IndexOutOfBoundsException("Invalid item at position $position. Check your cursor data.") } else { throw IndexOutOfBoundsException("Invalid item at position $position. Check your cursor data.") diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/BaseContentProvider.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/BaseContentProvider.kt index 76164ff12..4cbb0f244 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/BaseContentProvider.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/BaseContentProvider.kt @@ -3,12 +3,9 @@ package com.raizlabs.android.dbflow.runtime import android.content.ContentProvider import android.content.ContentValues import android.net.Uri - import com.raizlabs.android.dbflow.config.DatabaseDefinition import com.raizlabs.android.dbflow.config.DatabaseHolder import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.sql.language.property.IProperty -import com.raizlabs.android.dbflow.sql.language.property.Property import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper import com.raizlabs.android.dbflow.structure.database.transaction.ITransaction @@ -25,14 +22,6 @@ protected constructor(databaseHolderClass: Class? = null) : protected abstract val databaseName: String - /** - * Converts the column into a [Property]. This exists since the property method is static and cannot - * be referenced easily. - */ - interface PropertyConverter { - fun fromName(columnName: String): IProperty<*> - } - override fun onCreate(): Boolean { // If this is a module, then we need to initialize the module as part // of the creation process. We can assume the framework has been general @@ -46,7 +35,7 @@ protected constructor(databaseHolderClass: Class? = null) : override fun bulkInsert(uri: Uri, values: Array): Int { val count = database.executeTransaction(object : ITransaction { - override fun execute(databaseWrapper: DatabaseWrapper) : IntArray { + override fun execute(databaseWrapper: DatabaseWrapper): IntArray { val count = intArrayOf(0) for (contentValues in values) { count[0] += bulkInsert(uri, contentValues) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/FlowContentObserver.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/FlowContentObserver.kt index a0250af8a..14c904877 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/FlowContentObserver.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/FlowContentObserver.kt @@ -10,6 +10,7 @@ import android.os.Build.VERSION_CODES import android.os.Handler import com.raizlabs.android.dbflow.config.DatabaseConfig import com.raizlabs.android.dbflow.config.FlowManager +import com.raizlabs.android.dbflow.sql.TABLE_QUERY_PARAM import com.raizlabs.android.dbflow.sql.getNotificationUri import com.raizlabs.android.dbflow.sql.language.NameAlias import com.raizlabs.android.dbflow.sql.language.Operator @@ -207,20 +208,20 @@ open class FlowContentObserver(handler: Handler? = null) : ContentObserver(handl private fun onChange(selfChanges: Boolean, uri: Uri, calledInternally: Boolean) { var uri = uri val fragment = uri.fragment - val tableName = uri.authority + val tableName = uri.getQueryParameter(TABLE_QUERY_PARAM) var columnName: String var param: String val queryNames = uri.queryParameterNames val columnsChanged = arrayListOf() - if (!queryNames.isEmpty()) { - for (key in queryNames) { - param = Uri.decode(uri.getQueryParameter(key)) - columnName = Uri.decode(key) - columnsChanged += Operator.op(NameAlias.Builder(columnName).build()).eq(param) - } - } + queryNames.asSequence() + .filter { it != TABLE_QUERY_PARAM } + .forEach { key -> + param = Uri.decode(uri.getQueryParameter(key)) + columnName = Uri.decode(key) + columnsChanged += Operator.op(NameAlias.Builder(columnName).build()).eq(param) + } val table = registeredTables[tableName] var action = Action.valueOf(fragment) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/SqlUtils.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/SqlUtils.kt index 0d4f9f379..e270c4fc0 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/SqlUtils.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/SqlUtils.kt @@ -22,6 +22,8 @@ import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper */ private val hexArray = "0123456789ABCDEF".toCharArray() +val TABLE_QUERY_PARAM = "tableName" + /** * Constructs a [Uri] from a set of [SQLOperator] for specific table. * @@ -34,7 +36,8 @@ fun getNotificationUri(modelClass: Class<*>, action: Action?, conditions: Iterable?): Uri { val uriBuilder = Uri.Builder().scheme("dbflow") - .authority(FlowManager.getTableName(modelClass)) + .authority(FlowManager.getContentAuthorityForTable(modelClass)) + .appendQueryParameter(TABLE_QUERY_PARAM, FlowManager.getTableName(modelClass)) if (action != null) { uriBuilder.fragment(action.name) } @@ -59,7 +62,8 @@ fun getNotificationUri(modelClass: Class<*>, action: Action?, conditions: Array?): Uri { val uriBuilder = Uri.Builder().scheme("dbflow") - .authority(FlowManager.getTableName(modelClass)) + .authority(FlowManager.getContentAuthorityForTable(modelClass)) + .appendQueryParameter(TABLE_QUERY_PARAM, FlowManager.getTableName(modelClass)) action?.let { uriBuilder.fragment(action.name) } if (conditions != null && conditions.isNotEmpty()) { for (condition in conditions) { diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelAdapter.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelAdapter.kt index b3234fced..844165777 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelAdapter.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelAdapter.kt @@ -103,7 +103,7 @@ abstract class ModelAdapter(databaseDefinition: DatabaseDefinition) */ fun getInsertStatement(): DatabaseStatement { if (insertStatement == null) { - insertStatement = getInsertStatement(FlowManager.getWritableDatabaseForTable(modelClass)) + insertStatement = getInsertStatement(FlowManager.getDatabaseForTable(modelClass)) } return insertStatement!! @@ -114,7 +114,7 @@ abstract class ModelAdapter(databaseDefinition: DatabaseDefinition) */ fun getUpdateStatement(): DatabaseStatement { if (updateStatement == null) { - updateStatement = getUpdateStatement(FlowManager.getWritableDatabaseForTable(modelClass)) + updateStatement = getUpdateStatement(FlowManager.getDatabaseForTable(modelClass)) } return updateStatement!! @@ -125,7 +125,7 @@ abstract class ModelAdapter(databaseDefinition: DatabaseDefinition) */ fun getDeleteStatement(): DatabaseStatement { if (deleteStatement == null) { - deleteStatement = getDeleteStatement(FlowManager.getWritableDatabaseForTable(modelClass)) + deleteStatement = getDeleteStatement(FlowManager.getDatabaseForTable(modelClass)) } return deleteStatement!! @@ -175,7 +175,7 @@ abstract class ModelAdapter(databaseDefinition: DatabaseDefinition) */ fun getCompiledStatement(): DatabaseStatement { if (compiledStatement == null) { - compiledStatement = getCompiledStatement(FlowManager.getWritableDatabaseForTable(modelClass)) + compiledStatement = getCompiledStatement(FlowManager.getDatabaseForTable(modelClass)) } return compiledStatement!! From d02458b52901c05abd1c4f40e65b5db450a959d5 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sun, 26 Nov 2017 09:44:47 -0500 Subject: [PATCH 075/234] [5.0] fix content uris so that they can work with 8.0 changes. added stub contentprovider class. --- .../android/dbflow/StubContentProvider.kt | 20 +++++++++---------- .../android/dbflow/config/FlowManager.kt | 2 +- 2 files changed, 10 insertions(+), 12 deletions(-) diff --git a/dbflow-tests/src/main/java/com/raizlabs/android/dbflow/StubContentProvider.kt b/dbflow-tests/src/main/java/com/raizlabs/android/dbflow/StubContentProvider.kt index 78b9a99bd..fcaed3053 100644 --- a/dbflow-tests/src/main/java/com/raizlabs/android/dbflow/StubContentProvider.kt +++ b/dbflow-tests/src/main/java/com/raizlabs/android/dbflow/StubContentProvider.kt @@ -1,30 +1,28 @@ package com.raizlabs.android.dbflow +import android.content.ContentProvider import android.content.ContentValues import android.database.Cursor import android.net.Uri -import com.raizlabs.android.dbflow.runtime.BaseContentProvider /** - * Description: + * Description: Used as a stub, include this in order to work around Android O changes to [ContentProvider] */ -class StubContentProvider : BaseContentProvider() { - override val databaseName: String - get() = TODO("not implemented") - - override fun bulkInsert(uri: Uri, contentValues: ContentValues): Int { - TODO("not implemented") - } +open class StubContentProvider : ContentProvider() { override fun insert(uri: Uri?, values: ContentValues?): Uri { TODO("not implemented") } - override fun query(uri: Uri?, projection: Array?, selection: String?, selectionArgs: Array?, sortOrder: String?): Cursor { + override fun query(uri: Uri?, projection: Array?, selection: String?, + selectionArgs: Array?, sortOrder: String?): Cursor { TODO("not implemented") } - override fun update(uri: Uri?, values: ContentValues?, selection: String?, selectionArgs: Array?): Int { + override fun onCreate(): Boolean = true + + override fun update(uri: Uri?, values: ContentValues?, selection: String?, + selectionArgs: Array?): Int { TODO("not implemented") } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt index e96b67697..71142c2e5 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt @@ -180,7 +180,7 @@ object FlowManager { * that are part of a module. Building once will give you the ability to add the class. */ @JvmStatic - fun initModule(generatedClassName: Class) { + fun initModule(generatedClassName: Class) { loadDatabaseHolder(generatedClassName) } From a087a8a535dd6289ffd16c273c437896a7513e16 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sun, 26 Nov 2017 10:08:41 -0500 Subject: [PATCH 076/234] [5.0] removing extension of flowquerylist on flowcontent observer since it bleeds implementation details. will replace notification with more suitable method later. --- .../android/dbflow/config/FlowManager.kt | 2 +- .../android/dbflow/list/FlowQueryList.kt | 52 +------------------ .../dbflow/runtime/DirectModelNotifier.kt | 2 +- .../dbflow/runtime/FlowContentObserver.kt | 20 ++----- 4 files changed, 8 insertions(+), 68 deletions(-) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt index 71142c2e5..e96b67697 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt @@ -180,7 +180,7 @@ object FlowManager { * that are part of a module. Building once will give you the ability to add the class. */ @JvmStatic - fun initModule(generatedClassName: Class) { + fun initModule(generatedClassName: Class) { loadDatabaseHolder(generatedClassName) } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowQueryList.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowQueryList.kt index 745cb1706..c5d80361a 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowQueryList.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowQueryList.kt @@ -1,17 +1,11 @@ package com.raizlabs.android.dbflow.list -import android.annotation.TargetApi -import android.content.Context import android.database.Cursor -import android.net.Uri -import android.os.Build import android.os.Handler import android.os.Looper import com.raizlabs.android.dbflow.list.FlowCursorList.OnCursorRefreshListener -import com.raizlabs.android.dbflow.runtime.FlowContentObserver import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable import com.raizlabs.android.dbflow.structure.InstanceAdapter -import com.raizlabs.android.dbflow.structure.ModelAdapter import com.raizlabs.android.dbflow.structure.database.transaction.DefaultTransactionQueue import com.raizlabs.android.dbflow.structure.database.transaction.Transaction @@ -33,7 +27,7 @@ class FlowQueryList( * Holds the table cursor */ val internalCursorList: FlowCursorList) - : FlowContentObserver(), List, IFlowCursorIterator { + : List, IFlowCursorIterator { private var pendingRefresh = false @@ -49,8 +43,6 @@ class FlowQueryList( override val count: Long get() = internalCursorList.count - fun changeInTransaction() = changeInTransaction - private val refreshRunnable = object : Runnable { override fun run() { synchronized(this) { @@ -68,15 +60,6 @@ class FlowQueryList( .build() ) - /** - * Registers the list for model change events. Internally this refreshes the underlying [FlowCursorList]. Call - * [.beginTransaction] to bunch up calls to model changes and then [.endTransactionAndNotify] to dispatch - * and refresh this list when completed. - */ - fun registerForContentChanges(context: Context) { - super.registerForContentChanges(context, internalCursorList.table) - } - fun addOnCursorRefreshListener(onCursorRefreshListener: OnCursorRefreshListener) { internalCursorList.addOnCursorRefreshListener(onCursorRefreshListener) } @@ -85,31 +68,6 @@ class FlowQueryList( internalCursorList.removeOnCursorRefreshListener(onCursorRefreshListener) } - override fun registerForContentChanges(context: Context, table: Class<*>) { - throw RuntimeException( - "This method is not to be used in the FlowQueryList. We should only ever receive" - + " notifications for one class here. Call registerForContentChanges(Context) instead") - } - - override fun onChange(selfChange: Boolean) { - super.onChange(selfChange) - if (!isInTransaction) { - refreshAsync() - } else { - changeInTransaction = true - } - } - - @TargetApi(Build.VERSION_CODES.JELLY_BEAN) - override fun onChange(selfChange: Boolean, uri: Uri) { - super.onChange(selfChange, uri) - if (!isInTransaction) { - refreshAsync() - } else { - changeInTransaction = true - } - } - val cursorList: FlowCursorList get() = internalCursorList @@ -144,14 +102,6 @@ class FlowQueryList( REFRESH_HANDLER.post(refreshRunnable) } - override fun endTransactionAndNotify() { - if (changeInTransaction) { - changeInTransaction = false - refresh() - } - super.endTransactionAndNotify() - } - /** * Checks to see if the table contains the object only if its a [T] * diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DirectModelNotifier.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DirectModelNotifier.kt index 9aed98adf..cf1d9b2a3 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DirectModelNotifier.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DirectModelNotifier.kt @@ -28,7 +28,7 @@ private constructor() : ModelNotifier { } - interface ModelChangedListener : OnModelStateChangedListener, OnTableChangedListener + interface ModelChangedListener : OnModelStateChangedListener, OnTableChangedListener init { if (instanceCount > 0) { diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/FlowContentObserver.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/FlowContentObserver.kt index 14c904877..4a577ceae 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/FlowContentObserver.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/FlowContentObserver.kt @@ -26,7 +26,7 @@ import java.util.concurrent.atomic.AtomicInteger * tables with [.addModelChangeListener]. * Provides ability to register and deregister listeners for when data is inserted, deleted, updated, and saved if the device is * above [VERSION_CODES.JELLY_BEAN]. If below it will only provide one callback. This is to be paired - * with the [ContentResolverNotifier] specified in the [DatabaseConfig] by default. + * with the [ContentResolverNotifier] specified in the [DatabaseConfig]. */ open class FlowContentObserver(handler: Handler? = null) : ContentObserver(handler) { @@ -190,13 +190,8 @@ open class FlowContentObserver(handler: Handler? = null) : ContentObserver(handl } override fun onChange(selfChange: Boolean) { - for (modelChangeListener in modelChangeListeners) { - modelChangeListener.onModelStateChanged(null, Action.CHANGE, arrayOf()) - } - - for (onTableChangedListener in onTableChangedListeners) { - onTableChangedListener.onTableChanged(null, Action.CHANGE) - } + modelChangeListeners.forEach { it.onModelStateChanged(null, Action.CHANGE, arrayOf()) } + onTableChangedListeners.forEach { it.onTableChanged(null, Action.CHANGE) } } @TargetApi(VERSION_CODES.JELLY_BEAN) @@ -226,15 +221,10 @@ open class FlowContentObserver(handler: Handler? = null) : ContentObserver(handl val table = registeredTables[tableName] var action = Action.valueOf(fragment) if (!isInTransaction) { - - for (modelChangeListener in modelChangeListeners) { - modelChangeListener.onModelStateChanged(table, action, columnsChanged.toTypedArray()) - } + modelChangeListeners.forEach { it.onModelStateChanged(table, action, columnsChanged.toTypedArray()) } if (!calledInternally) { - for (onTableChangeListener in onTableChangedListeners) { - onTableChangeListener.onTableChanged(table, action) - } + onTableChangedListeners.forEach { it.onTableChanged(table, action) } } } else { // convert this uri to a CHANGE op if we don't care about individual changes. From fa2d7575f7bd51ab74150cd09fc1ae177310fa80 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sun, 26 Nov 2017 16:23:02 -0500 Subject: [PATCH 077/234] [5.0] instead of requiring through DB config, require contentResolverNotifier to specify authority. Also make FlowContentObserver require an explicit authority to use which should match the Manifest. --- .../dbflow/DBFlowInstrumentedTestRule.kt | 4 +-- .../contentobserver/ContentObserverTest.kt | 13 +++++---- .../android/dbflow/list/FlowQueryListTest.kt | 24 --------------- .../android/dbflow/config/DatabaseConfig.kt | 11 ++----- .../dbflow/config/DatabaseDefinition.kt | 7 ++--- .../android/dbflow/config/FlowManager.kt | 11 ------- .../android/dbflow/list/FlowQueryList.kt | 29 ++----------------- .../dbflow/runtime/ContentResolverNotifier.kt | 19 +++++++----- .../dbflow/runtime/DirectModelNotifier.kt | 2 ++ .../dbflow/runtime/FlowContentObserver.kt | 12 +++++--- .../raizlabs/android/dbflow/sql/SqlUtils.kt | 16 ++++++---- 11 files changed, 48 insertions(+), 100 deletions(-) delete mode 100644 dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowQueryListTest.kt diff --git a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/DBFlowInstrumentedTestRule.kt b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/DBFlowInstrumentedTestRule.kt index 891028f74..50ee5cc3b 100644 --- a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/DBFlowInstrumentedTestRule.kt +++ b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/DBFlowInstrumentedTestRule.kt @@ -20,7 +20,6 @@ class DBFlowInstrumentedTestRule : TestRule { FlowManager.init(FlowConfig.Builder(DemoApp.context) .addDatabaseConfig(DatabaseConfig( databaseClass = AppDatabase::class.java, - contentAuthority = "com.grosner.content", transactionManagerCreator = { databaseDefinition: DatabaseDefinition -> ImmediateTransactionManager(databaseDefinition) })) @@ -28,8 +27,7 @@ class DBFlowInstrumentedTestRule : TestRule { databaseClass = PrepackagedDB::class.java, databaseName = "prepackaged")) .addDatabaseConfig(DatabaseConfig( - databaseClass = CipherDatabase::class.java, - contentAuthority = "com.grosner.content")) + databaseClass = CipherDatabase::class.java)) .build()) try { base.evaluate() diff --git a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/contentobserver/ContentObserverTest.kt b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/contentobserver/ContentObserverTest.kt index 3ff0e2abe..b3a4fc11b 100644 --- a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/contentobserver/ContentObserverTest.kt +++ b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/contentobserver/ContentObserverTest.kt @@ -19,13 +19,14 @@ import com.raizlabs.android.dbflow.structure.insert import com.raizlabs.android.dbflow.structure.save import com.raizlabs.android.dbflow.structure.update import org.junit.Assert.assertEquals -import org.junit.Assert.assertTrue import org.junit.Before import org.junit.Test import java.util.concurrent.CountDownLatch class ContentObserverTest : BaseInstrumentedUnitTest() { + val contentUri = "com.grosner.content" + private lateinit var user: User @Before @@ -40,10 +41,11 @@ class ContentObserverTest : BaseInstrumentedUnitTest() { fun testSpecificUris() { val conditionGroup = FlowManager.getModelAdapter(User::class.java) .getPrimaryConditionClause(user) - val uri = getNotificationUri(User::class.java, BaseModel.Action.DELETE, + val uri = getNotificationUri(contentUri, + User::class.java, BaseModel.Action.DELETE, conditionGroup.conditions.toTypedArray()) - assertEquals(uri.authority, "com.grosner.content") + assertEquals(uri.authority, contentUri) assertEquals(tableName(), uri.getQueryParameter(TABLE_QUERY_PARAM)) assertEquals(uri.fragment, BaseModel.Action.DELETE.name) assertEquals(Uri.decode(uri.getQueryParameter(Uri.encode(id.query))), "5") @@ -75,7 +77,7 @@ class ContentObserverTest : BaseInstrumentedUnitTest() { } private fun assertProperConditions(action: BaseModel.Action, userFunc: (User) -> Unit) { - val contentObserver = FlowContentObserver() + val contentObserver = FlowContentObserver(contentUri) val countDownLatch = CountDownLatch(1) val mockOnModelStateChangedListener = MockOnModelStateChangedListener(countDownLatch) contentObserver.addModelChangeListener(mockOnModelStateChangedListener) @@ -96,7 +98,8 @@ class ContentObserverTest : BaseInstrumentedUnitTest() { contentObserver.unregisterForContentChanges(DemoApp.context) } - class MockOnModelStateChangedListener(val countDownLatch: CountDownLatch) : FlowContentObserver.OnModelStateChangedListener { + class MockOnModelStateChangedListener(val countDownLatch: CountDownLatch) + : FlowContentObserver.OnModelStateChangedListener { var action: BaseModel.Action? = null var operators: Array? = null diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowQueryListTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowQueryListTest.kt deleted file mode 100644 index a593eb30e..000000000 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowQueryListTest.kt +++ /dev/null @@ -1,24 +0,0 @@ -package com.raizlabs.android.dbflow.list - -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.config.databaseForTable -import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.sql.language.select -import org.junit.Assert.assertTrue -import org.junit.Test - -class FlowQueryListTest : BaseUnitTest() { - - @Test - fun validateBuilder() { - databaseForTable { - val list = FlowQueryList.Builder(select from SimpleModel::class) - .transact(true) - .changeInTransaction(true) - .build() - - assertTrue(list.transact) - assertTrue(list.changeInTransaction()) - } - } -} \ No newline at end of file diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.kt index c7640370b..81f7f9bd3 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.kt @@ -19,8 +19,7 @@ class DatabaseConfig( val modelNotifier: ModelNotifier? = null, val isInMemory: Boolean = false, val databaseName: String? = null, - val databaseExtensionName: String? = null, - val contentAuthority: String? = null) { + val databaseExtensionName: String? = null) { interface OpenHelperCreator { @@ -47,8 +46,7 @@ class DatabaseConfig( builder.databaseExtensionName == null -> ".db" builder.databaseExtensionName.isNotNullOrEmpty() -> ".${builder.databaseExtensionName}" else -> "" - }, - contentAuthority = builder.contentAuthority) + }) @Suppress("UNCHECKED_CAST") fun getTableConfigForTable(modelClass: Class): TableConfig? = @@ -67,7 +65,6 @@ class DatabaseConfig( internal var inMemory = false internal var databaseName: String? = null internal var databaseExtensionName: String? = null - internal var contentAuthority: String? = null fun transactionManagerCreator(transactionManager: TransactionManagerCreator) = transactionManagerCreator { databaseDefinition -> transactionManager.createManager(databaseDefinition) } @@ -91,10 +88,6 @@ class DatabaseConfig( } } - fun contentUri(contentAuthority: String) = apply { - this.contentAuthority = contentAuthority - } - fun helperListener(helperListener: DatabaseHelperListener) = apply { this.helperListener = helperListener } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.kt index 2c76073d1..6f44c6cef 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.kt @@ -6,7 +6,7 @@ import com.raizlabs.android.dbflow.annotation.Database import com.raizlabs.android.dbflow.annotation.QueryModel import com.raizlabs.android.dbflow.annotation.Table import com.raizlabs.android.dbflow.runtime.BaseTransactionManager -import com.raizlabs.android.dbflow.runtime.ContentResolverNotifier +import com.raizlabs.android.dbflow.runtime.DirectModelNotifier import com.raizlabs.android.dbflow.runtime.ModelNotifier import com.raizlabs.android.dbflow.sql.migration.Migration import com.raizlabs.android.dbflow.sql.queriable.ListModelLoader @@ -261,7 +261,7 @@ abstract class DatabaseDefinition : DatabaseWrapper { if (modelNotifier == null) { val config = FlowManager.getConfig().databaseConfigMap[associatedDatabaseClassFile] modelNotifier = if (config?.modelNotifier == null) { - ContentResolverNotifier() + DirectModelNotifier() } else { config.modelNotifier } @@ -304,8 +304,7 @@ abstract class DatabaseDefinition : DatabaseWrapper { */ abstract fun backupEnabled(): Boolean - - @Deprecated("use {@link #reset()}") + @Deprecated(message = "use {@link #reset()}", replaceWith = ReplaceWith("reset()")) fun reset(context: Context) { reset(databaseConfig) } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt index e96b67697..e884c4906 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt @@ -160,17 +160,6 @@ object FlowManager { fun getWritableDatabase(databaseClass: Class<*>): DatabaseWrapper = getDatabase(databaseClass).writableDatabase - fun getContentAuthorityForDatabase(clazz: Class<*>): String { - val databaseConfig = getConfig().getConfigForDatabase(clazz) - if (databaseConfig?.contentAuthority == null) { - throw IllegalStateException("Please specify a valid content authority for database $clazz via ${DatabaseConfig::class}") - } - return databaseConfig.contentAuthority - } - - fun getContentAuthorityForTable(table: Class<*>) - = getContentAuthorityForDatabase(getDatabaseForTable(table).associatedDatabaseClassFile) - /** * Loading the module Database holder via reflection. * diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowQueryList.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowQueryList.kt index c5d80361a..115881288 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowQueryList.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowQueryList.kt @@ -17,12 +17,6 @@ import com.raizlabs.android.dbflow.structure.database.transaction.Transaction * on the underlying table. */ class FlowQueryList( - /** - * If true, we will make all modifications on the [DefaultTransactionQueue], else - * we will run it on the main thread. - */ - val transact: Boolean = false, - private var changeInTransaction: Boolean = false, /** * Holds the table cursor */ @@ -53,8 +47,6 @@ class FlowQueryList( } internal constructor(builder: Builder) : this( - transact = builder.transact, - changeInTransaction = builder.changeInTransaction, internalCursorList = FlowCursorList.Builder(builder.modelQueriable) .cursor(builder.cursor) .build() @@ -75,11 +67,7 @@ class FlowQueryList( * @return Constructs a new [Builder] that reuses the underlying [Cursor], cache, * callbacks, and other properties. */ - fun newBuilder(): Builder { - return Builder(internalCursorList) - .changeInTransaction(changeInTransaction) - .transact(transact) - } + fun newBuilder(): Builder = Builder(internalCursorList) /** * Refreshes the content backing this list. @@ -142,7 +130,7 @@ class FlowQueryList( * @return A model converted from the internal [FlowCursorList]. For * performance improvements, ensure caching is turned on. */ - override operator fun get(index: Int): T = internalCursorList.get(index.toLong()) + override operator fun get(index: Int): T = internalCursorList[index.toLong()] override fun indexOf(element: T): Int { throw UnsupportedOperationException( @@ -203,8 +191,6 @@ class FlowQueryList( internal val table: Class - internal var transact: Boolean = false - internal var changeInTransaction: Boolean = false internal var cursor: Cursor? = null internal var modelQueriable: ModelQueriable @@ -223,17 +209,6 @@ class FlowQueryList( this.cursor = cursor } - fun transact(transact: Boolean) = apply { - this.transact = transact - } - - /** - * If true, when an operation occurs whenever we call endTransactionAndNotify, we refresh content. - */ - fun changeInTransaction(changeInTransaction: Boolean) = apply { - this.changeInTransaction = changeInTransaction - } - fun build() = FlowQueryList(this) } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ContentResolverNotifier.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ContentResolverNotifier.kt index 5f1ea4711..7f31f96f8 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ContentResolverNotifier.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ContentResolverNotifier.kt @@ -10,31 +10,36 @@ import com.raizlabs.android.dbflow.structure.ModelAdapter /** * The default use case, it notifies via the [ContentResolver] system. + * + * @param [authority] Specify the content URI authority you wish to use here. This will get propagated + * everywhere that changes get called from in a specific database. */ -class ContentResolverNotifier : ModelNotifier { +class ContentResolverNotifier(val authority: String) : ModelNotifier { override fun notifyModelChanged(model: T, adapter: ModelAdapter, action: BaseModel.Action) { if (FlowContentObserver.shouldNotify()) { FlowManager.context.contentResolver - .notifyChange(getNotificationUri(adapter.modelClass, action, - adapter.getPrimaryConditionClause(model).conditions), null, true) + .notifyChange(getNotificationUri(authority, + adapter.modelClass, action, + adapter.getPrimaryConditionClause(model).conditions), + null, true) } } override fun notifyTableChanged(table: Class, action: BaseModel.Action) { if (FlowContentObserver.shouldNotify()) { FlowManager.context.contentResolver - .notifyChange(getNotificationUri(table, action, + .notifyChange(getNotificationUri(authority, table, action, null as Array?), null, true) } } - override fun newRegister(): TableNotifierRegister = FlowContentTableNotifierRegister() + override fun newRegister(): TableNotifierRegister = FlowContentTableNotifierRegister(authority) - class FlowContentTableNotifierRegister : TableNotifierRegister { + class FlowContentTableNotifierRegister(contentAuthority: String) : TableNotifierRegister { - private val flowContentObserver = FlowContentObserver() + private val flowContentObserver = FlowContentObserver(contentAuthority) private var tableChangedListener: OnTableChangedListener? = null diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DirectModelNotifier.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DirectModelNotifier.kt index cf1d9b2a3..c5905491a 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DirectModelNotifier.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DirectModelNotifier.kt @@ -142,6 +142,8 @@ private constructor() : ModelNotifier { @JvmStatic fun get(): DirectModelNotifier = notifier + + operator fun invoke() = get() } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/FlowContentObserver.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/FlowContentObserver.kt index 4a577ceae..f4472ee82 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/FlowContentObserver.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/FlowContentObserver.kt @@ -27,8 +27,11 @@ import java.util.concurrent.atomic.AtomicInteger * Provides ability to register and deregister listeners for when data is inserted, deleted, updated, and saved if the device is * above [VERSION_CODES.JELLY_BEAN]. If below it will only provide one callback. This is to be paired * with the [ContentResolverNotifier] specified in the [DatabaseConfig]. + * + * @param [contentAuthority] Reuse the same authority as defined in your manifest and [ContentResolverNotifier]. */ -open class FlowContentObserver(handler: Handler? = null) : ContentObserver(handler) { +open class FlowContentObserver(private val contentAuthority: String, + handler: Handler? = null) : ContentObserver(handler) { private val modelChangeListeners = CopyOnWriteArraySet() private val onTableChangedListeners = CopyOnWriteArraySet() @@ -173,7 +176,8 @@ open class FlowContentObserver(handler: Handler? = null) : ContentObserver(handl */ fun registerForContentChanges(contentResolver: ContentResolver, table: Class<*>) { - contentResolver.registerContentObserver(getNotificationUri(table, null), true, this) + contentResolver.registerContentObserver( + getNotificationUri(contentAuthority, table, null), true, this) REGISTERED_COUNT.incrementAndGet() if (!registeredTables.containsValue(table)) { registeredTables.put(FlowManager.getTableName(table), table) @@ -230,7 +234,7 @@ open class FlowContentObserver(handler: Handler? = null) : ContentObserver(handl // convert this uri to a CHANGE op if we don't care about individual changes. if (!notifyAllUris) { action = Action.CHANGE - uri = getNotificationUri(table!!, action) + uri = getNotificationUri(contentAuthority, table!!, action) } synchronized(notificationUris) { // add and keep track of unique notification uris for when transaction completes. @@ -238,7 +242,7 @@ open class FlowContentObserver(handler: Handler? = null) : ContentObserver(handl } synchronized(tableUris) { - tableUris.add(getNotificationUri(table!!, action)) + tableUris.add(getNotificationUri(contentAuthority, table!!, action)) } } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/SqlUtils.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/SqlUtils.kt index e270c4fc0..6fb3380fd 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/SqlUtils.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/SqlUtils.kt @@ -32,11 +32,12 @@ val TABLE_QUERY_PARAM = "tableName" * @param conditions The set of key-value [SQLOperator] to construct into a uri. * @return The [Uri]. */ -fun getNotificationUri(modelClass: Class<*>, +fun getNotificationUri(contentAuthority: String, + modelClass: Class<*>, action: Action?, conditions: Iterable?): Uri { val uriBuilder = Uri.Builder().scheme("dbflow") - .authority(FlowManager.getContentAuthorityForTable(modelClass)) + .authority(contentAuthority) .appendQueryParameter(TABLE_QUERY_PARAM, FlowManager.getTableName(modelClass)) if (action != null) { uriBuilder.fragment(action.name) @@ -58,11 +59,12 @@ fun getNotificationUri(modelClass: Class<*>, * @param conditions The set of key-value [SQLOperator] to construct into a uri. * @return The [Uri]. */ -fun getNotificationUri(modelClass: Class<*>, +fun getNotificationUri(contentAuthority: String, + modelClass: Class<*>, action: Action?, conditions: Array?): Uri { val uriBuilder = Uri.Builder().scheme("dbflow") - .authority(FlowManager.getContentAuthorityForTable(modelClass)) + .authority(contentAuthority) .appendQueryParameter(TABLE_QUERY_PARAM, FlowManager.getTableName(modelClass)) action?.let { uriBuilder.fragment(action.name) } if (conditions != null && conditions.isNotEmpty()) { @@ -84,7 +86,8 @@ fun getNotificationUri(modelClass: Class<*>, * @return Notification uri. */ @JvmOverloads -fun getNotificationUri(modelClass: Class<*>, +fun getNotificationUri(contentAuthority: String, + modelClass: Class<*>, action: Action?, notifyKey: String = "", notifyValue: Any? = null): Uri { @@ -92,7 +95,8 @@ fun getNotificationUri(modelClass: Class<*>, if (notifyKey.isNotNullOrEmpty()) { operator = Operator.op(NameAlias.Builder(notifyKey).build()).value(notifyValue) } - return getNotificationUri(modelClass, action, if (operator != null) arrayOf(operator) else null) + return getNotificationUri(contentAuthority, modelClass, action, + if (operator != null) arrayOf(operator) else null) } From c4917803fbe2b42a1501f777781863490867e12e Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sun, 26 Nov 2017 16:45:33 -0500 Subject: [PATCH 078/234] [5.0] fix test for content resolver. --- .../com/raizlabs/android/dbflow/DBFlowInstrumentedTestRule.kt | 2 ++ 1 file changed, 2 insertions(+) diff --git a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/DBFlowInstrumentedTestRule.kt b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/DBFlowInstrumentedTestRule.kt index 50ee5cc3b..4fc06e210 100644 --- a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/DBFlowInstrumentedTestRule.kt +++ b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/DBFlowInstrumentedTestRule.kt @@ -5,6 +5,7 @@ import com.raizlabs.android.dbflow.config.DatabaseDefinition import com.raizlabs.android.dbflow.config.FlowConfig import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.prepackaged.PrepackagedDB +import com.raizlabs.android.dbflow.runtime.ContentResolverNotifier import com.raizlabs.android.dbflow.sqlcipher.CipherDatabase import org.junit.rules.TestRule import org.junit.runner.Description @@ -20,6 +21,7 @@ class DBFlowInstrumentedTestRule : TestRule { FlowManager.init(FlowConfig.Builder(DemoApp.context) .addDatabaseConfig(DatabaseConfig( databaseClass = AppDatabase::class.java, + modelNotifier = ContentResolverNotifier("com.grosner.content"), transactionManagerCreator = { databaseDefinition: DatabaseDefinition -> ImmediateTransactionManager(databaseDefinition) })) From 37cd67064a42befd1b1176695daaecf47ee488ed Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sun, 26 Nov 2017 18:49:07 -0500 Subject: [PATCH 079/234] [5.0] convert sqlcipher to kotlin. --- dbflow-sqlcipher/build.gradle | 6 +- .../dbflow/sqlcipher/SQLCipherDatabase.java | 95 ---------- .../dbflow/sqlcipher/SQLCipherDatabase.kt | 72 ++++++++ .../dbflow/sqlcipher/SQLCipherOpenHelper.java | 172 ------------------ .../dbflow/sqlcipher/SQLCipherOpenHelper.kt | 138 ++++++++++++++ .../dbflow/sqlcipher/SQLCipherStatement.java | 85 --------- .../dbflow/sqlcipher/SQLCipherStatement.kt | 62 +++++++ .../dbflow/sqlcipher/CipherTestObjects.kt | 2 +- .../database/DatabaseHelperDelegate.kt | 2 +- .../database/FlowSQLiteOpenHelper.kt | 6 +- 10 files changed, 281 insertions(+), 359 deletions(-) delete mode 100644 dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherDatabase.java create mode 100644 dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherDatabase.kt delete mode 100644 dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherOpenHelper.java create mode 100644 dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherOpenHelper.kt delete mode 100644 dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherStatement.java create mode 100644 dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherStatement.kt diff --git a/dbflow-sqlcipher/build.gradle b/dbflow-sqlcipher/build.gradle index 74428766d..49c54da62 100644 --- a/dbflow-sqlcipher/build.gradle +++ b/dbflow-sqlcipher/build.gradle @@ -1,4 +1,5 @@ apply plugin: 'com.android.library' +apply plugin: 'kotlin-android' project.ext.artifactId = bt_name @@ -17,14 +18,15 @@ android { } compileOptions { - sourceCompatibility JavaVersion.VERSION_1_7 - targetCompatibility JavaVersion.VERSION_1_7 + sourceCompatibility JavaVersion.VERSION_1_8 + targetCompatibility JavaVersion.VERSION_1_8 } } dependencies { api "net.zetetic:android-database-sqlcipher:3.5.7@aar" api project("${dbflow_project_prefix}dbflow") + api "org.jetbrains.kotlin:kotlin-stdlib-jre8:$kotlin_version" } apply from: '../android-artifacts.gradle' diff --git a/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherDatabase.java b/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherDatabase.java deleted file mode 100644 index 64e45401d..000000000 --- a/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherDatabase.java +++ /dev/null @@ -1,95 +0,0 @@ -package com.raizlabs.android.dbflow.sqlcipher; - -import android.content.ContentValues; -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.structure.database.DatabaseStatement; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; -import com.raizlabs.android.dbflow.structure.database.FlowCursor; - -import net.sqlcipher.database.SQLiteDatabase; - -/** - * Description: Implements the code necessary to use a {@link SQLiteDatabase} in dbflow. - */ -public class SQLCipherDatabase implements DatabaseWrapper { - - private final SQLiteDatabase database; - - public static SQLCipherDatabase from(SQLiteDatabase database) { - return new SQLCipherDatabase(database); - } - - SQLCipherDatabase(SQLiteDatabase database) { - this.database = database; - } - - @Override - public void execSQL(@NonNull String query) { - database.execSQL(query); - } - - @Override - public void beginTransaction() { - database.beginTransaction(); - } - - @Override - public void setTransactionSuccessful() { - database.setTransactionSuccessful(); - } - - @Override - public void endTransaction() { - database.endTransaction(); - } - - @Override - public int getVersion() { - return database.getVersion(); - } - - @NonNull - @Override - public DatabaseStatement compileStatement(@NonNull String rawQuery) { - return SQLCipherStatement.from(database.compileStatement(rawQuery)); - } - - public SQLiteDatabase getDatabase() { - return database; - } - - @NonNull - @Override - public FlowCursor rawQuery(@NonNull String query, @Nullable String[] selectionArgs) { - return FlowCursor.Companion.from(database.rawQuery(query, selectionArgs)); - } - - @Override - public long updateWithOnConflict(@NonNull String tableName, @NonNull ContentValues contentValues, @Nullable String where, @Nullable String[] whereArgs, int conflictAlgorithm) { - return database.updateWithOnConflict(tableName, contentValues, where, whereArgs, conflictAlgorithm); - } - - @Override - public long insertWithOnConflict(@NonNull String tableName, @Nullable String nullColumnHack, @NonNull ContentValues values, int sqLiteDatabaseAlgorithmInt) { - return database.insertWithOnConflict(tableName, nullColumnHack, values, sqLiteDatabaseAlgorithmInt); - } - - @NonNull - @Override - public FlowCursor query(@NonNull String tableName, - @Nullable String[] columns, - @Nullable String selection, - @Nullable String[] selectionArgs, - @Nullable String groupBy, - @Nullable String having, - @Nullable String orderBy) { - return FlowCursor.Companion.from(database.query(tableName, columns, selection, selectionArgs, groupBy, having, orderBy)); - } - - @Override - public int delete(@NonNull String tableName, @Nullable String whereClause, @Nullable String[] whereArgs) { - return database.delete(tableName, whereClause, whereArgs); - } -} diff --git a/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherDatabase.kt b/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherDatabase.kt new file mode 100644 index 000000000..8f9b4d046 --- /dev/null +++ b/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherDatabase.kt @@ -0,0 +1,72 @@ +package com.raizlabs.android.dbflow.sqlcipher + +import android.content.ContentValues + +import com.raizlabs.android.dbflow.structure.database.DatabaseStatement +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.structure.database.FlowCursor + +import net.sqlcipher.database.SQLiteDatabase + +/** + * Description: Implements the code necessary to use a [SQLiteDatabase] in dbflow. + */ +class SQLCipherDatabase +internal constructor(val database: SQLiteDatabase) : DatabaseWrapper { + + override val version: Int + get() = database.version + + override fun execSQL(query: String) { + database.execSQL(query) + } + + override fun beginTransaction() { + database.beginTransaction() + } + + override fun setTransactionSuccessful() { + database.setTransactionSuccessful() + } + + override fun endTransaction() { + database.endTransaction() + } + + override fun compileStatement(rawQuery: String): DatabaseStatement = + SQLCipherStatement.from(database.compileStatement(rawQuery)) + + override fun rawQuery(query: String, selectionArgs: Array?): FlowCursor = + FlowCursor.from(database.rawQuery(query, selectionArgs)) + + override fun updateWithOnConflict(tableName: String, + contentValues: ContentValues, + where: String?, whereArgs: Array?, + conflictAlgorithm: Int): Long = + database.updateWithOnConflict(tableName, contentValues, + where, whereArgs, conflictAlgorithm).toLong() + + override fun insertWithOnConflict(tableName: String, nullColumnHack: String?, values: ContentValues, sqLiteDatabaseAlgorithmInt: Int): Long { + return database.insertWithOnConflict(tableName, nullColumnHack, values, sqLiteDatabaseAlgorithmInt) + } + + override fun query(tableName: String, + columns: Array?, + selection: String?, + selectionArgs: Array?, + groupBy: String?, + having: String?, + orderBy: String?): FlowCursor { + return FlowCursor.from(database.query(tableName, columns, selection, selectionArgs, groupBy, having, orderBy)) + } + + override fun delete(tableName: String, whereClause: String?, whereArgs: Array?): Int { + return database.delete(tableName, whereClause, whereArgs) + } + + companion object { + + @JvmStatic + fun from(database: SQLiteDatabase): SQLCipherDatabase = SQLCipherDatabase(database) + } +} diff --git a/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherOpenHelper.java b/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherOpenHelper.java deleted file mode 100644 index 59a81079d..000000000 --- a/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherOpenHelper.java +++ /dev/null @@ -1,172 +0,0 @@ -package com.raizlabs.android.dbflow.sqlcipher; - -import android.content.Context; -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.config.DatabaseConfig; -import com.raizlabs.android.dbflow.config.DatabaseDefinition; -import com.raizlabs.android.dbflow.config.FlowManager; -import com.raizlabs.android.dbflow.structure.database.BaseDatabaseHelper; -import com.raizlabs.android.dbflow.structure.database.DatabaseHelperDelegate; -import com.raizlabs.android.dbflow.structure.database.DatabaseHelperListener; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; -import com.raizlabs.android.dbflow.structure.database.OpenHelper; - -import net.sqlcipher.database.SQLiteDatabase; -import net.sqlcipher.database.SQLiteOpenHelper; - -/** - * Description: The replacement {@link OpenHelper} for SQLCipher. Specify a subclass of this is {@link DatabaseConfig#getDatabaseClass()} - * of your database to get it to work with specifying the secret you use for the databaseForTable. - */ -public abstract class SQLCipherOpenHelper extends SQLiteOpenHelper implements OpenHelper { - - private DatabaseHelperDelegate databaseHelperDelegate; - private SQLCipherDatabase cipherDatabase; - - public SQLCipherOpenHelper(DatabaseDefinition databaseDefinition, DatabaseHelperListener listener) { - super(FlowManager.getContext(), databaseDefinition.isInMemory() ? null : databaseDefinition.getDatabaseFileName(), null, databaseDefinition.getDatabaseVersion()); - SQLiteDatabase.loadLibs(FlowManager.getContext()); - - OpenHelper backupHelper = null; - if (databaseDefinition.backupEnabled()) { - // Temp database mirrors existing - backupHelper = new BackupHelper(FlowManager.getContext(), DatabaseHelperDelegate.Companion.getTempDbFileName(databaseDefinition), - databaseDefinition.getDatabaseVersion(), databaseDefinition); - } - - databaseHelperDelegate = new DatabaseHelperDelegate(listener, databaseDefinition, backupHelper); - } - - @Override - public void performRestoreFromBackup() { - databaseHelperDelegate.performRestoreFromBackup(); - } - - @Nullable - @Override - public DatabaseHelperDelegate getDelegate() { - return databaseHelperDelegate; - } - - @Override - public boolean isDatabaseIntegrityOk() { - return databaseHelperDelegate.isDatabaseIntegrityOk(); - } - - @Override - public void backupDB() { - databaseHelperDelegate.backupDB(); - } - - @NonNull - @Override - public DatabaseWrapper getDatabase() { - if (cipherDatabase == null || !cipherDatabase.getDatabase().isOpen()) { - cipherDatabase = SQLCipherDatabase.from(getWritableDatabase(getCipherSecret())); - } - return cipherDatabase; - } - - /** - * Set a listener to listen for specific DB events and perform an action before we execute this classes - * specific methods. - * - * @param listener - */ - public void setDatabaseListener(@Nullable DatabaseHelperListener listener) { - databaseHelperDelegate.setDatabaseHelperListener(listener); - } - - @Override - public void onCreate(SQLiteDatabase db) { - databaseHelperDelegate.onCreate(SQLCipherDatabase.from(db)); - } - - @Override - public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { - databaseHelperDelegate.onUpgrade(SQLCipherDatabase.from(db), oldVersion, newVersion); - } - - @Override - public void onOpen(SQLiteDatabase db) { - databaseHelperDelegate.onOpen(SQLCipherDatabase.from(db)); - } - - @Override - public void closeDB() { - getDatabase(); - cipherDatabase.getDatabase().close(); - } - - /** - * @return The SQLCipher secret for opening this database. - */ - protected abstract String getCipherSecret(); - - /** - * Simple helper to manage backup. - */ - private class BackupHelper extends SQLiteOpenHelper implements OpenHelper { - - private SQLCipherDatabase sqlCipherDatabase; - private final BaseDatabaseHelper baseDatabaseHelper; - - public BackupHelper(Context context, String name, int version, DatabaseDefinition databaseDefinition) { - super(context, name, null, version); - this.baseDatabaseHelper = new BaseDatabaseHelper(databaseDefinition); - } - - @NonNull - @Override - public DatabaseWrapper getDatabase() { - if (sqlCipherDatabase == null) { - sqlCipherDatabase = SQLCipherDatabase.from(getWritableDatabase(getCipherSecret())); - } - return sqlCipherDatabase; - } - - @Override - public void performRestoreFromBackup() { - } - - @Nullable - @Override - public DatabaseHelperDelegate getDelegate() { - return null; - } - - @Override - public boolean isDatabaseIntegrityOk() { - return false; - } - - @Override - public void backupDB() { - } - - @Override - public void closeDB() { - } - - @Override - public void setDatabaseListener(@Nullable DatabaseHelperListener helperListener) { - } - - @Override - public void onCreate(SQLiteDatabase db) { - baseDatabaseHelper.onCreate(SQLCipherDatabase.from(db)); - } - - @Override - public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { - baseDatabaseHelper.onUpgrade(SQLCipherDatabase.from(db), oldVersion, newVersion); - } - - @Override - public void onOpen(SQLiteDatabase db) { - baseDatabaseHelper.onOpen(SQLCipherDatabase.from(db)); - } - } -} diff --git a/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherOpenHelper.kt b/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherOpenHelper.kt new file mode 100644 index 000000000..3822b17c5 --- /dev/null +++ b/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherOpenHelper.kt @@ -0,0 +1,138 @@ +package com.raizlabs.android.dbflow.sqlcipher + +import android.content.Context + +import com.raizlabs.android.dbflow.config.DatabaseConfig +import com.raizlabs.android.dbflow.config.DatabaseDefinition +import com.raizlabs.android.dbflow.config.FlowManager +import com.raizlabs.android.dbflow.structure.database.BaseDatabaseHelper +import com.raizlabs.android.dbflow.structure.database.DatabaseHelperDelegate +import com.raizlabs.android.dbflow.structure.database.DatabaseHelperListener +import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.structure.database.OpenHelper + +import net.sqlcipher.database.SQLiteDatabase +import net.sqlcipher.database.SQLiteOpenHelper + +/** + * Description: The replacement [OpenHelper] for SQLCipher. Specify a subclass of this is [DatabaseConfig.getDatabaseClass] + * of your database to get it to work with specifying the secret you use for the databaseForTable. + */ +abstract class SQLCipherOpenHelper(databaseDefinition: DatabaseDefinition, listener: DatabaseHelperListener?) + : SQLiteOpenHelper(FlowManager.context, if (databaseDefinition.isInMemory) null else databaseDefinition.databaseFileName, null, databaseDefinition.databaseVersion), OpenHelper { + + final override val delegate: DatabaseHelperDelegate + private var cipherDatabase: SQLCipherDatabase? = null + + override val isDatabaseIntegrityOk: Boolean + get() = delegate.isDatabaseIntegrityOk + + override val database: DatabaseWrapper + get() { + if (cipherDatabase == null || !cipherDatabase!!.database.isOpen) { + cipherDatabase = SQLCipherDatabase.from(getWritableDatabase(cipherSecret)) + } + return cipherDatabase!! + } + + /** + * @return The SQLCipher secret for opening this database. + */ + protected abstract val cipherSecret: String + + init { + SQLiteDatabase.loadLibs(FlowManager.context) + + var backupHelper: OpenHelper? = null + if (databaseDefinition.backupEnabled()) { + // Temp database mirrors existing + backupHelper = BackupHelper(FlowManager.context, + DatabaseHelperDelegate.getTempDbFileName(databaseDefinition), + databaseDefinition.databaseVersion, databaseDefinition) + } + + delegate = DatabaseHelperDelegate(listener, databaseDefinition, backupHelper) + } + + override fun performRestoreFromBackup() { + delegate.performRestoreFromBackup() + } + + override fun backupDB() { + delegate.backupDB() + } + + /** + * Set a listener to listen for specific DB events and perform an action before we execute this classes + * specific methods. + * + * @param helperListener + */ + override fun setDatabaseListener(helperListener: DatabaseHelperListener?) { + delegate.setDatabaseHelperListener(helperListener) + } + + override fun onCreate(db: SQLiteDatabase) { + delegate.onCreate(SQLCipherDatabase.from(db)) + } + + override fun onUpgrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) { + delegate.onUpgrade(SQLCipherDatabase.from(db), oldVersion, newVersion) + } + + override fun onOpen(db: SQLiteDatabase) { + delegate.onOpen(SQLCipherDatabase.from(db)) + } + + override fun closeDB() { + database + cipherDatabase?.database?.close() + } + + /** + * Simple helper to manage backup. + */ + private inner class BackupHelper(context: Context, name: String, version: Int, databaseDefinition: DatabaseDefinition) : SQLiteOpenHelper(context, name, null, version), OpenHelper { + + private var sqlCipherDatabase: SQLCipherDatabase? = null + private val baseDatabaseHelper: BaseDatabaseHelper + + override val database: DatabaseWrapper + get() { + if (sqlCipherDatabase == null) { + sqlCipherDatabase = SQLCipherDatabase.from(getWritableDatabase(cipherSecret)) + } + return sqlCipherDatabase!! + } + + override val delegate: DatabaseHelperDelegate? + get() = null + + override val isDatabaseIntegrityOk: Boolean + get() = false + + init { + this.baseDatabaseHelper = BaseDatabaseHelper(databaseDefinition) + } + + override fun performRestoreFromBackup() {} + + override fun backupDB() {} + + override fun closeDB() {} + + override fun setDatabaseListener(helperListener: DatabaseHelperListener?) {} + + override fun onCreate(db: SQLiteDatabase) { + baseDatabaseHelper.onCreate(SQLCipherDatabase.from(db)) + } + + override fun onUpgrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) { + baseDatabaseHelper.onUpgrade(SQLCipherDatabase.from(db), oldVersion, newVersion) + } + + override fun onOpen(db: SQLiteDatabase) { + baseDatabaseHelper.onOpen(SQLCipherDatabase.from(db)) + } + } +} diff --git a/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherStatement.java b/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherStatement.java deleted file mode 100644 index 6c51130d7..000000000 --- a/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherStatement.java +++ /dev/null @@ -1,85 +0,0 @@ -package com.raizlabs.android.dbflow.sqlcipher; - -import android.support.annotation.Nullable; - -import com.raizlabs.android.dbflow.structure.database.BaseDatabaseStatement; -import com.raizlabs.android.dbflow.structure.database.DatabaseStatement; - -import net.sqlcipher.database.SQLiteStatement; - -/** - * Description: Implements the methods necessary for {@link DatabaseStatement}. Delegates calls to - * the contained {@link SQLiteStatement}. - */ -public class SQLCipherStatement extends BaseDatabaseStatement { - - public static SQLCipherStatement from(SQLiteStatement statement) { - return new SQLCipherStatement(statement); - } - - private final SQLiteStatement statement; - - SQLCipherStatement(SQLiteStatement statement) { - this.statement = statement; - } - - public SQLiteStatement getStatement() { - return statement; - } - - @Override - public long executeUpdateDelete() { - return statement.executeUpdateDelete(); - } - - @Override - public void execute() { - statement.execute(); - } - - @Override - public void close() { - statement.close(); - } - - @Override - public long simpleQueryForLong() { - return statement.simpleQueryForLong(); - } - - @Nullable - @Override - public String simpleQueryForString() { - return statement.simpleQueryForString(); - } - - @Override - public long executeInsert() { - return statement.executeInsert(); - } - - @Override - public void bindString(int index, String s) { - statement.bindString(index, s); - } - - @Override - public void bindNull(int index) { - statement.bindNull(index); - } - - @Override - public void bindLong(int index, long aLong) { - statement.bindLong(index, aLong); - } - - @Override - public void bindDouble(int index, double aDouble) { - statement.bindDouble(index, aDouble); - } - - @Override - public void bindBlob(int index, byte[] bytes) { - statement.bindBlob(index, bytes); - } -} diff --git a/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherStatement.kt b/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherStatement.kt new file mode 100644 index 000000000..f0f47633e --- /dev/null +++ b/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherStatement.kt @@ -0,0 +1,62 @@ +package com.raizlabs.android.dbflow.sqlcipher + +import com.raizlabs.android.dbflow.structure.database.BaseDatabaseStatement +import com.raizlabs.android.dbflow.structure.database.DatabaseStatement + +import net.sqlcipher.database.SQLiteStatement + +/** + * Description: Implements the methods necessary for [DatabaseStatement]. Delegates calls to + * the contained [SQLiteStatement]. + */ +class SQLCipherStatement +internal constructor(val statement: SQLiteStatement) : BaseDatabaseStatement() { + + override fun executeUpdateDelete(): Long = statement.executeUpdateDelete().toLong() + + override fun execute() { + statement.execute() + } + + override fun close() { + statement.close() + } + + override fun simpleQueryForLong(): Long { + return statement.simpleQueryForLong() + } + + override fun simpleQueryForString(): String? { + return statement.simpleQueryForString() + } + + override fun executeInsert(): Long { + return statement.executeInsert() + } + + override fun bindString(index: Int, s: String) { + statement.bindString(index, s) + } + + override fun bindNull(index: Int) { + statement.bindNull(index) + } + + override fun bindLong(index: Int, aLong: Long) { + statement.bindLong(index, aLong) + } + + override fun bindDouble(index: Int, aDouble: Double) { + statement.bindDouble(index, aDouble) + } + + override fun bindBlob(index: Int, bytes: ByteArray) { + statement.bindBlob(index, bytes) + } + + companion object { + + @JvmStatic + fun from(statement: SQLiteStatement): SQLCipherStatement = SQLCipherStatement(statement) + } +} diff --git a/dbflow-tests/src/main/java/com/raizlabs/android/dbflow/sqlcipher/CipherTestObjects.kt b/dbflow-tests/src/main/java/com/raizlabs/android/dbflow/sqlcipher/CipherTestObjects.kt index d0b6c065a..39fa68c8b 100644 --- a/dbflow-tests/src/main/java/com/raizlabs/android/dbflow/sqlcipher/CipherTestObjects.kt +++ b/dbflow-tests/src/main/java/com/raizlabs/android/dbflow/sqlcipher/CipherTestObjects.kt @@ -9,7 +9,7 @@ import com.raizlabs.android.dbflow.structure.database.DatabaseHelperListener class SQLCipherOpenHelperImpl(databaseDefinition: DatabaseDefinition, helperListener: DatabaseHelperListener?) : SQLCipherOpenHelper(databaseDefinition, helperListener) { - override fun getCipherSecret() = "dbflow-rules" + override val cipherSecret get() = "dbflow-rules" } @Table(database = CipherDatabase::class) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseHelperDelegate.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseHelperDelegate.kt index a324b1148..3a1116bc5 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseHelperDelegate.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseHelperDelegate.kt @@ -59,7 +59,7 @@ class DatabaseHelperDelegate( * @param databaseHelperListener Listens for operations the DB and allow you to provide extra * functionality. */ - fun setDatabaseHelperListener(databaseHelperListener: DatabaseHelperListener) { + fun setDatabaseHelperListener(databaseHelperListener: DatabaseHelperListener?) { this.databaseHelperListener = databaseHelperListener } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/FlowSQLiteOpenHelper.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/FlowSQLiteOpenHelper.kt index 3b3e1632d..c08360966 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/FlowSQLiteOpenHelper.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/FlowSQLiteOpenHelper.kt @@ -59,10 +59,10 @@ class FlowSQLiteOpenHelper( * Set a listener to listen for specific DB events and perform an action before we execute this classes * specific methods. * - * @param listener + * @param helperListener */ - override fun setDatabaseListener(listener: DatabaseHelperListener?) { - databaseHelperDelegate.setDatabaseHelperListener(listener!!) + override fun setDatabaseListener(helperListener: DatabaseHelperListener?) { + databaseHelperDelegate.setDatabaseHelperListener(helperListener) } override fun onCreate(db: SQLiteDatabase) { From 2d148b2664af6c9d8ebcddbc770f2d9f642a24da Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sun, 26 Nov 2017 19:06:53 -0500 Subject: [PATCH 080/234] [5.0] remove non-database wrapper methods from adapter classes. --- .../dbflow/rx/structure/RXModelAdapter.kt | 28 ---------- .../dbflow/rx2/structure/RXModelAdapter.kt | 28 ---------- .../dbflow/runtime/DirectNotifierTest.kt | 1 - .../dbflow/runtime/DBBatchSaveQueue.kt | 6 +- .../dbflow/structure/InternalAdapter.kt | 56 ------------------- .../android/dbflow/structure/ModelAdapter.kt | 30 +--------- 6 files changed, 4 insertions(+), 145 deletions(-) diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/structure/RXModelAdapter.kt b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/structure/RXModelAdapter.kt index e0ae3065d..4b738bbb2 100644 --- a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/structure/RXModelAdapter.kt +++ b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/structure/RXModelAdapter.kt @@ -14,64 +14,36 @@ class RXModelAdapter internal constructor(private val modelAdapter: Mod constructor(table: Class) : this(FlowManager.getModelAdapter(table)) - fun save(model: T): Single = Single.fromCallable { modelAdapter.save(model) } - fun save(model: T, databaseWrapper: DatabaseWrapper): Single = Single.fromCallable { modelAdapter.save(model, databaseWrapper) } - fun saveAll(models: Collection): Completable = Completable.fromCallable { - modelAdapter.saveAll(models) - null - } - fun saveAll(models: Collection, databaseWrapper: DatabaseWrapper): Completable = Completable.fromCallable { modelAdapter.saveAll(models, databaseWrapper) null } - fun insert(model: T): Single = Single.fromCallable { modelAdapter.insert(model) } - fun insert(model: T, databaseWrapper: DatabaseWrapper): Single = Single.fromCallable { modelAdapter.insert(model, databaseWrapper) } - fun insertAll(models: Collection): Completable = Completable.fromCallable { - modelAdapter.insertAll(models) - null - } - fun insertAll(models: Collection, databaseWrapper: DatabaseWrapper): Completable = Completable.fromCallable { modelAdapter.insertAll(models, databaseWrapper) null } - fun update(model: T): Single = Single.fromCallable { modelAdapter.update(model) } - fun update(model: T, databaseWrapper: DatabaseWrapper): Single = Single.fromCallable { modelAdapter.update(model, databaseWrapper) } - fun updateAll(models: Collection): Completable = Completable.fromCallable { - modelAdapter.updateAll(models) - null - } - fun updateAll(models: Collection, databaseWrapper: DatabaseWrapper): Completable = Completable.fromCallable { modelAdapter.updateAll(models, databaseWrapper) null } - fun delete(model: T): Single = Single.fromCallable { modelAdapter.delete(model) } - fun delete(model: T, databaseWrapper: DatabaseWrapper): Single = Single.fromCallable { modelAdapter.delete(model, databaseWrapper) } - fun deleteAll(models: Collection): Completable = Completable.fromCallable { - modelAdapter.deleteAll(models) - null - } - fun deleteAll(models: Collection, databaseWrapper: DatabaseWrapper): Completable = Completable.fromCallable { modelAdapter.deleteAll(models, databaseWrapper) diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/structure/RXModelAdapter.kt b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/structure/RXModelAdapter.kt index eca1322f0..41a09846d 100644 --- a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/structure/RXModelAdapter.kt +++ b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/structure/RXModelAdapter.kt @@ -15,64 +15,36 @@ class RXModelAdapter internal constructor(private val modelAdapter: Mod constructor(table: Class) : this(FlowManager.getModelAdapter(table)) - fun save(model: T): Single = Single.fromCallable { modelAdapter.save(model) } - fun save(model: T, databaseWrapper: DatabaseWrapper): Single = Single.fromCallable { modelAdapter.save(model, databaseWrapper) } - fun saveAll(models: Collection): Completable = fromCallable { - modelAdapter.saveAll(models) - null - } - fun saveAll(models: Collection, databaseWrapper: DatabaseWrapper): Completable = fromCallable { modelAdapter.saveAll(models, databaseWrapper) null } - fun insert(model: T): Single = Single.fromCallable { modelAdapter.insert(model) } - fun insert(model: T, databaseWrapper: DatabaseWrapper): Single = Single.fromCallable { modelAdapter.insert(model, databaseWrapper) } - fun insertAll(models: Collection): Completable = fromCallable { - modelAdapter.insertAll(models) - null - } - fun insertAll(models: Collection, databaseWrapper: DatabaseWrapper): Completable = fromCallable { modelAdapter.insertAll(models, databaseWrapper) null } - fun update(model: T): Single = Single.fromCallable { modelAdapter.update(model) } - fun update(model: T, databaseWrapper: DatabaseWrapper): Single = Single.fromCallable { modelAdapter.update(model, databaseWrapper) } - fun updateAll(models: Collection): Completable = fromCallable { - modelAdapter.updateAll(models) - null - } - fun updateAll(models: Collection, databaseWrapper: DatabaseWrapper): Completable = fromCallable { modelAdapter.updateAll(models, databaseWrapper) null } - fun delete(model: T): Single = Single.fromCallable { modelAdapter.delete(model) } - fun delete(model: T, databaseWrapper: DatabaseWrapper): Single = Single.fromCallable { modelAdapter.delete(model, databaseWrapper) } - fun deleteAll(models: Collection): Completable = fromCallable { - modelAdapter.deleteAll(models) - null - } - fun deleteAll(models: Collection, databaseWrapper: DatabaseWrapper): Completable = fromCallable { modelAdapter.deleteAll(models, databaseWrapper) diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/runtime/DirectNotifierTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/runtime/DirectNotifierTest.kt index dd217e3bf..0b1fb45ed 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/runtime/DirectNotifierTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/runtime/DirectNotifierTest.kt @@ -43,7 +43,6 @@ class DirectNotifierTest { FlowManager.init(FlowConfig.Builder(context) .addDatabaseConfig(DatabaseConfig.Builder(TestDatabase::class.java) .transactionManagerCreator(::ImmediateTransactionManager2) - .modelNotifier(DirectModelNotifier.get()) .build()).build()) } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DBBatchSaveQueue.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DBBatchSaveQueue.kt index 319b9d7db..72df9d66f 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DBBatchSaveQueue.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DBBatchSaveQueue.kt @@ -3,7 +3,6 @@ package com.raizlabs.android.dbflow.runtime import android.os.Looper import com.raizlabs.android.dbflow.config.DatabaseDefinition import com.raizlabs.android.dbflow.config.FlowLog -import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.structure.Model import com.raizlabs.android.dbflow.structure.database.transaction.ProcessModelTransaction import com.raizlabs.android.dbflow.structure.database.transaction.Transaction @@ -48,10 +47,7 @@ internal constructor(private val databaseDefinition: DatabaseDefinition) : Threa private var emptyTransactionListener: Runnable? = null private val modelSaver = processModel { model, _ -> - (model as? Model)?.save() ?: if (model != null) { - val modelClass = model.javaClass - FlowManager.getModelAdapter(modelClass).save(model) - } + (model as? Model)?.save(databaseDefinition) ?: model?.save(databaseDefinition) } private val successCallback = transactionSuccess { transaction, result -> successListener?.onSuccess(transaction, result) } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/InternalAdapter.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/InternalAdapter.kt index 361f7535a..d540e4616 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/InternalAdapter.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/InternalAdapter.kt @@ -18,13 +18,6 @@ interface InternalAdapter { */ val tableName: String - /** - * Saves the specified model to the DB. - * - * @param model The model to save/insert/update - */ - fun save(model: TModel): Boolean - /** * Saves the specified model to the DB. * @@ -33,13 +26,6 @@ interface InternalAdapter { */ fun save(model: TModel, databaseWrapper: DatabaseWrapper): Boolean - /** - * Saves a [Collection] of models to the DB. - * - * @param models The [Collection] of models to save. - */ - fun saveAll(models: Collection) - /** * Saves a [Collection] of models to the DB. * @@ -48,13 +34,6 @@ interface InternalAdapter { */ fun saveAll(models: Collection, databaseWrapper: DatabaseWrapper) - /** - * Inserts the specified model into the DB. - * - * @param model The model to insert. - */ - fun insert(model: TModel): Long - /** * Inserts the specified model into the DB. * @@ -63,13 +42,6 @@ interface InternalAdapter { */ fun insert(model: TModel, databaseWrapper: DatabaseWrapper): Long - /** - * Inserts a [Collection] of models into the DB. - * - * @param models The [Collection] of models to save. - */ - fun insertAll(models: Collection) - /** * Inserts a [Collection] of models into the DB. * @@ -78,13 +50,6 @@ interface InternalAdapter { */ fun insertAll(models: Collection, databaseWrapper: DatabaseWrapper) - /** - * Updates the specified model into the DB. - * - * @param model The model to update. - */ - fun update(model: TModel): Boolean - /** * Updates the specified model into the DB. * @@ -93,13 +58,6 @@ interface InternalAdapter { */ fun update(model: TModel, databaseWrapper: DatabaseWrapper): Boolean - /** - * Updates a [Collection] of models in the DB. - * - * @param models The [Collection] of models to save. - */ - fun updateAll(models: Collection) - /** * Updates a [Collection] of models in the DB. * @@ -108,13 +66,6 @@ interface InternalAdapter { */ fun updateAll(models: Collection, databaseWrapper: DatabaseWrapper) - /** - * Deletes the model from the DB - * - * @param model The model to delete - */ - fun delete(model: TModel): Boolean - /** * Deletes the model from the DB * @@ -123,13 +74,6 @@ interface InternalAdapter { */ fun delete(model: TModel, databaseWrapper: DatabaseWrapper): Boolean - /** - * Updates a [Collection] of models in the DB. - * - * @param models The [Collection] of models to save. - */ - fun deleteAll(models: Collection) - /** * Updates a [Collection] of models in the DB. * diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelAdapter.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelAdapter.kt index 844165777..d054aa29b 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelAdapter.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelAdapter.kt @@ -92,9 +92,9 @@ abstract class ModelAdapter(databaseDefinition: DatabaseDefinition) get() = ConflictAction.ABORT init { - if (tableConfig != null && tableConfig!!.modelSaver != null) { - _modelSaver = tableConfig!!.modelSaver - _modelSaver!!.modelAdapter = this + tableConfig?.modelSaver?.let { modelSaver -> + modelSaver.modelAdapter = this + _modelSaver = modelSaver } } @@ -206,47 +206,27 @@ abstract class ModelAdapter(databaseDefinition: DatabaseDefinition) return model } - override fun save(model: T): Boolean = modelSaver.save(model) - override fun save(model: T, databaseWrapper: DatabaseWrapper): Boolean = modelSaver.save(model, databaseWrapper) - override fun saveAll(models: Collection) { - listModelSaver.saveAll(models) - } - override fun saveAll(models: Collection, databaseWrapper: DatabaseWrapper) { listModelSaver.saveAll(models, databaseWrapper) } - override fun insert(model: T): Long = modelSaver.insert(model) - override fun insert(model: T, databaseWrapper: DatabaseWrapper): Long = modelSaver.insert(model, databaseWrapper) - override fun insertAll(models: Collection) { - listModelSaver.insertAll(models) - } - override fun insertAll(models: Collection, databaseWrapper: DatabaseWrapper) { listModelSaver.insertAll(models, databaseWrapper) } - override fun update(model: T): Boolean = modelSaver.update(model) - override fun update(model: T, databaseWrapper: DatabaseWrapper): Boolean = modelSaver.update(model, databaseWrapper) - override fun updateAll(models: Collection) { - listModelSaver.updateAll(models) - } - override fun updateAll(models: Collection, databaseWrapper: DatabaseWrapper) { listModelSaver.updateAll(models, databaseWrapper) } - override fun delete(model: T): Boolean = modelSaver.delete(model) - override fun delete(model: T, databaseWrapper: DatabaseWrapper): Boolean = modelSaver.delete(model, databaseWrapper) @@ -254,10 +234,6 @@ abstract class ModelAdapter(databaseDefinition: DatabaseDefinition) listModelSaver.deleteAll(models, databaseWrapper) } - override fun deleteAll(models: Collection) { - listModelSaver.deleteAll(models) - } - override fun bindToInsertStatement(sqLiteStatement: DatabaseStatement, model: T) { bindToInsertStatement(sqLiteStatement, model, 0) } From 3c3b530ae9f0b91d5e369fd3be9b2b53c2bf7e1a Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sun, 26 Nov 2017 19:09:29 -0500 Subject: [PATCH 081/234] [5.0] remove non-wrapper methods from savers. --- .../sql/saveable/AutoIncrementModelSaver.kt | 2 -- .../dbflow/sql/saveable/ListModelSaver.kt | 20 ------------------ .../android/dbflow/sql/saveable/ModelSaver.kt | 21 ------------------- 3 files changed, 43 deletions(-) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/AutoIncrementModelSaver.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/AutoIncrementModelSaver.kt index d96e02487..cc8a158a4 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/AutoIncrementModelSaver.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/AutoIncrementModelSaver.kt @@ -11,8 +11,6 @@ import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper */ class AutoIncrementModelSaver : ModelSaver() { - @Synchronized override fun insert(model: T): Long = insert(model, writableDatabase) - @Synchronized override fun insert(model: T, wrapper: DatabaseWrapper): Long { val hasAutoIncrement = modelAdapter.hasAutoIncrement(model) val insertStatement = when { diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ListModelSaver.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ListModelSaver.kt index d8728d98b..cd4d245d7 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ListModelSaver.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ListModelSaver.kt @@ -4,11 +4,6 @@ import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper open class ListModelSaver(val modelSaver: ModelSaver) { - @Synchronized - open fun saveAll(tableCollection: Collection) { - saveAll(tableCollection, modelSaver.writableDatabase) - } - @Synchronized open fun saveAll(tableCollection: Collection, wrapper: DatabaseWrapper) { @@ -29,11 +24,6 @@ open class ListModelSaver(val modelSaver: ModelSaver) { } } - @Synchronized - open fun insertAll(tableCollection: Collection) { - insertAll(tableCollection, modelSaver.writableDatabase) - } - @Synchronized open fun insertAll(tableCollection: Collection, wrapper: DatabaseWrapper) { @@ -50,11 +40,6 @@ open class ListModelSaver(val modelSaver: ModelSaver) { } } - @Synchronized - open fun updateAll(tableCollection: Collection) { - updateAll(tableCollection, modelSaver.writableDatabase) - } - @Synchronized open fun updateAll(tableCollection: Collection, wrapper: DatabaseWrapper) { @@ -71,11 +56,6 @@ open class ListModelSaver(val modelSaver: ModelSaver) { } } - @Synchronized - open fun deleteAll(tableCollection: Collection) { - deleteAll(tableCollection, modelSaver.writableDatabase) - } - @Synchronized open fun deleteAll(tableCollection: Collection, wrapper: DatabaseWrapper) { diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ModelSaver.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ModelSaver.kt index 3e8ecefc4..3fbcb4007 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ModelSaver.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ModelSaver.kt @@ -1,9 +1,7 @@ package com.raizlabs.android.dbflow.sql.saveable import android.content.ContentValues - import com.raizlabs.android.dbflow.annotation.ConflictAction -import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.runtime.NotifyDistributor import com.raizlabs.android.dbflow.structure.BaseModel import com.raizlabs.android.dbflow.structure.ModelAdapter @@ -18,15 +16,6 @@ open class ModelSaver { lateinit var modelAdapter: ModelAdapter - val writableDatabase: DatabaseWrapper - get() = FlowManager.getDatabaseForTable(modelAdapter.modelClass).writableDatabase - - @Synchronized - fun save(model: T): Boolean { - return save(model, writableDatabase, modelAdapter.getInsertStatement(), - modelAdapter.getUpdateStatement()) - } - @Synchronized fun save(model: T, wrapper: DatabaseWrapper): Boolean { @@ -57,10 +46,6 @@ open class ModelSaver { return exists } - @Synchronized - fun update(model: T): Boolean = - update(model, writableDatabase, modelAdapter.getUpdateStatement()) - @Synchronized fun update(model: T, wrapper: DatabaseWrapper): Boolean { val updateStatement = modelAdapter.getUpdateStatement(wrapper) @@ -86,9 +71,6 @@ open class ModelSaver { return successful } - @Synchronized open fun insert(model: T): Long = - insert(model, modelAdapter.getInsertStatement(), writableDatabase) - @Synchronized open fun insert(model: T, wrapper: DatabaseWrapper): Long { val insertStatement = modelAdapter.getInsertStatement(wrapper) var result: Long = 0 @@ -114,9 +96,6 @@ open class ModelSaver { return id } - @Synchronized - fun delete(model: T): Boolean = delete(model, modelAdapter.getDeleteStatement(), writableDatabase) - @Synchronized fun delete(model: T, wrapper: DatabaseWrapper): Boolean { val deleteStatement = modelAdapter.getDeleteStatement(wrapper) From e0b3513e934a74e263a7d7f7a15ad8b170c71795 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sun, 26 Nov 2017 19:42:26 -0500 Subject: [PATCH 082/234] [5.0] cleanup modeladapter. replace singleton notifyDistributor with Invoke method on companion. --- .../dbflow/sql/saveable/ListModelSaver.kt | 4 +- .../android/dbflow/sql/saveable/ModelSaver.kt | 12 +-- .../android/dbflow/structure/ModelAdapter.kt | 85 +++---------------- 3 files changed, 19 insertions(+), 82 deletions(-) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ListModelSaver.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ListModelSaver.kt index cd4d245d7..c7cbfb52e 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ListModelSaver.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ListModelSaver.kt @@ -15,9 +15,7 @@ open class ListModelSaver(val modelSaver: ModelSaver) { val statement = modelSaver.modelAdapter.getInsertStatement(wrapper) val updateStatement = modelSaver.modelAdapter.getUpdateStatement(wrapper) try { - for (model in tableCollection) { - modelSaver.save(model, wrapper, statement, updateStatement) - } + tableCollection.forEach { modelSaver.save(it, wrapper, statement, updateStatement) } } finally { statement.close() updateStatement.close() diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ModelSaver.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ModelSaver.kt index 3fbcb4007..d21d2b096 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ModelSaver.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ModelSaver.kt @@ -39,7 +39,7 @@ open class ModelSaver { } if (exists) { - NotifyDistributor.get().notifyModelChanged(model, modelAdapter, BaseModel.Action.SAVE) + NotifyDistributor().notifyModelChanged(model, modelAdapter, BaseModel.Action.SAVE) } // return successful store into db. @@ -66,7 +66,7 @@ open class ModelSaver { modelAdapter.bindToUpdateStatement(databaseStatement, model) val successful = databaseStatement.executeUpdateDelete() != 0L if (successful) { - NotifyDistributor.get().notifyModelChanged(model, modelAdapter, BaseModel.Action.UPDATE) + NotifyDistributor().notifyModelChanged(model, modelAdapter, BaseModel.Action.UPDATE) } return successful } @@ -91,7 +91,7 @@ open class ModelSaver { val id = insertStatement.executeInsert() if (id > INSERT_FAILED) { modelAdapter.updateAutoIncrement(model, id) - NotifyDistributor.get().notifyModelChanged(model, modelAdapter, BaseModel.Action.INSERT) + NotifyDistributor().notifyModelChanged(model, modelAdapter, BaseModel.Action.INSERT) } return id } @@ -118,7 +118,7 @@ open class ModelSaver { val success = deleteStatement.executeUpdateDelete() != 0L if (success) { - NotifyDistributor.get().notifyModelChanged(model, modelAdapter, BaseModel.Action.DELETE) + NotifyDistributor().notifyModelChanged(model, modelAdapter, BaseModel.Action.DELETE) } modelAdapter.updateAutoIncrement(model, 0) return success @@ -146,7 +146,7 @@ open class ModelSaver { } if (exists) { - NotifyDistributor.get().notifyModelChanged(model, modelAdapter, BaseModel.Action.SAVE) + NotifyDistributor().notifyModelChanged(model, modelAdapter, BaseModel.Action.SAVE) } // return successful store into db. @@ -165,7 +165,7 @@ open class ModelSaver { modelAdapter.getPrimaryConditionClause(model).query, null, ConflictAction.getSQLiteDatabaseAlgorithmInt(modelAdapter.updateOnConflictAction)) != 0L if (successful) { - NotifyDistributor.get().notifyModelChanged(model, modelAdapter, BaseModel.Action.UPDATE) + NotifyDistributor().notifyModelChanged(model, modelAdapter, BaseModel.Action.UPDATE) } return successful } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelAdapter.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelAdapter.kt index d054aa29b..a3cbb3d07 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelAdapter.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelAdapter.kt @@ -8,7 +8,6 @@ import com.raizlabs.android.dbflow.annotation.ForeignKey import com.raizlabs.android.dbflow.annotation.PrimaryKey import com.raizlabs.android.dbflow.annotation.Table import com.raizlabs.android.dbflow.config.DatabaseDefinition -import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.sql.language.property.IProperty import com.raizlabs.android.dbflow.sql.language.property.Property import com.raizlabs.android.dbflow.sql.saveable.ListModelSaver @@ -42,9 +41,9 @@ abstract class ModelAdapter(databaseDefinition: DatabaseDefinition) * if it has the field. This method is overridden when its specified for the [T] */ open val autoIncrementingColumnName: String - get() = throw InvalidDBConfiguration( - String.format("This method may have been called in error. The model class %1s must contain " + "an autoincrementing or single int/long primary key (if used in a ModelCache, this method may be called)", - modelClass)) + get() = throw InvalidDBConfiguration("This method may have been called in error." + + " The model class $modelClass must contain an autoincrementing" + + " or single int/long primary key (if used in a ModelCache, this method may be called)") open val cacheSize: Int get() = DEFAULT_CACHE_SIZE @@ -98,39 +97,6 @@ abstract class ModelAdapter(databaseDefinition: DatabaseDefinition) } } - /** - * @return The pre-compiled insert statement for this table model adapter. This is reused and cached. - */ - fun getInsertStatement(): DatabaseStatement { - if (insertStatement == null) { - insertStatement = getInsertStatement(FlowManager.getDatabaseForTable(modelClass)) - } - - return insertStatement!! - } - - /** - * @return The pre-compiled update statement for this table model adapter. This is reused and cached. - */ - fun getUpdateStatement(): DatabaseStatement { - if (updateStatement == null) { - updateStatement = getUpdateStatement(FlowManager.getDatabaseForTable(modelClass)) - } - - return updateStatement!! - } - - /** - * @return The pre-compiled delete statement for this table model adapter. This is reused and cached. - */ - fun getDeleteStatement(): DatabaseStatement { - if (deleteStatement == null) { - deleteStatement = getDeleteStatement(FlowManager.getDatabaseForTable(modelClass)) - } - - return deleteStatement!! - } - fun closeInsertStatement() { insertStatement?.close() insertStatement = null @@ -170,17 +136,6 @@ abstract class ModelAdapter(databaseDefinition: DatabaseDefinition) fun getDeleteStatement(databaseWrapper: DatabaseWrapper): DatabaseStatement = databaseWrapper.compileStatement(deleteStatementQuery) - /** - * @return The precompiled full statement for this table model adapter - */ - fun getCompiledStatement(): DatabaseStatement { - if (compiledStatement == null) { - compiledStatement = getCompiledStatement(FlowManager.getDatabaseForTable(modelClass)) - } - - return compiledStatement!! - } - fun closeCompiledStatement() { compiledStatement?.close() compiledStatement = null @@ -200,11 +155,8 @@ abstract class ModelAdapter(databaseDefinition: DatabaseDefinition) * @param cursor The cursor to load * @return A new [T] */ - fun loadFromCursor(cursor: FlowCursor, databaseWrapper: DatabaseWrapper): T { - val model = newInstance() - loadFromCursor(cursor, model, databaseWrapper) - return model - } + fun loadFromCursor(cursor: FlowCursor, databaseWrapper: DatabaseWrapper): T = + newInstance().apply { loadFromCursor(cursor, this, databaseWrapper) } override fun save(model: T, databaseWrapper: DatabaseWrapper): Boolean = modelSaver.save(model, databaseWrapper) @@ -262,9 +214,7 @@ abstract class ModelAdapter(databaseDefinition: DatabaseDefinition) * if it has the field. This method is overridden when its specified for the [T] */ override fun getAutoIncrementingId(model: T): Number? { - throw InvalidDBConfiguration( - String.format("This method may have been called in error. The model class %1s must contain" + "a single primary key (if used in a ModelCache, this method may be called)", - modelClass)) + throwCachingError() } fun hasAutoIncrement(model: T): Boolean { @@ -305,7 +255,6 @@ abstract class ModelAdapter(databaseDefinition: DatabaseDefinition) open fun getCachingColumnValuesFromCursor(inValues: Array, cursor: FlowCursor): Array? { throwCachingError() - return null } /** @@ -313,8 +262,7 @@ abstract class ModelAdapter(databaseDefinition: DatabaseDefinition) * @return The single cache column from cursor (if single). */ open fun getCachingColumnValueFromCursor(cursor: FlowCursor): Any? { - throwSingleCachingError() - return null + throwCachingError() } /** @@ -328,7 +276,6 @@ abstract class ModelAdapter(databaseDefinition: DatabaseDefinition) */ open fun getCachingColumnValuesFromModel(inValues: Array, TModel: T): Array? { throwCachingError() - return null } /** @@ -336,8 +283,7 @@ abstract class ModelAdapter(databaseDefinition: DatabaseDefinition) * @return The single cache column from model (if single). */ open fun getCachingColumnValueFromModel(model: T): Any? { - throwSingleCachingError() - return null + throwCachingError() } fun storeModelInCache(model: T) { @@ -405,16 +351,9 @@ abstract class ModelAdapter(databaseDefinition: DatabaseDefinition) */ open fun createWithDatabase(): Boolean = true - private fun throwCachingError() { - throw InvalidDBConfiguration( - String.format("This method may have been called in error. The model class %1s must contain" + "an auto-incrementing or at least one primary key (if used in a ModelCache, this method may be called)", - modelClass)) - } - - private fun throwSingleCachingError() { - throw InvalidDBConfiguration( - String.format("This method may have been called in error. The model class %1s must contain" + "an auto-incrementing or one primary key (if used in a ModelCache, this method may be called)", - modelClass)) - } + private fun throwCachingError(): Nothing = throw InvalidDBConfiguration("This method may have been called in error. " + + "The model class $modelClass must contain an auto-incrementing " + + "or at least one primary key (if used in a ModelCache, " + + "this method may be called)") } From e1d5565992747936d891f0c0d0a2077ff0c36be1 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sun, 26 Nov 2017 19:47:01 -0500 Subject: [PATCH 083/234] [5.0] more kotlin syntax on modelsaver. --- .../android/dbflow/sql/saveable/ModelSaver.kt | 26 +++++++------------ 1 file changed, 9 insertions(+), 17 deletions(-) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ModelSaver.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ModelSaver.kt index d21d2b096..2f9a57f30 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ModelSaver.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ModelSaver.kt @@ -17,11 +17,9 @@ open class ModelSaver { lateinit var modelAdapter: ModelAdapter @Synchronized - fun save(model: T, - wrapper: DatabaseWrapper): Boolean { - return save(model, wrapper, modelAdapter.getInsertStatement(wrapper), - modelAdapter.getUpdateStatement(wrapper)) - } + fun save(model: T, wrapper: DatabaseWrapper): Boolean = + save(model, wrapper, modelAdapter.getInsertStatement(wrapper), + modelAdapter.getUpdateStatement(wrapper)) @Synchronized fun save(model: T, @@ -49,14 +47,12 @@ open class ModelSaver { @Synchronized fun update(model: T, wrapper: DatabaseWrapper): Boolean { val updateStatement = modelAdapter.getUpdateStatement(wrapper) - val success: Boolean - try { - success = update(model, wrapper, updateStatement) + return try { + update(model, wrapper, updateStatement) } finally { // since we generate an insert every time, we can safely close the statement here. updateStatement.close() } - return success } @Synchronized @@ -73,14 +69,12 @@ open class ModelSaver { @Synchronized open fun insert(model: T, wrapper: DatabaseWrapper): Long { val insertStatement = modelAdapter.getInsertStatement(wrapper) - var result: Long = 0 - try { - result = insert(model, insertStatement, wrapper) + return try { + insert(model, insertStatement, wrapper) } finally { // since we generate an insert every time, we can safely close the statement here. insertStatement.close() } - return result } @Synchronized open fun insert(model: T, @@ -99,14 +93,12 @@ open class ModelSaver { @Synchronized fun delete(model: T, wrapper: DatabaseWrapper): Boolean { val deleteStatement = modelAdapter.getDeleteStatement(wrapper) - var success = false - try { - success = delete(model, deleteStatement, wrapper) + return try { + delete(model, deleteStatement, wrapper) } finally { // since we generate an insert every time, we can safely close the statement here. deleteStatement.close() } - return success } @Synchronized From a9d1a4d10a40738c5670ec78d8794ac01b151dd2 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sun, 26 Nov 2017 19:48:43 -0500 Subject: [PATCH 084/234] [5.0] remove deprecated methods from modelsaver. --- .../android/dbflow/sql/saveable/ModelSaver.kt | 47 ------------------- 1 file changed, 47 deletions(-) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ModelSaver.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ModelSaver.kt index 2f9a57f30..082792478 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ModelSaver.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ModelSaver.kt @@ -1,7 +1,6 @@ package com.raizlabs.android.dbflow.sql.saveable import android.content.ContentValues -import com.raizlabs.android.dbflow.annotation.ConflictAction import com.raizlabs.android.dbflow.runtime.NotifyDistributor import com.raizlabs.android.dbflow.structure.BaseModel import com.raizlabs.android.dbflow.structure.ModelAdapter @@ -116,52 +115,6 @@ open class ModelSaver { return success } - /** - * Legacy save method. Uses [ContentValues] vs. the faster [DatabaseStatement] for updates. - * - * @see .save - */ - @Deprecated("") - @Synchronized - fun save(model: T, - wrapper: DatabaseWrapper, - insertStatement: DatabaseStatement, - contentValues: ContentValues): Boolean { - var exists = modelAdapter.exists(model, wrapper) - - if (exists) { - exists = update(model, wrapper, contentValues) - } - - if (!exists) { - exists = insert(model, insertStatement, wrapper) > INSERT_FAILED - } - - if (exists) { - NotifyDistributor().notifyModelChanged(model, modelAdapter, BaseModel.Action.SAVE) - } - - // return successful store into db. - return exists - } - - /** - * @see .update - */ - @Deprecated("") - @Synchronized - fun update(model: T, wrapper: DatabaseWrapper, contentValues: ContentValues): Boolean { - modelAdapter.saveForeignKeys(model, wrapper) - modelAdapter.bindToContentValues(contentValues, model) - val successful = wrapper.updateWithOnConflict(modelAdapter.tableName, contentValues, - modelAdapter.getPrimaryConditionClause(model).query, null, - ConflictAction.getSQLiteDatabaseAlgorithmInt(modelAdapter.updateOnConflictAction)) != 0L - if (successful) { - NotifyDistributor().notifyModelChanged(model, modelAdapter, BaseModel.Action.UPDATE) - } - return successful - } - companion object { val INSERT_FAILED = -1 From 6607db1ee6a8321e642ed2d608835d4e73ceb9d5 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sun, 26 Nov 2017 21:14:09 -0500 Subject: [PATCH 085/234] [5.0] update gradle plugin, drastically simplify logic for model saver via inline methods. --- build.gradle | 2 +- dbflow-core/build.gradle | 2 +- dbflow/build.gradle | 1 + .../sql/saveable/CacheableListModelSaver.kt | 74 +++++++++---------- .../dbflow/sql/saveable/ListModelSaver.kt | 54 +++++++------- .../android/dbflow/sql/saveable/ModelSaver.kt | 7 +- 6 files changed, 66 insertions(+), 74 deletions(-) diff --git a/build.gradle b/build.gradle index 1a47b29b4..9e583f603 100644 --- a/build.gradle +++ b/build.gradle @@ -5,7 +5,7 @@ buildscript { google() } dependencies { - classpath 'com.android.tools.build:gradle:3.0.0' + classpath 'com.android.tools.build:gradle:3.0.1' classpath 'com.github.dcendents:android-maven-gradle-plugin:1.5' classpath 'com.getkeepsafe.dexcount:dexcount-gradle-plugin:0.7.3' classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version" diff --git a/dbflow-core/build.gradle b/dbflow-core/build.gradle index c113e4469..6be3673bd 100644 --- a/dbflow-core/build.gradle +++ b/dbflow-core/build.gradle @@ -14,6 +14,6 @@ apply from: '../java-artifacts.gradle' compileKotlin { kotlinOptions { - jvmTarget = "1.6" + apiVersion = "1.1" } } \ No newline at end of file diff --git a/dbflow/build.gradle b/dbflow/build.gradle index 5ce0e0ad1..6875164d2 100644 --- a/dbflow/build.gradle +++ b/dbflow/build.gradle @@ -38,3 +38,4 @@ kotlin { } apply from: '../android-artifacts.gradle' + diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/CacheableListModelSaver.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/CacheableListModelSaver.kt index 633f61fdf..7e5f1badb 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/CacheableListModelSaver.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/CacheableListModelSaver.kt @@ -1,5 +1,6 @@ package com.raizlabs.android.dbflow.sql.saveable +import com.raizlabs.android.dbflow.structure.database.DatabaseStatement import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper /** @@ -31,58 +32,51 @@ class CacheableListModelSaver(modelSaver: ModelSaver) : ListModelSav } @Synchronized override fun insertAll(tableCollection: Collection, - wrapper: DatabaseWrapper) { - // skip if empty. - if (tableCollection.isEmpty()) { - return - } - - val modelSaver = modelSaver - val modelAdapter = modelSaver.modelAdapter - val statement = modelAdapter.getInsertStatement(wrapper) - try { - for (model in tableCollection) { - if (modelSaver.insert(model, statement, wrapper) > 0) { - modelAdapter.storeModelInCache(model) - } - } - } finally { - statement.close() + wrapper: DatabaseWrapper): Long { + return applyAndCount(tableCollection, wrapper, + modelSaver.modelAdapter.getInsertStatement(wrapper), + modelSaver.modelAdapter::storeModelInCache) { model, statement, databaseWrapper -> + modelSaver.insert(model, statement, databaseWrapper) > 0 } } @Synchronized override fun updateAll(tableCollection: Collection, - wrapper: DatabaseWrapper) { - // skip if empty. - if (tableCollection.isEmpty()) { - return - } - val modelSaver = modelSaver - val modelAdapter = modelSaver.modelAdapter - val statement = modelAdapter.getUpdateStatement(wrapper) - try { - for (model in tableCollection) { - if (modelSaver.update(model, wrapper, statement)) { - modelAdapter.storeModelInCache(model) - } - } - } finally { - statement.close() - } + wrapper: DatabaseWrapper): Long { + return applyAndCount(tableCollection, wrapper, + modelSaver.modelAdapter.getUpdateStatement(wrapper), + modelSaver.modelAdapter::storeModelInCache, + modelSaver::update) } @Synchronized override fun deleteAll(tableCollection: Collection, - wrapper: DatabaseWrapper) { + wrapper: DatabaseWrapper): Long { + return applyAndCount(tableCollection, wrapper, + modelSaver.modelAdapter.getDeleteStatement(wrapper), + modelSaver.modelAdapter::removeModelFromCache, + modelSaver::delete) + } + + private inline fun applyAndCount(tableCollection: Collection, + wrapper: DatabaseWrapper, + databaseStatement: DatabaseStatement, + crossinline cacheFn: (T) -> Unit, + crossinline fn: (T, DatabaseStatement, DatabaseWrapper) -> Boolean): Long { // skip if empty. if (tableCollection.isEmpty()) { - return + return 0L } - val modelSaver = modelSaver - for (model in tableCollection) { - if (modelSaver.delete(model, wrapper)) { - modelSaver.modelAdapter.removeModelFromCache(model) + var count = 0L + try { + tableCollection.forEach { + if (fn(it, databaseStatement, wrapper)) { + cacheFn(it) + count++ + } } + } finally { + databaseStatement.close() } + return count } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ListModelSaver.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ListModelSaver.kt index c7cbfb52e..397893000 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ListModelSaver.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ListModelSaver.kt @@ -1,5 +1,6 @@ package com.raizlabs.android.dbflow.sql.saveable +import com.raizlabs.android.dbflow.structure.database.DatabaseStatement import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper open class ListModelSaver(val modelSaver: ModelSaver) { @@ -24,49 +25,46 @@ open class ListModelSaver(val modelSaver: ModelSaver) { @Synchronized open fun insertAll(tableCollection: Collection, - wrapper: DatabaseWrapper) { - // skip if empty. - if (tableCollection.isEmpty()) { - return - } - - val statement = modelSaver.modelAdapter.getInsertStatement(wrapper) - try { - tableCollection.forEach { modelSaver.insert(it, statement, wrapper) } - } finally { - statement.close() + wrapper: DatabaseWrapper): Long { + return applyAndCount(tableCollection, wrapper, + modelSaver.modelAdapter.getInsertStatement(wrapper)) { model, statement, databaseWrapper -> + modelSaver.insert(model, statement, databaseWrapper) > 0 } } @Synchronized open fun updateAll(tableCollection: Collection, - wrapper: DatabaseWrapper) { - // skip if empty. - if (tableCollection.isEmpty()) { - return - } - - val updateStatement = modelSaver.modelAdapter.getUpdateStatement(wrapper) - try { - tableCollection.forEach { modelSaver.update(it, wrapper, updateStatement) } - } finally { - updateStatement.close() - } + wrapper: DatabaseWrapper): Long { + return applyAndCount(tableCollection, wrapper, + modelSaver.modelAdapter.getUpdateStatement(wrapper), modelSaver::update) } @Synchronized open fun deleteAll(tableCollection: Collection, - wrapper: DatabaseWrapper) { + wrapper: DatabaseWrapper): Long { + return applyAndCount(tableCollection, wrapper, + modelSaver.modelAdapter.getDeleteStatement(wrapper), modelSaver::delete) + } + + private inline fun applyAndCount(tableCollection: Collection, + wrapper: DatabaseWrapper, + databaseStatement: DatabaseStatement, + crossinline fn: (T, DatabaseStatement, DatabaseWrapper) -> Boolean): Long { // skip if empty. if (tableCollection.isEmpty()) { - return + return 0L } - val deleteStatement = modelSaver.modelAdapter.getDeleteStatement(wrapper) + var count = 0L try { - tableCollection.forEach { modelSaver.delete(it, deleteStatement, wrapper) } + tableCollection.forEach { + if (fn(it, databaseStatement, wrapper)) { + count++ + } + } } finally { - deleteStatement.close() + databaseStatement.close() } + return count } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ModelSaver.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ModelSaver.kt index 082792478..aff85788a 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ModelSaver.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ModelSaver.kt @@ -28,7 +28,7 @@ open class ModelSaver { var exists = modelAdapter.exists(model, wrapper) if (exists) { - exists = update(model, wrapper, updateStatement) + exists = update(model, updateStatement, wrapper) } if (!exists) { @@ -47,7 +47,7 @@ open class ModelSaver { fun update(model: T, wrapper: DatabaseWrapper): Boolean { val updateStatement = modelAdapter.getUpdateStatement(wrapper) return try { - update(model, wrapper, updateStatement) + update(model, updateStatement, wrapper) } finally { // since we generate an insert every time, we can safely close the statement here. updateStatement.close() @@ -55,8 +55,7 @@ open class ModelSaver { } @Synchronized - fun update(model: T, wrapper: DatabaseWrapper, - databaseStatement: DatabaseStatement): Boolean { + fun update(model: T, databaseStatement: DatabaseStatement, wrapper: DatabaseWrapper): Boolean { modelAdapter.saveForeignKeys(model, wrapper) modelAdapter.bindToUpdateStatement(databaseStatement, model) val successful = databaseStatement.executeUpdateDelete() != 0L From 2eec6c403fe7a7be90784882e390d8b6e2305192 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sun, 26 Nov 2017 21:25:41 -0500 Subject: [PATCH 086/234] [5.0] model adapter methods now return values for multiple objects operated on. --- .../sql/saveable/CacheableListModelSaver.kt | 53 ++++++++----------- .../dbflow/sql/saveable/ListModelSaver.kt | 32 +++++------ .../android/dbflow/sql/saveable/ModelSaver.kt | 8 +-- .../dbflow/structure/InternalAdapter.kt | 12 +++-- .../android/dbflow/structure/ModelAdapter.kt | 20 +++---- 5 files changed, 55 insertions(+), 70 deletions(-) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/CacheableListModelSaver.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/CacheableListModelSaver.kt index 7e5f1badb..54d5a74c8 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/CacheableListModelSaver.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/CacheableListModelSaver.kt @@ -9,58 +9,48 @@ import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper class CacheableListModelSaver(modelSaver: ModelSaver) : ListModelSaver(modelSaver) { @Synchronized override fun saveAll(tableCollection: Collection, - wrapper: DatabaseWrapper) { - // skip if empty. - if (tableCollection.isEmpty()) { - return - } - - val modelSaver = modelSaver + wrapper: DatabaseWrapper): Long { val modelAdapter = modelSaver.modelAdapter val statement = modelAdapter.getInsertStatement(wrapper) val updateStatement = modelAdapter.getUpdateStatement(wrapper) - try { - for (model in tableCollection) { - if (modelSaver.save(model, wrapper, statement, updateStatement)) { - modelAdapter.storeModelInCache(model) - } - } - } finally { - updateStatement.close() - statement.close() + return applyAndCount(tableCollection, statement, updateStatement, + modelSaver.modelAdapter::storeModelInCache) { + modelSaver.save(it, statement, updateStatement, wrapper) } } @Synchronized override fun insertAll(tableCollection: Collection, wrapper: DatabaseWrapper): Long { - return applyAndCount(tableCollection, wrapper, - modelSaver.modelAdapter.getInsertStatement(wrapper), - modelSaver.modelAdapter::storeModelInCache) { model, statement, databaseWrapper -> - modelSaver.insert(model, statement, databaseWrapper) > 0 + val statement = modelSaver.modelAdapter.getInsertStatement(wrapper) + return applyAndCount(tableCollection, statement, + cacheFn = modelSaver.modelAdapter::storeModelInCache) { + modelSaver.insert(it, statement, wrapper) > 0 } } @Synchronized override fun updateAll(tableCollection: Collection, wrapper: DatabaseWrapper): Long { - return applyAndCount(tableCollection, wrapper, - modelSaver.modelAdapter.getUpdateStatement(wrapper), - modelSaver.modelAdapter::storeModelInCache, - modelSaver::update) + val statement = modelSaver.modelAdapter.getUpdateStatement(wrapper) + return applyAndCount(tableCollection, statement, + cacheFn = modelSaver.modelAdapter::storeModelInCache) { + modelSaver.update(it, statement, wrapper) + } } @Synchronized override fun deleteAll(tableCollection: Collection, wrapper: DatabaseWrapper): Long { - return applyAndCount(tableCollection, wrapper, - modelSaver.modelAdapter.getDeleteStatement(wrapper), - modelSaver.modelAdapter::removeModelFromCache, - modelSaver::delete) + val statement = modelSaver.modelAdapter.getDeleteStatement(wrapper) + return applyAndCount(tableCollection, statement, + cacheFn = modelSaver.modelAdapter::removeModelFromCache) { + modelSaver.delete(it, statement, wrapper) + } } private inline fun applyAndCount(tableCollection: Collection, - wrapper: DatabaseWrapper, databaseStatement: DatabaseStatement, + otherStatement: DatabaseStatement? = null, crossinline cacheFn: (T) -> Unit, - crossinline fn: (T, DatabaseStatement, DatabaseWrapper) -> Boolean): Long { + crossinline fn: (T) -> Boolean): Long { // skip if empty. if (tableCollection.isEmpty()) { return 0L @@ -69,13 +59,14 @@ class CacheableListModelSaver(modelSaver: ModelSaver) : ListModelSav var count = 0L try { tableCollection.forEach { - if (fn(it, databaseStatement, wrapper)) { + if (fn(it)) { cacheFn(it) count++ } } } finally { databaseStatement.close() + otherStatement?.close() } return count } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ListModelSaver.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ListModelSaver.kt index 397893000..f66738200 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ListModelSaver.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ListModelSaver.kt @@ -7,49 +7,42 @@ open class ListModelSaver(val modelSaver: ModelSaver) { @Synchronized open fun saveAll(tableCollection: Collection, - wrapper: DatabaseWrapper) { + wrapper: DatabaseWrapper): Long { // skip if empty. if (tableCollection.isEmpty()) { - return + return 0L } val statement = modelSaver.modelAdapter.getInsertStatement(wrapper) val updateStatement = modelSaver.modelAdapter.getUpdateStatement(wrapper) - try { - tableCollection.forEach { modelSaver.save(it, wrapper, statement, updateStatement) } - } finally { - statement.close() - updateStatement.close() - } + return applyAndCount(tableCollection, statement, updateStatement) { modelSaver.save(it, statement, updateStatement, wrapper) } } @Synchronized open fun insertAll(tableCollection: Collection, wrapper: DatabaseWrapper): Long { - return applyAndCount(tableCollection, wrapper, - modelSaver.modelAdapter.getInsertStatement(wrapper)) { model, statement, databaseWrapper -> - modelSaver.insert(model, statement, databaseWrapper) > 0 - } + val statement = modelSaver.modelAdapter.getInsertStatement(wrapper) + return applyAndCount(tableCollection, statement) { modelSaver.insert(it, statement, wrapper) > 0 } } @Synchronized open fun updateAll(tableCollection: Collection, wrapper: DatabaseWrapper): Long { - return applyAndCount(tableCollection, wrapper, - modelSaver.modelAdapter.getUpdateStatement(wrapper), modelSaver::update) + val statement = modelSaver.modelAdapter.getUpdateStatement(wrapper) + return applyAndCount(tableCollection, statement) { modelSaver.update(it, statement, wrapper) } } @Synchronized open fun deleteAll(tableCollection: Collection, wrapper: DatabaseWrapper): Long { - return applyAndCount(tableCollection, wrapper, - modelSaver.modelAdapter.getDeleteStatement(wrapper), modelSaver::delete) + val statement = modelSaver.modelAdapter.getDeleteStatement(wrapper) + return applyAndCount(tableCollection, statement) { modelSaver.delete(it, statement, wrapper) } } private inline fun applyAndCount(tableCollection: Collection, - wrapper: DatabaseWrapper, databaseStatement: DatabaseStatement, - crossinline fn: (T, DatabaseStatement, DatabaseWrapper) -> Boolean): Long { + otherStatement: DatabaseStatement? = null, + crossinline fn: (T) -> Boolean): Long { // skip if empty. if (tableCollection.isEmpty()) { return 0L @@ -58,12 +51,13 @@ open class ListModelSaver(val modelSaver: ModelSaver) { var count = 0L try { tableCollection.forEach { - if (fn(it, databaseStatement, wrapper)) { + if (fn(it)) { count++ } } } finally { databaseStatement.close() + otherStatement?.close() } return count } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ModelSaver.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ModelSaver.kt index aff85788a..1e696a1f8 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ModelSaver.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ModelSaver.kt @@ -17,14 +17,14 @@ open class ModelSaver { @Synchronized fun save(model: T, wrapper: DatabaseWrapper): Boolean = - save(model, wrapper, modelAdapter.getInsertStatement(wrapper), - modelAdapter.getUpdateStatement(wrapper)) + save(model, modelAdapter.getInsertStatement(wrapper), + modelAdapter.getUpdateStatement(wrapper), wrapper) @Synchronized fun save(model: T, - wrapper: DatabaseWrapper, insertStatement: DatabaseStatement, - updateStatement: DatabaseStatement): Boolean { + updateStatement: DatabaseStatement, + wrapper: DatabaseWrapper): Boolean { var exists = modelAdapter.exists(model, wrapper) if (exists) { diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/InternalAdapter.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/InternalAdapter.kt index d540e4616..969af644b 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/InternalAdapter.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/InternalAdapter.kt @@ -31,8 +31,9 @@ interface InternalAdapter { * * @param models The [Collection] of models to save. * @param databaseWrapper The manually specified wrapper + * @return the count of models saved or updated. */ - fun saveAll(models: Collection, databaseWrapper: DatabaseWrapper) + fun saveAll(models: Collection, databaseWrapper: DatabaseWrapper): Long /** * Inserts the specified model into the DB. @@ -47,8 +48,9 @@ interface InternalAdapter { * * @param models The [Collection] of models to save. * @param databaseWrapper The manually specified wrapper + * @return the count inserted */ - fun insertAll(models: Collection, databaseWrapper: DatabaseWrapper) + fun insertAll(models: Collection, databaseWrapper: DatabaseWrapper): Long /** * Updates the specified model into the DB. @@ -63,8 +65,9 @@ interface InternalAdapter { * * @param models The [Collection] of models to save. * @param databaseWrapper The manually specified wrapper + * @return count of successful updates. */ - fun updateAll(models: Collection, databaseWrapper: DatabaseWrapper) + fun updateAll(models: Collection, databaseWrapper: DatabaseWrapper): Long /** * Deletes the model from the DB @@ -79,8 +82,9 @@ interface InternalAdapter { * * @param models The [Collection] of models to save. * @param databaseWrapper The manually specified wrapper + * @return count of successful deletions. */ - fun deleteAll(models: Collection, databaseWrapper: DatabaseWrapper) + fun deleteAll(models: Collection, databaseWrapper: DatabaseWrapper): Long /** * Binds a [TModel] to the specified db statement diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelAdapter.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelAdapter.kt index a3cbb3d07..3574362de 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelAdapter.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelAdapter.kt @@ -161,30 +161,26 @@ abstract class ModelAdapter(databaseDefinition: DatabaseDefinition) override fun save(model: T, databaseWrapper: DatabaseWrapper): Boolean = modelSaver.save(model, databaseWrapper) - override fun saveAll(models: Collection, databaseWrapper: DatabaseWrapper) { - listModelSaver.saveAll(models, databaseWrapper) - } + override fun saveAll(models: Collection, databaseWrapper: DatabaseWrapper): Long + = listModelSaver.saveAll(models, databaseWrapper) override fun insert(model: T, databaseWrapper: DatabaseWrapper): Long = modelSaver.insert(model, databaseWrapper) - override fun insertAll(models: Collection, databaseWrapper: DatabaseWrapper) { - listModelSaver.insertAll(models, databaseWrapper) - } + override fun insertAll(models: Collection, databaseWrapper: DatabaseWrapper): Long + = listModelSaver.insertAll(models, databaseWrapper) override fun update(model: T, databaseWrapper: DatabaseWrapper): Boolean = modelSaver.update(model, databaseWrapper) - override fun updateAll(models: Collection, databaseWrapper: DatabaseWrapper) { - listModelSaver.updateAll(models, databaseWrapper) - } + override fun updateAll(models: Collection, databaseWrapper: DatabaseWrapper): Long + = listModelSaver.updateAll(models, databaseWrapper) override fun delete(model: T, databaseWrapper: DatabaseWrapper): Boolean = modelSaver.delete(model, databaseWrapper) - override fun deleteAll(models: Collection, databaseWrapper: DatabaseWrapper) { - listModelSaver.deleteAll(models, databaseWrapper) - } + override fun deleteAll(models: Collection, databaseWrapper: DatabaseWrapper): Long + = listModelSaver.deleteAll(models, databaseWrapper) override fun bindToInsertStatement(sqLiteStatement: DatabaseStatement, model: T) { bindToInsertStatement(sqLiteStatement, model, 0) From 80b0b8ac1e4d5f6ee0c5232d2fb78efa8abbbca4 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sun, 26 Nov 2017 21:27:56 -0500 Subject: [PATCH 087/234] [5.0] cache modeladapter in modelsaver. --- .../sql/saveable/CacheableListModelSaver.kt | 16 +++++++--------- .../dbflow/sql/saveable/ListModelSaver.kt | 19 +++++++++---------- 2 files changed, 16 insertions(+), 19 deletions(-) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/CacheableListModelSaver.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/CacheableListModelSaver.kt index 54d5a74c8..01f3d82f5 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/CacheableListModelSaver.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/CacheableListModelSaver.kt @@ -10,38 +10,36 @@ class CacheableListModelSaver(modelSaver: ModelSaver) : ListModelSav @Synchronized override fun saveAll(tableCollection: Collection, wrapper: DatabaseWrapper): Long { - val modelAdapter = modelSaver.modelAdapter val statement = modelAdapter.getInsertStatement(wrapper) val updateStatement = modelAdapter.getUpdateStatement(wrapper) - return applyAndCount(tableCollection, statement, updateStatement, - modelSaver.modelAdapter::storeModelInCache) { + return applyAndCount(tableCollection, statement, updateStatement, modelAdapter::storeModelInCache) { modelSaver.save(it, statement, updateStatement, wrapper) } } @Synchronized override fun insertAll(tableCollection: Collection, wrapper: DatabaseWrapper): Long { - val statement = modelSaver.modelAdapter.getInsertStatement(wrapper) + val statement = modelAdapter.getInsertStatement(wrapper) return applyAndCount(tableCollection, statement, - cacheFn = modelSaver.modelAdapter::storeModelInCache) { + cacheFn = modelAdapter::storeModelInCache) { modelSaver.insert(it, statement, wrapper) > 0 } } @Synchronized override fun updateAll(tableCollection: Collection, wrapper: DatabaseWrapper): Long { - val statement = modelSaver.modelAdapter.getUpdateStatement(wrapper) + val statement = modelAdapter.getUpdateStatement(wrapper) return applyAndCount(tableCollection, statement, - cacheFn = modelSaver.modelAdapter::storeModelInCache) { + cacheFn = modelAdapter::storeModelInCache) { modelSaver.update(it, statement, wrapper) } } @Synchronized override fun deleteAll(tableCollection: Collection, wrapper: DatabaseWrapper): Long { - val statement = modelSaver.modelAdapter.getDeleteStatement(wrapper) + val statement = modelAdapter.getDeleteStatement(wrapper) return applyAndCount(tableCollection, statement, - cacheFn = modelSaver.modelAdapter::removeModelFromCache) { + cacheFn = modelAdapter::removeModelFromCache) { modelSaver.delete(it, statement, wrapper) } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ListModelSaver.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ListModelSaver.kt index f66738200..03c3f088e 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ListModelSaver.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ListModelSaver.kt @@ -5,37 +5,36 @@ import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper open class ListModelSaver(val modelSaver: ModelSaver) { + val modelAdapter = modelSaver.modelAdapter + @Synchronized open fun saveAll(tableCollection: Collection, wrapper: DatabaseWrapper): Long { - // skip if empty. - if (tableCollection.isEmpty()) { - return 0L + val statement = modelAdapter.getInsertStatement(wrapper) + val updateStatement = modelAdapter.getUpdateStatement(wrapper) + return applyAndCount(tableCollection, statement, updateStatement) { + modelSaver.save(it, statement, updateStatement, wrapper) } - - val statement = modelSaver.modelAdapter.getInsertStatement(wrapper) - val updateStatement = modelSaver.modelAdapter.getUpdateStatement(wrapper) - return applyAndCount(tableCollection, statement, updateStatement) { modelSaver.save(it, statement, updateStatement, wrapper) } } @Synchronized open fun insertAll(tableCollection: Collection, wrapper: DatabaseWrapper): Long { - val statement = modelSaver.modelAdapter.getInsertStatement(wrapper) + val statement = modelAdapter.getInsertStatement(wrapper) return applyAndCount(tableCollection, statement) { modelSaver.insert(it, statement, wrapper) > 0 } } @Synchronized open fun updateAll(tableCollection: Collection, wrapper: DatabaseWrapper): Long { - val statement = modelSaver.modelAdapter.getUpdateStatement(wrapper) + val statement = modelAdapter.getUpdateStatement(wrapper) return applyAndCount(tableCollection, statement) { modelSaver.update(it, statement, wrapper) } } @Synchronized open fun deleteAll(tableCollection: Collection, wrapper: DatabaseWrapper): Long { - val statement = modelSaver.modelAdapter.getDeleteStatement(wrapper) + val statement = modelAdapter.getDeleteStatement(wrapper) return applyAndCount(tableCollection, statement) { modelSaver.delete(it, statement, wrapper) } } From 471536754561229be0d34e5fd1700314429cfbe2 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sun, 26 Nov 2017 21:32:07 -0500 Subject: [PATCH 088/234] [5.0] move Action out of Model into ChangeAction. --- .../language/TableChangeListenerEmitter.java | 4 +-- .../rx2/language/TableChangeOnSubscribe.kt | 4 +-- .../contentobserver/ContentObserverTest.kt | 20 ++++++------ .../dbflow/runtime/DirectNotifierTest.kt | 16 +++++----- .../dbflow/runtime/ContentResolverNotifier.kt | 8 ++--- .../dbflow/runtime/DirectModelNotifier.kt | 10 +++--- .../dbflow/runtime/FlowContentObserver.kt | 14 ++++----- .../android/dbflow/runtime/ModelNotifier.kt | 6 ++-- .../dbflow/runtime/NotifyDistributor.kt | 6 ++-- .../dbflow/runtime/OnTableChangedListener.kt | 4 +-- .../raizlabs/android/dbflow/sql/SqlUtils.kt | 8 ++--- .../android/dbflow/sql/language/Actionable.kt | 4 +-- .../dbflow/sql/language/BaseQueriable.kt | 6 ++-- .../android/dbflow/sql/language/From.kt | 6 ++-- .../android/dbflow/sql/language/IndexedBy.kt | 4 +-- .../android/dbflow/sql/language/Insert.kt | 7 ++--- .../android/dbflow/sql/language/Set.kt | 6 ++-- .../android/dbflow/sql/language/Where.kt | 4 +-- .../android/dbflow/sql/queriable/Queriable.kt | 4 +-- .../dbflow/sql/queriable/StringQuery.kt | 6 ++-- .../sql/saveable/AutoIncrementModelSaver.kt | 4 +-- .../android/dbflow/sql/saveable/ModelSaver.kt | 10 +++--- .../android/dbflow/structure/Action.kt | 23 ++++++++++++++ .../android/dbflow/structure/BaseModel.kt | 31 ------------------- 24 files changed, 103 insertions(+), 112 deletions(-) create mode 100644 dbflow/src/main/java/com/raizlabs/android/dbflow/structure/Action.kt diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/TableChangeListenerEmitter.java b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/TableChangeListenerEmitter.java index a2ed536b8..4dac6e650 100644 --- a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/TableChangeListenerEmitter.java +++ b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/TableChangeListenerEmitter.java @@ -10,7 +10,7 @@ import com.raizlabs.android.dbflow.sql.language.Join; import com.raizlabs.android.dbflow.sql.language.Where; import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable; -import com.raizlabs.android.dbflow.structure.BaseModel; +import com.raizlabs.android.dbflow.structure.ChangeAction; import rx.Emitter; import rx.Subscription; @@ -80,7 +80,7 @@ public boolean isUnsubscribed() { private final OnTableChangedListener onTableChangedListener = new OnTableChangedListener() { @Override - public void onTableChanged(@Nullable Class table, @NonNull BaseModel.Action action) { + public void onTableChanged(@Nullable Class table, @NonNull ChangeAction action) { if (modelQueriable.getTable().equals(table)) { modelQueriableEmitter.onNext(modelQueriable); } diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/TableChangeOnSubscribe.kt b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/TableChangeOnSubscribe.kt index 12eb6ecc0..4ebee8194 100644 --- a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/TableChangeOnSubscribe.kt +++ b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/TableChangeOnSubscribe.kt @@ -7,7 +7,7 @@ import com.raizlabs.android.dbflow.sql.language.From import com.raizlabs.android.dbflow.sql.language.Join import com.raizlabs.android.dbflow.sql.language.Where import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable -import com.raizlabs.android.dbflow.structure.BaseModel +import com.raizlabs.android.dbflow.structure.ChangeAction import io.reactivex.FlowableEmitter import io.reactivex.FlowableOnSubscribe @@ -24,7 +24,7 @@ class TableChangeOnSubscribe(private val modelQueriable: ModelQueriable private var flowableEmitter: FlowableEmitter>? = null private val onTableChangedListener = object : OnTableChangedListener { - override fun onTableChanged(table: Class<*>?, action: BaseModel.Action) { + override fun onTableChanged(table: Class<*>?, action: ChangeAction) { if (modelQueriable.table == table) { flowableEmitter!!.onNext(modelQueriable) } diff --git a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/contentobserver/ContentObserverTest.kt b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/contentobserver/ContentObserverTest.kt index b3a4fc11b..f6b7605e5 100644 --- a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/contentobserver/ContentObserverTest.kt +++ b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/contentobserver/ContentObserverTest.kt @@ -13,7 +13,7 @@ import com.raizlabs.android.dbflow.sql.TABLE_QUERY_PARAM import com.raizlabs.android.dbflow.sql.getNotificationUri import com.raizlabs.android.dbflow.sql.language.SQLOperator import com.raizlabs.android.dbflow.sql.language.delete -import com.raizlabs.android.dbflow.structure.BaseModel +import com.raizlabs.android.dbflow.structure.ChangeAction import com.raizlabs.android.dbflow.structure.delete import com.raizlabs.android.dbflow.structure.insert import com.raizlabs.android.dbflow.structure.save @@ -42,41 +42,41 @@ class ContentObserverTest : BaseInstrumentedUnitTest() { val conditionGroup = FlowManager.getModelAdapter(User::class.java) .getPrimaryConditionClause(user) val uri = getNotificationUri(contentUri, - User::class.java, BaseModel.Action.DELETE, + User::class.java, ChangeAction.DELETE, conditionGroup.conditions.toTypedArray()) assertEquals(uri.authority, contentUri) assertEquals(tableName(), uri.getQueryParameter(TABLE_QUERY_PARAM)) - assertEquals(uri.fragment, BaseModel.Action.DELETE.name) + assertEquals(uri.fragment, ChangeAction.DELETE.name) assertEquals(Uri.decode(uri.getQueryParameter(Uri.encode(id.query))), "5") assertEquals(Uri.decode(uri.getQueryParameter(Uri.encode(name.query))), "Something") } @Test fun testSpecificUrlInsert() { - assertProperConditions(BaseModel.Action.INSERT, { it.insert() }) + assertProperConditions(ChangeAction.INSERT, { it.insert() }) } @Test fun testSpecificUrlUpdate() { user.save() - assertProperConditions(BaseModel.Action.UPDATE, { it.apply { age = 56 }.update() }) + assertProperConditions(ChangeAction.UPDATE, { it.apply { age = 56 }.update() }) } @Test fun testSpecificUrlSave() { // insert on SAVE - assertProperConditions(BaseModel.Action.INSERT, { it.apply { age = 57 }.save() }) + assertProperConditions(ChangeAction.INSERT, { it.apply { age = 57 }.save() }) } @Test fun testSpecificUrlDelete() { user.save() - assertProperConditions(BaseModel.Action.DELETE, { it.delete() }) + assertProperConditions(ChangeAction.DELETE, { it.delete() }) } - private fun assertProperConditions(action: BaseModel.Action, userFunc: (User) -> Unit) { + private fun assertProperConditions(action: ChangeAction, userFunc: (User) -> Unit) { val contentObserver = FlowContentObserver(contentUri) val countDownLatch = CountDownLatch(1) val mockOnModelStateChangedListener = MockOnModelStateChangedListener(countDownLatch) @@ -101,11 +101,11 @@ class ContentObserverTest : BaseInstrumentedUnitTest() { class MockOnModelStateChangedListener(val countDownLatch: CountDownLatch) : FlowContentObserver.OnModelStateChangedListener { - var action: BaseModel.Action? = null + var action: ChangeAction? = null var operators: Array? = null - override fun onModelStateChanged(table: Class<*>?, action: BaseModel.Action, + override fun onModelStateChanged(table: Class<*>?, action: ChangeAction, primaryKeyValues: Array) { this.action = action operators = primaryKeyValues diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/runtime/DirectNotifierTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/runtime/DirectNotifierTest.kt index 0b1fb45ed..298b09d76 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/runtime/DirectNotifierTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/runtime/DirectNotifierTest.kt @@ -17,7 +17,7 @@ import com.raizlabs.android.dbflow.sql.language.delete import com.raizlabs.android.dbflow.sql.language.insert import com.raizlabs.android.dbflow.sql.language.set import com.raizlabs.android.dbflow.sql.language.update -import com.raizlabs.android.dbflow.structure.BaseModel +import com.raizlabs.android.dbflow.structure.ChangeAction import com.raizlabs.android.dbflow.structure.delete import com.raizlabs.android.dbflow.structure.insert import com.raizlabs.android.dbflow.structure.save @@ -54,16 +54,16 @@ class DirectNotifierTest { DirectModelNotifier.get().registerForModelStateChanges(SimpleModel::class.java, modelChange) simpleModel.insert() - verify(modelChange).onModelChanged(simpleModel, BaseModel.Action.INSERT) + verify(modelChange).onModelChanged(simpleModel, ChangeAction.INSERT) simpleModel.update() - verify(modelChange).onModelChanged(simpleModel, BaseModel.Action.UPDATE) + verify(modelChange).onModelChanged(simpleModel, ChangeAction.UPDATE) simpleModel.save() - verify(modelChange, times(2)).onModelChanged(simpleModel, BaseModel.Action.UPDATE) + verify(modelChange, times(2)).onModelChanged(simpleModel, ChangeAction.UPDATE) simpleModel.delete() - verify(modelChange).onModelChanged(simpleModel, BaseModel.Action.DELETE) + verify(modelChange).onModelChanged(simpleModel, ChangeAction.DELETE) } @Test @@ -74,15 +74,15 @@ class DirectNotifierTest { insert().columnValues(SimpleModel_Table.name to "name").executeInsert() - verify(modelChange).onTableChanged(SimpleModel::class.java, BaseModel.Action.INSERT) + verify(modelChange).onTableChanged(SimpleModel::class.java, ChangeAction.INSERT) (update() set SimpleModel_Table.name.eq("name2")).executeUpdateDelete() - verify(modelChange).onTableChanged(SimpleModel::class.java, BaseModel.Action.UPDATE) + verify(modelChange).onTableChanged(SimpleModel::class.java, ChangeAction.UPDATE) delete().executeUpdateDelete() - verify(modelChange).onTableChanged(SimpleModel::class.java, BaseModel.Action.DELETE) + verify(modelChange).onTableChanged(SimpleModel::class.java, ChangeAction.DELETE) } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ContentResolverNotifier.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ContentResolverNotifier.kt index 7f31f96f8..b85160ebb 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ContentResolverNotifier.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ContentResolverNotifier.kt @@ -5,7 +5,7 @@ import android.content.ContentResolver import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.sql.getNotificationUri import com.raizlabs.android.dbflow.sql.language.SQLOperator -import com.raizlabs.android.dbflow.structure.BaseModel +import com.raizlabs.android.dbflow.structure.ChangeAction import com.raizlabs.android.dbflow.structure.ModelAdapter /** @@ -17,7 +17,7 @@ import com.raizlabs.android.dbflow.structure.ModelAdapter class ContentResolverNotifier(val authority: String) : ModelNotifier { override fun notifyModelChanged(model: T, adapter: ModelAdapter, - action: BaseModel.Action) { + action: ChangeAction) { if (FlowContentObserver.shouldNotify()) { FlowManager.context.contentResolver .notifyChange(getNotificationUri(authority, @@ -27,7 +27,7 @@ class ContentResolverNotifier(val authority: String) : ModelNotifier { } } - override fun notifyTableChanged(table: Class, action: BaseModel.Action) { + override fun notifyTableChanged(table: Class, action: ChangeAction) { if (FlowContentObserver.shouldNotify()) { FlowManager.context.contentResolver .notifyChange(getNotificationUri(authority, table, action, @@ -44,7 +44,7 @@ class ContentResolverNotifier(val authority: String) : ModelNotifier { private var tableChangedListener: OnTableChangedListener? = null private val internalContentChangeListener = object : OnTableChangedListener { - override fun onTableChanged(table: Class<*>?, action: BaseModel.Action) { + override fun onTableChanged(table: Class<*>?, action: ChangeAction) { tableChangedListener?.onTableChanged(table, action) } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DirectModelNotifier.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DirectModelNotifier.kt index c5905491a..5ce97fd76 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DirectModelNotifier.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DirectModelNotifier.kt @@ -1,7 +1,7 @@ package com.raizlabs.android.dbflow.runtime import com.raizlabs.android.dbflow.config.DatabaseConfig -import com.raizlabs.android.dbflow.structure.BaseModel +import com.raizlabs.android.dbflow.structure.ChangeAction import com.raizlabs.android.dbflow.structure.ModelAdapter import java.util.* @@ -24,7 +24,7 @@ private constructor() : ModelNotifier { interface OnModelStateChangedListener { - fun onModelChanged(model: T, action: BaseModel.Action) + fun onModelChanged(model: T, action: ChangeAction) } @@ -39,13 +39,13 @@ private constructor() : ModelNotifier { @Suppress("UNCHECKED_CAST") override fun notifyModelChanged(model: T, adapter: ModelAdapter, - action: BaseModel.Action) { + action: ChangeAction) { modelChangedListenerMap[adapter.modelClass]?.forEach { listener -> (listener as OnModelStateChangedListener).onModelChanged(model, action) } } - override fun notifyTableChanged(table: Class, action: BaseModel.Action) { + override fun notifyTableChanged(table: Class, action: ChangeAction) { tableChangedListenerMap[table]?.forEach { listener -> listener.onTableChanged(table, action) } } @@ -104,7 +104,7 @@ private constructor() : ModelNotifier { private var modelChangedListener: OnTableChangedListener? = null private val internalChangeListener = object : OnTableChangedListener { - override fun onTableChanged(table: Class<*>?, action: BaseModel.Action) { + override fun onTableChanged(table: Class<*>?, action: ChangeAction) { modelChangedListener?.onTableChanged(table, action) } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/FlowContentObserver.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/FlowContentObserver.kt index f4472ee82..6b8845e05 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/FlowContentObserver.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/FlowContentObserver.kt @@ -15,7 +15,7 @@ import com.raizlabs.android.dbflow.sql.getNotificationUri import com.raizlabs.android.dbflow.sql.language.NameAlias import com.raizlabs.android.dbflow.sql.language.Operator import com.raizlabs.android.dbflow.sql.language.SQLOperator -import com.raizlabs.android.dbflow.structure.BaseModel.Action +import com.raizlabs.android.dbflow.structure.ChangeAction import com.raizlabs.android.dbflow.structure.Model import java.util.* import java.util.concurrent.CopyOnWriteArraySet @@ -62,7 +62,7 @@ open class FlowContentObserver(private val contentAuthority: String, * @param primaryKeyValues The array of primary [SQLOperator] of what changed. Call [SQLOperator.columnName] * and [SQLOperator.value] to get each information. */ - fun onModelStateChanged(table: Class<*>?, action: Action, primaryKeyValues: Array) + fun onModelStateChanged(table: Class<*>?, action: ChangeAction, primaryKeyValues: Array) } interface ContentChangeListener : OnModelStateChangedListener, OnTableChangedListener @@ -108,7 +108,7 @@ open class FlowContentObserver(private val contentAuthority: String, for (uri in tableUris) { for (onTableChangedListener in onTableChangedListeners) { onTableChangedListener.onTableChanged(registeredTables[uri.authority], - Action.valueOf(uri.fragment)) + ChangeAction.valueOf(uri.fragment)) } } tableUris.clear() @@ -194,8 +194,8 @@ open class FlowContentObserver(private val contentAuthority: String, } override fun onChange(selfChange: Boolean) { - modelChangeListeners.forEach { it.onModelStateChanged(null, Action.CHANGE, arrayOf()) } - onTableChangedListeners.forEach { it.onTableChanged(null, Action.CHANGE) } + modelChangeListeners.forEach { it.onModelStateChanged(null, ChangeAction.CHANGE, arrayOf()) } + onTableChangedListeners.forEach { it.onTableChanged(null, ChangeAction.CHANGE) } } @TargetApi(VERSION_CODES.JELLY_BEAN) @@ -223,7 +223,7 @@ open class FlowContentObserver(private val contentAuthority: String, } val table = registeredTables[tableName] - var action = Action.valueOf(fragment) + var action = ChangeAction.valueOf(fragment) if (!isInTransaction) { modelChangeListeners.forEach { it.onModelStateChanged(table, action, columnsChanged.toTypedArray()) } @@ -233,7 +233,7 @@ open class FlowContentObserver(private val contentAuthority: String, } else { // convert this uri to a CHANGE op if we don't care about individual changes. if (!notifyAllUris) { - action = Action.CHANGE + action = ChangeAction.CHANGE uri = getNotificationUri(contentAuthority, table!!, action) } synchronized(notificationUris) { diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ModelNotifier.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ModelNotifier.kt index 0876f272c..68f89b158 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ModelNotifier.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ModelNotifier.kt @@ -1,6 +1,6 @@ package com.raizlabs.android.dbflow.runtime -import com.raizlabs.android.dbflow.structure.BaseModel +import com.raizlabs.android.dbflow.structure.ChangeAction import com.raizlabs.android.dbflow.structure.ModelAdapter /** @@ -8,9 +8,9 @@ import com.raizlabs.android.dbflow.structure.ModelAdapter */ interface ModelNotifier { - fun notifyModelChanged(model: T, adapter: ModelAdapter, action: BaseModel.Action) + fun notifyModelChanged(model: T, adapter: ModelAdapter, action: ChangeAction) - fun notifyTableChanged(table: Class, action: BaseModel.Action) + fun notifyTableChanged(table: Class, action: ChangeAction) fun newRegister(): TableNotifierRegister } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/NotifyDistributor.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/NotifyDistributor.kt index efd1e0889..80648e355 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/NotifyDistributor.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/NotifyDistributor.kt @@ -1,7 +1,7 @@ package com.raizlabs.android.dbflow.runtime import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.structure.BaseModel +import com.raizlabs.android.dbflow.structure.ChangeAction import com.raizlabs.android.dbflow.structure.ModelAdapter /** @@ -15,7 +15,7 @@ class NotifyDistributor : ModelNotifier { override fun notifyModelChanged(model: T, adapter: ModelAdapter, - action: BaseModel.Action) { + action: ChangeAction) { FlowManager.getModelNotifierForTable(adapter.modelClass) .notifyModelChanged(model, adapter, action) } @@ -24,7 +24,7 @@ class NotifyDistributor : ModelNotifier { * Notifies listeners of table-level changes from the SQLite-wrapper language. */ override fun notifyTableChanged(table: Class, - action: BaseModel.Action) { + action: ChangeAction) { FlowManager.getModelNotifierForTable(table).notifyTableChanged(table, action) } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/OnTableChangedListener.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/OnTableChangedListener.kt index 8d79d84ec..be88ef2ac 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/OnTableChangedListener.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/OnTableChangedListener.kt @@ -2,7 +2,7 @@ package com.raizlabs.android.dbflow.runtime import android.os.Build -import com.raizlabs.android.dbflow.structure.BaseModel +import com.raizlabs.android.dbflow.structure.ChangeAction /** * Interface for when a generic change on a table occurs. @@ -16,5 +16,5 @@ interface OnTableChangedListener { * or higher. * @param action The action that occurred. */ - fun onTableChanged(table: Class<*>?, action: BaseModel.Action) + fun onTableChanged(table: Class<*>?, action: ChangeAction) } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/SqlUtils.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/SqlUtils.kt index 6fb3380fd..52e56001b 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/SqlUtils.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/SqlUtils.kt @@ -12,7 +12,7 @@ import com.raizlabs.android.dbflow.sql.language.Operator import com.raizlabs.android.dbflow.sql.language.OperatorGroup import com.raizlabs.android.dbflow.sql.language.SQLOperator import com.raizlabs.android.dbflow.stripQuotes -import com.raizlabs.android.dbflow.structure.BaseModel.Action +import com.raizlabs.android.dbflow.structure.ChangeAction import com.raizlabs.android.dbflow.structure.Model import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper @@ -34,7 +34,7 @@ val TABLE_QUERY_PARAM = "tableName" */ fun getNotificationUri(contentAuthority: String, modelClass: Class<*>, - action: Action?, + action: ChangeAction?, conditions: Iterable?): Uri { val uriBuilder = Uri.Builder().scheme("dbflow") .authority(contentAuthority) @@ -61,7 +61,7 @@ fun getNotificationUri(contentAuthority: String, */ fun getNotificationUri(contentAuthority: String, modelClass: Class<*>, - action: Action?, + action: ChangeAction?, conditions: Array?): Uri { val uriBuilder = Uri.Builder().scheme("dbflow") .authority(contentAuthority) @@ -88,7 +88,7 @@ fun getNotificationUri(contentAuthority: String, @JvmOverloads fun getNotificationUri(contentAuthority: String, modelClass: Class<*>, - action: Action?, + action: ChangeAction?, notifyKey: String = "", notifyValue: Any? = null): Uri { var operator: Operator? = null diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Actionable.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Actionable.kt index d05dd3920..3884def90 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Actionable.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Actionable.kt @@ -1,11 +1,11 @@ package com.raizlabs.android.dbflow.sql.language -import com.raizlabs.android.dbflow.structure.BaseModel.Action +import com.raizlabs.android.dbflow.structure.ChangeAction /** * Description: Provides [Action] for SQL constructs. */ interface Actionable { - val primaryAction: Action + val primaryAction: ChangeAction } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseQueriable.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseQueriable.kt index 0fe4e3c16..acf29fdd2 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseQueriable.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseQueriable.kt @@ -5,7 +5,7 @@ import com.raizlabs.android.dbflow.config.FlowLog import com.raizlabs.android.dbflow.runtime.NotifyDistributor import com.raizlabs.android.dbflow.sql.longForQuery import com.raizlabs.android.dbflow.sql.queriable.Queriable -import com.raizlabs.android.dbflow.structure.BaseModel +import com.raizlabs.android.dbflow.structure.ChangeAction import com.raizlabs.android.dbflow.structure.database.DatabaseStatement import com.raizlabs.android.dbflow.structure.database.DatabaseStatementWrapper import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper @@ -21,7 +21,7 @@ abstract class BaseQueriable protected constructor( */ val table: Class) : Queriable, Actionable { - abstract override val primaryAction: BaseModel.Action + abstract override val primaryAction: ChangeAction override fun longValue(): Long { try { @@ -39,7 +39,7 @@ abstract class BaseQueriable protected constructor( override fun hasData(): Boolean = longValue() > 0 override fun query(): FlowCursor? { - if (primaryAction == BaseModel.Action.INSERT) { + if (primaryAction == ChangeAction.INSERT) { // inserting, let's compile and insert val databaseStatement = compileStatement() databaseStatement.executeInsert() diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/From.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/From.kt index dd1c699a8..2d1d37aac 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/From.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/From.kt @@ -5,7 +5,7 @@ import com.raizlabs.android.dbflow.sql.Query import com.raizlabs.android.dbflow.sql.language.Join.JoinType import com.raizlabs.android.dbflow.sql.language.property.IndexProperty import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable -import com.raizlabs.android.dbflow.structure.BaseModel +import com.raizlabs.android.dbflow.structure.ChangeAction import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper import java.util.* import kotlin.collections.Set as KSet @@ -39,8 +39,8 @@ internal constructor( */ private val joins = ArrayList>() - override val primaryAction: BaseModel.Action - get() = if (queryBuilderBase is Delete) BaseModel.Action.DELETE else BaseModel.Action.CHANGE + override val primaryAction: ChangeAction + get() = if (queryBuilderBase is Delete) ChangeAction.DELETE else ChangeAction.CHANGE override val query: String get() { diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IndexedBy.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IndexedBy.kt index 863b94a29..04a871376 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IndexedBy.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IndexedBy.kt @@ -3,7 +3,7 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.quoteIfNeeded import com.raizlabs.android.dbflow.sql.Query import com.raizlabs.android.dbflow.sql.language.property.IndexProperty -import com.raizlabs.android.dbflow.structure.BaseModel +import com.raizlabs.android.dbflow.structure.ChangeAction /** * Description: The INDEXED BY part of a SELECT/UPDATE/DELETE @@ -30,6 +30,6 @@ class IndexedBy append(" ") } - override val primaryAction: BaseModel.Action + override val primaryAction: ChangeAction get() = whereBase.primaryAction } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Insert.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Insert.kt index 46973fd45..b1c054c62 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Insert.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Insert.kt @@ -6,9 +6,8 @@ import com.raizlabs.android.dbflow.appendArray import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.sql.Query import com.raizlabs.android.dbflow.sql.language.property.IProperty -import com.raizlabs.android.dbflow.structure.BaseModel +import com.raizlabs.android.dbflow.structure.ChangeAction import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper -import kotlin.reflect.KClass /** * Description: The SQLite INSERT command @@ -85,8 +84,8 @@ internal constructor(databaseWrapper: DatabaseWrapper, return queryBuilder.toString() } - override val primaryAction: BaseModel.Action - get() = BaseModel.Action.INSERT + override val primaryAction: ChangeAction + get() = ChangeAction.INSERT /** * The optional columns to specify. If specified, the values length must correspond to these columns, and diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Set.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Set.kt index a7bacdb50..8a342fa1f 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Set.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Set.kt @@ -3,7 +3,7 @@ package com.raizlabs.android.dbflow.sql.language import android.content.ContentValues import com.raizlabs.android.dbflow.sql.Query import com.raizlabs.android.dbflow.sql.addContentValues -import com.raizlabs.android.dbflow.structure.BaseModel +import com.raizlabs.android.dbflow.structure.ChangeAction import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper /** @@ -19,8 +19,8 @@ class Set internal constructor( override val query: String get() = " ${queryBuilderBase.query}SET ${operatorGroup.query} " - override val primaryAction: BaseModel.Action - get() = BaseModel.Action.UPDATE + override val primaryAction: ChangeAction + get() = ChangeAction.UPDATE /** * Specifies a varg of conditions to append to this SET diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Where.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Where.kt index 5e0f08e77..163eeb587 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Where.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Where.kt @@ -5,7 +5,7 @@ import com.raizlabs.android.dbflow.annotation.provider.ContentProvider import com.raizlabs.android.dbflow.appendQualifier import com.raizlabs.android.dbflow.sql.language.property.IProperty import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable -import com.raizlabs.android.dbflow.structure.BaseModel +import com.raizlabs.android.dbflow.structure.ChangeAction import com.raizlabs.android.dbflow.structure.database.FlowCursor import java.util.* @@ -44,7 +44,7 @@ internal constructor( private var limit = VALUE_UNSET private var offset = VALUE_UNSET - override val primaryAction: BaseModel.Action + override val primaryAction: ChangeAction get() = whereBase.primaryAction override val query: String diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/Queriable.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/Queriable.kt index 8026c0a32..7532f75d7 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/Queriable.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/Queriable.kt @@ -4,7 +4,7 @@ import com.raizlabs.android.dbflow.sql.Query import com.raizlabs.android.dbflow.sql.language.Delete import com.raizlabs.android.dbflow.sql.language.Insert import com.raizlabs.android.dbflow.sql.language.Set -import com.raizlabs.android.dbflow.structure.BaseModel +import com.raizlabs.android.dbflow.structure.ChangeAction import com.raizlabs.android.dbflow.structure.Model import com.raizlabs.android.dbflow.structure.database.DatabaseStatement import com.raizlabs.android.dbflow.structure.database.FlowCursor @@ -15,7 +15,7 @@ import com.raizlabs.android.dbflow.structure.database.FlowCursor */ interface Queriable : Query { - val primaryAction: BaseModel.Action + val primaryAction: ChangeAction /** * @return A cursor from the DB based on this query diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/StringQuery.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/StringQuery.kt index 9eb1518b9..1d7e424fe 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/StringQuery.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/StringQuery.kt @@ -4,7 +4,7 @@ import android.database.sqlite.SQLiteDatabase import com.raizlabs.android.dbflow.sql.Query import com.raizlabs.android.dbflow.sql.language.BaseModelQueriable import com.raizlabs.android.dbflow.sql.language.Delete -import com.raizlabs.android.dbflow.structure.BaseModel +import com.raizlabs.android.dbflow.structure.ChangeAction import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper import com.raizlabs.android.dbflow.structure.database.FlowCursor @@ -28,8 +28,8 @@ class StringQuery private var args: Array? = null override// we don't explicitly know the change, but something changed. - val primaryAction: BaseModel.Action - get() = BaseModel.Action.CHANGE + val primaryAction: ChangeAction + get() = ChangeAction.CHANGE override fun query(): FlowCursor? = databaseWrapper.rawQuery(query, args) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/AutoIncrementModelSaver.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/AutoIncrementModelSaver.kt index cc8a158a4..5982f2d61 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/AutoIncrementModelSaver.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/AutoIncrementModelSaver.kt @@ -2,7 +2,7 @@ package com.raizlabs.android.dbflow.sql.saveable import com.raizlabs.android.dbflow.config.FlowLog import com.raizlabs.android.dbflow.runtime.NotifyDistributor -import com.raizlabs.android.dbflow.structure.BaseModel +import com.raizlabs.android.dbflow.structure.ChangeAction import com.raizlabs.android.dbflow.structure.database.DatabaseStatement import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper @@ -28,7 +28,7 @@ class AutoIncrementModelSaver : ModelSaver() { id = insertStatement.executeInsert() if (id > ModelSaver.INSERT_FAILED) { modelAdapter.updateAutoIncrement(model, id) - NotifyDistributor.get().notifyModelChanged(model, modelAdapter, BaseModel.Action.INSERT) + NotifyDistributor.get().notifyModelChanged(model, modelAdapter, ChangeAction.INSERT) } } finally { // since we generate an insert every time, we can safely close the statement here. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ModelSaver.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ModelSaver.kt index 1e696a1f8..8ccbeb560 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ModelSaver.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ModelSaver.kt @@ -2,7 +2,7 @@ package com.raizlabs.android.dbflow.sql.saveable import android.content.ContentValues import com.raizlabs.android.dbflow.runtime.NotifyDistributor -import com.raizlabs.android.dbflow.structure.BaseModel +import com.raizlabs.android.dbflow.structure.ChangeAction import com.raizlabs.android.dbflow.structure.ModelAdapter import com.raizlabs.android.dbflow.structure.database.DatabaseStatement import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper @@ -36,7 +36,7 @@ open class ModelSaver { } if (exists) { - NotifyDistributor().notifyModelChanged(model, modelAdapter, BaseModel.Action.SAVE) + NotifyDistributor().notifyModelChanged(model, modelAdapter, ChangeAction.SAVE) } // return successful store into db. @@ -60,7 +60,7 @@ open class ModelSaver { modelAdapter.bindToUpdateStatement(databaseStatement, model) val successful = databaseStatement.executeUpdateDelete() != 0L if (successful) { - NotifyDistributor().notifyModelChanged(model, modelAdapter, BaseModel.Action.UPDATE) + NotifyDistributor().notifyModelChanged(model, modelAdapter, ChangeAction.UPDATE) } return successful } @@ -83,7 +83,7 @@ open class ModelSaver { val id = insertStatement.executeInsert() if (id > INSERT_FAILED) { modelAdapter.updateAutoIncrement(model, id) - NotifyDistributor().notifyModelChanged(model, modelAdapter, BaseModel.Action.INSERT) + NotifyDistributor().notifyModelChanged(model, modelAdapter, ChangeAction.INSERT) } return id } @@ -108,7 +108,7 @@ open class ModelSaver { val success = deleteStatement.executeUpdateDelete() != 0L if (success) { - NotifyDistributor().notifyModelChanged(model, modelAdapter, BaseModel.Action.DELETE) + NotifyDistributor().notifyModelChanged(model, modelAdapter, ChangeAction.DELETE) } modelAdapter.updateAutoIncrement(model, 0) return success diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/Action.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/Action.kt new file mode 100644 index 000000000..f2d65c714 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/Action.kt @@ -0,0 +1,23 @@ +package com.raizlabs.android.dbflow.structure + +/** + * Specifies the Action that was taken when data changes + */ +enum class ChangeAction { + + /** + * Save called. Is paired with [UPDATE] or [INSERT] depending on action taken. + */ + SAVE, + + INSERT, + + UPDATE, + + DELETE, + + /** + * The model was changed. used in prior to [android.os.Build.VERSION_CODES.JELLY_BEAN_MR1] + */ + CHANGE +} \ No newline at end of file diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseModel.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseModel.kt index bfa27d40d..7bc4ca765 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseModel.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseModel.kt @@ -20,37 +20,6 @@ open class BaseModel : Model { @delegate:Transient val modelAdapter: ModelAdapter by lazy { FlowManager.getModelAdapter(javaClass) } - /** - * Specifies the Action that was taken when data changes - */ - enum class Action { - - /** - * The model called [Model.save] - */ - SAVE, - - /** - * The model called [Model.insert] - */ - INSERT, - - /** - * The model called [Model.update] - */ - UPDATE, - - /** - * The model called [Model.delete] - */ - DELETE, - - /** - * The model was changed. used in prior to [android.os.Build.VERSION_CODES.JELLY_BEAN_MR1] - */ - CHANGE - } - override fun load(wrapper: DatabaseWrapper) { modelAdapter.load(this, wrapper) } From 78324c72b376a63c33530cf475602a6584642aea Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sun, 26 Nov 2017 21:35:31 -0500 Subject: [PATCH 089/234] [5.0] revert unnecessary overrides. --- .../android/dbflow/structure/BaseModel.kt | 15 ++------------- .../provider/BaseSyncableProviderModel.kt | 12 +++++++----- 2 files changed, 9 insertions(+), 18 deletions(-) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseModel.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseModel.kt index 7bc4ca765..ef34167b2 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseModel.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseModel.kt @@ -24,24 +24,13 @@ open class BaseModel : Model { modelAdapter.load(this, wrapper) } - override fun save(wrapper: DatabaseWrapper): Boolean = wrapper.saveModel() + override fun save(wrapper: DatabaseWrapper): Boolean = modelAdapter.save(this@BaseModel, wrapper) - override fun delete(wrapper: DatabaseWrapper): Boolean = wrapper.deleteModel() + override fun delete(wrapper: DatabaseWrapper): Boolean = modelAdapter.delete(this@BaseModel, wrapper) override fun update(wrapper: DatabaseWrapper): Boolean = modelAdapter.update(this, wrapper) override fun insert(wrapper: DatabaseWrapper): Long = modelAdapter.insert(this, wrapper) override fun exists(wrapper: DatabaseWrapper): Boolean = modelAdapter.exists(this, wrapper) - - protected fun DatabaseWrapper.saveModel(): Boolean = modelAdapter.save(this@BaseModel, this) - - protected fun DatabaseWrapper.deleteModel(): Boolean = modelAdapter.delete(this@BaseModel, this) - - protected fun DatabaseWrapper.updateModel(): Boolean = modelAdapter.update(this@BaseModel, this) - - protected fun DatabaseWrapper.insertModel(): Long = modelAdapter.insert(this@BaseModel, this) - - protected fun DatabaseWrapper.existsModel(): Boolean = modelAdapter.exists(this@BaseModel, this) - } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/BaseSyncableProviderModel.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/BaseSyncableProviderModel.kt index 6af45ea2a..07c478783 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/BaseSyncableProviderModel.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/BaseSyncableProviderModel.kt @@ -16,22 +16,24 @@ import com.raizlabs.android.dbflow.structure.database.FlowCursor abstract class BaseSyncableProviderModel : BaseModel(), ModelProvider { override fun insert(wrapper: DatabaseWrapper): Long { - val rowId = wrapper.insertModel() + val rowId = super.insert(wrapper) ContentUtils.insert(insertUri, wrapper) return rowId } override fun save(wrapper: DatabaseWrapper): Boolean { return if (exists(wrapper)) { - wrapper.saveModel() && ContentUtils.update(updateUri, wrapper) > 0 + super.save(wrapper) && ContentUtils.update(updateUri, wrapper) > 0 } else { - wrapper.saveModel() && ContentUtils.insert(insertUri, wrapper) != null + super.save(wrapper) && ContentUtils.insert(insertUri, wrapper) != null } } - override fun delete(wrapper: DatabaseWrapper): Boolean = wrapper.deleteModel() && ContentUtils.delete(deleteUri, wrapper) > 0 + override fun delete(wrapper: DatabaseWrapper): Boolean + = super.delete(wrapper) && ContentUtils.delete(deleteUri, wrapper) > 0 - override fun update(wrapper: DatabaseWrapper): Boolean = wrapper.updateModel() && ContentUtils.update(updateUri, wrapper) > 0 + override fun update(wrapper: DatabaseWrapper): Boolean + = super.update(wrapper) && ContentUtils.update(updateUri, wrapper) > 0 override fun load(whereOperatorGroup: OperatorGroup, orderBy: String?, From 7dc6f52ebc98386f08056ecfe0d0b9cc13fa8a30 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Mon, 27 Nov 2017 07:32:04 -0500 Subject: [PATCH 090/234] [5.0] simplified project package structure. --- .../android/dbflow/processor/ClassNames.kt | 46 ++++++++----------- .../rx/language/CursorResultSubscriber.kt | 2 +- .../dbflow/rx/language/RXModelQueriable.kt | 10 ++-- .../rx/language/RXModelQueriableImpl.kt | 10 ++-- .../android/dbflow/rx/language/RXQueriable.kt | 10 ++-- .../dbflow/rx/language/RXQueriableImpl.kt | 6 +-- .../android/dbflow/rx/language/RXSQLite.kt | 6 +-- .../language/TableChangeListenerEmitter.java | 8 ++-- .../dbflow/rx/structure/BaseRXModel.kt | 4 +- .../dbflow/rx/structure/RXModelAdapter.kt | 4 +- .../dbflow/rx/structure/RXRetrievalAdapter.kt | 4 +- .../rx2/language/CursorResultFlowable.kt | 2 +- .../dbflow/rx2/language/RXModelQueriable.kt | 10 ++-- .../rx2/language/RXModelQueriableImpl.kt | 10 ++-- .../dbflow/rx2/language/RXQueriable.kt | 10 ++-- .../dbflow/rx2/language/RXQueriableImpl.kt | 6 +-- .../android/dbflow/rx2/language/RXSQLite.kt | 4 +- .../rx2/language/TableChangeOnSubscribe.kt | 8 ++-- .../dbflow/rx2/structure/BaseRXModel.kt | 4 +- .../dbflow/rx2/structure/RXModelAdapter.kt | 4 +- .../rx2/structure/RXRetrievalAdapter.kt | 4 +- .../dbflow/sqlcipher/SQLCipherDatabase.kt | 6 +-- .../dbflow/sqlcipher/SQLCipherOpenHelper.kt | 10 ++-- .../dbflow/sqlcipher/SQLCipherStatement.kt | 4 +- .../dbflow/ImmediateTransactionManager.kt | 6 +-- .../contentobserver/ContentObserverTest.kt | 9 ++-- .../dbflow/prepackaged/PrepackagedDBTest.kt | 4 +- .../android/dbflow/sqlcipher/CipherTest.kt | 8 ++-- .../dbflow/sqlcipher/CipherTestObjects.kt | 2 +- .../raizlabs/android/dbflow/DBFlowTestRule.kt | 2 +- .../dbflow/ImmediateTransactionManager.kt | 6 +-- .../raizlabs/android/dbflow/TestDatabase.kt | 2 +- .../dbflow/config/ConfigIntegrationTest.kt | 6 +-- .../dbflow/config/DatabaseConfigTest.kt | 6 +-- .../database/transaction/CoroutinesTest.kt | 18 ++++---- .../FastStoreModelTransactionTest.kt | 10 ++-- .../migration/UpdateTableMigrationTest.kt | 2 +- .../android/dbflow/models/CachingModels.kt | 2 +- .../dbflow/models/CachingModelsTest.kt | 6 +-- .../dbflow/models/DontCreateModelTest.kt | 4 +- .../android/dbflow/models/ForeignKeyModels.kt | 2 +- .../android/dbflow/models/ModelViews.kt | 8 ++-- .../dbflow/models/OneToManyModelTest.kt | 6 +-- .../android/dbflow/models/OneToManyModels.kt | 6 +-- .../dbflow/models/ParentChildCachingTest.kt | 4 +- .../android/dbflow/models/QueryModelTest.kt | 8 ++-- .../android/dbflow/models/SimpleTestModels.kt | 4 +- .../android/dbflow/models/issue/Issue.java | 5 +- .../android/dbflow/models/issue/SubIssue.java | 4 +- .../dbflow/models/java/JavaModelView.java | 4 +- .../ContentProviderObjects.kt | 5 +- .../ContentProviderTests.kt | 13 +++--- .../RealContentProvider.kt | 4 +- .../TestContentProvider.kt | 4 +- .../cache/ModelLruCacheTest.kt | 2 +- .../cache/SimpleMapCacheTest.kt | 2 +- .../list/FlowCursorIteratorTest.kt | 4 +- .../{ => query}/list/FlowCursorListTest.kt | 6 +-- .../dbflow/runtime/DirectNotifierTest.kt | 10 ++-- .../rx/language/CursorResultSubscriberTest.kt | 2 +- .../dbflow/rx/language/RXQueryTests.kt | 10 ++-- .../android/dbflow/sql/language/CaseTest.kt | 3 +- .../dbflow/sql/language/CursorResultTest.kt | 8 +++- .../android/dbflow/sql/language/DeleteTest.kt | 4 +- .../sql/language/ExistenceOperatorTest.kt | 3 ++ .../android/dbflow/sql/language/FromTest.kt | 3 ++ .../android/dbflow/sql/language/IndexTest.kt | 2 + .../dbflow/sql/language/IndexedByTest.kt | 3 +- .../android/dbflow/sql/language/InsertTest.kt | 7 ++- .../android/dbflow/sql/language/JoinTest.kt | 7 +++ .../android/dbflow/sql/language/MethodTest.kt | 14 ++++++ .../dbflow/sql/language/NameAliasTest.kt | 3 ++ .../dbflow/sql/language/OperatorGroupTest.kt | 5 ++ .../dbflow/sql/language/OperatorTest.kt | 4 ++ .../dbflow/sql/language/OrderByTest.kt | 3 ++ .../android/dbflow/sql/language/SelectTest.kt | 1 + .../android/dbflow/sql/language/SetTest.kt | 2 + .../dbflow/sql/language/TriggerTest.kt | 13 +++++- .../sql/language/UnsafeStringOperatorTest.kt | 3 ++ .../android/dbflow/sql/language/UpdateTest.kt | 5 +- .../android/dbflow/sql/language/WhereTest.kt | 13 ++++-- .../sql/language/property/BytePropertyTest.kt | 3 +- .../sql/language/property/CharPropertyTest.kt | 3 +- .../language/property/DoublePropertyTest.kt | 3 +- .../language/property/FloatPropertyTest.kt | 3 +- .../language/property/IndexPropertyTest.kt | 1 + .../sql/language/property/IntPropertyTest.kt | 3 +- .../sql/language/property/LongPropertyTest.kt | 3 +- .../language/property/PropertyFactoryTest.kt | 4 +- .../sql/language/property/PropertyTest.kt | 3 +- .../language/property/ShortPropertyTest.kt | 3 +- .../property/TypeConvertedPropertyTest.kt | 3 +- .../android/dbflow/{sql => }/SqlUtils.kt | 15 +++--- .../{structure => adapter}/InstanceAdapter.kt | 2 +- .../{structure => adapter}/InternalAdapter.kt | 6 +-- .../{structure => adapter}/ModelAdapter.kt | 23 +++++----- .../ModelViewAdapter.kt | 4 +- .../QueryModelAdapter.kt | 6 +-- .../RetrievalAdapter.kt | 16 +++---- .../queriable/CacheableListModelLoader.kt | 10 ++-- .../queriable/CacheableModelLoader.kt | 10 ++-- .../queriable/ListModelLoader.kt | 6 +-- .../{sql => adapter}/queriable/ModelLoader.kt | 8 ++-- .../SingleKeyCacheableListModelLoader.kt | 6 +-- .../SingleKeyCacheableModelLoader.kt | 6 +-- .../queriable/SingleModelLoader.kt | 6 +-- .../saveable/AutoIncrementModelSaver.kt | 6 +-- .../saveable/CacheableListModelSaver.kt | 6 +-- .../saveable/ListModelSaver.kt | 6 +-- .../{sql => adapter}/saveable/ModelSaver.kt | 8 ++-- .../android/dbflow/config/DatabaseConfig.kt | 6 +-- .../dbflow/config/DatabaseDefinition.kt | 36 +++++++-------- .../android/dbflow/config/FlowManager.kt | 14 +++--- .../android/dbflow/config/TableConfig.kt | 8 ++-- .../database/AndroidDatabase.kt | 2 +- .../database/AndroidDatabaseStatement.kt | 2 +- .../database/BaseDatabaseHelper.kt | 2 +- .../database/BaseDatabaseStatement.kt | 2 +- .../database/ContentValueExtensions.kt | 2 +- .../database/DatabaseHelperDelegate.kt | 6 +-- .../database/DatabaseHelperListener.kt | 2 +- .../database/DatabaseStatement.kt | 2 +- .../database/DatabaseStatementWrapper.kt | 4 +- .../database/DatabaseWrapper.kt | 2 +- .../{structure => }/database/FlowCursor.kt | 2 +- .../database/FlowSQLiteOpenHelper.kt | 2 +- .../{structure => }/database/OpenHelper.kt | 2 +- .../migration/AlterTableMigration.kt | 6 +-- .../{sql => }/migration/BaseMigration.kt | 4 +- .../{sql => }/migration/IndexMigration.kt | 8 ++-- .../migration/IndexPropertyMigration.kt | 6 +-- .../dbflow/{sql => }/migration/Migration.kt | 4 +- .../migration/UpdateTableMigration.kt | 12 ++--- .../BaseContentProvider.kt | 6 +-- .../provider/BaseProviderModel.kt | 8 ++-- .../provider/BaseSyncableProviderModel.kt | 8 ++-- .../{structure => }/provider/ContentUtils.kt | 12 ++--- .../{structure => }/provider/ModelProvider.kt | 8 ++-- .../{sql/language => query}/Actionable.kt | 2 +- .../language => query}/BaseModelQueriable.kt | 15 +++--- .../{sql/language => query}/BaseOperator.kt | 4 +- .../{sql/language => query}/BaseQueriable.kt | 13 +++--- .../language => query}/BaseTransformable.kt | 8 ++-- .../dbflow/{sql/language => query}/Case.kt | 6 +-- .../{sql/language => query}/CaseCondition.kt | 4 +- .../language => query}/CompletedTrigger.kt | 4 +- .../ContentValuesListener.kt | 4 +- .../{sql/language => query}/CursorResult.kt | 12 ++--- .../dbflow/{sql/language => query}/Delete.kt | 4 +- .../language => query}/ExistenceOperator.kt | 2 +- .../dbflow/{sql/language => query}/From.kt | 9 ++-- .../{sql/language => query}/IConditional.kt | 2 +- .../{sql/language => query}/IOperator.kt | 2 +- .../dbflow/{sql/language => query}/Index.kt | 8 ++-- .../{sql/language => query}/IndexedBy.kt | 4 +- .../dbflow/{sql/language => query}/Insert.kt | 6 +-- .../dbflow/{sql/language => query}/Join.kt | 7 ++- .../LoadFromCursorListener.kt | 2 +- .../dbflow/{sql/language => query}/Method.kt | 8 ++-- .../queriable => query}/ModelQueriable.kt | 9 ++-- .../{sql/language => query}/NameAlias.kt | 8 ++-- .../{sql/language => query}/Operator.kt | 10 ++-- .../{sql/language => query}/OperatorGroup.kt | 4 +- .../dbflow/{sql/language => query}/OrderBy.kt | 4 +- .../{sql/queriable => query}/Queriable.kt | 9 ++-- .../{sql/language => query}/SQLOperator.kt | 2 +- .../dbflow/{sql/language => query}/SQLite.kt | 8 ++-- .../SQLiteStatementListener.kt | 8 ++-- .../dbflow/{sql/language => query}/Select.kt | 10 ++-- .../dbflow/{sql/language => query}/Set.kt | 6 +-- .../{sql/queriable => query}/StringQuery.kt | 8 ++-- .../{sql/language => query}/Transformable.kt | 4 +- .../dbflow/{sql/language => query}/Trigger.kt | 4 +- .../{sql/language => query}/TriggerMethod.kt | 4 +- .../UnSafeStringOperator.kt | 2 +- .../dbflow/{sql/language => query}/Update.kt | 4 +- .../dbflow/{sql/language => query}/Where.kt | 7 ++- .../{sql/language => query}/WhereBase.kt | 4 +- .../cache/IMultiKeyCacheConverter.kt | 2 +- .../{structure => query}/cache/ModelCache.kt | 2 +- .../cache/ModelLruCache.kt | 2 +- .../cache/SimpleMapCache.kt | 2 +- .../cache/SparseArrayBasedCache.kt | 2 +- .../{ => query}/list/FlowCursorIterator.kt | 2 +- .../dbflow/{ => query}/list/FlowCursorList.kt | 8 ++-- .../dbflow/{ => query}/list/FlowQueryList.kt | 12 ++--- .../{ => query}/list/IFlowCursorIterator.kt | 2 +- .../property/IProperty.java | 10 ++-- .../property/IndexProperty.kt | 6 +-- .../language => query}/property/Property.kt | 14 +++--- .../property/PropertyFactory.kt | 8 ++-- .../property/TypeConvertedProperty.kt | 8 ++-- .../property/WrapperProperty.kt | 4 +- .../dbflow/runtime/ContentResolverNotifier.kt | 6 +-- .../dbflow/runtime/DBBatchSaveQueue.kt | 10 ++-- .../dbflow/runtime/DirectModelNotifier.kt | 2 +- .../dbflow/runtime/FlowContentObserver.kt | 10 ++-- .../android/dbflow/runtime/ModelNotifier.kt | 2 +- .../dbflow/runtime/NotifyDistributor.kt | 2 +- .../android/dbflow/structure/BaseModel.kt | 3 +- .../dbflow/structure/BaseQueryModel.kt | 2 +- .../android/dbflow/structure/Model.kt | 22 +++++---- .../dbflow/structure/NoModificationModel.kt | 3 +- .../android/dbflow/structure/OneToMany.kt | 4 +- .../android/dbflow/structure/ReadOnlyModel.kt | 2 +- .../BaseTransactionManager.kt | 5 +- .../database => }/transaction/Coroutines.kt | 4 +- .../transaction/DefaultTransactionManager.kt | 3 +- .../transaction/DefaultTransactionQueue.kt | 2 +- .../transaction/FastStoreModelTransaction.kt | 6 +-- .../database => }/transaction/ITransaction.kt | 4 +- .../transaction/ITransactionQueue.kt | 2 +- .../transaction/PriorityTransactionQueue.kt | 2 +- .../transaction/PriorityTransactionWrapper.kt | 4 +- .../transaction/ProcessModelTransaction.kt | 4 +- .../database => }/transaction/Transaction.kt | 3 +- .../transaction/TransactionWrapper.kt | 4 +- 217 files changed, 686 insertions(+), 614 deletions(-) rename dbflow-tests/src/test/java/com/raizlabs/android/dbflow/{sql => }/migration/UpdateTableMigrationTest.kt (91%) rename dbflow-tests/src/test/java/com/raizlabs/android/dbflow/{contentprovider => provider}/ContentProviderObjects.kt (92%) rename dbflow-tests/src/test/java/com/raizlabs/android/dbflow/{contentprovider => provider}/ContentProviderTests.kt (91%) rename dbflow-tests/src/test/java/com/raizlabs/android/dbflow/{contentprovider => provider}/RealContentProvider.kt (90%) rename dbflow-tests/src/test/java/com/raizlabs/android/dbflow/{contentprovider => provider}/TestContentProvider.kt (98%) rename dbflow-tests/src/test/java/com/raizlabs/android/dbflow/{structure => query}/cache/ModelLruCacheTest.kt (94%) rename dbflow-tests/src/test/java/com/raizlabs/android/dbflow/{structure => query}/cache/SimpleMapCacheTest.kt (94%) rename dbflow-tests/src/test/java/com/raizlabs/android/dbflow/{ => query}/list/FlowCursorIteratorTest.kt (94%) rename dbflow-tests/src/test/java/com/raizlabs/android/dbflow/{ => query}/list/FlowCursorListTest.kt (93%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql => }/SqlUtils.kt (92%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{structure => adapter}/InstanceAdapter.kt (91%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{structure => adapter}/InternalAdapter.kt (96%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{structure => adapter}/ModelAdapter.kt (94%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{structure => adapter}/ModelViewAdapter.kt (82%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{structure => adapter}/QueryModelAdapter.kt (83%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{structure => adapter}/RetrievalAdapter.kt (90%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql => adapter}/queriable/CacheableListModelLoader.kt (86%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql => adapter}/queriable/CacheableModelLoader.kt (86%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql => adapter}/queriable/ListModelLoader.kt (85%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql => adapter}/queriable/ModelLoader.kt (88%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql => adapter}/queriable/SingleKeyCacheableListModelLoader.kt (85%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql => adapter}/queriable/SingleKeyCacheableModelLoader.kt (87%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql => adapter}/queriable/SingleModelLoader.kt (81%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql => adapter}/saveable/AutoIncrementModelSaver.kt (90%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql => adapter}/saveable/CacheableListModelSaver.kt (93%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql => adapter}/saveable/ListModelSaver.kt (91%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql => adapter}/saveable/ModelSaver.kt (94%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{structure => }/database/AndroidDatabase.kt (98%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{structure => }/database/AndroidDatabaseStatement.kt (97%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{structure => }/database/BaseDatabaseHelper.kt (99%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{structure => }/database/BaseDatabaseStatement.kt (95%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{structure => }/database/ContentValueExtensions.kt (93%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{structure => }/database/DatabaseHelperDelegate.kt (98%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{structure => }/database/DatabaseHelperListener.kt (95%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{structure => }/database/DatabaseStatement.kt (93%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{structure => }/database/DatabaseStatementWrapper.kt (94%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{structure => }/database/DatabaseWrapper.kt (95%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{structure => }/database/FlowCursor.kt (99%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{structure => }/database/FlowSQLiteOpenHelper.kt (98%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{structure => }/database/OpenHelper.kt (87%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql => }/migration/AlterTableMigration.kt (96%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql => }/migration/BaseMigration.kt (75%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql => }/migration/IndexMigration.kt (80%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql => }/migration/IndexPropertyMigration.kt (74%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql => }/migration/Migration.kt (85%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql => }/migration/UpdateTableMigration.kt (81%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{runtime => provider}/BaseContentProvider.kt (90%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{structure => }/provider/BaseProviderModel.kt (90%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{structure => }/provider/BaseSyncableProviderModel.kt (88%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{structure => }/provider/ContentUtils.kt (97%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{structure => }/provider/ModelProvider.kt (86%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql/language => query}/Actionable.kt (78%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql/language => query}/BaseModelQueriable.kt (85%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql/language => query}/BaseOperator.kt (98%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql/language => query}/BaseQueriable.kt (83%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql/language => query}/BaseTransformable.kt (89%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql/language => query}/Case.kt (95%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql/language => query}/CaseCondition.kt (94%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql/language => query}/CompletedTrigger.kt (93%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{structure/listener => query}/ContentValuesListener.kt (92%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql/language => query}/CursorResult.kt (92%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql/language => query}/Delete.kt (93%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql/language => query}/ExistenceOperator.kt (95%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql/language => query}/From.kt (95%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql/language => query}/IConditional.kt (99%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql/language => query}/IOperator.kt (99%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql/language => query}/Index.kt (94%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql/language => query}/IndexedBy.kt (89%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql/language => query}/Insert.kt (98%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql/language => query}/Join.kt (96%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{structure/listener => query}/LoadFromCursorListener.kt (88%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql/language => query}/Method.kt (96%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql/queriable => query}/ModelQueriable.kt (87%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql/language => query}/NameAlias.kt (96%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql/language => query}/Operator.kt (98%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql/language => query}/OperatorGroup.kt (98%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql/language => query}/OrderBy.kt (94%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql/queriable => query}/Queriable.kt (81%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql/language => query}/SQLOperator.kt (96%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql/language => query}/SQLite.kt (92%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{structure/listener => query}/SQLiteStatementListener.kt (82%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql/language => query}/Select.kt (90%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql/language => query}/Set.kt (89%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql/queriable => query}/StringQuery.kt (79%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql/language => query}/Transformable.kt (89%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql/language => query}/Trigger.kt (96%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql/language => query}/TriggerMethod.kt (95%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql/language => query}/UnSafeStringOperator.kt (96%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql/language => query}/Update.kt (95%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql/language => query}/Where.kt (96%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql/language => query}/WhereBase.kt (75%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{structure => query}/cache/IMultiKeyCacheConverter.kt (93%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{structure => query}/cache/ModelCache.kt (95%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{structure => query}/cache/ModelLruCache.kt (97%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{structure => query}/cache/SimpleMapCache.kt (95%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{structure => query}/cache/SparseArrayBasedCache.kt (97%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{ => query}/list/FlowCursorIterator.kt (97%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{ => query}/list/FlowCursorList.kt (96%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{ => query}/list/FlowQueryList.kt (94%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{ => query}/list/IFlowCursorIterator.kt (95%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql/language => query}/property/IProperty.java (92%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql/language => query}/property/IndexProperty.kt (85%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql/language => query}/property/Property.kt (96%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql/language => query}/property/PropertyFactory.kt (95%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql/language => query}/property/TypeConvertedProperty.kt (90%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{sql/language => query}/property/WrapperProperty.kt (87%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{runtime => transaction}/BaseTransactionManager.kt (87%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{structure/database => }/transaction/Coroutines.kt (96%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{structure/database => }/transaction/DefaultTransactionManager.kt (82%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{structure/database => }/transaction/DefaultTransactionQueue.kt (97%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{structure/database => }/transaction/FastStoreModelTransaction.kt (95%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{structure/database => }/transaction/ITransaction.kt (79%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{structure/database => }/transaction/ITransactionQueue.kt (91%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{structure/database => }/transaction/PriorityTransactionQueue.kt (98%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{structure/database => }/transaction/PriorityTransactionWrapper.kt (93%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{structure/database => }/transaction/ProcessModelTransaction.kt (97%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{structure/database => }/transaction/Transaction.kt (98%) rename dbflow/src/main/java/com/raizlabs/android/dbflow/{structure/database => }/transaction/TransactionWrapper.kt (80%) diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/ClassNames.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/ClassNames.kt index 4875035ff..a57ec4ee8 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/ClassNames.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/ClassNames.kt @@ -13,18 +13,15 @@ object ClassNames { val FLOW_MANAGER_PACKAGE = BASE_PACKAGE + ".config" val DATABASE_HOLDER_STATIC_CLASS_NAME = "GeneratedDatabaseHolder" val CONVERTER = BASE_PACKAGE + ".converter" + val ADAPTER = BASE_PACKAGE + ".adapter" + val QUERY_PACKAGE = BASE_PACKAGE + ".query" val STRUCTURE = BASE_PACKAGE + ".structure" - val DATABASE = STRUCTURE + ".database" - val SQL = BASE_PACKAGE + ".sql" - val LANGUAGE = SQL + ".language" - val QUERIABLE = SQL + ".queriable" - val PROPERTY_PACKAGE = LANGUAGE + ".property" + val DATABASE = BASE_PACKAGE + ".database" + val QUERIABLE = ADAPTER + ".queriable" + val PROPERTY_PACKAGE = QUERY_PACKAGE + ".property" val CONFIG = BASE_PACKAGE + ".config" - val MIGRATION_PACKAGE = SQL + ".migration" - val LISTENER = STRUCTURE + ".listener" val RUNTIME = BASE_PACKAGE + ".runtime" - val TRANSACTION = RUNTIME + ".transaction" - val SAVEABLE = SQL + ".saveable" + val SAVEABLE = ADAPTER + ".saveable" val DATABASE_HOLDER = ClassName.get(CONFIG, "DatabaseHolder") val FLOW_MANAGER = ClassName.get(CONFIG, "FlowManager") @@ -38,27 +35,24 @@ object ClassNames { val CONTENT_VALUES = ClassName.get("android.content", "ContentValues") val CONTENT_URIS = ClassName.get("android.content", "ContentUris") - val MODEL_ADAPTER = ClassName.get(STRUCTURE, "ModelAdapter") - val QUERY_MODEL_ADAPTER = ClassName.get(STRUCTURE, "QueryModelAdapter") + val MODEL_ADAPTER = ClassName.get(ADAPTER, "ModelAdapter") + val QUERY_MODEL_ADAPTER = ClassName.get(ADAPTER, "QueryModelAdapter") val MODEL = ClassName.get(STRUCTURE, "Model") - val MODEL_VIEW_ADAPTER = ClassName.get(STRUCTURE, "ModelViewAdapter") - val MODEL_VIEW = ClassName.get(STRUCTURE, "BaseModelView") + val MODEL_VIEW_ADAPTER = ClassName.get(ADAPTER, "ModelViewAdapter") val DATABASE_STATEMENT = ClassName.get(DATABASE, "DatabaseStatement") - val QUERY = ClassName.get(SQL, "Query") + val QUERY = ClassName.get(QUERY_PACKAGE, "Query") val TYPE_CONVERTER = ClassName.get(CONVERTER, "TypeConverter") val TYPE_CONVERTER_GETTER: ClassName = ClassName.get(PROPERTY_PACKAGE, - "TypeConvertedProperty.TypeConverterGetter") - - val MIGRATION = ClassName.get(MIGRATION_PACKAGE, "Migration") + "TypeConvertedProperty.TypeConverterGetter") val CONFLICT_ACTION = ClassName.get(ConflictAction::class.java) - val CONTENT_VALUES_LISTENER = ClassName.get(LISTENER, "ContentValuesListener") - val LOAD_FROM_CURSOR_LISTENER = ClassName.get(LISTENER, "LoadFromCursorListener") - val SQLITE_STATEMENT_LISTENER = ClassName.get(LISTENER, "SQLiteStatementListener") + val CONTENT_VALUES_LISTENER = ClassName.get(QUERY_PACKAGE, "ContentValuesListener") + val LOAD_FROM_CURSOR_LISTENER = ClassName.get(QUERY_PACKAGE, "LoadFromCursorListener") + val SQLITE_STATEMENT_LISTENER = ClassName.get(QUERY_PACKAGE, "SQLiteStatementListener") val PROPERTY = ClassName.get(PROPERTY_PACKAGE, "Property") @@ -67,15 +61,15 @@ object ClassNames { val IPROPERTY = ClassName.get(PROPERTY_PACKAGE, "IProperty") val INDEX_PROPERTY = ClassName.get(PROPERTY_PACKAGE, "IndexProperty") - val OPERATOR_GROUP = ClassName.get(LANGUAGE, "OperatorGroup") + val OPERATOR_GROUP = ClassName.get(QUERY_PACKAGE, "OperatorGroup") - val ICONDITIONAL = ClassName.get(LANGUAGE, "IConditional") + val ICONDITIONAL = ClassName.get(QUERY_PACKAGE, "IConditional") val BASE_CONTENT_PROVIDER = ClassName.get(RUNTIME, "BaseContentProvider") - val BASE_MODEL = ClassName.get(STRUCTURE, "BaseModel") - val MODEL_CACHE = ClassName.get(STRUCTURE + ".cache", "ModelCache") - val MULTI_KEY_CACHE_CONVERTER = ClassName.get(STRUCTURE + ".cache", "IMultiKeyCacheConverter") + val BASE_MODEL = ClassName.get(ADAPTER, "BaseModel") + val MODEL_CACHE = ClassName.get(ADAPTER + ".cache", "ModelCache") + val MULTI_KEY_CACHE_CONVERTER = ClassName.get(ADAPTER + ".cache", "IMultiKeyCacheConverter") val CACHEABLE_MODEL_LOADER = ClassName.get(QUERIABLE, "CacheableModelLoader") val SINGLE_MODEL_LOADER = ClassName.get(QUERIABLE, "SingleModelLoader") @@ -84,7 +78,7 @@ object ClassNames { val DATABASE_WRAPPER = ClassName.get(DATABASE, "DatabaseWrapper") - val SQLITE = ClassName.get(LANGUAGE, "SQLite") + val SQLITE = ClassName.get(QUERY_PACKAGE, "SQLite") val CACHEABLE_LIST_MODEL_SAVER = ClassName.get(SAVEABLE, "CacheableListModelSaver") val SINGLE_MODEL_SAVER = ClassName.get(SAVEABLE, "ModelSaver") diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriber.kt b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriber.kt index 4408f95a7..881567d02 100644 --- a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriber.kt +++ b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriber.kt @@ -1,7 +1,7 @@ package com.raizlabs.android.dbflow.rx.language import com.raizlabs.android.dbflow.config.FlowLog -import com.raizlabs.android.dbflow.sql.language.CursorResult +import com.raizlabs.android.dbflow.query.CursorResult import rx.Observable import rx.Producer import rx.Subscriber diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXModelQueriable.kt b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXModelQueriable.kt index 64b80ca5e..349306551 100644 --- a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXModelQueriable.kt +++ b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXModelQueriable.kt @@ -1,10 +1,10 @@ package com.raizlabs.android.dbflow.rx.language -import com.raizlabs.android.dbflow.list.FlowCursorList -import com.raizlabs.android.dbflow.list.FlowQueryList -import com.raizlabs.android.dbflow.sql.language.CursorResult -import com.raizlabs.android.dbflow.sql.language.Join -import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable +import com.raizlabs.android.dbflow.query.list.FlowCursorList +import com.raizlabs.android.dbflow.query.list.FlowQueryList +import com.raizlabs.android.dbflow.query.CursorResult +import com.raizlabs.android.dbflow.query.Join +import com.raizlabs.android.dbflow.query.ModelQueriable import com.raizlabs.android.dbflow.structure.BaseQueryModel import rx.Observable import rx.Single diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXModelQueriableImpl.kt b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXModelQueriableImpl.kt index 793c39ca1..7bf22dcd8 100644 --- a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXModelQueriableImpl.kt +++ b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXModelQueriableImpl.kt @@ -1,10 +1,10 @@ package com.raizlabs.android.dbflow.rx.language -import com.raizlabs.android.dbflow.list.FlowCursorList -import com.raizlabs.android.dbflow.list.FlowQueryList -import com.raizlabs.android.dbflow.sql.language.BaseModelQueriable -import com.raizlabs.android.dbflow.sql.language.CursorResult -import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable +import com.raizlabs.android.dbflow.query.list.FlowCursorList +import com.raizlabs.android.dbflow.query.list.FlowQueryList +import com.raizlabs.android.dbflow.query.BaseModelQueriable +import com.raizlabs.android.dbflow.query.CursorResult +import com.raizlabs.android.dbflow.query.ModelQueriable import rx.Emitter import rx.Observable import rx.Single diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXQueriable.kt b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXQueriable.kt index e5fdea760..5c3d3a569 100644 --- a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXQueriable.kt +++ b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXQueriable.kt @@ -1,12 +1,12 @@ package com.raizlabs.android.dbflow.rx.language import android.database.Cursor -import com.raizlabs.android.dbflow.sql.language.Delete -import com.raizlabs.android.dbflow.sql.language.Insert -import com.raizlabs.android.dbflow.sql.language.Set -import com.raizlabs.android.dbflow.sql.queriable.Queriable +import com.raizlabs.android.dbflow.query.Delete +import com.raizlabs.android.dbflow.query.Insert +import com.raizlabs.android.dbflow.query.Set +import com.raizlabs.android.dbflow.query.Queriable import com.raizlabs.android.dbflow.structure.Model -import com.raizlabs.android.dbflow.structure.database.DatabaseStatement +import com.raizlabs.android.dbflow.database.DatabaseStatement import rx.Single /** diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXQueriableImpl.kt b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXQueriableImpl.kt index 7e19d61c8..9e7e7c131 100644 --- a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXQueriableImpl.kt +++ b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXQueriableImpl.kt @@ -1,9 +1,9 @@ package com.raizlabs.android.dbflow.rx.language import android.database.Cursor -import com.raizlabs.android.dbflow.sql.language.BaseQueriable -import com.raizlabs.android.dbflow.sql.queriable.Queriable -import com.raizlabs.android.dbflow.structure.database.DatabaseStatement +import com.raizlabs.android.dbflow.query.BaseQueriable +import com.raizlabs.android.dbflow.query.Queriable +import com.raizlabs.android.dbflow.database.DatabaseStatement import rx.Single import rx.Single.fromCallable diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXSQLite.kt b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXSQLite.kt index 606caa1d4..a76c4c962 100644 --- a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXSQLite.kt +++ b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXSQLite.kt @@ -2,9 +2,9 @@ package com.raizlabs.android.dbflow.rx.language -import com.raizlabs.android.dbflow.sql.language.BaseQueriable -import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable -import com.raizlabs.android.dbflow.sql.queriable.Queriable +import com.raizlabs.android.dbflow.query.BaseQueriable +import com.raizlabs.android.dbflow.query.ModelQueriable +import com.raizlabs.android.dbflow.query.Queriable fun ModelQueriable.rx(): RXModelQueriableImpl = RXModelQueriableImpl(this) diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/TableChangeListenerEmitter.java b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/TableChangeListenerEmitter.java index 4dac6e650..f7bd2d4e3 100644 --- a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/TableChangeListenerEmitter.java +++ b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/TableChangeListenerEmitter.java @@ -6,10 +6,10 @@ import com.raizlabs.android.dbflow.config.FlowManager; import com.raizlabs.android.dbflow.runtime.OnTableChangedListener; import com.raizlabs.android.dbflow.runtime.TableNotifierRegister; -import com.raizlabs.android.dbflow.sql.language.From; -import com.raizlabs.android.dbflow.sql.language.Join; -import com.raizlabs.android.dbflow.sql.language.Where; -import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable; +import com.raizlabs.android.dbflow.query.From; +import com.raizlabs.android.dbflow.query.Join; +import com.raizlabs.android.dbflow.query.Where; +import com.raizlabs.android.dbflow.query.ModelQueriable; import com.raizlabs.android.dbflow.structure.ChangeAction; import rx.Emitter; diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/structure/BaseRXModel.kt b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/structure/BaseRXModel.kt index 2883e0529..bf357150f 100644 --- a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/structure/BaseRXModel.kt +++ b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/structure/BaseRXModel.kt @@ -4,8 +4,8 @@ import com.raizlabs.android.dbflow.annotation.ColumnIgnore import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.structure.BaseModel import com.raizlabs.android.dbflow.structure.InvalidDBConfiguration -import com.raizlabs.android.dbflow.structure.ModelAdapter -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.adapter.ModelAdapter +import com.raizlabs.android.dbflow.database.DatabaseWrapper import rx.Completable import rx.Single diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/structure/RXModelAdapter.kt b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/structure/RXModelAdapter.kt index 4b738bbb2..eccf0792a 100644 --- a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/structure/RXModelAdapter.kt +++ b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/structure/RXModelAdapter.kt @@ -1,8 +1,8 @@ package com.raizlabs.android.dbflow.rx.structure import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.structure.ModelAdapter -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.adapter.ModelAdapter +import com.raizlabs.android.dbflow.database.DatabaseWrapper import rx.Completable import rx.Single diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/structure/RXRetrievalAdapter.kt b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/structure/RXRetrievalAdapter.kt index 965bc2a48..0495cca5c 100644 --- a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/structure/RXRetrievalAdapter.kt +++ b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/structure/RXRetrievalAdapter.kt @@ -1,8 +1,8 @@ package com.raizlabs.android.dbflow.rx.structure import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.structure.RetrievalAdapter -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.adapter.RetrievalAdapter +import com.raizlabs.android.dbflow.database.DatabaseWrapper import rx.Completable import rx.Single diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/CursorResultFlowable.kt b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/CursorResultFlowable.kt index cebf12bdf..1ec060da2 100644 --- a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/CursorResultFlowable.kt +++ b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/CursorResultFlowable.kt @@ -1,7 +1,7 @@ package com.raizlabs.android.dbflow.rx2.language import com.raizlabs.android.dbflow.config.FlowLog -import com.raizlabs.android.dbflow.sql.language.CursorResult +import com.raizlabs.android.dbflow.query.CursorResult import io.reactivex.Flowable import io.reactivex.SingleObserver import io.reactivex.disposables.Disposable diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXModelQueriable.kt b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXModelQueriable.kt index 17cb518d9..8d34a7dfa 100644 --- a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXModelQueriable.kt +++ b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXModelQueriable.kt @@ -1,10 +1,10 @@ package com.raizlabs.android.dbflow.rx2.language -import com.raizlabs.android.dbflow.list.FlowCursorList -import com.raizlabs.android.dbflow.list.FlowQueryList -import com.raizlabs.android.dbflow.sql.language.CursorResult -import com.raizlabs.android.dbflow.sql.language.Join -import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable +import com.raizlabs.android.dbflow.query.list.FlowCursorList +import com.raizlabs.android.dbflow.query.list.FlowQueryList +import com.raizlabs.android.dbflow.query.CursorResult +import com.raizlabs.android.dbflow.query.Join +import com.raizlabs.android.dbflow.query.ModelQueriable import com.raizlabs.android.dbflow.structure.BaseQueryModel import io.reactivex.Flowable import io.reactivex.Maybe diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXModelQueriableImpl.kt b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXModelQueriableImpl.kt index 76c465415..38c4c70cd 100644 --- a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXModelQueriableImpl.kt +++ b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXModelQueriableImpl.kt @@ -1,10 +1,10 @@ package com.raizlabs.android.dbflow.rx2.language -import com.raizlabs.android.dbflow.list.FlowCursorList -import com.raizlabs.android.dbflow.list.FlowQueryList -import com.raizlabs.android.dbflow.sql.language.BaseModelQueriable -import com.raizlabs.android.dbflow.sql.language.CursorResult -import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable +import com.raizlabs.android.dbflow.query.list.FlowCursorList +import com.raizlabs.android.dbflow.query.list.FlowQueryList +import com.raizlabs.android.dbflow.query.BaseModelQueriable +import com.raizlabs.android.dbflow.query.CursorResult +import com.raizlabs.android.dbflow.query.ModelQueriable import io.reactivex.BackpressureStrategy import io.reactivex.Flowable import io.reactivex.Maybe diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXQueriable.kt b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXQueriable.kt index 18948c260..87f18b46c 100644 --- a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXQueriable.kt +++ b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXQueriable.kt @@ -1,12 +1,12 @@ package com.raizlabs.android.dbflow.rx2.language import android.database.Cursor -import com.raizlabs.android.dbflow.sql.language.Delete -import com.raizlabs.android.dbflow.sql.language.Insert -import com.raizlabs.android.dbflow.sql.language.Set -import com.raizlabs.android.dbflow.sql.queriable.Queriable +import com.raizlabs.android.dbflow.query.Delete +import com.raizlabs.android.dbflow.query.Insert +import com.raizlabs.android.dbflow.query.Set +import com.raizlabs.android.dbflow.query.Queriable import com.raizlabs.android.dbflow.structure.Model -import com.raizlabs.android.dbflow.structure.database.DatabaseStatement +import com.raizlabs.android.dbflow.database.DatabaseStatement import io.reactivex.Completable import io.reactivex.Maybe import io.reactivex.Single diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXQueriableImpl.kt b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXQueriableImpl.kt index 1c660f891..c7344626b 100644 --- a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXQueriableImpl.kt +++ b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXQueriableImpl.kt @@ -1,9 +1,9 @@ package com.raizlabs.android.dbflow.rx2.language import android.database.Cursor -import com.raizlabs.android.dbflow.sql.language.BaseQueriable -import com.raizlabs.android.dbflow.sql.queriable.Queriable -import com.raizlabs.android.dbflow.structure.database.DatabaseStatement +import com.raizlabs.android.dbflow.query.BaseQueriable +import com.raizlabs.android.dbflow.query.Queriable +import com.raizlabs.android.dbflow.database.DatabaseStatement import io.reactivex.Completable import io.reactivex.Maybe import io.reactivex.Single diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXSQLite.kt b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXSQLite.kt index 0b40a6546..128edf8b1 100644 --- a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXSQLite.kt +++ b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXSQLite.kt @@ -2,8 +2,8 @@ package com.raizlabs.android.dbflow.rx2.language -import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable -import com.raizlabs.android.dbflow.sql.queriable.Queriable +import com.raizlabs.android.dbflow.query.ModelQueriable +import com.raizlabs.android.dbflow.query.Queriable fun ModelQueriable.rx(): RXModelQueriableImpl = RXModelQueriableImpl(this) diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/TableChangeOnSubscribe.kt b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/TableChangeOnSubscribe.kt index 4ebee8194..aca1f85f1 100644 --- a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/TableChangeOnSubscribe.kt +++ b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/TableChangeOnSubscribe.kt @@ -3,10 +3,10 @@ package com.raizlabs.android.dbflow.rx2.language import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.runtime.OnTableChangedListener import com.raizlabs.android.dbflow.runtime.TableNotifierRegister -import com.raizlabs.android.dbflow.sql.language.From -import com.raizlabs.android.dbflow.sql.language.Join -import com.raizlabs.android.dbflow.sql.language.Where -import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable +import com.raizlabs.android.dbflow.query.From +import com.raizlabs.android.dbflow.query.Join +import com.raizlabs.android.dbflow.query.Where +import com.raizlabs.android.dbflow.query.ModelQueriable import com.raizlabs.android.dbflow.structure.ChangeAction import io.reactivex.FlowableEmitter diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/structure/BaseRXModel.kt b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/structure/BaseRXModel.kt index 755af8910..d3a6e1ec4 100644 --- a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/structure/BaseRXModel.kt +++ b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/structure/BaseRXModel.kt @@ -4,8 +4,8 @@ import com.raizlabs.android.dbflow.annotation.ColumnIgnore import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.structure.BaseModel import com.raizlabs.android.dbflow.structure.InvalidDBConfiguration -import com.raizlabs.android.dbflow.structure.ModelAdapter -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.adapter.ModelAdapter +import com.raizlabs.android.dbflow.database.DatabaseWrapper import io.reactivex.Completable import io.reactivex.Single diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/structure/RXModelAdapter.kt b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/structure/RXModelAdapter.kt index 41a09846d..e2d8c1685 100644 --- a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/structure/RXModelAdapter.kt +++ b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/structure/RXModelAdapter.kt @@ -1,8 +1,8 @@ package com.raizlabs.android.dbflow.rx2.structure import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.structure.ModelAdapter -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.adapter.ModelAdapter +import com.raizlabs.android.dbflow.database.DatabaseWrapper import io.reactivex.Completable import io.reactivex.Completable.fromCallable import io.reactivex.Single diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/structure/RXRetrievalAdapter.kt b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/structure/RXRetrievalAdapter.kt index fbeac4994..5127c61ae 100644 --- a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/structure/RXRetrievalAdapter.kt +++ b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/structure/RXRetrievalAdapter.kt @@ -1,8 +1,8 @@ package com.raizlabs.android.dbflow.rx2.structure import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.structure.RetrievalAdapter -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.adapter.RetrievalAdapter +import com.raizlabs.android.dbflow.database.DatabaseWrapper import io.reactivex.Completable import io.reactivex.Single diff --git a/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherDatabase.kt b/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherDatabase.kt index 8f9b4d046..b05be6e70 100644 --- a/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherDatabase.kt +++ b/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherDatabase.kt @@ -2,9 +2,9 @@ package com.raizlabs.android.dbflow.sqlcipher import android.content.ContentValues -import com.raizlabs.android.dbflow.structure.database.DatabaseStatement -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper -import com.raizlabs.android.dbflow.structure.database.FlowCursor +import com.raizlabs.android.dbflow.database.DatabaseStatement +import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.android.dbflow.database.FlowCursor import net.sqlcipher.database.SQLiteDatabase diff --git a/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherOpenHelper.kt b/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherOpenHelper.kt index 3822b17c5..4cbf76076 100644 --- a/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherOpenHelper.kt +++ b/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherOpenHelper.kt @@ -5,11 +5,11 @@ import android.content.Context import com.raizlabs.android.dbflow.config.DatabaseConfig import com.raizlabs.android.dbflow.config.DatabaseDefinition import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.structure.database.BaseDatabaseHelper -import com.raizlabs.android.dbflow.structure.database.DatabaseHelperDelegate -import com.raizlabs.android.dbflow.structure.database.DatabaseHelperListener -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper -import com.raizlabs.android.dbflow.structure.database.OpenHelper +import com.raizlabs.android.dbflow.database.BaseDatabaseHelper +import com.raizlabs.android.dbflow.database.DatabaseHelperDelegate +import com.raizlabs.android.dbflow.database.DatabaseHelperListener +import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.android.dbflow.database.OpenHelper import net.sqlcipher.database.SQLiteDatabase import net.sqlcipher.database.SQLiteOpenHelper diff --git a/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherStatement.kt b/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherStatement.kt index f0f47633e..2a42e7222 100644 --- a/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherStatement.kt +++ b/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherStatement.kt @@ -1,7 +1,7 @@ package com.raizlabs.android.dbflow.sqlcipher -import com.raizlabs.android.dbflow.structure.database.BaseDatabaseStatement -import com.raizlabs.android.dbflow.structure.database.DatabaseStatement +import com.raizlabs.android.dbflow.database.BaseDatabaseStatement +import com.raizlabs.android.dbflow.database.DatabaseStatement import net.sqlcipher.database.SQLiteStatement diff --git a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/ImmediateTransactionManager.kt b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/ImmediateTransactionManager.kt index 777365fc5..a4d81c9e4 100644 --- a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/ImmediateTransactionManager.kt +++ b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/ImmediateTransactionManager.kt @@ -1,9 +1,9 @@ package com.raizlabs.android.dbflow import com.raizlabs.android.dbflow.config.DatabaseDefinition -import com.raizlabs.android.dbflow.runtime.BaseTransactionManager -import com.raizlabs.android.dbflow.structure.database.transaction.ITransactionQueue -import com.raizlabs.android.dbflow.structure.database.transaction.Transaction +import com.raizlabs.android.dbflow.transaction.BaseTransactionManager +import com.raizlabs.android.dbflow.transaction.ITransactionQueue +import com.raizlabs.android.dbflow.transaction.Transaction /** * Description: Executes all transactions on same thread for testing. diff --git a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/contentobserver/ContentObserverTest.kt b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/contentobserver/ContentObserverTest.kt index f6b7605e5..0a491ef22 100644 --- a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/contentobserver/ContentObserverTest.kt +++ b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/contentobserver/ContentObserverTest.kt @@ -9,10 +9,10 @@ import com.raizlabs.android.dbflow.config.tableName import com.raizlabs.android.dbflow.contentobserver.User_Table.id import com.raizlabs.android.dbflow.contentobserver.User_Table.name import com.raizlabs.android.dbflow.runtime.FlowContentObserver -import com.raizlabs.android.dbflow.sql.TABLE_QUERY_PARAM -import com.raizlabs.android.dbflow.sql.getNotificationUri -import com.raizlabs.android.dbflow.sql.language.SQLOperator -import com.raizlabs.android.dbflow.sql.language.delete +import com.raizlabs.android.dbflow.TABLE_QUERY_PARAM +import com.raizlabs.android.dbflow.getNotificationUri +import com.raizlabs.android.dbflow.query.SQLOperator +import com.raizlabs.android.dbflow.query.delete import com.raizlabs.android.dbflow.structure.ChangeAction import com.raizlabs.android.dbflow.structure.delete import com.raizlabs.android.dbflow.structure.insert @@ -59,7 +59,6 @@ class ContentObserverTest : BaseInstrumentedUnitTest() { @Test fun testSpecificUrlUpdate() { - user.save() assertProperConditions(ChangeAction.UPDATE, { it.apply { age = 56 }.update() }) } diff --git a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/prepackaged/PrepackagedDBTest.kt b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/prepackaged/PrepackagedDBTest.kt index 138eb1973..f2f1850e4 100644 --- a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/prepackaged/PrepackagedDBTest.kt +++ b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/prepackaged/PrepackagedDBTest.kt @@ -2,8 +2,8 @@ package com.raizlabs.android.dbflow.prepackaged import com.raizlabs.android.dbflow.BaseInstrumentedUnitTest import com.raizlabs.android.dbflow.config.databaseForTable -import com.raizlabs.android.dbflow.sql.language.select -import com.raizlabs.android.dbflow.sql.queriable.list +import com.raizlabs.android.dbflow.query.select +import com.raizlabs.android.dbflow.query.list import org.junit.Assert.assertTrue import org.junit.Test diff --git a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/sqlcipher/CipherTest.kt b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/sqlcipher/CipherTest.kt index ff43998e0..1a6cdc0e3 100644 --- a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/sqlcipher/CipherTest.kt +++ b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/sqlcipher/CipherTest.kt @@ -2,10 +2,10 @@ package com.raizlabs.android.dbflow.sqlcipher import com.raizlabs.android.dbflow.BaseInstrumentedUnitTest import com.raizlabs.android.dbflow.config.database -import com.raizlabs.android.dbflow.sql.language.delete -import com.raizlabs.android.dbflow.sql.language.select -import com.raizlabs.android.dbflow.sql.language.where -import com.raizlabs.android.dbflow.sql.queriable.result +import com.raizlabs.android.dbflow.query.delete +import com.raizlabs.android.dbflow.query.select +import com.raizlabs.android.dbflow.query.where +import com.raizlabs.android.dbflow.query.result import org.junit.Assert.assertTrue import org.junit.Test diff --git a/dbflow-tests/src/main/java/com/raizlabs/android/dbflow/sqlcipher/CipherTestObjects.kt b/dbflow-tests/src/main/java/com/raizlabs/android/dbflow/sqlcipher/CipherTestObjects.kt index 39fa68c8b..43a7b0e7d 100644 --- a/dbflow-tests/src/main/java/com/raizlabs/android/dbflow/sqlcipher/CipherTestObjects.kt +++ b/dbflow-tests/src/main/java/com/raizlabs/android/dbflow/sqlcipher/CipherTestObjects.kt @@ -5,7 +5,7 @@ import com.raizlabs.android.dbflow.annotation.PrimaryKey import com.raizlabs.android.dbflow.annotation.Table import com.raizlabs.android.dbflow.config.DatabaseDefinition import com.raizlabs.android.dbflow.structure.BaseModel -import com.raizlabs.android.dbflow.structure.database.DatabaseHelperListener +import com.raizlabs.android.dbflow.database.DatabaseHelperListener class SQLCipherOpenHelperImpl(databaseDefinition: DatabaseDefinition, helperListener: DatabaseHelperListener?) : SQLCipherOpenHelper(databaseDefinition, helperListener) { diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/DBFlowTestRule.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/DBFlowTestRule.kt index f253afadb..45277e834 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/DBFlowTestRule.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/DBFlowTestRule.kt @@ -3,7 +3,7 @@ package com.raizlabs.android.dbflow import com.raizlabs.android.dbflow.config.DatabaseConfig import com.raizlabs.android.dbflow.config.FlowConfig import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.contentprovider.ContentDatabase +import com.raizlabs.android.dbflow.provider.ContentDatabase import org.junit.rules.TestRule import org.junit.runner.Description import org.junit.runners.model.Statement diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/ImmediateTransactionManager.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/ImmediateTransactionManager.kt index 1d45c9947..a68ed063d 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/ImmediateTransactionManager.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/ImmediateTransactionManager.kt @@ -1,9 +1,9 @@ package com.raizlabs.android.dbflow import com.raizlabs.android.dbflow.config.DatabaseDefinition -import com.raizlabs.android.dbflow.runtime.BaseTransactionManager -import com.raizlabs.android.dbflow.structure.database.transaction.ITransactionQueue -import com.raizlabs.android.dbflow.structure.database.transaction.Transaction +import com.raizlabs.android.dbflow.transaction.BaseTransactionManager +import com.raizlabs.android.dbflow.transaction.ITransactionQueue +import com.raizlabs.android.dbflow.transaction.Transaction /** * Description: Executes all transactions on same thread for testing. diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/TestDatabase.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/TestDatabase.kt index 44f4860da..44b4feeb2 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/TestDatabase.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/TestDatabase.kt @@ -3,7 +3,7 @@ package com.raizlabs.android.dbflow import com.raizlabs.android.dbflow.annotation.Database import com.raizlabs.android.dbflow.annotation.Migration import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.sql.migration.UpdateTableMigration +import com.raizlabs.android.dbflow.migration.UpdateTableMigration /** * Description: diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/config/ConfigIntegrationTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/config/ConfigIntegrationTest.kt index ee440b3eb..cddb15558 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/config/ConfigIntegrationTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/config/ConfigIntegrationTest.kt @@ -3,9 +3,9 @@ package com.raizlabs.android.dbflow.config import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.TestDatabase import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.sql.queriable.ListModelLoader -import com.raizlabs.android.dbflow.sql.queriable.SingleModelLoader -import com.raizlabs.android.dbflow.sql.saveable.ModelSaver +import com.raizlabs.android.dbflow.adapter.queriable.ListModelLoader +import com.raizlabs.android.dbflow.adapter.queriable.SingleModelLoader +import com.raizlabs.android.dbflow.adapter.saveable.ModelSaver import org.junit.Assert.* import org.junit.Before import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/config/DatabaseConfigTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/config/DatabaseConfigTest.kt index 414fb899e..1f609a017 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/config/DatabaseConfigTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/config/DatabaseConfigTest.kt @@ -3,9 +3,9 @@ package com.raizlabs.android.dbflow.config import com.nhaarman.mockito_kotlin.mock import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.TestDatabase -import com.raizlabs.android.dbflow.runtime.BaseTransactionManager -import com.raizlabs.android.dbflow.structure.database.DatabaseHelperListener -import com.raizlabs.android.dbflow.structure.database.OpenHelper +import com.raizlabs.android.dbflow.transaction.BaseTransactionManager +import com.raizlabs.android.dbflow.database.DatabaseHelperListener +import com.raizlabs.android.dbflow.database.OpenHelper import org.junit.Assert import org.junit.Before import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/CoroutinesTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/CoroutinesTest.kt index 02e5bfe10..be20525b0 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/CoroutinesTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/CoroutinesTest.kt @@ -5,15 +5,15 @@ import com.raizlabs.android.dbflow.TestDatabase import com.raizlabs.android.dbflow.config.database import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table -import com.raizlabs.android.dbflow.sql.language.delete -import com.raizlabs.android.dbflow.sql.language.select -import com.raizlabs.android.dbflow.sql.language.where -import com.raizlabs.android.dbflow.sql.queriable.list -import com.raizlabs.android.dbflow.structure.database.transaction.awaitDelete -import com.raizlabs.android.dbflow.structure.database.transaction.awaitInsert -import com.raizlabs.android.dbflow.structure.database.transaction.awaitSave -import com.raizlabs.android.dbflow.structure.database.transaction.awaitUpdate -import com.raizlabs.android.dbflow.structure.database.transaction.transact +import com.raizlabs.android.dbflow.query.delete +import com.raizlabs.android.dbflow.query.select +import com.raizlabs.android.dbflow.query.where +import com.raizlabs.android.dbflow.query.list +import com.raizlabs.android.dbflow.transaction.awaitDelete +import com.raizlabs.android.dbflow.transaction.awaitInsert +import com.raizlabs.android.dbflow.transaction.awaitSave +import com.raizlabs.android.dbflow.transaction.awaitUpdate +import com.raizlabs.android.dbflow.transaction.transact import com.raizlabs.android.dbflow.structure.save import kotlinx.coroutines.experimental.runBlocking import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/FastStoreModelTransactionTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/FastStoreModelTransactionTest.kt index 48e7e14d2..727364ef7 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/FastStoreModelTransactionTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/FastStoreModelTransactionTest.kt @@ -5,11 +5,11 @@ import com.raizlabs.android.dbflow.TestDatabase import com.raizlabs.android.dbflow.config.database import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.TwoColumnModel -import com.raizlabs.android.dbflow.sql.language.select -import com.raizlabs.android.dbflow.sql.queriable.list -import com.raizlabs.android.dbflow.structure.database.transaction.fastInsert -import com.raizlabs.android.dbflow.structure.database.transaction.fastSave -import com.raizlabs.android.dbflow.structure.database.transaction.fastUpdate +import com.raizlabs.android.dbflow.query.select +import com.raizlabs.android.dbflow.query.list +import com.raizlabs.android.dbflow.transaction.fastInsert +import com.raizlabs.android.dbflow.transaction.fastSave +import com.raizlabs.android.dbflow.transaction.fastUpdate import org.junit.Assert.assertEquals import org.junit.Assert.assertNotEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/migration/UpdateTableMigrationTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/migration/UpdateTableMigrationTest.kt similarity index 91% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/migration/UpdateTableMigrationTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/android/dbflow/migration/UpdateTableMigrationTest.kt index 507513b54..3764ef315 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/migration/UpdateTableMigrationTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/migration/UpdateTableMigrationTest.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.sql.migration +package com.raizlabs.android.dbflow.migration import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.config.databaseForTable diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/CachingModels.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/CachingModels.kt index 3a5d8e5f2..64332d7b1 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/CachingModels.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/CachingModels.kt @@ -6,7 +6,7 @@ import com.raizlabs.android.dbflow.annotation.ForeignKey import com.raizlabs.android.dbflow.annotation.MultiCacheField import com.raizlabs.android.dbflow.annotation.PrimaryKey import com.raizlabs.android.dbflow.annotation.Table -import com.raizlabs.android.dbflow.structure.cache.IMultiKeyCacheConverter +import com.raizlabs.android.dbflow.query.cache.IMultiKeyCacheConverter @Table(database = TestDatabase::class, cachingEnabled = true) class SimpleCacheObject(@PrimaryKey var id: String = "") diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/CachingModelsTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/CachingModelsTest.kt index 0b68c4ed7..5dfb07e11 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/CachingModelsTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/CachingModelsTest.kt @@ -3,9 +3,9 @@ package com.raizlabs.android.dbflow.models import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.TestDatabase import com.raizlabs.android.dbflow.config.database -import com.raizlabs.android.dbflow.sql.language.select -import com.raizlabs.android.dbflow.sql.queriable.list -import com.raizlabs.android.dbflow.sql.queriable.result +import com.raizlabs.android.dbflow.query.select +import com.raizlabs.android.dbflow.query.list +import com.raizlabs.android.dbflow.query.result import com.raizlabs.android.dbflow.structure.save import org.junit.Assert.assertEquals import org.junit.Assert.assertNotEquals diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/DontCreateModelTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/DontCreateModelTest.kt index abd8e4064..77f8a1aa7 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/DontCreateModelTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/DontCreateModelTest.kt @@ -4,8 +4,8 @@ import android.database.sqlite.SQLiteException import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.assertThrowsException import com.raizlabs.android.dbflow.config.databaseForTable -import com.raizlabs.android.dbflow.sql.language.select -import com.raizlabs.android.dbflow.sql.queriable.list +import com.raizlabs.android.dbflow.query.select +import com.raizlabs.android.dbflow.query.list import org.junit.Test /** diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ForeignKeyModels.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ForeignKeyModels.kt index 7e1c84237..0bd4d4bb8 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ForeignKeyModels.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ForeignKeyModels.kt @@ -12,7 +12,7 @@ import com.raizlabs.android.dbflow.annotation.ForeignKeyReference import com.raizlabs.android.dbflow.annotation.NotNull import com.raizlabs.android.dbflow.annotation.PrimaryKey import com.raizlabs.android.dbflow.annotation.Table -import com.raizlabs.android.dbflow.structure.listener.LoadFromCursorListener +import com.raizlabs.android.dbflow.query.LoadFromCursorListener /** * Example of simple foreign key object with one foreign key object. diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ModelViews.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ModelViews.kt index 4aeb27eef..4f4e60810 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ModelViews.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ModelViews.kt @@ -6,10 +6,10 @@ import com.raizlabs.android.dbflow.annotation.ColumnMap import com.raizlabs.android.dbflow.annotation.ModelView import com.raizlabs.android.dbflow.annotation.ModelViewQuery import com.raizlabs.android.dbflow.models.Author_Table.* -import com.raizlabs.android.dbflow.sql.language.property.IProperty -import com.raizlabs.android.dbflow.sql.language.property.property -import com.raizlabs.android.dbflow.sql.language.select -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.query.property.IProperty +import com.raizlabs.android.dbflow.query.property.property +import com.raizlabs.android.dbflow.query.select +import com.raizlabs.android.dbflow.database.DatabaseWrapper class AuthorName(var name: String = "", var age: Int = 0) diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModelTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModelTest.kt index f50c47e54..6fbd907ae 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModelTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModelTest.kt @@ -3,9 +3,9 @@ package com.raizlabs.android.dbflow.models import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.TestDatabase import com.raizlabs.android.dbflow.config.database -import com.raizlabs.android.dbflow.sql.language.select -import com.raizlabs.android.dbflow.sql.queriable.list -import com.raizlabs.android.dbflow.sql.queriable.result +import com.raizlabs.android.dbflow.query.select +import com.raizlabs.android.dbflow.query.list +import com.raizlabs.android.dbflow.query.result import com.raizlabs.android.dbflow.structure.delete import com.raizlabs.android.dbflow.structure.exists import com.raizlabs.android.dbflow.structure.save diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModels.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModels.kt index e3ddd4fbb..ae4ce6dd5 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModels.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModels.kt @@ -7,10 +7,10 @@ import com.raizlabs.android.dbflow.annotation.PrimaryKey import com.raizlabs.android.dbflow.annotation.Table import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id -import com.raizlabs.android.dbflow.sql.language.select -import com.raizlabs.android.dbflow.sql.language.where +import com.raizlabs.android.dbflow.query.select +import com.raizlabs.android.dbflow.query.where import com.raizlabs.android.dbflow.structure.BaseModel -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.database.DatabaseWrapper import com.raizlabs.android.dbflow.structure.oneToMany @Table(database = TestDatabase::class) diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ParentChildCachingTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ParentChildCachingTest.kt index 73ace6c83..911241b2f 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ParentChildCachingTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ParentChildCachingTest.kt @@ -3,8 +3,8 @@ package com.raizlabs.android.dbflow.models import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.TestDatabase import com.raizlabs.android.dbflow.config.database -import com.raizlabs.android.dbflow.sql.language.select -import com.raizlabs.android.dbflow.sql.queriable.result +import com.raizlabs.android.dbflow.query.select +import com.raizlabs.android.dbflow.query.result import com.raizlabs.android.dbflow.structure.load import com.raizlabs.android.dbflow.structure.save import org.junit.Assert.assertEquals diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/QueryModelTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/QueryModelTest.kt index 8cbff9b80..4e45daa90 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/QueryModelTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/QueryModelTest.kt @@ -6,10 +6,10 @@ import com.raizlabs.android.dbflow.config.database import com.raizlabs.android.dbflow.models.Author_Table.id import com.raizlabs.android.dbflow.models.Blog_Table.author_id import com.raizlabs.android.dbflow.models.Blog_Table.name -import com.raizlabs.android.dbflow.sql.language.eq -import com.raizlabs.android.dbflow.sql.language.innerJoin -import com.raizlabs.android.dbflow.sql.language.on -import com.raizlabs.android.dbflow.sql.language.select +import com.raizlabs.android.dbflow.query.eq +import com.raizlabs.android.dbflow.query.innerJoin +import com.raizlabs.android.dbflow.query.on +import com.raizlabs.android.dbflow.query.select import com.raizlabs.android.dbflow.structure.exists import com.raizlabs.android.dbflow.structure.save import org.junit.Assert.assertEquals diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/SimpleTestModels.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/SimpleTestModels.kt index d18a5be15..0b36cd054 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/SimpleTestModels.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/SimpleTestModels.kt @@ -12,8 +12,8 @@ import com.raizlabs.android.dbflow.annotation.Table import com.raizlabs.android.dbflow.converter.TypeConverter import com.raizlabs.android.dbflow.data.Blob import com.raizlabs.android.dbflow.structure.BaseModel -import com.raizlabs.android.dbflow.structure.database.DatabaseStatement -import com.raizlabs.android.dbflow.structure.listener.SQLiteStatementListener +import com.raizlabs.android.dbflow.database.DatabaseStatement +import com.raizlabs.android.dbflow.query.SQLiteStatementListener import java.math.BigDecimal import java.math.BigInteger import java.util.* diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/Issue.java b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/Issue.java index e3cacf45e..b3792f92e 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/Issue.java +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/Issue.java @@ -5,13 +5,12 @@ import com.raizlabs.android.dbflow.annotation.OneToManyMethod; import com.raizlabs.android.dbflow.annotation.PrimaryKey; import com.raizlabs.android.dbflow.annotation.Table; -import com.raizlabs.android.dbflow.sql.language.SQLite; import com.raizlabs.android.dbflow.structure.BaseModel; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; +import com.raizlabs.android.dbflow.database.DatabaseWrapper; import java.util.List; -import static com.raizlabs.android.dbflow.sql.language.SQLite.select; +import static com.raizlabs.android.dbflow.query.SQLite.select; /** * Description: diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/SubIssue.java b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/SubIssue.java index 67cce6d10..507d5d7f1 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/SubIssue.java +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/SubIssue.java @@ -6,12 +6,12 @@ import com.raizlabs.android.dbflow.annotation.PrimaryKey; import com.raizlabs.android.dbflow.annotation.Table; import com.raizlabs.android.dbflow.structure.BaseModel; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; +import com.raizlabs.android.dbflow.database.DatabaseWrapper; import java.util.ArrayList; import java.util.List; -import static com.raizlabs.android.dbflow.sql.language.SQLite.select; +import static com.raizlabs.android.dbflow.query.SQLite.select; /** * Description: diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/java/JavaModelView.java b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/java/JavaModelView.java index c9acb8887..f50fcc5e2 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/java/JavaModelView.java +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/java/JavaModelView.java @@ -5,9 +5,9 @@ import com.raizlabs.android.dbflow.annotation.ModelView; import com.raizlabs.android.dbflow.annotation.ModelViewQuery; import com.raizlabs.android.dbflow.models.Author_Table; +import com.raizlabs.android.dbflow.query.SQLite; import com.raizlabs.android.dbflow.sql.Query; -import com.raizlabs.android.dbflow.sql.language.SQLite; -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper; +import com.raizlabs.android.dbflow.database.DatabaseWrapper; @ModelView(database = TestDatabase.class) public class JavaModelView { diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/contentprovider/ContentProviderObjects.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/provider/ContentProviderObjects.kt similarity index 92% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/contentprovider/ContentProviderObjects.kt rename to dbflow-tests/src/test/java/com/raizlabs/android/dbflow/provider/ContentProviderObjects.kt index ba7eac6ab..e1ba22958 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/contentprovider/ContentProviderObjects.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/provider/ContentProviderObjects.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.contentprovider +package com.raizlabs.android.dbflow.provider import com.raizlabs.android.dbflow.annotation.Column import com.raizlabs.android.dbflow.annotation.Database @@ -10,9 +10,6 @@ import com.raizlabs.android.dbflow.annotation.provider.ContentProvider import com.raizlabs.android.dbflow.annotation.provider.ContentType import com.raizlabs.android.dbflow.annotation.provider.ContentUri import com.raizlabs.android.dbflow.annotation.provider.TableEndpoint -import com.raizlabs.android.dbflow.structure.provider.BaseProviderModel -import com.raizlabs.android.dbflow.structure.provider.BaseSyncableProviderModel -import com.raizlabs.android.dbflow.structure.provider.ContentUtils /** diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/contentprovider/ContentProviderTests.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/provider/ContentProviderTests.kt similarity index 91% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/contentprovider/ContentProviderTests.kt rename to dbflow-tests/src/test/java/com/raizlabs/android/dbflow/provider/ContentProviderTests.kt index 91ee77d76..d3ef104de 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/contentprovider/ContentProviderTests.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/provider/ContentProviderTests.kt @@ -1,18 +1,17 @@ -package com.raizlabs.android.dbflow.contentprovider +package com.raizlabs.android.dbflow.provider import android.content.ContentResolver import android.content.pm.ProviderInfo import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.config.database -import com.raizlabs.android.dbflow.sql.language.Delete.Companion.table -import com.raizlabs.android.dbflow.sql.language.Delete.Companion.tables -import com.raizlabs.android.dbflow.sql.language.select -import com.raizlabs.android.dbflow.sql.language.where -import com.raizlabs.android.dbflow.sql.queriable.result +import com.raizlabs.android.dbflow.query.Delete.Companion.table +import com.raizlabs.android.dbflow.query.Delete.Companion.tables +import com.raizlabs.android.dbflow.query.select +import com.raizlabs.android.dbflow.query.where +import com.raizlabs.android.dbflow.query.result import com.raizlabs.android.dbflow.structure.delete import com.raizlabs.android.dbflow.structure.exists import com.raizlabs.android.dbflow.structure.insert -import com.raizlabs.android.dbflow.structure.provider.ContentUtils import com.raizlabs.android.dbflow.structure.save import com.raizlabs.android.dbflow.structure.update import org.junit.Assert.* diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/contentprovider/RealContentProvider.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/provider/RealContentProvider.kt similarity index 90% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/contentprovider/RealContentProvider.kt rename to dbflow-tests/src/test/java/com/raizlabs/android/dbflow/provider/RealContentProvider.kt index ad4ae5a3d..07a0ba5af 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/contentprovider/RealContentProvider.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/provider/RealContentProvider.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.contentprovider +package com.raizlabs.android.dbflow.provider import android.content.ContentProvider import android.content.ContentValues @@ -7,7 +7,7 @@ import android.net.Uri import com.raizlabs.android.dbflow.TestDatabase import com.raizlabs.android.dbflow.config.FlowConfig import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.database.DatabaseWrapper class RealContentProvider : ContentProvider() { diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/contentprovider/TestContentProvider.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/provider/TestContentProvider.kt similarity index 98% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/contentprovider/TestContentProvider.kt rename to dbflow-tests/src/test/java/com/raizlabs/android/dbflow/provider/TestContentProvider.kt index 2e5441280..a2c5df700 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/contentprovider/TestContentProvider.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/provider/TestContentProvider.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.contentprovider +package com.raizlabs.android.dbflow.provider import android.content.ContentValues import android.content.Context @@ -10,7 +10,7 @@ import com.raizlabs.android.dbflow.annotation.provider.Notify import com.raizlabs.android.dbflow.annotation.provider.NotifyMethod import com.raizlabs.android.dbflow.annotation.provider.PathSegment import com.raizlabs.android.dbflow.annotation.provider.TableEndpoint -import com.raizlabs.android.dbflow.sql.getContentValuesKey +import com.raizlabs.android.dbflow.getContentValuesKey @ContentProvider(authority = TestContentProvider.AUTHORITY, database = ContentDatabase::class, baseContentUri = TestContentProvider.BASE_CONTENT_URI) diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/structure/cache/ModelLruCacheTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/query/cache/ModelLruCacheTest.kt similarity index 94% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/structure/cache/ModelLruCacheTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/android/dbflow/query/cache/ModelLruCacheTest.kt index c80503dcc..cc80d78da 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/structure/cache/ModelLruCacheTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/query/cache/ModelLruCacheTest.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.structure.cache +package com.raizlabs.android.dbflow.query.cache import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.models.NumberModel diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/structure/cache/SimpleMapCacheTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/query/cache/SimpleMapCacheTest.kt similarity index 94% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/structure/cache/SimpleMapCacheTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/android/dbflow/query/cache/SimpleMapCacheTest.kt index 1de1d9e15..e17e2805e 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/structure/cache/SimpleMapCacheTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/query/cache/SimpleMapCacheTest.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.structure.cache +package com.raizlabs.android.dbflow.query.cache import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.models.SimpleModel diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorIteratorTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/query/list/FlowCursorIteratorTest.kt similarity index 94% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorIteratorTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/android/dbflow/query/list/FlowCursorIteratorTest.kt index d9181a9b4..9d5abafa2 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorIteratorTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/query/list/FlowCursorIteratorTest.kt @@ -1,9 +1,9 @@ -package com.raizlabs.android.dbflow.list +package com.raizlabs.android.dbflow.query.list import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.sql.language.select +import com.raizlabs.android.dbflow.query.select import com.raizlabs.android.dbflow.structure.save import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorListTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/query/list/FlowCursorListTest.kt similarity index 93% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorListTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/android/dbflow/query/list/FlowCursorListTest.kt index 476ac79b2..55529dc85 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/list/FlowCursorListTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/query/list/FlowCursorListTest.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.list +package com.raizlabs.android.dbflow.query.list import com.nhaarman.mockito_kotlin.mock import com.nhaarman.mockito_kotlin.times @@ -6,8 +6,8 @@ import com.nhaarman.mockito_kotlin.verify import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.sql.language.select -import com.raizlabs.android.dbflow.sql.queriable.cursor +import com.raizlabs.android.dbflow.query.select +import com.raizlabs.android.dbflow.query.cursor import com.raizlabs.android.dbflow.structure.save import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/runtime/DirectNotifierTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/runtime/DirectNotifierTest.kt index 298b09d76..ac155e05a 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/runtime/DirectNotifierTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/runtime/DirectNotifierTest.kt @@ -12,11 +12,11 @@ import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table -import com.raizlabs.android.dbflow.sql.language.columnValues -import com.raizlabs.android.dbflow.sql.language.delete -import com.raizlabs.android.dbflow.sql.language.insert -import com.raizlabs.android.dbflow.sql.language.set -import com.raizlabs.android.dbflow.sql.language.update +import com.raizlabs.android.dbflow.query.columnValues +import com.raizlabs.android.dbflow.query.delete +import com.raizlabs.android.dbflow.query.insert +import com.raizlabs.android.dbflow.query.set +import com.raizlabs.android.dbflow.query.update import com.raizlabs.android.dbflow.structure.ChangeAction import com.raizlabs.android.dbflow.structure.delete import com.raizlabs.android.dbflow.structure.insert diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriberTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriberTest.kt index ecc5f3bfb..4ff2599c2 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriberTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriberTest.kt @@ -3,7 +3,7 @@ package com.raizlabs.android.dbflow.rx.language import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.sql.language.select +import com.raizlabs.android.dbflow.query.select import com.raizlabs.android.dbflow.structure.save import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/RXQueryTests.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/RXQueryTests.kt index 76196f18c..e0622fe7f 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/RXQueryTests.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/RXQueryTests.kt @@ -5,11 +5,11 @@ import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table.name -import com.raizlabs.android.dbflow.sql.language.insert -import com.raizlabs.android.dbflow.sql.language.property.Property -import com.raizlabs.android.dbflow.sql.language.select -import com.raizlabs.android.dbflow.sql.language.selectCountOf -import com.raizlabs.android.dbflow.structure.database.DatabaseStatement +import com.raizlabs.android.dbflow.query.insert +import com.raizlabs.android.dbflow.query.property.Property +import com.raizlabs.android.dbflow.query.select +import com.raizlabs.android.dbflow.query.selectCountOf +import com.raizlabs.android.dbflow.database.DatabaseStatement import com.raizlabs.android.dbflow.structure.save import org.junit.Assert.assertEquals import org.junit.Assert.assertNotNull diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CaseTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CaseTest.kt index 2ce9041c7..c8763cbae 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CaseTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CaseTest.kt @@ -2,7 +2,8 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.models.SimpleModel_Table -import com.raizlabs.android.dbflow.sql.language.property.propertyString +import com.raizlabs.android.dbflow.query.caseWhen +import com.raizlabs.android.dbflow.query.property.propertyString import org.junit.Assert.* import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CursorResultTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CursorResultTest.kt index d4fa14f18..5a797dc4a 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CursorResultTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CursorResultTest.kt @@ -5,7 +5,13 @@ import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.models.SimpleCustomModel import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.sql.queriable.cursorResult +import com.raizlabs.android.dbflow.query.CursorResult +import com.raizlabs.android.dbflow.query.select +import com.raizlabs.android.dbflow.query.toCustomList +import com.raizlabs.android.dbflow.query.toCustomListClose +import com.raizlabs.android.dbflow.query.toCustomModel +import com.raizlabs.android.dbflow.query.toCustomModelClose +import com.raizlabs.android.dbflow.query.cursorResult import com.raizlabs.android.dbflow.structure.save import org.junit.Assert.* import org.junit.Before diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/DeleteTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/DeleteTest.kt index e06e71845..66f777321 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/DeleteTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/DeleteTest.kt @@ -4,7 +4,9 @@ import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table -import com.raizlabs.android.dbflow.sql.queriable.list +import com.raizlabs.android.dbflow.query.delete +import com.raizlabs.android.dbflow.query.select +import com.raizlabs.android.dbflow.query.list import com.raizlabs.android.dbflow.structure.save import org.junit.Assert.assertEquals import org.junit.Assert.assertFalse diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/ExistenceOperatorTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/ExistenceOperatorTest.kt index 9ee9e87dd..8ba168777 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/ExistenceOperatorTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/ExistenceOperatorTest.kt @@ -4,6 +4,9 @@ import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table +import com.raizlabs.android.dbflow.query.ExistenceOperator +import com.raizlabs.android.dbflow.query.select +import com.raizlabs.android.dbflow.query.where import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/FromTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/FromTest.kt index fab82db5e..b76156e88 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/FromTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/FromTest.kt @@ -7,6 +7,9 @@ import com.raizlabs.android.dbflow.models.SimpleModel_Table.name import com.raizlabs.android.dbflow.models.TwoColumnModel import com.raizlabs.android.dbflow.models.TwoColumnModel_Table import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id +import com.raizlabs.android.dbflow.query.innerJoin +import com.raizlabs.android.dbflow.query.on +import com.raizlabs.android.dbflow.query.select import org.junit.Assert.assertEquals import org.junit.Assert.assertTrue import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexTest.kt index 370ddbe7d..80e6865b2 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexTest.kt @@ -4,6 +4,8 @@ import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table +import com.raizlabs.android.dbflow.query.indexOn +import com.raizlabs.android.dbflow.query.nameAlias import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexedByTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexedByTest.kt index eaeb7a7d6..3dc065510 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexedByTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexedByTest.kt @@ -4,7 +4,8 @@ import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table -import com.raizlabs.android.dbflow.sql.language.property.IndexProperty +import com.raizlabs.android.dbflow.query.select +import com.raizlabs.android.dbflow.query.property.IndexProperty import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/InsertTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/InsertTest.kt index d8f8bd96b..17c14fb50 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/InsertTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/InsertTest.kt @@ -7,7 +7,12 @@ import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.TwoColumnModel import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.name -import com.raizlabs.android.dbflow.structure.database.set +import com.raizlabs.android.dbflow.query.NameAlias +import com.raizlabs.android.dbflow.query.Operator +import com.raizlabs.android.dbflow.query.OperatorGroup +import com.raizlabs.android.dbflow.query.insert +import com.raizlabs.android.dbflow.query.select +import com.raizlabs.android.dbflow.database.set import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/JoinTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/JoinTest.kt index 8e9145a92..dad9cc512 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/JoinTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/JoinTest.kt @@ -6,6 +6,13 @@ import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table import com.raizlabs.android.dbflow.models.TwoColumnModel import com.raizlabs.android.dbflow.models.TwoColumnModel_Table +import com.raizlabs.android.dbflow.query.crossJoin +import com.raizlabs.android.dbflow.query.innerJoin +import com.raizlabs.android.dbflow.query.leftOuterJoin +import com.raizlabs.android.dbflow.query.naturalJoin +import com.raizlabs.android.dbflow.query.on +import com.raizlabs.android.dbflow.query.select +import com.raizlabs.android.dbflow.query.using import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/MethodTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/MethodTest.kt index 9fe8f792f..9d15f554e 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/MethodTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/MethodTest.kt @@ -3,6 +3,20 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.name +import com.raizlabs.android.dbflow.query.avg +import com.raizlabs.android.dbflow.query.cast +import com.raizlabs.android.dbflow.query.count +import com.raizlabs.android.dbflow.query.date +import com.raizlabs.android.dbflow.query.datetime +import com.raizlabs.android.dbflow.query.group_concat +import com.raizlabs.android.dbflow.query.ifNull +import com.raizlabs.android.dbflow.query.max +import com.raizlabs.android.dbflow.query.min +import com.raizlabs.android.dbflow.query.nullIf +import com.raizlabs.android.dbflow.query.replace +import com.raizlabs.android.dbflow.query.strftime +import com.raizlabs.android.dbflow.query.sum +import com.raizlabs.android.dbflow.query.total import com.raizlabs.android.dbflow.sql.SQLiteType import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/NameAliasTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/NameAliasTest.kt index e206582f8..91ba1bbf7 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/NameAliasTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/NameAliasTest.kt @@ -1,6 +1,9 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest +import com.raizlabs.android.dbflow.query.NameAlias +import com.raizlabs.android.dbflow.query.`as` +import com.raizlabs.android.dbflow.query.nameAlias import org.junit.Assert.assertEquals import org.junit.Assert.assertFalse import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OperatorGroupTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OperatorGroupTest.kt index ec911f837..8ca50a33b 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OperatorGroupTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OperatorGroupTest.kt @@ -4,6 +4,11 @@ import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.assertEquals import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.name +import com.raizlabs.android.dbflow.query.OperatorGroup +import com.raizlabs.android.dbflow.query.and +import com.raizlabs.android.dbflow.query.andAll +import com.raizlabs.android.dbflow.query.or +import com.raizlabs.android.dbflow.query.orAll import org.junit.Test class OperatorGroupTest : BaseUnitTest() { diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OperatorTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OperatorTest.kt index 9dc0eaccb..6f1264044 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OperatorTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OperatorTest.kt @@ -6,6 +6,10 @@ import com.raizlabs.android.dbflow.assertEquals import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id +import com.raizlabs.android.dbflow.query.and +import com.raizlabs.android.dbflow.query.collate +import com.raizlabs.android.dbflow.query.op +import com.raizlabs.android.dbflow.query.select import org.junit.Test class OperatorTest : BaseUnitTest() { diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OrderByTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OrderByTest.kt index 47f3bff50..5583fbc25 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OrderByTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OrderByTest.kt @@ -4,6 +4,9 @@ import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.annotation.Collate import com.raizlabs.android.dbflow.assertEquals import com.raizlabs.android.dbflow.models.SimpleModel_Table.name +import com.raizlabs.android.dbflow.query.OrderBy +import com.raizlabs.android.dbflow.query.collate +import com.raizlabs.android.dbflow.query.nameAlias import org.junit.Test class OrderByTest : BaseUnitTest() { diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/SelectTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/SelectTest.kt index 0e16d16fb..dbf318525 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/SelectTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/SelectTest.kt @@ -7,6 +7,7 @@ import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.TwoColumnModel import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.name +import com.raizlabs.android.dbflow.query.select import org.junit.Test class SelectTest : BaseUnitTest() { diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/SetTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/SetTest.kt index 9ffea13e5..daa73a763 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/SetTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/SetTest.kt @@ -6,6 +6,8 @@ import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table.name import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id +import com.raizlabs.android.dbflow.query.set +import com.raizlabs.android.dbflow.query.update import org.junit.Test class SetTest : BaseUnitTest() { diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/TriggerTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/TriggerTest.kt index 7259ade35..bdc74c19a 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/TriggerTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/TriggerTest.kt @@ -7,9 +7,18 @@ import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table.name import com.raizlabs.android.dbflow.models.TwoColumnModel import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id +import com.raizlabs.android.dbflow.query.NameAlias +import com.raizlabs.android.dbflow.query.and +import com.raizlabs.android.dbflow.query.begin +import com.raizlabs.android.dbflow.query.cast +import com.raizlabs.android.dbflow.query.createTrigger +import com.raizlabs.android.dbflow.query.insert +import com.raizlabs.android.dbflow.query.insertOn +import com.raizlabs.android.dbflow.query.select +import com.raizlabs.android.dbflow.query.updateOn +import com.raizlabs.android.dbflow.query.where import com.raizlabs.android.dbflow.sql.SQLiteType -import com.raizlabs.android.dbflow.sql.language.property.eq -import com.raizlabs.android.dbflow.sql.language.property.property +import com.raizlabs.android.dbflow.query.property.property import com.raizlabs.android.dbflow.structure.insert import org.junit.Assert.assertNotNull import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UnsafeStringOperatorTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UnsafeStringOperatorTest.kt index 7e451b478..ac9d267a3 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UnsafeStringOperatorTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UnsafeStringOperatorTest.kt @@ -4,6 +4,9 @@ import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.assertEquals import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.models.SimpleModel +import com.raizlabs.android.dbflow.query.UnSafeStringOperator +import com.raizlabs.android.dbflow.query.select +import com.raizlabs.android.dbflow.query.where import org.junit.Test class UnsafeStringOperatorTest : BaseUnitTest() { diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UpdateTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UpdateTest.kt index 88ce9e1ac..85b488b82 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UpdateTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UpdateTest.kt @@ -8,8 +8,9 @@ import com.raizlabs.android.dbflow.models.NumberModel import com.raizlabs.android.dbflow.models.NumberModel_Table.id import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table.name -import com.raizlabs.android.dbflow.sql.language.property.Property -import com.raizlabs.android.dbflow.sql.language.property.eq +import com.raizlabs.android.dbflow.query.set +import com.raizlabs.android.dbflow.query.update +import com.raizlabs.android.dbflow.query.property.Property import org.junit.Test class UpdateTest : BaseUnitTest() { diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/WhereTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/WhereTest.kt index 6cb102f77..419edc757 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/WhereTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/WhereTest.kt @@ -7,9 +7,16 @@ import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table.name import com.raizlabs.android.dbflow.models.TwoColumnModel import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id -import com.raizlabs.android.dbflow.sql.language.OrderBy.Companion.fromNameAlias -import com.raizlabs.android.dbflow.sql.queriable.list -import com.raizlabs.android.dbflow.sql.queriable.result +import com.raizlabs.android.dbflow.query.OrderBy.Companion.fromNameAlias +import com.raizlabs.android.dbflow.query.groupBy +import com.raizlabs.android.dbflow.query.having +import com.raizlabs.android.dbflow.query.nameAlias +import com.raizlabs.android.dbflow.query.or +import com.raizlabs.android.dbflow.query.select +import com.raizlabs.android.dbflow.query.update +import com.raizlabs.android.dbflow.query.where +import com.raizlabs.android.dbflow.query.list +import com.raizlabs.android.dbflow.query.result import org.junit.Assert.fail import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/BytePropertyTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/BytePropertyTest.kt index 7c79ce63c..b7c911e5b 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/BytePropertyTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/BytePropertyTest.kt @@ -2,7 +2,8 @@ package com.raizlabs.android.dbflow.sql.language.property import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.sql.language.NameAlias +import com.raizlabs.android.dbflow.query.NameAlias +import com.raizlabs.android.dbflow.query.property.Property import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/CharPropertyTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/CharPropertyTest.kt index 927115057..4c813a37a 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/CharPropertyTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/CharPropertyTest.kt @@ -2,7 +2,8 @@ package com.raizlabs.android.dbflow.sql.language.property import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.sql.language.NameAlias +import com.raizlabs.android.dbflow.query.NameAlias +import com.raizlabs.android.dbflow.query.property.Property import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/DoublePropertyTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/DoublePropertyTest.kt index bc4ebd524..dbb76279d 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/DoublePropertyTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/DoublePropertyTest.kt @@ -2,7 +2,8 @@ package com.raizlabs.android.dbflow.sql.language.property import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.sql.language.NameAlias +import com.raizlabs.android.dbflow.query.NameAlias +import com.raizlabs.android.dbflow.query.property.Property import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/FloatPropertyTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/FloatPropertyTest.kt index dd792a227..1d58b731f 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/FloatPropertyTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/FloatPropertyTest.kt @@ -2,7 +2,8 @@ package com.raizlabs.android.dbflow.sql.language.property import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.sql.language.NameAlias +import com.raizlabs.android.dbflow.query.NameAlias +import com.raizlabs.android.dbflow.query.property.Property import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/IndexPropertyTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/IndexPropertyTest.kt index d21d0913f..2948a7fe3 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/IndexPropertyTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/IndexPropertyTest.kt @@ -4,6 +4,7 @@ import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table +import com.raizlabs.android.dbflow.query.property.IndexProperty import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/IntPropertyTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/IntPropertyTest.kt index 57bb10e8a..0836933eb 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/IntPropertyTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/IntPropertyTest.kt @@ -2,7 +2,8 @@ package com.raizlabs.android.dbflow.sql.language.property import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.sql.language.NameAlias +import com.raizlabs.android.dbflow.query.NameAlias +import com.raizlabs.android.dbflow.query.property.Property import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/LongPropertyTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/LongPropertyTest.kt index e30d72937..d2ceee099 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/LongPropertyTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/LongPropertyTest.kt @@ -2,7 +2,8 @@ package com.raizlabs.android.dbflow.sql.language.property import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.sql.language.NameAlias +import com.raizlabs.android.dbflow.query.NameAlias +import com.raizlabs.android.dbflow.query.property.Property import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/PropertyFactoryTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/PropertyFactoryTest.kt index 1aded7c7a..6745c921c 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/PropertyFactoryTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/PropertyFactoryTest.kt @@ -3,7 +3,9 @@ package com.raizlabs.android.dbflow.sql.language.property import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.sql.language.select +import com.raizlabs.android.dbflow.query.property.property +import com.raizlabs.android.dbflow.query.property.propertyString +import com.raizlabs.android.dbflow.query.select import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/PropertyTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/PropertyTest.kt index 74699af17..1d2787831 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/PropertyTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/PropertyTest.kt @@ -2,7 +2,8 @@ package com.raizlabs.android.dbflow.sql.language.property import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.sql.language.NameAlias +import com.raizlabs.android.dbflow.query.NameAlias +import com.raizlabs.android.dbflow.query.property.Property import org.junit.Assert import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/ShortPropertyTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/ShortPropertyTest.kt index 3dc213bcd..048399566 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/ShortPropertyTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/ShortPropertyTest.kt @@ -2,7 +2,8 @@ package com.raizlabs.android.dbflow.sql.language.property import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.sql.language.NameAlias +import com.raizlabs.android.dbflow.query.NameAlias +import com.raizlabs.android.dbflow.query.property.Property import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/TypeConvertedPropertyTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/TypeConvertedPropertyTest.kt index ea6bc9d09..64183f69c 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/TypeConvertedPropertyTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/TypeConvertedPropertyTest.kt @@ -6,7 +6,8 @@ import com.raizlabs.android.dbflow.converter.TypeConverter import com.raizlabs.android.dbflow.models.Difficulty import com.raizlabs.android.dbflow.models.EnumTypeConverterModel_Table import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.sql.language.NameAlias +import com.raizlabs.android.dbflow.query.NameAlias +import com.raizlabs.android.dbflow.query.property.TypeConvertedProperty import org.junit.Assert.assertEquals import org.junit.Test import java.util.* diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/SqlUtils.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/SqlUtils.kt similarity index 92% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/SqlUtils.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/SqlUtils.kt index 52e56001b..26008fd20 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/SqlUtils.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/SqlUtils.kt @@ -1,20 +1,17 @@ @file:JvmName("SqlUtils") -package com.raizlabs.android.dbflow.sql +package com.raizlabs.android.dbflow import android.content.ContentValues import android.net.Uri import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.isNotNullOrEmpty -import com.raizlabs.android.dbflow.quoteIfNeeded -import com.raizlabs.android.dbflow.sql.language.NameAlias -import com.raizlabs.android.dbflow.sql.language.Operator -import com.raizlabs.android.dbflow.sql.language.OperatorGroup -import com.raizlabs.android.dbflow.sql.language.SQLOperator -import com.raizlabs.android.dbflow.stripQuotes +import com.raizlabs.android.dbflow.query.NameAlias +import com.raizlabs.android.dbflow.query.Operator +import com.raizlabs.android.dbflow.query.OperatorGroup +import com.raizlabs.android.dbflow.query.SQLOperator import com.raizlabs.android.dbflow.structure.ChangeAction import com.raizlabs.android.dbflow.structure.Model -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.database.DatabaseWrapper /** * Description: Provides some handy methods for dealing with SQL statements. It's purpose is to move the diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/InstanceAdapter.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/InstanceAdapter.kt similarity index 91% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/InstanceAdapter.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/InstanceAdapter.kt index 2192102ee..66224b107 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/InstanceAdapter.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/InstanceAdapter.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.structure +package com.raizlabs.android.dbflow.adapter import com.raizlabs.android.dbflow.config.DatabaseDefinition diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/InternalAdapter.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/InternalAdapter.kt similarity index 96% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/InternalAdapter.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/InternalAdapter.kt index 969af644b..3940ec590 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/InternalAdapter.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/InternalAdapter.kt @@ -1,12 +1,12 @@ -package com.raizlabs.android.dbflow.structure +package com.raizlabs.android.dbflow.adapter import android.content.ContentValues import android.database.sqlite.SQLiteStatement import android.support.annotation.IntRange import com.raizlabs.android.dbflow.annotation.PrimaryKey -import com.raizlabs.android.dbflow.structure.database.DatabaseStatement -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.database.DatabaseStatement +import com.raizlabs.android.dbflow.database.DatabaseWrapper /** * Description: Used for our internal Adapter classes such as generated [ModelAdapter]. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelAdapter.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/ModelAdapter.kt similarity index 94% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelAdapter.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/ModelAdapter.kt index 3574362de..8d96a0cc6 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelAdapter.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/ModelAdapter.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.structure +package com.raizlabs.android.dbflow.adapter import android.content.ContentValues import android.database.sqlite.SQLiteStatement @@ -8,16 +8,17 @@ import com.raizlabs.android.dbflow.annotation.ForeignKey import com.raizlabs.android.dbflow.annotation.PrimaryKey import com.raizlabs.android.dbflow.annotation.Table import com.raizlabs.android.dbflow.config.DatabaseDefinition -import com.raizlabs.android.dbflow.sql.language.property.IProperty -import com.raizlabs.android.dbflow.sql.language.property.Property -import com.raizlabs.android.dbflow.sql.saveable.ListModelSaver -import com.raizlabs.android.dbflow.sql.saveable.ModelSaver -import com.raizlabs.android.dbflow.structure.cache.IMultiKeyCacheConverter -import com.raizlabs.android.dbflow.structure.cache.ModelCache -import com.raizlabs.android.dbflow.structure.cache.SimpleMapCache -import com.raizlabs.android.dbflow.structure.database.DatabaseStatement -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper -import com.raizlabs.android.dbflow.structure.database.FlowCursor +import com.raizlabs.android.dbflow.query.property.IProperty +import com.raizlabs.android.dbflow.query.property.Property +import com.raizlabs.android.dbflow.adapter.saveable.ListModelSaver +import com.raizlabs.android.dbflow.adapter.saveable.ModelSaver +import com.raizlabs.android.dbflow.query.cache.IMultiKeyCacheConverter +import com.raizlabs.android.dbflow.query.cache.ModelCache +import com.raizlabs.android.dbflow.query.cache.SimpleMapCache +import com.raizlabs.android.dbflow.structure.InvalidDBConfiguration +import com.raizlabs.android.dbflow.database.DatabaseStatement +import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.android.dbflow.database.FlowCursor /** * Description: Used for generated classes from the combination of [Table] and [Model]. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelViewAdapter.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/ModelViewAdapter.kt similarity index 82% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelViewAdapter.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/ModelViewAdapter.kt index 9407ec183..c2bf54242 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ModelViewAdapter.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/ModelViewAdapter.kt @@ -1,7 +1,7 @@ -package com.raizlabs.android.dbflow.structure +package com.raizlabs.android.dbflow.adapter import com.raizlabs.android.dbflow.config.DatabaseDefinition -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.database.DatabaseWrapper /** * Description: The base class for a [T] adapter that defines how it interacts with the DB. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/QueryModelAdapter.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/QueryModelAdapter.kt similarity index 83% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/QueryModelAdapter.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/QueryModelAdapter.kt index 23fd06001..751dce831 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/QueryModelAdapter.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/QueryModelAdapter.kt @@ -1,9 +1,9 @@ -package com.raizlabs.android.dbflow.structure +package com.raizlabs.android.dbflow.adapter import com.raizlabs.android.dbflow.annotation.QueryModel import com.raizlabs.android.dbflow.config.DatabaseDefinition -import com.raizlabs.android.dbflow.sql.language.OperatorGroup -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.query.OperatorGroup +import com.raizlabs.android.dbflow.database.DatabaseWrapper /** * Description: The baseclass for adapters to [QueryModel] that defines how it interacts with the DB. The diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/RetrievalAdapter.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/RetrievalAdapter.kt similarity index 90% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/RetrievalAdapter.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/RetrievalAdapter.kt index d999b0b7f..d76366f61 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/RetrievalAdapter.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/RetrievalAdapter.kt @@ -1,16 +1,16 @@ -package com.raizlabs.android.dbflow.structure +package com.raizlabs.android.dbflow.adapter import android.database.Cursor import com.raizlabs.android.dbflow.config.DatabaseDefinition import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.config.TableConfig -import com.raizlabs.android.dbflow.sql.language.OperatorGroup -import com.raizlabs.android.dbflow.sql.language.select -import com.raizlabs.android.dbflow.sql.language.where -import com.raizlabs.android.dbflow.sql.queriable.ListModelLoader -import com.raizlabs.android.dbflow.sql.queriable.SingleModelLoader -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper -import com.raizlabs.android.dbflow.structure.database.FlowCursor +import com.raizlabs.android.dbflow.query.OperatorGroup +import com.raizlabs.android.dbflow.query.select +import com.raizlabs.android.dbflow.query.where +import com.raizlabs.android.dbflow.adapter.queriable.ListModelLoader +import com.raizlabs.android.dbflow.adapter.queriable.SingleModelLoader +import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.android.dbflow.database.FlowCursor /** * Description: Provides a base retrieval class for all [Model] backed diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/CacheableListModelLoader.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/CacheableListModelLoader.kt similarity index 86% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/CacheableListModelLoader.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/CacheableListModelLoader.kt index dec02da2b..186348a59 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/CacheableListModelLoader.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/CacheableListModelLoader.kt @@ -1,10 +1,10 @@ -package com.raizlabs.android.dbflow.sql.queriable +package com.raizlabs.android.dbflow.adapter.queriable import com.raizlabs.android.dbflow.annotation.Table -import com.raizlabs.android.dbflow.structure.ModelAdapter -import com.raizlabs.android.dbflow.structure.cache.ModelCache -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper -import com.raizlabs.android.dbflow.structure.database.FlowCursor +import com.raizlabs.android.dbflow.adapter.ModelAdapter +import com.raizlabs.android.dbflow.query.cache.ModelCache +import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.android.dbflow.database.FlowCursor /** * Description: Loads a [List] of [T] with [Table.cachingEnabled] true. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/CacheableModelLoader.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/CacheableModelLoader.kt similarity index 86% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/CacheableModelLoader.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/CacheableModelLoader.kt index 7ff52bc19..e80474caa 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/CacheableModelLoader.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/CacheableModelLoader.kt @@ -1,10 +1,10 @@ -package com.raizlabs.android.dbflow.sql.queriable +package com.raizlabs.android.dbflow.adapter.queriable import com.raizlabs.android.dbflow.annotation.Table -import com.raizlabs.android.dbflow.structure.ModelAdapter -import com.raizlabs.android.dbflow.structure.cache.ModelCache -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper -import com.raizlabs.android.dbflow.structure.database.FlowCursor +import com.raizlabs.android.dbflow.adapter.ModelAdapter +import com.raizlabs.android.dbflow.query.cache.ModelCache +import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.android.dbflow.database.FlowCursor /** * Description: Loads model data that is backed by a [ModelCache]. Used when [Table.cachingEnabled] diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ListModelLoader.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/ListModelLoader.kt similarity index 85% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ListModelLoader.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/ListModelLoader.kt index 2083bee63..27e0834ec 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ListModelLoader.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/ListModelLoader.kt @@ -1,7 +1,7 @@ -package com.raizlabs.android.dbflow.sql.queriable +package com.raizlabs.android.dbflow.adapter.queriable -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper -import com.raizlabs.android.dbflow.structure.database.FlowCursor +import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.android.dbflow.database.FlowCursor /** * Description: Loads a [List] of [T]. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ModelLoader.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/ModelLoader.kt similarity index 88% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ModelLoader.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/ModelLoader.kt index ec06d426b..5efa7e443 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ModelLoader.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/ModelLoader.kt @@ -1,11 +1,11 @@ -package com.raizlabs.android.dbflow.sql.queriable +package com.raizlabs.android.dbflow.adapter.queriable import android.database.Cursor import android.database.sqlite.SQLiteDatabase import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.structure.InstanceAdapter -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper -import com.raizlabs.android.dbflow.structure.database.FlowCursor +import com.raizlabs.android.dbflow.adapter.InstanceAdapter +import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.android.dbflow.database.FlowCursor /** * Description: Represents how models load from DB. It will query a [SQLiteDatabase] diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleKeyCacheableListModelLoader.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/SingleKeyCacheableListModelLoader.kt similarity index 85% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleKeyCacheableListModelLoader.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/SingleKeyCacheableListModelLoader.kt index 26b0d7be3..ea755eee6 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleKeyCacheableListModelLoader.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/SingleKeyCacheableListModelLoader.kt @@ -1,7 +1,7 @@ -package com.raizlabs.android.dbflow.sql.queriable +package com.raizlabs.android.dbflow.adapter.queriable -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper -import com.raizlabs.android.dbflow.structure.database.FlowCursor +import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.android.dbflow.database.FlowCursor /** * Description: diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleKeyCacheableModelLoader.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/SingleKeyCacheableModelLoader.kt similarity index 87% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleKeyCacheableModelLoader.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/SingleKeyCacheableModelLoader.kt index 8d7e0763a..7b4eac335 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleKeyCacheableModelLoader.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/SingleKeyCacheableModelLoader.kt @@ -1,8 +1,8 @@ -package com.raizlabs.android.dbflow.sql.queriable +package com.raizlabs.android.dbflow.adapter.queriable import com.raizlabs.android.dbflow.structure.Model -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper -import com.raizlabs.android.dbflow.structure.database.FlowCursor +import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.android.dbflow.database.FlowCursor /** * Description: More optimized version of [CacheableModelLoader] which assumes that the [Model] diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleModelLoader.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/SingleModelLoader.kt similarity index 81% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleModelLoader.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/SingleModelLoader.kt index 8a75faffb..a076d0abc 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/SingleModelLoader.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/SingleModelLoader.kt @@ -1,7 +1,7 @@ -package com.raizlabs.android.dbflow.sql.queriable +package com.raizlabs.android.dbflow.adapter.queriable -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper -import com.raizlabs.android.dbflow.structure.database.FlowCursor +import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.android.dbflow.database.FlowCursor /** * Description: Responsible for loading data into a single object. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/AutoIncrementModelSaver.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/saveable/AutoIncrementModelSaver.kt similarity index 90% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/AutoIncrementModelSaver.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/saveable/AutoIncrementModelSaver.kt index 5982f2d61..550a807b9 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/AutoIncrementModelSaver.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/saveable/AutoIncrementModelSaver.kt @@ -1,10 +1,10 @@ -package com.raizlabs.android.dbflow.sql.saveable +package com.raizlabs.android.dbflow.adapter.saveable import com.raizlabs.android.dbflow.config.FlowLog import com.raizlabs.android.dbflow.runtime.NotifyDistributor import com.raizlabs.android.dbflow.structure.ChangeAction -import com.raizlabs.android.dbflow.structure.database.DatabaseStatement -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.database.DatabaseStatement +import com.raizlabs.android.dbflow.database.DatabaseWrapper /** * Description: Used to properly handle autoincrementing fields. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/CacheableListModelSaver.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/saveable/CacheableListModelSaver.kt similarity index 93% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/CacheableListModelSaver.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/saveable/CacheableListModelSaver.kt index 01f3d82f5..9adacb780 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/CacheableListModelSaver.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/saveable/CacheableListModelSaver.kt @@ -1,7 +1,7 @@ -package com.raizlabs.android.dbflow.sql.saveable +package com.raizlabs.android.dbflow.adapter.saveable -import com.raizlabs.android.dbflow.structure.database.DatabaseStatement -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.database.DatabaseStatement +import com.raizlabs.android.dbflow.database.DatabaseWrapper /** * Description: Used for model caching, enables caching models when saving in list. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ListModelSaver.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/saveable/ListModelSaver.kt similarity index 91% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ListModelSaver.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/saveable/ListModelSaver.kt index 03c3f088e..3f1420e0b 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ListModelSaver.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/saveable/ListModelSaver.kt @@ -1,7 +1,7 @@ -package com.raizlabs.android.dbflow.sql.saveable +package com.raizlabs.android.dbflow.adapter.saveable -import com.raizlabs.android.dbflow.structure.database.DatabaseStatement -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.database.DatabaseStatement +import com.raizlabs.android.dbflow.database.DatabaseWrapper open class ListModelSaver(val modelSaver: ModelSaver) { diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ModelSaver.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/saveable/ModelSaver.kt similarity index 94% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ModelSaver.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/saveable/ModelSaver.kt index 8ccbeb560..3f80528d4 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/saveable/ModelSaver.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/saveable/ModelSaver.kt @@ -1,11 +1,11 @@ -package com.raizlabs.android.dbflow.sql.saveable +package com.raizlabs.android.dbflow.adapter.saveable import android.content.ContentValues import com.raizlabs.android.dbflow.runtime.NotifyDistributor import com.raizlabs.android.dbflow.structure.ChangeAction -import com.raizlabs.android.dbflow.structure.ModelAdapter -import com.raizlabs.android.dbflow.structure.database.DatabaseStatement -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.adapter.ModelAdapter +import com.raizlabs.android.dbflow.database.DatabaseStatement +import com.raizlabs.android.dbflow.database.DatabaseWrapper /** * Description: Defines how models get saved into the DB. It will bind values to [DatabaseStatement] diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.kt index 81f7f9bd3..f2c19fd08 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.kt @@ -1,10 +1,10 @@ package com.raizlabs.android.dbflow.config import com.raizlabs.android.dbflow.isNotNullOrEmpty -import com.raizlabs.android.dbflow.runtime.BaseTransactionManager +import com.raizlabs.android.dbflow.transaction.BaseTransactionManager import com.raizlabs.android.dbflow.runtime.ModelNotifier -import com.raizlabs.android.dbflow.structure.database.DatabaseHelperListener -import com.raizlabs.android.dbflow.structure.database.OpenHelper +import com.raizlabs.android.dbflow.database.DatabaseHelperListener +import com.raizlabs.android.dbflow.database.OpenHelper import java.util.* /** diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.kt index 6f44c6cef..fd15b3ab5 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.kt @@ -5,27 +5,27 @@ import android.content.Context import com.raizlabs.android.dbflow.annotation.Database import com.raizlabs.android.dbflow.annotation.QueryModel import com.raizlabs.android.dbflow.annotation.Table -import com.raizlabs.android.dbflow.runtime.BaseTransactionManager +import com.raizlabs.android.dbflow.transaction.BaseTransactionManager import com.raizlabs.android.dbflow.runtime.DirectModelNotifier import com.raizlabs.android.dbflow.runtime.ModelNotifier -import com.raizlabs.android.dbflow.sql.migration.Migration -import com.raizlabs.android.dbflow.sql.queriable.ListModelLoader -import com.raizlabs.android.dbflow.sql.queriable.SingleModelLoader -import com.raizlabs.android.dbflow.sql.saveable.ModelSaver +import com.raizlabs.android.dbflow.migration.Migration +import com.raizlabs.android.dbflow.adapter.queriable.ListModelLoader +import com.raizlabs.android.dbflow.adapter.queriable.SingleModelLoader +import com.raizlabs.android.dbflow.adapter.saveable.ModelSaver import com.raizlabs.android.dbflow.structure.BaseModelView -import com.raizlabs.android.dbflow.structure.ModelAdapter -import com.raizlabs.android.dbflow.structure.ModelViewAdapter -import com.raizlabs.android.dbflow.structure.QueryModelAdapter -import com.raizlabs.android.dbflow.structure.database.DatabaseHelperListener -import com.raizlabs.android.dbflow.structure.database.DatabaseStatement -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper -import com.raizlabs.android.dbflow.structure.database.FlowCursor -import com.raizlabs.android.dbflow.structure.database.FlowSQLiteOpenHelper -import com.raizlabs.android.dbflow.structure.database.OpenHelper -import com.raizlabs.android.dbflow.structure.database.transaction.DefaultTransactionManager -import com.raizlabs.android.dbflow.structure.database.transaction.DefaultTransactionQueue -import com.raizlabs.android.dbflow.structure.database.transaction.ITransaction -import com.raizlabs.android.dbflow.structure.database.transaction.Transaction +import com.raizlabs.android.dbflow.adapter.ModelAdapter +import com.raizlabs.android.dbflow.adapter.ModelViewAdapter +import com.raizlabs.android.dbflow.adapter.QueryModelAdapter +import com.raizlabs.android.dbflow.database.DatabaseHelperListener +import com.raizlabs.android.dbflow.database.DatabaseStatement +import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.android.dbflow.database.FlowCursor +import com.raizlabs.android.dbflow.database.FlowSQLiteOpenHelper +import com.raizlabs.android.dbflow.database.OpenHelper +import com.raizlabs.android.dbflow.transaction.DefaultTransactionManager +import com.raizlabs.android.dbflow.transaction.DefaultTransactionQueue +import com.raizlabs.android.dbflow.transaction.ITransaction +import com.raizlabs.android.dbflow.transaction.Transaction import java.util.* /** diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt index e884c4906..4107f4a60 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt @@ -6,18 +6,18 @@ import com.raizlabs.android.dbflow.converter.TypeConverter import com.raizlabs.android.dbflow.quote import com.raizlabs.android.dbflow.runtime.ModelNotifier import com.raizlabs.android.dbflow.runtime.TableNotifierRegister -import com.raizlabs.android.dbflow.sql.migration.Migration +import com.raizlabs.android.dbflow.migration.Migration import com.raizlabs.android.dbflow.structure.BaseModel import com.raizlabs.android.dbflow.structure.BaseModelView import com.raizlabs.android.dbflow.structure.BaseQueryModel -import com.raizlabs.android.dbflow.structure.InstanceAdapter +import com.raizlabs.android.dbflow.adapter.InstanceAdapter import com.raizlabs.android.dbflow.structure.InvalidDBConfiguration import com.raizlabs.android.dbflow.structure.Model -import com.raizlabs.android.dbflow.structure.ModelAdapter -import com.raizlabs.android.dbflow.structure.ModelViewAdapter -import com.raizlabs.android.dbflow.structure.QueryModelAdapter -import com.raizlabs.android.dbflow.structure.RetrievalAdapter -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.adapter.ModelAdapter +import com.raizlabs.android.dbflow.adapter.ModelViewAdapter +import com.raizlabs.android.dbflow.adapter.QueryModelAdapter +import com.raizlabs.android.dbflow.adapter.RetrievalAdapter +import com.raizlabs.android.dbflow.database.DatabaseWrapper import java.util.* import kotlin.reflect.KClass diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/TableConfig.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/TableConfig.kt index 0a53f301d..bb592ff50 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/TableConfig.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/TableConfig.kt @@ -1,9 +1,9 @@ package com.raizlabs.android.dbflow.config -import com.raizlabs.android.dbflow.sql.queriable.ListModelLoader -import com.raizlabs.android.dbflow.sql.queriable.SingleModelLoader -import com.raizlabs.android.dbflow.sql.saveable.ModelSaver -import com.raizlabs.android.dbflow.structure.ModelAdapter +import com.raizlabs.android.dbflow.adapter.queriable.ListModelLoader +import com.raizlabs.android.dbflow.adapter.queriable.SingleModelLoader +import com.raizlabs.android.dbflow.adapter.saveable.ModelSaver +import com.raizlabs.android.dbflow.adapter.ModelAdapter /** * Description: Represents certain table configuration options. This allows you to easily specify diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/AndroidDatabase.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/database/AndroidDatabase.kt similarity index 98% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/AndroidDatabase.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/database/AndroidDatabase.kt index 1d2beda50..f259ad84b 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/AndroidDatabase.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/database/AndroidDatabase.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.structure.database +package com.raizlabs.android.dbflow.database import android.content.ContentValues import android.database.sqlite.SQLiteDatabase diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/AndroidDatabaseStatement.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/database/AndroidDatabaseStatement.kt similarity index 97% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/AndroidDatabaseStatement.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/database/AndroidDatabaseStatement.kt index f37155cec..da3246d3a 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/AndroidDatabaseStatement.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/database/AndroidDatabaseStatement.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.structure.database +package com.raizlabs.android.dbflow.database import android.database.Cursor import android.database.SQLException diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/BaseDatabaseHelper.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/database/BaseDatabaseHelper.kt similarity index 99% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/BaseDatabaseHelper.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/database/BaseDatabaseHelper.kt index 151e93355..011416c1c 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/BaseDatabaseHelper.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/database/BaseDatabaseHelper.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.structure.database +package com.raizlabs.android.dbflow.database import android.database.sqlite.SQLiteException import com.raizlabs.android.dbflow.config.DatabaseDefinition diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/BaseDatabaseStatement.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/database/BaseDatabaseStatement.kt similarity index 95% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/BaseDatabaseStatement.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/database/BaseDatabaseStatement.kt index 8d707c262..b5823066f 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/BaseDatabaseStatement.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/database/BaseDatabaseStatement.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.structure.database +package com.raizlabs.android.dbflow.database /** * Description: Default implementation for some [DatabaseStatement] methods. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/ContentValueExtensions.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/database/ContentValueExtensions.kt similarity index 93% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/ContentValueExtensions.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/database/ContentValueExtensions.kt index 40c816e5d..8ed252e0a 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/ContentValueExtensions.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/database/ContentValueExtensions.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.structure.database +package com.raizlabs.android.dbflow.database import android.content.ContentValues diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseHelperDelegate.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/database/DatabaseHelperDelegate.kt similarity index 98% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseHelperDelegate.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/database/DatabaseHelperDelegate.kt index 3a1116bc5..318edb822 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseHelperDelegate.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/database/DatabaseHelperDelegate.kt @@ -1,11 +1,11 @@ -package com.raizlabs.android.dbflow.structure.database +package com.raizlabs.android.dbflow.database import android.database.sqlite.SQLiteOpenHelper import com.raizlabs.android.dbflow.config.DatabaseDefinition import com.raizlabs.android.dbflow.config.FlowLog import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.structure.database.transaction.DefaultTransactionQueue -import com.raizlabs.android.dbflow.structure.database.transaction.ITransaction +import com.raizlabs.android.dbflow.transaction.DefaultTransactionQueue +import com.raizlabs.android.dbflow.transaction.ITransaction import java.io.File import java.io.FileInputStream import java.io.FileOutputStream diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseHelperListener.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/database/DatabaseHelperListener.kt similarity index 95% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseHelperListener.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/database/DatabaseHelperListener.kt index 122dc24dc..27e163eb9 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseHelperListener.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/database/DatabaseHelperListener.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.structure.database +package com.raizlabs.android.dbflow.database /** * Description: Provides callbacks for [OpenHelper] methods diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseStatement.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/database/DatabaseStatement.kt similarity index 93% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseStatement.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/database/DatabaseStatement.kt index 6e9779763..4a58bcf2c 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseStatement.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/database/DatabaseStatement.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.structure.database +package com.raizlabs.android.dbflow.database import android.database.sqlite.SQLiteStatement diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseStatementWrapper.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/database/DatabaseStatementWrapper.kt similarity index 94% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseStatementWrapper.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/database/DatabaseStatementWrapper.kt index fecf241de..c13b3bdbe 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseStatementWrapper.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/database/DatabaseStatementWrapper.kt @@ -1,7 +1,7 @@ -package com.raizlabs.android.dbflow.structure.database +package com.raizlabs.android.dbflow.database import com.raizlabs.android.dbflow.runtime.NotifyDistributor -import com.raizlabs.android.dbflow.sql.language.BaseQueriable +import com.raizlabs.android.dbflow.query.BaseQueriable /** * Description: Delegates all of its calls to the contained [DatabaseStatement], while diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseWrapper.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/database/DatabaseWrapper.kt similarity index 95% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseWrapper.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/database/DatabaseWrapper.kt index 1b9f6f088..950c0997e 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/DatabaseWrapper.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/database/DatabaseWrapper.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.structure.database +package com.raizlabs.android.dbflow.database import android.content.ContentValues diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/FlowCursor.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/database/FlowCursor.kt similarity index 99% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/FlowCursor.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/database/FlowCursor.kt index 9408ab92d..d546c5b35 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/FlowCursor.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/database/FlowCursor.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.structure.database +package com.raizlabs.android.dbflow.database import android.database.Cursor import android.database.CursorWrapper diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/FlowSQLiteOpenHelper.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/database/FlowSQLiteOpenHelper.kt similarity index 98% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/FlowSQLiteOpenHelper.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/database/FlowSQLiteOpenHelper.kt index c08360966..9dfaf5145 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/FlowSQLiteOpenHelper.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/database/FlowSQLiteOpenHelper.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.structure.database +package com.raizlabs.android.dbflow.database import android.content.Context import android.database.sqlite.SQLiteDatabase diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/OpenHelper.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/database/OpenHelper.kt similarity index 87% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/OpenHelper.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/database/OpenHelper.kt index 6cd6ba15a..7dc207997 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/OpenHelper.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/database/OpenHelper.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.structure.database +package com.raizlabs.android.dbflow.database /** * Description: Abstracts out the [DatabaseHelperDelegate] into the one used in this library. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/AlterTableMigration.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/migration/AlterTableMigration.kt similarity index 96% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/AlterTableMigration.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/migration/AlterTableMigration.kt index 3eb5a4c9e..0574a9e6f 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/AlterTableMigration.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/migration/AlterTableMigration.kt @@ -1,13 +1,13 @@ -package com.raizlabs.android.dbflow.sql.migration +package com.raizlabs.android.dbflow.migration import android.support.annotation.CallSuper import com.raizlabs.android.dbflow.appendQuotedIfNeeded import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.quoteIfNeeded import com.raizlabs.android.dbflow.sql.SQLiteType -import com.raizlabs.android.dbflow.sql.language.select +import com.raizlabs.android.dbflow.query.select import com.raizlabs.android.dbflow.stripQuotes -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.database.DatabaseWrapper /** * Description: Provides a very nice way to alter a single table quickly and easily. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/BaseMigration.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/migration/BaseMigration.kt similarity index 75% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/BaseMigration.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/migration/BaseMigration.kt index 393c077f9..a37af2760 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/BaseMigration.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/migration/BaseMigration.kt @@ -1,6 +1,6 @@ -package com.raizlabs.android.dbflow.sql.migration +package com.raizlabs.android.dbflow.migration -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.database.DatabaseWrapper /** * Description: Provides the base implementation of [com.raizlabs.android.dbflow.sql.migration.Migration] with diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/IndexMigration.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/migration/IndexMigration.kt similarity index 80% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/IndexMigration.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/migration/IndexMigration.kt index 8e8113396..fff80bef2 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/IndexMigration.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/migration/IndexMigration.kt @@ -1,8 +1,8 @@ -package com.raizlabs.android.dbflow.sql.migration +package com.raizlabs.android.dbflow.migration -import com.raizlabs.android.dbflow.sql.language.index -import com.raizlabs.android.dbflow.sql.language.property.IProperty -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.query.index +import com.raizlabs.android.dbflow.query.property.IProperty +import com.raizlabs.android.dbflow.database.DatabaseWrapper import java.util.* /** diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/IndexPropertyMigration.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/migration/IndexPropertyMigration.kt similarity index 74% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/IndexPropertyMigration.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/migration/IndexPropertyMigration.kt index e93010c72..07340cc39 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/IndexPropertyMigration.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/migration/IndexPropertyMigration.kt @@ -1,7 +1,7 @@ -package com.raizlabs.android.dbflow.sql.migration +package com.raizlabs.android.dbflow.migration -import com.raizlabs.android.dbflow.sql.language.property.IndexProperty -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.query.property.IndexProperty +import com.raizlabs.android.dbflow.database.DatabaseWrapper /** * Description: Allows you to specify if and when an [IndexProperty] gets used or created. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/Migration.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/migration/Migration.kt similarity index 85% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/Migration.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/migration/Migration.kt index 93081760c..665a3be3c 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/Migration.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/migration/Migration.kt @@ -1,6 +1,6 @@ -package com.raizlabs.android.dbflow.sql.migration +package com.raizlabs.android.dbflow.migration -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.database.DatabaseWrapper /** * Description: Called when the Database is migrating. We can perform custom migrations here. A [com.raizlabs.android.dbflow.annotation.Migration] diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/UpdateTableMigration.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/migration/UpdateTableMigration.kt similarity index 81% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/UpdateTableMigration.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/migration/UpdateTableMigration.kt index d9a38de42..dc1cc297f 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/migration/UpdateTableMigration.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/migration/UpdateTableMigration.kt @@ -1,10 +1,10 @@ -package com.raizlabs.android.dbflow.sql.migration +package com.raizlabs.android.dbflow.migration -import com.raizlabs.android.dbflow.sql.language.BaseQueriable -import com.raizlabs.android.dbflow.sql.language.OperatorGroup -import com.raizlabs.android.dbflow.sql.language.SQLOperator -import com.raizlabs.android.dbflow.sql.language.update -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.query.BaseQueriable +import com.raizlabs.android.dbflow.query.OperatorGroup +import com.raizlabs.android.dbflow.query.SQLOperator +import com.raizlabs.android.dbflow.query.update +import com.raizlabs.android.dbflow.database.DatabaseWrapper /** * Description: Provides a simple way to update a table's field or fields quickly in a migration. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/BaseContentProvider.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/provider/BaseContentProvider.kt similarity index 90% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/BaseContentProvider.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/provider/BaseContentProvider.kt index 4cbb0f244..b4ee7b3c0 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/BaseContentProvider.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/provider/BaseContentProvider.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.runtime +package com.raizlabs.android.dbflow.provider import android.content.ContentProvider import android.content.ContentValues @@ -6,8 +6,8 @@ import android.net.Uri import com.raizlabs.android.dbflow.config.DatabaseDefinition import com.raizlabs.android.dbflow.config.DatabaseHolder import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper -import com.raizlabs.android.dbflow.structure.database.transaction.ITransaction +import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.android.dbflow.transaction.ITransaction /** * Description: The base provider class that [com.raizlabs.android.dbflow.annotation.provider.ContentProvider] diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/BaseProviderModel.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/provider/BaseProviderModel.kt similarity index 90% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/BaseProviderModel.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/provider/BaseProviderModel.kt index 1d60e9c4c..8b6df2e8c 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/BaseProviderModel.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/provider/BaseProviderModel.kt @@ -1,12 +1,12 @@ -package com.raizlabs.android.dbflow.structure.provider +package com.raizlabs.android.dbflow.provider import android.content.ContentProvider import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.sql.language.OperatorGroup +import com.raizlabs.android.dbflow.query.OperatorGroup import com.raizlabs.android.dbflow.structure.BaseModel import com.raizlabs.android.dbflow.structure.Model -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper -import com.raizlabs.android.dbflow.structure.database.FlowCursor +import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.android.dbflow.database.FlowCursor /** * Description: Provides a base implementation of a [Model] backed diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/BaseSyncableProviderModel.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/provider/BaseSyncableProviderModel.kt similarity index 88% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/BaseSyncableProviderModel.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/provider/BaseSyncableProviderModel.kt index 07c478783..e7f820c7b 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/BaseSyncableProviderModel.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/provider/BaseSyncableProviderModel.kt @@ -1,13 +1,13 @@ -package com.raizlabs.android.dbflow.structure.provider +package com.raizlabs.android.dbflow.provider import android.content.ContentProvider import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.sql.language.OperatorGroup +import com.raizlabs.android.dbflow.query.OperatorGroup import com.raizlabs.android.dbflow.structure.BaseModel import com.raizlabs.android.dbflow.structure.Model -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper -import com.raizlabs.android.dbflow.structure.database.FlowCursor +import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.android.dbflow.database.FlowCursor /** * Description: Provides a base implementation of a [Model] backed diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/ContentUtils.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/provider/ContentUtils.kt similarity index 97% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/ContentUtils.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/provider/ContentUtils.kt index ab7facd80..82ba27559 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/ContentUtils.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/provider/ContentUtils.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.structure.provider +package com.raizlabs.android.dbflow.provider import android.content.ContentResolver import android.content.ContentValues @@ -7,11 +7,11 @@ import android.net.Uri import com.raizlabs.android.dbflow.annotation.provider.ContentProvider import com.raizlabs.android.dbflow.config.FlowLog import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.sql.language.Operator -import com.raizlabs.android.dbflow.sql.language.OperatorGroup -import com.raizlabs.android.dbflow.structure.ModelAdapter -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper -import com.raizlabs.android.dbflow.structure.database.FlowCursor +import com.raizlabs.android.dbflow.query.Operator +import com.raizlabs.android.dbflow.query.OperatorGroup +import com.raizlabs.android.dbflow.adapter.ModelAdapter +import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.android.dbflow.database.FlowCursor /** * Description: Provides handy wrapper mechanisms for [android.content.ContentProvider] diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/ModelProvider.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/provider/ModelProvider.kt similarity index 86% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/ModelProvider.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/provider/ModelProvider.kt index 37fe9c78b..e920f646e 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/provider/ModelProvider.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/provider/ModelProvider.kt @@ -1,11 +1,11 @@ -package com.raizlabs.android.dbflow.structure.provider +package com.raizlabs.android.dbflow.provider import android.content.ContentResolver import android.net.Uri -import com.raizlabs.android.dbflow.sql.language.Operator -import com.raizlabs.android.dbflow.sql.language.OperatorGroup -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.query.Operator +import com.raizlabs.android.dbflow.query.OperatorGroup +import com.raizlabs.android.dbflow.database.DatabaseWrapper /** * Description: A base interface for Models that are connected to providers. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Actionable.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Actionable.kt similarity index 78% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Actionable.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/Actionable.kt index 3884def90..6d173c715 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Actionable.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Actionable.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.android.dbflow.query import com.raizlabs.android.dbflow.structure.ChangeAction diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseModelQueriable.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/BaseModelQueriable.kt similarity index 85% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseModelQueriable.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/BaseModelQueriable.kt index 7ab4ce9a2..55d719750 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseModelQueriable.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/BaseModelQueriable.kt @@ -1,16 +1,15 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.android.dbflow.query import com.raizlabs.android.dbflow.config.FlowLog import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.list.FlowCursorList -import com.raizlabs.android.dbflow.list.FlowQueryList +import com.raizlabs.android.dbflow.query.list.FlowCursorList +import com.raizlabs.android.dbflow.query.list.FlowQueryList import com.raizlabs.android.dbflow.runtime.NotifyDistributor import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.sql.queriable.ListModelLoader -import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable -import com.raizlabs.android.dbflow.sql.queriable.SingleModelLoader -import com.raizlabs.android.dbflow.structure.InstanceAdapter -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.adapter.queriable.ListModelLoader +import com.raizlabs.android.dbflow.adapter.queriable.SingleModelLoader +import com.raizlabs.android.dbflow.adapter.InstanceAdapter +import com.raizlabs.android.dbflow.database.DatabaseWrapper /** * Description: Provides a base implementation of [ModelQueriable] to simplify a lot of code. It provides the diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseOperator.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/BaseOperator.kt similarity index 98% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseOperator.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/BaseOperator.kt index 8b6a19259..604e52945 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseOperator.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/BaseOperator.kt @@ -1,11 +1,11 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.android.dbflow.query import android.database.DatabaseUtils import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.converter.TypeConverter import com.raizlabs.android.dbflow.data.Blob import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.sql.byteArrayToHexString +import com.raizlabs.android.dbflow.byteArrayToHexString /** * Description: Base class for all kinds of [SQLOperator] diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseQueriable.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/BaseQueriable.kt similarity index 83% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseQueriable.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/BaseQueriable.kt index acf29fdd2..69d90fb30 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseQueriable.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/BaseQueriable.kt @@ -1,15 +1,14 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.android.dbflow.query import android.database.sqlite.SQLiteDoneException import com.raizlabs.android.dbflow.config.FlowLog import com.raizlabs.android.dbflow.runtime.NotifyDistributor -import com.raizlabs.android.dbflow.sql.longForQuery -import com.raizlabs.android.dbflow.sql.queriable.Queriable +import com.raizlabs.android.dbflow.longForQuery import com.raizlabs.android.dbflow.structure.ChangeAction -import com.raizlabs.android.dbflow.structure.database.DatabaseStatement -import com.raizlabs.android.dbflow.structure.database.DatabaseStatementWrapper -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper -import com.raizlabs.android.dbflow.structure.database.FlowCursor +import com.raizlabs.android.dbflow.database.DatabaseStatement +import com.raizlabs.android.dbflow.database.DatabaseStatementWrapper +import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.android.dbflow.database.FlowCursor /** * Description: Base implementation of something that can be queried from the database. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseTransformable.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/BaseTransformable.kt similarity index 89% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseTransformable.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/BaseTransformable.kt index a38ec5008..ef1cc8c86 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/BaseTransformable.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/BaseTransformable.kt @@ -1,8 +1,8 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.android.dbflow.query -import com.raizlabs.android.dbflow.sql.language.property.IProperty -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper -import com.raizlabs.android.dbflow.structure.database.FlowCursor +import com.raizlabs.android.dbflow.query.property.IProperty +import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.android.dbflow.database.FlowCursor /** * Description: Combines basic transformations and query ops into a base class. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Case.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Case.kt similarity index 95% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Case.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/Case.kt index 43ca85228..6d069c280 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Case.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Case.kt @@ -1,9 +1,9 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.android.dbflow.query import com.raizlabs.android.dbflow.quoteIfNeeded import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.sql.language.property.IProperty -import com.raizlabs.android.dbflow.sql.language.property.Property +import com.raizlabs.android.dbflow.query.property.IProperty +import com.raizlabs.android.dbflow.query.property.Property /** * Description: Represents a SQLITE CASE argument. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CaseCondition.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/CaseCondition.kt similarity index 94% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CaseCondition.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/CaseCondition.kt index bb569fde4..f90511115 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CaseCondition.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/CaseCondition.kt @@ -1,7 +1,7 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.android.dbflow.query import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.sql.language.property.IProperty +import com.raizlabs.android.dbflow.query.property.IProperty /** * Description: Represents an individual condition inside a CASE. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CompletedTrigger.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/CompletedTrigger.kt similarity index 93% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CompletedTrigger.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/CompletedTrigger.kt index 9e3f7ed50..db1d0b550 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CompletedTrigger.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/CompletedTrigger.kt @@ -1,8 +1,8 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.android.dbflow.query import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.sql.dropTrigger +import com.raizlabs.android.dbflow.dropTrigger import java.util.* /** diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/listener/ContentValuesListener.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/ContentValuesListener.kt similarity index 92% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/listener/ContentValuesListener.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/ContentValuesListener.kt index 5f3aef9bb..54121764e 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/listener/ContentValuesListener.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/ContentValuesListener.kt @@ -1,10 +1,10 @@ -package com.raizlabs.android.dbflow.structure.listener +package com.raizlabs.android.dbflow.query import android.content.ContentValues import com.raizlabs.android.dbflow.annotation.provider.ContentProvider import com.raizlabs.android.dbflow.structure.Model -import com.raizlabs.android.dbflow.structure.ModelAdapter +import com.raizlabs.android.dbflow.adapter.ModelAdapter /** * Description: Called after the declared [ContentValues] are binded. It enables diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CursorResult.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/CursorResult.kt similarity index 92% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CursorResult.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/CursorResult.kt index d6bdc565a..ecdd0fee2 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/CursorResult.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/CursorResult.kt @@ -1,12 +1,12 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.android.dbflow.query import android.database.Cursor import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.list.FlowCursorIterator -import com.raizlabs.android.dbflow.list.IFlowCursorIterator -import com.raizlabs.android.dbflow.structure.InstanceAdapter -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper -import com.raizlabs.android.dbflow.structure.database.FlowCursor +import com.raizlabs.android.dbflow.query.list.FlowCursorIterator +import com.raizlabs.android.dbflow.query.list.IFlowCursorIterator +import com.raizlabs.android.dbflow.adapter.InstanceAdapter +import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.android.dbflow.database.FlowCursor /** * Description: A class that contains a [Cursor] and handy methods for retrieving data from it. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Delete.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Delete.kt similarity index 93% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Delete.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/Delete.kt index 129c1d5d2..fad1cf54b 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Delete.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Delete.kt @@ -1,7 +1,7 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.android.dbflow.query import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.database.DatabaseWrapper import kotlin.reflect.KClass /** diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/ExistenceOperator.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/ExistenceOperator.kt similarity index 95% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/ExistenceOperator.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/ExistenceOperator.kt index 6424a74be..1cebb82e2 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/ExistenceOperator.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/ExistenceOperator.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.android.dbflow.query import com.raizlabs.android.dbflow.appendQualifier import com.raizlabs.android.dbflow.sql.Query diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/From.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/From.kt similarity index 95% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/From.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/From.kt index 2d1d37aac..4f013e410 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/From.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/From.kt @@ -1,12 +1,11 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.android.dbflow.query import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.sql.language.Join.JoinType -import com.raizlabs.android.dbflow.sql.language.property.IndexProperty -import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable +import com.raizlabs.android.dbflow.query.Join.JoinType +import com.raizlabs.android.dbflow.query.property.IndexProperty import com.raizlabs.android.dbflow.structure.ChangeAction -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.database.DatabaseWrapper import java.util.* import kotlin.collections.Set as KSet diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IConditional.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/IConditional.kt similarity index 99% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IConditional.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/IConditional.kt index 5b4132f32..469d52568 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IConditional.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/IConditional.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.android.dbflow.query import com.raizlabs.android.dbflow.sql.Query diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IOperator.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/IOperator.kt similarity index 99% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IOperator.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/IOperator.kt index f9ba41c38..5a8b96be8 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IOperator.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/IOperator.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.android.dbflow.query import com.raizlabs.android.dbflow.sql.Query diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Index.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Index.kt similarity index 94% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Index.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/Index.kt index 1050cb512..f8e19c59f 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Index.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Index.kt @@ -1,12 +1,12 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.android.dbflow.query import com.raizlabs.android.dbflow.appendList import com.raizlabs.android.dbflow.appendQuotedIfNeeded import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.sql.dropIndex -import com.raizlabs.android.dbflow.sql.language.property.IProperty -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.dropIndex +import com.raizlabs.android.dbflow.query.property.IProperty +import com.raizlabs.android.dbflow.database.DatabaseWrapper /** * Description: an INDEX class that enables you to index a specific column from a table. This enables diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IndexedBy.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/IndexedBy.kt similarity index 89% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IndexedBy.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/IndexedBy.kt index 04a871376..81224b41e 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/IndexedBy.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/IndexedBy.kt @@ -1,8 +1,8 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.android.dbflow.query import com.raizlabs.android.dbflow.quoteIfNeeded import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.sql.language.property.IndexProperty +import com.raizlabs.android.dbflow.query.property.IndexProperty import com.raizlabs.android.dbflow.structure.ChangeAction /** diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Insert.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Insert.kt similarity index 98% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Insert.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/Insert.kt index b1c054c62..94ebb67dd 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Insert.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Insert.kt @@ -1,13 +1,13 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.android.dbflow.query import android.content.ContentValues import com.raizlabs.android.dbflow.annotation.ConflictAction import com.raizlabs.android.dbflow.appendArray import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.sql.language.property.IProperty +import com.raizlabs.android.dbflow.query.property.IProperty import com.raizlabs.android.dbflow.structure.ChangeAction -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.database.DatabaseWrapper /** * Description: The SQLite INSERT command diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Join.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Join.kt similarity index 96% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Join.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/Join.kt index 39792dfcb..f9d4f1103 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Join.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Join.kt @@ -1,11 +1,10 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.android.dbflow.query import com.raizlabs.android.dbflow.appendList import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.sql.language.property.IProperty -import com.raizlabs.android.dbflow.sql.language.property.PropertyFactory -import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable +import com.raizlabs.android.dbflow.query.property.IProperty +import com.raizlabs.android.dbflow.query.property.PropertyFactory import java.util.* import kotlin.reflect.KClass diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/listener/LoadFromCursorListener.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/LoadFromCursorListener.kt similarity index 88% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/listener/LoadFromCursorListener.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/LoadFromCursorListener.kt index eb7ff0da5..bcdf83fde 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/listener/LoadFromCursorListener.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/LoadFromCursorListener.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.structure.listener +package com.raizlabs.android.dbflow.query import android.database.Cursor diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Method.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Method.kt similarity index 96% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Method.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/Method.kt index 7c502427e..509781770 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Method.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Method.kt @@ -1,10 +1,10 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.android.dbflow.query import com.raizlabs.android.dbflow.sql.SQLiteType -import com.raizlabs.android.dbflow.sql.language.property.IProperty -import com.raizlabs.android.dbflow.sql.language.property.Property -import com.raizlabs.android.dbflow.sql.language.property.PropertyFactory +import com.raizlabs.android.dbflow.query.property.IProperty +import com.raizlabs.android.dbflow.query.property.Property +import com.raizlabs.android.dbflow.query.property.PropertyFactory import java.util.* /** diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ModelQueriable.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/ModelQueriable.kt similarity index 87% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ModelQueriable.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/ModelQueriable.kt index b3b744d45..297262f39 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/ModelQueriable.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/ModelQueriable.kt @@ -1,11 +1,8 @@ -package com.raizlabs.android.dbflow.sql.queriable +package com.raizlabs.android.dbflow.query import android.database.Cursor -import com.raizlabs.android.dbflow.list.FlowCursorList -import com.raizlabs.android.dbflow.list.FlowQueryList -import com.raizlabs.android.dbflow.sql.language.CursorResult -import com.raizlabs.android.dbflow.sql.language.From -import com.raizlabs.android.dbflow.sql.language.Where +import com.raizlabs.android.dbflow.query.list.FlowCursorList +import com.raizlabs.android.dbflow.query.list.FlowQueryList import com.raizlabs.android.dbflow.structure.BaseQueryModel /** diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/NameAlias.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/NameAlias.kt similarity index 96% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/NameAlias.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/NameAlias.kt index bcf5433a3..018aa56b8 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/NameAlias.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/NameAlias.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.android.dbflow.query import com.raizlabs.android.dbflow.isNotNullOrEmpty import com.raizlabs.android.dbflow.quoteIfNeeded @@ -230,13 +230,13 @@ class NameAlias(private val name: String, .shouldAddIdentifierToName(false) } - fun of(name: String): NameAlias = NameAlias.builder(name).build() + fun of(name: String): NameAlias = builder(name).build() fun of(name: String, aliasName: String): NameAlias = - NameAlias.builder(name).`as`(aliasName).build() + builder(name).`as`(aliasName).build() fun ofTable(tableName: String, name: String): NameAlias = - NameAlias.builder(name).withTable(tableName).build() + builder(name).withTable(tableName).build() } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Operator.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Operator.kt similarity index 98% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Operator.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/Operator.kt index 914725c3d..3332046b0 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Operator.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Operator.kt @@ -1,6 +1,6 @@ @file:Suppress("UNCHECKED_CAST") -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.android.dbflow.query import com.raizlabs.android.dbflow.annotation.Collate import com.raizlabs.android.dbflow.appendOptional @@ -8,7 +8,7 @@ import com.raizlabs.android.dbflow.config.FlowLog import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.converter.TypeConverter import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.sql.language.property.Property +import com.raizlabs.android.dbflow.query.property.Property /** * Description: The class that contains a column name, Operator, and value. @@ -376,7 +376,7 @@ class Operator : BaseOperator, IOperator { FlowLog.log(FlowLog.Level.W, throwable = c) } - BaseOperator.convertValueToString(converted, appendInnerParenthesis, false) + convertValueToString(converted, appendInnerParenthesis, false) } ?: super.convertObjectToString(obj, appendInnerParenthesis) private fun assignValueOp(value: Any?, operation: String): Operator { @@ -597,7 +597,7 @@ class Operator : BaseOperator, IOperator { queryBuilder.append(columnName()) .append(operation()) .append("(") - .append(BaseOperator.joinArguments(",", inArguments, this)) + .append(joinArguments(",", inArguments, this)) .append(")") } } @@ -606,7 +606,7 @@ class Operator : BaseOperator, IOperator { @JvmStatic fun convertValueToString(value: Any?): String? = - BaseOperator.convertValueToString(value, false) + convertValueToString(value, false) @JvmStatic fun op(column: NameAlias): Operator = Operator(column) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/OperatorGroup.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/OperatorGroup.kt similarity index 98% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/OperatorGroup.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/OperatorGroup.kt index 4e5f6fe7c..5dc1bd13f 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/OperatorGroup.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/OperatorGroup.kt @@ -1,7 +1,7 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.android.dbflow.query import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.sql.language.Operator.Operation +import com.raizlabs.android.dbflow.query.Operator.Operation import java.util.* /** diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/OrderBy.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/OrderBy.kt similarity index 94% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/OrderBy.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/OrderBy.kt index 479150e7a..120cf57b1 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/OrderBy.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/OrderBy.kt @@ -1,8 +1,8 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.android.dbflow.query import com.raizlabs.android.dbflow.annotation.Collate import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.sql.language.property.IProperty +import com.raizlabs.android.dbflow.query.property.IProperty /** * Description: Class that represents a SQL order-by. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/Queriable.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Queriable.kt similarity index 81% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/Queriable.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/Queriable.kt index 7532f75d7..1a71b2890 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/Queriable.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Queriable.kt @@ -1,13 +1,10 @@ -package com.raizlabs.android.dbflow.sql.queriable +package com.raizlabs.android.dbflow.query import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.sql.language.Delete -import com.raizlabs.android.dbflow.sql.language.Insert -import com.raizlabs.android.dbflow.sql.language.Set import com.raizlabs.android.dbflow.structure.ChangeAction import com.raizlabs.android.dbflow.structure.Model -import com.raizlabs.android.dbflow.structure.database.DatabaseStatement -import com.raizlabs.android.dbflow.structure.database.FlowCursor +import com.raizlabs.android.dbflow.database.DatabaseStatement +import com.raizlabs.android.dbflow.database.FlowCursor /** * Description: The most basic interface that some of the classes such as [Insert], [ModelQueriable], diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/SQLOperator.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/SQLOperator.kt similarity index 96% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/SQLOperator.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/SQLOperator.kt index 2520bd20b..df1843055 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/SQLOperator.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/SQLOperator.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.android.dbflow.query /** * Description: Basic interface for all of the Operator classes. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/SQLite.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/SQLite.kt similarity index 92% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/SQLite.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/SQLite.kt index 8fe803f18..93c3e4736 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/SQLite.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/SQLite.kt @@ -1,12 +1,12 @@ @file:JvmName("SQLite") -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.android.dbflow.query -import com.raizlabs.android.dbflow.sql.language.property.IProperty -import com.raizlabs.android.dbflow.sql.language.property.Property +import com.raizlabs.android.dbflow.query.property.IProperty +import com.raizlabs.android.dbflow.query.property.Property import com.raizlabs.android.dbflow.structure.Model -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.database.DatabaseWrapper import kotlin.reflect.KClass diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/listener/SQLiteStatementListener.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/SQLiteStatementListener.kt similarity index 82% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/listener/SQLiteStatementListener.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/SQLiteStatementListener.kt index a60ae4328..6ec7a21b4 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/listener/SQLiteStatementListener.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/SQLiteStatementListener.kt @@ -1,9 +1,9 @@ -package com.raizlabs.android.dbflow.structure.listener +package com.raizlabs.android.dbflow.query -import com.raizlabs.android.dbflow.structure.InternalAdapter +import com.raizlabs.android.dbflow.adapter.InternalAdapter import com.raizlabs.android.dbflow.structure.Model -import com.raizlabs.android.dbflow.structure.ModelAdapter -import com.raizlabs.android.dbflow.structure.database.DatabaseStatement +import com.raizlabs.android.dbflow.adapter.ModelAdapter +import com.raizlabs.android.dbflow.database.DatabaseStatement /** * Description: Marks a [Model] as subscribing to the [DatabaseStatement] diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Select.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Select.kt similarity index 90% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Select.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/Select.kt index 66a1818a0..d416f60ca 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Select.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Select.kt @@ -1,9 +1,9 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.android.dbflow.query import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.sql.language.property.IProperty -import com.raizlabs.android.dbflow.sql.language.property.Property -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.query.property.IProperty +import com.raizlabs.android.dbflow.query.property.Property +import com.raizlabs.android.dbflow.database.DatabaseWrapper import kotlin.reflect.KClass /** @@ -56,7 +56,7 @@ internal constructor(private val databaseWrapper: DatabaseWrapper, * @param [T] The class that implements [com.raizlabs.android.dbflow.structure.Model] * @return the From part of this query */ - infix fun from(table: Class): From = From(databaseWrapper,this, table) + infix fun from(table: Class): From = From(databaseWrapper, this, table) inline fun from() = from(T::class.java) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Set.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Set.kt similarity index 89% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Set.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/Set.kt index 8a342fa1f..3e7345d2f 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Set.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Set.kt @@ -1,10 +1,10 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.android.dbflow.query import android.content.ContentValues import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.sql.addContentValues +import com.raizlabs.android.dbflow.addContentValues import com.raizlabs.android.dbflow.structure.ChangeAction -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.database.DatabaseWrapper /** * Description: Used to specify the SET part of an [com.raizlabs.android.dbflow.sql.language.Update] query. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/StringQuery.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/StringQuery.kt similarity index 79% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/StringQuery.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/StringQuery.kt index 1d7e424fe..ff4fd1320 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/queriable/StringQuery.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/StringQuery.kt @@ -1,12 +1,10 @@ -package com.raizlabs.android.dbflow.sql.queriable +package com.raizlabs.android.dbflow.query import android.database.sqlite.SQLiteDatabase import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.sql.language.BaseModelQueriable -import com.raizlabs.android.dbflow.sql.language.Delete import com.raizlabs.android.dbflow.structure.ChangeAction -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper -import com.raizlabs.android.dbflow.structure.database.FlowCursor +import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.android.dbflow.database.FlowCursor /** * Description: Provides a very basic query mechanism for strings. Allows you to easily perform custom SQL query string diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Transformable.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Transformable.kt similarity index 89% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Transformable.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/Transformable.kt index 5faf29bfb..810c8ccd1 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Transformable.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Transformable.kt @@ -1,6 +1,6 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.android.dbflow.query -import com.raizlabs.android.dbflow.sql.language.property.IProperty +import com.raizlabs.android.dbflow.query.property.IProperty /** * Description: Provides a standard set of methods for ending a SQLite query method. These include diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Trigger.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Trigger.kt similarity index 96% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Trigger.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/Trigger.kt index 64fa7d708..9a59d45d7 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Trigger.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Trigger.kt @@ -1,9 +1,9 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.android.dbflow.query import com.raizlabs.android.dbflow.appendOptional import com.raizlabs.android.dbflow.appendQuotedIfNeeded import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.sql.language.property.IProperty +import com.raizlabs.android.dbflow.query.property.IProperty import kotlin.reflect.KClass /** diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/TriggerMethod.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/TriggerMethod.kt similarity index 95% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/TriggerMethod.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/TriggerMethod.kt index 9f75b1f2c..db2fcdf64 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/TriggerMethod.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/TriggerMethod.kt @@ -1,9 +1,9 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.android.dbflow.query import com.raizlabs.android.dbflow.appendArray import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.sql.language.property.IProperty +import com.raizlabs.android.dbflow.query.property.IProperty /** * Description: Describes the method that the trigger uses. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/UnSafeStringOperator.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/UnSafeStringOperator.kt similarity index 96% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/UnSafeStringOperator.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/UnSafeStringOperator.kt index c10e14f29..b3ca07c42 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/UnSafeStringOperator.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/UnSafeStringOperator.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.android.dbflow.query import com.raizlabs.android.dbflow.isNotNullOrEmpty import com.raizlabs.android.dbflow.sql.Query diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Update.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Update.kt similarity index 95% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Update.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/Update.kt index fab05f600..6028b16c6 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Update.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Update.kt @@ -1,9 +1,9 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.android.dbflow.query import com.raizlabs.android.dbflow.annotation.ConflictAction import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.database.DatabaseWrapper /** * Description: The SQLite UPDATE query. Will update rows in the DB. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Where.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Where.kt similarity index 96% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Where.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/Where.kt index 163eeb587..ce470454a 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/Where.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Where.kt @@ -1,12 +1,11 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.android.dbflow.query import android.database.Cursor import com.raizlabs.android.dbflow.annotation.provider.ContentProvider import com.raizlabs.android.dbflow.appendQualifier -import com.raizlabs.android.dbflow.sql.language.property.IProperty -import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable +import com.raizlabs.android.dbflow.query.property.IProperty import com.raizlabs.android.dbflow.structure.ChangeAction -import com.raizlabs.android.dbflow.structure.database.FlowCursor +import com.raizlabs.android.dbflow.database.FlowCursor import java.util.* /** diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/WhereBase.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/WhereBase.kt similarity index 75% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/WhereBase.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/WhereBase.kt index 9d9f77d4a..8662b8c96 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/WhereBase.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/WhereBase.kt @@ -1,7 +1,7 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.android.dbflow.query import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.database.DatabaseWrapper /** * Description: The base for a [Where] statement. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/IMultiKeyCacheConverter.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/cache/IMultiKeyCacheConverter.kt similarity index 93% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/IMultiKeyCacheConverter.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/cache/IMultiKeyCacheConverter.kt index bd9a0fe92..17d5c7b4a 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/IMultiKeyCacheConverter.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/cache/IMultiKeyCacheConverter.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.structure.cache +package com.raizlabs.android.dbflow.query.cache import com.raizlabs.android.dbflow.structure.Model diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/ModelCache.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/cache/ModelCache.kt similarity index 95% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/ModelCache.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/cache/ModelCache.kt index 7511e526c..c9a395375 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/ModelCache.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/cache/ModelCache.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.structure.cache +package com.raizlabs.android.dbflow.query.cache /** * Description: A generic cache for models that is implemented or can be implemented to your liking. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/ModelLruCache.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/cache/ModelLruCache.kt similarity index 97% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/ModelLruCache.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/cache/ModelLruCache.kt index ef158514a..b233f4040 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/ModelLruCache.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/cache/ModelLruCache.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.structure.cache +package com.raizlabs.android.dbflow.query.cache import android.util.LruCache import com.raizlabs.android.dbflow.annotation.DEFAULT_CACHE_SIZE diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/SimpleMapCache.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/cache/SimpleMapCache.kt similarity index 95% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/SimpleMapCache.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/cache/SimpleMapCache.kt index 2e05c4674..d8fcd55fe 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/SimpleMapCache.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/cache/SimpleMapCache.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.structure.cache +package com.raizlabs.android.dbflow.query.cache import com.raizlabs.android.dbflow.config.FlowLog import com.raizlabs.android.dbflow.structure.Model diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/SparseArrayBasedCache.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/cache/SparseArrayBasedCache.kt similarity index 97% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/SparseArrayBasedCache.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/cache/SparseArrayBasedCache.kt index c38ae669a..6ea513f7e 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/cache/SparseArrayBasedCache.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/cache/SparseArrayBasedCache.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.structure.cache +package com.raizlabs.android.dbflow.query.cache import android.util.SparseArray diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorIterator.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/list/FlowCursorIterator.kt similarity index 97% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorIterator.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/list/FlowCursorIterator.kt index 901210099..280915d9f 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorIterator.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/list/FlowCursorIterator.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.list +package com.raizlabs.android.dbflow.query.list import java.util.* diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorList.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/list/FlowCursorList.kt similarity index 96% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorList.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/list/FlowCursorList.kt index 5606ea965..405942d10 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowCursorList.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/list/FlowCursorList.kt @@ -1,12 +1,12 @@ -package com.raizlabs.android.dbflow.list +package com.raizlabs.android.dbflow.query.list import android.database.Cursor import android.widget.ListView import com.raizlabs.android.dbflow.config.FlowLog import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable -import com.raizlabs.android.dbflow.structure.InstanceAdapter -import com.raizlabs.android.dbflow.structure.database.FlowCursor +import com.raizlabs.android.dbflow.query.ModelQueriable +import com.raizlabs.android.dbflow.adapter.InstanceAdapter +import com.raizlabs.android.dbflow.database.FlowCursor import java.util.* /** diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowQueryList.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/list/FlowQueryList.kt similarity index 94% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowQueryList.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/list/FlowQueryList.kt index 115881288..d8e94bc32 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/FlowQueryList.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/list/FlowQueryList.kt @@ -1,13 +1,13 @@ -package com.raizlabs.android.dbflow.list +package com.raizlabs.android.dbflow.query.list import android.database.Cursor import android.os.Handler import android.os.Looper -import com.raizlabs.android.dbflow.list.FlowCursorList.OnCursorRefreshListener -import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable -import com.raizlabs.android.dbflow.structure.InstanceAdapter -import com.raizlabs.android.dbflow.structure.database.transaction.DefaultTransactionQueue -import com.raizlabs.android.dbflow.structure.database.transaction.Transaction +import com.raizlabs.android.dbflow.query.list.FlowCursorList.OnCursorRefreshListener +import com.raizlabs.android.dbflow.query.ModelQueriable +import com.raizlabs.android.dbflow.adapter.InstanceAdapter +import com.raizlabs.android.dbflow.transaction.DefaultTransactionQueue +import com.raizlabs.android.dbflow.transaction.Transaction /** * Description: Operates very similiar to a [java.util.List] except its backed by a table cursor. All of diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/IFlowCursorIterator.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/list/IFlowCursorIterator.kt similarity index 95% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/list/IFlowCursorIterator.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/list/IFlowCursorIterator.kt index 9c3d5f86d..fc0e22967 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/list/IFlowCursorIterator.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/list/IFlowCursorIterator.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.list +package com.raizlabs.android.dbflow.query.list import android.database.Cursor diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/IProperty.java b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/property/IProperty.java similarity index 92% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/IProperty.java rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/property/IProperty.java index 5f4305b53..3dd125baf 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/IProperty.java +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/property/IProperty.java @@ -1,13 +1,13 @@ -package com.raizlabs.android.dbflow.sql.language.property; +package com.raizlabs.android.dbflow.query.property; import android.support.annotation.NonNull; import android.support.annotation.Nullable; import com.raizlabs.android.dbflow.sql.Query; -import com.raizlabs.android.dbflow.sql.language.Join; -import com.raizlabs.android.dbflow.sql.language.Method; -import com.raizlabs.android.dbflow.sql.language.NameAlias; -import com.raizlabs.android.dbflow.sql.language.OrderBy; +import com.raizlabs.android.dbflow.query.Join; +import com.raizlabs.android.dbflow.query.Method; +import com.raizlabs.android.dbflow.query.NameAlias; +import com.raizlabs.android.dbflow.query.OrderBy; import com.raizlabs.android.dbflow.structure.Model; /** diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/IndexProperty.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/property/IndexProperty.kt similarity index 85% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/IndexProperty.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/property/IndexProperty.kt index ed66822a9..dfc86b514 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/IndexProperty.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/property/IndexProperty.kt @@ -1,9 +1,9 @@ -package com.raizlabs.android.dbflow.sql.language.property +package com.raizlabs.android.dbflow.query.property import com.raizlabs.android.dbflow.annotation.Table import com.raizlabs.android.dbflow.quoteIfNeeded -import com.raizlabs.android.dbflow.sql.language.Index -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.query.Index +import com.raizlabs.android.dbflow.database.DatabaseWrapper /** * Description: Defines an INDEX in Sqlite. It basically speeds up data retrieval over large datasets. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/Property.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/property/Property.kt similarity index 96% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/Property.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/property/Property.kt index f614de45a..787950852 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/Property.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/property/Property.kt @@ -1,12 +1,12 @@ -package com.raizlabs.android.dbflow.sql.language.property +package com.raizlabs.android.dbflow.query.property import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.sql.language.BaseModelQueriable -import com.raizlabs.android.dbflow.sql.language.IConditional -import com.raizlabs.android.dbflow.sql.language.IOperator -import com.raizlabs.android.dbflow.sql.language.NameAlias -import com.raizlabs.android.dbflow.sql.language.Operator -import com.raizlabs.android.dbflow.sql.language.OrderBy +import com.raizlabs.android.dbflow.query.BaseModelQueriable +import com.raizlabs.android.dbflow.query.IConditional +import com.raizlabs.android.dbflow.query.IOperator +import com.raizlabs.android.dbflow.query.NameAlias +import com.raizlabs.android.dbflow.query.Operator +import com.raizlabs.android.dbflow.query.OrderBy /** * Description: The main, immutable property class that gets generated from a table definition. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/PropertyFactory.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/property/PropertyFactory.kt similarity index 95% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/PropertyFactory.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/property/PropertyFactory.kt index 2e196542e..9020d6025 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/PropertyFactory.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/property/PropertyFactory.kt @@ -1,8 +1,8 @@ -package com.raizlabs.android.dbflow.sql.language.property +package com.raizlabs.android.dbflow.query.property -import com.raizlabs.android.dbflow.sql.language.NameAlias -import com.raizlabs.android.dbflow.sql.language.Operator -import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable +import com.raizlabs.android.dbflow.query.NameAlias +import com.raizlabs.android.dbflow.query.Operator +import com.raizlabs.android.dbflow.query.ModelQueriable import kotlin.reflect.KClass /** diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/TypeConvertedProperty.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/property/TypeConvertedProperty.kt similarity index 90% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/TypeConvertedProperty.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/property/TypeConvertedProperty.kt index 6b67606cd..b1fa3f742 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/TypeConvertedProperty.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/property/TypeConvertedProperty.kt @@ -1,9 +1,9 @@ -package com.raizlabs.android.dbflow.sql.language.property +package com.raizlabs.android.dbflow.query.property import com.raizlabs.android.dbflow.converter.TypeConverter -import com.raizlabs.android.dbflow.sql.language.NameAlias -import com.raizlabs.android.dbflow.sql.language.Operator -import com.raizlabs.android.dbflow.structure.ModelAdapter +import com.raizlabs.android.dbflow.query.NameAlias +import com.raizlabs.android.dbflow.query.Operator +import com.raizlabs.android.dbflow.adapter.ModelAdapter /** * Description: Provides convenience methods for [TypeConverter] when constructing queries. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/WrapperProperty.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/property/WrapperProperty.kt similarity index 87% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/WrapperProperty.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/query/property/WrapperProperty.kt index b3e653c11..2b002e207 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/language/property/WrapperProperty.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/property/WrapperProperty.kt @@ -1,6 +1,6 @@ -package com.raizlabs.android.dbflow.sql.language.property +package com.raizlabs.android.dbflow.query.property -import com.raizlabs.android.dbflow.sql.language.NameAlias +import com.raizlabs.android.dbflow.query.NameAlias /** * Description: Provides convenience for types that are represented in different ways in the DB. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ContentResolverNotifier.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ContentResolverNotifier.kt index b85160ebb..eba5f6184 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ContentResolverNotifier.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ContentResolverNotifier.kt @@ -3,10 +3,10 @@ package com.raizlabs.android.dbflow.runtime import android.content.ContentResolver import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.sql.getNotificationUri -import com.raizlabs.android.dbflow.sql.language.SQLOperator +import com.raizlabs.android.dbflow.getNotificationUri +import com.raizlabs.android.dbflow.query.SQLOperator import com.raizlabs.android.dbflow.structure.ChangeAction -import com.raizlabs.android.dbflow.structure.ModelAdapter +import com.raizlabs.android.dbflow.adapter.ModelAdapter /** * The default use case, it notifies via the [ContentResolver] system. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DBBatchSaveQueue.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DBBatchSaveQueue.kt index 72df9d66f..e80bc0fa3 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DBBatchSaveQueue.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DBBatchSaveQueue.kt @@ -4,11 +4,11 @@ import android.os.Looper import com.raizlabs.android.dbflow.config.DatabaseDefinition import com.raizlabs.android.dbflow.config.FlowLog import com.raizlabs.android.dbflow.structure.Model -import com.raizlabs.android.dbflow.structure.database.transaction.ProcessModelTransaction -import com.raizlabs.android.dbflow.structure.database.transaction.Transaction -import com.raizlabs.android.dbflow.structure.database.transaction.processModel -import com.raizlabs.android.dbflow.structure.database.transaction.transactionError -import com.raizlabs.android.dbflow.structure.database.transaction.transactionSuccess +import com.raizlabs.android.dbflow.transaction.ProcessModelTransaction +import com.raizlabs.android.dbflow.transaction.Transaction +import com.raizlabs.android.dbflow.transaction.processModel +import com.raizlabs.android.dbflow.transaction.transactionError +import com.raizlabs.android.dbflow.transaction.transactionSuccess import com.raizlabs.android.dbflow.structure.save import java.util.* diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DirectModelNotifier.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DirectModelNotifier.kt index 5ce97fd76..f729bb8a5 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DirectModelNotifier.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DirectModelNotifier.kt @@ -2,7 +2,7 @@ package com.raizlabs.android.dbflow.runtime import com.raizlabs.android.dbflow.config.DatabaseConfig import com.raizlabs.android.dbflow.structure.ChangeAction -import com.raizlabs.android.dbflow.structure.ModelAdapter +import com.raizlabs.android.dbflow.adapter.ModelAdapter import java.util.* /** diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/FlowContentObserver.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/FlowContentObserver.kt index 6b8845e05..50e186801 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/FlowContentObserver.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/FlowContentObserver.kt @@ -10,11 +10,11 @@ import android.os.Build.VERSION_CODES import android.os.Handler import com.raizlabs.android.dbflow.config.DatabaseConfig import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.sql.TABLE_QUERY_PARAM -import com.raizlabs.android.dbflow.sql.getNotificationUri -import com.raizlabs.android.dbflow.sql.language.NameAlias -import com.raizlabs.android.dbflow.sql.language.Operator -import com.raizlabs.android.dbflow.sql.language.SQLOperator +import com.raizlabs.android.dbflow.TABLE_QUERY_PARAM +import com.raizlabs.android.dbflow.getNotificationUri +import com.raizlabs.android.dbflow.query.NameAlias +import com.raizlabs.android.dbflow.query.Operator +import com.raizlabs.android.dbflow.query.SQLOperator import com.raizlabs.android.dbflow.structure.ChangeAction import com.raizlabs.android.dbflow.structure.Model import java.util.* diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ModelNotifier.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ModelNotifier.kt index 68f89b158..76fbf86f9 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ModelNotifier.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ModelNotifier.kt @@ -1,7 +1,7 @@ package com.raizlabs.android.dbflow.runtime import com.raizlabs.android.dbflow.structure.ChangeAction -import com.raizlabs.android.dbflow.structure.ModelAdapter +import com.raizlabs.android.dbflow.adapter.ModelAdapter /** * Interface for defining how we notify model changes. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/NotifyDistributor.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/NotifyDistributor.kt index 80648e355..365b8ffbf 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/NotifyDistributor.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/NotifyDistributor.kt @@ -2,7 +2,7 @@ package com.raizlabs.android.dbflow.runtime import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.structure.ChangeAction -import com.raizlabs.android.dbflow.structure.ModelAdapter +import com.raizlabs.android.dbflow.adapter.ModelAdapter /** * Description: Distributes notifications to the [ModelNotifier]. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseModel.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseModel.kt index ef34167b2..50455b4cf 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseModel.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseModel.kt @@ -1,8 +1,9 @@ package com.raizlabs.android.dbflow.structure +import com.raizlabs.android.dbflow.adapter.ModelAdapter import com.raizlabs.android.dbflow.annotation.ColumnIgnore import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.database.DatabaseWrapper /** * Description: The base implementation of [Model]. It is recommended to use this class as diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseQueryModel.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseQueryModel.kt index 036ec0de6..a24fe60ef 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseQueryModel.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseQueryModel.kt @@ -1,7 +1,7 @@ package com.raizlabs.android.dbflow.structure import com.raizlabs.android.dbflow.annotation.QueryModel -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.database.DatabaseWrapper /** * Description: Provides a base class for objects that represent [QueryModel]. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/Model.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/Model.kt index a60238ca5..b581df92e 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/Model.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/Model.kt @@ -1,8 +1,8 @@ package com.raizlabs.android.dbflow.structure -import com.raizlabs.android.dbflow.config.modelAdapter import com.raizlabs.android.dbflow.config.databaseForTable -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.config.modelAdapter +import com.raizlabs.android.dbflow.database.DatabaseWrapper interface Model : ReadOnlyModel { @@ -44,15 +44,21 @@ interface Model : ReadOnlyModel { } -inline fun T.save(databaseWrapper: DatabaseWrapper = databaseForTable()) = modelAdapter().save(this, databaseWrapper) +inline fun T.save(databaseWrapper: DatabaseWrapper = databaseForTable()): Boolean + = modelAdapter().save(this, databaseWrapper) -inline fun T.insert(databaseWrapper: DatabaseWrapper = databaseForTable()) = modelAdapter().insert(this, databaseWrapper) +inline fun T.insert(databaseWrapper: DatabaseWrapper = databaseForTable()): Long + = modelAdapter().insert(this, databaseWrapper) -inline fun T.update(databaseWrapper: DatabaseWrapper = databaseForTable()) = modelAdapter().update(this, databaseWrapper) +inline fun T.update(databaseWrapper: DatabaseWrapper = databaseForTable()): Boolean + = modelAdapter().update(this, databaseWrapper) -inline fun T.delete(databaseWrapper: DatabaseWrapper = databaseForTable()) = modelAdapter().delete(this, databaseWrapper) +inline fun T.delete(databaseWrapper: DatabaseWrapper = databaseForTable()): Boolean + = modelAdapter().delete(this, databaseWrapper) -inline fun T.exists(databaseWrapper: DatabaseWrapper = databaseForTable()) = modelAdapter().exists(this, databaseWrapper) +inline fun T.exists(databaseWrapper: DatabaseWrapper = databaseForTable()): Boolean + = modelAdapter().exists(this, databaseWrapper) -inline fun T.load(databaseWrapper: DatabaseWrapper = databaseForTable()) = modelAdapter().load(this, databaseWrapper) +inline fun T.load(databaseWrapper: DatabaseWrapper = databaseForTable()) + = modelAdapter().load(this, databaseWrapper) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/NoModificationModel.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/NoModificationModel.kt index 3d6821a59..873627668 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/NoModificationModel.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/NoModificationModel.kt @@ -1,7 +1,8 @@ package com.raizlabs.android.dbflow.structure +import com.raizlabs.android.dbflow.adapter.RetrievalAdapter import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.database.DatabaseWrapper /** * Description: A convenience class for [ReadOnlyModel]. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/OneToMany.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/OneToMany.kt index 9a27c2851..99c72e248 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/OneToMany.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/OneToMany.kt @@ -1,7 +1,7 @@ package com.raizlabs.android.dbflow.structure -import com.raizlabs.android.dbflow.sql.queriable.ModelQueriable -import com.raizlabs.android.dbflow.sql.queriable.list +import com.raizlabs.android.dbflow.query.ModelQueriable +import com.raizlabs.android.dbflow.query.list import kotlin.properties.ReadWriteProperty import kotlin.reflect.KProperty diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ReadOnlyModel.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ReadOnlyModel.kt index f5c303047..e4b1ffa3a 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ReadOnlyModel.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ReadOnlyModel.kt @@ -1,6 +1,6 @@ package com.raizlabs.android.dbflow.structure -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.database.DatabaseWrapper interface ReadOnlyModel { diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/BaseTransactionManager.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/BaseTransactionManager.kt similarity index 87% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/BaseTransactionManager.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/BaseTransactionManager.kt index 84320082e..7640bb309 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/BaseTransactionManager.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/BaseTransactionManager.kt @@ -1,9 +1,8 @@ -package com.raizlabs.android.dbflow.runtime +package com.raizlabs.android.dbflow.transaction import com.raizlabs.android.dbflow.config.DatabaseDefinition import com.raizlabs.android.dbflow.config.FlowLog -import com.raizlabs.android.dbflow.structure.database.transaction.ITransactionQueue -import com.raizlabs.android.dbflow.structure.database.transaction.Transaction +import com.raizlabs.android.dbflow.runtime.DBBatchSaveQueue /** * Description: The base implementation of Transaction manager. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Coroutines.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/Coroutines.kt similarity index 96% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Coroutines.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/Coroutines.kt index eb169f580..d3533334e 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Coroutines.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/Coroutines.kt @@ -1,7 +1,7 @@ -package com.raizlabs.android.dbflow.structure.database.transaction +package com.raizlabs.android.dbflow.transaction import com.raizlabs.android.dbflow.config.DatabaseDefinition -import com.raizlabs.android.dbflow.sql.queriable.Queriable +import com.raizlabs.android.dbflow.query.Queriable import com.raizlabs.android.dbflow.structure.delete import com.raizlabs.android.dbflow.structure.insert import com.raizlabs.android.dbflow.structure.load diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/DefaultTransactionManager.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/DefaultTransactionManager.kt similarity index 82% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/DefaultTransactionManager.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/DefaultTransactionManager.kt index 343917040..0d7f90354 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/DefaultTransactionManager.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/DefaultTransactionManager.kt @@ -1,7 +1,6 @@ -package com.raizlabs.android.dbflow.structure.database.transaction +package com.raizlabs.android.dbflow.transaction import com.raizlabs.android.dbflow.config.DatabaseDefinition -import com.raizlabs.android.dbflow.runtime.BaseTransactionManager /** * Description: This class manages batch database interactions. It is useful for retrieving, updating, saving, diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/DefaultTransactionQueue.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/DefaultTransactionQueue.kt similarity index 97% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/DefaultTransactionQueue.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/DefaultTransactionQueue.kt index eefc9d5d5..1ff0e32d5 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/DefaultTransactionQueue.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/DefaultTransactionQueue.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.structure.database.transaction +package com.raizlabs.android.dbflow.transaction import android.os.Looper diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/FastStoreModelTransaction.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/FastStoreModelTransaction.kt similarity index 95% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/FastStoreModelTransaction.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/FastStoreModelTransaction.kt index 5deef54f6..0734df73e 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/FastStoreModelTransaction.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/FastStoreModelTransaction.kt @@ -1,9 +1,9 @@ -package com.raizlabs.android.dbflow.structure.database.transaction +package com.raizlabs.android.dbflow.transaction import com.raizlabs.android.dbflow.config.modelAdapter -import com.raizlabs.android.dbflow.structure.InternalAdapter +import com.raizlabs.android.dbflow.adapter.InternalAdapter import com.raizlabs.android.dbflow.structure.Model -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.database.DatabaseWrapper import java.util.* /** diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ITransaction.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/ITransaction.kt similarity index 79% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ITransaction.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/ITransaction.kt index b1b664c55..bde57cd77 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ITransaction.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/ITransaction.kt @@ -1,8 +1,8 @@ -package com.raizlabs.android.dbflow.structure.database.transaction +package com.raizlabs.android.dbflow.transaction import android.database.sqlite.SQLiteDatabaseLockedException -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.database.DatabaseWrapper /** * Description: Simplest form of a transaction. It represents an interface by which code is executed diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ITransactionQueue.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/ITransactionQueue.kt similarity index 91% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ITransactionQueue.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/ITransactionQueue.kt index ea390ea06..d3e653b1d 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ITransactionQueue.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/ITransactionQueue.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.structure.database.transaction +package com.raizlabs.android.dbflow.transaction /** * Description: Interface for a queue that manages transactions. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/PriorityTransactionQueue.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/PriorityTransactionQueue.kt similarity index 98% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/PriorityTransactionQueue.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/PriorityTransactionQueue.kt index 757f15e73..95f3a5940 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/PriorityTransactionQueue.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/PriorityTransactionQueue.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.structure.database.transaction +package com.raizlabs.android.dbflow.transaction import android.os.Looper diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/PriorityTransactionWrapper.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/PriorityTransactionWrapper.kt similarity index 93% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/PriorityTransactionWrapper.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/PriorityTransactionWrapper.kt index b106a6ca1..080ea71ec 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/PriorityTransactionWrapper.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/PriorityTransactionWrapper.kt @@ -1,8 +1,8 @@ -package com.raizlabs.android.dbflow.structure.database.transaction +package com.raizlabs.android.dbflow.transaction import android.support.annotation.IntDef -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.database.DatabaseWrapper /** * Description: Provides transaction with priority. Meant to be used in a [PriorityTransactionQueue]. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ProcessModelTransaction.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/ProcessModelTransaction.kt similarity index 97% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ProcessModelTransaction.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/ProcessModelTransaction.kt index f87986a14..b5778aa60 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/ProcessModelTransaction.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/ProcessModelTransaction.kt @@ -1,8 +1,8 @@ -package com.raizlabs.android.dbflow.structure.database.transaction +package com.raizlabs.android.dbflow.transaction import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.structure.Model -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.database.DatabaseWrapper /** * Description: Allows you to process a single or [List] of models in a transaction. You diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Transaction.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/Transaction.kt similarity index 98% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Transaction.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/Transaction.kt index 672be62db..b20970253 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/Transaction.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/Transaction.kt @@ -1,11 +1,10 @@ -package com.raizlabs.android.dbflow.structure.database.transaction +package com.raizlabs.android.dbflow.transaction import android.os.Handler import android.os.Looper import com.raizlabs.android.dbflow.config.DatabaseDefinition import com.raizlabs.android.dbflow.config.FlowLog -import com.raizlabs.android.dbflow.runtime.BaseTransactionManager /** * Description: The main transaction class. It represents a transaction that occurs in the database. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/TransactionWrapper.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/TransactionWrapper.kt similarity index 80% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/TransactionWrapper.kt rename to dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/TransactionWrapper.kt index 5642a7370..1fb5844a4 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/database/transaction/TransactionWrapper.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/TransactionWrapper.kt @@ -1,6 +1,6 @@ -package com.raizlabs.android.dbflow.structure.database.transaction +package com.raizlabs.android.dbflow.transaction -import com.raizlabs.android.dbflow.structure.database.DatabaseWrapper +import com.raizlabs.android.dbflow.database.DatabaseWrapper import java.util.* /** From fad36e7a782697a9106ba977522dc10cada9c227 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Mon, 27 Nov 2017 08:03:06 -0500 Subject: [PATCH 091/234] [5.0] fix compilation errors in APT. add infix modifiers to app IOperator ops. remove old class. --- .../android/dbflow/processor/ClassNames.kt | 9 +- .../definition/InternalAdapterHelper.kt | 102 ------------------ .../definition/column/ColumnDefinition.kt | 16 +-- .../android/dbflow/sql/language/CaseTest.kt | 1 + .../dbflow/sql/language/TriggerTest.kt | 1 + .../android/dbflow/query/IOperator.kt | 34 +++--- 6 files changed, 33 insertions(+), 130 deletions(-) delete mode 100644 dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/InternalAdapterHelper.kt diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/ClassNames.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/ClassNames.kt index a57ec4ee8..2261abad8 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/ClassNames.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/ClassNames.kt @@ -22,6 +22,7 @@ object ClassNames { val CONFIG = BASE_PACKAGE + ".config" val RUNTIME = BASE_PACKAGE + ".runtime" val SAVEABLE = ADAPTER + ".saveable" + val PROVIDER = BASE_PACKAGE + ".provider" val DATABASE_HOLDER = ClassName.get(CONFIG, "DatabaseHolder") val FLOW_MANAGER = ClassName.get(CONFIG, "FlowManager") @@ -65,11 +66,11 @@ object ClassNames { val ICONDITIONAL = ClassName.get(QUERY_PACKAGE, "IConditional") - val BASE_CONTENT_PROVIDER = ClassName.get(RUNTIME, "BaseContentProvider") + val BASE_CONTENT_PROVIDER = ClassName.get(PROVIDER, "BaseContentProvider") - val BASE_MODEL = ClassName.get(ADAPTER, "BaseModel") - val MODEL_CACHE = ClassName.get(ADAPTER + ".cache", "ModelCache") - val MULTI_KEY_CACHE_CONVERTER = ClassName.get(ADAPTER + ".cache", "IMultiKeyCacheConverter") + val BASE_MODEL = ClassName.get(STRUCTURE, "BaseModel") + val MODEL_CACHE = ClassName.get(QUERY_PACKAGE + ".cache", "ModelCache") + val MULTI_KEY_CACHE_CONVERTER = ClassName.get(QUERY_PACKAGE + ".cache", "IMultiKeyCacheConverter") val CACHEABLE_MODEL_LOADER = ClassName.get(QUERIABLE, "CacheableModelLoader") val SINGLE_MODEL_LOADER = ClassName.get(QUERIABLE, "SingleModelLoader") diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/InternalAdapterHelper.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/InternalAdapterHelper.kt deleted file mode 100644 index e1b50d3ef..000000000 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/InternalAdapterHelper.kt +++ /dev/null @@ -1,102 +0,0 @@ -package com.raizlabs.android.dbflow.processor.definition - -import com.raizlabs.android.dbflow.processor.ClassNames -import com.raizlabs.android.dbflow.processor.definition.column.ColumnDefinition -import com.raizlabs.android.dbflow.processor.definition.column.DefinitionUtils -import com.raizlabs.android.dbflow.processor.utils.ModelUtils -import com.raizlabs.android.dbflow.quote -import com.squareup.javapoet.ArrayTypeName -import com.squareup.javapoet.ClassName -import com.squareup.javapoet.MethodSpec -import com.squareup.javapoet.ParameterizedTypeName -import com.squareup.javapoet.TypeName -import com.squareup.javapoet.TypeSpec -import javax.lang.model.element.Modifier - -/** - * Description: Assists in writing methods for adapters - */ -object InternalAdapterHelper { - - fun writeGetModelClass(typeBuilder: TypeSpec.Builder, modelClassName: ClassName?) { - typeBuilder.addMethod(MethodSpec.methodBuilder("getModelClass") - .addAnnotation(Override::class.java) - .addModifiers(Modifier.PUBLIC, Modifier.FINAL) - .addStatement("return \$T.class", modelClassName) - .returns(ParameterizedTypeName.get(ClassName.get(Class::class.java), modelClassName)) - .build()) - } - - fun writeGetTableName(typeBuilder: TypeSpec.Builder, tableName: String?) { - typeBuilder.addMethod(MethodSpec.methodBuilder("getTableName") - .addModifiers(Modifier.PUBLIC, Modifier.FINAL) - .addStatement("return \$S", tableName.quote()) - .returns(ClassName.get(String::class.java)) - .build()) - } - - fun writeUpdateAutoIncrement(typeBuilder: TypeSpec.Builder, modelClassName: TypeName?, - autoIncrementDefinition: ColumnDefinition) { - typeBuilder.addMethod(MethodSpec.methodBuilder("updateAutoIncrement") - .addAnnotation(Override::class.java) - .addModifiers(Modifier.PUBLIC, Modifier.FINAL) - .addParameter(modelClassName, ModelUtils.variable) - .addParameter(ClassName.get(Number::class.java), "id") - .addCode(autoIncrementDefinition.updateAutoIncrementMethod) - .build()) - } - - fun writeGetCachingId(typeBuilder: TypeSpec.Builder, modelClassName: TypeName?, - primaryColumns: List) { - if (primaryColumns.size > 1) { - var methodBuilder: MethodSpec.Builder = MethodSpec.methodBuilder("getCachingColumnValuesFromModel") - .addAnnotation(Override::class.java).addModifiers(Modifier.PUBLIC, Modifier.FINAL) - .addParameter(ArrayTypeName.of(Any::class.java), "inValues") - .addParameter(modelClassName, ModelUtils.variable) - for (i in primaryColumns.indices) { - val column = primaryColumns[i] - methodBuilder.addCode(column.getColumnAccessString(i)) - } - methodBuilder.addStatement("return \$L", "inValues").returns(ArrayTypeName.of(Any::class.java)) - typeBuilder.addMethod(methodBuilder.build()) - - methodBuilder = MethodSpec.methodBuilder("getCachingColumnValuesFromCursor") - .addAnnotation(Override::class.java).addModifiers(Modifier.PUBLIC, Modifier.FINAL) - .addParameter(ArrayTypeName.of(Any::class.java), "inValues") - .addParameter(ClassNames.CURSOR, "cursor") - for (i in primaryColumns.indices) { - val column = primaryColumns[i] - val method = DefinitionUtils.getLoadFromCursorMethodString(column.elementTypeName, column.wrapperTypeName) - methodBuilder.addStatement("inValues[\$L] = \$L.\$L(\$L.getColumnIndex(\$S))", i, LoadFromCursorMethod.PARAM_CURSOR, - method, LoadFromCursorMethod.PARAM_CURSOR, column.columnName) - } - methodBuilder.addStatement("return \$L", "inValues").returns(ArrayTypeName.of(Any::class.java)) - typeBuilder.addMethod(methodBuilder.build()) - } else { - // single primary key - var methodBuilder: MethodSpec.Builder = MethodSpec.methodBuilder("getCachingColumnValueFromModel") - .addAnnotation(Override::class.java).addModifiers(Modifier.PUBLIC, Modifier.FINAL) - .addParameter(modelClassName, ModelUtils.variable) - methodBuilder.addCode(primaryColumns[0].getSimpleAccessString()) - .returns(Any::class.java) - typeBuilder.addMethod(methodBuilder.build()) - - methodBuilder = MethodSpec.methodBuilder("getCachingColumnValueFromCursor") - .addAnnotation(Override::class.java).addModifiers(Modifier.PUBLIC, Modifier.FINAL) - .addParameter(ClassNames.CURSOR, "cursor") - val column = primaryColumns[0] - val method = DefinitionUtils.getLoadFromCursorMethodString(column.elementTypeName, column.wrapperTypeName) - methodBuilder.addStatement("return \$L.\$L(\$L.getColumnIndex(\$S))", LoadFromCursorMethod.PARAM_CURSOR, - method, LoadFromCursorMethod.PARAM_CURSOR, column.columnName).returns(Any::class.java) - typeBuilder.addMethod(methodBuilder.build()) - - methodBuilder = MethodSpec.methodBuilder("getCachingId") - .addModifiers(Modifier.PUBLIC, Modifier.FINAL) - .addParameter(modelClassName, ModelUtils.variable) - .addStatement("return getCachingColumnValueFromModel(\$L)", - ModelUtils.variable).returns(TypeName.OBJECT) - typeBuilder.addMethod(methodBuilder.build()) - } - } - -} diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ColumnDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ColumnDefinition.kt index 481fbbe59..9dacf1968 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ColumnDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ColumnDefinition.kt @@ -326,13 +326,15 @@ constructor(processorManager: ProcessorManager, element: Element, if (isNonPrimitiveTypeConverter) { val codeBlock = CodeBlock.builder() codeBlock.add("new \$T(\$T.class, \$S, true,", propParam, tableClass, columnName) - codeBlock.add("\nnew \$T() {" + - "\n@Override" + - "\npublic \$T getTypeConverter(Class modelClass) {" + - "\n \$T adapter = (\$T) \$T.getInstanceAdapter(modelClass);" + - "\nreturn adapter.\$L;" + - "\n}" + - "\n})", ClassNames.TYPE_CONVERTER_GETTER, ClassNames.TYPE_CONVERTER, + codeBlock.add(""" + new ${"$"}T() { + @Override + public ${"$"}T getTypeConverter(Class modelClass) { + ${"$"}T adapter = (${"$"}T) ${"$"}T.getInstanceAdapter(modelClass); + return adapter.${"$"}L; + } + })""", + ClassNames.TYPE_CONVERTER_GETTER, ClassNames.TYPE_CONVERTER, baseTableDefinition.outputClassName, baseTableDefinition.outputClassName, ClassNames.FLOW_MANAGER, (wrapperAccessor as TypeConverterScopeColumnAccessor).typeConverterFieldName) diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CaseTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CaseTest.kt index c8763cbae..bf228591f 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CaseTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CaseTest.kt @@ -2,6 +2,7 @@ package com.raizlabs.android.dbflow.sql.language import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.models.SimpleModel_Table +import com.raizlabs.android.dbflow.query.case import com.raizlabs.android.dbflow.query.caseWhen import com.raizlabs.android.dbflow.query.property.propertyString import org.junit.Assert.* diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/TriggerTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/TriggerTest.kt index bdc74c19a..2c41571bf 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/TriggerTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/TriggerTest.kt @@ -11,6 +11,7 @@ import com.raizlabs.android.dbflow.query.NameAlias import com.raizlabs.android.dbflow.query.and import com.raizlabs.android.dbflow.query.begin import com.raizlabs.android.dbflow.query.cast +import com.raizlabs.android.dbflow.query.columnValues import com.raizlabs.android.dbflow.query.createTrigger import com.raizlabs.android.dbflow.query.insert import com.raizlabs.android.dbflow.query.insertOn diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/IOperator.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/IOperator.kt index 5a8b96be8..c6b2bb9fa 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/IOperator.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/IOperator.kt @@ -13,7 +13,7 @@ interface IOperator : Query, IConditional { * @param value The [T] that we express equality to. * @return A [Operator] that represents equality between this and the parameter. */ - fun `is`(value: T?): Operator + infix fun `is`(value: T?): Operator /** * Assigns the operation to "=". Identical to [.is] @@ -22,7 +22,7 @@ interface IOperator : Query, IConditional { * @return A [Operator] that represents equality between this and the parameter. * @see .is */ - fun eq(value: T?): Operator + infix fun eq(value: T?): Operator /** * Generates a [Operator] that concatenates this [IOperator] with the [T] via "||" @@ -31,7 +31,7 @@ interface IOperator : Query, IConditional { * @param value The value to concatenate. * @return A [<] that represents concatenation. */ - fun concatenate(value: Any?): Operator + infix fun concatenate(value: Any?): Operator /** * Assigns the operation to "!=" @@ -39,7 +39,7 @@ interface IOperator : Query, IConditional { * @param value The [T] that we express inequality to. * @return A [<] that represents inequality between this and the parameter. */ - fun isNot(value: T?): Operator + infix fun isNot(value: T?): Operator /** * Assigns the operation to "!=" @@ -48,7 +48,7 @@ interface IOperator : Query, IConditional { * @return A [<] that represents inequality between this and the parameter. * @see .notEq */ - fun notEq(value: T?): Operator + infix fun notEq(value: T?): Operator /** * Assigns operation to ">" @@ -56,7 +56,7 @@ interface IOperator : Query, IConditional { * @param value The [T] that this [IOperator] is greater than. * @return A [<] that represents greater than between this and the parameter. */ - fun greaterThan(value: T): Operator + infix fun greaterThan(value: T): Operator /** * Assigns operation to ">=" @@ -64,7 +64,7 @@ interface IOperator : Query, IConditional { * @param value The [T] that this [IOperator] is greater than or equal to. * @return A [<] that represents greater than or equal between this and the parameter. */ - fun greaterThanOrEq(value: T): Operator + infix fun greaterThanOrEq(value: T): Operator /** @@ -73,7 +73,7 @@ interface IOperator : Query, IConditional { * @param value The [T] that this [IOperator] is less than. * @return A [<] that represents less than between this and the parameter. */ - fun lessThan(value: T): Operator + infix fun lessThan(value: T): Operator /** @@ -82,9 +82,9 @@ interface IOperator : Query, IConditional { * @param value The [T] that this [IOperator] is less than or equal to. * @return A [<] that represents less than or equal to between this and the parameter. */ - fun lessThanOrEq(value: T): Operator + infix fun lessThanOrEq(value: T): Operator - fun between(value: T): Operator.Between + infix fun between(value: T): Operator.Between /** * Turns this [IOperator] into an [.In][<]. It means that this object should @@ -113,7 +113,7 @@ interface IOperator : Query, IConditional { * @param values The rest of the values to pass optionally. * @return A new [.In][<] built from this [IOperator]. */ - fun `in`(values: Collection): Operator.In + infix fun `in`(values: Collection): Operator.In /** * Turns this [IOperator] into an [.In][<] (not). It means that this object should NOT @@ -122,21 +122,21 @@ interface IOperator : Query, IConditional { * @param values The rest of the values to pass optionally. * @return A new [.In][<] (not) built from this [IOperator]. */ - fun notIn(values: Collection): Operator.In + infix fun notIn(values: Collection): Operator.In /** * Adds another value and returns the operator. i.e p1 + p2 * * @param value the value to add. */ - operator fun plus(value: T): Operator + infix operator fun plus(value: T): Operator /** * Subtracts another value and returns the operator. i.e p1 - p2 * * @param value the value to subtract. */ - operator fun minus(value: T): Operator + infix operator fun minus(value: T): Operator /** * Divides another value and returns as the operator. i.e p1 / p2 @@ -144,19 +144,19 @@ interface IOperator : Query, IConditional { * @param value the value to divide. * @return A new instance. */ - operator fun div(value: T): Operator + infix operator fun div(value: T): Operator /** * Multiplies another value and returns as the operator. i.e p1 * p2 * * @param value the value to multiply. */ - operator fun times(value: T): Operator + infix operator fun times(value: T): Operator /** * Modulous another value and returns as the operator. i.e p1 % p2 * * @param value the value to calculate remainder of. */ - operator fun rem(value: T): Operator + infix operator fun rem(value: T): Operator } From 5747a5521a6aab269d61d3dcab8579ab49d7ff57 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Mon, 27 Nov 2017 08:07:15 -0500 Subject: [PATCH 092/234] [5.0] make IConditional methods infix and remove unneeded extension methods. --- .../raizlabs/android/dbflow/TestDatabase.kt | 2 +- .../dbflow/config/ConfigIntegrationTest.kt | 2 +- .../dbflow/config/DatabaseConfigTest.kt | 2 +- .../database/transaction/CoroutinesTest.kt | 4 +- .../FastStoreModelTransactionTest.kt | 2 +- .../dbflow/models/CachingModelsTest.kt | 2 +- .../dbflow/models/DontCreateModelTest.kt | 2 +- .../android/dbflow/models/ModelViews.kt | 2 +- .../dbflow/models/OneToManyModelTest.kt | 4 +- .../android/dbflow/models/OneToManyModels.kt | 2 +- .../dbflow/models/ParentChildCachingTest.kt | 2 +- .../android/dbflow/models/QueryModelTest.kt | 2 - .../android/dbflow/models/SimpleTestModels.kt | 2 +- .../android/dbflow/models/issue/Issue.java | 2 +- .../android/dbflow/models/issue/SubIssue.java | 2 +- .../dbflow/models/java/JavaModelView.java | 2 +- .../dbflow/provider/ContentProviderTests.kt | 2 +- .../dbflow/query/list/FlowCursorListTest.kt | 2 +- .../dbflow/rx/language/RXQueryTests.kt | 2 +- .../dbflow/sql/language/CursorResultTest.kt | 2 +- .../android/dbflow/sql/language/DeleteTest.kt | 2 +- .../dbflow/sql/language/IndexedByTest.kt | 2 +- .../android/dbflow/sql/language/InsertTest.kt | 16 +-- .../dbflow/sql/language/TriggerTest.kt | 2 +- .../android/dbflow/sql/language/UpdateTest.kt | 2 +- .../android/dbflow/sql/language/WhereTest.kt | 4 +- .../android/dbflow/query/IConditional.kt | 111 ++++++------------ 27 files changed, 69 insertions(+), 114 deletions(-) diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/TestDatabase.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/TestDatabase.kt index 44b4feeb2..f6915e29c 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/TestDatabase.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/TestDatabase.kt @@ -2,8 +2,8 @@ package com.raizlabs.android.dbflow import com.raizlabs.android.dbflow.annotation.Database import com.raizlabs.android.dbflow.annotation.Migration -import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.migration.UpdateTableMigration +import com.raizlabs.android.dbflow.models.SimpleModel /** * Description: diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/config/ConfigIntegrationTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/config/ConfigIntegrationTest.kt index cddb15558..904dfbde1 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/config/ConfigIntegrationTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/config/ConfigIntegrationTest.kt @@ -2,10 +2,10 @@ package com.raizlabs.android.dbflow.config import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.TestDatabase -import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.adapter.queriable.ListModelLoader import com.raizlabs.android.dbflow.adapter.queriable.SingleModelLoader import com.raizlabs.android.dbflow.adapter.saveable.ModelSaver +import com.raizlabs.android.dbflow.models.SimpleModel import org.junit.Assert.* import org.junit.Before import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/config/DatabaseConfigTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/config/DatabaseConfigTest.kt index 1f609a017..22387c506 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/config/DatabaseConfigTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/config/DatabaseConfigTest.kt @@ -3,9 +3,9 @@ package com.raizlabs.android.dbflow.config import com.nhaarman.mockito_kotlin.mock import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.TestDatabase -import com.raizlabs.android.dbflow.transaction.BaseTransactionManager import com.raizlabs.android.dbflow.database.DatabaseHelperListener import com.raizlabs.android.dbflow.database.OpenHelper +import com.raizlabs.android.dbflow.transaction.BaseTransactionManager import org.junit.Assert import org.junit.Before import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/CoroutinesTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/CoroutinesTest.kt index be20525b0..0ed42d447 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/CoroutinesTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/CoroutinesTest.kt @@ -6,15 +6,15 @@ import com.raizlabs.android.dbflow.config.database import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table import com.raizlabs.android.dbflow.query.delete +import com.raizlabs.android.dbflow.query.list import com.raizlabs.android.dbflow.query.select import com.raizlabs.android.dbflow.query.where -import com.raizlabs.android.dbflow.query.list +import com.raizlabs.android.dbflow.structure.save import com.raizlabs.android.dbflow.transaction.awaitDelete import com.raizlabs.android.dbflow.transaction.awaitInsert import com.raizlabs.android.dbflow.transaction.awaitSave import com.raizlabs.android.dbflow.transaction.awaitUpdate import com.raizlabs.android.dbflow.transaction.transact -import com.raizlabs.android.dbflow.structure.save import kotlinx.coroutines.experimental.runBlocking import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/FastStoreModelTransactionTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/FastStoreModelTransactionTest.kt index 727364ef7..bc3d71b3d 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/FastStoreModelTransactionTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/FastStoreModelTransactionTest.kt @@ -5,8 +5,8 @@ import com.raizlabs.android.dbflow.TestDatabase import com.raizlabs.android.dbflow.config.database import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.TwoColumnModel -import com.raizlabs.android.dbflow.query.select import com.raizlabs.android.dbflow.query.list +import com.raizlabs.android.dbflow.query.select import com.raizlabs.android.dbflow.transaction.fastInsert import com.raizlabs.android.dbflow.transaction.fastSave import com.raizlabs.android.dbflow.transaction.fastUpdate diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/CachingModelsTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/CachingModelsTest.kt index 5dfb07e11..04046e6e8 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/CachingModelsTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/CachingModelsTest.kt @@ -3,9 +3,9 @@ package com.raizlabs.android.dbflow.models import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.TestDatabase import com.raizlabs.android.dbflow.config.database -import com.raizlabs.android.dbflow.query.select import com.raizlabs.android.dbflow.query.list import com.raizlabs.android.dbflow.query.result +import com.raizlabs.android.dbflow.query.select import com.raizlabs.android.dbflow.structure.save import org.junit.Assert.assertEquals import org.junit.Assert.assertNotEquals diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/DontCreateModelTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/DontCreateModelTest.kt index 77f8a1aa7..3b707c409 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/DontCreateModelTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/DontCreateModelTest.kt @@ -4,8 +4,8 @@ import android.database.sqlite.SQLiteException import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.assertThrowsException import com.raizlabs.android.dbflow.config.databaseForTable -import com.raizlabs.android.dbflow.query.select import com.raizlabs.android.dbflow.query.list +import com.raizlabs.android.dbflow.query.select import org.junit.Test /** diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ModelViews.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ModelViews.kt index 4f4e60810..fd42dce8d 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ModelViews.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ModelViews.kt @@ -5,11 +5,11 @@ import com.raizlabs.android.dbflow.annotation.Column import com.raizlabs.android.dbflow.annotation.ColumnMap import com.raizlabs.android.dbflow.annotation.ModelView import com.raizlabs.android.dbflow.annotation.ModelViewQuery +import com.raizlabs.android.dbflow.database.DatabaseWrapper import com.raizlabs.android.dbflow.models.Author_Table.* import com.raizlabs.android.dbflow.query.property.IProperty import com.raizlabs.android.dbflow.query.property.property import com.raizlabs.android.dbflow.query.select -import com.raizlabs.android.dbflow.database.DatabaseWrapper class AuthorName(var name: String = "", var age: Int = 0) diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModelTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModelTest.kt index 6fbd907ae..551081e1e 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModelTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModelTest.kt @@ -3,9 +3,9 @@ package com.raizlabs.android.dbflow.models import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.TestDatabase import com.raizlabs.android.dbflow.config.database -import com.raizlabs.android.dbflow.query.select import com.raizlabs.android.dbflow.query.list import com.raizlabs.android.dbflow.query.result +import com.raizlabs.android.dbflow.query.select import com.raizlabs.android.dbflow.structure.delete import com.raizlabs.android.dbflow.structure.exists import com.raizlabs.android.dbflow.structure.save @@ -15,7 +15,7 @@ import org.junit.Test class OneToManyModelTest : BaseUnitTest() { @Test - fun testOneToManyModel(){ + fun testOneToManyModel() { database(TestDatabase::class) { var testModel2 = TwoColumnModel("Greater", 4) testModel2.save() diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModels.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModels.kt index ae4ce6dd5..908160900 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModels.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModels.kt @@ -6,11 +6,11 @@ import com.raizlabs.android.dbflow.annotation.OneToManyMethod import com.raizlabs.android.dbflow.annotation.PrimaryKey import com.raizlabs.android.dbflow.annotation.Table import com.raizlabs.android.dbflow.config.databaseForTable +import com.raizlabs.android.dbflow.database.DatabaseWrapper import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id import com.raizlabs.android.dbflow.query.select import com.raizlabs.android.dbflow.query.where import com.raizlabs.android.dbflow.structure.BaseModel -import com.raizlabs.android.dbflow.database.DatabaseWrapper import com.raizlabs.android.dbflow.structure.oneToMany @Table(database = TestDatabase::class) diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ParentChildCachingTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ParentChildCachingTest.kt index 911241b2f..9d42d50ec 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ParentChildCachingTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ParentChildCachingTest.kt @@ -3,8 +3,8 @@ package com.raizlabs.android.dbflow.models import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.TestDatabase import com.raizlabs.android.dbflow.config.database -import com.raizlabs.android.dbflow.query.select import com.raizlabs.android.dbflow.query.result +import com.raizlabs.android.dbflow.query.select import com.raizlabs.android.dbflow.structure.load import com.raizlabs.android.dbflow.structure.save import org.junit.Assert.assertEquals diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/QueryModelTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/QueryModelTest.kt index 4e45daa90..f88754735 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/QueryModelTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/QueryModelTest.kt @@ -6,7 +6,6 @@ import com.raizlabs.android.dbflow.config.database import com.raizlabs.android.dbflow.models.Author_Table.id import com.raizlabs.android.dbflow.models.Blog_Table.author_id import com.raizlabs.android.dbflow.models.Blog_Table.name -import com.raizlabs.android.dbflow.query.eq import com.raizlabs.android.dbflow.query.innerJoin import com.raizlabs.android.dbflow.query.on import com.raizlabs.android.dbflow.query.select @@ -20,7 +19,6 @@ import org.junit.Test */ class QueryModelTest : BaseUnitTest() { - @Test fun testCanLoadAuthorBlogs() = database(TestDatabase::class) { val author = Author(0, "Andrew", "Grosner") diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/SimpleTestModels.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/SimpleTestModels.kt index 0b36cd054..c6b32e6e4 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/SimpleTestModels.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/SimpleTestModels.kt @@ -11,9 +11,9 @@ import com.raizlabs.android.dbflow.annotation.QueryModel import com.raizlabs.android.dbflow.annotation.Table import com.raizlabs.android.dbflow.converter.TypeConverter import com.raizlabs.android.dbflow.data.Blob -import com.raizlabs.android.dbflow.structure.BaseModel import com.raizlabs.android.dbflow.database.DatabaseStatement import com.raizlabs.android.dbflow.query.SQLiteStatementListener +import com.raizlabs.android.dbflow.structure.BaseModel import java.math.BigDecimal import java.math.BigInteger import java.util.* diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/Issue.java b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/Issue.java index b3792f92e..31c88aa66 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/Issue.java +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/Issue.java @@ -5,8 +5,8 @@ import com.raizlabs.android.dbflow.annotation.OneToManyMethod; import com.raizlabs.android.dbflow.annotation.PrimaryKey; import com.raizlabs.android.dbflow.annotation.Table; -import com.raizlabs.android.dbflow.structure.BaseModel; import com.raizlabs.android.dbflow.database.DatabaseWrapper; +import com.raizlabs.android.dbflow.structure.BaseModel; import java.util.List; diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/SubIssue.java b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/SubIssue.java index 507d5d7f1..d5dedb7ed 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/SubIssue.java +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/SubIssue.java @@ -5,8 +5,8 @@ import com.raizlabs.android.dbflow.annotation.OneToManyMethod; import com.raizlabs.android.dbflow.annotation.PrimaryKey; import com.raizlabs.android.dbflow.annotation.Table; -import com.raizlabs.android.dbflow.structure.BaseModel; import com.raizlabs.android.dbflow.database.DatabaseWrapper; +import com.raizlabs.android.dbflow.structure.BaseModel; import java.util.ArrayList; import java.util.List; diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/java/JavaModelView.java b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/java/JavaModelView.java index f50fcc5e2..dc7bd1205 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/java/JavaModelView.java +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/java/JavaModelView.java @@ -4,10 +4,10 @@ import com.raizlabs.android.dbflow.annotation.Column; import com.raizlabs.android.dbflow.annotation.ModelView; import com.raizlabs.android.dbflow.annotation.ModelViewQuery; +import com.raizlabs.android.dbflow.database.DatabaseWrapper; import com.raizlabs.android.dbflow.models.Author_Table; import com.raizlabs.android.dbflow.query.SQLite; import com.raizlabs.android.dbflow.sql.Query; -import com.raizlabs.android.dbflow.database.DatabaseWrapper; @ModelView(database = TestDatabase.class) public class JavaModelView { diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/provider/ContentProviderTests.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/provider/ContentProviderTests.kt index d3ef104de..11cf06006 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/provider/ContentProviderTests.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/provider/ContentProviderTests.kt @@ -6,9 +6,9 @@ import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.config.database import com.raizlabs.android.dbflow.query.Delete.Companion.table import com.raizlabs.android.dbflow.query.Delete.Companion.tables +import com.raizlabs.android.dbflow.query.result import com.raizlabs.android.dbflow.query.select import com.raizlabs.android.dbflow.query.where -import com.raizlabs.android.dbflow.query.result import com.raizlabs.android.dbflow.structure.delete import com.raizlabs.android.dbflow.structure.exists import com.raizlabs.android.dbflow.structure.insert diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/query/list/FlowCursorListTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/query/list/FlowCursorListTest.kt index 55529dc85..ee5ebd3fc 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/query/list/FlowCursorListTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/query/list/FlowCursorListTest.kt @@ -6,8 +6,8 @@ import com.nhaarman.mockito_kotlin.verify import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.query.select import com.raizlabs.android.dbflow.query.cursor +import com.raizlabs.android.dbflow.query.select import com.raizlabs.android.dbflow.structure.save import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/RXQueryTests.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/RXQueryTests.kt index e0622fe7f..d331422f7 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/RXQueryTests.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/RXQueryTests.kt @@ -3,13 +3,13 @@ package com.raizlabs.android.dbflow.rx.language import android.database.Cursor import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.config.databaseForTable +import com.raizlabs.android.dbflow.database.DatabaseStatement import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table.name import com.raizlabs.android.dbflow.query.insert import com.raizlabs.android.dbflow.query.property.Property import com.raizlabs.android.dbflow.query.select import com.raizlabs.android.dbflow.query.selectCountOf -import com.raizlabs.android.dbflow.database.DatabaseStatement import com.raizlabs.android.dbflow.structure.save import org.junit.Assert.assertEquals import org.junit.Assert.assertNotNull diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CursorResultTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CursorResultTest.kt index 5a797dc4a..f69177d7e 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CursorResultTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CursorResultTest.kt @@ -6,12 +6,12 @@ import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.models.SimpleCustomModel import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.query.CursorResult +import com.raizlabs.android.dbflow.query.cursorResult import com.raizlabs.android.dbflow.query.select import com.raizlabs.android.dbflow.query.toCustomList import com.raizlabs.android.dbflow.query.toCustomListClose import com.raizlabs.android.dbflow.query.toCustomModel import com.raizlabs.android.dbflow.query.toCustomModelClose -import com.raizlabs.android.dbflow.query.cursorResult import com.raizlabs.android.dbflow.structure.save import org.junit.Assert.* import org.junit.Before diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/DeleteTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/DeleteTest.kt index 66f777321..5624f94e6 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/DeleteTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/DeleteTest.kt @@ -5,8 +5,8 @@ import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table import com.raizlabs.android.dbflow.query.delete -import com.raizlabs.android.dbflow.query.select import com.raizlabs.android.dbflow.query.list +import com.raizlabs.android.dbflow.query.select import com.raizlabs.android.dbflow.structure.save import org.junit.Assert.assertEquals import org.junit.Assert.assertFalse diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexedByTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexedByTest.kt index 3dc065510..0e03d1f1d 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexedByTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexedByTest.kt @@ -4,8 +4,8 @@ import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table -import com.raizlabs.android.dbflow.query.select import com.raizlabs.android.dbflow.query.property.IndexProperty +import com.raizlabs.android.dbflow.query.select import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/InsertTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/InsertTest.kt index 17c14fb50..d24bb5faa 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/InsertTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/InsertTest.kt @@ -3,6 +3,7 @@ package com.raizlabs.android.dbflow.sql.language import android.content.ContentValues import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.config.databaseForTable +import com.raizlabs.android.dbflow.database.set import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.TwoColumnModel import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id @@ -12,22 +13,21 @@ import com.raizlabs.android.dbflow.query.Operator import com.raizlabs.android.dbflow.query.OperatorGroup import com.raizlabs.android.dbflow.query.insert import com.raizlabs.android.dbflow.query.select -import com.raizlabs.android.dbflow.database.set import org.junit.Assert.assertEquals import org.junit.Test class InsertTest : BaseUnitTest() { @Test - fun validateInsert(){ - databaseForTable{ + fun validateInsert() { + databaseForTable { assertEquals("INSERT INTO `SimpleModel` VALUES('something')", insert().values("something").query.trim()) } } @Test - fun validateInsertOr(){ + fun validateInsertOr() { databaseForTable { assertEquals("INSERT OR REPLACE INTO `SimpleModel` VALUES('something')", insert().orReplace().values("something").query.trim()) @@ -45,7 +45,7 @@ class InsertTest : BaseUnitTest() { } @Test - fun validateInsertProjection(){ + fun validateInsertProjection() { databaseForTable { assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 'id')", insert().columns(name, id).values("name", "id").query.trim()) @@ -53,7 +53,7 @@ class InsertTest : BaseUnitTest() { } @Test - fun validateSelect(){ + fun validateSelect() { databaseForTable { assertEquals("INSERT INTO `TwoColumnModel` SELECT * FROM `SimpleModel`", insert().select(select from SimpleModel::class).query.trim()) @@ -61,7 +61,7 @@ class InsertTest : BaseUnitTest() { } @Test - fun validateColumns(){ + fun validateColumns() { databaseForTable { assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 'id')", insert().asColumns().values("name", "id").query.trim()) @@ -73,7 +73,7 @@ class InsertTest : BaseUnitTest() { } @Test - fun validateColumnValues(){ + fun validateColumnValues() { databaseForTable { assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 0)", insert().columnValues(name.eq("name"), id.eq(0)).query.trim()) diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/TriggerTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/TriggerTest.kt index 2c41571bf..c8c09d7ab 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/TriggerTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/TriggerTest.kt @@ -15,11 +15,11 @@ import com.raizlabs.android.dbflow.query.columnValues import com.raizlabs.android.dbflow.query.createTrigger import com.raizlabs.android.dbflow.query.insert import com.raizlabs.android.dbflow.query.insertOn +import com.raizlabs.android.dbflow.query.property.property import com.raizlabs.android.dbflow.query.select import com.raizlabs.android.dbflow.query.updateOn import com.raizlabs.android.dbflow.query.where import com.raizlabs.android.dbflow.sql.SQLiteType -import com.raizlabs.android.dbflow.query.property.property import com.raizlabs.android.dbflow.structure.insert import org.junit.Assert.assertNotNull import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UpdateTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UpdateTest.kt index 85b488b82..ef91e8ee7 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UpdateTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UpdateTest.kt @@ -8,9 +8,9 @@ import com.raizlabs.android.dbflow.models.NumberModel import com.raizlabs.android.dbflow.models.NumberModel_Table.id import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.SimpleModel_Table.name +import com.raizlabs.android.dbflow.query.property.Property import com.raizlabs.android.dbflow.query.set import com.raizlabs.android.dbflow.query.update -import com.raizlabs.android.dbflow.query.property.Property import org.junit.Test class UpdateTest : BaseUnitTest() { diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/WhereTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/WhereTest.kt index 419edc757..7a1b0e60f 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/WhereTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/WhereTest.kt @@ -10,13 +10,13 @@ import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id import com.raizlabs.android.dbflow.query.OrderBy.Companion.fromNameAlias import com.raizlabs.android.dbflow.query.groupBy import com.raizlabs.android.dbflow.query.having +import com.raizlabs.android.dbflow.query.list import com.raizlabs.android.dbflow.query.nameAlias import com.raizlabs.android.dbflow.query.or +import com.raizlabs.android.dbflow.query.result import com.raizlabs.android.dbflow.query.select import com.raizlabs.android.dbflow.query.update import com.raizlabs.android.dbflow.query.where -import com.raizlabs.android.dbflow.query.list -import com.raizlabs.android.dbflow.query.result import org.junit.Assert.fail import org.junit.Test diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/IConditional.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/IConditional.kt index 469d52568..ce5bd076a 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/IConditional.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/IConditional.kt @@ -12,61 +12,61 @@ interface IConditional : Query { fun isNotNull(): Operator<*> - fun `is`(conditional: IConditional): Operator<*> + infix fun `is`(conditional: IConditional): Operator<*> - fun `is`(baseModelQueriable: BaseModelQueriable<*>): Operator<*> + infix fun `is`(baseModelQueriable: BaseModelQueriable<*>): Operator<*> - fun eq(conditional: IConditional): Operator<*> + infix fun eq(conditional: IConditional): Operator<*> - fun eq(baseModelQueriable: BaseModelQueriable<*>): Operator<*> + infix fun eq(baseModelQueriable: BaseModelQueriable<*>): Operator<*> - fun concatenate(conditional: IConditional): Operator<*> + infix fun concatenate(conditional: IConditional): Operator<*> - fun isNot(conditional: IConditional): Operator<*> + infix fun isNot(conditional: IConditional): Operator<*> - fun isNot(baseModelQueriable: BaseModelQueriable<*>): Operator<*> + infix fun isNot(baseModelQueriable: BaseModelQueriable<*>): Operator<*> - fun notEq(conditional: IConditional): Operator<*> + infix fun notEq(conditional: IConditional): Operator<*> - fun notEq(baseModelQueriable: BaseModelQueriable<*>): Operator<*> + infix fun notEq(baseModelQueriable: BaseModelQueriable<*>): Operator<*> - fun like(conditional: IConditional): Operator<*> + infix fun like(conditional: IConditional): Operator<*> - fun like(baseModelQueriable: BaseModelQueriable<*>): Operator<*> + infix fun like(baseModelQueriable: BaseModelQueriable<*>): Operator<*> - fun notLike(conditional: IConditional): Operator<*> + infix fun notLike(conditional: IConditional): Operator<*> - fun notLike(baseModelQueriable: BaseModelQueriable<*>): Operator<*> + infix fun notLike(baseModelQueriable: BaseModelQueriable<*>): Operator<*> - fun glob(conditional: IConditional): Operator<*> + infix fun glob(conditional: IConditional): Operator<*> - fun glob(baseModelQueriable: BaseModelQueriable<*>): Operator<*> + infix fun glob(baseModelQueriable: BaseModelQueriable<*>): Operator<*> - fun like(value: String): Operator<*> + infix fun like(value: String): Operator<*> - fun notLike(value: String): Operator<*> + infix fun notLike(value: String): Operator<*> - fun glob(value: String): Operator<*> + infix fun glob(value: String): Operator<*> - fun greaterThan(conditional: IConditional): Operator<*> + infix fun greaterThan(conditional: IConditional): Operator<*> - fun greaterThan(baseModelQueriable: BaseModelQueriable<*>): Operator<*> + infix fun greaterThan(baseModelQueriable: BaseModelQueriable<*>): Operator<*> - fun greaterThanOrEq(conditional: IConditional): Operator<*> + infix fun greaterThanOrEq(conditional: IConditional): Operator<*> - fun greaterThanOrEq(baseModelQueriable: BaseModelQueriable<*>): Operator<*> + infix fun greaterThanOrEq(baseModelQueriable: BaseModelQueriable<*>): Operator<*> - fun lessThan(conditional: IConditional): Operator<*> + infix fun lessThan(conditional: IConditional): Operator<*> - fun lessThan(baseModelQueriable: BaseModelQueriable<*>): Operator<*> + infix fun lessThan(baseModelQueriable: BaseModelQueriable<*>): Operator<*> - fun lessThanOrEq(conditional: IConditional): Operator<*> + infix fun lessThanOrEq(conditional: IConditional): Operator<*> - fun lessThanOrEq(baseModelQueriable: BaseModelQueriable<*>): Operator<*> + infix fun lessThanOrEq(baseModelQueriable: BaseModelQueriable<*>): Operator<*> - fun between(conditional: IConditional): Operator.Between<*> + infix fun between(conditional: IConditional): Operator.Between<*> - fun between(baseModelQueriable: BaseModelQueriable<*>): Operator.Between<*> + infix fun between(baseModelQueriable: BaseModelQueriable<*>): Operator.Between<*> fun `in`(firstConditional: IConditional, vararg conditionals: IConditional): Operator.In<*> @@ -78,43 +78,17 @@ interface IConditional : Query { fun notIn(firstBaseModelQueriable: BaseModelQueriable<*>, vararg baseModelQueriables: BaseModelQueriable<*>): Operator.In<*> - operator fun plus(value: BaseModelQueriable<*>): Operator<*> + infix operator fun plus(value: BaseModelQueriable<*>): Operator<*> - operator fun minus(value: BaseModelQueriable<*>): Operator<*> + infix operator fun minus(value: BaseModelQueriable<*>): Operator<*> - operator fun div(value: BaseModelQueriable<*>): Operator<*> + infix operator fun div(value: BaseModelQueriable<*>): Operator<*> - operator fun times(value: BaseModelQueriable<*>): Operator<*> + infix operator fun times(value: BaseModelQueriable<*>): Operator<*> - operator fun rem(value: BaseModelQueriable<*>): Operator<*> + infix operator fun rem(value: BaseModelQueriable<*>): Operator<*> } -infix fun IConditional.eq(value: IConditional): Operator<*> = this.eq(value) - -infix fun IConditional.`is`(conditional: IConditional): Operator<*> = this.`is`(conditional) - -infix fun IConditional.isNot(conditional: IConditional): Operator<*> = this.isNot(conditional) - -infix fun IConditional.notEq(conditional: IConditional): Operator<*> = this.notEq(conditional) - -infix fun IConditional.like(conditional: IConditional): Operator<*> = this.like(conditional) - -infix fun IConditional.glob(conditional: IConditional): Operator<*> = this.glob(conditional) - -infix fun IConditional.like(value: String): Operator<*> = this.like(value) - -infix fun IConditional.glob(value: String): Operator<*> = this.glob(value) - -infix fun IConditional.greaterThan(conditional: IConditional): Operator<*> = this.greaterThan(conditional) - -infix fun IConditional.greaterThanOrEq(conditional: IConditional): Operator<*> = this.greaterThanOrEq(conditional) - -infix fun IConditional.lessThan(conditional: IConditional): Operator<*> = this.lessThan(conditional) - -infix fun IConditional.lessThanOrEq(conditional: IConditional): Operator<*> = this.lessThanOrEq(conditional) - -infix fun IConditional.between(conditional: IConditional): Operator.Between<*> = this.between(conditional) - infix fun IConditional.`in`(values: Array): Operator.In<*> { return when (values.size) { 1 -> `in`(values[0]) @@ -129,20 +103,6 @@ infix fun IConditional.notIn(values: Array): Operator.In<*> { } } -infix fun IConditional.`is`(baseModelQueriable: BaseModelQueriable): Operator<*> = this.`is`(baseModelQueriable) - -infix fun IConditional.eq(baseModelQueriable: BaseModelQueriable): Operator<*> = this.eq(baseModelQueriable) - -infix fun IConditional.isNot(baseModelQueriable: BaseModelQueriable): Operator<*> = this.isNot(baseModelQueriable) -infix fun IConditional.notEq(baseModelQueriable: BaseModelQueriable): Operator<*> = this.notEq(baseModelQueriable) -infix fun IConditional.like(baseModelQueriable: BaseModelQueriable): Operator<*> = this.like(baseModelQueriable) -infix fun IConditional.glob(baseModelQueriable: BaseModelQueriable): Operator<*> = this.glob(baseModelQueriable) -infix fun IConditional.greaterThan(baseModelQueriable: BaseModelQueriable): Operator<*> = this.greaterThan(baseModelQueriable) -infix fun IConditional.greaterThanOrEq(baseModelQueriable: BaseModelQueriable): Operator<*> = this.greaterThanOrEq(baseModelQueriable) -infix fun IConditional.lessThan(baseModelQueriable: BaseModelQueriable): Operator<*> = this.lessThan(baseModelQueriable) -infix fun IConditional.lessThanOrEq(baseModelQueriable: BaseModelQueriable): Operator<*> = this.lessThanOrEq(baseModelQueriable) -infix fun IConditional.between(baseModelQueriable: BaseModelQueriable): Operator.Between<*> = this.between(baseModelQueriable) - infix fun IConditional.`in`(values: Array>): Operator.In<*> { return when (values.size) { 1 -> `in`(values[0]) @@ -155,7 +115,4 @@ infix fun IConditional.notIn(values: Array>): Op 1 -> notIn(values[0]) else -> this.notIn(values[0], *values.sliceArray(IntRange(1, values.size))) } -} - -infix fun IConditional.concatenate(conditional: IConditional): Operator<*> = this.concatenate(conditional) - +} \ No newline at end of file From 32813f321019c31d6491cba32af47aa9b40ae238 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Mon, 27 Nov 2017 08:16:03 -0500 Subject: [PATCH 093/234] [5.0] FastStoreModelTransaction now uses kotlin fn under the hood and no need for interface. --- .../transaction/FastStoreModelTransaction.kt | 70 ++++++------------- 1 file changed, 22 insertions(+), 48 deletions(-) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/FastStoreModelTransaction.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/FastStoreModelTransaction.kt index 0734df73e..043232959 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/FastStoreModelTransaction.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/FastStoreModelTransaction.kt @@ -1,11 +1,16 @@ package com.raizlabs.android.dbflow.transaction -import com.raizlabs.android.dbflow.config.modelAdapter import com.raizlabs.android.dbflow.adapter.InternalAdapter -import com.raizlabs.android.dbflow.structure.Model +import com.raizlabs.android.dbflow.config.modelAdapter import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.android.dbflow.structure.Model import java.util.* +/** + * Description: Simple interface for acting on a model in a Transaction or list of [Model] + */ +private typealias ProcessModelList = (List, InternalAdapter, DatabaseWrapper) -> Unit + /** * Description: Similiar to [ProcessModelTransaction] in that it allows you to store a [List] of * [Model], except that it performs it as efficiently as possible. Also due to way the class operates, @@ -17,20 +22,6 @@ class FastStoreModelTransaction internal constructor(builder: Builder internal val internalAdapter: InternalAdapter - /** - * Description: Simple interface for acting on a model in a Transaction or list of [Model] - */ - internal interface ProcessModelList { - - /** - * Called when processing models - * - * @param modelList The model list to process - */ - fun processModel(modelList: List, adapter: InternalAdapter, - wrapper: DatabaseWrapper) - } - init { models = builder.models processModelList = builder.processModelList @@ -39,7 +30,7 @@ class FastStoreModelTransaction internal constructor(builder: Builder internal constructor(builder: Builder */ - class Builder internal constructor(internal val processModelList: ProcessModelList, - internal val internalAdapter: InternalAdapter) { + class Builder internal constructor(internal val internalAdapter: InternalAdapter, + internal val processModelList: ProcessModelList) { internal var models: MutableList = ArrayList() fun add(model: TModel) = apply { @@ -83,40 +74,21 @@ class FastStoreModelTransaction internal constructor(builder: Builder saveBuilder(internalAdapter: InternalAdapter): Builder { - return Builder(object : ProcessModelList { - override fun processModel(tModels: List, adapter: InternalAdapter, wrapper: DatabaseWrapper) { - adapter.saveAll(tModels, wrapper) - } - }, internalAdapter) - } + fun saveBuilder(internalAdapter: InternalAdapter): Builder = + Builder(internalAdapter) { tModels, adapter, wrapper -> adapter.saveAll(tModels, wrapper) } @JvmStatic - fun insertBuilder(internalAdapter: InternalAdapter): Builder { - return Builder(object : ProcessModelList { - override fun processModel(tModels: List, adapter: InternalAdapter, wrapper: DatabaseWrapper) { - adapter.insertAll(tModels, wrapper) - } - }, internalAdapter) - } + fun insertBuilder(internalAdapter: InternalAdapter): Builder = + Builder(internalAdapter) { tModels, adapter, wrapper -> adapter.insertAll(tModels, wrapper) } + @JvmStatic - fun updateBuilder(internalAdapter: InternalAdapter): Builder { - return Builder(object : ProcessModelList { - override fun processModel(tModels: List, adapter: InternalAdapter, wrapper: DatabaseWrapper) { - adapter.updateAll(tModels, wrapper) - } - }, internalAdapter) - } + fun updateBuilder(internalAdapter: InternalAdapter): Builder = + Builder(internalAdapter) { tModels, adapter, wrapper -> adapter.updateAll(tModels, wrapper) } @JvmStatic - fun deleteBuilder(internalAdapter: InternalAdapter): Builder { - return Builder(object : ProcessModelList { - override fun processModel(tModels: List, adapter: InternalAdapter, wrapper: DatabaseWrapper) { - adapter.deleteAll(tModels, wrapper) - } - }, internalAdapter) - } + fun deleteBuilder(internalAdapter: InternalAdapter): Builder = + Builder(internalAdapter) { tModels, adapter, wrapper -> adapter.deleteAll(tModels, wrapper) } } } @@ -124,4 +96,6 @@ inline fun Collection.fastSave() = FastStoreModelTransactio inline fun Collection.fastInsert() = FastStoreModelTransaction.insertBuilder(modelAdapter()).addAll(this) -inline fun Collection.fastUpdate() = FastStoreModelTransaction.updateBuilder(modelAdapter()).addAll(this) \ No newline at end of file +inline fun Collection.fastUpdate() = FastStoreModelTransaction.updateBuilder(modelAdapter()).addAll(this) + +inline fun Collection.fastDelete() = FastStoreModelTransaction.deleteBuilder(modelAdapter()).addAll(this) \ No newline at end of file From 9a4927082916208bea974f4a4e0ff58970155a16 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Mon, 27 Nov 2017 09:17:47 -0500 Subject: [PATCH 094/234] [5.0] fast store model transaction now returns the list operated on. Add coroutines for fast operations. --- .../android/dbflow/transaction/Coroutines.kt | 51 +++++++++++++++++++ .../transaction/FastStoreModelTransaction.kt | 5 +- .../transaction/PriorityTransactionWrapper.kt | 2 +- 3 files changed, 55 insertions(+), 3 deletions(-) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/Coroutines.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/Coroutines.kt index d3533334e..d22cb9400 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/Coroutines.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/Coroutines.kt @@ -83,4 +83,55 @@ inline suspend fun M.awaitUpdate(databaseDefinition: DatabaseD inline suspend fun M.awaitLoad(databaseDefinition: DatabaseDefinition) = suspendCancellableCoroutine { continuation -> constructCoroutine(continuation, databaseDefinition) { load(databaseDefinition) } +} + +/** + * Description: Puts the [Collection] inside a [FastStoreModelTransaction] coroutine. + */ +inline suspend fun > M.awaitSave(databaseDefinition: DatabaseDefinition) + = suspendCancellableCoroutine?> { continuation -> + constructFastCoroutine(continuation, databaseDefinition) { fastSave() } +} + +/** + * Description: Puts the [Collection] inside a [FastStoreModelTransaction] coroutine. + */ +inline suspend fun > M.awaitInsert(databaseDefinition: DatabaseDefinition) + = suspendCancellableCoroutine?> { continuation -> + constructFastCoroutine(continuation, databaseDefinition) { fastInsert() } +} + +/** + * Description: Puts the [Collection] inside a [FastStoreModelTransaction] coroutine. + */ +inline suspend fun > M.awaitUpdate(databaseDefinition: DatabaseDefinition) + = suspendCancellableCoroutine?> { continuation -> + constructFastCoroutine(continuation, databaseDefinition) { fastUpdate() } +} + +/** + * Description: Puts the [Collection] inside a [FastStoreModelTransaction] coroutine. + */ +inline suspend fun > M.awaitDelete(databaseDefinition: DatabaseDefinition) + = suspendCancellableCoroutine?> { continuation -> + constructFastCoroutine(continuation, databaseDefinition) { fastDelete() } +} + + +inline fun constructFastCoroutine(continuation: CancellableContinuation?>, + databaseDefinition: DatabaseDefinition, + crossinline fn: () -> FastStoreModelTransaction.Builder) { + val transaction = databaseDefinition.beginTransactionAsync(fn().build()) + .success { _, result -> continuation.resume(result) } + .error { _, throwable -> + if (continuation.isCancelled) return@error + continuation.resumeWithException(throwable) + }.build() + transaction.execute() + + continuation.invokeOnCompletion { + if (continuation.isCancelled) { + transaction.cancel() + } + } } \ No newline at end of file diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/FastStoreModelTransaction.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/FastStoreModelTransaction.kt index 043232959..f0ebb0319 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/FastStoreModelTransaction.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/FastStoreModelTransaction.kt @@ -16,7 +16,7 @@ private typealias ProcessModelList = (List, InternalAdapter internal constructor(builder: Builder) : ITransaction { +class FastStoreModelTransaction internal constructor(builder: Builder) : ITransaction?> { internal val models: List? internal val processModelList: ProcessModelList @@ -28,10 +28,11 @@ class FastStoreModelTransaction internal constructor(builder: Builder? { if (models != null) { processModelList(models, internalAdapter, databaseWrapper) } + return models } /** diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/PriorityTransactionWrapper.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/PriorityTransactionWrapper.kt index 080ea71ec..c63f6d2d9 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/PriorityTransactionWrapper.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/PriorityTransactionWrapper.kt @@ -12,7 +12,7 @@ class PriorityTransactionWrapper(private val priority: Int, private val transact @Retention(AnnotationRetention.SOURCE) @IntDef(PRIORITY_LOW.toLong(), PRIORITY_NORMAL.toLong(), PRIORITY_HIGH.toLong(), PRIORITY_UI.toLong()) - annotation class Priority() + annotation class Priority internal constructor(builder: Builder) : this( priority = if (builder.priority == 0) { From b9793a244f091ea666481f5a1ed3f8252c23744a Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Tue, 28 Nov 2017 08:43:56 -0500 Subject: [PATCH 095/234] [RX] move packages into proper hierarchy. add transaction funs for RX. --- .../CursorResultSubscriber.kt | 2 +- .../{language => query}/RXModelQueriable.kt | 2 +- .../RXModelQueriableImpl.kt | 2 +- .../rx/{language => query}/RXQueriable.kt | 2 +- .../rx/{language => query}/RXQueriableImpl.kt | 2 +- .../dbflow/rx/{language => query}/RXSQLite.kt | 2 +- .../TableChangeListenerEmitter.java | 2 +- .../CursorResultFlowable.kt | 2 +- .../{language => query}/RXModelQueriable.kt | 2 +- .../RXModelQueriableImpl.kt | 2 +- .../rx2/{language => query}/RXQueriable.kt | 2 +- .../{language => query}/RXQueriableImpl.kt | 2 +- .../rx2/{language => query}/RXSQLite.kt | 2 +- .../TableChangeOnSubscribe.kt | 2 +- .../rx2/transaction/TransactionObservable.kt | 27 ++++++++ .../FastStoreModelTransactionTest.kt | 61 +++++++++---------- .../CursorResultSubscriberTest.kt | 2 +- .../rx/{language => query}/RXQueryTests.kt | 2 +- .../dbflow/rx/{language => query}/RxModels.kt | 2 +- .../android/dbflow/transaction/Coroutines.kt | 10 +-- .../transaction/DefaultTransactionManager.kt | 3 +- .../transaction/FastStoreModelTransaction.kt | 10 +-- .../transaction/PriorityTransactionWrapper.kt | 2 +- .../transaction/ProcessModelTransaction.kt | 6 +- 24 files changed, 90 insertions(+), 63 deletions(-) rename dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/{language => query}/CursorResultSubscriber.kt (98%) rename dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/{language => query}/RXModelQueriable.kt (98%) rename dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/{language => query}/RXModelQueriableImpl.kt (97%) rename dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/{language => query}/RXQueriable.kt (97%) rename dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/{language => query}/RXQueriableImpl.kt (96%) rename dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/{language => query}/RXSQLite.kt (89%) rename dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/{language => query}/TableChangeListenerEmitter.java (98%) rename dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/{language => query}/CursorResultFlowable.kt (98%) rename dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/{language => query}/RXModelQueriable.kt (98%) rename dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/{language => query}/RXModelQueriableImpl.kt (97%) rename dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/{language => query}/RXQueriable.kt (97%) rename dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/{language => query}/RXQueriableImpl.kt (96%) rename dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/{language => query}/RXSQLite.kt (85%) rename dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/{language => query}/TableChangeOnSubscribe.kt (97%) create mode 100644 dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/transaction/TransactionObservable.kt rename dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/{language => query}/CursorResultSubscriberTest.kt (94%) rename dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/{language => query}/RXQueryTests.kt (98%) rename dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/{language => query}/RxModels.kt (91%) diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriber.kt b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/query/CursorResultSubscriber.kt similarity index 98% rename from dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriber.kt rename to dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/query/CursorResultSubscriber.kt index 881567d02..51e8dec2a 100644 --- a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriber.kt +++ b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/query/CursorResultSubscriber.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.rx.language +package com.raizlabs.android.dbflow.rx.query import com.raizlabs.android.dbflow.config.FlowLog import com.raizlabs.android.dbflow.query.CursorResult diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXModelQueriable.kt b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/query/RXModelQueriable.kt similarity index 98% rename from dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXModelQueriable.kt rename to dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/query/RXModelQueriable.kt index 349306551..6e3cffcf2 100644 --- a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXModelQueriable.kt +++ b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/query/RXModelQueriable.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.rx.language +package com.raizlabs.android.dbflow.rx.query import com.raizlabs.android.dbflow.query.list.FlowCursorList import com.raizlabs.android.dbflow.query.list.FlowQueryList diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXModelQueriableImpl.kt b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/query/RXModelQueriableImpl.kt similarity index 97% rename from dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXModelQueriableImpl.kt rename to dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/query/RXModelQueriableImpl.kt index 7bf22dcd8..a1941b5ba 100644 --- a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXModelQueriableImpl.kt +++ b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/query/RXModelQueriableImpl.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.rx.language +package com.raizlabs.android.dbflow.rx.query import com.raizlabs.android.dbflow.query.list.FlowCursorList import com.raizlabs.android.dbflow.query.list.FlowQueryList diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXQueriable.kt b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/query/RXQueriable.kt similarity index 97% rename from dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXQueriable.kt rename to dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/query/RXQueriable.kt index 5c3d3a569..7bb96fa6d 100644 --- a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXQueriable.kt +++ b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/query/RXQueriable.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.rx.language +package com.raizlabs.android.dbflow.rx.query import android.database.Cursor import com.raizlabs.android.dbflow.query.Delete diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXQueriableImpl.kt b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/query/RXQueriableImpl.kt similarity index 96% rename from dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXQueriableImpl.kt rename to dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/query/RXQueriableImpl.kt index 9e7e7c131..b01e72a9e 100644 --- a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXQueriableImpl.kt +++ b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/query/RXQueriableImpl.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.rx.language +package com.raizlabs.android.dbflow.rx.query import android.database.Cursor import com.raizlabs.android.dbflow.query.BaseQueriable diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXSQLite.kt b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/query/RXSQLite.kt similarity index 89% rename from dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXSQLite.kt rename to dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/query/RXSQLite.kt index a76c4c962..4610728c4 100644 --- a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/RXSQLite.kt +++ b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/query/RXSQLite.kt @@ -1,6 +1,6 @@ @file:JvmName("RXSQLite") -package com.raizlabs.android.dbflow.rx.language +package com.raizlabs.android.dbflow.rx.query import com.raizlabs.android.dbflow.query.BaseQueriable import com.raizlabs.android.dbflow.query.ModelQueriable diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/TableChangeListenerEmitter.java b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/query/TableChangeListenerEmitter.java similarity index 98% rename from dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/TableChangeListenerEmitter.java rename to dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/query/TableChangeListenerEmitter.java index f7bd2d4e3..a1390b595 100644 --- a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/language/TableChangeListenerEmitter.java +++ b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/query/TableChangeListenerEmitter.java @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.rx.language; +package com.raizlabs.android.dbflow.rx.query; import android.support.annotation.NonNull; import android.support.annotation.Nullable; diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/CursorResultFlowable.kt b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/query/CursorResultFlowable.kt similarity index 98% rename from dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/CursorResultFlowable.kt rename to dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/query/CursorResultFlowable.kt index 1ec060da2..eca4ab8e7 100644 --- a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/CursorResultFlowable.kt +++ b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/query/CursorResultFlowable.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.rx2.language +package com.raizlabs.android.dbflow.rx2.query import com.raizlabs.android.dbflow.config.FlowLog import com.raizlabs.android.dbflow.query.CursorResult diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXModelQueriable.kt b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/query/RXModelQueriable.kt similarity index 98% rename from dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXModelQueriable.kt rename to dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/query/RXModelQueriable.kt index 8d34a7dfa..a4ebc7bcc 100644 --- a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXModelQueriable.kt +++ b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/query/RXModelQueriable.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.rx2.language +package com.raizlabs.android.dbflow.rx2.query import com.raizlabs.android.dbflow.query.list.FlowCursorList import com.raizlabs.android.dbflow.query.list.FlowQueryList diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXModelQueriableImpl.kt b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/query/RXModelQueriableImpl.kt similarity index 97% rename from dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXModelQueriableImpl.kt rename to dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/query/RXModelQueriableImpl.kt index 38c4c70cd..7eec01434 100644 --- a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXModelQueriableImpl.kt +++ b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/query/RXModelQueriableImpl.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.rx2.language +package com.raizlabs.android.dbflow.rx2.query import com.raizlabs.android.dbflow.query.list.FlowCursorList import com.raizlabs.android.dbflow.query.list.FlowQueryList diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXQueriable.kt b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/query/RXQueriable.kt similarity index 97% rename from dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXQueriable.kt rename to dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/query/RXQueriable.kt index 87f18b46c..74992e78c 100644 --- a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXQueriable.kt +++ b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/query/RXQueriable.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.rx2.language +package com.raizlabs.android.dbflow.rx2.query import android.database.Cursor import com.raizlabs.android.dbflow.query.Delete diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXQueriableImpl.kt b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/query/RXQueriableImpl.kt similarity index 96% rename from dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXQueriableImpl.kt rename to dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/query/RXQueriableImpl.kt index c7344626b..d5bef7bb8 100644 --- a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXQueriableImpl.kt +++ b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/query/RXQueriableImpl.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.rx2.language +package com.raizlabs.android.dbflow.rx2.query import android.database.Cursor import com.raizlabs.android.dbflow.query.BaseQueriable diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXSQLite.kt b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/query/RXSQLite.kt similarity index 85% rename from dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXSQLite.kt rename to dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/query/RXSQLite.kt index 128edf8b1..64c706fbf 100644 --- a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/RXSQLite.kt +++ b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/query/RXSQLite.kt @@ -1,6 +1,6 @@ @file:JvmName("RXSQLite") -package com.raizlabs.android.dbflow.rx2.language +package com.raizlabs.android.dbflow.rx2.query import com.raizlabs.android.dbflow.query.ModelQueriable import com.raizlabs.android.dbflow.query.Queriable diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/TableChangeOnSubscribe.kt b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/query/TableChangeOnSubscribe.kt similarity index 97% rename from dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/TableChangeOnSubscribe.kt rename to dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/query/TableChangeOnSubscribe.kt index aca1f85f1..30b6b8289 100644 --- a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/language/TableChangeOnSubscribe.kt +++ b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/query/TableChangeOnSubscribe.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.rx2.language +package com.raizlabs.android.dbflow.rx2.query import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.runtime.OnTableChangedListener diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/transaction/TransactionObservable.kt b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/transaction/TransactionObservable.kt new file mode 100644 index 000000000..1f3430d3e --- /dev/null +++ b/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/transaction/TransactionObservable.kt @@ -0,0 +1,27 @@ +@file:JvmName("RXTransactions") + +package com.raizlabs.android.dbflow.rx2.transaction + +import com.raizlabs.android.dbflow.config.DatabaseDefinition +import com.raizlabs.android.dbflow.transaction.ITransaction +import io.reactivex.Flowable +import io.reactivex.Maybe +import io.reactivex.Observable + +/** + * Description: Returns a [Maybe] that executes the [transaction] when called. + */ +fun DatabaseDefinition.beginMaybe(transaction: ITransaction) = + Maybe.fromCallable { transaction.execute(this) } + +/** + * Description: Returns a [Observable] that executes the [transaction] when called. + */ +fun DatabaseDefinition.beginObservable(transaction: ITransaction) = + Observable.fromCallable { transaction.execute(this) } + +/** + * Description: Returns a [Flowable] that executes the [transaction] when called. + */ +fun DatabaseDefinition.beginFlowable(transaction: ITransaction) = + Flowable.fromCallable { transaction.execute(this) } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/FastStoreModelTransactionTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/FastStoreModelTransactionTest.kt index bc3d71b3d..8b988520a 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/FastStoreModelTransactionTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/FastStoreModelTransactionTest.kt @@ -7,9 +7,10 @@ import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.TwoColumnModel import com.raizlabs.android.dbflow.query.list import com.raizlabs.android.dbflow.query.select -import com.raizlabs.android.dbflow.transaction.fastInsert -import com.raizlabs.android.dbflow.transaction.fastSave -import com.raizlabs.android.dbflow.transaction.fastUpdate +import com.raizlabs.android.dbflow.transaction.awaitInsert +import com.raizlabs.android.dbflow.transaction.awaitSave +import com.raizlabs.android.dbflow.transaction.awaitUpdate +import kotlinx.coroutines.experimental.runBlocking import org.junit.Assert.assertEquals import org.junit.Assert.assertNotEquals import org.junit.Test @@ -19,46 +20,44 @@ class FastStoreModelTransactionTest : BaseUnitTest() { @Test fun testSaveBuilder() { - - database(TestDatabase::class) { - beginTransactionAsync((0..9) - .map { SimpleModel("$it") } - .fastSave().build()) - .execute() - - val list = (writableDatabase.select from SimpleModel::class).list - assertEquals(10, list.size) + runBlocking { + database(TestDatabase::class) { + val result = (0..9) + .map { SimpleModel("$it") }.awaitSave(this) + val list = (writableDatabase.select from SimpleModel::class).list + assertEquals(10, list.size) + assertEquals(10L, result) + } } } @Test fun testInsertBuilder() { - database(TestDatabase::class) { - beginTransactionAsync((0..9) - .map { SimpleModel("$it") } - .fastInsert().build()) - .execute() - - val list = (writableDatabase.select from SimpleModel::class).list - assertEquals(10, list.size) + runBlocking { + database(TestDatabase::class) { + val result = (0..9) + .map { SimpleModel("$it") }.awaitInsert(this) + val list = (writableDatabase.select from SimpleModel::class).list + assertEquals(10, list.size) + assertEquals(10L, result) + } } } @Test fun testUpdateBuilder() { - database(TestDatabase::class) { - val oldList = (0..9).map { TwoColumnModel("$it", Random().nextInt()) } - beginTransactionAsync(oldList.fastInsert().build()) - .execute() + runBlocking { + database(TestDatabase::class) { + val oldList = (0..9).map { TwoColumnModel("$it", Random().nextInt()) } + oldList.awaitInsert(this) - beginTransactionAsync((0..9).map { TwoColumnModel("$it", Random().nextInt()) } - .fastUpdate().build()) - .execute() + (0..9).map { TwoColumnModel("$it", Random().nextInt()) }.awaitUpdate(this) - val list = (writableDatabase.select from TwoColumnModel::class).list - assertEquals(10, list.size) - list.forEachIndexed { index, model -> - assertNotEquals(model, oldList[index]) + val list = (writableDatabase.select from TwoColumnModel::class).list + assertEquals(10, list.size) + list.forEachIndexed { index, model -> + assertNotEquals(model, oldList[index]) + } } } } diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriberTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/query/CursorResultSubscriberTest.kt similarity index 94% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriberTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/query/CursorResultSubscriberTest.kt index 4ff2599c2..cc3468e5d 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/CursorResultSubscriberTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/query/CursorResultSubscriberTest.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.rx.language +package com.raizlabs.android.dbflow.rx.query import com.raizlabs.android.dbflow.BaseUnitTest import com.raizlabs.android.dbflow.config.databaseForTable diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/RXQueryTests.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/query/RXQueryTests.kt similarity index 98% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/RXQueryTests.kt rename to dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/query/RXQueryTests.kt index d331422f7..3b6fec85d 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/RXQueryTests.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/query/RXQueryTests.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.rx.language +package com.raizlabs.android.dbflow.rx.query import android.database.Cursor import com.raizlabs.android.dbflow.BaseUnitTest diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/RxModels.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/query/RxModels.kt similarity index 91% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/RxModels.kt rename to dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/query/RxModels.kt index e2ea6dfe6..749fc80cf 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/language/RxModels.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/query/RxModels.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.rx.language +package com.raizlabs.android.dbflow.rx.query import com.raizlabs.android.dbflow.TestDatabase import com.raizlabs.android.dbflow.annotation.PrimaryKey diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/Coroutines.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/Coroutines.kt index d22cb9400..ba8ce0ca6 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/Coroutines.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/Coroutines.kt @@ -89,7 +89,7 @@ inline suspend fun M.awaitLoad(databaseDefinition: DatabaseDef * Description: Puts the [Collection] inside a [FastStoreModelTransaction] coroutine. */ inline suspend fun > M.awaitSave(databaseDefinition: DatabaseDefinition) - = suspendCancellableCoroutine?> { continuation -> + = suspendCancellableCoroutine { continuation -> constructFastCoroutine(continuation, databaseDefinition) { fastSave() } } @@ -97,7 +97,7 @@ inline suspend fun > M.awaitSave(data * Description: Puts the [Collection] inside a [FastStoreModelTransaction] coroutine. */ inline suspend fun > M.awaitInsert(databaseDefinition: DatabaseDefinition) - = suspendCancellableCoroutine?> { continuation -> + = suspendCancellableCoroutine { continuation -> constructFastCoroutine(continuation, databaseDefinition) { fastInsert() } } @@ -105,7 +105,7 @@ inline suspend fun > M.awaitInsert(da * Description: Puts the [Collection] inside a [FastStoreModelTransaction] coroutine. */ inline suspend fun > M.awaitUpdate(databaseDefinition: DatabaseDefinition) - = suspendCancellableCoroutine?> { continuation -> + = suspendCancellableCoroutine { continuation -> constructFastCoroutine(continuation, databaseDefinition) { fastUpdate() } } @@ -113,12 +113,12 @@ inline suspend fun > M.awaitUpdate(da * Description: Puts the [Collection] inside a [FastStoreModelTransaction] coroutine. */ inline suspend fun > M.awaitDelete(databaseDefinition: DatabaseDefinition) - = suspendCancellableCoroutine?> { continuation -> + = suspendCancellableCoroutine { continuation -> constructFastCoroutine(continuation, databaseDefinition) { fastDelete() } } -inline fun constructFastCoroutine(continuation: CancellableContinuation?>, +inline fun constructFastCoroutine(continuation: CancellableContinuation, databaseDefinition: DatabaseDefinition, crossinline fn: () -> FastStoreModelTransaction.Builder) { val transaction = databaseDefinition.beginTransactionAsync(fn().build()) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/DefaultTransactionManager.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/DefaultTransactionManager.kt index 0d7f90354..00f22268b 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/DefaultTransactionManager.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/DefaultTransactionManager.kt @@ -3,8 +3,7 @@ package com.raizlabs.android.dbflow.transaction import com.raizlabs.android.dbflow.config.DatabaseDefinition /** - * Description: This class manages batch database interactions. It is useful for retrieving, updating, saving, - * and deleting lists of items. The bulk of DB operations should exist in this class. + * Description: This class manages batch database interactions. Places DB operations onto the same Thread. */ class DefaultTransactionManager : BaseTransactionManager { diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/FastStoreModelTransaction.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/FastStoreModelTransaction.kt index f0ebb0319..996158157 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/FastStoreModelTransaction.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/FastStoreModelTransaction.kt @@ -9,14 +9,14 @@ import java.util.* /** * Description: Simple interface for acting on a model in a Transaction or list of [Model] */ -private typealias ProcessModelList = (List, InternalAdapter, DatabaseWrapper) -> Unit +private typealias ProcessModelList = (List, InternalAdapter, DatabaseWrapper) -> Long /** * Description: Similiar to [ProcessModelTransaction] in that it allows you to store a [List] of * [Model], except that it performs it as efficiently as possible. Also due to way the class operates, * only one kind of [TModel] is allowed. */ -class FastStoreModelTransaction internal constructor(builder: Builder) : ITransaction?> { +class FastStoreModelTransaction internal constructor(builder: Builder) : ITransaction { internal val models: List? internal val processModelList: ProcessModelList @@ -28,11 +28,11 @@ class FastStoreModelTransaction internal constructor(builder: Builder? { + override fun execute(databaseWrapper: DatabaseWrapper): Long { if (models != null) { - processModelList(models, internalAdapter, databaseWrapper) + return processModelList(models, internalAdapter, databaseWrapper) } - return models + return 0L } /** diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/PriorityTransactionWrapper.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/PriorityTransactionWrapper.kt index c63f6d2d9..080ea71ec 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/PriorityTransactionWrapper.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/PriorityTransactionWrapper.kt @@ -12,7 +12,7 @@ class PriorityTransactionWrapper(private val priority: Int, private val transact @Retention(AnnotationRetention.SOURCE) @IntDef(PRIORITY_LOW.toLong(), PRIORITY_NORMAL.toLong(), PRIORITY_HIGH.toLong(), PRIORITY_UI.toLong()) - annotation class Priority + annotation class Priority() internal constructor(builder: Builder) : this( priority = if (builder.priority == 0) { diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/ProcessModelTransaction.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/ProcessModelTransaction.kt index b5778aa60..51a045041 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/ProcessModelTransaction.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/ProcessModelTransaction.kt @@ -1,8 +1,10 @@ package com.raizlabs.android.dbflow.transaction import com.raizlabs.android.dbflow.config.databaseForTable -import com.raizlabs.android.dbflow.structure.Model import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.android.dbflow.structure.Model + +typealias ProcessFunction = (T, DatabaseWrapper) -> Unit /** * Description: Allows you to process a single or [List] of models in a transaction. You @@ -145,11 +147,11 @@ class ProcessModelTransaction( } -typealias ProcessFunction = (T, DatabaseWrapper) -> Unit /** * Enables a collection of T objects to easily operate on them within a synchronous database transaction. */ +@Deprecated(message = "Use the coroutines awaitSave, awaitInsert, awaitDelete, awaitUpdate") inline fun Collection.processInTransaction( crossinline processFunction: ProcessFunction) { databaseForTable().executeTransaction { db -> forEach { processFunction(it, db) } } From 940c0509553d68d27b64f9c2457ba02f1a8b9943 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Tue, 28 Nov 2017 16:43:36 -0500 Subject: [PATCH 096/234] [RX] add rx1 transaction extensions. --- .../rx/transaction/TransactionObservable.kt | 20 +++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/transaction/TransactionObservable.kt diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/transaction/TransactionObservable.kt b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/transaction/TransactionObservable.kt new file mode 100644 index 000000000..0a4d38443 --- /dev/null +++ b/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/transaction/TransactionObservable.kt @@ -0,0 +1,20 @@ +@file:JvmName("RXTransactions") + +package com.raizlabs.android.dbflow.rx.transaction + +import com.raizlabs.android.dbflow.config.DatabaseDefinition +import com.raizlabs.android.dbflow.transaction.ITransaction +import rx.Observable +import rx.Single + +/** + * Description: Returns a [Maybe] that executes the [transaction] when called. + */ +fun DatabaseDefinition.beginSingle(transaction: ITransaction) = + Single.fromCallable { transaction.execute(this) } + +/** + * Description: Returns a [Observable] that executes the [transaction] when called. + */ +fun DatabaseDefinition.beginObservable(transaction: ITransaction) = + Observable.fromCallable { transaction.execute(this) } From 0a2b5e8a313ef1ea0d8171b500a349d938988114 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Tue, 28 Nov 2017 17:04:37 -0500 Subject: [PATCH 097/234] [processor] add method for more consolidated handling of annotations. --- .../processor/definition/ContentProvider.kt | 4 +-- .../definition/ManyToManyDefinition.kt | 22 +++++++++------- .../definition/ModelViewDefinition.kt | 1 - .../definition/QueryModelDefinition.kt | 22 +++++----------- .../definition/TableEndpointDefinition.kt | 13 ++-------- .../dbflow/processor/utils/ProcessorUtils.kt | 25 +++++++++++++++++++ 6 files changed, 47 insertions(+), 40 deletions(-) diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/ContentProvider.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/ContentProvider.kt index bb44f81d3..66c0cca72 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/ContentProvider.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/ContentProvider.kt @@ -375,9 +375,7 @@ class ContentProviderDefinition(typeElement: Element, processorManager: Processo UpdateMethod(this, manager)) init { - - val provider = element.annotation() - if (provider != null) { + element.annotation()?.let { provider -> try { provider.database } catch (mte: MirroredTypeException) { diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/ManyToManyDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/ManyToManyDefinition.kt index 256c1d112..1fc4ab1e1 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/ManyToManyDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/ManyToManyDefinition.kt @@ -1,6 +1,16 @@ package com.raizlabs.android.dbflow.processor.definition -import com.grosner.kpoet.* +import com.grosner.kpoet.L +import com.grosner.kpoet.`@` +import com.grosner.kpoet.`fun` +import com.grosner.kpoet.`return` +import com.grosner.kpoet.field +import com.grosner.kpoet.final +import com.grosner.kpoet.member +import com.grosner.kpoet.modifiers +import com.grosner.kpoet.param +import com.grosner.kpoet.public +import com.grosner.kpoet.statement import com.raizlabs.android.dbflow.annotation.ForeignKey import com.raizlabs.android.dbflow.annotation.ManyToMany import com.raizlabs.android.dbflow.annotation.PrimaryKey @@ -8,6 +18,7 @@ import com.raizlabs.android.dbflow.annotation.Table import com.raizlabs.android.dbflow.processor.ClassNames import com.raizlabs.android.dbflow.processor.ProcessorManager import com.raizlabs.android.dbflow.processor.utils.annotation +import com.raizlabs.android.dbflow.processor.utils.extractTypeNameFromAnnotation import com.raizlabs.android.dbflow.processor.utils.isNullOrEmpty import com.raizlabs.android.dbflow.processor.utils.lower import com.raizlabs.android.dbflow.processor.utils.toTypeElement @@ -48,14 +59,7 @@ class ManyToManyDefinition(element: TypeElement, processorManager: ProcessorMana sameTableReferenced = referencedTable == elementTypeName - element.annotation()?.let { table -> - try { - table.database - } catch (mte: MirroredTypeException) { - databaseTypeName = TypeName.get(mte.typeMirror) - } - } - + databaseTypeName = element.extractTypeNameFromAnnotation
{ it.database } if (!thisColumnName.isNullOrEmpty() && !referencedColumnName.isNullOrEmpty() && thisColumnName == referencedColumnName) { manager.logError(ManyToManyDefinition::class, "The thisTableColumnName and referenceTableColumnName cannot be the same") diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/ModelViewDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/ModelViewDefinition.kt index dbd44ec79..00f16d261 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/ModelViewDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/ModelViewDefinition.kt @@ -54,7 +54,6 @@ class ModelViewDefinition(manager: ProcessorManager, element: Element) : BaseTab var priority: Int = 0 init { - element.annotation()?.let { modelView -> try { modelView.database diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/QueryModelDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/QueryModelDefinition.kt index fee449d55..955c9b60d 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/QueryModelDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/QueryModelDefinition.kt @@ -15,6 +15,7 @@ import com.raizlabs.android.dbflow.processor.definition.column.ReferenceColumnDe import com.raizlabs.android.dbflow.processor.utils.ElementUtility import com.raizlabs.android.dbflow.processor.utils.`override fun` import com.raizlabs.android.dbflow.processor.utils.annotation +import com.raizlabs.android.dbflow.processor.utils.extractTypeNameFromAnnotation import com.raizlabs.android.dbflow.processor.utils.implementsClass import com.squareup.javapoet.ParameterizedTypeName import com.squareup.javapoet.TypeName @@ -22,7 +23,6 @@ import com.squareup.javapoet.TypeSpec import java.util.* import javax.lang.model.element.Element import javax.lang.model.element.TypeElement -import javax.lang.model.type.MirroredTypeException /** * Description: @@ -37,24 +37,14 @@ class QueryModelDefinition(typeElement: Element, processorManager: ProcessorMana internal var methods: Array init { - - typeElement.annotation()?.let { queryModel -> - try { - queryModel.database - } catch (mte: MirroredTypeException) { - databaseTypeName = TypeName.get(mte.typeMirror) - } - } + databaseTypeName = typeElement.extractTypeNameFromAnnotation { it.database } elementClassName?.let { elementClassName -> databaseTypeName?.let { processorManager.addModelToDatabase(elementClassName, it) } } - if (element is TypeElement) { - implementsLoadFromCursorListener = - (element as TypeElement).implementsClass(manager.processingEnvironment, ClassNames.LOAD_FROM_CURSOR_LISTENER) - } - + implementsLoadFromCursorListener = (element as? TypeElement) + ?.implementsClass(manager.processingEnvironment, ClassNames.LOAD_FROM_CURSOR_LISTENER) == true - methods = arrayOf(LoadFromCursorMethod(this)) + methods = arrayOf(LoadFromCursorMethod(this)) } @@ -94,7 +84,7 @@ class QueryModelDefinition(typeElement: Element, processorManager: ProcessorMana } methods.mapNotNull { it.methodSpec } - .forEach { typeBuilder.addMethod(it) } + .forEach { typeBuilder.addMethod(it) } } override fun createColumnDefinitions(typeElement: TypeElement) { diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/TableEndpointDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/TableEndpointDefinition.kt index 901146204..a2e852cfe 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/TableEndpointDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/TableEndpointDefinition.kt @@ -6,11 +6,11 @@ import com.raizlabs.android.dbflow.annotation.provider.NotifyMethod import com.raizlabs.android.dbflow.annotation.provider.TableEndpoint import com.raizlabs.android.dbflow.processor.ProcessorManager import com.raizlabs.android.dbflow.processor.utils.annotation +import com.raizlabs.android.dbflow.processor.utils.extractTypeNameFromAnnotation import com.squareup.javapoet.TypeName import javax.lang.model.element.Element import javax.lang.model.element.PackageElement import javax.lang.model.element.TypeElement -import javax.lang.model.type.MirroredTypeException /** * Description: @@ -35,16 +35,7 @@ class TableEndpointDefinition(typeElement: Element, processorManager: ProcessorM var isTopLevel = false init { - - typeElement.annotation()?.let { endpoint -> - tableName = endpoint.name - - try { - endpoint.contentProvider - } catch (mte: MirroredTypeException) { - contentProviderName = TypeName.get(mte.typeMirror) - } - } + contentProviderName = typeElement.extractTypeNameFromAnnotation { it.contentProvider } isTopLevel = typeElement.enclosingElement is PackageElement diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/utils/ProcessorUtils.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/utils/ProcessorUtils.kt index b1832ccb9..9fdaf0527 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/utils/ProcessorUtils.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/utils/ProcessorUtils.kt @@ -3,10 +3,12 @@ package com.raizlabs.android.dbflow.processor.utils import com.raizlabs.android.dbflow.processor.ProcessorManager import com.raizlabs.android.dbflow.processor.ProcessorManager.Companion.manager import com.squareup.javapoet.ClassName +import com.squareup.javapoet.TypeName import javax.annotation.processing.ProcessingEnvironment import javax.lang.model.element.Element import javax.lang.model.element.Modifier import javax.lang.model.element.TypeElement +import javax.lang.model.type.MirroredTypeException import javax.lang.model.type.TypeMirror import javax.tools.Diagnostic @@ -109,3 +111,26 @@ fun ensureVisibleStatic(element: Element, typeElement: TypeElement, } } +inline fun + Element.extractTypeNameFromAnnotation(invoker: (A) -> Unit): TypeName? + = annotation()?.let { a -> + return@let try { + invoker(a) + null + } catch (mte: MirroredTypeException) { + TypeName.get(mte.typeMirror) + } +} + +inline fun + Element.extractTypeNameFromAnnotation(invoker: (A) -> Unit, + exceptionHandler: (MirroredTypeException) -> Unit): TypeName? + = annotation()?.let { a -> + return@let try { + invoker(a) + null + } catch (mte: MirroredTypeException) { + exceptionHandler(mte) + TypeName.get(mte.typeMirror) + } +} \ No newline at end of file From 18f6ff5bcb232d1a827b9fb8b08870823be036dd Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Tue, 28 Nov 2017 17:43:18 -0500 Subject: [PATCH 098/234] [processor] apply kotlin stdlib consolidations. add inline method for modelcache operations so we dont repeat logic in them everywhere. --- .../dbflow/processor/ProcessorManager.kt | 85 +++++++------------ .../definition/BaseTableDefinition.kt | 30 +++---- .../processor/definition/NotifyDefinition.kt | 32 +++---- .../processor/definition/TableDefinition.kt | 4 +- .../definition/TableEndpointDefinition.kt | 19 ++--- .../dbflow/processor/utils/ProcessorUtils.kt | 6 +- .../queriable/CacheableListModelLoader.kt | 18 ++-- .../adapter/queriable/CacheableModelLoader.kt | 43 +++++----- .../adapter/queriable/ListModelLoader.kt | 21 ++--- .../SingleKeyCacheableListModelLoader.kt | 10 +-- .../SingleKeyCacheableModelLoader.kt | 21 ++--- .../android/dbflow/query/cache/ModelCache.kt | 21 +++++ 12 files changed, 123 insertions(+), 187 deletions(-) diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/ProcessorManager.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/ProcessorManager.kt index 4f93685e6..c4e2242b8 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/ProcessorManager.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/ProcessorManager.kt @@ -92,7 +92,7 @@ class ProcessorManager internal constructor(val processingEnvironment: Processin fun addQueryModelDefinition(queryModelDefinition: QueryModelDefinition) { queryModelDefinition.elementClassName?.let { getOrPutDatabase(queryModelDefinition.databaseTypeName)?. - queryModelDefinitionMap?.put(it, queryModelDefinition) + queryModelDefinitionMap?.put(it, queryModelDefinition) } } @@ -103,7 +103,7 @@ class ProcessorManager internal constructor(val processingEnvironment: Processin holderDefinition?.tableNameMap?.let { if (holderDefinition.tableNameMap.containsKey(tableDefinition.tableName)) { logError("Found duplicate table ${tableDefinition.tableName} " + - "for database ${holderDefinition.databaseDefinition?.databaseClassName}") + "for database ${holderDefinition.databaseDefinition?.databaseClassName}") } else tableDefinition.tableName?.let { holderDefinition.tableNameMap.put(it, tableDefinition) } @@ -114,15 +114,9 @@ class ProcessorManager internal constructor(val processingEnvironment: Processin fun addManyToManyDefinition(manyToManyDefinition: ManyToManyDefinition) { val databaseHolderDefinition = getOrPutDatabase(manyToManyDefinition.databaseTypeName) databaseHolderDefinition?.manyToManyDefinitionMap?.let { - manyToManyDefinition.elementClassName?.let { elementClassName -> - var manyToManyDefinitions: MutableList? = it[elementClassName] - if (manyToManyDefinitions == null) { - manyToManyDefinitions = ArrayList() - it.put(elementClassName, manyToManyDefinitions) - } - - manyToManyDefinitions.add(manyToManyDefinition) + it.getOrPut(elementClassName) { arrayListOf() } + .add(manyToManyDefinition) } } } @@ -141,14 +135,14 @@ class ProcessorManager internal constructor(val processingEnvironment: Processin fun getReferenceDefinition(databaseName: TypeName?, typeName: TypeName?): BaseTableDefinition? { return getTableDefinition(databaseName, typeName) - ?: getQueryModelDefinition(databaseName, typeName) - ?: getModelViewDefinition(databaseName, typeName) + ?: getQueryModelDefinition(databaseName, typeName) + ?: getModelViewDefinition(databaseName, typeName) } fun addModelViewDefinition(modelViewDefinition: ModelViewDefinition) { modelViewDefinition.elementClassName?.let { getOrPutDatabase(modelViewDefinition.databaseTypeName)?. - modelViewDefinitionMap?.put(it, modelViewDefinition) + modelViewDefinitionMap?.put(it, modelViewDefinition) } } @@ -157,8 +151,8 @@ class ProcessorManager internal constructor(val processingEnvironment: Processin fun getTableDefinitions(databaseName: TypeName): List { val databaseHolderDefinition = getOrPutDatabase(databaseName) return (databaseHolderDefinition?.tableDefinitionMap?.values ?: arrayListOf()) - .toHashSet() - .sortedBy { it.outputClassName?.simpleName() } + .toHashSet() + .sortedBy { it.outputClassName?.simpleName() } } fun setTableDefinitions(tableDefinitionSet: MutableMap, databaseName: TypeName) { @@ -169,9 +163,9 @@ class ProcessorManager internal constructor(val processingEnvironment: Processin fun getModelViewDefinitions(databaseName: TypeName): List { val databaseDefinition = getOrPutDatabase(databaseName) return (databaseDefinition?.modelViewDefinitionMap?.values ?: arrayListOf()) - .toHashSet() - .sortedBy { it.outputClassName?.simpleName() } - .sortedByDescending { it.priority } + .toHashSet() + .sortedBy { it.outputClassName?.simpleName() } + .sortedByDescending { it.priority } } fun setModelViewDefinitions(modelViewDefinitionMap: MutableMap, elementClassName: ClassName) { @@ -182,23 +176,13 @@ class ProcessorManager internal constructor(val processingEnvironment: Processin fun getQueryModelDefinitions(databaseName: TypeName): List { val databaseDefinition = getOrPutDatabase(databaseName) return (databaseDefinition?.queryModelDefinitionMap?.values ?: arrayListOf()) - .toHashSet() - .sortedBy { it.outputClassName?.simpleName() } + .toHashSet() + .sortedBy { it.outputClassName?.simpleName() } } fun addMigrationDefinition(migrationDefinition: MigrationDefinition) { - var migrationDefinitionMap: MutableMap>? = migrations[migrationDefinition.databaseName] - if (migrationDefinitionMap == null) { - migrationDefinitionMap = hashMapOf() - migrations.put(migrationDefinition.databaseName, migrationDefinitionMap) - } - - var migrationDefinitions: MutableList? = migrationDefinitionMap[migrationDefinition.version] - if (migrationDefinitions == null) { - migrationDefinitions = arrayListOf() - migrationDefinitionMap.put(migrationDefinition.version, migrationDefinitions) - } - + val migrationDefinitionMap = migrations.getOrPut(migrationDefinition.databaseName) { hashMapOf() } + val migrationDefinitions = migrationDefinitionMap.getOrPut(migrationDefinition.version) { arrayListOf() } if (!migrationDefinitions.contains(migrationDefinition)) { migrationDefinitions.add(migrationDefinition) } @@ -218,7 +202,7 @@ class ProcessorManager internal constructor(val processingEnvironment: Processin val contentProviderDefinition = providerMap[tableEndpointDefinition.contentProviderName] if (contentProviderDefinition == null) { logError("Content Provider %1s was not found for the @TableEndpoint %1s", - tableEndpointDefinition.contentProviderName, tableEndpointDefinition.elementClassName) + tableEndpointDefinition.contentProviderName, tableEndpointDefinition.elementClassName) } else { contentProviderDefinition.endpointDefinitions.add(tableEndpointDefinition) } @@ -243,20 +227,14 @@ class ProcessorManager internal constructor(val processingEnvironment: Processin logWarning("$callingClass : $error", *args) } - private fun getOrPutDatabase(databaseName: TypeName?): DatabaseObjectHolder? { - var objectHolder: DatabaseObjectHolder? = databaseDefinitionMap[databaseName] - if (objectHolder == null) { - objectHolder = DatabaseObjectHolder() - databaseDefinitionMap.put(databaseName, objectHolder) - } - return objectHolder - } + private fun getOrPutDatabase(databaseName: TypeName?): DatabaseObjectHolder? = + databaseDefinitionMap.getOrPut(databaseName) { DatabaseObjectHolder() } override fun handle(processorManager: ProcessorManager, roundEnvironment: RoundEnvironment) { handlers.forEach { it.handle(processorManager, roundEnvironment) } val databaseDefinitions = getDatabaseHolderDefinitionList() - .sortedBy { it.databaseDefinition?.outputClassName?.simpleName() } + .sortedBy { it.databaseDefinition?.outputClassName?.simpleName() } for (databaseHolderDefinition in databaseDefinitions) { try { @@ -282,7 +260,7 @@ class ProcessorManager internal constructor(val processingEnvironment: Processin if (roundEnvironment.processingOver()) { val validator = ContentProviderValidator() val contentProviderDefinitions = databaseHolderDefinition.providerMap.values - .sortedBy { it.outputClassName?.simpleName() } + .sortedBy { it.outputClassName?.simpleName() } contentProviderDefinitions.forEach { contentProviderDefinition -> contentProviderDefinition.prepareForWrite() if (validator.validate(processorManager, contentProviderDefinition)) { @@ -297,24 +275,23 @@ class ProcessorManager internal constructor(val processingEnvironment: Processin databaseHolderDefinition.databaseDefinition?.let { if (it.outputClassName != null) { JavaFile.builder(it.packageName, it.typeSpec).build() - .writeTo(processorManager.processingEnvironment.filer) + .writeTo(processorManager.processingEnvironment.filer) } } } - val tableDefinitions = databaseHolderDefinition.tableDefinitionMap.values - .sortedBy { it.outputClassName?.simpleName() } + .sortedBy { it.outputClassName?.simpleName() } tableDefinitions.forEach { WriterUtils.writeBaseDefinition(it, processorManager) } val modelViewDefinitions = databaseHolderDefinition.modelViewDefinitionMap.values modelViewDefinitions - .sortedByDescending { it.priority } - .forEach { WriterUtils.writeBaseDefinition(it, processorManager) } + .sortedByDescending { it.priority } + .forEach { WriterUtils.writeBaseDefinition(it, processorManager) } val queryModelDefinitions = databaseHolderDefinition.queryModelDefinitionMap.values - .sortedBy { it.outputClassName?.simpleName() } + .sortedBy { it.outputClassName?.simpleName() } queryModelDefinitions.forEach { WriterUtils.writeBaseDefinition(it, processorManager) } tableDefinitions.forEach { @@ -346,8 +323,8 @@ class ProcessorManager internal constructor(val processingEnvironment: Processin val databaseHolderDefinition = DatabaseHolderDefinition(processorManager) if (!databaseHolderDefinition.isGarbage()) { JavaFile.builder(ClassNames.FLOW_MANAGER_PACKAGE, - databaseHolderDefinition.typeSpec).build() - .writeTo(processorManager.processingEnvironment.filer) + databaseHolderDefinition.typeSpec).build() + .writeTo(processorManager.processingEnvironment.filer) } } catch (e: FilerException) { } catch (e: IOException) { @@ -358,17 +335,17 @@ class ProcessorManager internal constructor(val processingEnvironment: Processin fun elementBelongsInTable(element: Element): Boolean { val enclosingElement = element.enclosingElement var find: BaseTableDefinition? = databaseDefinitionMap.values.flatMap { it.tableDefinitionMap.values } - .find { it.element == enclosingElement } + .find { it.element == enclosingElement } // modelview check. if (find == null) { find = databaseDefinitionMap.values.flatMap { it.modelViewDefinitionMap.values } - .find { it.element == enclosingElement } + .find { it.element == enclosingElement } } // querymodel check if (find == null) { find = databaseDefinitionMap.values.flatMap { it.queryModelDefinitionMap.values } - .find { it.element == enclosingElement } + .find { it.element == enclosingElement } } return find != null } diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/BaseTableDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/BaseTableDefinition.kt index 0eb923527..1a28ba36f 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/BaseTableDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/BaseTableDefinition.kt @@ -77,25 +77,15 @@ abstract class BaseTableDefinition(typeElement: Element, processorManager: Proce get() = elementClassName fun addColumnForCustomTypeConverter(columnDefinition: ColumnDefinition, typeConverterName: ClassName): String { - var columnDefinitions: MutableList? = associatedTypeConverters[typeConverterName] - if (columnDefinitions == null) { - columnDefinitions = ArrayList() - associatedTypeConverters.put(typeConverterName, columnDefinitions) - } + val columnDefinitions = associatedTypeConverters.getOrPut(typeConverterName) { arrayListOf() } columnDefinitions.add(columnDefinition) - - return "typeConverter" + typeConverterName.simpleName() + return "typeConverter${typeConverterName.simpleName()}" } fun addColumnForTypeConverter(columnDefinition: ColumnDefinition, typeConverterName: ClassName): String { - var columnDefinitions: MutableList? = globalTypeConverters[typeConverterName] - if (columnDefinitions == null) { - columnDefinitions = ArrayList() - globalTypeConverters.put(typeConverterName, columnDefinitions) - } + val columnDefinitions = globalTypeConverters.getOrPut(typeConverterName) { arrayListOf() } columnDefinitions.add(columnDefinition) - - return "global_typeConverter" + typeConverterName.simpleName() + return "global_typeConverter${typeConverterName.simpleName()}" } fun writeConstructor(typeBuilder: TypeSpec.Builder) { @@ -131,7 +121,7 @@ abstract class BaseTableDefinition(typeElement: Element, processorManager: Proce if (!packagePrivateList.isEmpty()) { val classSeparator = databaseDefinition?.classSeparator val typeBuilder = TypeSpec.classBuilder("${elementClassName?.simpleName()}${classSeparator}Helper") - .addModifiers(Modifier.PUBLIC, Modifier.FINAL) + .addModifiers(Modifier.PUBLIC, Modifier.FINAL) for (columnDefinition in packagePrivateList) { var helperClassName = "${columnDefinition.element.getPackage()}.${columnDefinition.element.enclosingElement.toClassName()?.simpleName()}${classSeparator}Helper" @@ -149,7 +139,7 @@ abstract class BaseTableDefinition(typeElement: Element, processorManager: Proce val methodName = columnDefinition.columnName.capitalize() `public static final`(columnDefinition.elementTypeName!!, "get$methodName", - param(elementTypeName!!, ModelUtils.variable)) { + param(elementTypeName!!, ModelUtils.variable)) { if (samePackage) { `return`("${ModelUtils.variable}.${columnDefinition.elementName}") } else { @@ -158,8 +148,8 @@ abstract class BaseTableDefinition(typeElement: Element, processorManager: Proce } `public static final`(TypeName.VOID, "set$methodName", - param(elementTypeName!!, ModelUtils.variable), - param(columnDefinition.elementTypeName!!, "var")) { + param(elementTypeName!!, ModelUtils.variable), + param(columnDefinition.elementTypeName!!, "var")) { if (samePackage) { statement("${ModelUtils.variable}.${columnDefinition.elementName} = var") } else { @@ -185,8 +175,8 @@ abstract class BaseTableDefinition(typeElement: Element, processorManager: Proce internal fun checkInheritancePackagePrivate(isPackagePrivateNotInSamePackage: Boolean, element: Element): Boolean { if (isPackagePrivateNotInSamePackage && !manager.elementBelongsInTable(element)) { manager.logError("Package private inheritance on non-table/querymodel/view " + - "is not supported without a @InheritedColumn annotation." + - " Make $element from ${element.enclosingElement} public or private.") + "is not supported without a @InheritedColumn annotation." + + " Make $element from ${element.enclosingElement} public or private.") return true } return false diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/NotifyDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/NotifyDefinition.kt index 46c2f83d9..97845d878 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/NotifyDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/NotifyDefinition.kt @@ -45,32 +45,24 @@ class NotifyDefinition(typeElement: Element, processorManager: ProcessorManager) val paramType = param.asType() val typeAsString = paramType.toString() paramsBuilder.append( - if ("android.content.Context" == typeAsString) { - "getContext()" - } else if ("android.net.Uri" == typeAsString) { - "uri" - } else if ("android.content.ContentValues" == typeAsString) { - "values" - } else if ("long" == typeAsString) { - "id" - } else if ("java.lang.String" == typeAsString) { - "where" - } else if ("java.lang.String[]" == typeAsString) { - "whereArgs" - } else { - "" + when (typeAsString) { + "android.content.Context" -> "getContext()" + "android.net.Uri" -> "uri" + "android.content.ContentValues" -> "values" + "long" -> "id" + "java.lang.String" -> "where" + "java.lang.String[]" -> "whereArgs" + else -> "" }) } params = paramsBuilder.toString() val typeMirror = executableElement.returnType - if (ClassNames.URI.toString() + "[]" == typeMirror.toString()) { - returnsArray = true - } else if (ClassNames.URI.toString() == typeMirror.toString()) { - returnsSingle = true - } else { - processorManager.logError("Notify method returns wrong type. It must return Uri or Uri[]") + when { + "${ClassNames.URI}[]" == typeMirror.toString() -> returnsArray = true + ClassNames.URI.toString() == typeMirror.toString() -> returnsSingle = true + else -> processorManager.logError("Notify method returns wrong type. It must return Uri or Uri[]") } } diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/TableDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/TableDefinition.kt index e8d83169d..8b2908cae 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/TableDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/TableDefinition.kt @@ -357,14 +357,14 @@ class TableDefinition(manager: ProcessorManager, element: TypeElement) : BaseTab } else if (element.annotation() != null) { ensureVisibleStatic(element, typeElement, "ModelCacheField") if (!customCacheFieldName.isNullOrEmpty()) { - manager.logError("ModelCacheField can only be declared once from: " + typeElement) + manager.logError("ModelCacheField can only be declared once from: $typeElement") } else { customCacheFieldName = element.simpleName.toString() } } else if (element.annotation() != null) { ensureVisibleStatic(element, typeElement, "MultiCacheField") if (!customMultiCacheFieldName.isNullOrEmpty()) { - manager.logError("MultiCacheField can only be declared once from: " + typeElement) + manager.logError("MultiCacheField can only be declared once from: $typeElement") } else { customMultiCacheFieldName = element.simpleName.toString() } diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/TableEndpointDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/TableEndpointDefinition.kt index a2e852cfe..333b214d8 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/TableEndpointDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/TableEndpointDefinition.kt @@ -35,7 +35,10 @@ class TableEndpointDefinition(typeElement: Element, processorManager: ProcessorM var isTopLevel = false init { - contentProviderName = typeElement.extractTypeNameFromAnnotation { it.contentProvider } + contentProviderName = typeElement.extractTypeNameFromAnnotation { + tableName = it.name + it.contentProvider + } isTopLevel = typeElement.enclosingElement is PackageElement @@ -50,19 +53,9 @@ class TableEndpointDefinition(typeElement: Element, processorManager: ProcessorM } } else if (innerElement.annotation() != null) { val notifyDefinition = NotifyDefinition(innerElement, processorManager) - for (path in notifyDefinition.paths) { - var methodListMap = notifyDefinitionPathMap[path] - if (methodListMap == null) { - methodListMap = mutableMapOf() - notifyDefinitionPathMap.put(path, methodListMap) - } - - var notifyDefinitionList: MutableList? = methodListMap[notifyDefinition.method] - if (notifyDefinitionList == null) { - notifyDefinitionList = arrayListOf() - methodListMap.put(notifyDefinition.method, notifyDefinitionList) - } + val methodListMap = notifyDefinitionPathMap.getOrPut(path) { mutableMapOf() } + val notifyDefinitionList = methodListMap.getOrPut(notifyDefinition.method) { arrayListOf() } notifyDefinitionList.add(notifyDefinition) } } diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/utils/ProcessorUtils.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/utils/ProcessorUtils.kt index 9fdaf0527..fecd80650 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/utils/ProcessorUtils.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/utils/ProcessorUtils.kt @@ -114,12 +114,12 @@ fun ensureVisibleStatic(element: Element, typeElement: TypeElement, inline fun Element.extractTypeNameFromAnnotation(invoker: (A) -> Unit): TypeName? = annotation()?.let { a -> - return@let try { + try { invoker(a) - null } catch (mte: MirroredTypeException) { - TypeName.get(mte.typeMirror) + return@let TypeName.get(mte.typeMirror) } + return@let null } inline fun diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/CacheableListModelLoader.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/CacheableListModelLoader.kt index 186348a59..6f2ed48ea 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/CacheableListModelLoader.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/CacheableListModelLoader.kt @@ -1,10 +1,11 @@ package com.raizlabs.android.dbflow.adapter.queriable -import com.raizlabs.android.dbflow.annotation.Table import com.raizlabs.android.dbflow.adapter.ModelAdapter -import com.raizlabs.android.dbflow.query.cache.ModelCache +import com.raizlabs.android.dbflow.annotation.Table import com.raizlabs.android.dbflow.database.DatabaseWrapper import com.raizlabs.android.dbflow.database.FlowCursor +import com.raizlabs.android.dbflow.query.cache.ModelCache +import com.raizlabs.android.dbflow.query.cache.addOrReload /** * Description: Loads a [List] of [T] with [Table.cachingEnabled] true. @@ -33,16 +34,9 @@ open class CacheableListModelLoader(modelClass: Class) if (cursor.moveToFirst()) { do { val values = modelAdapter.getCachingColumnValuesFromCursor(cacheValues, cursor) - var model: T? = modelCache[modelAdapter.getCachingId(values)] - if (model != null) { - modelAdapter.reloadRelationships(model, cursor, databaseWrapper) - _data.add(model) - } else { - model = modelAdapter.newInstance() - modelAdapter.loadFromCursor(cursor, model, databaseWrapper) - modelCache.addModel(modelAdapter.getCachingId(values), model) - _data.add(model) - } + val model = modelCache.addOrReload(modelAdapter.getCachingId(values), + modelAdapter, cursor, databaseWrapper) + _data.add(model) } while (cursor.moveToNext()) } return _data diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/CacheableModelLoader.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/CacheableModelLoader.kt index e80474caa..5042d6709 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/CacheableModelLoader.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/CacheableModelLoader.kt @@ -1,10 +1,11 @@ package com.raizlabs.android.dbflow.adapter.queriable -import com.raizlabs.android.dbflow.annotation.Table import com.raizlabs.android.dbflow.adapter.ModelAdapter -import com.raizlabs.android.dbflow.query.cache.ModelCache +import com.raizlabs.android.dbflow.annotation.Table import com.raizlabs.android.dbflow.database.DatabaseWrapper import com.raizlabs.android.dbflow.database.FlowCursor +import com.raizlabs.android.dbflow.query.cache.ModelCache +import com.raizlabs.android.dbflow.query.cache.addOrReload /** * Description: Loads model data that is backed by a [ModelCache]. Used when [Table.cachingEnabled] @@ -13,15 +14,19 @@ import com.raizlabs.android.dbflow.database.FlowCursor open class CacheableModelLoader(modelClass: Class) : SingleModelLoader(modelClass) { - val modelAdapter by lazy { - if (instanceAdapter !is ModelAdapter<*>) { - throw IllegalArgumentException("A non-Table type was used.") - } - val modelAdapter = instanceAdapter as ModelAdapter - if (!modelAdapter.cachingEnabled()) { - throw IllegalArgumentException("You cannot call this method for a table that has no caching id. Either" + "use one Primary Key or use the MultiCacheKeyConverter") + val modelAdapter: ModelAdapter by lazy { + when (instanceAdapter) { + !is ModelAdapter<*> -> throw IllegalArgumentException("A non-Table type was used.") + else -> { + val modelAdapter = instanceAdapter as ModelAdapter + if (!modelAdapter.cachingEnabled()) { + throw IllegalArgumentException("""You cannot call this method for a table that + |has no caching id. Either use one Primary Key or + |use the MultiCacheKeyConverter""".trimMargin()) + } + return@lazy modelAdapter + } } - return@lazy modelAdapter } val modelCache: ModelCache by lazy { modelAdapter.modelCache } @@ -34,21 +39,11 @@ open class CacheableModelLoader(modelClass: Class) */ override fun convertToData(cursor: FlowCursor, data: T?, moveToFirst: Boolean, databaseWrapper: DatabaseWrapper): T? { - if (!moveToFirst || cursor.moveToFirst()) { + return if (!moveToFirst || cursor.moveToFirst()) { val values = modelAdapter.getCachingColumnValuesFromCursor( arrayOfNulls(modelAdapter.cachingColumns.size), cursor) - var model: T? = modelCache[modelAdapter.getCachingId(values)] - if (model == null) { - model = (data ?: modelAdapter.newInstance()).apply { - modelAdapter.loadFromCursor(cursor, this, databaseWrapper) - modelCache.addModel(modelAdapter.getCachingId(values), this) - } - } else { - modelAdapter.reloadRelationships(model, cursor, databaseWrapper) - } - return model - } else { - return null - } + modelCache.addOrReload(modelAdapter.getCachingId(values), modelAdapter, + cursor, databaseWrapper, data) + } else null } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/ListModelLoader.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/ListModelLoader.kt index 27e0834ec..ef21a7c58 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/ListModelLoader.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/ListModelLoader.kt @@ -11,31 +11,20 @@ open class ListModelLoader(modelClass: Class) override fun load(cursor: FlowCursor?, data: MutableList?, databaseWrapper: DatabaseWrapper): MutableList? { - var _data = data - if (_data == null) { - _data = arrayListOf() - } else { - _data.clear() - } - return super.load(cursor, _data, databaseWrapper) + val emptyData = data?.apply { clear() } ?: arrayListOf() + return super.load(cursor, emptyData, databaseWrapper) } override fun convertToData(cursor: FlowCursor, data: MutableList?, databaseWrapper: DatabaseWrapper): MutableList { - var _data = data - if (_data == null) { - _data = arrayListOf() - } else { - _data.clear() - } - + val retData = data?.apply { clear() } ?: arrayListOf() if (cursor.moveToFirst()) { do { val model = instanceAdapter.newInstance() instanceAdapter.loadFromCursor(cursor, model, databaseWrapper) - _data.add(model) + retData.add(model) } while (cursor.moveToNext()) } - return _data + return retData } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/SingleKeyCacheableListModelLoader.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/SingleKeyCacheableListModelLoader.kt index ea755eee6..f1920e536 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/SingleKeyCacheableListModelLoader.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/SingleKeyCacheableListModelLoader.kt @@ -2,6 +2,7 @@ package com.raizlabs.android.dbflow.adapter.queriable import com.raizlabs.android.dbflow.database.DatabaseWrapper import com.raizlabs.android.dbflow.database.FlowCursor +import com.raizlabs.android.dbflow.query.cache.addOrReload /** * Description: @@ -17,14 +18,7 @@ class SingleKeyCacheableListModelLoader(tModelClass: Class) if (cursor.moveToFirst()) { do { cacheValue = modelAdapter.getCachingColumnValueFromCursor(cursor) - var model: T? = modelCache[cacheValue] - if (model != null) { - modelAdapter.reloadRelationships(model, cursor, databaseWrapper) - } else { - model = modelAdapter.newInstance() - modelAdapter.loadFromCursor(cursor, model, databaseWrapper) - modelCache.addModel(cacheValue, model) - } + val model = modelCache.addOrReload(cacheValue, modelAdapter, cursor, databaseWrapper) _data.add(model) } while (cursor.moveToNext()) } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/SingleKeyCacheableModelLoader.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/SingleKeyCacheableModelLoader.kt index 7b4eac335..d43445dc7 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/SingleKeyCacheableModelLoader.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/SingleKeyCacheableModelLoader.kt @@ -1,8 +1,9 @@ package com.raizlabs.android.dbflow.adapter.queriable -import com.raizlabs.android.dbflow.structure.Model import com.raizlabs.android.dbflow.database.DatabaseWrapper import com.raizlabs.android.dbflow.database.FlowCursor +import com.raizlabs.android.dbflow.query.cache.addOrReload +import com.raizlabs.android.dbflow.structure.Model /** * Description: More optimized version of [CacheableModelLoader] which assumes that the [Model] @@ -20,20 +21,10 @@ class SingleKeyCacheableModelLoader(modelClass: Class) override fun convertToData(cursor: FlowCursor, data: T?, moveToFirst: Boolean, databaseWrapper: DatabaseWrapper): T? { - if (!moveToFirst || cursor.moveToFirst()) { + return if (!moveToFirst || cursor.moveToFirst()) { val value = modelAdapter.getCachingColumnValueFromCursor(cursor) - var model: T? = modelCache.get(value) - if (model == null) { - model = (data ?: modelAdapter.newInstance()).apply { - modelAdapter.loadFromCursor(cursor, this, databaseWrapper) - modelCache.addModel(value, this) - } - } else { - modelAdapter.reloadRelationships(model, cursor, databaseWrapper) - } - return model - } else { - return null - } + modelCache.addOrReload(value, modelAdapter, + cursor, databaseWrapper, data) + } else null } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/cache/ModelCache.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/cache/ModelCache.kt index c9a395375..81fc6fde3 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/cache/ModelCache.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/cache/ModelCache.kt @@ -1,5 +1,9 @@ package com.raizlabs.android.dbflow.query.cache +import com.raizlabs.android.dbflow.adapter.ModelAdapter +import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.android.dbflow.database.FlowCursor + /** * Description: A generic cache for models that is implemented or can be implemented to your liking. */ @@ -48,3 +52,20 @@ abstract class ModelCache */ abstract fun setCacheSize(size: Int) } + +@Suppress("NOTHING_TO_INLINE") +inline fun ModelCache.addOrReload(cacheValue: Any?, + modelAdapter: ModelAdapter, + cursor: FlowCursor, + databaseWrapper: DatabaseWrapper, + data: T? = null): T { + var model: T? = get(cacheValue) + if (model != null) { + modelAdapter.reloadRelationships(model, cursor, databaseWrapper) + } else { + model = data ?: modelAdapter.newInstance() + modelAdapter.loadFromCursor(cursor, model, databaseWrapper) + addModel(cacheValue, model) + } + return model +} \ No newline at end of file From 6d1df625fe8611866bcf9836353074e76970c307 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Tue, 28 Nov 2017 17:51:56 -0500 Subject: [PATCH 099/234] [properties] remove extension on properties since operator has same methods. --- .../contentobserver/ContentObserverTest.kt | 4 +- .../dbflow/prepackaged/PrepackagedDBTest.kt | 2 +- .../android/dbflow/sqlcipher/CipherTest.kt | 2 +- .../dbflow/sqlcipher/CipherTestObjects.kt | 2 +- .../android/dbflow/test/DemoActivity.java | 10 ++--- dbflow-tests/src/main/res/menu/menu_demo.xml | 9 +++-- .../android/dbflow/config/FlowConfig.kt | 4 +- .../raizlabs/android/dbflow/query/Operator.kt | 34 ++++++++++++----- .../android/dbflow/query/property/Property.kt | 37 ------------------- 9 files changed, 40 insertions(+), 64 deletions(-) diff --git a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/contentobserver/ContentObserverTest.kt b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/contentobserver/ContentObserverTest.kt index 0a491ef22..52c3f932f 100644 --- a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/contentobserver/ContentObserverTest.kt +++ b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/contentobserver/ContentObserverTest.kt @@ -3,16 +3,16 @@ package com.raizlabs.android.dbflow.contentobserver import android.net.Uri import com.raizlabs.android.dbflow.BaseInstrumentedUnitTest import com.raizlabs.android.dbflow.DemoApp +import com.raizlabs.android.dbflow.TABLE_QUERY_PARAM import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.config.databaseForTable import com.raizlabs.android.dbflow.config.tableName import com.raizlabs.android.dbflow.contentobserver.User_Table.id import com.raizlabs.android.dbflow.contentobserver.User_Table.name -import com.raizlabs.android.dbflow.runtime.FlowContentObserver -import com.raizlabs.android.dbflow.TABLE_QUERY_PARAM import com.raizlabs.android.dbflow.getNotificationUri import com.raizlabs.android.dbflow.query.SQLOperator import com.raizlabs.android.dbflow.query.delete +import com.raizlabs.android.dbflow.runtime.FlowContentObserver import com.raizlabs.android.dbflow.structure.ChangeAction import com.raizlabs.android.dbflow.structure.delete import com.raizlabs.android.dbflow.structure.insert diff --git a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/prepackaged/PrepackagedDBTest.kt b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/prepackaged/PrepackagedDBTest.kt index f2f1850e4..18cfcea6b 100644 --- a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/prepackaged/PrepackagedDBTest.kt +++ b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/prepackaged/PrepackagedDBTest.kt @@ -2,8 +2,8 @@ package com.raizlabs.android.dbflow.prepackaged import com.raizlabs.android.dbflow.BaseInstrumentedUnitTest import com.raizlabs.android.dbflow.config.databaseForTable -import com.raizlabs.android.dbflow.query.select import com.raizlabs.android.dbflow.query.list +import com.raizlabs.android.dbflow.query.select import org.junit.Assert.assertTrue import org.junit.Test diff --git a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/sqlcipher/CipherTest.kt b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/sqlcipher/CipherTest.kt index 1a6cdc0e3..6b9f84afd 100644 --- a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/sqlcipher/CipherTest.kt +++ b/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/sqlcipher/CipherTest.kt @@ -3,9 +3,9 @@ package com.raizlabs.android.dbflow.sqlcipher import com.raizlabs.android.dbflow.BaseInstrumentedUnitTest import com.raizlabs.android.dbflow.config.database import com.raizlabs.android.dbflow.query.delete +import com.raizlabs.android.dbflow.query.result import com.raizlabs.android.dbflow.query.select import com.raizlabs.android.dbflow.query.where -import com.raizlabs.android.dbflow.query.result import org.junit.Assert.assertTrue import org.junit.Test diff --git a/dbflow-tests/src/main/java/com/raizlabs/android/dbflow/sqlcipher/CipherTestObjects.kt b/dbflow-tests/src/main/java/com/raizlabs/android/dbflow/sqlcipher/CipherTestObjects.kt index 43a7b0e7d..c6eb5a80d 100644 --- a/dbflow-tests/src/main/java/com/raizlabs/android/dbflow/sqlcipher/CipherTestObjects.kt +++ b/dbflow-tests/src/main/java/com/raizlabs/android/dbflow/sqlcipher/CipherTestObjects.kt @@ -4,8 +4,8 @@ import com.raizlabs.android.dbflow.annotation.Column import com.raizlabs.android.dbflow.annotation.PrimaryKey import com.raizlabs.android.dbflow.annotation.Table import com.raizlabs.android.dbflow.config.DatabaseDefinition -import com.raizlabs.android.dbflow.structure.BaseModel import com.raizlabs.android.dbflow.database.DatabaseHelperListener +import com.raizlabs.android.dbflow.structure.BaseModel class SQLCipherOpenHelperImpl(databaseDefinition: DatabaseDefinition, helperListener: DatabaseHelperListener?) : SQLCipherOpenHelper(databaseDefinition, helperListener) { diff --git a/dbflow-tests/src/main/java/com/raizlabs/android/dbflow/test/DemoActivity.java b/dbflow-tests/src/main/java/com/raizlabs/android/dbflow/test/DemoActivity.java index 943d49d1d..6e13c3907 100644 --- a/dbflow-tests/src/main/java/com/raizlabs/android/dbflow/test/DemoActivity.java +++ b/dbflow-tests/src/main/java/com/raizlabs/android/dbflow/test/DemoActivity.java @@ -19,11 +19,11 @@ protected void onCreate(Bundle savedInstanceState) { setContentView(R.layout.activity_demo); FlowManager.init(new FlowConfig.Builder(getApplicationContext()) - .addDatabaseConfig( - DatabaseConfig.builder(PrepackagedDB.class) - .databaseName("prepackaged") - .build()) - .build()); + .addDatabaseConfig( + DatabaseConfig.builder(PrepackagedDB.class) + .databaseName("prepackaged") + .build()) + .build()); } diff --git a/dbflow-tests/src/main/res/menu/menu_demo.xml b/dbflow-tests/src/main/res/menu/menu_demo.xml index 77c35819a..76854bbdd 100644 --- a/dbflow-tests/src/main/res/menu/menu_demo.xml +++ b/dbflow-tests/src/main/res/menu/menu_demo.xml @@ -2,8 +2,9 @@ xmlns:app="http://schemas.android.com/apk/res-auto" xmlns:tools="http://schemas.android.com/tools" tools:context="com.raizlabs.android.dbflow.DemoActivity"> - + diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowConfig.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowConfig.kt index 03328c0b0..340541dd9 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowConfig.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowConfig.kt @@ -50,8 +50,6 @@ class FlowConfig(val context: Context, companion object { - fun builder(context: Context): FlowConfig.Builder { - return FlowConfig.Builder(context) - } + fun builder(context: Context): FlowConfig.Builder = FlowConfig.Builder(context) } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Operator.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Operator.kt index 3332046b0..55aba8cfc 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Operator.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Operator.kt @@ -7,8 +7,8 @@ import com.raizlabs.android.dbflow.appendOptional import com.raizlabs.android.dbflow.config.FlowLog import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.converter.TypeConverter -import com.raizlabs.android.dbflow.sql.Query import com.raizlabs.android.dbflow.query.property.Property +import com.raizlabs.android.dbflow.sql.Query /** * Description: The class that contains a column name, Operator, and value. @@ -622,20 +622,34 @@ fun NameAlias.op() = Operator.op(this) fun String.op(): Operator = nameAlias.op() -infix fun Operator.collate(collation: Collate) = collate(collation) +infix fun Operator.collate(collation: Collate): BaseOperator = collate(collation) + +infix fun Operator.collate(collation: String): BaseOperator = collate(collation) -infix fun Operator.collate(collation: String) = collate(collation) +infix fun Operator.postfix(collation: String): BaseOperator = postfix(collation) -infix fun Operator.postfix(collation: String) = postfix(collation) +infix fun Operator.Between.and(value: T?): BaseOperator = and(value) -infix fun Operator.Between.and(value: T?) = and(value) +infix fun Operator.In.and(value: T?): BaseOperator = and(value) -infix fun Operator.In.and(value: T?) = and(value) +infix fun Operator.and(sqlOperator: SQLOperator): OperatorGroup + = OperatorGroup.clause(this).and(sqlOperator) -infix fun Operator.and(sqlOperator: SQLOperator) = OperatorGroup.clause(this).and(sqlOperator) +infix fun Operator.or(sqlOperator: SQLOperator): OperatorGroup + = OperatorGroup.clause(this).or(sqlOperator) -infix fun Operator.or(sqlOperator: SQLOperator) = OperatorGroup.clause(this).or(sqlOperator) +infix fun Operator.andAll(sqlOperator: Collection): OperatorGroup + = OperatorGroup.clause(this).andAll(sqlOperator) -infix fun Operator.andAll(sqlOperator: Collection) = OperatorGroup.clause(this).andAll(sqlOperator) +infix fun Operator.orAll(sqlOperator: Collection): OperatorGroup + = OperatorGroup.clause(this).orAll(sqlOperator) + +infix fun Operator.`in`(values: Array): Operator.In = when (values.size) { + 1 -> `in`(values[0]) + else -> this.`in`(values[0], *values.sliceArray(IntRange(1, values.size))) +} -infix fun Operator.orAll(sqlOperator: Collection) = OperatorGroup.clause(this).orAll(sqlOperator) \ No newline at end of file +infix fun Operator.notIn(values: Array): Operator.In = when (values.size) { + 1 -> notIn(values[0]) + else -> this.notIn(values[0], *values.sliceArray(IntRange(1, values.size))) +} \ No newline at end of file diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/property/Property.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/property/Property.kt index 787950852..e31702bc9 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/property/Property.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/property/Property.kt @@ -277,40 +277,3 @@ open class Property : IProperty>, IConditional, IOperator { } -infix fun Property.eq(value: T?) = this.eq(value) - -infix fun Property.`is`(value: T?) = this.`is`(value) - -infix fun Property.isNot(value: T?) = this.isNot(value) - -infix fun Property.notEq(value: T?) = this.notEq(value) - -infix fun Property.like(value: String) = this.like(value) - -infix fun Property.glob(value: String) = this.glob(value) - -infix fun Property.greaterThan(value: T) = this.greaterThan(value) - -infix fun Property.greaterThanOrEq(value: T) = this.greaterThanOrEq(value) - -infix fun Property.lessThan(value: T) = this.lessThan(value) - -infix fun Property.lessThanOrEq(value: T) = this.lessThanOrEq(value) - -infix fun Property.between(value: T) = this.between(value) - -infix fun Property.`in`(values: Array): Operator.In = when (values.size) { - 1 -> `in`(values[0]) - else -> this.`in`(values[0], *values.sliceArray(IntRange(1, values.size))) -} - -infix fun Property.notIn(values: Array): Operator.In = when (values.size) { - 1 -> notIn(values[0]) - else -> this.notIn(values[0], *values.sliceArray(IntRange(1, values.size))) -} - -infix fun Property.`in`(values: Collection) = this.`in`(values) - -infix fun Property.notIn(values: Collection) = this.notIn(values) - -infix fun Property.concatenate(value: T) = this.concatenate(value) From a44408202c2601077c40c43118d3c417a337ee94 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Tue, 28 Nov 2017 18:24:47 -0500 Subject: [PATCH 100/234] [kotlin] replace usages where possible of java construction with kotlin collection methods. --- .../raizlabs/android/dbflow/sql/SQLiteType.kt | 49 ++++++++-------- .../dbflow/processor/ProcessorManager.kt | 3 +- .../definition/BaseTableDefinition.kt | 3 +- .../definition/DatabaseDefinition.kt | 31 +++++----- .../definition/DatabaseObjectHolder.kt | 11 ++-- .../definition/IndexGroupsDefinition.kt | 10 +++- .../dbflow/processor/definition/Methods.kt | 9 ++- .../definition/QueryModelDefinition.kt | 3 +- .../processor/definition/TableDefinition.kt | 12 ++-- .../definition/UniqueGroupsDefinition.kt | 3 +- .../definition/column/ColumnAccessor.kt | 23 +++----- .../column/ReferenceColumnDefinition.kt | 3 +- .../dbflow/processor/utils/ElementUtility.kt | 11 ++-- .../android/dbflow/config/DatabaseConfig.kt | 9 ++- .../dbflow/config/DatabaseDefinition.kt | 27 +++++---- .../android/dbflow/config/DatabaseHolder.kt | 11 ++-- .../android/dbflow/config/FlowConfig.kt | 7 +-- .../android/dbflow/config/FlowManager.kt | 3 +- .../dbflow/database/BaseDatabaseHelper.kt | 41 ++++++------- .../dbflow/migration/IndexMigration.kt | 5 +- .../android/dbflow/query/CompletedTrigger.kt | 5 +- .../com/raizlabs/android/dbflow/query/From.kt | 3 +- .../com/raizlabs/android/dbflow/query/Join.kt | 5 +- .../raizlabs/android/dbflow/query/Method.kt | 19 +++--- .../raizlabs/android/dbflow/query/Operator.kt | 58 +++++++++---------- .../android/dbflow/query/OperatorGroup.kt | 3 +- .../raizlabs/android/dbflow/query/Where.kt | 7 +-- .../dbflow/query/list/FlowCursorList.kt | 3 +- .../dbflow/runtime/DBBatchSaveQueue.kt | 5 +- .../dbflow/runtime/DirectModelNotifier.kt | 9 ++- .../dbflow/runtime/FlowContentObserver.kt | 7 +-- .../transaction/FastStoreModelTransaction.kt | 3 +- .../dbflow/transaction/TransactionWrapper.kt | 5 +- 33 files changed, 183 insertions(+), 223 deletions(-) diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/sql/SQLiteType.kt b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/sql/SQLiteType.kt index 1515734e0..2fb4e170b 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/sql/SQLiteType.kt +++ b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/sql/SQLiteType.kt @@ -1,7 +1,6 @@ package com.raizlabs.android.dbflow.sql import com.raizlabs.android.dbflow.data.Blob -import java.util.* /** * Description: Represents a type that SQLite understands. @@ -31,31 +30,28 @@ enum class SQLiteType { companion object { - private val sTypeMap = object : HashMap() { - init { - put(Byte::class.javaPrimitiveType!!.name, SQLiteType.INTEGER) - put(Short::class.javaPrimitiveType!!.name, SQLiteType.INTEGER) - put(Int::class.javaPrimitiveType!!.name, SQLiteType.INTEGER) - put(Long::class.javaPrimitiveType!!.name, SQLiteType.INTEGER) - put(Float::class.javaPrimitiveType!!.name, SQLiteType.REAL) - put(Double::class.javaPrimitiveType!!.name, SQLiteType.REAL) - put(Boolean::class.javaPrimitiveType!!.name, SQLiteType.INTEGER) - put(Char::class.javaPrimitiveType!!.name, SQLiteType.TEXT) - put(ByteArray::class.java.name, SQLiteType.BLOB) - put(Byte::class.java.name, SQLiteType.INTEGER) - put(Short::class.java.name, SQLiteType.INTEGER) - put(Int::class.java.name, SQLiteType.INTEGER) - put(Long::class.java.name, SQLiteType.INTEGER) - put(Float::class.java.name, SQLiteType.REAL) - put(Double::class.java.name, SQLiteType.REAL) - put(Boolean::class.java.name, SQLiteType.INTEGER) - put(Char::class.java.name, SQLiteType.TEXT) - put(CharSequence::class.java.name, SQLiteType.TEXT) - put(String::class.java.name, SQLiteType.TEXT) - put(Array::class.java.name, SQLiteType.BLOB) - put(Blob::class.java.name, SQLiteType.BLOB) - } - } + private val sTypeMap = hashMapOf( + Byte::class.javaPrimitiveType!!.name to SQLiteType.INTEGER, + Short::class.javaPrimitiveType!!.name to SQLiteType.INTEGER, + Int::class.javaPrimitiveType!!.name to SQLiteType.INTEGER, + Long::class.javaPrimitiveType!!.name to SQLiteType.INTEGER, + Float::class.javaPrimitiveType!!.name to SQLiteType.REAL, + Double::class.javaPrimitiveType!!.name to SQLiteType.REAL, + Boolean::class.javaPrimitiveType!!.name to SQLiteType.INTEGER, + Char::class.javaPrimitiveType!!.name to SQLiteType.TEXT, + ByteArray::class.java.name to SQLiteType.BLOB, + Byte::class.java.name to SQLiteType.INTEGER, + Short::class.java.name to SQLiteType.INTEGER, + Int::class.java.name to SQLiteType.INTEGER, + Long::class.java.name to SQLiteType.INTEGER, + Float::class.java.name to SQLiteType.REAL, + Double::class.java.name to SQLiteType.REAL, + Boolean::class.java.name to SQLiteType.INTEGER, + Char::class.java.name to SQLiteType.TEXT, + CharSequence::class.java.name to SQLiteType.TEXT, + String::class.java.name to SQLiteType.TEXT, + Array::class.java.name to SQLiteType.BLOB, + Blob::class.java.name to SQLiteType.BLOB) /** * Returns the [SQLiteType] for this class @@ -63,6 +59,7 @@ enum class SQLiteType { * @param className The fully qualified class name * @return The type from the class name */ + operator fun get(className: String): SQLiteType? = sTypeMap[className] fun containsClass(className: String): Boolean = sTypeMap.containsKey(className) diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/ProcessorManager.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/ProcessorManager.kt index c4e2242b8..ae25daf32 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/ProcessorManager.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/ProcessorManager.kt @@ -17,7 +17,6 @@ import com.squareup.javapoet.ClassName import com.squareup.javapoet.JavaFile import com.squareup.javapoet.TypeName import java.io.IOException -import java.util.* import javax.annotation.processing.FilerException import javax.annotation.processing.Messager import javax.annotation.processing.ProcessingEnvironment @@ -72,7 +71,7 @@ class ProcessorManager internal constructor(val processingEnvironment: Processin holderDefinition?.databaseDefinition = databaseDefinition } - fun getDatabaseHolderDefinitionList() = ArrayList(databaseDefinitionMap.values) + fun getDatabaseHolderDefinitionList() = databaseDefinitionMap.values.toList() fun getDatabaseHolderDefinition(databaseName: TypeName?) = databaseDefinitionMap[databaseName] diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/BaseTableDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/BaseTableDefinition.kt index 1a28ba36f..c2bce0538 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/BaseTableDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/BaseTableDefinition.kt @@ -25,7 +25,6 @@ import com.squareup.javapoet.ParameterizedTypeName import com.squareup.javapoet.TypeName import com.squareup.javapoet.TypeSpec import java.io.IOException -import java.util.* import javax.annotation.processing.ProcessingEnvironment import javax.lang.model.element.Element import javax.lang.model.element.Modifier @@ -64,7 +63,7 @@ abstract class BaseTableDefinition(typeElement: Element, processorManager: Proce get() = globalTypeConverters.isNotEmpty() init { - columnDefinitions = ArrayList() + columnDefinitions = arrayListOf() } protected abstract fun createColumnDefinitions(typeElement: TypeElement) diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/DatabaseDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/DatabaseDefinition.kt index c669a37a7..6fa152484 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/DatabaseDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/DatabaseDefinition.kt @@ -22,7 +22,6 @@ import com.squareup.javapoet.ParameterizedTypeName import com.squareup.javapoet.TypeName import com.squareup.javapoet.TypeSpec import com.squareup.javapoet.WildcardTypeName -import java.util.* import java.util.regex.Pattern import javax.lang.model.element.Element @@ -95,18 +94,18 @@ class DatabaseDefinition(manager: ProcessorManager, element: Element) : BaseDefi private fun validateDefinitions() { elementClassName?.let { - val map = HashMap() + val map = hashMapOf() val tableValidator = TableValidator() manager.getTableDefinitions(it) - .filter { tableValidator.validate(ProcessorManager.manager, it) } - .forEach { it.elementClassName?.let { className -> map.put(className, it) } } + .filter { tableValidator.validate(ProcessorManager.manager, it) } + .forEach { it.elementClassName?.let { className -> map.put(className, it) } } manager.setTableDefinitions(map, it) - val modelViewDefinitionMap = HashMap() + val modelViewDefinitionMap = hashMapOf() val modelViewValidator = ModelViewValidator() manager.getModelViewDefinitions(it) - .filter { modelViewValidator.validate(ProcessorManager.manager, it) } - .forEach { it.elementClassName?.let { className -> modelViewDefinitionMap.put(className, it) } } + .filter { modelViewValidator.validate(ProcessorManager.manager, it) } + .forEach { it.elementClassName?.let { className -> modelViewDefinitionMap.put(className, it) } } manager.setModelViewDefinitions(modelViewDefinitionMap, it) } } @@ -150,14 +149,14 @@ class DatabaseDefinition(manager: ProcessorManager, element: Element) : BaseDefi val migrationDefinitionMap = manager.getMigrationsForDatabase(elementClassName) migrationDefinitionMap.keys - .sortedByDescending { it } - .forEach { version -> - migrationDefinitionMap[version] - ?.sortedBy { it.priority } - ?.forEach { migrationDefinition -> - statement("addMigration($version, new \$T${migrationDefinition.constructorName})", migrationDefinition.elementClassName) - } - } + .sortedByDescending { it } + .forEach { version -> + migrationDefinitionMap[version] + ?.sortedBy { it.priority } + ?.forEach { migrationDefinition -> + statement("addMigration($version, new \$T${migrationDefinition.constructorName})", migrationDefinition.elementClassName) + } + } } this } @@ -167,7 +166,7 @@ class DatabaseDefinition(manager: ProcessorManager, element: Element) : BaseDefi private fun writeGetters(typeBuilder: TypeSpec.Builder) { typeBuilder.apply { `override fun`(ParameterizedTypeName.get(ClassName.get(Class::class.java), WildcardTypeName.subtypeOf(Any::class.java)), - "getAssociatedDatabaseClassFile") { + "getAssociatedDatabaseClassFile") { modifiers(public, final) `return`("\$T.class", elementTypeName) } diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/DatabaseObjectHolder.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/DatabaseObjectHolder.kt index fb1035341..cc83eb462 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/DatabaseObjectHolder.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/DatabaseObjectHolder.kt @@ -1,7 +1,6 @@ package com.raizlabs.android.dbflow.processor.definition import com.squareup.javapoet.TypeName -import java.util.* /** * Description: Provides overarching holder for [DatabaseDefinition], [TableDefinition], @@ -15,12 +14,12 @@ class DatabaseObjectHolder { field?.objectHolder = this } - var tableDefinitionMap: MutableMap = HashMap() - var tableNameMap: MutableMap = HashMap() + var tableDefinitionMap: MutableMap = hashMapOf() + var tableNameMap: MutableMap = hashMapOf() - var queryModelDefinitionMap: MutableMap = HashMap() - var modelViewDefinitionMap: MutableMap = HashMap() - var manyToManyDefinitionMap: MutableMap> = HashMap() + var queryModelDefinitionMap: MutableMap = hashMapOf() + var modelViewDefinitionMap: MutableMap = hashMapOf() + var manyToManyDefinitionMap: MutableMap> = hashMapOf() var providerMap = hashMapOf() /** diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/IndexGroupsDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/IndexGroupsDefinition.kt index 1398fd97c..2c8f01bd5 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/IndexGroupsDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/IndexGroupsDefinition.kt @@ -1,11 +1,15 @@ package com.raizlabs.android.dbflow.processor.definition -import com.grosner.kpoet.* +import com.grosner.kpoet.S +import com.grosner.kpoet.`=` +import com.grosner.kpoet.field +import com.grosner.kpoet.final +import com.grosner.kpoet.public +import com.grosner.kpoet.static import com.raizlabs.android.dbflow.annotation.IndexGroup import com.raizlabs.android.dbflow.processor.ClassNames import com.raizlabs.android.dbflow.processor.definition.column.ColumnDefinition import com.squareup.javapoet.ParameterizedTypeName -import java.util.* import java.util.concurrent.atomic.AtomicInteger /** @@ -17,7 +21,7 @@ class IndexGroupsDefinition(private val tableDefinition: TableDefinition, indexG val indexNumber = indexGroup.number val isUnique = indexGroup.unique - val columnDefinitionList: MutableList = ArrayList() + val columnDefinitionList: MutableList = arrayListOf() val fieldSpec get() = field(ParameterizedTypeName.get(ClassNames.INDEX_PROPERTY, tableDefinition.elementClassName), diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/Methods.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/Methods.kt index 63180e710..a008ee974 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/Methods.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/Methods.kt @@ -23,7 +23,6 @@ import com.squareup.javapoet.MethodSpec import com.squareup.javapoet.NameAllocator import com.squareup.javapoet.TypeName import com.squareup.javapoet.TypeSpec -import java.util.* import java.util.concurrent.atomic.AtomicInteger import javax.lang.model.element.Modifier @@ -236,11 +235,11 @@ class CreationQueryMethod(private val tableDefinition: TableDefinition) : Method val codeBuilder = CodeBlock.builder() .add("return ${creationBuilder.toString().S}") - val foreignKeyBlocks = ArrayList() - val tableNameBlocks = ArrayList() - val referenceKeyBlocks = ArrayList() + val foreignKeyBlocks = arrayListOf() + val tableNameBlocks = arrayListOf() + val referenceKeyBlocks = arrayListOf() - for (i in 0..foreignSize - 1) { + for (i in 0 until foreignSize) { val foreignKeyBuilder = CodeBlock.builder() val referenceBuilder = CodeBlock.builder() val fk = tableDefinition.foreignKeyDefinitions[i] diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/QueryModelDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/QueryModelDefinition.kt index 955c9b60d..1a6ecc07d 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/QueryModelDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/QueryModelDefinition.kt @@ -20,7 +20,6 @@ import com.raizlabs.android.dbflow.processor.utils.implementsClass import com.squareup.javapoet.ParameterizedTypeName import com.squareup.javapoet.TypeName import com.squareup.javapoet.TypeSpec -import java.util.* import javax.lang.model.element.Element import javax.lang.model.element.TypeElement @@ -130,6 +129,6 @@ class QueryModelDefinition(typeElement: Element, processorManager: ProcessorMana override // Shouldn't include any val primaryColumnDefinitions: List - get() = ArrayList() + get() = arrayListOf() } diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/TableDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/TableDefinition.kt index 8b2908cae..4c36aa286 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/TableDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/TableDefinition.kt @@ -31,7 +31,10 @@ import com.raizlabs.android.dbflow.processor.ClassNames import com.raizlabs.android.dbflow.processor.ColumnValidator import com.raizlabs.android.dbflow.processor.OneToManyValidator import com.raizlabs.android.dbflow.processor.ProcessorManager -import com.raizlabs.android.dbflow.processor.definition.BindToStatementMethod.Mode.* +import com.raizlabs.android.dbflow.processor.definition.BindToStatementMethod.Mode.DELETE +import com.raizlabs.android.dbflow.processor.definition.BindToStatementMethod.Mode.INSERT +import com.raizlabs.android.dbflow.processor.definition.BindToStatementMethod.Mode.NON_INSERT +import com.raizlabs.android.dbflow.processor.definition.BindToStatementMethod.Mode.UPDATE import com.raizlabs.android.dbflow.processor.definition.column.ColumnDefinition import com.raizlabs.android.dbflow.processor.definition.column.DefinitionUtils import com.raizlabs.android.dbflow.processor.definition.column.ReferenceColumnDefinition @@ -54,7 +57,6 @@ import com.squareup.javapoet.ParameterizedTypeName import com.squareup.javapoet.TypeName import com.squareup.javapoet.TypeSpec import com.squareup.javapoet.WildcardTypeName -import java.util.* import java.util.concurrent.atomic.AtomicInteger import javax.lang.model.element.ExecutableElement import javax.lang.model.element.Modifier @@ -185,7 +187,7 @@ class TableDefinition(manager: ProcessorManager, element: TypeElement) : BaseTab } override fun prepareForWrite() { - columnDefinitions = ArrayList() + columnDefinitions = arrayListOf() columnMap.clear() classElementLookUpMap.clear() _primaryColumnDefinitions.clear() @@ -228,7 +230,7 @@ class TableDefinition(manager: ProcessorManager, element: TypeElement) : BaseTab typeElement?.let { createColumnDefinitions(it) } val groups = table.uniqueColumnGroups - var uniqueNumbersSet: MutableSet = HashSet() + var uniqueNumbersSet: MutableSet = hashSetOf() for (uniqueGroup in groups) { if (uniqueNumbersSet.contains(uniqueGroup.groupNumber)) { manager.logError("A duplicate unique group with number %1s was found for %1s", uniqueGroup.groupNumber, tableName) @@ -241,7 +243,7 @@ class TableDefinition(manager: ProcessorManager, element: TypeElement) : BaseTab } val indexGroups = table.indexGroups - uniqueNumbersSet = HashSet() + uniqueNumbersSet = hashSetOf() for (indexGroup in indexGroups) { if (uniqueNumbersSet.contains(indexGroup.number)) { manager.logError(TableDefinition::class, "A duplicate unique index number %1s was found for %1s", indexGroup.number, elementName) diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/UniqueGroupsDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/UniqueGroupsDefinition.kt index 92068afb4..cb84d3647 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/UniqueGroupsDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/UniqueGroupsDefinition.kt @@ -6,14 +6,13 @@ import com.raizlabs.android.dbflow.processor.definition.column.ColumnDefinition import com.raizlabs.android.dbflow.processor.definition.column.ReferenceColumnDefinition import com.raizlabs.android.dbflow.quote import com.squareup.javapoet.CodeBlock -import java.util.* /** * Description: */ class UniqueGroupsDefinition(uniqueGroup: UniqueGroup) { - var columnDefinitionList: MutableList = ArrayList() + var columnDefinitionList: MutableList = arrayListOf() var number: Int = uniqueGroup.groupNumber diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ColumnAccessor.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ColumnAccessor.kt index fc148e86b..180eee6e1 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ColumnAccessor.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ColumnAccessor.kt @@ -8,7 +8,6 @@ import com.raizlabs.android.dbflow.processor.utils.lower import com.squareup.javapoet.ClassName import com.squareup.javapoet.CodeBlock import com.squareup.javapoet.TypeName -import java.util.* val modelBlock: CodeBlock = CodeBlock.of("model") @@ -61,14 +60,14 @@ class VisibleScopeColumnAccessor(propertyName: String) : ColumnAccessor(property val codeBlock: CodeBlock.Builder = CodeBlock.builder() baseVariableName?.let { codeBlock.add("\$L.", baseVariableName) } return codeBlock.add("\$L = \$L", propertyName, existingBlock) - .build() + .build() } override fun get(existingBlock: CodeBlock?): CodeBlock { val codeBlock: CodeBlock.Builder = CodeBlock.builder() existingBlock?.let { codeBlock.add("\$L.", existingBlock) } return codeBlock.add(propertyName) - .build() + .build() } } @@ -128,7 +127,7 @@ class PrivateScopeColumnAccessor(propertyName: String, getterSetter: GetterSette } class PackagePrivateScopeColumnAccessor( - propertyName: String, packageName: String, separator: String?, tableClassName: String) + propertyName: String, packageName: String, separator: String?, tableClassName: String) : ColumnAccessor(propertyName) { val helperClassName: ClassName @@ -141,16 +140,16 @@ class PackagePrivateScopeColumnAccessor( override fun get(existingBlock: CodeBlock?): CodeBlock { return CodeBlock.of("\$T.get\$L(\$L)", internalHelperClassName, - propertyName.capitalizeFirstLetter(), - existingBlock) + propertyName.capitalizeFirstLetter(), + existingBlock) } override fun set(existingBlock: CodeBlock?, baseVariableName: CodeBlock?, isDefault: Boolean): CodeBlock { return CodeBlock.of("\$T.set\$L(\$L, \$L)", helperClassName, - propertyName.capitalizeFirstLetter(), - baseVariableName, - existingBlock) + propertyName.capitalizeFirstLetter(), + baseVariableName, + existingBlock) } companion object { @@ -167,11 +166,7 @@ class PackagePrivateScopeColumnAccessor( * Ensures we only map and use a package private field generated access method if its necessary. */ fun putElement(className: ClassName, elementName: String) { - var list: MutableList? = methodWrittenMap[className] - if (list == null) { - list = ArrayList() - methodWrittenMap.put(className, list) - } + val list = methodWrittenMap.getOrPut(className) { arrayListOf() } if (!list.contains(elementName)) { list.add(elementName) } diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ReferenceColumnDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ReferenceColumnDefinition.kt index 37d99a802..09233e19f 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ReferenceColumnDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ReferenceColumnDefinition.kt @@ -32,7 +32,6 @@ import com.squareup.javapoet.NameAllocator import com.squareup.javapoet.ParameterizedTypeName import com.squareup.javapoet.TypeName import com.squareup.javapoet.TypeSpec -import java.util.* import java.util.concurrent.atomic.AtomicInteger import javax.lang.model.element.Element import javax.lang.model.element.Modifier @@ -46,7 +45,7 @@ class ReferenceColumnDefinition(manager: ProcessorManager, tableDefinition: Base element: Element, isPackagePrivate: Boolean) : ColumnDefinition(manager, element, tableDefinition, isPackagePrivate) { - val _referenceDefinitionList: MutableList = ArrayList() + val _referenceDefinitionList: MutableList = arrayListOf() var referencedClassName: ClassName? = null diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/utils/ElementUtility.kt b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/utils/ElementUtility.kt index 6257ac6df..5e377fe47 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/utils/ElementUtility.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/utils/ElementUtility.kt @@ -3,7 +3,6 @@ package com.raizlabs.android.dbflow.processor.utils import com.raizlabs.android.dbflow.annotation.ColumnIgnore import com.raizlabs.android.dbflow.processor.ProcessorManager import com.squareup.javapoet.ClassName -import java.util.* import javax.lang.model.element.Element import javax.lang.model.element.Modifier import javax.lang.model.element.TypeElement @@ -18,7 +17,7 @@ object ElementUtility { * @return real full-set of elements, including ones from super-class. */ fun getAllElements(element: TypeElement, manager: ProcessorManager): List { - val elements = ArrayList(manager.elements.getAllMembers(element)) + val elements = manager.elements.getAllMembers(element).toMutableList() var superMirror: TypeMirror? = null var typeElement: TypeElement? = element while (typeElement?.superclass.let { superMirror = it; it != null }) { @@ -37,14 +36,14 @@ object ElementUtility { fun isPackagePrivate(element: Element): Boolean { return !element.modifiers.contains(Modifier.PUBLIC) && !element.modifiers.contains(Modifier.PRIVATE) - && !element.modifiers.contains(Modifier.STATIC) + && !element.modifiers.contains(Modifier.STATIC) } fun isValidAllFields(allFields: Boolean, element: Element): Boolean { return allFields && element.kind.isField && - !element.modifiers.contains(Modifier.STATIC) && - !element.modifiers.contains(Modifier.FINAL) && - element.annotation() == null + !element.modifiers.contains(Modifier.STATIC) && + !element.modifiers.contains(Modifier.FINAL) && + element.annotation() == null } fun getClassName(elementClassname: String, manager: ProcessorManager): ClassName? { diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.kt index f2c19fd08..892e2a318 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.kt @@ -1,11 +1,10 @@ package com.raizlabs.android.dbflow.config -import com.raizlabs.android.dbflow.isNotNullOrEmpty -import com.raizlabs.android.dbflow.transaction.BaseTransactionManager -import com.raizlabs.android.dbflow.runtime.ModelNotifier import com.raizlabs.android.dbflow.database.DatabaseHelperListener import com.raizlabs.android.dbflow.database.OpenHelper -import java.util.* +import com.raizlabs.android.dbflow.isNotNullOrEmpty +import com.raizlabs.android.dbflow.runtime.ModelNotifier +import com.raizlabs.android.dbflow.transaction.BaseTransactionManager /** * Description: @@ -60,7 +59,7 @@ class DatabaseConfig( internal var openHelperCreator: ((DatabaseDefinition, DatabaseHelperListener?) -> OpenHelper)? = null internal var transactionManagerCreator: ((DatabaseDefinition) -> BaseTransactionManager)? = null internal var helperListener: DatabaseHelperListener? = null - internal val tableConfigMap: MutableMap, TableConfig<*>> = HashMap() + internal val tableConfigMap: MutableMap, TableConfig<*>> = hashMapOf() internal var modelNotifier: ModelNotifier? = null internal var inMemory = false internal var databaseName: String? = null diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.kt index fd15b3ab5..f85bb817c 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.kt @@ -2,31 +2,30 @@ package com.raizlabs.android.dbflow.config import android.content.ContentValues import android.content.Context -import com.raizlabs.android.dbflow.annotation.Database -import com.raizlabs.android.dbflow.annotation.QueryModel -import com.raizlabs.android.dbflow.annotation.Table -import com.raizlabs.android.dbflow.transaction.BaseTransactionManager -import com.raizlabs.android.dbflow.runtime.DirectModelNotifier -import com.raizlabs.android.dbflow.runtime.ModelNotifier -import com.raizlabs.android.dbflow.migration.Migration -import com.raizlabs.android.dbflow.adapter.queriable.ListModelLoader -import com.raizlabs.android.dbflow.adapter.queriable.SingleModelLoader -import com.raizlabs.android.dbflow.adapter.saveable.ModelSaver -import com.raizlabs.android.dbflow.structure.BaseModelView import com.raizlabs.android.dbflow.adapter.ModelAdapter import com.raizlabs.android.dbflow.adapter.ModelViewAdapter import com.raizlabs.android.dbflow.adapter.QueryModelAdapter +import com.raizlabs.android.dbflow.adapter.queriable.ListModelLoader +import com.raizlabs.android.dbflow.adapter.queriable.SingleModelLoader +import com.raizlabs.android.dbflow.adapter.saveable.ModelSaver +import com.raizlabs.android.dbflow.annotation.Database +import com.raizlabs.android.dbflow.annotation.QueryModel +import com.raizlabs.android.dbflow.annotation.Table import com.raizlabs.android.dbflow.database.DatabaseHelperListener import com.raizlabs.android.dbflow.database.DatabaseStatement import com.raizlabs.android.dbflow.database.DatabaseWrapper import com.raizlabs.android.dbflow.database.FlowCursor import com.raizlabs.android.dbflow.database.FlowSQLiteOpenHelper import com.raizlabs.android.dbflow.database.OpenHelper +import com.raizlabs.android.dbflow.migration.Migration +import com.raizlabs.android.dbflow.runtime.DirectModelNotifier +import com.raizlabs.android.dbflow.runtime.ModelNotifier +import com.raizlabs.android.dbflow.structure.BaseModelView +import com.raizlabs.android.dbflow.transaction.BaseTransactionManager import com.raizlabs.android.dbflow.transaction.DefaultTransactionManager import com.raizlabs.android.dbflow.transaction.DefaultTransactionQueue import com.raizlabs.android.dbflow.transaction.ITransaction import com.raizlabs.android.dbflow.transaction.Transaction -import java.util.* /** * Description: The main interface that all Database implementations extend from. This is for internal usage only @@ -70,13 +69,13 @@ abstract class DatabaseDefinition : DatabaseWrapper { * @return a list of all model classes in this database. */ val modelClasses: List> - get() = ArrayList(modelAdapters.keys) + get() = modelAdapters.keys.toList() /** * @return the [BaseModelView] list for this database. */ val modelViews: List> - get() = ArrayList(modelViewAdapterMap.keys) + get() = modelViewAdapterMap.keys.toList() /** * @return The list of [ModelViewAdapter]. Internal method for diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseHolder.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseHolder.kt index 9b7041b36..03eed762e 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseHolder.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseHolder.kt @@ -1,7 +1,6 @@ package com.raizlabs.android.dbflow.config import com.raizlabs.android.dbflow.converter.TypeConverter -import java.util.* /** * Description: The base interface for interacting with all of the database and top-level data that's shared @@ -9,15 +8,15 @@ import java.util.* */ abstract class DatabaseHolder { - val databaseDefinitionMap: MutableMap, DatabaseDefinition> = HashMap() - val databaseNameMap: MutableMap = HashMap() - val databaseClassLookupMap: MutableMap, DatabaseDefinition> = HashMap() + val databaseDefinitionMap: MutableMap, DatabaseDefinition> = hashMapOf() + val databaseNameMap: MutableMap = hashMapOf() + val databaseClassLookupMap: MutableMap, DatabaseDefinition> = hashMapOf() @JvmField - val typeConverters: MutableMap, TypeConverter<*, *>> = HashMap() + val typeConverters: MutableMap, TypeConverter<*, *>> = hashMapOf() val databaseDefinitions: List - get() = ArrayList(databaseNameMap.values) + get() = databaseNameMap.values.toList() /** * @param clazz The model value class to get a [com.raizlabs.android.dbflow.converter.TypeConverter] diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowConfig.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowConfig.kt index 340541dd9..9e324e713 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowConfig.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowConfig.kt @@ -1,7 +1,6 @@ package com.raizlabs.android.dbflow.config import android.content.Context -import java.util.* /** * Description: The main configuration instance for DBFlow. This @@ -12,7 +11,7 @@ class FlowConfig(val context: Context, val openDatabasesOnInit: Boolean = false) { internal constructor(builder: Builder) : this( - databaseHolders = Collections.unmodifiableSet(builder.databaseHolders), + databaseHolders = builder.databaseHolders.toSet(), databaseConfigMap = builder.databaseConfigMap, context = builder.context, openDatabasesOnInit = builder.openDatabasesOnInit @@ -25,8 +24,8 @@ class FlowConfig(val context: Context, class Builder(context: Context) { internal val context: Context = context.applicationContext - internal var databaseHolders: MutableSet> = HashSet() - internal val databaseConfigMap: MutableMap, DatabaseConfig> = HashMap() + internal var databaseHolders: MutableSet> = hashSetOf() + internal val databaseConfigMap: MutableMap, DatabaseConfig> = hashMapOf() internal var openDatabasesOnInit: Boolean = false fun addDatabaseHolder(databaseHolderClass: Class) = apply { diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt index 4107f4a60..69550cdf7 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt @@ -18,7 +18,6 @@ import com.raizlabs.android.dbflow.adapter.ModelViewAdapter import com.raizlabs.android.dbflow.adapter.QueryModelAdapter import com.raizlabs.android.dbflow.adapter.RetrievalAdapter import com.raizlabs.android.dbflow.database.DatabaseWrapper -import java.util.* import kotlin.reflect.KClass /** @@ -32,7 +31,7 @@ object FlowManager { private var globalDatabaseHolder = GlobalDatabaseHolder() - private val loadedModules = HashSet>() + private val loadedModules = hashSetOf>() private val DEFAULT_DATABASE_HOLDER_NAME = "GeneratedDatabaseHolder" diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/database/BaseDatabaseHelper.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/database/BaseDatabaseHelper.kt index 011416c1c..865f16105 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/database/BaseDatabaseHelper.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/database/BaseDatabaseHelper.kt @@ -8,7 +8,6 @@ import com.raizlabs.android.dbflow.config.NaturalOrderComparator import java.io.BufferedReader import java.io.IOException import java.io.InputStreamReader -import java.util.* /** * Description: @@ -51,16 +50,16 @@ open class BaseDatabaseHelper(val databaseDefinition: DatabaseDefinition) { try { database.beginTransaction() val modelAdapters = databaseDefinition.getModelAdapters() - for (modelAdapter in modelAdapters) { - if (modelAdapter.createWithDatabase()) { - try { - database.execSQL(modelAdapter.creationQuery) - } catch (e: SQLiteException) { - FlowLog.logError(e) + modelAdapters + .asSequence() + .filter { it.createWithDatabase() } + .forEach { + try { + database.execSQL(it.creationQuery) + } catch (e: SQLiteException) { + FlowLog.logError(e) + } } - - } - } database.setTransactionSuccessful() } finally { database.endTransaction() @@ -95,22 +94,18 @@ open class BaseDatabaseHelper(val databaseDefinition: DatabaseDefinition) { // will try migrations file or execute migrations from code try { - val files = Arrays.asList(*FlowManager.context.assets.list( - MIGRATION_PATH + "/" + databaseDefinition.databaseName)) - Collections.sort(files, NaturalOrderComparator()) + val files = FlowManager.context.assets.list( + "$MIGRATION_PATH/${databaseDefinition.databaseName}") + .sortedWith(NaturalOrderComparator()) val migrationFileMap = hashMapOf>() for (file in files) { try { val version = Integer.valueOf(file.replace(".sql", "")) - var fileList: MutableList? = migrationFileMap[version] - if (fileList == null) { - fileList = arrayListOf() - migrationFileMap.put(version, fileList) - } + val fileList = migrationFileMap.getOrPut(version) { arrayListOf() } fileList.add(file) } catch (e: NumberFormatException) { - FlowLog.log(FlowLog.Level.W, "Skipping invalidly named file: " + file, e) + FlowLog.log(FlowLog.Level.W, "Skipping invalidly named file: $file", e) } } @@ -128,7 +123,7 @@ open class BaseDatabaseHelper(val databaseDefinition: DatabaseDefinition) { if (migrationFiles != null) { for (migrationFile in migrationFiles) { executeSqlScript(db, migrationFile) - FlowLog.log(FlowLog.Level.I, migrationFile + " executed successfully.") + FlowLog.log(FlowLog.Level.I, "$migrationFile executed successfully.") } } @@ -143,7 +138,7 @@ open class BaseDatabaseHelper(val databaseDefinition: DatabaseDefinition) { // after migration cleanup migration.onPostMigrate() - FlowLog.log(FlowLog.Level.I, migration.javaClass.toString() + " executed successfully.") + FlowLog.log(FlowLog.Level.I, "${migration.javaClass} executed successfully.") } } } @@ -152,7 +147,7 @@ open class BaseDatabaseHelper(val databaseDefinition: DatabaseDefinition) { db.endTransaction() } } catch (e: IOException) { - FlowLog.log(FlowLog.Level.E, "Failed to execute migrations.", e) + FlowLog.log(FlowLog.Level.E, "Failed to execute migrations. App might be in an inconsistent state.", e) } } @@ -197,7 +192,7 @@ open class BaseDatabaseHelper(val databaseDefinition: DatabaseDefinition) { db.execSQL(queryString) } } catch (e: IOException) { - FlowLog.log(FlowLog.Level.E, "Failed to execute " + file, e) + FlowLog.log(FlowLog.Level.E, "Failed to execute $file. App might be in an inconsistent state!!", e) } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/migration/IndexMigration.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/migration/IndexMigration.kt index fff80bef2..1c996da71 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/migration/IndexMigration.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/migration/IndexMigration.kt @@ -1,9 +1,8 @@ package com.raizlabs.android.dbflow.migration +import com.raizlabs.android.dbflow.database.DatabaseWrapper import com.raizlabs.android.dbflow.query.index import com.raizlabs.android.dbflow.query.property.IProperty -import com.raizlabs.android.dbflow.database.DatabaseWrapper -import java.util.* /** * Description: Defines and enables an Index structurally through a migration. @@ -15,7 +14,7 @@ abstract class IndexMigration( private var onTable: Class) : BaseMigration() { private var unique: Boolean = false - private val columns: ArrayList> = arrayListOf() + private val columns = arrayListOf>() abstract val name: String diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/CompletedTrigger.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/CompletedTrigger.kt index db1d0b550..80b5d29e0 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/CompletedTrigger.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/CompletedTrigger.kt @@ -1,9 +1,8 @@ package com.raizlabs.android.dbflow.query import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.sql.Query import com.raizlabs.android.dbflow.dropTrigger -import java.util.* +import com.raizlabs.android.dbflow.sql.Query /** * Description: The last piece of a TRIGGER statement, this class contains the BEGIN...END and the logic in between. @@ -17,7 +16,7 @@ class CompletedTrigger internal constructor( /** * The query to run between the BEGIN and END of this statement */ - private val triggerLogicQuery = ArrayList() + private val triggerLogicQuery = arrayListOf() override val query: String get() = diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/From.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/From.kt index 4f013e410..a1766093f 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/From.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/From.kt @@ -6,7 +6,6 @@ import com.raizlabs.android.dbflow.query.Join.JoinType import com.raizlabs.android.dbflow.query.property.IndexProperty import com.raizlabs.android.dbflow.structure.ChangeAction import com.raizlabs.android.dbflow.database.DatabaseWrapper -import java.util.* import kotlin.collections.Set as KSet /** @@ -36,7 +35,7 @@ internal constructor( /** * Enables the SQL JOIN statement */ - private val joins = ArrayList>() + private val joins = arrayListOf>() override val primaryAction: ChangeAction get() = if (queryBuilderBase is Delete) ChangeAction.DELETE else ChangeAction.CHANGE diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Join.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Join.kt index f9d4f1103..7c4e42112 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Join.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Join.kt @@ -2,10 +2,9 @@ package com.raizlabs.android.dbflow.query import com.raizlabs.android.dbflow.appendList import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.sql.Query import com.raizlabs.android.dbflow.query.property.IProperty import com.raizlabs.android.dbflow.query.property.PropertyFactory -import java.util.* +import com.raizlabs.android.dbflow.sql.Query import kotlin.reflect.KClass /** @@ -38,7 +37,7 @@ class Join : Query { /** * What columns to use. */ - private val using = ArrayList>() + private val using = arrayListOf>() override// natural joins do no have on or using clauses. val query: String diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Method.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Method.kt index 509781770..1deb0fc30 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Method.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Method.kt @@ -1,11 +1,10 @@ package com.raizlabs.android.dbflow.query -import com.raizlabs.android.dbflow.sql.SQLiteType import com.raizlabs.android.dbflow.query.property.IProperty import com.raizlabs.android.dbflow.query.property.Property import com.raizlabs.android.dbflow.query.property.PropertyFactory -import java.util.* +import com.raizlabs.android.dbflow.sql.SQLiteType /** * Represents SQLite methods on columns. These act as [Property] so we can use them in complex @@ -13,8 +12,8 @@ import java.util.* */ class Method(methodName: String, vararg properties: IProperty<*>) : Property(null, null as String?) { - private val propertyList = ArrayList>() - private val operationsList = ArrayList() + private val propertyList = arrayListOf>() + private val operationsList = arrayListOf() private val methodProperty: IProperty<*> private var nameAlias: NameAlias? = null @@ -172,12 +171,10 @@ fun replace(property: IProperty<*>, findString: String, replacement: String): Me */ fun strftime(formatString: String, timeString: String, vararg modifiers: String): Method { - val propertyList = ArrayList>() + val propertyList = arrayListOf>() propertyList.add(PropertyFactory.from(formatString)) propertyList.add(PropertyFactory.from(timeString)) - for (modifier in modifiers) { - propertyList.add(PropertyFactory.from(modifier)) - } + modifiers.mapTo(propertyList) { PropertyFactory.from(it) } return Method("strftime", *propertyList.toTypedArray()) } @@ -196,11 +193,9 @@ fun datetime(timeStamp: Long, vararg modifiers: String): Method { */ fun date(timeString: String, vararg modifiers: String): Method { - val propertyList = ArrayList>() + val propertyList = arrayListOf>() propertyList.add(PropertyFactory.from(timeString)) - for (modifier in modifiers) { - propertyList.add(PropertyFactory.from(modifier)) - } + modifiers.mapTo(propertyList) { PropertyFactory.from(it) } return Method("date", *propertyList.toTypedArray()) } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Operator.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Operator.kt index 55aba8cfc..48342c28b 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Operator.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Operator.kt @@ -50,9 +50,7 @@ class Operator : BaseOperator, IOperator { queryBuilder.append(convertObjectToString(value(), true)) } - if (postArgument() != null) { - queryBuilder.append(" ${postArgument()}") - } + postArgument()?.let { queryBuilder.append(" $it") } } override fun isNull() = apply { @@ -88,7 +86,7 @@ class Operator : BaseOperator, IOperator { * @return This condition */ override fun like(value: String): Operator { - operation = String.format(" %1s ", Operation.LIKE) + operation = " ${Operation.LIKE} " return value(value) } @@ -103,7 +101,7 @@ class Operator : BaseOperator, IOperator { * @return This condition */ override fun notLike(value: String): Operator { - operation = String.format(" %1s ", Operation.NOT_LIKE) + operation = " ${Operation.NOT_LIKE} " return value(value) } @@ -118,7 +116,7 @@ class Operator : BaseOperator, IOperator { * @return This condition */ override fun glob(value: String): Operator { - operation = String.format(" %1s ", Operation.GLOB) + operation = " ${Operation.GLOB} " return value(value) } @@ -180,7 +178,7 @@ class Operator : BaseOperator, IOperator { * @return This condition. */ fun collate(collation: String) = apply { - postArg = "COLLATE " + collation + postArg = "COLLATE $collation" } /** @@ -392,33 +390,33 @@ class Operator : BaseOperator, IOperator { /** * Equals comparison */ - val EQUALS = "=" + const val EQUALS = "=" /** * Not-equals comparison */ - val NOT_EQUALS = "!=" + const val NOT_EQUALS = "!=" /** * String concatenation */ - val CONCATENATE = "||" + const val CONCATENATE = "||" /** * Number addition */ - val PLUS = "+" + const val PLUS = "+" /** * Number subtraction */ - val MINUS = "-" + const val MINUS = "-" - val DIVISION = "/" + const val DIVISION = "/" - val MULTIPLY = "*" + const val MULTIPLY = "*" - val MOD = "%" + const val MOD = "%" /** * If something is LIKE another (a case insensitive search). @@ -426,7 +424,7 @@ class Operator : BaseOperator, IOperator { * % represents [0,many) numbers or characters. * The _ represents a single number or character. */ - val LIKE = "LIKE" + const val LIKE = "LIKE" /** * If something is NOT LIKE another (a case insensitive search). @@ -434,7 +432,7 @@ class Operator : BaseOperator, IOperator { * % represents [0,many) numbers or characters. * The _ represents a single number or character. */ - val NOT_LIKE = "NOT LIKE" + const val NOT_LIKE = "NOT LIKE" /** * If something is case sensitive like another. @@ -443,71 +441,71 @@ class Operator : BaseOperator, IOperator { * * represents [0,many) numbers or characters. * The ? represents a single number or character */ - val GLOB = "GLOB" + const val GLOB = "GLOB" /** * Greater than some value comparison */ - val GREATER_THAN = ">" + const val GREATER_THAN = ">" /** * Greater than or equals to some value comparison */ - val GREATER_THAN_OR_EQUALS = ">=" + const val GREATER_THAN_OR_EQUALS = ">=" /** * Less than some value comparison */ - val LESS_THAN = "<" + const val LESS_THAN = "<" /** * Less than or equals to some value comparison */ - val LESS_THAN_OR_EQUALS = "<=" + const val LESS_THAN_OR_EQUALS = "<=" /** * Between comparison. A simplification of X<Y AND Y<Z to Y BETWEEN X AND Z */ - val BETWEEN = "BETWEEN" + const val BETWEEN = "BETWEEN" /** * AND comparison separator */ - val AND = "AND" + const val AND = "AND" /** * OR comparison separator */ - val OR = "OR" + const val OR = "OR" /** * An empty value for the condition. */ - val EMPTY_PARAM = "?" + const val EMPTY_PARAM = "?" /** * Special operation that specify if the column is not null for a specified row. Use of this as * an operator will ignore the value of the [Operator] for it. */ - val IS_NOT_NULL = "IS NOT NULL" + const val IS_NOT_NULL = "IS NOT NULL" /** * Special operation that specify if the column is null for a specified row. Use of this as * an operator will ignore the value of the [Operator] for it. */ - val IS_NULL = "IS NULL" + const val IS_NULL = "IS NULL" /** * The SQLite IN command that will select rows that are contained in a list of values. * EX: SELECT * from Table where column IN ('first', 'second', etc) */ - val IN = "IN" + const val IN = "IN" /** * The reverse of the [.IN] command that selects rows that are not contained * in a list of values specified. */ - val NOT_IN = "NOT IN" + const val NOT_IN = "NOT IN" } /** diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/OperatorGroup.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/OperatorGroup.kt index 5dc1bd13f..600409d46 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/OperatorGroup.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/OperatorGroup.kt @@ -2,7 +2,6 @@ package com.raizlabs.android.dbflow.query import com.raizlabs.android.dbflow.sql.Query import com.raizlabs.android.dbflow.query.Operator.Operation -import java.util.* /** * Allows combining of [SQLOperator] into one condition. @@ -11,7 +10,7 @@ class OperatorGroup @JvmOverloads constructor(columnName: NameAlias? = null) : BaseOperator(columnName), Query, Iterable { - private val conditionsList = ArrayList() + private val conditionsList = arrayListOf() private var internalQuery: String? = null private var isChanged: Boolean = false diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Where.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Where.kt index ce470454a..4c7a09743 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Where.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Where.kt @@ -3,10 +3,9 @@ package com.raizlabs.android.dbflow.query import android.database.Cursor import com.raizlabs.android.dbflow.annotation.provider.ContentProvider import com.raizlabs.android.dbflow.appendQualifier +import com.raizlabs.android.dbflow.database.FlowCursor import com.raizlabs.android.dbflow.query.property.IProperty import com.raizlabs.android.dbflow.structure.ChangeAction -import com.raizlabs.android.dbflow.database.FlowCursor -import java.util.* /** * Description: Defines the SQL WHERE statement of the query. @@ -31,9 +30,9 @@ internal constructor( */ private val operatorGroup: OperatorGroup = OperatorGroup.nonGroupingClause() - private val groupByList = ArrayList() + private val groupByList = arrayListOf() - private val orderByList = ArrayList() + private val orderByList = arrayListOf() /** * The SQL HAVING statement diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/list/FlowCursorList.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/list/FlowCursorList.kt index 405942d10..2677400d1 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/list/FlowCursorList.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/list/FlowCursorList.kt @@ -7,7 +7,6 @@ import com.raizlabs.android.dbflow.config.FlowManager import com.raizlabs.android.dbflow.query.ModelQueriable import com.raizlabs.android.dbflow.adapter.InstanceAdapter import com.raizlabs.android.dbflow.database.FlowCursor -import java.util.* /** * Description: A non-modifiable, cursor-backed list that you can use in [ListView] or other data sources. @@ -34,7 +33,7 @@ class FlowCursorList private constructor(builder: Builder) : IFlowCu internal val instanceAdapter: InstanceAdapter - private val cursorRefreshListenerSet = HashSet>() + private val cursorRefreshListenerSet = hashSetOf>() /** * @return the full, converted [T] list from the database on this list. For large diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DBBatchSaveQueue.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DBBatchSaveQueue.kt index e80bc0fa3..a86352d0f 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DBBatchSaveQueue.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DBBatchSaveQueue.kt @@ -4,13 +4,12 @@ import android.os.Looper import com.raizlabs.android.dbflow.config.DatabaseDefinition import com.raizlabs.android.dbflow.config.FlowLog import com.raizlabs.android.dbflow.structure.Model +import com.raizlabs.android.dbflow.structure.save import com.raizlabs.android.dbflow.transaction.ProcessModelTransaction import com.raizlabs.android.dbflow.transaction.Transaction import com.raizlabs.android.dbflow.transaction.processModel import com.raizlabs.android.dbflow.transaction.transactionError import com.raizlabs.android.dbflow.transaction.transactionSuccess -import com.raizlabs.android.dbflow.structure.save -import java.util.* /** * Description: This queue will bulk save items added to it when it gets access to the DB. It should only exist as one entity. @@ -35,7 +34,7 @@ internal constructor(private val databaseDefinition: DatabaseDefinition) : Threa /** * The list of DB objects that we will save here */ - private val models: ArrayList = arrayListOf() + private val models = arrayListOf() /** * If true, this queue will quit. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DirectModelNotifier.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DirectModelNotifier.kt index f729bb8a5..9d323b966 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DirectModelNotifier.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DirectModelNotifier.kt @@ -1,9 +1,8 @@ package com.raizlabs.android.dbflow.runtime +import com.raizlabs.android.dbflow.adapter.ModelAdapter import com.raizlabs.android.dbflow.config.DatabaseConfig import com.raizlabs.android.dbflow.structure.ChangeAction -import com.raizlabs.android.dbflow.adapter.ModelAdapter -import java.util.* /** * Description: Directly notifies about model changes. Users should use [.get] to use the shared @@ -99,7 +98,7 @@ private constructor() : ModelNotifier { } private inner class DirectTableNotifierRegister : TableNotifierRegister { - private val registeredTables = ArrayList>() + private val registeredTables = arrayListOf>() private var modelChangedListener: OnTableChangedListener? = null @@ -124,8 +123,8 @@ private constructor() : ModelNotifier { this.modelChangedListener = null } - override fun setListener(modelChangedListener: OnTableChangedListener?) { - this.modelChangedListener = modelChangedListener + override fun setListener(listener: OnTableChangedListener?) { + this.modelChangedListener = listener } override val isSubscribed: Boolean diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/FlowContentObserver.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/FlowContentObserver.kt index 50e186801..874349c71 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/FlowContentObserver.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/FlowContentObserver.kt @@ -17,7 +17,6 @@ import com.raizlabs.android.dbflow.query.Operator import com.raizlabs.android.dbflow.query.SQLOperator import com.raizlabs.android.dbflow.structure.ChangeAction import com.raizlabs.android.dbflow.structure.Model -import java.util.* import java.util.concurrent.CopyOnWriteArraySet import java.util.concurrent.atomic.AtomicInteger @@ -35,9 +34,9 @@ open class FlowContentObserver(private val contentAuthority: String, private val modelChangeListeners = CopyOnWriteArraySet() private val onTableChangedListeners = CopyOnWriteArraySet() - private val registeredTables = HashMap>() - private val notificationUris = HashSet() - private val tableUris = HashSet() + private val registeredTables = hashMapOf>() + private val notificationUris = hashSetOf() + private val tableUris = hashSetOf() protected var isInTransaction = false private var notifyAllUris = false diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/FastStoreModelTransaction.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/FastStoreModelTransaction.kt index 996158157..68fae7fda 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/FastStoreModelTransaction.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/FastStoreModelTransaction.kt @@ -4,7 +4,6 @@ import com.raizlabs.android.dbflow.adapter.InternalAdapter import com.raizlabs.android.dbflow.config.modelAdapter import com.raizlabs.android.dbflow.database.DatabaseWrapper import com.raizlabs.android.dbflow.structure.Model -import java.util.* /** * Description: Simple interface for acting on a model in a Transaction or list of [Model] @@ -42,7 +41,7 @@ class FastStoreModelTransaction internal constructor(builder: Builder */ class Builder internal constructor(internal val internalAdapter: InternalAdapter, internal val processModelList: ProcessModelList) { - internal var models: MutableList = ArrayList() + internal var models: MutableList = arrayListOf() fun add(model: TModel) = apply { models.add(model) diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/TransactionWrapper.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/TransactionWrapper.kt index 1fb5844a4..8799cb9b4 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/TransactionWrapper.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/TransactionWrapper.kt @@ -1,17 +1,16 @@ package com.raizlabs.android.dbflow.transaction import com.raizlabs.android.dbflow.database.DatabaseWrapper -import java.util.* /** * Description: Wraps multiple transactions together. */ class TransactionWrapper : ITransaction { - private val transactions = ArrayList>() + private val transactions = arrayListOf>() constructor(vararg transactions: ITransaction) { - this.transactions.addAll(Arrays.asList(*transactions)) + this.transactions.addAll(transactions) } constructor(transactions: Collection>) { From 22f93a3cc0c58fdf358d866ab3f2d803c1e58a33 Mon Sep 17 00:00:00 2001 From: fuzzagrosner Date: Fri, 1 Dec 2017 15:42:21 -0500 Subject: [PATCH 101/234] [query] fold in extension functions into class definition for operator. update kotlin to 1.2 --- build.gradle | 2 +- .../raizlabs/android/dbflow/query/Operator.kt | 20 +++++-------------- 2 files changed, 6 insertions(+), 16 deletions(-) diff --git a/build.gradle b/build.gradle index 9e583f603..1bf727a43 100644 --- a/build.gradle +++ b/build.gradle @@ -1,5 +1,5 @@ buildscript { - ext.kotlin_version = '1.1.61' + ext.kotlin_version = '1.2.0' repositories { jcenter() google() diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Operator.kt b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Operator.kt index 48342c28b..a26de9464 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Operator.kt +++ b/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Operator.kt @@ -177,7 +177,7 @@ class Operator : BaseOperator, IOperator { * @param collation The SQLite collate function * @return This condition. */ - fun collate(collation: String) = apply { + infix fun collate(collation: String) = apply { postArg = "COLLATE $collation" } @@ -187,7 +187,7 @@ class Operator : BaseOperator, IOperator { * @param collation The SQLite collate function * @return This condition. */ - fun collate(collation: Collate) = apply { + infix fun collate(collation: Collate) = apply { if (collation == Collate.NONE) { postArg = null } else { @@ -198,7 +198,7 @@ class Operator : BaseOperator, IOperator { /** * Appends an optional SQL string to the end of this condition */ - fun postfix(postfix: String) = apply { + infix fun postfix(postfix: String) = apply { postArg = postfix } @@ -532,7 +532,7 @@ class Operator : BaseOperator, IOperator { this.postArg = operator.postArgument() } - fun and(secondValue: T?) = apply { + infix fun and(secondValue: T?) = apply { this.secondValue = secondValue } @@ -586,7 +586,7 @@ class Operator : BaseOperator, IOperator { * in a [OperatorGroup]. * @return */ - fun and(argument: T?): In { + infix fun and(argument: T?): In { inArguments.add(argument) return this } @@ -620,16 +620,6 @@ fun NameAlias.op() = Operator.op(this) fun String.op(): Operator = nameAlias.op() -infix fun Operator.collate(collation: Collate): BaseOperator = collate(collation) - -infix fun Operator.collate(collation: String): BaseOperator = collate(collation) - -infix fun Operator.postfix(collation: String): BaseOperator = postfix(collation) - -infix fun Operator.Between.and(value: T?): BaseOperator = and(value) - -infix fun Operator.In.and(value: T?): BaseOperator = and(value) - infix fun Operator.and(sqlOperator: SQLOperator): OperatorGroup = OperatorGroup.clause(this).and(sqlOperator) From d7e2199de8ed359361d498f256757aa5c46ea281 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sun, 3 Dec 2017 16:10:21 -0500 Subject: [PATCH 102/234] [coroutines] make coroutines a separate artifact. --- dbflow-coroutines/.gitignore | 1 + dbflow-coroutines/build.gradle | 29 +++++++++++++++++++ dbflow-coroutines/proguard-rules.pro | 21 ++++++++++++++ .../src/main/AndroidManifest.xml | 2 ++ .../raizlabs/dbflow/coroutines}/Coroutines.kt | 9 ++++-- dbflow-tests/build.gradle | 1 + .../database/transaction/CoroutinesTest.kt | 10 +++---- .../FastStoreModelTransactionTest.kt | 6 ++-- dbflow/build.gradle | 6 ---- settings.gradle | 2 +- 10 files changed, 70 insertions(+), 17 deletions(-) create mode 100644 dbflow-coroutines/.gitignore create mode 100644 dbflow-coroutines/build.gradle create mode 100644 dbflow-coroutines/proguard-rules.pro create mode 100644 dbflow-coroutines/src/main/AndroidManifest.xml rename {dbflow/src/main/java/com/raizlabs/android/dbflow/transaction => dbflow-coroutines/src/main/java/com/raizlabs/dbflow/coroutines}/Coroutines.kt (92%) diff --git a/dbflow-coroutines/.gitignore b/dbflow-coroutines/.gitignore new file mode 100644 index 000000000..796b96d1c --- /dev/null +++ b/dbflow-coroutines/.gitignore @@ -0,0 +1 @@ +/build diff --git a/dbflow-coroutines/build.gradle b/dbflow-coroutines/build.gradle new file mode 100644 index 000000000..8e5feab59 --- /dev/null +++ b/dbflow-coroutines/build.gradle @@ -0,0 +1,29 @@ +apply plugin: 'com.android.library' +apply plugin: 'kotlin-android' + +android { + compileSdkVersion 26 + defaultConfig { + minSdkVersion 15 + targetSdkVersion 26 + } + + buildTypes { + release { + minifyEnabled false + proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro' + } + } + +} + +dependencies { + implementation project("${dbflow_project_prefix}dbflow") +} + +kotlin { + experimental { + coroutines 'enable' + } +} + diff --git a/dbflow-coroutines/proguard-rules.pro b/dbflow-coroutines/proguard-rules.pro new file mode 100644 index 000000000..f1b424510 --- /dev/null +++ b/dbflow-coroutines/proguard-rules.pro @@ -0,0 +1,21 @@ +# Add project specific ProGuard rules here. +# You can control the set of applied configuration files using the +# proguardFiles setting in build.gradle. +# +# For more details, see +# http://developer.android.com/guide/developing/tools/proguard.html + +# If your project uses WebView with JS, uncomment the following +# and specify the fully qualified class name to the JavaScript interface +# class: +#-keepclassmembers class fqcn.of.javascript.interface.for.webview { +# public *; +#} + +# Uncomment this to preserve the line number information for +# debugging stack traces. +#-keepattributes SourceFile,LineNumberTable + +# If you keep the line number information, uncomment this to +# hide the original source file name. +#-renamesourcefileattribute SourceFile diff --git a/dbflow-coroutines/src/main/AndroidManifest.xml b/dbflow-coroutines/src/main/AndroidManifest.xml new file mode 100644 index 000000000..15f15db30 --- /dev/null +++ b/dbflow-coroutines/src/main/AndroidManifest.xml @@ -0,0 +1,2 @@ + diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/Coroutines.kt b/dbflow-coroutines/src/main/java/com/raizlabs/dbflow/coroutines/Coroutines.kt similarity index 92% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/Coroutines.kt rename to dbflow-coroutines/src/main/java/com/raizlabs/dbflow/coroutines/Coroutines.kt index ba8ce0ca6..8a4885ec6 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/Coroutines.kt +++ b/dbflow-coroutines/src/main/java/com/raizlabs/dbflow/coroutines/Coroutines.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.transaction +package com.raizlabs.dbflow.coroutines import com.raizlabs.android.dbflow.config.DatabaseDefinition import com.raizlabs.android.dbflow.query.Queriable @@ -7,6 +7,11 @@ import com.raizlabs.android.dbflow.structure.insert import com.raizlabs.android.dbflow.structure.load import com.raizlabs.android.dbflow.structure.save import com.raizlabs.android.dbflow.structure.update +import com.raizlabs.android.dbflow.transaction.FastStoreModelTransaction +import com.raizlabs.android.dbflow.transaction.fastDelete +import com.raizlabs.android.dbflow.transaction.fastInsert +import com.raizlabs.android.dbflow.transaction.fastSave +import com.raizlabs.android.dbflow.transaction.fastUpdate import kotlinx.coroutines.experimental.CancellableContinuation import kotlinx.coroutines.experimental.suspendCancellableCoroutine @@ -18,7 +23,7 @@ inline suspend fun DatabaseDefinition.transact( modelQueriable: Q, crossinline queriableFunction: Q.() -> R) = suspendCancellableCoroutine { continuation -> - constructCoroutine(continuation, this) { queriableFunction(modelQueriable) } + com.raizlabs.dbflow.coroutines.constructCoroutine(continuation, this) { queriableFunction(modelQueriable) } } inline fun constructCoroutine(continuation: CancellableContinuation, diff --git a/dbflow-tests/build.gradle b/dbflow-tests/build.gradle index 10f92b92f..095cd21dd 100644 --- a/dbflow-tests/build.gradle +++ b/dbflow-tests/build.gradle @@ -52,6 +52,7 @@ dependencies { implementation project("${dbflow_project_prefix}dbflow-sqlcipher") implementation project("${dbflow_project_prefix}dbflow-rx") implementation project("${dbflow_project_prefix}dbflow-rx2") + implementation project("${dbflow_project_prefix}dbflow-coroutines") kaptTest project("${dbflow_project_prefix}dbflow-processor") kaptAndroidTest project("${dbflow_project_prefix}dbflow-processor") diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/CoroutinesTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/CoroutinesTest.kt index 0ed42d447..906771c42 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/CoroutinesTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/CoroutinesTest.kt @@ -10,11 +10,11 @@ import com.raizlabs.android.dbflow.query.list import com.raizlabs.android.dbflow.query.select import com.raizlabs.android.dbflow.query.where import com.raizlabs.android.dbflow.structure.save -import com.raizlabs.android.dbflow.transaction.awaitDelete -import com.raizlabs.android.dbflow.transaction.awaitInsert -import com.raizlabs.android.dbflow.transaction.awaitSave -import com.raizlabs.android.dbflow.transaction.awaitUpdate -import com.raizlabs.android.dbflow.transaction.transact +import com.raizlabs.dbflow.coroutines.awaitDelete +import com.raizlabs.dbflow.coroutines.awaitInsert +import com.raizlabs.dbflow.coroutines.awaitSave +import com.raizlabs.dbflow.coroutines.awaitUpdate +import com.raizlabs.dbflow.coroutines.transact import kotlinx.coroutines.experimental.runBlocking import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/FastStoreModelTransactionTest.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/FastStoreModelTransactionTest.kt index 8b988520a..04c8f8ce9 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/FastStoreModelTransactionTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/FastStoreModelTransactionTest.kt @@ -7,9 +7,9 @@ import com.raizlabs.android.dbflow.models.SimpleModel import com.raizlabs.android.dbflow.models.TwoColumnModel import com.raizlabs.android.dbflow.query.list import com.raizlabs.android.dbflow.query.select -import com.raizlabs.android.dbflow.transaction.awaitInsert -import com.raizlabs.android.dbflow.transaction.awaitSave -import com.raizlabs.android.dbflow.transaction.awaitUpdate +import com.raizlabs.dbflow.coroutines.awaitInsert +import com.raizlabs.dbflow.coroutines.awaitSave +import com.raizlabs.dbflow.coroutines.awaitUpdate import kotlinx.coroutines.experimental.runBlocking import org.junit.Assert.assertEquals import org.junit.Assert.assertNotEquals diff --git a/dbflow/build.gradle b/dbflow/build.gradle index 6875164d2..32e403de3 100644 --- a/dbflow/build.gradle +++ b/dbflow/build.gradle @@ -31,11 +31,5 @@ dependencies { api "org.jetbrains.kotlinx:kotlinx-coroutines-core:0.19.2" } -kotlin { - experimental { - coroutines 'enable' - } -} - apply from: '../android-artifacts.gradle' diff --git a/settings.gradle b/settings.gradle index 07d1e7b2e..6e1a455aa 100644 --- a/settings.gradle +++ b/settings.gradle @@ -1,4 +1,4 @@ -include ':dbflow', ':dbflow-rx2', +include ':dbflow', ':dbflow-rx2', ':dbflow-coroutines', ':dbflow-processor', ':dbflow-core', ':dbflow-sqlcipher', From 5b4087d12c4e48b413a0ce35734e4ac06b3bc64e Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sun, 3 Dec 2017 16:13:20 -0500 Subject: [PATCH 103/234] remove usage2 as submodule. will add back as subtree. --- usage2 | 1 - 1 file changed, 1 deletion(-) delete mode 160000 usage2 diff --git a/usage2 b/usage2 deleted file mode 160000 index 76b48d64b..000000000 --- a/usage2 +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 76b48d64bf3f1e5256a7003d2230a29e2fb07c7a From beb755bad0f89acc72457a677cf2fdb05d72038e Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sun, 3 Dec 2017 16:36:02 -0500 Subject: [PATCH 104/234] moved packages to com.raizlabs.dbflow5 --- dbflow-core/build.gradle | 2 +- .../raizlabs/android/dbflow/sql/SQLiteType.kt | 67 ------------------ .../dbflow => dbflow5}/StringUtils.kt | 6 +- .../dbflow => dbflow5}/annotation/Collate.kt | 2 +- .../dbflow => dbflow5}/annotation/Column.kt | 5 +- .../annotation/ColumnIgnore.kt | 2 +- .../annotation/ColumnMap.kt | 2 +- .../annotation/ColumnMapReference.kt | 2 +- .../annotation/ConflictAction.kt | 2 +- .../dbflow => dbflow5}/annotation/Database.kt | 4 +- .../annotation/ForeignKey.kt | 2 +- .../annotation/ForeignKeyAction.kt | 2 +- .../annotation/ForeignKeyReference.kt | 2 +- .../dbflow => dbflow5}/annotation/Index.kt | 2 +- .../annotation/IndexGroup.kt | 2 +- .../annotation/InheritedColumn.kt | 5 +- .../annotation/InheritedPrimaryKey.kt | 2 +- .../annotation/ManyToMany.kt | 2 +- .../annotation/Migration.kt | 2 +- .../annotation/ModelCacheField.kt | 2 +- .../annotation/ModelView.kt | 4 +- .../annotation/ModelViewQuery.kt | 4 +- .../annotation/MultiCacheField.kt | 2 +- .../annotation/MultipleManyToMany.kt | 4 +- .../dbflow => dbflow5}/annotation/NotNull.kt | 4 +- .../annotation/OneToMany.kt | 2 +- .../annotation/PrimaryKey.kt | 2 +- .../annotation/QueryModel.kt | 2 +- .../dbflow => dbflow5}/annotation/Table.kt | 2 +- .../annotation/TypeConverter.kt | 2 +- .../dbflow => dbflow5}/annotation/Unique.kt | 4 +- .../annotation/UniqueGroup.kt | 4 +- .../annotation/provider/ContentProvider.kt | 2 +- .../annotation/provider/ContentUri.kt | 2 +- .../annotation/provider/Notify.kt | 2 +- .../annotation/provider/TableEndpoint.kt | 2 +- .../converter/TypeConverters.kt | 8 +-- .../{android/dbflow => dbflow5}/data/Blob.kt | 2 +- .../{android/dbflow => dbflow5}/sql/Query.kt | 2 +- .../com/raizlabs/dbflow5/sql/SQLiteType.kt | 67 ++++++++++++++++++ dbflow-coroutines/build.gradle | 2 +- .../src/main/AndroidManifest.xml | 3 +- .../coroutines/Coroutines.kt | 30 ++++---- .../dbflow/processor/ClassNames.kt | 6 +- .../dbflow/processor/DBFlowProcessor.kt | 22 +++--- .../dbflow/processor/Handlers.kt | 62 ++++++++-------- .../dbflow/processor/ProcessorManager.kt | 30 ++++---- .../dbflow/processor/ProcessorUtils.kt | 10 +-- .../dbflow/processor/SQLiteHelper.kt | 4 +- .../dbflow/processor/Validators.kt | 16 ++--- .../dbflow/processor/definition/Adders.kt | 2 +- .../processor/definition/BaseDefinition.kt | 14 ++-- .../definition/BaseTableDefinition.kt | 22 +++--- .../processor/definition/ContentProvider.kt | 26 +++---- .../definition/DatabaseDefinition.kt | 18 ++--- .../definition/DatabaseHolderDefinition.kt | 8 +-- .../definition/DatabaseObjectHolder.kt | 2 +- .../definition/IndexGroupsDefinition.kt | 8 +-- .../definition/ManyToManyDefinition.kt | 24 +++---- .../dbflow/processor/definition/Methods.kt | 16 ++--- .../definition/MigrationDefinition.kt | 10 +-- .../definition/ModelViewDefinition.kt | 40 +++++------ .../processor/definition/NotifyDefinition.kt | 12 ++-- .../definition/OneToManyDefinition.kt | 36 +++++----- .../definition/QueryModelDefinition.kt | 28 ++++---- .../processor/definition/TableDefinition.kt | 70 +++++++++---------- .../definition/TableEndpointDefinition.kt | 16 ++--- .../definition/TypeConverterDefinition.kt | 10 +-- .../processor/definition/TypeDefinition.kt | 2 +- .../definition/UniqueGroupsDefinition.kt | 12 ++-- .../definition/column/ColumnAccessCombiner.kt | 16 ++--- .../definition/column/ColumnAccessor.kt | 10 +-- .../definition/column/ColumnDefinition.kt | 46 ++++++------ .../definition/column/DefinitionUtils.kt | 6 +- .../column/ForeignKeyAccessCombiner.kt | 8 +-- .../column/ReferenceColumnDefinition.kt | 44 ++++++------ .../definition/column/ReferenceDefinition.kt | 18 ++--- .../dbflow/processor/utils/CodeExtensions.kt | 2 +- .../dbflow/processor/utils/DependencyUtils.kt | 4 +- .../processor/utils/ElementExtensions.kt | 4 +- .../dbflow/processor/utils/ElementUtility.kt | 6 +- .../processor/utils/JavaPoetExtensions.kt | 2 +- .../dbflow/processor/utils/ModelUtils.kt | 2 +- .../dbflow/processor/utils/ProcessorUtils.kt | 6 +- .../dbflow/processor/utils/StringUtils.kt | 2 +- .../dbflow/processor/utils/WriterUtils.kt | 6 +- .../javax.annotation.processing.Processor | 2 +- .../test/ColumnAccessCombinerTests.kt | 6 +- .../test/ForeignKeyAccessCombinerTests.kt | 24 +++---- .../test/SimpleColumnAccessorTests.kt | 8 +-- dbflow-rx/src/main/AndroidManifest.xml | 6 +- .../rx/query/CursorResultSubscriber.kt | 6 +- .../rx/query/RXModelQueriable.kt | 16 ++--- .../rx/query/RXModelQueriableImpl.kt | 12 ++-- .../rx/query/RXQueriable.kt | 14 ++-- .../rx/query/RXQueriableImpl.kt | 8 +-- .../dbflow => dbflow5}/rx/query/RXSQLite.kt | 8 +-- .../rx/query/TableChangeListenerEmitter.java | 18 ++--- .../rx/structure/BaseRXModel.kt | 16 ++--- .../rx/structure/RXModelAdapter.kt | 8 +-- .../rx/structure/RXRetrievalAdapter.kt | 8 +-- .../rx/transaction/TransactionObservable.kt | 6 +- dbflow-rx2/build.gradle | 1 - dbflow-rx2/src/main/AndroidManifest.xml | 6 +- .../rx2/query/CursorResultFlowable.kt | 6 +- .../rx2/query/RXModelQueriable.kt | 16 ++--- .../rx2/query/RXModelQueriableImpl.kt | 12 ++-- .../rx2/query/RXQueriable.kt | 14 ++-- .../rx2/query/RXQueriableImpl.kt | 8 +-- .../dbflow => dbflow5}/rx2/query/RXSQLite.kt | 6 +- .../rx2/query/TableChangeOnSubscribe.kt | 20 +++--- .../rx2/structure/BaseRXModel.kt | 16 ++--- .../rx2/structure/RXModelAdapter.kt | 8 +-- .../rx2/structure/RXRetrievalAdapter.kt | 8 +-- .../rx2/transaction/TransactionObservable.kt | 6 +- dbflow-sqlcipher/build.gradle | 1 - dbflow-sqlcipher/src/main/AndroidManifest.xml | 4 +- .../sqlcipher/SQLCipherDatabase.kt | 8 +-- .../sqlcipher/SQLCipherOpenHelper.kt | 18 ++--- .../sqlcipher/SQLCipherStatement.kt | 6 +- .../src/androidTest/AndroidManifest.xml | 6 +- .../dbflow/BaseUnitTest.kt | 2 +- .../dbflow/DBFlowInstrumentedTestRule.kt | 16 ++--- .../dbflow/ImmediateTransactionManager.kt | 10 +-- .../contentobserver/ContentObserverTest.kt | 36 +++++----- .../dbflow/prepackaged/PrepackagedDBTest.kt | 8 +-- .../sqlcipher/CipherTest.kt | 11 ++- dbflow-tests/src/main/AndroidManifest.xml | 8 +-- .../android/dbflow/contentobserver/User.kt | 9 --- .../dbflow/prepackaged/PrepackagedDB.kt | 25 ------- .../dbflow/sqlcipher/CipherDatabase.kt | 9 --- .../dbflow/AppDatabase.kt | 4 +- .../{android => dbflow5}/dbflow/DemoApp.kt | 2 +- .../dbflow/StubContentProvider.kt | 2 +- .../{android => dbflow5}/dbflow/User.kt | 8 +-- .../dbflow5/dbflow/contentobserver/User.kt | 9 +++ .../dbflow/prepackaged/PrepackagedDB.kt | 25 +++++++ .../dbflow/test/DemoActivity.java | 10 +-- .../dbflow5/sqlcipher/CipherDatabase.kt | 9 +++ .../sqlcipher/CipherTestObjects.kt | 14 ++-- dbflow-tests/src/main/res/menu/menu_demo.xml | 2 +- dbflow-tests/src/test/AndroidManifest.xml | 6 +- .../dbflow/models/InnerClassExample.kt | 14 ---- .../models/NonTypical/nonTypicalClassName.kt | 11 --- .../android/dbflow/models/issue/Page.java | 25 ------- .../dbflow/models/java/JavaModelView.java | 26 ------- .../java/otherpackage/ExampleModel.java | 12 ---- .../android/dbflow/rx/query/RxModels.kt | 13 ---- .../dbflow/BaseUnitTest.kt | 2 +- .../dbflow/DBFlowTestRule.kt | 10 +-- .../dbflow/ImmediateTransactionManager.kt | 10 +-- .../dbflow/TestDatabase.kt | 10 +-- .../dbflow/TestExtensions.kt | 4 +- .../dbflow/config/ConfigIntegrationTest.kt | 21 +++--- .../dbflow/config/DatabaseConfigTest.kt | 17 +++-- .../database/transaction/CoroutinesTest.kt | 30 ++++---- .../FastStoreModelTransactionTest.kt | 26 ++++--- .../migration/UpdateTableMigrationTest.kt | 11 +-- .../dbflow/models/AutoIncrementTest.kt | 12 ++-- .../dbflow/models/CachingModels.kt | 16 ++--- .../dbflow/models/CachingModelsTest.kt | 15 ++-- .../dbflow/models/DontCreateModelTest.kt | 10 ++- .../dbflow/models/ForeignKeyModels.kt | 26 +++---- .../dbflow/models/IndexModels.kt | 14 ++-- .../dbflow/models/InnerClassExample.kt | 14 ++++ .../dbflow/models/ManyToMany.kt | 12 ++-- .../dbflow/models/ManyToManyTest.kt | 6 +- .../dbflow/models/ModelViewTest.kt | 12 ++-- .../dbflow/models/ModelViews.kt | 21 +++--- .../models/NonTypical/nonTypicalClassName.kt | 11 +++ .../dbflow/models/OneToManyModelTest.kt | 19 +++-- .../dbflow/models/OneToManyModels.kt | 26 ++++--- .../dbflow/models/ParentChildCachingTest.kt | 14 ++-- .../dbflow/models/QueryModelTest.kt | 21 +++--- .../dbflow/models/QueryModels.kt | 14 ++-- .../dbflow/models/SimpleTestModels.kt | 34 ++++----- .../dbflow/models/issue/Issue.java | 18 ++--- .../dbflow5/dbflow/models/issue/Page.java | 25 +++++++ .../dbflow/models/issue/SubIssue.java | 18 ++--- .../dbflow/models/java/DatabaseModel.java | 6 +- .../dbflow/models/java/JavaModelView.java | 26 +++++++ .../java/otherpackage/ExampleModel.java | 12 ++++ .../dbflow/provider/ContentProviderObjects.kt | 27 +++---- .../dbflow/provider/ContentProviderTests.kt | 24 +++---- .../dbflow/provider/RealContentProvider.kt | 10 +-- .../dbflow/provider/TestContentProvider.kt | 20 +++--- .../dbflow/query/cache/ModelLruCacheTest.kt | 7 +- .../dbflow/query/cache/SimpleMapCacheTest.kt | 7 +- .../query/list/FlowCursorIteratorTest.kt | 11 ++- .../dbflow/query/list/FlowCursorListTest.kt | 13 ++-- .../dbflow/runtime/DirectNotifierTest.kt | 40 ++++++----- .../dbflow/sql/language/CaseTest.kt | 12 ++-- .../dbflow/sql/language/CursorResultTest.kt | 24 +++---- .../dbflow/sql/language/DeleteTest.kt | 16 ++--- .../sql/language/ExistenceOperatorTest.kt | 14 ++-- .../dbflow/sql/language/FromTest.kt | 19 +++-- .../dbflow/sql/language/IndexTest.kt | 14 ++-- .../dbflow/sql/language/IndexedByTest.kt | 13 ++-- .../dbflow/sql/language/InsertTest.kt | 25 ++++--- .../dbflow/sql/language/JoinTest.kt | 21 ++---- .../dbflow/sql/language/MethodTest.kt | 38 +++++----- .../dbflow/sql/language/NameAliasTest.kt | 10 +-- .../dbflow/sql/language/OperatorGroupTest.kt | 22 +++--- .../dbflow/sql/language/OperatorTest.kt | 19 +++-- .../dbflow/sql/language/OrderByTest.kt | 16 ++--- .../dbflow/sql/language/SelectTest.kt | 17 +++-- .../dbflow/sql/language/SetTest.kt | 18 ++--- .../dbflow/sql/language/TriggerTest.kt | 41 +++++------ .../sql/language/UnsafeStringOperatorTest.kt | 14 ++-- .../dbflow/sql/language/UpdateTest.kt | 24 +++---- .../dbflow/sql/language/WhereTest.kt | 34 ++++----- .../sql/language/property/BytePropertyTest.kt | 10 +-- .../sql/language/property/CharPropertyTest.kt | 10 +-- .../language/property/DoublePropertyTest.kt | 10 +-- .../language/property/FloatPropertyTest.kt | 10 +-- .../language/property/IndexPropertyTest.kt | 12 ++-- .../sql/language/property/IntPropertyTest.kt | 10 +-- .../sql/language/property/LongPropertyTest.kt | 10 +-- .../language/property/PropertyFactoryTest.kt | 13 ++-- .../sql/language/property/PropertyTest.kt | 10 +-- .../language/property/ShortPropertyTest.kt | 10 +-- .../property/TypeConvertedPropertyTest.kt | 20 +++--- .../rx/query/CursorResultSubscriberTest.kt | 11 ++- .../rx/query/RXQueryTests.kt | 21 +++--- .../com/raizlabs/dbflow5/rx/query/RxModels.kt | 13 ++++ dbflow/build.gradle | 3 - dbflow/src/main/AndroidManifest.xml | 8 +-- .../{android/dbflow => dbflow5}/SqlUtils.kt | 18 ++--- .../adapter/InstanceAdapter.kt | 4 +- .../adapter/InternalAdapter.kt | 8 +-- .../adapter/ModelAdapter.kt | 36 +++++----- .../adapter/ModelViewAdapter.kt | 6 +- .../adapter/QueryModelAdapter.kt | 10 +-- .../adapter/RetrievalAdapter.kt | 20 +++--- .../queriable/CacheableListModelLoader.kt | 14 ++-- .../adapter/queriable/CacheableModelLoader.kt | 14 ++-- .../adapter/queriable/ListModelLoader.kt | 6 +- .../adapter/queriable/ModelLoader.kt | 10 +-- .../SingleKeyCacheableListModelLoader.kt | 8 +-- .../SingleKeyCacheableModelLoader.kt | 10 +-- .../adapter/queriable/SingleModelLoader.kt | 6 +- .../saveable/AutoIncrementModelSaver.kt | 14 ++-- .../saveable/CacheableListModelSaver.kt | 6 +- .../adapter/saveable/ListModelSaver.kt | 6 +- .../adapter/saveable/ModelSaver.kt | 12 ++-- .../config/DatabaseConfig.kt | 18 ++--- .../config/DatabaseDefinition.kt | 51 +++++++------- .../config/DatabaseHolder.kt | 4 +- .../dbflow => dbflow5}/config/FlowConfig.kt | 4 +- .../dbflow => dbflow5}/config/FlowLog.kt | 4 +- .../dbflow => dbflow5}/config/FlowManager.kt | 46 ++++++------ .../config/NaturalOrderComparator.java | 2 +- .../dbflow => dbflow5}/config/TableConfig.kt | 14 ++-- .../database/AndroidDatabase.kt | 2 +- .../database/AndroidDatabaseStatement.kt | 2 +- .../database/BaseDatabaseHelper.kt | 14 ++-- .../database/BaseDatabaseStatement.kt | 2 +- .../database/ContentValueExtensions.kt | 2 +- .../database/DatabaseHelperDelegate.kt | 12 ++-- .../database/DatabaseHelperListener.kt | 2 +- .../database/DatabaseStatement.kt | 2 +- .../database/DatabaseStatementWrapper.kt | 6 +- .../database/DatabaseWrapper.kt | 2 +- .../dbflow => dbflow5}/database/FlowCursor.kt | 2 +- .../database/FlowSQLiteOpenHelper.kt | 6 +- .../dbflow => dbflow5}/database/OpenHelper.kt | 6 +- .../migration/AlterTableMigration.kt | 17 +++-- .../migration/BaseMigration.kt | 4 +- .../migration/IndexMigration.kt | 8 +-- .../migration/IndexPropertyMigration.kt | 7 +- .../dbflow => dbflow5}/migration/Migration.kt | 4 +- .../migration/UpdateTableMigration.kt | 12 ++-- .../provider/BaseContentProvider.kt | 12 ++-- .../provider/BaseProviderModel.kt | 14 ++-- .../provider/BaseSyncableProviderModel.kt | 14 ++-- .../provider/ContentUtils.kt | 18 ++--- .../provider/ModelProvider.kt | 8 +-- .../dbflow => dbflow5}/query/Actionable.kt | 4 +- .../query/BaseModelQueriable.kt | 22 +++--- .../dbflow => dbflow5}/query/BaseOperator.kt | 12 ++-- .../dbflow => dbflow5}/query/BaseQueriable.kt | 18 ++--- .../query/BaseTransformable.kt | 8 +-- .../{android/dbflow => dbflow5}/query/Case.kt | 10 +-- .../dbflow => dbflow5}/query/CaseCondition.kt | 6 +- .../query/CompletedTrigger.kt | 8 +-- .../query/ContentValuesListener.kt | 8 +-- .../dbflow => dbflow5}/query/CursorResult.kt | 14 ++-- .../dbflow => dbflow5}/query/Delete.kt | 6 +- .../query/ExistenceOperator.kt | 6 +- .../{android/dbflow => dbflow5}/query/From.kt | 16 ++--- .../dbflow => dbflow5}/query/IConditional.kt | 4 +- .../dbflow => dbflow5}/query/IOperator.kt | 4 +- .../dbflow => dbflow5}/query/Index.kt | 16 ++--- .../dbflow => dbflow5}/query/IndexedBy.kt | 10 +-- .../dbflow => dbflow5}/query/Insert.kt | 16 ++--- .../{android/dbflow => dbflow5}/query/Join.kt | 12 ++-- .../query/LoadFromCursorListener.kt | 4 +- .../dbflow => dbflow5}/query/Method.kt | 10 +-- .../query/ModelQueriable.kt | 8 +-- .../dbflow => dbflow5}/query/NameAlias.kt | 10 +-- .../dbflow => dbflow5}/query/Operator.kt | 18 ++--- .../dbflow => dbflow5}/query/OperatorGroup.kt | 6 +- .../dbflow => dbflow5}/query/OrderBy.kt | 8 +-- .../dbflow => dbflow5}/query/Queriable.kt | 12 ++-- .../dbflow => dbflow5}/query/SQLOperator.kt | 2 +- .../dbflow => dbflow5}/query/SQLite.kt | 10 +-- .../query/SQLiteStatementListener.kt | 10 +-- .../dbflow => dbflow5}/query/Select.kt | 10 +-- .../{android/dbflow => dbflow5}/query/Set.kt | 10 +-- .../dbflow => dbflow5}/query/StringQuery.kt | 10 +-- .../dbflow => dbflow5}/query/Transformable.kt | 4 +- .../dbflow => dbflow5}/query/Trigger.kt | 10 +-- .../dbflow => dbflow5}/query/TriggerMethod.kt | 10 +-- .../query/UnSafeStringOperator.kt | 6 +- .../dbflow => dbflow5}/query/Update.kt | 10 +-- .../dbflow => dbflow5}/query/Where.kt | 12 ++-- .../dbflow => dbflow5}/query/WhereBase.kt | 6 +- .../query/cache/IMultiKeyCacheConverter.kt | 4 +- .../query/cache/ModelCache.kt | 8 +-- .../query/cache/ModelLruCache.kt | 4 +- .../query/cache/SimpleMapCache.kt | 6 +- .../query/cache/SparseArrayBasedCache.kt | 4 +- .../query/list/FlowCursorIterator.kt | 2 +- .../query/list/FlowCursorList.kt | 12 ++-- .../query/list/FlowQueryList.kt | 12 ++-- .../query/list/IFlowCursorIterator.kt | 2 +- .../query/property/IProperty.java | 14 ++-- .../query/property/IndexProperty.kt | 10 +-- .../query/property/Property.kt | 18 ++--- .../query/property/PropertyFactory.kt | 8 +-- .../query/property/TypeConvertedProperty.kt | 10 +-- .../query/property/WrapperProperty.kt | 4 +- .../runtime/ContentResolverNotifier.kt | 12 ++-- .../runtime/DBBatchSaveQueue.kt | 20 +++--- .../runtime/DirectModelNotifier.kt | 8 +-- .../runtime/FlowContentObserver.kt | 22 +++--- .../runtime/ModelNotifier.kt | 6 +- .../runtime/NotifyDistributor.kt | 8 +-- .../runtime/OnTableChangedListener.kt | 4 +- .../runtime/TableNotifierRegister.kt | 2 +- .../dbflow => dbflow5}/structure/Action.kt | 2 +- .../dbflow => dbflow5}/structure/BaseModel.kt | 10 +-- .../structure/BaseModelView.kt | 6 +- .../structure/BaseQueryModel.kt | 8 +-- .../structure/InvalidDBConfiguration.kt | 2 +- .../dbflow => dbflow5}/structure/Model.kt | 8 +-- .../structure/NoModificationModel.kt | 8 +-- .../dbflow => dbflow5}/structure/OneToMany.kt | 6 +- .../structure/ReadOnlyModel.kt | 4 +- .../transaction/BaseTransactionManager.kt | 8 +-- .../transaction/DefaultTransactionManager.kt | 4 +- .../transaction/DefaultTransactionQueue.kt | 4 +- .../transaction/FastStoreModelTransaction.kt | 10 +-- .../transaction/ITransaction.kt | 4 +- .../transaction/ITransactionQueue.kt | 2 +- .../transaction/PriorityTransactionQueue.kt | 4 +- .../transaction/PriorityTransactionWrapper.kt | 4 +- .../transaction/ProcessModelTransaction.kt | 8 +-- .../transaction/Transaction.kt | 18 ++--- .../transaction/TransactionWrapper.kt | 4 +- usage2/ContentProviderGeneration.md | 6 +- usage2/Intro.md | 2 +- usage2/Relationships.md | 2 +- usage2/TypeConverters.md | 2 +- usage2/proguard.md | 2 +- 365 files changed, 2071 insertions(+), 2121 deletions(-) delete mode 100644 dbflow-core/src/main/java/com/raizlabs/android/dbflow/sql/SQLiteType.kt rename dbflow-core/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/StringUtils.kt (94%) rename dbflow-core/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/annotation/Collate.kt (93%) rename dbflow-core/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/annotation/Column.kt (90%) rename dbflow-core/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/annotation/ColumnIgnore.kt (80%) rename dbflow-core/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/annotation/ColumnMap.kt (92%) rename dbflow-core/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/annotation/ColumnMapReference.kt (93%) rename dbflow-core/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/annotation/ConflictAction.kt (98%) rename dbflow-core/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/annotation/Database.kt (96%) rename dbflow-core/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/annotation/ForeignKey.kt (98%) rename dbflow-core/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/annotation/ForeignKeyAction.kt (96%) rename dbflow-core/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/annotation/ForeignKeyReference.kt (94%) rename dbflow-core/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/annotation/Index.kt (89%) rename dbflow-core/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/annotation/IndexGroup.kt (93%) rename dbflow-core/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/annotation/InheritedColumn.kt (85%) rename dbflow-core/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/annotation/InheritedPrimaryKey.kt (94%) rename dbflow-core/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/annotation/ManyToMany.kt (97%) rename dbflow-core/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/annotation/Migration.kt (95%) rename dbflow-core/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/annotation/ModelCacheField.kt (82%) rename dbflow-core/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/annotation/ModelView.kt (92%) rename dbflow-core/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/annotation/ModelViewQuery.kt (79%) rename dbflow-core/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/annotation/MultiCacheField.kt (83%) rename dbflow-core/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/annotation/MultipleManyToMany.kt (73%) rename dbflow-core/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/annotation/NotNull.kt (81%) rename dbflow-core/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/annotation/OneToMany.kt (97%) rename dbflow-core/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/annotation/PrimaryKey.kt (93%) rename dbflow-core/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/annotation/QueryModel.kt (92%) rename dbflow-core/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/annotation/Table.kt (98%) rename dbflow-core/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/annotation/TypeConverter.kt (92%) rename dbflow-core/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/annotation/Unique.kt (89%) rename dbflow-core/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/annotation/UniqueGroup.kt (81%) rename dbflow-core/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/annotation/provider/ContentProvider.kt (91%) rename dbflow-core/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/annotation/provider/ContentUri.kt (97%) rename dbflow-core/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/annotation/provider/Notify.kt (94%) rename dbflow-core/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/annotation/provider/TableEndpoint.kt (90%) rename dbflow-core/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/converter/TypeConverters.kt (94%) rename dbflow-core/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/data/Blob.kt (86%) rename dbflow-core/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/sql/Query.kt (82%) create mode 100644 dbflow-core/src/main/java/com/raizlabs/dbflow5/sql/SQLiteType.kt rename dbflow-coroutines/src/main/java/com/raizlabs/{dbflow => dbflow5}/coroutines/Coroutines.kt (86%) rename dbflow-processor/src/main/java/com/raizlabs/{android => dbflow5}/dbflow/processor/ClassNames.kt (96%) rename dbflow-processor/src/main/java/com/raizlabs/{android => dbflow5}/dbflow/processor/DBFlowProcessor.kt (78%) rename dbflow-processor/src/main/java/com/raizlabs/{android => dbflow5}/dbflow/processor/Handlers.kt (82%) rename dbflow-processor/src/main/java/com/raizlabs/{android => dbflow5}/dbflow/processor/ProcessorManager.kt (94%) rename dbflow-processor/src/main/java/com/raizlabs/{android => dbflow5}/dbflow/processor/ProcessorUtils.kt (93%) rename dbflow-processor/src/main/java/com/raizlabs/{android => dbflow5}/dbflow/processor/SQLiteHelper.kt (97%) rename dbflow-processor/src/main/java/com/raizlabs/{android => dbflow5}/dbflow/processor/Validators.kt (96%) rename dbflow-processor/src/main/java/com/raizlabs/{android => dbflow5}/dbflow/processor/definition/Adders.kt (83%) rename dbflow-processor/src/main/java/com/raizlabs/{android => dbflow5}/dbflow/processor/definition/BaseDefinition.kt (93%) rename dbflow-processor/src/main/java/com/raizlabs/{android => dbflow5}/dbflow/processor/definition/BaseTableDefinition.kt (91%) rename dbflow-processor/src/main/java/com/raizlabs/{android => dbflow5}/dbflow/processor/definition/ContentProvider.kt (96%) rename dbflow-processor/src/main/java/com/raizlabs/{android => dbflow5}/dbflow/processor/definition/DatabaseDefinition.kt (94%) rename dbflow-processor/src/main/java/com/raizlabs/{android => dbflow5}/dbflow/processor/definition/DatabaseHolderDefinition.kt (89%) rename dbflow-processor/src/main/java/com/raizlabs/{android => dbflow5}/dbflow/processor/definition/DatabaseObjectHolder.kt (96%) rename dbflow-processor/src/main/java/com/raizlabs/{android => dbflow5}/dbflow/processor/definition/IndexGroupsDefinition.kt (84%) rename dbflow-processor/src/main/java/com/raizlabs/{android => dbflow5}/dbflow/processor/definition/ManyToManyDefinition.kt (87%) rename dbflow-processor/src/main/java/com/raizlabs/{android => dbflow5}/dbflow/processor/definition/Methods.kt (98%) rename dbflow-processor/src/main/java/com/raizlabs/{android => dbflow5}/dbflow/processor/definition/MigrationDefinition.kt (90%) rename dbflow-processor/src/main/java/com/raizlabs/{android => dbflow5}/dbflow/processor/definition/ModelViewDefinition.kt (85%) rename dbflow-processor/src/main/java/com/raizlabs/{android => dbflow5}/dbflow/processor/definition/NotifyDefinition.kt (85%) rename dbflow-processor/src/main/java/com/raizlabs/{android => dbflow5}/dbflow/processor/definition/OneToManyDefinition.kt (86%) rename dbflow-processor/src/main/java/com/raizlabs/{android => dbflow5}/dbflow/processor/definition/QueryModelDefinition.kt (84%) rename dbflow-processor/src/main/java/com/raizlabs/{android => dbflow5}/dbflow/processor/definition/TableDefinition.kt (93%) rename dbflow-processor/src/main/java/com/raizlabs/{android => dbflow5}/dbflow/processor/definition/TableEndpointDefinition.kt (81%) rename dbflow-processor/src/main/java/com/raizlabs/{android => dbflow5}/dbflow/processor/definition/TypeConverterDefinition.kt (86%) rename dbflow-processor/src/main/java/com/raizlabs/{android => dbflow5}/dbflow/processor/definition/TypeDefinition.kt (81%) rename dbflow-processor/src/main/java/com/raizlabs/{android => dbflow5}/dbflow/processor/definition/UniqueGroupsDefinition.kt (78%) rename dbflow-processor/src/main/java/com/raizlabs/{android => dbflow5}/dbflow/processor/definition/column/ColumnAccessCombiner.kt (97%) rename dbflow-processor/src/main/java/com/raizlabs/{android => dbflow5}/dbflow/processor/definition/column/ColumnAccessor.kt (97%) rename dbflow-processor/src/main/java/com/raizlabs/{android => dbflow5}/dbflow/processor/definition/column/ColumnDefinition.kt (93%) rename dbflow-processor/src/main/java/com/raizlabs/{android => dbflow5}/dbflow/processor/definition/column/DefinitionUtils.kt (85%) rename dbflow-processor/src/main/java/com/raizlabs/{android => dbflow5}/dbflow/processor/definition/column/ForeignKeyAccessCombiner.kt (96%) rename dbflow-processor/src/main/java/com/raizlabs/{android => dbflow5}/dbflow/processor/definition/column/ReferenceColumnDefinition.kt (92%) rename dbflow-processor/src/main/java/com/raizlabs/{android => dbflow5}/dbflow/processor/definition/column/ReferenceDefinition.kt (93%) rename dbflow-processor/src/main/java/com/raizlabs/{android => dbflow5}/dbflow/processor/utils/CodeExtensions.kt (96%) rename dbflow-processor/src/main/java/com/raizlabs/{android => dbflow5}/dbflow/processor/utils/DependencyUtils.kt (65%) rename dbflow-processor/src/main/java/com/raizlabs/{android => dbflow5}/dbflow/processor/utils/ElementExtensions.kt (91%) rename dbflow-processor/src/main/java/com/raizlabs/{android => dbflow5}/dbflow/processor/utils/ElementUtility.kt (93%) rename dbflow-processor/src/main/java/com/raizlabs/{android => dbflow5}/dbflow/processor/utils/JavaPoetExtensions.kt (97%) rename dbflow-processor/src/main/java/com/raizlabs/{android => dbflow5}/dbflow/processor/utils/ModelUtils.kt (60%) rename dbflow-processor/src/main/java/com/raizlabs/{android => dbflow5}/dbflow/processor/utils/ProcessorUtils.kt (96%) rename dbflow-processor/src/main/java/com/raizlabs/{android => dbflow5}/dbflow/processor/utils/StringUtils.kt (90%) rename dbflow-processor/src/main/java/com/raizlabs/{android => dbflow5}/dbflow/processor/utils/WriterUtils.kt (81%) rename dbflow-processor/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/processor/test/ColumnAccessCombinerTests.kt (98%) rename dbflow-processor/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/processor/test/ForeignKeyAccessCombinerTests.kt (90%) rename dbflow-processor/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/processor/test/SimpleColumnAccessorTests.kt (94%) rename dbflow-rx/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/rx/query/CursorResultSubscriber.kt (94%) rename dbflow-rx/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/rx/query/RXModelQueriable.kt (86%) rename dbflow-rx/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/rx/query/RXModelQueriableImpl.kt (83%) rename dbflow-rx/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/rx/query/RXQueriable.kt (79%) rename dbflow-rx/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/rx/query/RXQueriableImpl.kt (82%) rename dbflow-rx/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/rx/query/RXSQLite.kt (53%) rename dbflow-rx/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/rx/query/TableChangeListenerEmitter.java (85%) rename dbflow-rx/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/rx/structure/BaseRXModel.kt (75%) rename dbflow-rx/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/rx/structure/RXModelAdapter.kt (90%) rename dbflow-rx/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/rx/structure/RXRetrievalAdapter.kt (84%) rename dbflow-rx/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/rx/transaction/TransactionObservable.kt (75%) rename dbflow-rx2/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/rx2/query/CursorResultFlowable.kt (94%) rename dbflow-rx2/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/rx2/query/RXModelQueriable.kt (86%) rename dbflow-rx2/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/rx2/query/RXModelQueriableImpl.kt (83%) rename dbflow-rx2/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/rx2/query/RXQueriable.kt (80%) rename dbflow-rx2/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/rx2/query/RXQueriableImpl.kt (82%) rename dbflow-rx2/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/rx2/query/RXSQLite.kt (54%) rename dbflow-rx2/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/rx2/query/TableChangeOnSubscribe.kt (79%) rename dbflow-rx2/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/rx2/structure/BaseRXModel.kt (75%) rename dbflow-rx2/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/rx2/structure/RXModelAdapter.kt (90%) rename dbflow-rx2/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/rx2/structure/RXRetrievalAdapter.kt (84%) rename dbflow-rx2/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/rx2/transaction/TransactionObservable.kt (82%) rename dbflow-sqlcipher/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/sqlcipher/SQLCipherDatabase.kt (91%) rename dbflow-sqlcipher/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/sqlcipher/SQLCipherOpenHelper.kt (89%) rename dbflow-sqlcipher/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/sqlcipher/SQLCipherStatement.kt (89%) rename dbflow-tests/src/androidTest/java/com/raizlabs/{android => dbflow5}/dbflow/BaseUnitTest.kt (81%) rename dbflow-tests/src/androidTest/java/com/raizlabs/{android => dbflow5}/dbflow/DBFlowInstrumentedTestRule.kt (76%) rename dbflow-tests/src/androidTest/java/com/raizlabs/{android => dbflow5}/dbflow/ImmediateTransactionManager.kt (70%) rename dbflow-tests/src/androidTest/java/com/raizlabs/{android => dbflow5}/dbflow/contentobserver/ContentObserverTest.kt (76%) rename dbflow-tests/src/androidTest/java/com/raizlabs/{android => dbflow5}/dbflow/prepackaged/PrepackagedDBTest.kt (57%) rename dbflow-tests/src/androidTest/java/com/raizlabs/{android/dbflow => dbflow5}/sqlcipher/CipherTest.kt (64%) delete mode 100644 dbflow-tests/src/main/java/com/raizlabs/android/dbflow/contentobserver/User.kt delete mode 100644 dbflow-tests/src/main/java/com/raizlabs/android/dbflow/prepackaged/PrepackagedDB.kt delete mode 100644 dbflow-tests/src/main/java/com/raizlabs/android/dbflow/sqlcipher/CipherDatabase.kt rename dbflow-tests/src/main/java/com/raizlabs/{android => dbflow5}/dbflow/AppDatabase.kt (50%) rename dbflow-tests/src/main/java/com/raizlabs/{android => dbflow5}/dbflow/DemoApp.kt (87%) rename dbflow-tests/src/main/java/com/raizlabs/{android => dbflow5}/dbflow/StubContentProvider.kt (96%) rename dbflow-tests/src/main/java/com/raizlabs/{android => dbflow5}/dbflow/User.kt (55%) create mode 100644 dbflow-tests/src/main/java/com/raizlabs/dbflow5/dbflow/contentobserver/User.kt create mode 100644 dbflow-tests/src/main/java/com/raizlabs/dbflow5/dbflow/prepackaged/PrepackagedDB.kt rename dbflow-tests/src/main/java/com/raizlabs/{android => dbflow5}/dbflow/test/DemoActivity.java (83%) create mode 100644 dbflow-tests/src/main/java/com/raizlabs/dbflow5/sqlcipher/CipherDatabase.kt rename dbflow-tests/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/sqlcipher/CipherTestObjects.kt (51%) delete mode 100644 dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/InnerClassExample.kt delete mode 100644 dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/NonTypical/nonTypicalClassName.kt delete mode 100644 dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/Page.java delete mode 100644 dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/java/JavaModelView.java delete mode 100644 dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/java/otherpackage/ExampleModel.java delete mode 100644 dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/query/RxModels.kt rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/BaseUnitTest.kt (92%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/DBFlowTestRule.kt (81%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/ImmediateTransactionManager.kt (70%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/TestDatabase.kt (57%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/TestExtensions.kt (86%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/config/ConfigIntegrationTest.kt (79%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/config/DatabaseConfigTest.kt (84%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/database/transaction/CoroutinesTest.kt (71%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/database/transaction/FastStoreModelTransactionTest.kt (63%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/migration/UpdateTableMigrationTest.kt (50%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/models/AutoIncrementTest.kt (65%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/models/CachingModels.kt (62%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/models/CachingModelsTest.kt (75%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/models/DontCreateModelTest.kt (55%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/models/ForeignKeyModels.kt (81%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/models/IndexModels.kt (66%) create mode 100644 dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/InnerClassExample.kt rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/models/ManyToMany.kt (51%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/models/ManyToManyTest.kt (76%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/models/ModelViewTest.kt (62%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/models/ModelViews.kt (62%) create mode 100644 dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/NonTypical/nonTypicalClassName.kt rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/models/OneToManyModelTest.kt (70%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/models/OneToManyModels.kt (67%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/models/ParentChildCachingTest.kt (64%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/models/QueryModelTest.kt (59%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/models/QueryModels.kt (64%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/models/SimpleTestModels.kt (88%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/models/issue/Issue.java (57%) create mode 100644 dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/issue/Page.java rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/models/issue/SubIssue.java (61%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/models/java/DatabaseModel.java (56%) create mode 100644 dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/java/JavaModelView.java create mode 100644 dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/java/otherpackage/ExampleModel.java rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/provider/ContentProviderObjects.kt (79%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/provider/ContentProviderTests.kt (86%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/provider/RealContentProvider.kt (79%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/provider/TestContentProvider.kt (88%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/query/cache/ModelLruCacheTest.kt (77%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/query/cache/SimpleMapCacheTest.kt (78%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/query/list/FlowCursorIteratorTest.kt (81%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/query/list/FlowCursorListTest.kt (85%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/runtime/DirectNotifierTest.kt (71%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/sql/language/CaseTest.kt (74%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/sql/language/CursorResultTest.kt (81%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/sql/language/DeleteTest.kt (68%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/sql/language/ExistenceOperatorTest.kt (54%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/sql/language/FromTest.kt (71%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/sql/language/IndexTest.kt (73%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/sql/language/IndexedByTest.kt (54%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/sql/language/InsertTest.kt (84%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/sql/language/JoinTest.kt (81%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/sql/language/MethodTest.kt (68%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/sql/language/NameAliasTest.kt (83%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/sql/language/OperatorGroupTest.kt (68%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/sql/language/OperatorTest.kt (78%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/sql/language/OrderByTest.kt (60%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/sql/language/SelectTest.kt (52%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/sql/language/SetTest.kt (53%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/sql/language/TriggerTest.kt (64%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/sql/language/UnsafeStringOperatorTest.kt (55%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/sql/language/UpdateTest.kt (71%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/sql/language/WhereTest.kt (84%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/sql/language/property/BytePropertyTest.kt (85%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/sql/language/property/CharPropertyTest.kt (86%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/sql/language/property/DoublePropertyTest.kt (86%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/sql/language/property/FloatPropertyTest.kt (85%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/sql/language/property/IndexPropertyTest.kt (56%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/sql/language/property/IntPropertyTest.kt (85%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/sql/language/property/LongPropertyTest.kt (85%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/sql/language/property/PropertyFactoryTest.kt (67%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/sql/language/property/PropertyTest.kt (88%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/sql/language/property/ShortPropertyTest.kt (85%) rename dbflow-tests/src/test/java/com/raizlabs/{android => dbflow5}/dbflow/sql/language/property/TypeConvertedPropertyTest.kt (71%) rename dbflow-tests/src/test/java/com/raizlabs/{android/dbflow => dbflow5}/rx/query/CursorResultSubscriberTest.kt (66%) rename dbflow-tests/src/test/java/com/raizlabs/{android/dbflow => dbflow5}/rx/query/RXQueryTests.kt (76%) create mode 100644 dbflow-tests/src/test/java/com/raizlabs/dbflow5/rx/query/RxModels.kt rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/SqlUtils.kt (93%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/adapter/InstanceAdapter.kt (80%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/adapter/InternalAdapter.kt (96%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/adapter/ModelAdapter.kt (92%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/adapter/ModelViewAdapter.kt (75%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/adapter/QueryModelAdapter.kt (74%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/adapter/RetrievalAdapter.kt (88%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/adapter/queriable/CacheableListModelLoader.kt (79%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/adapter/queriable/CacheableModelLoader.kt (81%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/adapter/queriable/ListModelLoader.kt (85%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/adapter/queriable/ModelLoader.kt (86%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/adapter/queriable/SingleKeyCacheableListModelLoader.kt (78%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/adapter/queriable/SingleKeyCacheableModelLoader.kt (76%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/adapter/queriable/SingleModelLoader.kt (82%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/adapter/saveable/AutoIncrementModelSaver.kt (81%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/adapter/saveable/CacheableListModelSaver.kt (93%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/adapter/saveable/ListModelSaver.kt (92%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/adapter/saveable/ModelSaver.kt (91%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/config/DatabaseConfig.kt (89%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/config/DatabaseDefinition.kt (90%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/config/DatabaseHolder.kt (95%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/config/FlowConfig.kt (93%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/config/FlowLog.kt (97%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/config/FlowManager.kt (92%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/config/NaturalOrderComparator.java (98%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/config/TableConfig.kt (83%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/database/AndroidDatabase.kt (98%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/database/AndroidDatabaseStatement.kt (98%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/database/BaseDatabaseHelper.kt (93%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/database/BaseDatabaseStatement.kt (96%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/database/ContentValueExtensions.kt (94%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/database/DatabaseHelperDelegate.kt (96%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/database/DatabaseHelperListener.kt (96%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/database/DatabaseStatement.kt (94%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/database/DatabaseStatementWrapper.kt (91%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/database/DatabaseWrapper.kt (96%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/database/FlowCursor.kt (99%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/database/FlowSQLiteOpenHelper.kt (96%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/database/OpenHelper.kt (64%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/migration/AlterTableMigration.kt (90%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/migration/BaseMigration.kt (77%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/migration/IndexMigration.kt (82%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/migration/IndexPropertyMigration.kt (73%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/migration/Migration.kt (86%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/migration/UpdateTableMigration.kt (83%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/provider/BaseContentProvider.kt (83%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/provider/BaseProviderModel.kt (85%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/provider/BaseSyncableProviderModel.kt (82%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/provider/ContentUtils.kt (96%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/provider/ModelProvider.kt (88%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/Actionable.kt (55%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/BaseModelQueriable.kt (80%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/BaseOperator.kt (96%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/BaseQueriable.kt (80%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/BaseTransformable.kt (91%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/Case.kt (93%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/CaseCondition.kt (92%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/CompletedTrigger.kt (87%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/ContentValuesListener.kt (85%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/CursorResult.kt (92%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/Delete.kt (92%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/ExistenceOperator.kt (87%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/From.kt (94%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/IConditional.kt (97%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/IOperator.kt (98%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/Index.kt (90%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/IndexedBy.kt (76%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/Insert.kt (95%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/Join.kt (94%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/LoadFromCursorListener.kt (79%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/Method.kt (96%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/ModelQueriable.kt (91%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/NameAlias.kt (97%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/Operator.kt (98%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/OperatorGroup.kt (97%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/OrderBy.kt (89%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/Queriable.kt (81%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/SQLOperator.kt (96%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/SQLite.kt (92%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/SQLiteStatementListener.kt (80%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/Select.kt (91%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/Set.kt (83%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/StringQuery.kt (81%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/Transformable.kt (90%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/Trigger.kt (93%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/TriggerMethod.kt (90%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/UnSafeStringOperator.kt (89%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/Update.kt (89%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/Where.kt (94%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/WhereBase.kt (69%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/cache/IMultiKeyCacheConverter.kt (86%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/cache/ModelCache.kt (89%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/cache/ModelLruCache.kt (94%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/cache/SimpleMapCache.kt (87%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/cache/SparseArrayBasedCache.kt (95%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/list/FlowCursorIterator.kt (97%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/list/FlowCursorList.kt (94%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/list/FlowQueryList.kt (94%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/list/IFlowCursorIterator.kt (95%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/property/IProperty.java (90%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/property/IndexProperty.kt (78%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/property/Property.kt (96%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/property/PropertyFactory.kt (95%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/property/TypeConvertedProperty.kt (89%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/query/property/WrapperProperty.kt (88%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/runtime/ContentResolverNotifier.kt (89%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/runtime/DBBatchSaveQueue.kt (92%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/runtime/DirectModelNotifier.kt (95%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/runtime/FlowContentObserver.kt (94%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/runtime/ModelNotifier.kt (66%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/runtime/NotifyDistributor.kt (83%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/runtime/OnTableChangedListener.kt (80%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/runtime/TableNotifierRegister.kt (88%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/structure/Action.kt (88%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/structure/BaseModel.kt (81%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/structure/BaseModelView.kt (66%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/structure/BaseQueryModel.kt (59%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/structure/InvalidDBConfiguration.kt (86%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/structure/Model.kt (89%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/structure/NoModificationModel.kt (75%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/structure/OneToMany.kt (82%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/structure/ReadOnlyModel.kt (79%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/transaction/BaseTransactionManager.kt (85%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/transaction/DefaultTransactionManager.kt (82%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/transaction/DefaultTransactionQueue.kt (96%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/transaction/FastStoreModelTransaction.kt (93%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/transaction/ITransaction.kt (82%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/transaction/ITransactionQueue.kt (93%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/transaction/PriorityTransactionQueue.kt (97%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/transaction/PriorityTransactionWrapper.kt (95%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/transaction/ProcessModelTransaction.kt (96%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/transaction/Transaction.kt (93%) rename dbflow/src/main/java/com/raizlabs/{android/dbflow => dbflow5}/transaction/TransactionWrapper.kt (83%) diff --git a/dbflow-core/build.gradle b/dbflow-core/build.gradle index 6be3673bd..476caac1e 100644 --- a/dbflow-core/build.gradle +++ b/dbflow-core/build.gradle @@ -14,6 +14,6 @@ apply from: '../java-artifacts.gradle' compileKotlin { kotlinOptions { - apiVersion = "1.1" + apiVersion = "1.2" } } \ No newline at end of file diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/sql/SQLiteType.kt b/dbflow-core/src/main/java/com/raizlabs/android/dbflow/sql/SQLiteType.kt deleted file mode 100644 index 2fb4e170b..000000000 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/sql/SQLiteType.kt +++ /dev/null @@ -1,67 +0,0 @@ -package com.raizlabs.android.dbflow.sql - -import com.raizlabs.android.dbflow.data.Blob - -/** - * Description: Represents a type that SQLite understands. - */ -enum class SQLiteType { - - /** - * Represents an integer number in the DB. - */ - INTEGER, - - /** - * Represents a floating-point, precise number. - */ - REAL, - - /** - * Represents text. - */ - TEXT, - - /** - * A column defined by [byte[]] data. Usually reserved for images or larger pieces of content. - */ - BLOB; - - - companion object { - - private val sTypeMap = hashMapOf( - Byte::class.javaPrimitiveType!!.name to SQLiteType.INTEGER, - Short::class.javaPrimitiveType!!.name to SQLiteType.INTEGER, - Int::class.javaPrimitiveType!!.name to SQLiteType.INTEGER, - Long::class.javaPrimitiveType!!.name to SQLiteType.INTEGER, - Float::class.javaPrimitiveType!!.name to SQLiteType.REAL, - Double::class.javaPrimitiveType!!.name to SQLiteType.REAL, - Boolean::class.javaPrimitiveType!!.name to SQLiteType.INTEGER, - Char::class.javaPrimitiveType!!.name to SQLiteType.TEXT, - ByteArray::class.java.name to SQLiteType.BLOB, - Byte::class.java.name to SQLiteType.INTEGER, - Short::class.java.name to SQLiteType.INTEGER, - Int::class.java.name to SQLiteType.INTEGER, - Long::class.java.name to SQLiteType.INTEGER, - Float::class.java.name to SQLiteType.REAL, - Double::class.java.name to SQLiteType.REAL, - Boolean::class.java.name to SQLiteType.INTEGER, - Char::class.java.name to SQLiteType.TEXT, - CharSequence::class.java.name to SQLiteType.TEXT, - String::class.java.name to SQLiteType.TEXT, - Array::class.java.name to SQLiteType.BLOB, - Blob::class.java.name to SQLiteType.BLOB) - - /** - * Returns the [SQLiteType] for this class - * - * @param className The fully qualified class name - * @return The type from the class name - */ - - operator fun get(className: String): SQLiteType? = sTypeMap[className] - - fun containsClass(className: String): Boolean = sTypeMap.containsKey(className) - } -} diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/StringUtils.kt b/dbflow-core/src/main/java/com/raizlabs/dbflow5/StringUtils.kt similarity index 94% rename from dbflow-core/src/main/java/com/raizlabs/android/dbflow/StringUtils.kt rename to dbflow-core/src/main/java/com/raizlabs/dbflow5/StringUtils.kt index 1e8a47a81..f1af066d2 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/StringUtils.kt +++ b/dbflow-core/src/main/java/com/raizlabs/dbflow5/StringUtils.kt @@ -1,8 +1,8 @@ @file:JvmName("StringUtils") -package com.raizlabs.android.dbflow +package com.raizlabs.dbflow5 -import com.raizlabs.android.dbflow.sql.SQLiteType +import com.raizlabs.dbflow5.sql.SQLiteType import java.util.regex.Pattern @@ -41,7 +41,7 @@ fun String?.isQuoted(): Boolean = QUOTE_PATTERN.matcher(this).find() * @return A name in quotes. E.G. index => `index` so we can use keywords as column names without fear * of clashing. */ -fun String?.quote(): String = "$QUOTE${this?.replace(".", "`.`")}$QUOTE" +fun String?.quote(): String = "${QUOTE}${this?.replace(".", "`.`")}${QUOTE}" fun String?.quoteIfNeeded() = if (this != null && !isQuoted()) { quote() diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Collate.kt b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/Collate.kt similarity index 93% rename from dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Collate.kt rename to dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/Collate.kt index 0355502d7..a0248fb66 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Collate.kt +++ b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/Collate.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.annotation +package com.raizlabs.dbflow5.annotation /** * Represents a SQL Collate method for comparing string columns. diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Column.kt b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/Column.kt similarity index 90% rename from dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Column.kt rename to dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/Column.kt index d64c81863..bc5590827 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Column.kt +++ b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/Column.kt @@ -1,5 +1,6 @@ -package com.raizlabs.android.dbflow.annotation +package com.raizlabs.dbflow5.annotation +import com.raizlabs.dbflow5.converter.TypeConverter import kotlin.reflect.KClass /** @@ -43,4 +44,4 @@ annotation class Column( * @return A custom type converter that's only used for this field. It will be created and used in * the Adapter associated with this table. */ - val typeConverter: KClass> = com.raizlabs.android.dbflow.converter.TypeConverter::class) + val typeConverter: KClass> = TypeConverter::class) diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ColumnIgnore.kt b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ColumnIgnore.kt similarity index 80% rename from dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ColumnIgnore.kt rename to dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ColumnIgnore.kt index a5523b633..bbd29be3c 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ColumnIgnore.kt +++ b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ColumnIgnore.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.annotation +package com.raizlabs.dbflow5.annotation /** * Description: An annotation used to ignore a column in the [Table.allFields] instance. diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ColumnMap.kt b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ColumnMap.kt similarity index 92% rename from dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ColumnMap.kt rename to dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ColumnMap.kt index 27089ba35..14f6e9065 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ColumnMap.kt +++ b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ColumnMap.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.annotation +package com.raizlabs.dbflow5.annotation /** * Description: Maps an arbitrary object and its corresponding fields into a set of columns. It is similar diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ColumnMapReference.kt b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ColumnMapReference.kt similarity index 93% rename from dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ColumnMapReference.kt rename to dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ColumnMapReference.kt index de882d401..70ecbef0b 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ColumnMapReference.kt +++ b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ColumnMapReference.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.annotation +package com.raizlabs.dbflow5.annotation /** * Description: Allows a [ColumnMap] to specify a reference override for its fields. Anything not diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ConflictAction.kt b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ConflictAction.kt similarity index 98% rename from dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ConflictAction.kt rename to dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ConflictAction.kt index 6081639c1..2dbf01cfe 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ConflictAction.kt +++ b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ConflictAction.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.annotation +package com.raizlabs.dbflow5.annotation /** * This is how to resolve null or unique conflicts with a field marked as [NotNull] diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Database.kt b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/Database.kt similarity index 96% rename from dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Database.kt rename to dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/Database.kt index 91f585bf8..d31d6b5c4 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Database.kt +++ b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/Database.kt @@ -1,4 +1,6 @@ -package com.raizlabs.android.dbflow.annotation +package com.raizlabs.dbflow5.annotation + +import com.raizlabs.dbflow5.annotation.ConflictAction /** * Description: Creates a new database to use in the application. diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ForeignKey.kt b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ForeignKey.kt similarity index 98% rename from dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ForeignKey.kt rename to dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ForeignKey.kt index fd658eb05..d612a9df9 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ForeignKey.kt +++ b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ForeignKey.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.annotation +package com.raizlabs.dbflow5.annotation import kotlin.reflect.KClass diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ForeignKeyAction.kt b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ForeignKeyAction.kt similarity index 96% rename from dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ForeignKeyAction.kt rename to dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ForeignKeyAction.kt index 25fd567c2..8db864044 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ForeignKeyAction.kt +++ b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ForeignKeyAction.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.annotation +package com.raizlabs.dbflow5.annotation /** * Actions associated with on update and on delete diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ForeignKeyReference.kt b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ForeignKeyReference.kt similarity index 94% rename from dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ForeignKeyReference.kt rename to dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ForeignKeyReference.kt index 46dfeb117..08b43490d 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ForeignKeyReference.kt +++ b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ForeignKeyReference.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.annotation +package com.raizlabs.dbflow5.annotation /** * Description: Used inside of [ForeignKey.references], describes the diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Index.kt b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/Index.kt similarity index 89% rename from dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Index.kt rename to dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/Index.kt index ef56efb24..5334b03e5 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Index.kt +++ b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/Index.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.annotation +package com.raizlabs.dbflow5.annotation /** * Description: Creates an index for a specified [Column]. A single column can belong to multiple diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/IndexGroup.kt b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/IndexGroup.kt similarity index 93% rename from dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/IndexGroup.kt rename to dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/IndexGroup.kt index f919fd575..8ec5d3930 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/IndexGroup.kt +++ b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/IndexGroup.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.annotation +package com.raizlabs.dbflow5.annotation const val INDEX_GENERIC = -1 diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/InheritedColumn.kt b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/InheritedColumn.kt similarity index 85% rename from dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/InheritedColumn.kt rename to dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/InheritedColumn.kt index d46f64d34..06558ebf7 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/InheritedColumn.kt +++ b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/InheritedColumn.kt @@ -1,4 +1,7 @@ -package com.raizlabs.android.dbflow.annotation +package com.raizlabs.dbflow5.annotation + +import com.raizlabs.dbflow5.annotation.Column +import com.raizlabs.dbflow5.annotation.ConflictAction /** * Description: Allows [Table] to inherit fields from other objects to make it part of the DB table. diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/InheritedPrimaryKey.kt b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/InheritedPrimaryKey.kt similarity index 94% rename from dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/InheritedPrimaryKey.kt rename to dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/InheritedPrimaryKey.kt index a35ae914c..d3e49a1e0 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/InheritedPrimaryKey.kt +++ b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/InheritedPrimaryKey.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.annotation +package com.raizlabs.dbflow5.annotation /** * Description: Allows you to specify a non-Column to be inherited and used as a [PrimaryKey] diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ManyToMany.kt b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ManyToMany.kt similarity index 97% rename from dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ManyToMany.kt rename to dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ManyToMany.kt index e0438964c..12e08e522 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ManyToMany.kt +++ b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ManyToMany.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.annotation +package com.raizlabs.dbflow5.annotation import kotlin.reflect.KClass diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Migration.kt b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/Migration.kt similarity index 95% rename from dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Migration.kt rename to dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/Migration.kt index ea3eb548b..848d2650b 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Migration.kt +++ b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/Migration.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.annotation +package com.raizlabs.dbflow5.annotation import kotlin.reflect.KClass diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ModelCacheField.kt b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ModelCacheField.kt similarity index 82% rename from dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ModelCacheField.kt rename to dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ModelCacheField.kt index ea03091fa..e61277816 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ModelCacheField.kt +++ b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ModelCacheField.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.annotation +package com.raizlabs.dbflow5.annotation /** * Description: marks a single field as a ModelCache creator that is used in the corresponding ModelAdapter. diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ModelView.kt b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ModelView.kt similarity index 92% rename from dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ModelView.kt rename to dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ModelView.kt index 0ea30e1c3..bf8163f04 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ModelView.kt +++ b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ModelView.kt @@ -1,6 +1,6 @@ -package com.raizlabs.android.dbflow.annotation +package com.raizlabs.dbflow5.annotation -import com.raizlabs.android.dbflow.sql.Query +import com.raizlabs.dbflow5.sql.Query import kotlin.reflect.KClass /** diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ModelViewQuery.kt b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ModelViewQuery.kt similarity index 79% rename from dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ModelViewQuery.kt rename to dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ModelViewQuery.kt index c748ba946..81fcc2ffa 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/ModelViewQuery.kt +++ b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ModelViewQuery.kt @@ -1,6 +1,6 @@ -package com.raizlabs.android.dbflow.annotation +package com.raizlabs.dbflow5.annotation -import com.raizlabs.android.dbflow.sql.Query +import com.raizlabs.dbflow5.sql.Query /** * Description: Represents a field that is a [Query]. This is only meant to be used as a query diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/MultiCacheField.kt b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/MultiCacheField.kt similarity index 83% rename from dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/MultiCacheField.kt rename to dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/MultiCacheField.kt index aecb61bbe..5b14ac649 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/MultiCacheField.kt +++ b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/MultiCacheField.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.annotation +package com.raizlabs.dbflow5.annotation /** * Description: Marks a field as the IMultiKeyCacheModel that we use to convert multiple fields into diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/MultipleManyToMany.kt b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/MultipleManyToMany.kt similarity index 73% rename from dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/MultipleManyToMany.kt rename to dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/MultipleManyToMany.kt index c9423cfc7..4fe4457a6 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/MultipleManyToMany.kt +++ b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/MultipleManyToMany.kt @@ -1,4 +1,6 @@ -package com.raizlabs.android.dbflow.annotation +package com.raizlabs.dbflow5.annotation + +import com.raizlabs.dbflow5.annotation.ManyToMany /** * Description: Provides ability to add multiple [ManyToMany] annotations at once. diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/NotNull.kt b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/NotNull.kt similarity index 81% rename from dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/NotNull.kt rename to dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/NotNull.kt index 10aa945f7..f3cdaa0bb 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/NotNull.kt +++ b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/NotNull.kt @@ -1,4 +1,6 @@ -package com.raizlabs.android.dbflow.annotation +package com.raizlabs.dbflow5.annotation + +import com.raizlabs.dbflow5.annotation.ConflictAction /** * Description: Specifies that a [Column] is not null. diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/OneToMany.kt b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/OneToMany.kt similarity index 97% rename from dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/OneToMany.kt rename to dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/OneToMany.kt index ed2e97a56..cc1150d7b 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/OneToMany.kt +++ b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/OneToMany.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.annotation +package com.raizlabs.dbflow5.annotation /** * Description: Describes a 1-many relationship. It applies to some method that returns a [List] of Model objects. diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/PrimaryKey.kt b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/PrimaryKey.kt similarity index 93% rename from dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/PrimaryKey.kt rename to dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/PrimaryKey.kt index 6ce96e18c..f0a7f2563 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/PrimaryKey.kt +++ b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/PrimaryKey.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.annotation +package com.raizlabs.dbflow5.annotation /** * Description: diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/QueryModel.kt b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/QueryModel.kt similarity index 92% rename from dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/QueryModel.kt rename to dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/QueryModel.kt index 3c23c3cb6..227ebbf03 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/QueryModel.kt +++ b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/QueryModel.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.annotation +package com.raizlabs.dbflow5.annotation import kotlin.reflect.KClass diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Table.kt b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/Table.kt similarity index 98% rename from dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Table.kt rename to dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/Table.kt index be2495fef..4bf540a44 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Table.kt +++ b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/Table.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.annotation +package com.raizlabs.dbflow5.annotation import kotlin.reflect.KClass diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/TypeConverter.kt b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/TypeConverter.kt similarity index 92% rename from dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/TypeConverter.kt rename to dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/TypeConverter.kt index 8f33e3f78..7fc4848ec 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/TypeConverter.kt +++ b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/TypeConverter.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.annotation +package com.raizlabs.dbflow5.annotation import kotlin.reflect.KClass diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Unique.kt b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/Unique.kt similarity index 89% rename from dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Unique.kt rename to dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/Unique.kt index 1d204159f..87d9f7a05 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/Unique.kt +++ b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/Unique.kt @@ -1,4 +1,6 @@ -package com.raizlabs.android.dbflow.annotation +package com.raizlabs.dbflow5.annotation + +import com.raizlabs.dbflow5.annotation.ConflictAction /** * Description: Marks the field as unique, meaning its value cannot be repeated. It is, however, diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/UniqueGroup.kt b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/UniqueGroup.kt similarity index 81% rename from dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/UniqueGroup.kt rename to dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/UniqueGroup.kt index 2240efa86..b3ba16e39 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/UniqueGroup.kt +++ b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/UniqueGroup.kt @@ -1,4 +1,6 @@ -package com.raizlabs.android.dbflow.annotation +package com.raizlabs.dbflow5.annotation + +import com.raizlabs.dbflow5.annotation.ConflictAction /** * Description: diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/ContentProvider.kt b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/provider/ContentProvider.kt similarity index 91% rename from dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/ContentProvider.kt rename to dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/provider/ContentProvider.kt index c31eb701a..b54181aed 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/ContentProvider.kt +++ b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/provider/ContentProvider.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.annotation.provider +package com.raizlabs.dbflow5.annotation.provider import kotlin.reflect.KClass diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/ContentUri.kt b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/provider/ContentUri.kt similarity index 97% rename from dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/ContentUri.kt rename to dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/provider/ContentUri.kt index 419349677..651c39245 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/ContentUri.kt +++ b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/provider/ContentUri.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.annotation.provider +package com.raizlabs.dbflow5.annotation.provider /** * Description: Defines the URI for a content provider. diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/Notify.kt b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/provider/Notify.kt similarity index 94% rename from dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/Notify.kt rename to dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/provider/Notify.kt index 97840717d..5ed232b16 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/Notify.kt +++ b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/provider/Notify.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.annotation.provider +package com.raizlabs.dbflow5.annotation.provider /** * Description: Annotates a method part of [com.raizlabs.android.dbflow.annotation.provider.TableEndpoint] diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/TableEndpoint.kt b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/provider/TableEndpoint.kt similarity index 90% rename from dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/TableEndpoint.kt rename to dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/provider/TableEndpoint.kt index 7ae3cfcc3..ce07c395f 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/annotation/provider/TableEndpoint.kt +++ b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/provider/TableEndpoint.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.annotation.provider +package com.raizlabs.dbflow5.annotation.provider import kotlin.reflect.KClass diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/converter/TypeConverters.kt b/dbflow-core/src/main/java/com/raizlabs/dbflow5/converter/TypeConverters.kt similarity index 94% rename from dbflow-core/src/main/java/com/raizlabs/android/dbflow/converter/TypeConverters.kt rename to dbflow-core/src/main/java/com/raizlabs/dbflow5/converter/TypeConverters.kt index a1d2b1fef..f13cef837 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/converter/TypeConverters.kt +++ b/dbflow-core/src/main/java/com/raizlabs/dbflow5/converter/TypeConverters.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.converter +package com.raizlabs.dbflow5.converter import java.math.BigDecimal import java.math.BigInteger @@ -11,7 +11,7 @@ import java.util.* * Description: This class is responsible for converting the stored database value into the field value in * a Model. */ -@com.raizlabs.android.dbflow.annotation.TypeConverter +@com.raizlabs.dbflow5.dbflow.annotation.TypeConverter abstract class TypeConverter { /** @@ -61,7 +61,7 @@ class BooleanConverter : TypeConverter() { /** * Description: Defines how we store and retrieve a [java.util.Calendar] */ -@com.raizlabs.android.dbflow.annotation.TypeConverter(allowedSubtypes = arrayOf(GregorianCalendar::class)) +@com.raizlabs.dbflow5.dbflow.annotation.TypeConverter(allowedSubtypes = arrayOf(GregorianCalendar::class)) class CalendarConverter : TypeConverter() { override fun getDBValue(model: Calendar?): Long? = model?.timeInMillis @@ -94,7 +94,7 @@ class DateConverter : TypeConverter() { /** * Description: Defines how we store and retrieve a [java.sql.Date] */ -@com.raizlabs.android.dbflow.annotation.TypeConverter(allowedSubtypes = arrayOf(Time::class, Timestamp::class)) +@com.raizlabs.dbflow5.dbflow.annotation.TypeConverter(allowedSubtypes = arrayOf(Time::class, Timestamp::class)) class SqlDateConverter : TypeConverter() { override fun getDBValue(model: java.sql.Date?): Long? = model?.time diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/data/Blob.kt b/dbflow-core/src/main/java/com/raizlabs/dbflow5/data/Blob.kt similarity index 86% rename from dbflow-core/src/main/java/com/raizlabs/android/dbflow/data/Blob.kt rename to dbflow-core/src/main/java/com/raizlabs/dbflow5/data/Blob.kt index 732f1b49d..57723da61 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/data/Blob.kt +++ b/dbflow-core/src/main/java/com/raizlabs/dbflow5/data/Blob.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.data +package com.raizlabs.dbflow5.data /** * Description: Provides a way to support blob format data. diff --git a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/sql/Query.kt b/dbflow-core/src/main/java/com/raizlabs/dbflow5/sql/Query.kt similarity index 82% rename from dbflow-core/src/main/java/com/raizlabs/android/dbflow/sql/Query.kt rename to dbflow-core/src/main/java/com/raizlabs/dbflow5/sql/Query.kt index f41e4732e..1bd91f464 100644 --- a/dbflow-core/src/main/java/com/raizlabs/android/dbflow/sql/Query.kt +++ b/dbflow-core/src/main/java/com/raizlabs/dbflow5/sql/Query.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.sql +package com.raizlabs.dbflow5.sql /** * Description: The basic interface for something that has a piece of a query. diff --git a/dbflow-core/src/main/java/com/raizlabs/dbflow5/sql/SQLiteType.kt b/dbflow-core/src/main/java/com/raizlabs/dbflow5/sql/SQLiteType.kt new file mode 100644 index 000000000..c139fcb10 --- /dev/null +++ b/dbflow-core/src/main/java/com/raizlabs/dbflow5/sql/SQLiteType.kt @@ -0,0 +1,67 @@ +package com.raizlabs.dbflow5.sql + +import com.raizlabs.dbflow5.data.Blob + +/** + * Description: Represents a type that SQLite understands. + */ +enum class SQLiteType { + + /** + * Represents an integer number in the DB. + */ + INTEGER, + + /** + * Represents a floating-point, precise number. + */ + REAL, + + /** + * Represents text. + */ + TEXT, + + /** + * A column defined by [byte[]] data. Usually reserved for images or larger pieces of content. + */ + BLOB; + + + companion object { + + private val sTypeMap = hashMapOf( + Byte::class.javaPrimitiveType!!.name to INTEGER, + Short::class.javaPrimitiveType!!.name to INTEGER, + Int::class.javaPrimitiveType!!.name to INTEGER, + Long::class.javaPrimitiveType!!.name to INTEGER, + Float::class.javaPrimitiveType!!.name to REAL, + Double::class.javaPrimitiveType!!.name to REAL, + Boolean::class.javaPrimitiveType!!.name to INTEGER, + Char::class.javaPrimitiveType!!.name to TEXT, + ByteArray::class.java.name to BLOB, + Byte::class.java.name to INTEGER, + Short::class.java.name to INTEGER, + Int::class.java.name to INTEGER, + Long::class.java.name to INTEGER, + Float::class.java.name to REAL, + Double::class.java.name to REAL, + Boolean::class.java.name to INTEGER, + Char::class.java.name to TEXT, + CharSequence::class.java.name to TEXT, + String::class.java.name to TEXT, + Array::class.java.name to BLOB, + Blob::class.java.name to BLOB) + + /** + * Returns the [SQLiteType] for this class + * + * @param className The fully qualified class name + * @return The type from the class name + */ + + operator fun get(className: String): SQLiteType? = sTypeMap[className] + + fun containsClass(className: String): Boolean = sTypeMap.containsKey(className) + } +} diff --git a/dbflow-coroutines/build.gradle b/dbflow-coroutines/build.gradle index 8e5feab59..f07f9942b 100644 --- a/dbflow-coroutines/build.gradle +++ b/dbflow-coroutines/build.gradle @@ -14,11 +14,11 @@ android { proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro' } } - } dependencies { implementation project("${dbflow_project_prefix}dbflow") + implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:0.19.2" } kotlin { diff --git a/dbflow-coroutines/src/main/AndroidManifest.xml b/dbflow-coroutines/src/main/AndroidManifest.xml index 15f15db30..00f38e852 100644 --- a/dbflow-coroutines/src/main/AndroidManifest.xml +++ b/dbflow-coroutines/src/main/AndroidManifest.xml @@ -1,2 +1 @@ - + diff --git a/dbflow-coroutines/src/main/java/com/raizlabs/dbflow/coroutines/Coroutines.kt b/dbflow-coroutines/src/main/java/com/raizlabs/dbflow5/coroutines/Coroutines.kt similarity index 86% rename from dbflow-coroutines/src/main/java/com/raizlabs/dbflow/coroutines/Coroutines.kt rename to dbflow-coroutines/src/main/java/com/raizlabs/dbflow5/coroutines/Coroutines.kt index 8a4885ec6..a56b49bc5 100644 --- a/dbflow-coroutines/src/main/java/com/raizlabs/dbflow/coroutines/Coroutines.kt +++ b/dbflow-coroutines/src/main/java/com/raizlabs/dbflow5/coroutines/Coroutines.kt @@ -1,17 +1,17 @@ -package com.raizlabs.dbflow.coroutines - -import com.raizlabs.android.dbflow.config.DatabaseDefinition -import com.raizlabs.android.dbflow.query.Queriable -import com.raizlabs.android.dbflow.structure.delete -import com.raizlabs.android.dbflow.structure.insert -import com.raizlabs.android.dbflow.structure.load -import com.raizlabs.android.dbflow.structure.save -import com.raizlabs.android.dbflow.structure.update -import com.raizlabs.android.dbflow.transaction.FastStoreModelTransaction -import com.raizlabs.android.dbflow.transaction.fastDelete -import com.raizlabs.android.dbflow.transaction.fastInsert -import com.raizlabs.android.dbflow.transaction.fastSave -import com.raizlabs.android.dbflow.transaction.fastUpdate +package com.raizlabs.dbflow5.coroutines + +import com.raizlabs.dbflow5.config.DatabaseDefinition +import com.raizlabs.dbflow5.query.Queriable +import com.raizlabs.dbflow5.structure.delete +import com.raizlabs.dbflow5.structure.insert +import com.raizlabs.dbflow5.structure.load +import com.raizlabs.dbflow5.structure.save +import com.raizlabs.dbflow5.structure.update +import com.raizlabs.dbflow5.transaction.FastStoreModelTransaction +import com.raizlabs.dbflow5.transaction.fastDelete +import com.raizlabs.dbflow5.transaction.fastInsert +import com.raizlabs.dbflow5.transaction.fastSave +import com.raizlabs.dbflow5.transaction.fastUpdate import kotlinx.coroutines.experimental.CancellableContinuation import kotlinx.coroutines.experimental.suspendCancellableCoroutine @@ -23,7 +23,7 @@ inline suspend fun DatabaseDefinition.transact( modelQueriable: Q, crossinline queriableFunction: Q.() -> R) = suspendCancellableCoroutine { continuation -> - com.raizlabs.dbflow.coroutines.constructCoroutine(continuation, this) { queriableFunction(modelQueriable) } + com.raizlabs.dbflow5.coroutines.constructCoroutine(continuation, this) { queriableFunction(modelQueriable) } } inline fun constructCoroutine(continuation: CancellableContinuation, diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/ClassNames.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/ClassNames.kt similarity index 96% rename from dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/ClassNames.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/ClassNames.kt index 2261abad8..f3c1ae9d1 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/ClassNames.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/ClassNames.kt @@ -1,6 +1,6 @@ -package com.raizlabs.android.dbflow.processor +package com.raizlabs.dbflow5.dbflow.processor -import com.raizlabs.android.dbflow.annotation.ConflictAction +import com.raizlabs.dbflow5.annotation.ConflictAction import com.squareup.javapoet.ClassName /** @@ -9,7 +9,7 @@ import com.squareup.javapoet.ClassName object ClassNames { - val BASE_PACKAGE = "com.raizlabs.android.dbflow" + val BASE_PACKAGE = "com.raizlabs.dbflow5.dbflow" val FLOW_MANAGER_PACKAGE = BASE_PACKAGE + ".config" val DATABASE_HOLDER_STATIC_CLASS_NAME = "GeneratedDatabaseHolder" val CONVERTER = BASE_PACKAGE + ".converter" diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/DBFlowProcessor.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/DBFlowProcessor.kt similarity index 78% rename from dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/DBFlowProcessor.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/DBFlowProcessor.kt index c3b7581a7..f21c0a4d6 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/DBFlowProcessor.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/DBFlowProcessor.kt @@ -1,15 +1,15 @@ -package com.raizlabs.android.dbflow.processor +package com.raizlabs.dbflow5.dbflow.processor -import com.raizlabs.android.dbflow.annotation.Column -import com.raizlabs.android.dbflow.annotation.ColumnIgnore -import com.raizlabs.android.dbflow.annotation.Migration -import com.raizlabs.android.dbflow.annotation.ModelView -import com.raizlabs.android.dbflow.annotation.QueryModel -import com.raizlabs.android.dbflow.annotation.Table -import com.raizlabs.android.dbflow.annotation.TypeConverter -import com.raizlabs.android.dbflow.annotation.provider.ContentProvider -import com.raizlabs.android.dbflow.annotation.provider.TableEndpoint -import com.raizlabs.android.dbflow.processor.definition.DatabaseHolderDefinition +import com.raizlabs.dbflow5.annotation.Column +import com.raizlabs.dbflow5.annotation.ColumnIgnore +import com.raizlabs.dbflow5.annotation.Migration +import com.raizlabs.dbflow5.annotation.ModelView +import com.raizlabs.dbflow5.annotation.QueryModel +import com.raizlabs.dbflow5.annotation.Table +import com.raizlabs.dbflow5.dbflow.annotation.TypeConverter +import com.raizlabs.dbflow5.annotation.provider.ContentProvider +import com.raizlabs.dbflow5.annotation.provider.TableEndpoint +import com.raizlabs.dbflow5.dbflow.processor.definition.DatabaseHolderDefinition import javax.annotation.processing.AbstractProcessor import javax.annotation.processing.ProcessingEnvironment import javax.annotation.processing.RoundEnvironment diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/Handlers.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/Handlers.kt similarity index 82% rename from dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/Handlers.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/Handlers.kt index c15468258..dfc9b74e2 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/Handlers.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/Handlers.kt @@ -1,33 +1,33 @@ -package com.raizlabs.android.dbflow.processor - -import com.raizlabs.android.dbflow.annotation.Database -import com.raizlabs.android.dbflow.annotation.ManyToMany -import com.raizlabs.android.dbflow.annotation.Migration -import com.raizlabs.android.dbflow.annotation.ModelView -import com.raizlabs.android.dbflow.annotation.MultipleManyToMany -import com.raizlabs.android.dbflow.annotation.QueryModel -import com.raizlabs.android.dbflow.annotation.Table -import com.raizlabs.android.dbflow.annotation.TypeConverter -import com.raizlabs.android.dbflow.annotation.provider.ContentProvider -import com.raizlabs.android.dbflow.annotation.provider.TableEndpoint -import com.raizlabs.android.dbflow.converter.BigDecimalConverter -import com.raizlabs.android.dbflow.converter.BigIntegerConverter -import com.raizlabs.android.dbflow.converter.BooleanConverter -import com.raizlabs.android.dbflow.converter.CalendarConverter -import com.raizlabs.android.dbflow.converter.CharConverter -import com.raizlabs.android.dbflow.converter.DateConverter -import com.raizlabs.android.dbflow.converter.SqlDateConverter -import com.raizlabs.android.dbflow.converter.UUIDConverter -import com.raizlabs.android.dbflow.processor.definition.ContentProviderDefinition -import com.raizlabs.android.dbflow.processor.definition.DatabaseDefinition -import com.raizlabs.android.dbflow.processor.definition.ManyToManyDefinition -import com.raizlabs.android.dbflow.processor.definition.MigrationDefinition -import com.raizlabs.android.dbflow.processor.definition.ModelViewDefinition -import com.raizlabs.android.dbflow.processor.definition.QueryModelDefinition -import com.raizlabs.android.dbflow.processor.definition.TableDefinition -import com.raizlabs.android.dbflow.processor.definition.TableEndpointDefinition -import com.raizlabs.android.dbflow.processor.definition.TypeConverterDefinition -import com.raizlabs.android.dbflow.processor.utils.annotation +package com.raizlabs.dbflow5.dbflow.processor + +import com.raizlabs.dbflow5.annotation.Database +import com.raizlabs.dbflow5.annotation.ManyToMany +import com.raizlabs.dbflow5.annotation.Migration +import com.raizlabs.dbflow5.annotation.ModelView +import com.raizlabs.dbflow5.annotation.MultipleManyToMany +import com.raizlabs.dbflow5.annotation.QueryModel +import com.raizlabs.dbflow5.annotation.Table +import com.raizlabs.dbflow5.dbflow.annotation.TypeConverter +import com.raizlabs.dbflow5.annotation.provider.ContentProvider +import com.raizlabs.dbflow5.annotation.provider.TableEndpoint +import com.raizlabs.dbflow5.converter.BigDecimalConverter +import com.raizlabs.dbflow5.converter.BigIntegerConverter +import com.raizlabs.dbflow5.converter.BooleanConverter +import com.raizlabs.dbflow5.converter.CalendarConverter +import com.raizlabs.dbflow5.converter.CharConverter +import com.raizlabs.dbflow5.converter.DateConverter +import com.raizlabs.dbflow5.converter.SqlDateConverter +import com.raizlabs.dbflow5.converter.UUIDConverter +import com.raizlabs.dbflow5.dbflow.processor.definition.ContentProviderDefinition +import com.raizlabs.dbflow5.dbflow.processor.definition.DatabaseDefinition +import com.raizlabs.dbflow5.dbflow.processor.definition.ManyToManyDefinition +import com.raizlabs.dbflow5.dbflow.processor.definition.MigrationDefinition +import com.raizlabs.dbflow5.dbflow.processor.definition.ModelViewDefinition +import com.raizlabs.dbflow5.dbflow.processor.definition.QueryModelDefinition +import com.raizlabs.dbflow5.dbflow.processor.definition.TableDefinition +import com.raizlabs.dbflow5.dbflow.processor.definition.TableEndpointDefinition +import com.raizlabs.dbflow5.dbflow.processor.definition.TypeConverterDefinition +import com.raizlabs.dbflow5.dbflow.processor.utils.annotation import javax.annotation.processing.RoundEnvironment import javax.lang.model.element.Element import javax.lang.model.element.PackageElement @@ -155,7 +155,7 @@ class TypeConverterHandler : BaseContainerHandler() { override fun onProcessElement(processorManager: ProcessorManager, element: Element) { if (element is TypeElement) { - val className = com.raizlabs.android.dbflow.processor.utils.fromTypeMirror(element.asType(), processorManager) + val className = com.raizlabs.dbflow5.dbflow.processor.utils.fromTypeMirror(element.asType(), processorManager) val converterDefinition = className?.let { TypeConverterDefinition(it, element.asType(), processorManager, element) } converterDefinition?.let { if (VALIDATOR.validate(processorManager, converterDefinition)) { diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/ProcessorManager.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/ProcessorManager.kt similarity index 94% rename from dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/ProcessorManager.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/ProcessorManager.kt index ae25daf32..75934419c 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/ProcessorManager.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/ProcessorManager.kt @@ -1,18 +1,18 @@ -package com.raizlabs.android.dbflow.processor - -import com.raizlabs.android.dbflow.processor.definition.BaseTableDefinition -import com.raizlabs.android.dbflow.processor.definition.ContentProviderDefinition -import com.raizlabs.android.dbflow.processor.definition.DatabaseDefinition -import com.raizlabs.android.dbflow.processor.definition.DatabaseHolderDefinition -import com.raizlabs.android.dbflow.processor.definition.DatabaseObjectHolder -import com.raizlabs.android.dbflow.processor.definition.ManyToManyDefinition -import com.raizlabs.android.dbflow.processor.definition.MigrationDefinition -import com.raizlabs.android.dbflow.processor.definition.ModelViewDefinition -import com.raizlabs.android.dbflow.processor.definition.QueryModelDefinition -import com.raizlabs.android.dbflow.processor.definition.TableDefinition -import com.raizlabs.android.dbflow.processor.definition.TableEndpointDefinition -import com.raizlabs.android.dbflow.processor.definition.TypeConverterDefinition -import com.raizlabs.android.dbflow.processor.utils.WriterUtils +package com.raizlabs.dbflow5.dbflow.processor + +import com.raizlabs.dbflow5.dbflow.processor.definition.BaseTableDefinition +import com.raizlabs.dbflow5.dbflow.processor.definition.ContentProviderDefinition +import com.raizlabs.dbflow5.dbflow.processor.definition.DatabaseDefinition +import com.raizlabs.dbflow5.dbflow.processor.definition.DatabaseHolderDefinition +import com.raizlabs.dbflow5.dbflow.processor.definition.DatabaseObjectHolder +import com.raizlabs.dbflow5.dbflow.processor.definition.ManyToManyDefinition +import com.raizlabs.dbflow5.dbflow.processor.definition.MigrationDefinition +import com.raizlabs.dbflow5.dbflow.processor.definition.ModelViewDefinition +import com.raizlabs.dbflow5.dbflow.processor.definition.QueryModelDefinition +import com.raizlabs.dbflow5.dbflow.processor.definition.TableDefinition +import com.raizlabs.dbflow5.dbflow.processor.definition.TableEndpointDefinition +import com.raizlabs.dbflow5.dbflow.processor.definition.TypeConverterDefinition +import com.raizlabs.dbflow5.dbflow.processor.utils.WriterUtils import com.squareup.javapoet.ClassName import com.squareup.javapoet.JavaFile import com.squareup.javapoet.TypeName diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/ProcessorUtils.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/ProcessorUtils.kt similarity index 93% rename from dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/ProcessorUtils.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/ProcessorUtils.kt index 36b4bf4bb..f551b9edd 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/ProcessorUtils.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/ProcessorUtils.kt @@ -1,9 +1,9 @@ -package com.raizlabs.android.dbflow.processor +package com.raizlabs.dbflow5.dbflow.processor -import com.raizlabs.android.dbflow.processor.ProcessorManager.Companion.manager -import com.raizlabs.android.dbflow.processor.utils.ElementUtility -import com.raizlabs.android.dbflow.processor.utils.erasure -import com.raizlabs.android.dbflow.processor.utils.toTypeElement +import com.raizlabs.dbflow5.dbflow.processor.ProcessorManager.Companion.manager +import com.raizlabs.dbflow5.dbflow.processor.utils.ElementUtility +import com.raizlabs.dbflow5.dbflow.processor.utils.erasure +import com.raizlabs.dbflow5.dbflow.processor.utils.toTypeElement import com.squareup.javapoet.ClassName import javax.annotation.processing.ProcessingEnvironment import javax.lang.model.element.Element diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/SQLiteHelper.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/SQLiteHelper.kt similarity index 97% rename from dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/SQLiteHelper.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/SQLiteHelper.kt index 1e838b16e..0501f2047 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/SQLiteHelper.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/SQLiteHelper.kt @@ -1,6 +1,6 @@ -package com.raizlabs.android.dbflow.processor +package com.raizlabs.dbflow5.dbflow.processor -import com.raizlabs.android.dbflow.data.Blob +import com.raizlabs.dbflow5.data.Blob import com.squareup.javapoet.ArrayTypeName import com.squareup.javapoet.ClassName import com.squareup.javapoet.TypeName diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/Validators.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/Validators.kt similarity index 96% rename from dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/Validators.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/Validators.kt index eff4f295c..eeec25c62 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/Validators.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/Validators.kt @@ -1,11 +1,11 @@ -package com.raizlabs.android.dbflow.processor - -import com.raizlabs.android.dbflow.processor.definition.* -import com.raizlabs.android.dbflow.processor.definition.column.ColumnDefinition -import com.raizlabs.android.dbflow.processor.definition.column.EnumColumnAccessor -import com.raizlabs.android.dbflow.processor.definition.column.ReferenceColumnDefinition -import com.raizlabs.android.dbflow.processor.definition.column.PrivateScopeColumnAccessor -import com.raizlabs.android.dbflow.processor.utils.isNullOrEmpty +package com.raizlabs.dbflow5.dbflow.processor + +import com.raizlabs.dbflow5.dbflow.processor.definition.* +import com.raizlabs.dbflow5.dbflow.processor.definition.column.ColumnDefinition +import com.raizlabs.dbflow5.dbflow.processor.definition.column.EnumColumnAccessor +import com.raizlabs.dbflow5.dbflow.processor.definition.column.ReferenceColumnDefinition +import com.raizlabs.dbflow5.dbflow.processor.definition.column.PrivateScopeColumnAccessor +import com.raizlabs.dbflow5.dbflow.processor.utils.isNullOrEmpty /** diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/Adders.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/Adders.kt similarity index 83% rename from dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/Adders.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/Adders.kt index ab6377a17..92cfe7c18 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/Adders.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/Adders.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.processor.definition +package com.raizlabs.dbflow5.dbflow.processor.definition import com.squareup.javapoet.CodeBlock import com.squareup.javapoet.TypeSpec diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/BaseDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/BaseDefinition.kt similarity index 93% rename from dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/BaseDefinition.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/BaseDefinition.kt index c9fc808e4..33749299c 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/BaseDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/BaseDefinition.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.processor.definition +package com.raizlabs.dbflow5.dbflow.processor.definition import com.grosner.kpoet.S import com.grosner.kpoet.`@` @@ -7,12 +7,12 @@ import com.grosner.kpoet.extends import com.grosner.kpoet.implements import com.grosner.kpoet.javadoc import com.grosner.kpoet.typeName -import com.raizlabs.android.dbflow.processor.ClassNames -import com.raizlabs.android.dbflow.processor.DBFlowProcessor -import com.raizlabs.android.dbflow.processor.ProcessorManager -import com.raizlabs.android.dbflow.processor.utils.ElementUtility -import com.raizlabs.android.dbflow.processor.utils.hasJavaX -import com.raizlabs.android.dbflow.processor.utils.toTypeElement +import com.raizlabs.dbflow5.dbflow.processor.ClassNames +import com.raizlabs.dbflow5.dbflow.processor.DBFlowProcessor +import com.raizlabs.dbflow5.dbflow.processor.ProcessorManager +import com.raizlabs.dbflow5.dbflow.processor.utils.ElementUtility +import com.raizlabs.dbflow5.dbflow.processor.utils.hasJavaX +import com.raizlabs.dbflow5.dbflow.processor.utils.toTypeElement import com.squareup.javapoet.ClassName import com.squareup.javapoet.ParameterizedTypeName import com.squareup.javapoet.TypeName diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/BaseTableDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/BaseTableDefinition.kt similarity index 91% rename from dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/BaseTableDefinition.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/BaseTableDefinition.kt index c2bce0538..f377c7eda 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/BaseTableDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/BaseTableDefinition.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.processor.definition +package com.raizlabs.dbflow5.dbflow.processor.definition import com.grosner.kpoet.`public static final` import com.grosner.kpoet.`return` @@ -9,16 +9,16 @@ import com.grosner.kpoet.modifiers import com.grosner.kpoet.param import com.grosner.kpoet.public import com.grosner.kpoet.statement -import com.raizlabs.android.dbflow.processor.ClassNames -import com.raizlabs.android.dbflow.processor.ProcessorManager -import com.raizlabs.android.dbflow.processor.definition.column.ColumnDefinition -import com.raizlabs.android.dbflow.processor.definition.column.PackagePrivateScopeColumnAccessor -import com.raizlabs.android.dbflow.processor.definition.column.ReferenceColumnDefinition -import com.raizlabs.android.dbflow.processor.utils.ElementUtility -import com.raizlabs.android.dbflow.processor.utils.ModelUtils -import com.raizlabs.android.dbflow.processor.utils.`override fun` -import com.raizlabs.android.dbflow.processor.utils.getPackage -import com.raizlabs.android.dbflow.processor.utils.toClassName +import com.raizlabs.dbflow5.dbflow.processor.ClassNames +import com.raizlabs.dbflow5.dbflow.processor.ProcessorManager +import com.raizlabs.dbflow5.dbflow.processor.definition.column.ColumnDefinition +import com.raizlabs.dbflow5.dbflow.processor.definition.column.PackagePrivateScopeColumnAccessor +import com.raizlabs.dbflow5.dbflow.processor.definition.column.ReferenceColumnDefinition +import com.raizlabs.dbflow5.dbflow.processor.utils.ElementUtility +import com.raizlabs.dbflow5.dbflow.processor.utils.ModelUtils +import com.raizlabs.dbflow5.dbflow.processor.utils.`override fun` +import com.raizlabs.dbflow5.dbflow.processor.utils.getPackage +import com.raizlabs.dbflow5.dbflow.processor.utils.toClassName import com.squareup.javapoet.ClassName import com.squareup.javapoet.JavaFile import com.squareup.javapoet.ParameterizedTypeName diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/ContentProvider.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/ContentProvider.kt similarity index 96% rename from dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/ContentProvider.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/ContentProvider.kt index 66c0cca72..18989a40e 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/ContentProvider.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/ContentProvider.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.processor.definition +package com.raizlabs.dbflow5.dbflow.processor.definition import com.grosner.kpoet.L import com.grosner.kpoet.`=` @@ -14,18 +14,18 @@ import com.grosner.kpoet.param import com.grosner.kpoet.parameterized import com.grosner.kpoet.public import com.grosner.kpoet.statement -import com.raizlabs.android.dbflow.annotation.provider.ContentProvider -import com.raizlabs.android.dbflow.annotation.provider.ContentUri -import com.raizlabs.android.dbflow.annotation.provider.NotifyMethod -import com.raizlabs.android.dbflow.annotation.provider.PathSegment -import com.raizlabs.android.dbflow.annotation.provider.TableEndpoint -import com.raizlabs.android.dbflow.processor.ClassNames -import com.raizlabs.android.dbflow.processor.ProcessorManager -import com.raizlabs.android.dbflow.processor.TableEndpointValidator -import com.raizlabs.android.dbflow.processor.utils.`override fun` -import com.raizlabs.android.dbflow.processor.utils.annotation -import com.raizlabs.android.dbflow.processor.utils.controlFlow -import com.raizlabs.android.dbflow.processor.utils.isNullOrEmpty +import com.raizlabs.dbflow5.annotation.provider.ContentProvider +import com.raizlabs.dbflow5.annotation.provider.ContentUri +import com.raizlabs.dbflow5.annotation.provider.NotifyMethod +import com.raizlabs.dbflow5.annotation.provider.PathSegment +import com.raizlabs.dbflow5.annotation.provider.TableEndpoint +import com.raizlabs.dbflow5.dbflow.processor.ClassNames +import com.raizlabs.dbflow5.dbflow.processor.ProcessorManager +import com.raizlabs.dbflow5.dbflow.processor.TableEndpointValidator +import com.raizlabs.dbflow5.dbflow.processor.utils.`override fun` +import com.raizlabs.dbflow5.dbflow.processor.utils.annotation +import com.raizlabs.dbflow5.dbflow.processor.utils.controlFlow +import com.raizlabs.dbflow5.dbflow.processor.utils.isNullOrEmpty import com.squareup.javapoet.ArrayTypeName import com.squareup.javapoet.ClassName import com.squareup.javapoet.CodeBlock diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/DatabaseDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/DatabaseDefinition.kt similarity index 94% rename from dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/DatabaseDefinition.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/DatabaseDefinition.kt index 6fa152484..da035901d 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/DatabaseDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/DatabaseDefinition.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.processor.definition +package com.raizlabs.dbflow5.dbflow.processor.definition import com.grosner.kpoet.L import com.grosner.kpoet.S @@ -9,14 +9,14 @@ import com.grosner.kpoet.modifiers import com.grosner.kpoet.param import com.grosner.kpoet.public import com.grosner.kpoet.statement -import com.raizlabs.android.dbflow.annotation.ConflictAction -import com.raizlabs.android.dbflow.annotation.Database -import com.raizlabs.android.dbflow.processor.ClassNames -import com.raizlabs.android.dbflow.processor.ModelViewValidator -import com.raizlabs.android.dbflow.processor.ProcessorManager -import com.raizlabs.android.dbflow.processor.TableValidator -import com.raizlabs.android.dbflow.processor.utils.`override fun` -import com.raizlabs.android.dbflow.processor.utils.annotation +import com.raizlabs.dbflow5.annotation.ConflictAction +import com.raizlabs.dbflow5.annotation.Database +import com.raizlabs.dbflow5.dbflow.processor.ClassNames +import com.raizlabs.dbflow5.dbflow.processor.ModelViewValidator +import com.raizlabs.dbflow5.dbflow.processor.ProcessorManager +import com.raizlabs.dbflow5.dbflow.processor.TableValidator +import com.raizlabs.dbflow5.dbflow.processor.utils.`override fun` +import com.raizlabs.dbflow5.dbflow.processor.utils.annotation import com.squareup.javapoet.ClassName import com.squareup.javapoet.ParameterizedTypeName import com.squareup.javapoet.TypeName diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/DatabaseHolderDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/DatabaseHolderDefinition.kt similarity index 89% rename from dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/DatabaseHolderDefinition.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/DatabaseHolderDefinition.kt index fb55ff3f8..5fda43833 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/DatabaseHolderDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/DatabaseHolderDefinition.kt @@ -1,9 +1,9 @@ -package com.raizlabs.android.dbflow.processor.definition +package com.raizlabs.dbflow5.dbflow.processor.definition import com.grosner.kpoet.* -import com.raizlabs.android.dbflow.processor.ClassNames -import com.raizlabs.android.dbflow.processor.DatabaseHandler -import com.raizlabs.android.dbflow.processor.ProcessorManager +import com.raizlabs.dbflow5.dbflow.processor.ClassNames +import com.raizlabs.dbflow5.dbflow.processor.DatabaseHandler +import com.raizlabs.dbflow5.dbflow.processor.ProcessorManager import com.squareup.javapoet.TypeSpec /** diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/DatabaseObjectHolder.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/DatabaseObjectHolder.kt similarity index 96% rename from dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/DatabaseObjectHolder.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/DatabaseObjectHolder.kt index cc83eb462..8c958ce63 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/DatabaseObjectHolder.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/DatabaseObjectHolder.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.processor.definition +package com.raizlabs.dbflow5.dbflow.processor.definition import com.squareup.javapoet.TypeName diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/IndexGroupsDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/IndexGroupsDefinition.kt similarity index 84% rename from dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/IndexGroupsDefinition.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/IndexGroupsDefinition.kt index 2c8f01bd5..aa5c61581 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/IndexGroupsDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/IndexGroupsDefinition.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.processor.definition +package com.raizlabs.dbflow5.dbflow.processor.definition import com.grosner.kpoet.S import com.grosner.kpoet.`=` @@ -6,9 +6,9 @@ import com.grosner.kpoet.field import com.grosner.kpoet.final import com.grosner.kpoet.public import com.grosner.kpoet.static -import com.raizlabs.android.dbflow.annotation.IndexGroup -import com.raizlabs.android.dbflow.processor.ClassNames -import com.raizlabs.android.dbflow.processor.definition.column.ColumnDefinition +import com.raizlabs.dbflow5.annotation.IndexGroup +import com.raizlabs.dbflow5.dbflow.processor.ClassNames +import com.raizlabs.dbflow5.dbflow.processor.definition.column.ColumnDefinition import com.squareup.javapoet.ParameterizedTypeName import java.util.concurrent.atomic.AtomicInteger diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/ManyToManyDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/ManyToManyDefinition.kt similarity index 87% rename from dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/ManyToManyDefinition.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/ManyToManyDefinition.kt index 1fc4ab1e1..7f36e03fc 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/ManyToManyDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/ManyToManyDefinition.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.processor.definition +package com.raizlabs.dbflow5.dbflow.processor.definition import com.grosner.kpoet.L import com.grosner.kpoet.`@` @@ -11,17 +11,17 @@ import com.grosner.kpoet.modifiers import com.grosner.kpoet.param import com.grosner.kpoet.public import com.grosner.kpoet.statement -import com.raizlabs.android.dbflow.annotation.ForeignKey -import com.raizlabs.android.dbflow.annotation.ManyToMany -import com.raizlabs.android.dbflow.annotation.PrimaryKey -import com.raizlabs.android.dbflow.annotation.Table -import com.raizlabs.android.dbflow.processor.ClassNames -import com.raizlabs.android.dbflow.processor.ProcessorManager -import com.raizlabs.android.dbflow.processor.utils.annotation -import com.raizlabs.android.dbflow.processor.utils.extractTypeNameFromAnnotation -import com.raizlabs.android.dbflow.processor.utils.isNullOrEmpty -import com.raizlabs.android.dbflow.processor.utils.lower -import com.raizlabs.android.dbflow.processor.utils.toTypeElement +import com.raizlabs.dbflow5.annotation.ForeignKey +import com.raizlabs.dbflow5.annotation.ManyToMany +import com.raizlabs.dbflow5.annotation.PrimaryKey +import com.raizlabs.dbflow5.annotation.Table +import com.raizlabs.dbflow5.dbflow.processor.ClassNames +import com.raizlabs.dbflow5.dbflow.processor.ProcessorManager +import com.raizlabs.dbflow5.dbflow.processor.utils.annotation +import com.raizlabs.dbflow5.dbflow.processor.utils.extractTypeNameFromAnnotation +import com.raizlabs.dbflow5.dbflow.processor.utils.isNullOrEmpty +import com.raizlabs.dbflow5.dbflow.processor.utils.lower +import com.raizlabs.dbflow5.dbflow.processor.utils.toTypeElement import com.squareup.javapoet.AnnotationSpec import com.squareup.javapoet.TypeName import com.squareup.javapoet.TypeSpec diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/Methods.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/Methods.kt similarity index 98% rename from dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/Methods.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/Methods.kt index a008ee974..5f31382a2 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/Methods.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/Methods.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.processor.definition +package com.raizlabs.dbflow5.dbflow.processor.definition import com.grosner.kpoet.S import com.grosner.kpoet.`=` @@ -10,13 +10,13 @@ import com.grosner.kpoet.modifiers import com.grosner.kpoet.param import com.grosner.kpoet.public import com.grosner.kpoet.statement -import com.raizlabs.android.dbflow.processor.ClassNames -import com.raizlabs.android.dbflow.processor.definition.column.wrapperCommaIfBaseModel -import com.raizlabs.android.dbflow.processor.utils.ModelUtils -import com.raizlabs.android.dbflow.processor.utils.`override fun` -import com.raizlabs.android.dbflow.processor.utils.codeBlock -import com.raizlabs.android.dbflow.processor.utils.isNullOrEmpty -import com.raizlabs.android.dbflow.quote +import com.raizlabs.dbflow5.dbflow.processor.ClassNames +import com.raizlabs.dbflow5.dbflow.processor.definition.column.wrapperCommaIfBaseModel +import com.raizlabs.dbflow5.dbflow.processor.utils.ModelUtils +import com.raizlabs.dbflow5.dbflow.processor.utils.`override fun` +import com.raizlabs.dbflow5.dbflow.processor.utils.codeBlock +import com.raizlabs.dbflow5.dbflow.processor.utils.isNullOrEmpty +import com.raizlabs.dbflow5.quote import com.squareup.javapoet.ClassName import com.squareup.javapoet.CodeBlock import com.squareup.javapoet.MethodSpec diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/MigrationDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/MigrationDefinition.kt similarity index 90% rename from dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/MigrationDefinition.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/MigrationDefinition.kt index 14d521abf..3ea9dff20 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/MigrationDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/MigrationDefinition.kt @@ -1,10 +1,10 @@ -package com.raizlabs.android.dbflow.processor.definition +package com.raizlabs.dbflow5.dbflow.processor.definition import com.grosner.kpoet.typeName -import com.raizlabs.android.dbflow.annotation.Migration -import com.raizlabs.android.dbflow.processor.ProcessorManager -import com.raizlabs.android.dbflow.processor.utils.annotation -import com.raizlabs.android.dbflow.processor.utils.isNullOrEmpty +import com.raizlabs.dbflow5.annotation.Migration +import com.raizlabs.dbflow5.dbflow.processor.ProcessorManager +import com.raizlabs.dbflow5.dbflow.processor.utils.annotation +import com.raizlabs.dbflow5.dbflow.processor.utils.isNullOrEmpty import com.squareup.javapoet.ClassName import com.squareup.javapoet.CodeBlock import com.squareup.javapoet.ParameterizedTypeName diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/ModelViewDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/ModelViewDefinition.kt similarity index 85% rename from dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/ModelViewDefinition.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/ModelViewDefinition.kt index 00f16d261..8f3a53340 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/ModelViewDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/ModelViewDefinition.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.processor.definition +package com.raizlabs.dbflow5.dbflow.processor.definition import com.grosner.kpoet.S import com.grosner.kpoet.`=` @@ -8,25 +8,25 @@ import com.grosner.kpoet.final import com.grosner.kpoet.modifiers import com.grosner.kpoet.param import com.grosner.kpoet.public -import com.raizlabs.android.dbflow.annotation.Column -import com.raizlabs.android.dbflow.annotation.ColumnMap -import com.raizlabs.android.dbflow.annotation.ModelView -import com.raizlabs.android.dbflow.annotation.ModelViewQuery -import com.raizlabs.android.dbflow.processor.ClassNames -import com.raizlabs.android.dbflow.processor.ColumnValidator -import com.raizlabs.android.dbflow.processor.ProcessorManager -import com.raizlabs.android.dbflow.processor.definition.column.ColumnDefinition -import com.raizlabs.android.dbflow.processor.definition.column.ReferenceColumnDefinition -import com.raizlabs.android.dbflow.processor.utils.ElementUtility -import com.raizlabs.android.dbflow.processor.utils.ModelUtils -import com.raizlabs.android.dbflow.processor.utils.`override fun` -import com.raizlabs.android.dbflow.processor.utils.annotation -import com.raizlabs.android.dbflow.processor.utils.ensureVisibleStatic -import com.raizlabs.android.dbflow.processor.utils.implementsClass -import com.raizlabs.android.dbflow.processor.utils.isNullOrEmpty -import com.raizlabs.android.dbflow.processor.utils.simpleString -import com.raizlabs.android.dbflow.processor.utils.toTypeElement -import com.raizlabs.android.dbflow.processor.utils.toTypeErasedElement +import com.raizlabs.dbflow5.annotation.Column +import com.raizlabs.dbflow5.annotation.ColumnMap +import com.raizlabs.dbflow5.annotation.ModelView +import com.raizlabs.dbflow5.annotation.ModelViewQuery +import com.raizlabs.dbflow5.dbflow.processor.ClassNames +import com.raizlabs.dbflow5.dbflow.processor.ColumnValidator +import com.raizlabs.dbflow5.dbflow.processor.ProcessorManager +import com.raizlabs.dbflow5.dbflow.processor.definition.column.ColumnDefinition +import com.raizlabs.dbflow5.dbflow.processor.definition.column.ReferenceColumnDefinition +import com.raizlabs.dbflow5.dbflow.processor.utils.ElementUtility +import com.raizlabs.dbflow5.dbflow.processor.utils.ModelUtils +import com.raizlabs.dbflow5.dbflow.processor.utils.`override fun` +import com.raizlabs.dbflow5.dbflow.processor.utils.annotation +import com.raizlabs.dbflow5.dbflow.processor.utils.ensureVisibleStatic +import com.raizlabs.dbflow5.dbflow.processor.utils.implementsClass +import com.raizlabs.dbflow5.dbflow.processor.utils.isNullOrEmpty +import com.raizlabs.dbflow5.dbflow.processor.utils.simpleString +import com.raizlabs.dbflow5.dbflow.processor.utils.toTypeElement +import com.raizlabs.dbflow5.dbflow.processor.utils.toTypeErasedElement import com.squareup.javapoet.ParameterizedTypeName import com.squareup.javapoet.TypeName import com.squareup.javapoet.TypeSpec diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/NotifyDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/NotifyDefinition.kt similarity index 85% rename from dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/NotifyDefinition.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/NotifyDefinition.kt index 97845d878..259223d17 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/NotifyDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/NotifyDefinition.kt @@ -1,10 +1,10 @@ -package com.raizlabs.android.dbflow.processor.definition +package com.raizlabs.dbflow5.dbflow.processor.definition -import com.raizlabs.android.dbflow.annotation.provider.Notify -import com.raizlabs.android.dbflow.annotation.provider.NotifyMethod -import com.raizlabs.android.dbflow.processor.ClassNames -import com.raizlabs.android.dbflow.processor.ProcessorManager -import com.raizlabs.android.dbflow.processor.utils.annotation +import com.raizlabs.dbflow5.annotation.provider.Notify +import com.raizlabs.dbflow5.annotation.provider.NotifyMethod +import com.raizlabs.dbflow5.dbflow.processor.ClassNames +import com.raizlabs.dbflow5.dbflow.processor.ProcessorManager +import com.raizlabs.dbflow5.dbflow.processor.utils.annotation import com.squareup.javapoet.ClassName import javax.lang.model.element.Element import javax.lang.model.element.ExecutableElement diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/OneToManyDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/OneToManyDefinition.kt similarity index 86% rename from dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/OneToManyDefinition.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/OneToManyDefinition.kt index 4cd191fbe..f5865a5db 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/OneToManyDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/OneToManyDefinition.kt @@ -1,27 +1,27 @@ -package com.raizlabs.android.dbflow.processor.definition +package com.raizlabs.dbflow5.dbflow.processor.definition import com.grosner.kpoet.`for` import com.grosner.kpoet.`if` import com.grosner.kpoet.end import com.grosner.kpoet.statement import com.grosner.kpoet.typeName -import com.raizlabs.android.dbflow.annotation.OneToMany -import com.raizlabs.android.dbflow.annotation.OneToManyMethod -import com.raizlabs.android.dbflow.processor.ClassNames -import com.raizlabs.android.dbflow.processor.ProcessorManager -import com.raizlabs.android.dbflow.processor.definition.column.ColumnAccessor -import com.raizlabs.android.dbflow.processor.definition.column.GetterSetter -import com.raizlabs.android.dbflow.processor.definition.column.PrivateScopeColumnAccessor -import com.raizlabs.android.dbflow.processor.definition.column.VisibleScopeColumnAccessor -import com.raizlabs.android.dbflow.processor.definition.column.modelBlock -import com.raizlabs.android.dbflow.processor.definition.column.wrapperCommaIfBaseModel -import com.raizlabs.android.dbflow.processor.definition.column.wrapperIfBaseModel -import com.raizlabs.android.dbflow.processor.utils.ModelUtils -import com.raizlabs.android.dbflow.processor.utils.annotation -import com.raizlabs.android.dbflow.processor.utils.isSubclass -import com.raizlabs.android.dbflow.processor.utils.simpleString -import com.raizlabs.android.dbflow.processor.utils.statement -import com.raizlabs.android.dbflow.processor.utils.toTypeElement +import com.raizlabs.dbflow5.annotation.OneToMany +import com.raizlabs.dbflow5.annotation.OneToManyMethod +import com.raizlabs.dbflow5.dbflow.processor.ClassNames +import com.raizlabs.dbflow5.dbflow.processor.ProcessorManager +import com.raizlabs.dbflow5.dbflow.processor.definition.column.ColumnAccessor +import com.raizlabs.dbflow5.dbflow.processor.definition.column.GetterSetter +import com.raizlabs.dbflow5.dbflow.processor.definition.column.PrivateScopeColumnAccessor +import com.raizlabs.dbflow5.dbflow.processor.definition.column.VisibleScopeColumnAccessor +import com.raizlabs.dbflow5.dbflow.processor.definition.column.modelBlock +import com.raizlabs.dbflow5.dbflow.processor.definition.column.wrapperCommaIfBaseModel +import com.raizlabs.dbflow5.dbflow.processor.definition.column.wrapperIfBaseModel +import com.raizlabs.dbflow5.dbflow.processor.utils.ModelUtils +import com.raizlabs.dbflow5.dbflow.processor.utils.annotation +import com.raizlabs.dbflow5.dbflow.processor.utils.isSubclass +import com.raizlabs.dbflow5.dbflow.processor.utils.simpleString +import com.raizlabs.dbflow5.dbflow.processor.utils.statement +import com.raizlabs.dbflow5.dbflow.processor.utils.toTypeElement import com.squareup.javapoet.ClassName import com.squareup.javapoet.CodeBlock import com.squareup.javapoet.MethodSpec diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/QueryModelDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/QueryModelDefinition.kt similarity index 84% rename from dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/QueryModelDefinition.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/QueryModelDefinition.kt index 1a6ecc07d..6287ddea6 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/QueryModelDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/QueryModelDefinition.kt @@ -1,22 +1,22 @@ -package com.raizlabs.android.dbflow.processor.definition +package com.raizlabs.dbflow5.dbflow.processor.definition import com.grosner.kpoet.`return` import com.grosner.kpoet.final import com.grosner.kpoet.modifiers import com.grosner.kpoet.public -import com.raizlabs.android.dbflow.annotation.Column -import com.raizlabs.android.dbflow.annotation.ColumnMap -import com.raizlabs.android.dbflow.annotation.QueryModel -import com.raizlabs.android.dbflow.processor.ClassNames -import com.raizlabs.android.dbflow.processor.ColumnValidator -import com.raizlabs.android.dbflow.processor.ProcessorManager -import com.raizlabs.android.dbflow.processor.definition.column.ColumnDefinition -import com.raizlabs.android.dbflow.processor.definition.column.ReferenceColumnDefinition -import com.raizlabs.android.dbflow.processor.utils.ElementUtility -import com.raizlabs.android.dbflow.processor.utils.`override fun` -import com.raizlabs.android.dbflow.processor.utils.annotation -import com.raizlabs.android.dbflow.processor.utils.extractTypeNameFromAnnotation -import com.raizlabs.android.dbflow.processor.utils.implementsClass +import com.raizlabs.dbflow5.annotation.Column +import com.raizlabs.dbflow5.annotation.ColumnMap +import com.raizlabs.dbflow5.annotation.QueryModel +import com.raizlabs.dbflow5.dbflow.processor.ClassNames +import com.raizlabs.dbflow5.dbflow.processor.ColumnValidator +import com.raizlabs.dbflow5.dbflow.processor.ProcessorManager +import com.raizlabs.dbflow5.dbflow.processor.definition.column.ColumnDefinition +import com.raizlabs.dbflow5.dbflow.processor.definition.column.ReferenceColumnDefinition +import com.raizlabs.dbflow5.dbflow.processor.utils.ElementUtility +import com.raizlabs.dbflow5.dbflow.processor.utils.`override fun` +import com.raizlabs.dbflow5.dbflow.processor.utils.annotation +import com.raizlabs.dbflow5.dbflow.processor.utils.extractTypeNameFromAnnotation +import com.raizlabs.dbflow5.dbflow.processor.utils.implementsClass import com.squareup.javapoet.ParameterizedTypeName import com.squareup.javapoet.TypeName import com.squareup.javapoet.TypeSpec diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/TableDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/TableDefinition.kt similarity index 93% rename from dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/TableDefinition.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/TableDefinition.kt index 4c36aa286..f67e1e937 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/TableDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/TableDefinition.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.processor.definition +package com.raizlabs.dbflow5.dbflow.processor.definition import com.grosner.kpoet.L import com.grosner.kpoet.S @@ -15,40 +15,40 @@ import com.grosner.kpoet.protected import com.grosner.kpoet.public import com.grosner.kpoet.statement import com.grosner.kpoet.switch -import com.raizlabs.android.dbflow.annotation.Column -import com.raizlabs.android.dbflow.annotation.ColumnMap -import com.raizlabs.android.dbflow.annotation.ConflictAction -import com.raizlabs.android.dbflow.annotation.DEFAULT_CACHE_SIZE -import com.raizlabs.android.dbflow.annotation.ForeignKey -import com.raizlabs.android.dbflow.annotation.InheritedColumn -import com.raizlabs.android.dbflow.annotation.InheritedPrimaryKey -import com.raizlabs.android.dbflow.annotation.ModelCacheField -import com.raizlabs.android.dbflow.annotation.MultiCacheField -import com.raizlabs.android.dbflow.annotation.OneToMany -import com.raizlabs.android.dbflow.annotation.PrimaryKey -import com.raizlabs.android.dbflow.annotation.Table -import com.raizlabs.android.dbflow.processor.ClassNames -import com.raizlabs.android.dbflow.processor.ColumnValidator -import com.raizlabs.android.dbflow.processor.OneToManyValidator -import com.raizlabs.android.dbflow.processor.ProcessorManager -import com.raizlabs.android.dbflow.processor.definition.BindToStatementMethod.Mode.DELETE -import com.raizlabs.android.dbflow.processor.definition.BindToStatementMethod.Mode.INSERT -import com.raizlabs.android.dbflow.processor.definition.BindToStatementMethod.Mode.NON_INSERT -import com.raizlabs.android.dbflow.processor.definition.BindToStatementMethod.Mode.UPDATE -import com.raizlabs.android.dbflow.processor.definition.column.ColumnDefinition -import com.raizlabs.android.dbflow.processor.definition.column.DefinitionUtils -import com.raizlabs.android.dbflow.processor.definition.column.ReferenceColumnDefinition -import com.raizlabs.android.dbflow.processor.utils.ElementUtility -import com.raizlabs.android.dbflow.processor.utils.ModelUtils -import com.raizlabs.android.dbflow.processor.utils.ModelUtils.wrapper -import com.raizlabs.android.dbflow.processor.utils.`override fun` -import com.raizlabs.android.dbflow.processor.utils.annotation -import com.raizlabs.android.dbflow.processor.utils.ensureVisibleStatic -import com.raizlabs.android.dbflow.processor.utils.implementsClass -import com.raizlabs.android.dbflow.processor.utils.isNullOrEmpty -import com.raizlabs.android.dbflow.quote -import com.raizlabs.android.dbflow.quoteIfNeeded -import com.raizlabs.android.dbflow.stripQuotes +import com.raizlabs.dbflow5.annotation.Column +import com.raizlabs.dbflow5.annotation.ColumnMap +import com.raizlabs.dbflow5.annotation.ConflictAction +import com.raizlabs.dbflow5.annotation.DEFAULT_CACHE_SIZE +import com.raizlabs.dbflow5.annotation.ForeignKey +import com.raizlabs.dbflow5.annotation.InheritedColumn +import com.raizlabs.dbflow5.annotation.InheritedPrimaryKey +import com.raizlabs.dbflow5.annotation.ModelCacheField +import com.raizlabs.dbflow5.annotation.MultiCacheField +import com.raizlabs.dbflow5.annotation.OneToMany +import com.raizlabs.dbflow5.annotation.PrimaryKey +import com.raizlabs.dbflow5.annotation.Table +import com.raizlabs.dbflow5.dbflow.processor.ClassNames +import com.raizlabs.dbflow5.dbflow.processor.ColumnValidator +import com.raizlabs.dbflow5.dbflow.processor.OneToManyValidator +import com.raizlabs.dbflow5.dbflow.processor.ProcessorManager +import com.raizlabs.dbflow5.dbflow.processor.definition.BindToStatementMethod.Mode.DELETE +import com.raizlabs.dbflow5.dbflow.processor.definition.BindToStatementMethod.Mode.INSERT +import com.raizlabs.dbflow5.dbflow.processor.definition.BindToStatementMethod.Mode.NON_INSERT +import com.raizlabs.dbflow5.dbflow.processor.definition.BindToStatementMethod.Mode.UPDATE +import com.raizlabs.dbflow5.dbflow.processor.definition.column.ColumnDefinition +import com.raizlabs.dbflow5.dbflow.processor.definition.column.DefinitionUtils +import com.raizlabs.dbflow5.dbflow.processor.definition.column.ReferenceColumnDefinition +import com.raizlabs.dbflow5.dbflow.processor.utils.ElementUtility +import com.raizlabs.dbflow5.dbflow.processor.utils.ModelUtils +import com.raizlabs.dbflow5.dbflow.processor.utils.ModelUtils.wrapper +import com.raizlabs.dbflow5.dbflow.processor.utils.`override fun` +import com.raizlabs.dbflow5.dbflow.processor.utils.annotation +import com.raizlabs.dbflow5.dbflow.processor.utils.ensureVisibleStatic +import com.raizlabs.dbflow5.dbflow.processor.utils.implementsClass +import com.raizlabs.dbflow5.dbflow.processor.utils.isNullOrEmpty +import com.raizlabs.dbflow5.quote +import com.raizlabs.dbflow5.quoteIfNeeded +import com.raizlabs.dbflow5.stripQuotes import com.squareup.javapoet.ArrayTypeName import com.squareup.javapoet.ClassName import com.squareup.javapoet.CodeBlock diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/TableEndpointDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/TableEndpointDefinition.kt similarity index 81% rename from dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/TableEndpointDefinition.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/TableEndpointDefinition.kt index 333b214d8..0e1e2597e 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/TableEndpointDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/TableEndpointDefinition.kt @@ -1,12 +1,12 @@ -package com.raizlabs.android.dbflow.processor.definition +package com.raizlabs.dbflow5.dbflow.processor.definition -import com.raizlabs.android.dbflow.annotation.provider.ContentUri -import com.raizlabs.android.dbflow.annotation.provider.Notify -import com.raizlabs.android.dbflow.annotation.provider.NotifyMethod -import com.raizlabs.android.dbflow.annotation.provider.TableEndpoint -import com.raizlabs.android.dbflow.processor.ProcessorManager -import com.raizlabs.android.dbflow.processor.utils.annotation -import com.raizlabs.android.dbflow.processor.utils.extractTypeNameFromAnnotation +import com.raizlabs.dbflow5.annotation.provider.ContentUri +import com.raizlabs.dbflow5.annotation.provider.Notify +import com.raizlabs.dbflow5.annotation.provider.NotifyMethod +import com.raizlabs.dbflow5.annotation.provider.TableEndpoint +import com.raizlabs.dbflow5.dbflow.processor.ProcessorManager +import com.raizlabs.dbflow5.dbflow.processor.utils.annotation +import com.raizlabs.dbflow5.dbflow.processor.utils.extractTypeNameFromAnnotation import com.squareup.javapoet.TypeName import javax.lang.model.element.Element import javax.lang.model.element.PackageElement diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/TypeConverterDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/TypeConverterDefinition.kt similarity index 86% rename from dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/TypeConverterDefinition.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/TypeConverterDefinition.kt index 0f4e698c0..ae66dcda2 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/TypeConverterDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/TypeConverterDefinition.kt @@ -1,9 +1,9 @@ -package com.raizlabs.android.dbflow.processor.definition +package com.raizlabs.dbflow5.dbflow.processor.definition -import com.raizlabs.android.dbflow.annotation.TypeConverter -import com.raizlabs.android.dbflow.processor.ClassNames -import com.raizlabs.android.dbflow.processor.ProcessorManager -import com.raizlabs.android.dbflow.processor.utils.annotation +import com.raizlabs.dbflow5.dbflow.annotation.TypeConverter +import com.raizlabs.dbflow5.dbflow.processor.ClassNames +import com.raizlabs.dbflow5.dbflow.processor.ProcessorManager +import com.raizlabs.dbflow5.dbflow.processor.utils.annotation import com.squareup.javapoet.ClassName import com.squareup.javapoet.TypeName import javax.lang.model.element.TypeElement diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/TypeDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/TypeDefinition.kt similarity index 81% rename from dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/TypeDefinition.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/TypeDefinition.kt index a88ad1d68..b02484495 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/TypeDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/TypeDefinition.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.processor.definition +package com.raizlabs.dbflow5.dbflow.processor.definition import com.squareup.javapoet.TypeSpec diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/UniqueGroupsDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/UniqueGroupsDefinition.kt similarity index 78% rename from dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/UniqueGroupsDefinition.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/UniqueGroupsDefinition.kt index cb84d3647..f19c015f1 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/UniqueGroupsDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/UniqueGroupsDefinition.kt @@ -1,10 +1,10 @@ -package com.raizlabs.android.dbflow.processor.definition +package com.raizlabs.dbflow5.dbflow.processor.definition -import com.raizlabs.android.dbflow.annotation.ConflictAction -import com.raizlabs.android.dbflow.annotation.UniqueGroup -import com.raizlabs.android.dbflow.processor.definition.column.ColumnDefinition -import com.raizlabs.android.dbflow.processor.definition.column.ReferenceColumnDefinition -import com.raizlabs.android.dbflow.quote +import com.raizlabs.dbflow5.annotation.ConflictAction +import com.raizlabs.dbflow5.annotation.UniqueGroup +import com.raizlabs.dbflow5.dbflow.processor.definition.column.ColumnDefinition +import com.raizlabs.dbflow5.dbflow.processor.definition.column.ReferenceColumnDefinition +import com.raizlabs.dbflow5.quote import com.squareup.javapoet.CodeBlock /** diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ColumnAccessCombiner.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/column/ColumnAccessCombiner.kt similarity index 97% rename from dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ColumnAccessCombiner.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/column/ColumnAccessCombiner.kt index 3a69b80fd..d56b2e89c 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ColumnAccessCombiner.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/column/ColumnAccessCombiner.kt @@ -1,17 +1,17 @@ -package com.raizlabs.android.dbflow.processor.definition.column +package com.raizlabs.dbflow5.dbflow.processor.definition.column import com.grosner.kpoet.S import com.grosner.kpoet.`else` import com.grosner.kpoet.`if` import com.grosner.kpoet.end import com.grosner.kpoet.statement -import com.raizlabs.android.dbflow.processor.ClassNames -import com.raizlabs.android.dbflow.processor.SQLiteHelper -import com.raizlabs.android.dbflow.processor.utils.ModelUtils -import com.raizlabs.android.dbflow.processor.utils.catch -import com.raizlabs.android.dbflow.processor.utils.isNullOrEmpty -import com.raizlabs.android.dbflow.processor.utils.statement -import com.raizlabs.android.dbflow.quote +import com.raizlabs.dbflow5.dbflow.processor.ClassNames +import com.raizlabs.dbflow5.dbflow.processor.SQLiteHelper +import com.raizlabs.dbflow5.dbflow.processor.utils.ModelUtils +import com.raizlabs.dbflow5.dbflow.processor.utils.catch +import com.raizlabs.dbflow5.dbflow.processor.utils.isNullOrEmpty +import com.raizlabs.dbflow5.dbflow.processor.utils.statement +import com.raizlabs.dbflow5.quote import com.squareup.javapoet.ClassName import com.squareup.javapoet.CodeBlock import com.squareup.javapoet.NameAllocator diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ColumnAccessor.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/column/ColumnAccessor.kt similarity index 97% rename from dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ColumnAccessor.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/column/ColumnAccessor.kt index 180eee6e1..0ce94935a 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ColumnAccessor.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/column/ColumnAccessor.kt @@ -1,10 +1,10 @@ -package com.raizlabs.android.dbflow.processor.definition.column +package com.raizlabs.dbflow5.dbflow.processor.definition.column import com.grosner.kpoet.code -import com.raizlabs.android.dbflow.data.Blob -import com.raizlabs.android.dbflow.processor.utils.capitalizeFirstLetter -import com.raizlabs.android.dbflow.processor.utils.isNullOrEmpty -import com.raizlabs.android.dbflow.processor.utils.lower +import com.raizlabs.dbflow5.data.Blob +import com.raizlabs.dbflow5.dbflow.processor.utils.capitalizeFirstLetter +import com.raizlabs.dbflow5.dbflow.processor.utils.isNullOrEmpty +import com.raizlabs.dbflow5.dbflow.processor.utils.lower import com.squareup.javapoet.ClassName import com.squareup.javapoet.CodeBlock import com.squareup.javapoet.TypeName diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ColumnDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/column/ColumnDefinition.kt similarity index 93% rename from dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ColumnDefinition.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/column/ColumnDefinition.kt index 9dacf1968..1d8981aa7 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ColumnDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/column/ColumnDefinition.kt @@ -1,28 +1,28 @@ -package com.raizlabs.android.dbflow.processor.definition.column +package com.raizlabs.dbflow5.dbflow.processor.definition.column import com.grosner.kpoet.code -import com.raizlabs.android.dbflow.annotation.Collate -import com.raizlabs.android.dbflow.annotation.Column -import com.raizlabs.android.dbflow.annotation.ConflictAction -import com.raizlabs.android.dbflow.annotation.INDEX_GENERIC -import com.raizlabs.android.dbflow.annotation.Index -import com.raizlabs.android.dbflow.annotation.NotNull -import com.raizlabs.android.dbflow.annotation.PrimaryKey -import com.raizlabs.android.dbflow.annotation.Unique -import com.raizlabs.android.dbflow.data.Blob -import com.raizlabs.android.dbflow.processor.ClassNames -import com.raizlabs.android.dbflow.processor.ProcessorManager -import com.raizlabs.android.dbflow.processor.definition.BaseDefinition -import com.raizlabs.android.dbflow.processor.definition.BaseTableDefinition -import com.raizlabs.android.dbflow.processor.definition.TableDefinition -import com.raizlabs.android.dbflow.processor.definition.TypeConverterDefinition -import com.raizlabs.android.dbflow.processor.utils.annotation -import com.raizlabs.android.dbflow.processor.utils.fromTypeMirror -import com.raizlabs.android.dbflow.processor.utils.getTypeElement -import com.raizlabs.android.dbflow.processor.utils.isNullOrEmpty -import com.raizlabs.android.dbflow.processor.utils.toClassName -import com.raizlabs.android.dbflow.processor.utils.toTypeElement -import com.raizlabs.android.dbflow.quote +import com.raizlabs.dbflow5.annotation.Collate +import com.raizlabs.dbflow5.annotation.Column +import com.raizlabs.dbflow5.annotation.ConflictAction +import com.raizlabs.dbflow5.annotation.INDEX_GENERIC +import com.raizlabs.dbflow5.annotation.Index +import com.raizlabs.dbflow5.annotation.NotNull +import com.raizlabs.dbflow5.annotation.PrimaryKey +import com.raizlabs.dbflow5.annotation.Unique +import com.raizlabs.dbflow5.data.Blob +import com.raizlabs.dbflow5.dbflow.processor.ClassNames +import com.raizlabs.dbflow5.dbflow.processor.ProcessorManager +import com.raizlabs.dbflow5.dbflow.processor.definition.BaseDefinition +import com.raizlabs.dbflow5.dbflow.processor.definition.BaseTableDefinition +import com.raizlabs.dbflow5.dbflow.processor.definition.TableDefinition +import com.raizlabs.dbflow5.dbflow.processor.definition.TypeConverterDefinition +import com.raizlabs.dbflow5.dbflow.processor.utils.annotation +import com.raizlabs.dbflow5.dbflow.processor.utils.fromTypeMirror +import com.raizlabs.dbflow5.dbflow.processor.utils.getTypeElement +import com.raizlabs.dbflow5.dbflow.processor.utils.isNullOrEmpty +import com.raizlabs.dbflow5.dbflow.processor.utils.toClassName +import com.raizlabs.dbflow5.dbflow.processor.utils.toTypeElement +import com.raizlabs.dbflow5.quote import com.squareup.javapoet.ArrayTypeName import com.squareup.javapoet.ClassName import com.squareup.javapoet.CodeBlock diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/DefinitionUtils.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/column/DefinitionUtils.kt similarity index 85% rename from dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/DefinitionUtils.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/column/DefinitionUtils.kt index 9901044c4..2503d1761 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/DefinitionUtils.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/column/DefinitionUtils.kt @@ -1,7 +1,7 @@ -package com.raizlabs.android.dbflow.processor.definition.column +package com.raizlabs.dbflow5.dbflow.processor.definition.column -import com.raizlabs.android.dbflow.processor.SQLiteHelper -import com.raizlabs.android.dbflow.quote +import com.raizlabs.dbflow5.dbflow.processor.SQLiteHelper +import com.raizlabs.dbflow5.quote import com.squareup.javapoet.CodeBlock import com.squareup.javapoet.TypeName diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ForeignKeyAccessCombiner.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/column/ForeignKeyAccessCombiner.kt similarity index 96% rename from dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ForeignKeyAccessCombiner.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/column/ForeignKeyAccessCombiner.kt index 3b0969111..a26687a0d 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ForeignKeyAccessCombiner.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/column/ForeignKeyAccessCombiner.kt @@ -1,8 +1,8 @@ -package com.raizlabs.android.dbflow.processor.definition.column +package com.raizlabs.dbflow5.dbflow.processor.definition.column -import com.raizlabs.android.dbflow.processor.ClassNames -import com.raizlabs.android.dbflow.processor.SQLiteHelper -import com.raizlabs.android.dbflow.processor.utils.statement +import com.raizlabs.dbflow5.dbflow.processor.ClassNames +import com.raizlabs.dbflow5.dbflow.processor.SQLiteHelper +import com.raizlabs.dbflow5.dbflow.processor.utils.statement import com.squareup.javapoet.ClassName import com.squareup.javapoet.CodeBlock import com.squareup.javapoet.NameAllocator diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ReferenceColumnDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/column/ReferenceColumnDefinition.kt similarity index 92% rename from dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ReferenceColumnDefinition.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/column/ReferenceColumnDefinition.kt index 09233e19f..2646b76de 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ReferenceColumnDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/column/ReferenceColumnDefinition.kt @@ -1,29 +1,29 @@ -package com.raizlabs.android.dbflow.processor.definition.column +package com.raizlabs.dbflow5.dbflow.processor.definition.column import com.grosner.kpoet.S import com.grosner.kpoet.`return` import com.grosner.kpoet.case -import com.raizlabs.android.dbflow.annotation.ColumnMap -import com.raizlabs.android.dbflow.annotation.ConflictAction -import com.raizlabs.android.dbflow.annotation.ForeignKey -import com.raizlabs.android.dbflow.annotation.ForeignKeyAction -import com.raizlabs.android.dbflow.annotation.ForeignKeyReference -import com.raizlabs.android.dbflow.annotation.QueryModel -import com.raizlabs.android.dbflow.annotation.Table -import com.raizlabs.android.dbflow.processor.ClassNames -import com.raizlabs.android.dbflow.processor.ProcessorManager -import com.raizlabs.android.dbflow.processor.definition.BaseTableDefinition -import com.raizlabs.android.dbflow.processor.definition.QueryModelDefinition -import com.raizlabs.android.dbflow.processor.definition.TableDefinition -import com.raizlabs.android.dbflow.processor.utils.annotation -import com.raizlabs.android.dbflow.processor.utils.fromTypeMirror -import com.raizlabs.android.dbflow.processor.utils.implementsClass -import com.raizlabs.android.dbflow.processor.utils.isNullOrEmpty -import com.raizlabs.android.dbflow.processor.utils.isSubclass -import com.raizlabs.android.dbflow.processor.utils.toTypeElement -import com.raizlabs.android.dbflow.processor.utils.toTypeErasedElement -import com.raizlabs.android.dbflow.quote -import com.raizlabs.android.dbflow.quoteIfNeeded +import com.raizlabs.dbflow5.annotation.ColumnMap +import com.raizlabs.dbflow5.annotation.ConflictAction +import com.raizlabs.dbflow5.annotation.ForeignKey +import com.raizlabs.dbflow5.annotation.ForeignKeyAction +import com.raizlabs.dbflow5.annotation.ForeignKeyReference +import com.raizlabs.dbflow5.annotation.QueryModel +import com.raizlabs.dbflow5.annotation.Table +import com.raizlabs.dbflow5.dbflow.processor.ClassNames +import com.raizlabs.dbflow5.dbflow.processor.ProcessorManager +import com.raizlabs.dbflow5.dbflow.processor.definition.BaseTableDefinition +import com.raizlabs.dbflow5.dbflow.processor.definition.QueryModelDefinition +import com.raizlabs.dbflow5.dbflow.processor.definition.TableDefinition +import com.raizlabs.dbflow5.dbflow.processor.utils.annotation +import com.raizlabs.dbflow5.dbflow.processor.utils.fromTypeMirror +import com.raizlabs.dbflow5.dbflow.processor.utils.implementsClass +import com.raizlabs.dbflow5.dbflow.processor.utils.isNullOrEmpty +import com.raizlabs.dbflow5.dbflow.processor.utils.isSubclass +import com.raizlabs.dbflow5.dbflow.processor.utils.toTypeElement +import com.raizlabs.dbflow5.dbflow.processor.utils.toTypeErasedElement +import com.raizlabs.dbflow5.quote +import com.raizlabs.dbflow5.quoteIfNeeded import com.squareup.javapoet.ClassName import com.squareup.javapoet.CodeBlock import com.squareup.javapoet.FieldSpec diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ReferenceDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/column/ReferenceDefinition.kt similarity index 93% rename from dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ReferenceDefinition.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/column/ReferenceDefinition.kt index ba00b72be..4e1156223 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/definition/column/ReferenceDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/column/ReferenceDefinition.kt @@ -1,12 +1,12 @@ -package com.raizlabs.android.dbflow.processor.definition.column - -import com.raizlabs.android.dbflow.annotation.ConflictAction -import com.raizlabs.android.dbflow.data.Blob -import com.raizlabs.android.dbflow.processor.ProcessorManager -import com.raizlabs.android.dbflow.processor.definition.TypeConverterDefinition -import com.raizlabs.android.dbflow.processor.utils.ElementUtility -import com.raizlabs.android.dbflow.processor.utils.isNullOrEmpty -import com.raizlabs.android.dbflow.quote +package com.raizlabs.dbflow5.dbflow.processor.definition.column + +import com.raizlabs.dbflow5.annotation.ConflictAction +import com.raizlabs.dbflow5.data.Blob +import com.raizlabs.dbflow5.dbflow.processor.ProcessorManager +import com.raizlabs.dbflow5.dbflow.processor.definition.TypeConverterDefinition +import com.raizlabs.dbflow5.dbflow.processor.utils.ElementUtility +import com.raizlabs.dbflow5.dbflow.processor.utils.isNullOrEmpty +import com.raizlabs.dbflow5.quote import com.squareup.javapoet.ClassName import com.squareup.javapoet.CodeBlock import com.squareup.javapoet.TypeName diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/utils/CodeExtensions.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/CodeExtensions.kt similarity index 96% rename from dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/utils/CodeExtensions.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/CodeExtensions.kt index ad1a58f68..de11857f0 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/utils/CodeExtensions.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/CodeExtensions.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.processor.utils +package com.raizlabs.dbflow5.dbflow.processor.utils import com.grosner.kpoet.end import com.grosner.kpoet.nextControl diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/utils/DependencyUtils.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/DependencyUtils.kt similarity index 65% rename from dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/utils/DependencyUtils.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/DependencyUtils.kt index 20d449c8a..478e81795 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/utils/DependencyUtils.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/DependencyUtils.kt @@ -1,6 +1,6 @@ -package com.raizlabs.android.dbflow.processor.utils +package com.raizlabs.dbflow5.dbflow.processor.utils -import com.raizlabs.android.dbflow.processor.ProcessorManager +import com.raizlabs.dbflow5.dbflow.processor.ProcessorManager /** * Used to check if class exists on class path, if so, we add the annotation to generated class files. diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/utils/ElementExtensions.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/ElementExtensions.kt similarity index 91% rename from dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/utils/ElementExtensions.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/ElementExtensions.kt index 5ff5af720..d596320fa 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/utils/ElementExtensions.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/ElementExtensions.kt @@ -1,6 +1,6 @@ -package com.raizlabs.android.dbflow.processor.utils +package com.raizlabs.dbflow5.dbflow.processor.utils -import com.raizlabs.android.dbflow.processor.ProcessorManager +import com.raizlabs.dbflow5.dbflow.processor.ProcessorManager import com.squareup.javapoet.ClassName import com.squareup.javapoet.TypeName import javax.lang.model.element.Element diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/utils/ElementUtility.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/ElementUtility.kt similarity index 93% rename from dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/utils/ElementUtility.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/ElementUtility.kt index 5e377fe47..93f30ed48 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/utils/ElementUtility.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/ElementUtility.kt @@ -1,7 +1,7 @@ -package com.raizlabs.android.dbflow.processor.utils +package com.raizlabs.dbflow5.dbflow.processor.utils -import com.raizlabs.android.dbflow.annotation.ColumnIgnore -import com.raizlabs.android.dbflow.processor.ProcessorManager +import com.raizlabs.dbflow5.annotation.ColumnIgnore +import com.raizlabs.dbflow5.dbflow.processor.ProcessorManager import com.squareup.javapoet.ClassName import javax.lang.model.element.Element import javax.lang.model.element.Modifier diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/utils/JavaPoetExtensions.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/JavaPoetExtensions.kt similarity index 97% rename from dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/utils/JavaPoetExtensions.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/JavaPoetExtensions.kt index aacfa2dbd..b3654a4ab 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/utils/JavaPoetExtensions.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/JavaPoetExtensions.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.processor.utils +package com.raizlabs.dbflow5.dbflow.processor.utils import com.grosner.kpoet.returns import com.squareup.javapoet.MethodSpec diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/utils/ModelUtils.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/ModelUtils.kt similarity index 60% rename from dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/utils/ModelUtils.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/ModelUtils.kt index acd1a38e9..bc64a8bdb 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/utils/ModelUtils.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/ModelUtils.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.processor.utils +package com.raizlabs.dbflow5.dbflow.processor.utils object ModelUtils { diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/utils/ProcessorUtils.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/ProcessorUtils.kt similarity index 96% rename from dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/utils/ProcessorUtils.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/ProcessorUtils.kt index fecd80650..c330b1f9e 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/utils/ProcessorUtils.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/ProcessorUtils.kt @@ -1,7 +1,7 @@ -package com.raizlabs.android.dbflow.processor.utils +package com.raizlabs.dbflow5.dbflow.processor.utils -import com.raizlabs.android.dbflow.processor.ProcessorManager -import com.raizlabs.android.dbflow.processor.ProcessorManager.Companion.manager +import com.raizlabs.dbflow5.dbflow.processor.ProcessorManager +import com.raizlabs.dbflow5.dbflow.processor.ProcessorManager.Companion.manager import com.squareup.javapoet.ClassName import com.squareup.javapoet.TypeName import javax.annotation.processing.ProcessingEnvironment diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/utils/StringUtils.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/StringUtils.kt similarity index 90% rename from dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/utils/StringUtils.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/StringUtils.kt index f03f7fa61..ffe3201f0 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/utils/StringUtils.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/StringUtils.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.processor.utils +package com.raizlabs.dbflow5.dbflow.processor.utils /** * Description: diff --git a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/utils/WriterUtils.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/WriterUtils.kt similarity index 81% rename from dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/utils/WriterUtils.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/WriterUtils.kt index 281dedeca..c6c661eef 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/android/dbflow/processor/utils/WriterUtils.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/WriterUtils.kt @@ -1,8 +1,8 @@ -package com.raizlabs.android.dbflow.processor.utils +package com.raizlabs.dbflow5.dbflow.processor.utils import com.grosner.kpoet.javaFile -import com.raizlabs.android.dbflow.processor.ProcessorManager -import com.raizlabs.android.dbflow.processor.definition.BaseDefinition +import com.raizlabs.dbflow5.dbflow.processor.ProcessorManager +import com.raizlabs.dbflow5.dbflow.processor.definition.BaseDefinition import java.io.IOException /** diff --git a/dbflow-processor/src/main/resources/META-INF/services/javax.annotation.processing.Processor b/dbflow-processor/src/main/resources/META-INF/services/javax.annotation.processing.Processor index 0d2dfaf75..1dd33ebb1 100644 --- a/dbflow-processor/src/main/resources/META-INF/services/javax.annotation.processing.Processor +++ b/dbflow-processor/src/main/resources/META-INF/services/javax.annotation.processing.Processor @@ -1 +1 @@ -com.raizlabs.android.dbflow.processor.DBFlowProcessor \ No newline at end of file +com.raizlabs.dbflow5.dbflow.processor.DBFlowProcessor \ No newline at end of file diff --git a/dbflow-processor/src/test/java/com/raizlabs/android/dbflow/processor/test/ColumnAccessCombinerTests.kt b/dbflow-processor/src/test/java/com/raizlabs/dbflow5/dbflow/processor/test/ColumnAccessCombinerTests.kt similarity index 98% rename from dbflow-processor/src/test/java/com/raizlabs/android/dbflow/processor/test/ColumnAccessCombinerTests.kt rename to dbflow-processor/src/test/java/com/raizlabs/dbflow5/dbflow/processor/test/ColumnAccessCombinerTests.kt index 0d35405c5..519e0fe3e 100644 --- a/dbflow-processor/src/test/java/com/raizlabs/android/dbflow/processor/test/ColumnAccessCombinerTests.kt +++ b/dbflow-processor/src/test/java/com/raizlabs/dbflow5/dbflow/processor/test/ColumnAccessCombinerTests.kt @@ -1,7 +1,7 @@ -package com.raizlabs.android.dbflow.processor.test +package com.raizlabs.dbflow5.dbflow.processor.test -import com.raizlabs.android.dbflow.processor.definition.column.* -import com.raizlabs.android.dbflow.processor.definition.column.PrimaryReferenceAccessCombiner +import com.raizlabs.dbflow5.dbflow.processor.definition.column.* +import com.raizlabs.dbflow5.dbflow.processor.definition.column.PrimaryReferenceAccessCombiner import com.squareup.javapoet.CodeBlock import com.squareup.javapoet.TypeName import org.junit.Assert.assertEquals diff --git a/dbflow-processor/src/test/java/com/raizlabs/android/dbflow/processor/test/ForeignKeyAccessCombinerTests.kt b/dbflow-processor/src/test/java/com/raizlabs/dbflow5/dbflow/processor/test/ForeignKeyAccessCombinerTests.kt similarity index 90% rename from dbflow-processor/src/test/java/com/raizlabs/android/dbflow/processor/test/ForeignKeyAccessCombinerTests.kt rename to dbflow-processor/src/test/java/com/raizlabs/dbflow5/dbflow/processor/test/ForeignKeyAccessCombinerTests.kt index e3e178ad4..774d5004d 100644 --- a/dbflow-processor/src/test/java/com/raizlabs/android/dbflow/processor/test/ForeignKeyAccessCombinerTests.kt +++ b/dbflow-processor/src/test/java/com/raizlabs/dbflow5/dbflow/processor/test/ForeignKeyAccessCombinerTests.kt @@ -1,7 +1,7 @@ -package com.raizlabs.android.dbflow.processor.test +package com.raizlabs.dbflow5.dbflow.processor.test -import com.raizlabs.android.dbflow.processor.definition.column.* -import com.raizlabs.android.dbflow.processor.definition.column.PrimaryReferenceAccessCombiner +import com.raizlabs.dbflow5.dbflow.processor.definition.column.* +import com.raizlabs.dbflow5.dbflow.processor.definition.column.PrimaryReferenceAccessCombiner import com.squareup.javapoet.ClassName import com.squareup.javapoet.CodeBlock import com.squareup.javapoet.NameAllocator @@ -73,7 +73,7 @@ class ForeignKeyAccessCombinerTest { assertEquals("if (com.fuzz.android.TestHelper_Helper.getName(model) != null) {" + "\n clause.and(test.eq(com.fuzz.android.TestHelper2_Helper.getTest(com.fuzz.android.TestHelper_Helper.getName(model))));" + "\n} else {" + - "\n clause.and(test.eq((com.raizlabs.android.dbflow.sql.language.IConditional) null));" + + "\n clause.and(test.eq((com.raizlabs.dbflow5.dbflow.sql.language.IConditional) null));" + "\n}", builder.build().toString().trim()) } @@ -105,8 +105,8 @@ class ForeignKeyAccessCombinerTest { @Test fun test_canLoadFromCursor() { val foreignKeyAccessCombiner = ForeignKeyLoadFromCursorCombiner(VisibleScopeColumnAccessor("testModel1"), - ClassName.get("com.raizlabs.android.dbflow.test.container", "ParentModel"), - ClassName.get("com.raizlabs.android.dbflow.test.container", "ParentModel_Table"), false, + ClassName.get("com.raizlabs.dbflow5.dbflow.test.container", "ParentModel"), + ClassName.get("com.raizlabs.dbflow5.dbflow.test.container", "ParentModel_Table"), false, NameAllocator()) foreignKeyAccessCombiner.fieldAccesses += PartialLoadFromCursorAccessCombiner("testmodel_id", "name", TypeName.get(String::class.java), false, null) @@ -119,9 +119,9 @@ class ForeignKeyAccessCombinerTest { assertEquals("int index_testmodel_id = cursor.getColumnIndex(\"testmodel_id\");" + "\nint index_testmodel_type = cursor.getColumnIndex(\"testmodel_type\");" + "\nif (index_testmodel_id != -1 && !cursor.isNull(index_testmodel_id) && index_testmodel_type != -1 && !cursor.isNull(index_testmodel_type)) {" + - "\n model.testModel1 = com.raizlabs.android.dbflow.sql.language.SQLite.select().from(com.raizlabs.android.dbflow.test.container.ParentModel.class).where()" + - "\n .and(com.raizlabs.android.dbflow.test.container.ParentModel_Table.name.eq(cursor.getString(index_testmodel_id)))" + - "\n .and(com.raizlabs.android.dbflow.test.container.ParentModel_Table.type.eq(cursor.getString(index_testmodel_type)))" + + "\n model.testModel1 = com.raizlabs.dbflow5.dbflow.sql.language.SQLite.select().from(com.raizlabs.dbflow5.dbflow.test.container.ParentModel.class).where()" + + "\n .and(com.raizlabs.dbflow5.dbflow.test.container.ParentModel_Table.name.eq(cursor.getString(index_testmodel_id)))" + + "\n .and(com.raizlabs.dbflow5.dbflow.test.container.ParentModel_Table.type.eq(cursor.getString(index_testmodel_type)))" + "\n .querySingle();" + "\n} else {" + "\n model.testModel1 = null;" + @@ -131,8 +131,8 @@ class ForeignKeyAccessCombinerTest { @Test fun test_canLoadFromCursorStubbed() { val foreignKeyAccessCombiner = ForeignKeyLoadFromCursorCombiner(VisibleScopeColumnAccessor("testModel1"), - ClassName.get("com.raizlabs.android.dbflow.test.container", "ParentModel"), - ClassName.get("com.raizlabs.android.dbflow.test.container", "ParentModel_Table"), true, + ClassName.get("com.raizlabs.dbflow5.dbflow.test.container", "ParentModel"), + ClassName.get("com.raizlabs.dbflow5.dbflow.test.container", "ParentModel_Table"), true, NameAllocator()) foreignKeyAccessCombiner.fieldAccesses += PartialLoadFromCursorAccessCombiner("testmodel_id", "name", TypeName.get(String::class.java), false, VisibleScopeColumnAccessor("name")) @@ -145,7 +145,7 @@ class ForeignKeyAccessCombinerTest { assertEquals("int index_testmodel_id = cursor.getColumnIndex(\"testmodel_id\");" + "\nint index_testmodel_type = cursor.getColumnIndex(\"testmodel_type\");" + "\nif (index_testmodel_id != -1 && !cursor.isNull(index_testmodel_id) && index_testmodel_type != -1 && !cursor.isNull(index_testmodel_type)) {" + - "\n model.testModel1 = new com.raizlabs.android.dbflow.test.container.ParentModel();" + + "\n model.testModel1 = new com.raizlabs.dbflow5.dbflow.test.container.ParentModel();" + "\n model.testModel1.name = cursor.getString(index_testmodel_id);" + "\n model.testModel1.type = cursor.getString(index_testmodel_type);" + "\n} else {" + diff --git a/dbflow-processor/src/test/java/com/raizlabs/android/dbflow/processor/test/SimpleColumnAccessorTests.kt b/dbflow-processor/src/test/java/com/raizlabs/dbflow5/dbflow/processor/test/SimpleColumnAccessorTests.kt similarity index 94% rename from dbflow-processor/src/test/java/com/raizlabs/android/dbflow/processor/test/SimpleColumnAccessorTests.kt rename to dbflow-processor/src/test/java/com/raizlabs/dbflow5/dbflow/processor/test/SimpleColumnAccessorTests.kt index 3a2019a15..580497f7b 100644 --- a/dbflow-processor/src/test/java/com/raizlabs/android/dbflow/processor/test/SimpleColumnAccessorTests.kt +++ b/dbflow-processor/src/test/java/com/raizlabs/dbflow5/dbflow/processor/test/SimpleColumnAccessorTests.kt @@ -1,6 +1,6 @@ -package com.raizlabs.android.dbflow.processor.test +package com.raizlabs.dbflow5.dbflow.processor.test -import com.raizlabs.android.dbflow.processor.definition.column.* +import com.raizlabs.dbflow5.dbflow.processor.definition.column.* import com.squareup.javapoet.CodeBlock import com.squareup.javapoet.TypeName import org.junit.Assert.assertEquals @@ -118,7 +118,7 @@ class EnumColumnAccessorTest { @Test fun test_canSetEnum() { val access = EnumColumnAccessor(TypeName.get(TestEnum::class.java)) - assertEquals("com.raizlabs.android.dbflow.processor.test.EnumColumnAccessorTest.TestEnum.valueOf(model.test)", + assertEquals("com.raizlabs.dbflow5.dbflow.processor.test.EnumColumnAccessorTest.TestEnum.valueOf(model.test)", access.set(CodeBlock.of("model.test")).toString()) } } @@ -134,7 +134,7 @@ class BlobColumnAccessorTest() { @Test fun test_canSetBlob() { val access = BlobColumnAccessor() - assertEquals("new com.raizlabs.android.dbflow.data.Blob(cursor.getBlob(index))", + assertEquals("new com.raizlabs.dbflow5.Blob(cursor.getBlob(index))", access.set(CodeBlock.of("cursor.getBlob(index)")).toString()) } } diff --git a/dbflow-rx/src/main/AndroidManifest.xml b/dbflow-rx/src/main/AndroidManifest.xml index d05f0ea55..d8b4139c7 100644 --- a/dbflow-rx/src/main/AndroidManifest.xml +++ b/dbflow-rx/src/main/AndroidManifest.xml @@ -1,5 +1 @@ - - - - - + diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/query/CursorResultSubscriber.kt b/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/query/CursorResultSubscriber.kt similarity index 94% rename from dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/query/CursorResultSubscriber.kt rename to dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/query/CursorResultSubscriber.kt index 51e8dec2a..3615802cb 100644 --- a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/query/CursorResultSubscriber.kt +++ b/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/query/CursorResultSubscriber.kt @@ -1,7 +1,7 @@ -package com.raizlabs.android.dbflow.rx.query +package com.raizlabs.dbflow5.rx.query -import com.raizlabs.android.dbflow.config.FlowLog -import com.raizlabs.android.dbflow.query.CursorResult +import com.raizlabs.dbflow5.config.FlowLog +import com.raizlabs.dbflow5.query.CursorResult import rx.Observable import rx.Producer import rx.Subscriber diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/query/RXModelQueriable.kt b/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/query/RXModelQueriable.kt similarity index 86% rename from dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/query/RXModelQueriable.kt rename to dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/query/RXModelQueriable.kt index 6e3cffcf2..6650e3591 100644 --- a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/query/RXModelQueriable.kt +++ b/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/query/RXModelQueriable.kt @@ -1,11 +1,11 @@ -package com.raizlabs.android.dbflow.rx.query - -import com.raizlabs.android.dbflow.query.list.FlowCursorList -import com.raizlabs.android.dbflow.query.list.FlowQueryList -import com.raizlabs.android.dbflow.query.CursorResult -import com.raizlabs.android.dbflow.query.Join -import com.raizlabs.android.dbflow.query.ModelQueriable -import com.raizlabs.android.dbflow.structure.BaseQueryModel +package com.raizlabs.dbflow5.rx.query + +import com.raizlabs.dbflow5.query.list.FlowCursorList +import com.raizlabs.dbflow5.query.list.FlowQueryList +import com.raizlabs.dbflow5.query.CursorResult +import com.raizlabs.dbflow5.query.Join +import com.raizlabs.dbflow5.query.ModelQueriable +import com.raizlabs.dbflow5.structure.BaseQueryModel import rx.Observable import rx.Single diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/query/RXModelQueriableImpl.kt b/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/query/RXModelQueriableImpl.kt similarity index 83% rename from dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/query/RXModelQueriableImpl.kt rename to dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/query/RXModelQueriableImpl.kt index a1941b5ba..a43ab65dc 100644 --- a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/query/RXModelQueriableImpl.kt +++ b/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/query/RXModelQueriableImpl.kt @@ -1,10 +1,10 @@ -package com.raizlabs.android.dbflow.rx.query +package com.raizlabs.dbflow5.rx.query -import com.raizlabs.android.dbflow.query.list.FlowCursorList -import com.raizlabs.android.dbflow.query.list.FlowQueryList -import com.raizlabs.android.dbflow.query.BaseModelQueriable -import com.raizlabs.android.dbflow.query.CursorResult -import com.raizlabs.android.dbflow.query.ModelQueriable +import com.raizlabs.dbflow5.query.list.FlowCursorList +import com.raizlabs.dbflow5.query.list.FlowQueryList +import com.raizlabs.dbflow5.query.BaseModelQueriable +import com.raizlabs.dbflow5.query.CursorResult +import com.raizlabs.dbflow5.query.ModelQueriable import rx.Emitter import rx.Observable import rx.Single diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/query/RXQueriable.kt b/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/query/RXQueriable.kt similarity index 79% rename from dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/query/RXQueriable.kt rename to dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/query/RXQueriable.kt index 7bb96fa6d..53885a416 100644 --- a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/query/RXQueriable.kt +++ b/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/query/RXQueriable.kt @@ -1,12 +1,12 @@ -package com.raizlabs.android.dbflow.rx.query +package com.raizlabs.dbflow5.rx.query import android.database.Cursor -import com.raizlabs.android.dbflow.query.Delete -import com.raizlabs.android.dbflow.query.Insert -import com.raizlabs.android.dbflow.query.Set -import com.raizlabs.android.dbflow.query.Queriable -import com.raizlabs.android.dbflow.structure.Model -import com.raizlabs.android.dbflow.database.DatabaseStatement +import com.raizlabs.dbflow5.query.Delete +import com.raizlabs.dbflow5.query.Insert +import com.raizlabs.dbflow5.query.Set +import com.raizlabs.dbflow5.query.Queriable +import com.raizlabs.dbflow5.structure.Model +import com.raizlabs.dbflow5.database.DatabaseStatement import rx.Single /** diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/query/RXQueriableImpl.kt b/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/query/RXQueriableImpl.kt similarity index 82% rename from dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/query/RXQueriableImpl.kt rename to dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/query/RXQueriableImpl.kt index b01e72a9e..09fd23b34 100644 --- a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/query/RXQueriableImpl.kt +++ b/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/query/RXQueriableImpl.kt @@ -1,9 +1,9 @@ -package com.raizlabs.android.dbflow.rx.query +package com.raizlabs.dbflow5.rx.query import android.database.Cursor -import com.raizlabs.android.dbflow.query.BaseQueriable -import com.raizlabs.android.dbflow.query.Queriable -import com.raizlabs.android.dbflow.database.DatabaseStatement +import com.raizlabs.dbflow5.query.BaseQueriable +import com.raizlabs.dbflow5.query.Queriable +import com.raizlabs.dbflow5.database.DatabaseStatement import rx.Single import rx.Single.fromCallable diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/query/RXSQLite.kt b/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/query/RXSQLite.kt similarity index 53% rename from dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/query/RXSQLite.kt rename to dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/query/RXSQLite.kt index 4610728c4..814d9f826 100644 --- a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/query/RXSQLite.kt +++ b/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/query/RXSQLite.kt @@ -1,10 +1,10 @@ @file:JvmName("RXSQLite") -package com.raizlabs.android.dbflow.rx.query +package com.raizlabs.dbflow5.rx.query -import com.raizlabs.android.dbflow.query.BaseQueriable -import com.raizlabs.android.dbflow.query.ModelQueriable -import com.raizlabs.android.dbflow.query.Queriable +import com.raizlabs.dbflow5.query.BaseQueriable +import com.raizlabs.dbflow5.query.ModelQueriable +import com.raizlabs.dbflow5.query.Queriable fun ModelQueriable.rx(): RXModelQueriableImpl = RXModelQueriableImpl(this) diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/query/TableChangeListenerEmitter.java b/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/query/TableChangeListenerEmitter.java similarity index 85% rename from dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/query/TableChangeListenerEmitter.java rename to dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/query/TableChangeListenerEmitter.java index a1390b595..69bf0ecfd 100644 --- a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/query/TableChangeListenerEmitter.java +++ b/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/query/TableChangeListenerEmitter.java @@ -1,16 +1,16 @@ -package com.raizlabs.android.dbflow.rx.query; +package com.raizlabs.dbflow5.rx.query; import android.support.annotation.NonNull; import android.support.annotation.Nullable; -import com.raizlabs.android.dbflow.config.FlowManager; -import com.raizlabs.android.dbflow.runtime.OnTableChangedListener; -import com.raizlabs.android.dbflow.runtime.TableNotifierRegister; -import com.raizlabs.android.dbflow.query.From; -import com.raizlabs.android.dbflow.query.Join; -import com.raizlabs.android.dbflow.query.Where; -import com.raizlabs.android.dbflow.query.ModelQueriable; -import com.raizlabs.android.dbflow.structure.ChangeAction; +import com.raizlabs.dbflow5.config.FlowManager; +import com.raizlabs.dbflow5.runtime.OnTableChangedListener; +import com.raizlabs.dbflow5.runtime.TableNotifierRegister; +import com.raizlabs.dbflow5.query.From; +import com.raizlabs.dbflow5.query.Join; +import com.raizlabs.dbflow5.query.Where; +import com.raizlabs.dbflow5.query.ModelQueriable; +import com.raizlabs.dbflow5.structure.ChangeAction; import rx.Emitter; import rx.Subscription; diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/structure/BaseRXModel.kt b/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/structure/BaseRXModel.kt similarity index 75% rename from dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/structure/BaseRXModel.kt rename to dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/structure/BaseRXModel.kt index bf357150f..d0293ece6 100644 --- a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/structure/BaseRXModel.kt +++ b/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/structure/BaseRXModel.kt @@ -1,11 +1,11 @@ -package com.raizlabs.android.dbflow.rx.structure - -import com.raizlabs.android.dbflow.annotation.ColumnIgnore -import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.structure.BaseModel -import com.raizlabs.android.dbflow.structure.InvalidDBConfiguration -import com.raizlabs.android.dbflow.adapter.ModelAdapter -import com.raizlabs.android.dbflow.database.DatabaseWrapper +package com.raizlabs.dbflow5.rx.structure + +import com.raizlabs.dbflow5.annotation.ColumnIgnore +import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.structure.BaseModel +import com.raizlabs.dbflow5.structure.InvalidDBConfiguration +import com.raizlabs.dbflow5.adapter.ModelAdapter +import com.raizlabs.dbflow5.database.DatabaseWrapper import rx.Completable import rx.Single diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/structure/RXModelAdapter.kt b/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/structure/RXModelAdapter.kt similarity index 90% rename from dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/structure/RXModelAdapter.kt rename to dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/structure/RXModelAdapter.kt index eccf0792a..ed8414c8d 100644 --- a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/structure/RXModelAdapter.kt +++ b/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/structure/RXModelAdapter.kt @@ -1,8 +1,8 @@ -package com.raizlabs.android.dbflow.rx.structure +package com.raizlabs.dbflow5.rx.structure -import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.adapter.ModelAdapter -import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.adapter.ModelAdapter +import com.raizlabs.dbflow5.database.DatabaseWrapper import rx.Completable import rx.Single diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/structure/RXRetrievalAdapter.kt b/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/structure/RXRetrievalAdapter.kt similarity index 84% rename from dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/structure/RXRetrievalAdapter.kt rename to dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/structure/RXRetrievalAdapter.kt index 0495cca5c..b12d8e8f1 100644 --- a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/structure/RXRetrievalAdapter.kt +++ b/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/structure/RXRetrievalAdapter.kt @@ -1,8 +1,8 @@ -package com.raizlabs.android.dbflow.rx.structure +package com.raizlabs.dbflow5.rx.structure -import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.adapter.RetrievalAdapter -import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.adapter.RetrievalAdapter +import com.raizlabs.dbflow5.database.DatabaseWrapper import rx.Completable import rx.Single diff --git a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/transaction/TransactionObservable.kt b/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/transaction/TransactionObservable.kt similarity index 75% rename from dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/transaction/TransactionObservable.kt rename to dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/transaction/TransactionObservable.kt index 0a4d38443..7a790aeec 100644 --- a/dbflow-rx/src/main/java/com/raizlabs/android/dbflow/rx/transaction/TransactionObservable.kt +++ b/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/transaction/TransactionObservable.kt @@ -1,9 +1,9 @@ @file:JvmName("RXTransactions") -package com.raizlabs.android.dbflow.rx.transaction +package com.raizlabs.dbflow5.rx.transaction -import com.raizlabs.android.dbflow.config.DatabaseDefinition -import com.raizlabs.android.dbflow.transaction.ITransaction +import com.raizlabs.dbflow5.config.DatabaseDefinition +import com.raizlabs.dbflow5.transaction.ITransaction import rx.Observable import rx.Single diff --git a/dbflow-rx2/build.gradle b/dbflow-rx2/build.gradle index 21ac122dc..abc3cfe31 100644 --- a/dbflow-rx2/build.gradle +++ b/dbflow-rx2/build.gradle @@ -5,7 +5,6 @@ project.ext.artifactId = bt_name android { compileSdkVersion Integer.valueOf(dbflow_target_sdk) - buildToolsVersion dbflow_build_tools_version defaultConfig { minSdkVersion dbflow_min_sdk_rx diff --git a/dbflow-rx2/src/main/AndroidManifest.xml b/dbflow-rx2/src/main/AndroidManifest.xml index 34ee46575..2380e798a 100644 --- a/dbflow-rx2/src/main/AndroidManifest.xml +++ b/dbflow-rx2/src/main/AndroidManifest.xml @@ -1,5 +1 @@ - - - - - + diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/query/CursorResultFlowable.kt b/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/query/CursorResultFlowable.kt similarity index 94% rename from dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/query/CursorResultFlowable.kt rename to dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/query/CursorResultFlowable.kt index eca4ab8e7..faad764b0 100644 --- a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/query/CursorResultFlowable.kt +++ b/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/query/CursorResultFlowable.kt @@ -1,7 +1,7 @@ -package com.raizlabs.android.dbflow.rx2.query +package com.raizlabs.dbflow5.rx2.query -import com.raizlabs.android.dbflow.config.FlowLog -import com.raizlabs.android.dbflow.query.CursorResult +import com.raizlabs.dbflow5.config.FlowLog +import com.raizlabs.dbflow5.query.CursorResult import io.reactivex.Flowable import io.reactivex.SingleObserver import io.reactivex.disposables.Disposable diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/query/RXModelQueriable.kt b/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/query/RXModelQueriable.kt similarity index 86% rename from dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/query/RXModelQueriable.kt rename to dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/query/RXModelQueriable.kt index a4ebc7bcc..4844b37e3 100644 --- a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/query/RXModelQueriable.kt +++ b/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/query/RXModelQueriable.kt @@ -1,11 +1,11 @@ -package com.raizlabs.android.dbflow.rx2.query - -import com.raizlabs.android.dbflow.query.list.FlowCursorList -import com.raizlabs.android.dbflow.query.list.FlowQueryList -import com.raizlabs.android.dbflow.query.CursorResult -import com.raizlabs.android.dbflow.query.Join -import com.raizlabs.android.dbflow.query.ModelQueriable -import com.raizlabs.android.dbflow.structure.BaseQueryModel +package com.raizlabs.dbflow5.rx2.query + +import com.raizlabs.dbflow5.query.list.FlowCursorList +import com.raizlabs.dbflow5.query.list.FlowQueryList +import com.raizlabs.dbflow5.query.CursorResult +import com.raizlabs.dbflow5.query.Join +import com.raizlabs.dbflow5.query.ModelQueriable +import com.raizlabs.dbflow5.structure.BaseQueryModel import io.reactivex.Flowable import io.reactivex.Maybe import io.reactivex.Observable diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/query/RXModelQueriableImpl.kt b/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/query/RXModelQueriableImpl.kt similarity index 83% rename from dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/query/RXModelQueriableImpl.kt rename to dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/query/RXModelQueriableImpl.kt index 7eec01434..ebd9a23a7 100644 --- a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/query/RXModelQueriableImpl.kt +++ b/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/query/RXModelQueriableImpl.kt @@ -1,10 +1,10 @@ -package com.raizlabs.android.dbflow.rx2.query +package com.raizlabs.dbflow5.rx2.query -import com.raizlabs.android.dbflow.query.list.FlowCursorList -import com.raizlabs.android.dbflow.query.list.FlowQueryList -import com.raizlabs.android.dbflow.query.BaseModelQueriable -import com.raizlabs.android.dbflow.query.CursorResult -import com.raizlabs.android.dbflow.query.ModelQueriable +import com.raizlabs.dbflow5.query.list.FlowCursorList +import com.raizlabs.dbflow5.query.list.FlowQueryList +import com.raizlabs.dbflow5.query.BaseModelQueriable +import com.raizlabs.dbflow5.query.CursorResult +import com.raizlabs.dbflow5.query.ModelQueriable import io.reactivex.BackpressureStrategy import io.reactivex.Flowable import io.reactivex.Maybe diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/query/RXQueriable.kt b/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/query/RXQueriable.kt similarity index 80% rename from dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/query/RXQueriable.kt rename to dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/query/RXQueriable.kt index 74992e78c..1d78ef62c 100644 --- a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/query/RXQueriable.kt +++ b/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/query/RXQueriable.kt @@ -1,12 +1,12 @@ -package com.raizlabs.android.dbflow.rx2.query +package com.raizlabs.dbflow5.rx2.query import android.database.Cursor -import com.raizlabs.android.dbflow.query.Delete -import com.raizlabs.android.dbflow.query.Insert -import com.raizlabs.android.dbflow.query.Set -import com.raizlabs.android.dbflow.query.Queriable -import com.raizlabs.android.dbflow.structure.Model -import com.raizlabs.android.dbflow.database.DatabaseStatement +import com.raizlabs.dbflow5.query.Delete +import com.raizlabs.dbflow5.query.Insert +import com.raizlabs.dbflow5.query.Set +import com.raizlabs.dbflow5.query.Queriable +import com.raizlabs.dbflow5.structure.Model +import com.raizlabs.dbflow5.database.DatabaseStatement import io.reactivex.Completable import io.reactivex.Maybe import io.reactivex.Single diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/query/RXQueriableImpl.kt b/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/query/RXQueriableImpl.kt similarity index 82% rename from dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/query/RXQueriableImpl.kt rename to dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/query/RXQueriableImpl.kt index d5bef7bb8..40399899f 100644 --- a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/query/RXQueriableImpl.kt +++ b/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/query/RXQueriableImpl.kt @@ -1,9 +1,9 @@ -package com.raizlabs.android.dbflow.rx2.query +package com.raizlabs.dbflow5.rx2.query import android.database.Cursor -import com.raizlabs.android.dbflow.query.BaseQueriable -import com.raizlabs.android.dbflow.query.Queriable -import com.raizlabs.android.dbflow.database.DatabaseStatement +import com.raizlabs.dbflow5.query.BaseQueriable +import com.raizlabs.dbflow5.query.Queriable +import com.raizlabs.dbflow5.database.DatabaseStatement import io.reactivex.Completable import io.reactivex.Maybe import io.reactivex.Single diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/query/RXSQLite.kt b/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/query/RXSQLite.kt similarity index 54% rename from dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/query/RXSQLite.kt rename to dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/query/RXSQLite.kt index 64c706fbf..e2bee4009 100644 --- a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/query/RXSQLite.kt +++ b/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/query/RXSQLite.kt @@ -1,9 +1,9 @@ @file:JvmName("RXSQLite") -package com.raizlabs.android.dbflow.rx2.query +package com.raizlabs.dbflow5.rx2.query -import com.raizlabs.android.dbflow.query.ModelQueriable -import com.raizlabs.android.dbflow.query.Queriable +import com.raizlabs.dbflow5.query.ModelQueriable +import com.raizlabs.dbflow5.query.Queriable fun ModelQueriable.rx(): RXModelQueriableImpl = RXModelQueriableImpl(this) diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/query/TableChangeOnSubscribe.kt b/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/query/TableChangeOnSubscribe.kt similarity index 79% rename from dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/query/TableChangeOnSubscribe.kt rename to dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/query/TableChangeOnSubscribe.kt index 30b6b8289..e91a6391e 100644 --- a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/query/TableChangeOnSubscribe.kt +++ b/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/query/TableChangeOnSubscribe.kt @@ -1,13 +1,13 @@ -package com.raizlabs.android.dbflow.rx2.query - -import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.runtime.OnTableChangedListener -import com.raizlabs.android.dbflow.runtime.TableNotifierRegister -import com.raizlabs.android.dbflow.query.From -import com.raizlabs.android.dbflow.query.Join -import com.raizlabs.android.dbflow.query.Where -import com.raizlabs.android.dbflow.query.ModelQueriable -import com.raizlabs.android.dbflow.structure.ChangeAction +package com.raizlabs.dbflow5.rx2.query + +import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.runtime.OnTableChangedListener +import com.raizlabs.dbflow5.runtime.TableNotifierRegister +import com.raizlabs.dbflow5.query.From +import com.raizlabs.dbflow5.query.Join +import com.raizlabs.dbflow5.query.Where +import com.raizlabs.dbflow5.query.ModelQueriable +import com.raizlabs.dbflow5.structure.ChangeAction import io.reactivex.FlowableEmitter import io.reactivex.FlowableOnSubscribe diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/structure/BaseRXModel.kt b/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/structure/BaseRXModel.kt similarity index 75% rename from dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/structure/BaseRXModel.kt rename to dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/structure/BaseRXModel.kt index d3a6e1ec4..0d4b6b4ab 100644 --- a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/structure/BaseRXModel.kt +++ b/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/structure/BaseRXModel.kt @@ -1,11 +1,11 @@ -package com.raizlabs.android.dbflow.rx2.structure - -import com.raizlabs.android.dbflow.annotation.ColumnIgnore -import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.structure.BaseModel -import com.raizlabs.android.dbflow.structure.InvalidDBConfiguration -import com.raizlabs.android.dbflow.adapter.ModelAdapter -import com.raizlabs.android.dbflow.database.DatabaseWrapper +package com.raizlabs.dbflow5.rx2.structure + +import com.raizlabs.dbflow5.annotation.ColumnIgnore +import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.structure.BaseModel +import com.raizlabs.dbflow5.structure.InvalidDBConfiguration +import com.raizlabs.dbflow5.adapter.ModelAdapter +import com.raizlabs.dbflow5.database.DatabaseWrapper import io.reactivex.Completable import io.reactivex.Single diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/structure/RXModelAdapter.kt b/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/structure/RXModelAdapter.kt similarity index 90% rename from dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/structure/RXModelAdapter.kt rename to dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/structure/RXModelAdapter.kt index e2d8c1685..65cc8b733 100644 --- a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/structure/RXModelAdapter.kt +++ b/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/structure/RXModelAdapter.kt @@ -1,8 +1,8 @@ -package com.raizlabs.android.dbflow.rx2.structure +package com.raizlabs.dbflow5.rx2.structure -import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.adapter.ModelAdapter -import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.adapter.ModelAdapter +import com.raizlabs.dbflow5.database.DatabaseWrapper import io.reactivex.Completable import io.reactivex.Completable.fromCallable import io.reactivex.Single diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/structure/RXRetrievalAdapter.kt b/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/structure/RXRetrievalAdapter.kt similarity index 84% rename from dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/structure/RXRetrievalAdapter.kt rename to dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/structure/RXRetrievalAdapter.kt index 5127c61ae..f7fec3401 100644 --- a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/structure/RXRetrievalAdapter.kt +++ b/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/structure/RXRetrievalAdapter.kt @@ -1,8 +1,8 @@ -package com.raizlabs.android.dbflow.rx2.structure +package com.raizlabs.dbflow5.rx2.structure -import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.adapter.RetrievalAdapter -import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.adapter.RetrievalAdapter +import com.raizlabs.dbflow5.database.DatabaseWrapper import io.reactivex.Completable import io.reactivex.Single diff --git a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/transaction/TransactionObservable.kt b/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/transaction/TransactionObservable.kt similarity index 82% rename from dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/transaction/TransactionObservable.kt rename to dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/transaction/TransactionObservable.kt index 1f3430d3e..dc6c92bc7 100644 --- a/dbflow-rx2/src/main/java/com/raizlabs/android/dbflow/rx2/transaction/TransactionObservable.kt +++ b/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/transaction/TransactionObservable.kt @@ -1,9 +1,9 @@ @file:JvmName("RXTransactions") -package com.raizlabs.android.dbflow.rx2.transaction +package com.raizlabs.dbflow5.rx2.transaction -import com.raizlabs.android.dbflow.config.DatabaseDefinition -import com.raizlabs.android.dbflow.transaction.ITransaction +import com.raizlabs.dbflow5.config.DatabaseDefinition +import com.raizlabs.dbflow5.transaction.ITransaction import io.reactivex.Flowable import io.reactivex.Maybe import io.reactivex.Observable diff --git a/dbflow-sqlcipher/build.gradle b/dbflow-sqlcipher/build.gradle index 49c54da62..fe46d5ae1 100644 --- a/dbflow-sqlcipher/build.gradle +++ b/dbflow-sqlcipher/build.gradle @@ -5,7 +5,6 @@ project.ext.artifactId = bt_name android { compileSdkVersion 26 - buildToolsVersion dbflow_build_tools_version defaultConfig { minSdkVersion 7 diff --git a/dbflow-sqlcipher/src/main/AndroidManifest.xml b/dbflow-sqlcipher/src/main/AndroidManifest.xml index fa75ae33c..4d1de0cf9 100644 --- a/dbflow-sqlcipher/src/main/AndroidManifest.xml +++ b/dbflow-sqlcipher/src/main/AndroidManifest.xml @@ -1,3 +1 @@ - - - + diff --git a/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherDatabase.kt b/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherDatabase.kt similarity index 91% rename from dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherDatabase.kt rename to dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherDatabase.kt index b05be6e70..296976f7e 100644 --- a/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherDatabase.kt +++ b/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherDatabase.kt @@ -1,10 +1,10 @@ -package com.raizlabs.android.dbflow.sqlcipher +package com.raizlabs.dbflow5.sqlcipher import android.content.ContentValues -import com.raizlabs.android.dbflow.database.DatabaseStatement -import com.raizlabs.android.dbflow.database.DatabaseWrapper -import com.raizlabs.android.dbflow.database.FlowCursor +import com.raizlabs.dbflow5.database.DatabaseStatement +import com.raizlabs.dbflow5.database.DatabaseWrapper +import com.raizlabs.dbflow5.database.FlowCursor import net.sqlcipher.database.SQLiteDatabase diff --git a/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherOpenHelper.kt b/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherOpenHelper.kt similarity index 89% rename from dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherOpenHelper.kt rename to dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherOpenHelper.kt index 4cbf76076..ca4575c8a 100644 --- a/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherOpenHelper.kt +++ b/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherOpenHelper.kt @@ -1,15 +1,15 @@ -package com.raizlabs.android.dbflow.sqlcipher +package com.raizlabs.dbflow5.sqlcipher import android.content.Context -import com.raizlabs.android.dbflow.config.DatabaseConfig -import com.raizlabs.android.dbflow.config.DatabaseDefinition -import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.database.BaseDatabaseHelper -import com.raizlabs.android.dbflow.database.DatabaseHelperDelegate -import com.raizlabs.android.dbflow.database.DatabaseHelperListener -import com.raizlabs.android.dbflow.database.DatabaseWrapper -import com.raizlabs.android.dbflow.database.OpenHelper +import com.raizlabs.dbflow5.config.DatabaseConfig +import com.raizlabs.dbflow5.config.DatabaseDefinition +import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.database.BaseDatabaseHelper +import com.raizlabs.dbflow5.database.DatabaseHelperDelegate +import com.raizlabs.dbflow5.database.DatabaseHelperListener +import com.raizlabs.dbflow5.database.DatabaseWrapper +import com.raizlabs.dbflow5.database.OpenHelper import net.sqlcipher.database.SQLiteDatabase import net.sqlcipher.database.SQLiteOpenHelper diff --git a/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherStatement.kt b/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherStatement.kt similarity index 89% rename from dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherStatement.kt rename to dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherStatement.kt index 2a42e7222..e6a624395 100644 --- a/dbflow-sqlcipher/src/main/java/com/raizlabs/android/dbflow/sqlcipher/SQLCipherStatement.kt +++ b/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherStatement.kt @@ -1,7 +1,7 @@ -package com.raizlabs.android.dbflow.sqlcipher +package com.raizlabs.dbflow5.sqlcipher -import com.raizlabs.android.dbflow.database.BaseDatabaseStatement -import com.raizlabs.android.dbflow.database.DatabaseStatement +import com.raizlabs.dbflow5.database.BaseDatabaseStatement +import com.raizlabs.dbflow5.database.DatabaseStatement import net.sqlcipher.database.SQLiteStatement diff --git a/dbflow-tests/src/androidTest/AndroidManifest.xml b/dbflow-tests/src/androidTest/AndroidManifest.xml index 1f4db6ec2..40517d16c 100644 --- a/dbflow-tests/src/androidTest/AndroidManifest.xml +++ b/dbflow-tests/src/androidTest/AndroidManifest.xml @@ -1,12 +1,12 @@ + android:name="com.raizlabs.dbflow5.dbflow.test.DemoActivity"> diff --git a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/BaseUnitTest.kt b/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/dbflow/BaseUnitTest.kt similarity index 81% rename from dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/BaseUnitTest.kt rename to dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/dbflow/BaseUnitTest.kt index 09e47175c..0c64be061 100644 --- a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/BaseUnitTest.kt +++ b/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/dbflow/BaseUnitTest.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow +package com.raizlabs.dbflow5.dbflow import org.junit.Rule diff --git a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/DBFlowInstrumentedTestRule.kt b/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/dbflow/DBFlowInstrumentedTestRule.kt similarity index 76% rename from dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/DBFlowInstrumentedTestRule.kt rename to dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/dbflow/DBFlowInstrumentedTestRule.kt index 4fc06e210..186b559dc 100644 --- a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/DBFlowInstrumentedTestRule.kt +++ b/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/dbflow/DBFlowInstrumentedTestRule.kt @@ -1,12 +1,12 @@ -package com.raizlabs.android.dbflow +package com.raizlabs.dbflow5.dbflow -import com.raizlabs.android.dbflow.config.DatabaseConfig -import com.raizlabs.android.dbflow.config.DatabaseDefinition -import com.raizlabs.android.dbflow.config.FlowConfig -import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.prepackaged.PrepackagedDB -import com.raizlabs.android.dbflow.runtime.ContentResolverNotifier -import com.raizlabs.android.dbflow.sqlcipher.CipherDatabase +import com.raizlabs.dbflow5.config.DatabaseConfig +import com.raizlabs.dbflow5.config.DatabaseDefinition +import com.raizlabs.dbflow5.config.FlowConfig +import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.dbflow.prepackaged.PrepackagedDB +import com.raizlabs.dbflow5.runtime.ContentResolverNotifier +import com.raizlabs.dbflow5.sqlcipher.CipherDatabase import org.junit.rules.TestRule import org.junit.runner.Description import org.junit.runners.model.Statement diff --git a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/ImmediateTransactionManager.kt b/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/dbflow/ImmediateTransactionManager.kt similarity index 70% rename from dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/ImmediateTransactionManager.kt rename to dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/dbflow/ImmediateTransactionManager.kt index a4d81c9e4..6913293f2 100644 --- a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/ImmediateTransactionManager.kt +++ b/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/dbflow/ImmediateTransactionManager.kt @@ -1,9 +1,9 @@ -package com.raizlabs.android.dbflow +package com.raizlabs.dbflow5.dbflow -import com.raizlabs.android.dbflow.config.DatabaseDefinition -import com.raizlabs.android.dbflow.transaction.BaseTransactionManager -import com.raizlabs.android.dbflow.transaction.ITransactionQueue -import com.raizlabs.android.dbflow.transaction.Transaction +import com.raizlabs.dbflow5.config.DatabaseDefinition +import com.raizlabs.dbflow5.transaction.BaseTransactionManager +import com.raizlabs.dbflow5.transaction.ITransactionQueue +import com.raizlabs.dbflow5.transaction.Transaction /** * Description: Executes all transactions on same thread for testing. diff --git a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/contentobserver/ContentObserverTest.kt b/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/dbflow/contentobserver/ContentObserverTest.kt similarity index 76% rename from dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/contentobserver/ContentObserverTest.kt rename to dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/dbflow/contentobserver/ContentObserverTest.kt index 52c3f932f..37d48f8d1 100644 --- a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/contentobserver/ContentObserverTest.kt +++ b/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/dbflow/contentobserver/ContentObserverTest.kt @@ -1,23 +1,23 @@ -package com.raizlabs.android.dbflow.contentobserver +package com.raizlabs.dbflow5.dbflow.contentobserver import android.net.Uri -import com.raizlabs.android.dbflow.BaseInstrumentedUnitTest -import com.raizlabs.android.dbflow.DemoApp -import com.raizlabs.android.dbflow.TABLE_QUERY_PARAM -import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.config.databaseForTable -import com.raizlabs.android.dbflow.config.tableName -import com.raizlabs.android.dbflow.contentobserver.User_Table.id -import com.raizlabs.android.dbflow.contentobserver.User_Table.name -import com.raizlabs.android.dbflow.getNotificationUri -import com.raizlabs.android.dbflow.query.SQLOperator -import com.raizlabs.android.dbflow.query.delete -import com.raizlabs.android.dbflow.runtime.FlowContentObserver -import com.raizlabs.android.dbflow.structure.ChangeAction -import com.raizlabs.android.dbflow.structure.delete -import com.raizlabs.android.dbflow.structure.insert -import com.raizlabs.android.dbflow.structure.save -import com.raizlabs.android.dbflow.structure.update +import com.raizlabs.dbflow5.dbflow.BaseInstrumentedUnitTest +import com.raizlabs.dbflow5.dbflow.DemoApp +import com.raizlabs.dbflow5.TABLE_QUERY_PARAM +import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.config.databaseForTable +import com.raizlabs.dbflow5.config.tableName +import com.raizlabs.dbflow5.dbflow.contentobserver.User_Table.id +import com.raizlabs.dbflow5.dbflow.contentobserver.User_Table.name +import com.raizlabs.dbflow5.getNotificationUri +import com.raizlabs.dbflow5.query.SQLOperator +import com.raizlabs.dbflow5.query.delete +import com.raizlabs.dbflow5.runtime.FlowContentObserver +import com.raizlabs.dbflow5.structure.ChangeAction +import com.raizlabs.dbflow5.structure.delete +import com.raizlabs.dbflow5.structure.insert +import com.raizlabs.dbflow5.structure.save +import com.raizlabs.dbflow5.structure.update import org.junit.Assert.assertEquals import org.junit.Before import org.junit.Test diff --git a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/prepackaged/PrepackagedDBTest.kt b/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/dbflow/prepackaged/PrepackagedDBTest.kt similarity index 57% rename from dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/prepackaged/PrepackagedDBTest.kt rename to dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/dbflow/prepackaged/PrepackagedDBTest.kt index 18cfcea6b..d86eae7c7 100644 --- a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/prepackaged/PrepackagedDBTest.kt +++ b/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/dbflow/prepackaged/PrepackagedDBTest.kt @@ -1,9 +1,7 @@ -package com.raizlabs.android.dbflow.prepackaged +package com.raizlabs.dbflow5.dbflow.prepackaged -import com.raizlabs.android.dbflow.BaseInstrumentedUnitTest -import com.raizlabs.android.dbflow.config.databaseForTable -import com.raizlabs.android.dbflow.query.list -import com.raizlabs.android.dbflow.query.select +import com.raizlabs.dbflow5.dbflow.BaseInstrumentedUnitTest +import com.raizlabs.dbflow5.config.databaseForTable import org.junit.Assert.assertTrue import org.junit.Test diff --git a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/sqlcipher/CipherTest.kt b/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/sqlcipher/CipherTest.kt similarity index 64% rename from dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/sqlcipher/CipherTest.kt rename to dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/sqlcipher/CipherTest.kt index 6b9f84afd..5f3186215 100644 --- a/dbflow-tests/src/androidTest/java/com/raizlabs/android/dbflow/sqlcipher/CipherTest.kt +++ b/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/sqlcipher/CipherTest.kt @@ -1,11 +1,8 @@ -package com.raizlabs.android.dbflow.sqlcipher +package com.raizlabs.dbflow5.sqlcipher -import com.raizlabs.android.dbflow.BaseInstrumentedUnitTest -import com.raizlabs.android.dbflow.config.database -import com.raizlabs.android.dbflow.query.delete -import com.raizlabs.android.dbflow.query.result -import com.raizlabs.android.dbflow.query.select -import com.raizlabs.android.dbflow.query.where +import com.raizlabs.dbflow5.dbflow.BaseInstrumentedUnitTest +import com.raizlabs.dbflow5.config.database +import com.raizlabs.dbflow5.query.delete import org.junit.Assert.assertTrue import org.junit.Test diff --git a/dbflow-tests/src/main/AndroidManifest.xml b/dbflow-tests/src/main/AndroidManifest.xml index dc5309fa7..15b815b16 100644 --- a/dbflow-tests/src/main/AndroidManifest.xml +++ b/dbflow-tests/src/main/AndroidManifest.xml @@ -1,16 +1,16 @@ + android:name="com.raizlabs.dbflow5.dbflow.test.DemoActivity"> diff --git a/dbflow-tests/src/main/java/com/raizlabs/android/dbflow/contentobserver/User.kt b/dbflow-tests/src/main/java/com/raizlabs/android/dbflow/contentobserver/User.kt deleted file mode 100644 index 5d5da0878..000000000 --- a/dbflow-tests/src/main/java/com/raizlabs/android/dbflow/contentobserver/User.kt +++ /dev/null @@ -1,9 +0,0 @@ -package com.raizlabs.android.dbflow.contentobserver - -import com.raizlabs.android.dbflow.AppDatabase -import com.raizlabs.android.dbflow.annotation.Column -import com.raizlabs.android.dbflow.annotation.PrimaryKey -import com.raizlabs.android.dbflow.annotation.Table - -@Table(database = AppDatabase::class) -class User(@PrimaryKey var id: Int = 0, @PrimaryKey var name: String = "", @Column var age: Int = 0) \ No newline at end of file diff --git a/dbflow-tests/src/main/java/com/raizlabs/android/dbflow/prepackaged/PrepackagedDB.kt b/dbflow-tests/src/main/java/com/raizlabs/android/dbflow/prepackaged/PrepackagedDB.kt deleted file mode 100644 index 464fd34c4..000000000 --- a/dbflow-tests/src/main/java/com/raizlabs/android/dbflow/prepackaged/PrepackagedDB.kt +++ /dev/null @@ -1,25 +0,0 @@ -package com.raizlabs.android.dbflow.prepackaged - -import com.raizlabs.android.dbflow.annotation.Column -import com.raizlabs.android.dbflow.annotation.Database -import com.raizlabs.android.dbflow.annotation.PrimaryKey -import com.raizlabs.android.dbflow.annotation.Table -import com.raizlabs.android.dbflow.structure.BaseModel - -@Database(version = PrepackagedDB.VERSION) -object PrepackagedDB { - const val VERSION = 1 -} - -@Table(database = PrepackagedDB::class, allFields = true) -class Dog : BaseModel() { - - @PrimaryKey - var id: Int = 0 - - @Column - var breed: String? = null - - @Column - var color: String? = null -} \ No newline at end of file diff --git a/dbflow-tests/src/main/java/com/raizlabs/android/dbflow/sqlcipher/CipherDatabase.kt b/dbflow-tests/src/main/java/com/raizlabs/android/dbflow/sqlcipher/CipherDatabase.kt deleted file mode 100644 index 5c4911f7f..000000000 --- a/dbflow-tests/src/main/java/com/raizlabs/android/dbflow/sqlcipher/CipherDatabase.kt +++ /dev/null @@ -1,9 +0,0 @@ -package com.raizlabs.android.dbflow.sqlcipher - -import com.raizlabs.android.dbflow.annotation.Database - -@Database(version = CipherDatabase.VERSION) -object CipherDatabase { - - const val VERSION = 1 -} \ No newline at end of file diff --git a/dbflow-tests/src/main/java/com/raizlabs/android/dbflow/AppDatabase.kt b/dbflow-tests/src/main/java/com/raizlabs/dbflow5/dbflow/AppDatabase.kt similarity index 50% rename from dbflow-tests/src/main/java/com/raizlabs/android/dbflow/AppDatabase.kt rename to dbflow-tests/src/main/java/com/raizlabs/dbflow5/dbflow/AppDatabase.kt index 01ee859f9..f0ff75f67 100644 --- a/dbflow-tests/src/main/java/com/raizlabs/android/dbflow/AppDatabase.kt +++ b/dbflow-tests/src/main/java/com/raizlabs/dbflow5/dbflow/AppDatabase.kt @@ -1,6 +1,6 @@ -package com.raizlabs.android.dbflow +package com.raizlabs.dbflow5.dbflow -import com.raizlabs.android.dbflow.annotation.Database +import com.raizlabs.dbflow5.annotation.Database @Database(version = AppDatabase.VERSION) object AppDatabase { diff --git a/dbflow-tests/src/main/java/com/raizlabs/android/dbflow/DemoApp.kt b/dbflow-tests/src/main/java/com/raizlabs/dbflow5/dbflow/DemoApp.kt similarity index 87% rename from dbflow-tests/src/main/java/com/raizlabs/android/dbflow/DemoApp.kt rename to dbflow-tests/src/main/java/com/raizlabs/dbflow5/dbflow/DemoApp.kt index 6676d1d28..90ec23f57 100644 --- a/dbflow-tests/src/main/java/com/raizlabs/android/dbflow/DemoApp.kt +++ b/dbflow-tests/src/main/java/com/raizlabs/dbflow5/dbflow/DemoApp.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow +package com.raizlabs.dbflow5.dbflow import android.app.Application import android.content.Context diff --git a/dbflow-tests/src/main/java/com/raizlabs/android/dbflow/StubContentProvider.kt b/dbflow-tests/src/main/java/com/raizlabs/dbflow5/dbflow/StubContentProvider.kt similarity index 96% rename from dbflow-tests/src/main/java/com/raizlabs/android/dbflow/StubContentProvider.kt rename to dbflow-tests/src/main/java/com/raizlabs/dbflow5/dbflow/StubContentProvider.kt index fcaed3053..e5667f831 100644 --- a/dbflow-tests/src/main/java/com/raizlabs/android/dbflow/StubContentProvider.kt +++ b/dbflow-tests/src/main/java/com/raizlabs/dbflow5/dbflow/StubContentProvider.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow +package com.raizlabs.dbflow5.dbflow import android.content.ContentProvider import android.content.ContentValues diff --git a/dbflow-tests/src/main/java/com/raizlabs/android/dbflow/User.kt b/dbflow-tests/src/main/java/com/raizlabs/dbflow5/dbflow/User.kt similarity index 55% rename from dbflow-tests/src/main/java/com/raizlabs/android/dbflow/User.kt rename to dbflow-tests/src/main/java/com/raizlabs/dbflow5/dbflow/User.kt index 583d61896..d2295e1d4 100644 --- a/dbflow-tests/src/main/java/com/raizlabs/android/dbflow/User.kt +++ b/dbflow-tests/src/main/java/com/raizlabs/dbflow5/dbflow/User.kt @@ -1,8 +1,8 @@ -package com.raizlabs.android.dbflow +package com.raizlabs.dbflow5.dbflow -import com.raizlabs.android.dbflow.annotation.Column -import com.raizlabs.android.dbflow.annotation.PrimaryKey -import com.raizlabs.android.dbflow.annotation.Table +import com.raizlabs.dbflow5.annotation.Column +import com.raizlabs.dbflow5.annotation.PrimaryKey +import com.raizlabs.dbflow5.annotation.Table @Table(database = AppDatabase::class, name = "User2") class User { diff --git a/dbflow-tests/src/main/java/com/raizlabs/dbflow5/dbflow/contentobserver/User.kt b/dbflow-tests/src/main/java/com/raizlabs/dbflow5/dbflow/contentobserver/User.kt new file mode 100644 index 000000000..29c348aa9 --- /dev/null +++ b/dbflow-tests/src/main/java/com/raizlabs/dbflow5/dbflow/contentobserver/User.kt @@ -0,0 +1,9 @@ +package com.raizlabs.dbflow5.dbflow.contentobserver + +import com.raizlabs.dbflow5.dbflow.AppDatabase +import com.raizlabs.dbflow5.annotation.Column +import com.raizlabs.dbflow5.annotation.PrimaryKey +import com.raizlabs.dbflow5.annotation.Table + +@Table(database = AppDatabase::class) +class User(@PrimaryKey var id: Int = 0, @PrimaryKey var name: String = "", @Column var age: Int = 0) \ No newline at end of file diff --git a/dbflow-tests/src/main/java/com/raizlabs/dbflow5/dbflow/prepackaged/PrepackagedDB.kt b/dbflow-tests/src/main/java/com/raizlabs/dbflow5/dbflow/prepackaged/PrepackagedDB.kt new file mode 100644 index 000000000..5c7260afd --- /dev/null +++ b/dbflow-tests/src/main/java/com/raizlabs/dbflow5/dbflow/prepackaged/PrepackagedDB.kt @@ -0,0 +1,25 @@ +package com.raizlabs.dbflow5.dbflow.prepackaged + +import com.raizlabs.dbflow5.annotation.Column +import com.raizlabs.dbflow5.annotation.Database +import com.raizlabs.dbflow5.annotation.PrimaryKey +import com.raizlabs.dbflow5.annotation.Table +import com.raizlabs.dbflow5.structure.BaseModel + +@Database(version = PrepackagedDB.VERSION) +object PrepackagedDB { + const val VERSION = 1 +} + +@Table(database = PrepackagedDB::class, allFields = true) +class Dog : BaseModel() { + + @PrimaryKey + var id: Int = 0 + + @Column + var breed: String? = null + + @Column + var color: String? = null +} \ No newline at end of file diff --git a/dbflow-tests/src/main/java/com/raizlabs/android/dbflow/test/DemoActivity.java b/dbflow-tests/src/main/java/com/raizlabs/dbflow5/dbflow/test/DemoActivity.java similarity index 83% rename from dbflow-tests/src/main/java/com/raizlabs/android/dbflow/test/DemoActivity.java rename to dbflow-tests/src/main/java/com/raizlabs/dbflow5/dbflow/test/DemoActivity.java index 6e13c3907..76e1b74f8 100644 --- a/dbflow-tests/src/main/java/com/raizlabs/android/dbflow/test/DemoActivity.java +++ b/dbflow-tests/src/main/java/com/raizlabs/dbflow5/dbflow/test/DemoActivity.java @@ -1,14 +1,14 @@ -package com.raizlabs.android.dbflow.test; +package com.raizlabs.dbflow5.dbflow.test; import android.app.Activity; import android.os.Bundle; import android.view.Menu; import android.view.MenuItem; -import com.raizlabs.android.dbflow.config.DatabaseConfig; -import com.raizlabs.android.dbflow.config.FlowConfig; -import com.raizlabs.android.dbflow.config.FlowManager; -import com.raizlabs.android.dbflow.prepackaged.PrepackagedDB; +import com.raizlabs.dbflow5.config.DatabaseConfig; +import com.raizlabs.dbflow5.config.FlowConfig; +import com.raizlabs.dbflow5.config.FlowManager; +import com.raizlabs.dbflow5.dbflow.prepackaged.PrepackagedDB; public class DemoActivity extends Activity { diff --git a/dbflow-tests/src/main/java/com/raizlabs/dbflow5/sqlcipher/CipherDatabase.kt b/dbflow-tests/src/main/java/com/raizlabs/dbflow5/sqlcipher/CipherDatabase.kt new file mode 100644 index 000000000..4bf3cb5a0 --- /dev/null +++ b/dbflow-tests/src/main/java/com/raizlabs/dbflow5/sqlcipher/CipherDatabase.kt @@ -0,0 +1,9 @@ +package com.raizlabs.dbflow5.sqlcipher + +import com.raizlabs.dbflow5.annotation.Database + +@Database(version = CipherDatabase.VERSION) +object CipherDatabase { + + const val VERSION = 1 +} \ No newline at end of file diff --git a/dbflow-tests/src/main/java/com/raizlabs/android/dbflow/sqlcipher/CipherTestObjects.kt b/dbflow-tests/src/main/java/com/raizlabs/dbflow5/sqlcipher/CipherTestObjects.kt similarity index 51% rename from dbflow-tests/src/main/java/com/raizlabs/android/dbflow/sqlcipher/CipherTestObjects.kt rename to dbflow-tests/src/main/java/com/raizlabs/dbflow5/sqlcipher/CipherTestObjects.kt index c6eb5a80d..fa3ad71ad 100644 --- a/dbflow-tests/src/main/java/com/raizlabs/android/dbflow/sqlcipher/CipherTestObjects.kt +++ b/dbflow-tests/src/main/java/com/raizlabs/dbflow5/sqlcipher/CipherTestObjects.kt @@ -1,11 +1,11 @@ -package com.raizlabs.android.dbflow.sqlcipher +package com.raizlabs.dbflow5.sqlcipher -import com.raizlabs.android.dbflow.annotation.Column -import com.raizlabs.android.dbflow.annotation.PrimaryKey -import com.raizlabs.android.dbflow.annotation.Table -import com.raizlabs.android.dbflow.config.DatabaseDefinition -import com.raizlabs.android.dbflow.database.DatabaseHelperListener -import com.raizlabs.android.dbflow.structure.BaseModel +import com.raizlabs.dbflow5.annotation.Column +import com.raizlabs.dbflow5.annotation.PrimaryKey +import com.raizlabs.dbflow5.annotation.Table +import com.raizlabs.dbflow5.config.DatabaseDefinition +import com.raizlabs.dbflow5.database.DatabaseHelperListener +import com.raizlabs.dbflow5.structure.BaseModel class SQLCipherOpenHelperImpl(databaseDefinition: DatabaseDefinition, helperListener: DatabaseHelperListener?) : SQLCipherOpenHelper(databaseDefinition, helperListener) { diff --git a/dbflow-tests/src/main/res/menu/menu_demo.xml b/dbflow-tests/src/main/res/menu/menu_demo.xml index 76854bbdd..dff9615bd 100644 --- a/dbflow-tests/src/main/res/menu/menu_demo.xml +++ b/dbflow-tests/src/main/res/menu/menu_demo.xml @@ -1,7 +1,7 @@ + tools:context="com.raizlabs.dbflow5.dbflow.DemoActivity"> - + diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/InnerClassExample.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/InnerClassExample.kt deleted file mode 100644 index ee120108d..000000000 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/InnerClassExample.kt +++ /dev/null @@ -1,14 +0,0 @@ -package com.raizlabs.android.dbflow.models - -import com.raizlabs.android.dbflow.TestDatabase -import com.raizlabs.android.dbflow.annotation.PrimaryKey -import com.raizlabs.android.dbflow.annotation.Table - -/** - * Example ensuring static inner classes work. - */ -class Outer { - - @Table(database = TestDatabase::class) - class Inner(@PrimaryKey var id: Int = 0) -} \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/NonTypical/nonTypicalClassName.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/NonTypical/nonTypicalClassName.kt deleted file mode 100644 index aa38949fb..000000000 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/NonTypical/nonTypicalClassName.kt +++ /dev/null @@ -1,11 +0,0 @@ -package com.raizlabs.android.dbflow.models.NonTypical - -import com.raizlabs.android.dbflow.TestDatabase -import com.raizlabs.android.dbflow.annotation.PrimaryKey -import com.raizlabs.android.dbflow.annotation.Table - -/** - * Tests package name capitalized, class name is lower cased. - */ -@Table(database = TestDatabase::class) -class nonTypicalClassName(@PrimaryKey var id: Int = 0) \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/Page.java b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/Page.java deleted file mode 100644 index 3f93879ef..000000000 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/Page.java +++ /dev/null @@ -1,25 +0,0 @@ -package com.raizlabs.android.dbflow.models.issue; - -import com.raizlabs.android.dbflow.TestDatabase; -import com.raizlabs.android.dbflow.annotation.Column; -import com.raizlabs.android.dbflow.annotation.ForeignKey; -import com.raizlabs.android.dbflow.annotation.PrimaryKey; -import com.raizlabs.android.dbflow.annotation.Table; -import com.raizlabs.android.dbflow.structure.BaseModel; - -/** - * Description: - */ -@Table(database = TestDatabase.class) -public class Page extends BaseModel { - - @PrimaryKey - @Column - String id; - - @PrimaryKey - String owningIssueId; - - @ForeignKey(stubbedRelationship = true) - SubIssue subIssue; -} diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/java/JavaModelView.java b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/java/JavaModelView.java deleted file mode 100644 index dc7bd1205..000000000 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/java/JavaModelView.java +++ /dev/null @@ -1,26 +0,0 @@ -package com.raizlabs.android.dbflow.models.java; - -import com.raizlabs.android.dbflow.TestDatabase; -import com.raizlabs.android.dbflow.annotation.Column; -import com.raizlabs.android.dbflow.annotation.ModelView; -import com.raizlabs.android.dbflow.annotation.ModelViewQuery; -import com.raizlabs.android.dbflow.database.DatabaseWrapper; -import com.raizlabs.android.dbflow.models.Author_Table; -import com.raizlabs.android.dbflow.query.SQLite; -import com.raizlabs.android.dbflow.sql.Query; - -@ModelView(database = TestDatabase.class) -public class JavaModelView { - - @ModelViewQuery - public static Query getQuery(DatabaseWrapper databaseWrapper) { - return SQLite.select(databaseWrapper, Author_Table.first_name.as("firstName"), Author_Table.id.as("id")); - } - - @Column - String id; - - @Column - Integer firstName; - -} diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/java/otherpackage/ExampleModel.java b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/java/otherpackage/ExampleModel.java deleted file mode 100644 index bac84d390..000000000 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/java/otherpackage/ExampleModel.java +++ /dev/null @@ -1,12 +0,0 @@ -package com.raizlabs.android.dbflow.models.java.otherpackage; - -import com.raizlabs.android.dbflow.TestDatabase; -import com.raizlabs.android.dbflow.annotation.Column; -import com.raizlabs.android.dbflow.annotation.Table; -import com.raizlabs.android.dbflow.models.java.DatabaseModel; - -@Table(database = TestDatabase.class) -public class ExampleModel extends DatabaseModel { - @Column - String name; -} diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/query/RxModels.kt b/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/query/RxModels.kt deleted file mode 100644 index 749fc80cf..000000000 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/query/RxModels.kt +++ /dev/null @@ -1,13 +0,0 @@ -package com.raizlabs.android.dbflow.rx.query - -import com.raizlabs.android.dbflow.TestDatabase -import com.raizlabs.android.dbflow.annotation.PrimaryKey -import com.raizlabs.android.dbflow.annotation.Table -import com.raizlabs.android.dbflow.rx.structure.BaseRXModel - - -@Table(database = TestDatabase::class, allFields = true) -class SimpleRXModel(@PrimaryKey var id: String = "") : BaseRXModel() - -@Table(database = TestDatabase::class) -class SimpleRXModel2(@PrimaryKey var id: String = "") : com.raizlabs.android.dbflow.rx2.structure.BaseRXModel() \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/BaseUnitTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/BaseUnitTest.kt similarity index 92% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/BaseUnitTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/BaseUnitTest.kt index 7dad0f0aa..c90e55041 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/BaseUnitTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/BaseUnitTest.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow +package com.raizlabs.dbflow5.dbflow import android.content.Context import org.junit.Rule diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/DBFlowTestRule.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/DBFlowTestRule.kt similarity index 81% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/DBFlowTestRule.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/DBFlowTestRule.kt index 45277e834..a07c470c8 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/DBFlowTestRule.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/DBFlowTestRule.kt @@ -1,9 +1,9 @@ -package com.raizlabs.android.dbflow +package com.raizlabs.dbflow5.dbflow -import com.raizlabs.android.dbflow.config.DatabaseConfig -import com.raizlabs.android.dbflow.config.FlowConfig -import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.provider.ContentDatabase +import com.raizlabs.dbflow5.config.DatabaseConfig +import com.raizlabs.dbflow5.config.FlowConfig +import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.dbflow.provider.ContentDatabase import org.junit.rules.TestRule import org.junit.runner.Description import org.junit.runners.model.Statement diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/ImmediateTransactionManager.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/ImmediateTransactionManager.kt similarity index 70% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/ImmediateTransactionManager.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/ImmediateTransactionManager.kt index a68ed063d..cf4a12d7c 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/ImmediateTransactionManager.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/ImmediateTransactionManager.kt @@ -1,9 +1,9 @@ -package com.raizlabs.android.dbflow +package com.raizlabs.dbflow5.dbflow -import com.raizlabs.android.dbflow.config.DatabaseDefinition -import com.raizlabs.android.dbflow.transaction.BaseTransactionManager -import com.raizlabs.android.dbflow.transaction.ITransactionQueue -import com.raizlabs.android.dbflow.transaction.Transaction +import com.raizlabs.dbflow5.config.DatabaseDefinition +import com.raizlabs.dbflow5.transaction.BaseTransactionManager +import com.raizlabs.dbflow5.transaction.ITransactionQueue +import com.raizlabs.dbflow5.transaction.Transaction /** * Description: Executes all transactions on same thread for testing. diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/TestDatabase.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/TestDatabase.kt similarity index 57% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/TestDatabase.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/TestDatabase.kt index f6915e29c..5ae85d348 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/TestDatabase.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/TestDatabase.kt @@ -1,9 +1,9 @@ -package com.raizlabs.android.dbflow +package com.raizlabs.dbflow5.dbflow -import com.raizlabs.android.dbflow.annotation.Database -import com.raizlabs.android.dbflow.annotation.Migration -import com.raizlabs.android.dbflow.migration.UpdateTableMigration -import com.raizlabs.android.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.annotation.Database +import com.raizlabs.dbflow5.annotation.Migration +import com.raizlabs.dbflow5.migration.UpdateTableMigration +import com.raizlabs.dbflow5.dbflow.models.SimpleModel /** * Description: diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/TestExtensions.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/TestExtensions.kt similarity index 86% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/TestExtensions.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/TestExtensions.kt index d33cc7cc5..bfc033b69 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/TestExtensions.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/TestExtensions.kt @@ -1,6 +1,6 @@ -package com.raizlabs.android.dbflow +package com.raizlabs.dbflow5.dbflow -import com.raizlabs.android.dbflow.sql.Query +import com.raizlabs.dbflow5.sql.Query import org.junit.Assert.assertEquals import org.junit.Assert.fail import kotlin.reflect.KClass diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/config/ConfigIntegrationTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/config/ConfigIntegrationTest.kt similarity index 79% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/config/ConfigIntegrationTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/config/ConfigIntegrationTest.kt index 904dfbde1..b9c941c35 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/config/ConfigIntegrationTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/config/ConfigIntegrationTest.kt @@ -1,11 +1,16 @@ -package com.raizlabs.android.dbflow.config - -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.TestDatabase -import com.raizlabs.android.dbflow.adapter.queriable.ListModelLoader -import com.raizlabs.android.dbflow.adapter.queriable.SingleModelLoader -import com.raizlabs.android.dbflow.adapter.saveable.ModelSaver -import com.raizlabs.android.dbflow.models.SimpleModel +package com.raizlabs.dbflow5.dbflow.config + +import com.raizlabs.dbflow5.config.DatabaseConfig +import com.raizlabs.dbflow5.config.FlowConfig +import com.raizlabs.dbflow5.config.FlowLog +import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.dbflow.TestDatabase +import com.raizlabs.dbflow5.adapter.queriable.ListModelLoader +import com.raizlabs.dbflow5.adapter.queriable.SingleModelLoader +import com.raizlabs.dbflow5.adapter.saveable.ModelSaver +import com.raizlabs.dbflow5.config.TableConfig +import com.raizlabs.dbflow5.dbflow.models.SimpleModel import org.junit.Assert.* import org.junit.Before import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/config/DatabaseConfigTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/config/DatabaseConfigTest.kt similarity index 84% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/config/DatabaseConfigTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/config/DatabaseConfigTest.kt index 22387c506..a30eac6f9 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/config/DatabaseConfigTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/config/DatabaseConfigTest.kt @@ -1,11 +1,16 @@ -package com.raizlabs.android.dbflow.config +package com.raizlabs.dbflow5.dbflow.config import com.nhaarman.mockito_kotlin.mock -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.TestDatabase -import com.raizlabs.android.dbflow.database.DatabaseHelperListener -import com.raizlabs.android.dbflow.database.OpenHelper -import com.raizlabs.android.dbflow.transaction.BaseTransactionManager +import com.raizlabs.dbflow5.config.DatabaseConfig +import com.raizlabs.dbflow5.config.DatabaseDefinition +import com.raizlabs.dbflow5.config.FlowConfig +import com.raizlabs.dbflow5.config.FlowLog +import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.dbflow.TestDatabase +import com.raizlabs.dbflow5.database.DatabaseHelperListener +import com.raizlabs.dbflow5.database.OpenHelper +import com.raizlabs.dbflow5.transaction.BaseTransactionManager import org.junit.Assert import org.junit.Before import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/CoroutinesTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/database/transaction/CoroutinesTest.kt similarity index 71% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/CoroutinesTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/database/transaction/CoroutinesTest.kt index 906771c42..0e6654139 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/CoroutinesTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/database/transaction/CoroutinesTest.kt @@ -1,20 +1,18 @@ -package com.raizlabs.android.dbflow.database.transaction +package com.raizlabs.dbflow5.dbflow.database.transaction -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.TestDatabase -import com.raizlabs.android.dbflow.config.database -import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.models.SimpleModel_Table -import com.raizlabs.android.dbflow.query.delete -import com.raizlabs.android.dbflow.query.list -import com.raizlabs.android.dbflow.query.select -import com.raizlabs.android.dbflow.query.where -import com.raizlabs.android.dbflow.structure.save -import com.raizlabs.dbflow.coroutines.awaitDelete -import com.raizlabs.dbflow.coroutines.awaitInsert -import com.raizlabs.dbflow.coroutines.awaitSave -import com.raizlabs.dbflow.coroutines.awaitUpdate -import com.raizlabs.dbflow.coroutines.transact +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.dbflow.TestDatabase +import com.raizlabs.dbflow5.config.database +import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.dbflow.models.SimpleModel_Table +import com.raizlabs.dbflow5.query.delete +import com.raizlabs.dbflow5.query.where +import com.raizlabs.dbflow5.structure.save +import com.raizlabs.dbflow5.coroutines.awaitDelete +import com.raizlabs.dbflow5.coroutines.awaitInsert +import com.raizlabs.dbflow5.coroutines.awaitSave +import com.raizlabs.dbflow5.coroutines.awaitUpdate +import com.raizlabs.dbflow5.coroutines.transact import kotlinx.coroutines.experimental.runBlocking import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/FastStoreModelTransactionTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/database/transaction/FastStoreModelTransactionTest.kt similarity index 63% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/FastStoreModelTransactionTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/database/transaction/FastStoreModelTransactionTest.kt index 04c8f8ce9..554a6c0c7 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/database/transaction/FastStoreModelTransactionTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/database/transaction/FastStoreModelTransactionTest.kt @@ -1,15 +1,13 @@ -package com.raizlabs.android.dbflow.database.transaction +package com.raizlabs.dbflow5.dbflow.database.transaction -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.TestDatabase -import com.raizlabs.android.dbflow.config.database -import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.models.TwoColumnModel -import com.raizlabs.android.dbflow.query.list -import com.raizlabs.android.dbflow.query.select -import com.raizlabs.dbflow.coroutines.awaitInsert -import com.raizlabs.dbflow.coroutines.awaitSave -import com.raizlabs.dbflow.coroutines.awaitUpdate +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.dbflow.TestDatabase +import com.raizlabs.dbflow5.config.database +import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.dbflow.models.TwoColumnModel +import com.raizlabs.dbflow5.coroutines.awaitInsert +import com.raizlabs.dbflow5.coroutines.awaitSave +import com.raizlabs.dbflow5.coroutines.awaitUpdate import kotlinx.coroutines.experimental.runBlocking import org.junit.Assert.assertEquals import org.junit.Assert.assertNotEquals @@ -24,7 +22,7 @@ class FastStoreModelTransactionTest : BaseUnitTest() { database(TestDatabase::class) { val result = (0..9) .map { SimpleModel("$it") }.awaitSave(this) - val list = (writableDatabase.select from SimpleModel::class).list + val list = (select from SimpleModel::class).list assertEquals(10, list.size) assertEquals(10L, result) } @@ -37,7 +35,7 @@ class FastStoreModelTransactionTest : BaseUnitTest() { database(TestDatabase::class) { val result = (0..9) .map { SimpleModel("$it") }.awaitInsert(this) - val list = (writableDatabase.select from SimpleModel::class).list + val list = (select from SimpleModel::class).list assertEquals(10, list.size) assertEquals(10L, result) } @@ -53,7 +51,7 @@ class FastStoreModelTransactionTest : BaseUnitTest() { (0..9).map { TwoColumnModel("$it", Random().nextInt()) }.awaitUpdate(this) - val list = (writableDatabase.select from TwoColumnModel::class).list + val list = (select from TwoColumnModel::class).list assertEquals(10, list.size) list.forEachIndexed { index, model -> assertNotEquals(model, oldList[index]) diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/migration/UpdateTableMigrationTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/migration/UpdateTableMigrationTest.kt similarity index 50% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/migration/UpdateTableMigrationTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/migration/UpdateTableMigrationTest.kt index 3764ef315..04b7cc554 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/migration/UpdateTableMigrationTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/migration/UpdateTableMigrationTest.kt @@ -1,9 +1,10 @@ -package com.raizlabs.android.dbflow.migration +package com.raizlabs.dbflow5.dbflow.migration -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.config.databaseForTable -import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.models.SimpleModel_Table +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.config.databaseForTable +import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.dbflow.models.SimpleModel_Table +import com.raizlabs.dbflow5.migration.UpdateTableMigration import org.junit.Test /** diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/AutoIncrementTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/AutoIncrementTest.kt similarity index 65% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/AutoIncrementTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/AutoIncrementTest.kt index e3a39d044..8e646fc52 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/AutoIncrementTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/AutoIncrementTest.kt @@ -1,10 +1,10 @@ -package com.raizlabs.android.dbflow.models +package com.raizlabs.dbflow5.dbflow.models -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.TestDatabase -import com.raizlabs.android.dbflow.annotation.PrimaryKey -import com.raizlabs.android.dbflow.annotation.Table -import com.raizlabs.android.dbflow.structure.insert +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.dbflow.TestDatabase +import com.raizlabs.dbflow5.annotation.PrimaryKey +import com.raizlabs.dbflow5.annotation.Table +import com.raizlabs.dbflow5.structure.insert import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/CachingModels.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/CachingModels.kt similarity index 62% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/CachingModels.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/CachingModels.kt index 64332d7b1..c2cdfc1d0 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/CachingModels.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/CachingModels.kt @@ -1,12 +1,12 @@ -package com.raizlabs.android.dbflow.models +package com.raizlabs.dbflow5.dbflow.models -import com.raizlabs.android.dbflow.TestDatabase -import com.raizlabs.android.dbflow.annotation.Column -import com.raizlabs.android.dbflow.annotation.ForeignKey -import com.raizlabs.android.dbflow.annotation.MultiCacheField -import com.raizlabs.android.dbflow.annotation.PrimaryKey -import com.raizlabs.android.dbflow.annotation.Table -import com.raizlabs.android.dbflow.query.cache.IMultiKeyCacheConverter +import com.raizlabs.dbflow5.dbflow.TestDatabase +import com.raizlabs.dbflow5.annotation.Column +import com.raizlabs.dbflow5.annotation.ForeignKey +import com.raizlabs.dbflow5.annotation.MultiCacheField +import com.raizlabs.dbflow5.annotation.PrimaryKey +import com.raizlabs.dbflow5.annotation.Table +import com.raizlabs.dbflow5.query.cache.IMultiKeyCacheConverter @Table(database = TestDatabase::class, cachingEnabled = true) class SimpleCacheObject(@PrimaryKey var id: String = "") diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/CachingModelsTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/CachingModelsTest.kt similarity index 75% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/CachingModelsTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/CachingModelsTest.kt index 04046e6e8..2fe488f9f 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/CachingModelsTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/CachingModelsTest.kt @@ -1,12 +1,9 @@ -package com.raizlabs.android.dbflow.models - -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.TestDatabase -import com.raizlabs.android.dbflow.config.database -import com.raizlabs.android.dbflow.query.list -import com.raizlabs.android.dbflow.query.result -import com.raizlabs.android.dbflow.query.select -import com.raizlabs.android.dbflow.structure.save +package com.raizlabs.dbflow5.dbflow.models + +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.dbflow.TestDatabase +import com.raizlabs.dbflow5.config.database +import com.raizlabs.dbflow5.structure.save import org.junit.Assert.assertEquals import org.junit.Assert.assertNotEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/DontCreateModelTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/DontCreateModelTest.kt similarity index 55% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/DontCreateModelTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/DontCreateModelTest.kt index 3b707c409..d61beade1 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/DontCreateModelTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/DontCreateModelTest.kt @@ -1,11 +1,9 @@ -package com.raizlabs.android.dbflow.models +package com.raizlabs.dbflow5.dbflow.models import android.database.sqlite.SQLiteException -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.assertThrowsException -import com.raizlabs.android.dbflow.config.databaseForTable -import com.raizlabs.android.dbflow.query.list -import com.raizlabs.android.dbflow.query.select +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.dbflow.assertThrowsException +import com.raizlabs.dbflow5.config.databaseForTable import org.junit.Test /** diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ForeignKeyModels.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/ForeignKeyModels.kt similarity index 81% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ForeignKeyModels.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/ForeignKeyModels.kt index 0bd4d4bb8..b8f52de09 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ForeignKeyModels.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/ForeignKeyModels.kt @@ -1,18 +1,18 @@ -package com.raizlabs.android.dbflow.models +package com.raizlabs.dbflow5.dbflow.models import android.database.Cursor -import com.raizlabs.android.dbflow.TestDatabase -import com.raizlabs.android.dbflow.annotation.Column -import com.raizlabs.android.dbflow.annotation.ColumnMap -import com.raizlabs.android.dbflow.annotation.ColumnMapReference -import com.raizlabs.android.dbflow.annotation.ConflictAction -import com.raizlabs.android.dbflow.annotation.ForeignKey -import com.raizlabs.android.dbflow.annotation.ForeignKeyAction -import com.raizlabs.android.dbflow.annotation.ForeignKeyReference -import com.raizlabs.android.dbflow.annotation.NotNull -import com.raizlabs.android.dbflow.annotation.PrimaryKey -import com.raizlabs.android.dbflow.annotation.Table -import com.raizlabs.android.dbflow.query.LoadFromCursorListener +import com.raizlabs.dbflow5.dbflow.TestDatabase +import com.raizlabs.dbflow5.annotation.Column +import com.raizlabs.dbflow5.annotation.ColumnMap +import com.raizlabs.dbflow5.annotation.ColumnMapReference +import com.raizlabs.dbflow5.annotation.ConflictAction +import com.raizlabs.dbflow5.annotation.ForeignKey +import com.raizlabs.dbflow5.annotation.ForeignKeyAction +import com.raizlabs.dbflow5.annotation.ForeignKeyReference +import com.raizlabs.dbflow5.annotation.NotNull +import com.raizlabs.dbflow5.annotation.PrimaryKey +import com.raizlabs.dbflow5.annotation.Table +import com.raizlabs.dbflow5.query.LoadFromCursorListener /** * Example of simple foreign key object with one foreign key object. diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/IndexModels.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/IndexModels.kt similarity index 66% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/IndexModels.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/IndexModels.kt index d1938222b..7f54dee68 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/IndexModels.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/IndexModels.kt @@ -1,11 +1,11 @@ -package com.raizlabs.android.dbflow.models +package com.raizlabs.dbflow5.dbflow.models -import com.raizlabs.android.dbflow.TestDatabase -import com.raizlabs.android.dbflow.annotation.Column -import com.raizlabs.android.dbflow.annotation.Index -import com.raizlabs.android.dbflow.annotation.IndexGroup -import com.raizlabs.android.dbflow.annotation.PrimaryKey -import com.raizlabs.android.dbflow.annotation.Table +import com.raizlabs.dbflow5.dbflow.TestDatabase +import com.raizlabs.dbflow5.annotation.Column +import com.raizlabs.dbflow5.annotation.Index +import com.raizlabs.dbflow5.annotation.IndexGroup +import com.raizlabs.dbflow5.annotation.PrimaryKey +import com.raizlabs.dbflow5.annotation.Table import java.util.* /** diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/InnerClassExample.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/InnerClassExample.kt new file mode 100644 index 000000000..8aedff3f6 --- /dev/null +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/InnerClassExample.kt @@ -0,0 +1,14 @@ +package com.raizlabs.dbflow5.dbflow.models + +import com.raizlabs.dbflow5.dbflow.TestDatabase +import com.raizlabs.dbflow5.annotation.PrimaryKey +import com.raizlabs.dbflow5.annotation.Table + +/** + * Example ensuring static inner classes work. + */ +class Outer { + + @Table(database = TestDatabase::class) + class Inner(@PrimaryKey var id: Int = 0) +} \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ManyToMany.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/ManyToMany.kt similarity index 51% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ManyToMany.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/ManyToMany.kt index 2a30d8db8..448bdb852 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ManyToMany.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/ManyToMany.kt @@ -1,10 +1,10 @@ -package com.raizlabs.android.dbflow.models +package com.raizlabs.dbflow5.dbflow.models -import com.raizlabs.android.dbflow.TestDatabase -import com.raizlabs.android.dbflow.annotation.Column -import com.raizlabs.android.dbflow.annotation.ManyToMany -import com.raizlabs.android.dbflow.annotation.PrimaryKey -import com.raizlabs.android.dbflow.annotation.Table +import com.raizlabs.dbflow5.dbflow.TestDatabase +import com.raizlabs.dbflow5.annotation.Column +import com.raizlabs.dbflow5.annotation.ManyToMany +import com.raizlabs.dbflow5.annotation.PrimaryKey +import com.raizlabs.dbflow5.annotation.Table @ManyToMany(referencedTable = Song::class) @Table(database = TestDatabase::class) diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ManyToManyTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/ManyToManyTest.kt similarity index 76% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ManyToManyTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/ManyToManyTest.kt index 25627f043..1421b6bd5 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ManyToManyTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/ManyToManyTest.kt @@ -1,7 +1,7 @@ -package com.raizlabs.android.dbflow.models +package com.raizlabs.dbflow5.dbflow.models -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.structure.save +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.structure.save import org.junit.Assert.assertTrue import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ModelViewTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/ModelViewTest.kt similarity index 62% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ModelViewTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/ModelViewTest.kt index c4522d31c..4aa9b4b93 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ModelViewTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/ModelViewTest.kt @@ -1,10 +1,10 @@ -package com.raizlabs.android.dbflow.models +package com.raizlabs.dbflow5.dbflow.models -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.TestDatabase -import com.raizlabs.android.dbflow.assertEquals -import com.raizlabs.android.dbflow.config.database -import com.raizlabs.android.dbflow.models.java.JavaModelView +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.dbflow.TestDatabase +import com.raizlabs.dbflow5.dbflow.assertEquals +import com.raizlabs.dbflow5.config.database +import com.raizlabs.dbflow5.dbflow.models.java.JavaModelView import org.junit.Test class ModelViewTest : BaseUnitTest() { diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ModelViews.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/ModelViews.kt similarity index 62% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ModelViews.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/ModelViews.kt index fd42dce8d..b0958a0ad 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ModelViews.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/ModelViews.kt @@ -1,15 +1,14 @@ -package com.raizlabs.android.dbflow.models +package com.raizlabs.dbflow5.dbflow.models -import com.raizlabs.android.dbflow.TestDatabase -import com.raizlabs.android.dbflow.annotation.Column -import com.raizlabs.android.dbflow.annotation.ColumnMap -import com.raizlabs.android.dbflow.annotation.ModelView -import com.raizlabs.android.dbflow.annotation.ModelViewQuery -import com.raizlabs.android.dbflow.database.DatabaseWrapper -import com.raizlabs.android.dbflow.models.Author_Table.* -import com.raizlabs.android.dbflow.query.property.IProperty -import com.raizlabs.android.dbflow.query.property.property -import com.raizlabs.android.dbflow.query.select +import com.raizlabs.dbflow5.dbflow.TestDatabase +import com.raizlabs.dbflow5.annotation.Column +import com.raizlabs.dbflow5.annotation.ColumnMap +import com.raizlabs.dbflow5.annotation.ModelView +import com.raizlabs.dbflow5.annotation.ModelViewQuery +import com.raizlabs.dbflow5.database.DatabaseWrapper +import com.raizlabs.dbflow5.dbflow.models.Author_Table.* +import com.raizlabs.dbflow5.query.property.IProperty +import com.raizlabs.dbflow5.query.property.property class AuthorName(var name: String = "", var age: Int = 0) diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/NonTypical/nonTypicalClassName.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/NonTypical/nonTypicalClassName.kt new file mode 100644 index 000000000..bf5cde466 --- /dev/null +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/NonTypical/nonTypicalClassName.kt @@ -0,0 +1,11 @@ +package com.raizlabs.dbflow5.dbflow.models.NonTypical + +import com.raizlabs.dbflow5.dbflow.TestDatabase +import com.raizlabs.dbflow5.annotation.PrimaryKey +import com.raizlabs.dbflow5.annotation.Table + +/** + * Tests package name capitalized, class name is lower cased. + */ +@Table(database = TestDatabase::class) +class nonTypicalClassName(@PrimaryKey var id: Int = 0) \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModelTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/OneToManyModelTest.kt similarity index 70% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModelTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/OneToManyModelTest.kt index 551081e1e..e5679d7ae 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModelTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/OneToManyModelTest.kt @@ -1,14 +1,11 @@ -package com.raizlabs.android.dbflow.models - -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.TestDatabase -import com.raizlabs.android.dbflow.config.database -import com.raizlabs.android.dbflow.query.list -import com.raizlabs.android.dbflow.query.result -import com.raizlabs.android.dbflow.query.select -import com.raizlabs.android.dbflow.structure.delete -import com.raizlabs.android.dbflow.structure.exists -import com.raizlabs.android.dbflow.structure.save +package com.raizlabs.dbflow5.dbflow.models + +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.dbflow.TestDatabase +import com.raizlabs.dbflow5.config.database +import com.raizlabs.dbflow5.structure.delete +import com.raizlabs.dbflow5.structure.exists +import com.raizlabs.dbflow5.structure.save import org.junit.Assert.* import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModels.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/OneToManyModels.kt similarity index 67% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModels.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/OneToManyModels.kt index 908160900..e0392be26 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/OneToManyModels.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/OneToManyModels.kt @@ -1,17 +1,15 @@ -package com.raizlabs.android.dbflow.models - -import com.raizlabs.android.dbflow.TestDatabase -import com.raizlabs.android.dbflow.annotation.OneToMany -import com.raizlabs.android.dbflow.annotation.OneToManyMethod -import com.raizlabs.android.dbflow.annotation.PrimaryKey -import com.raizlabs.android.dbflow.annotation.Table -import com.raizlabs.android.dbflow.config.databaseForTable -import com.raizlabs.android.dbflow.database.DatabaseWrapper -import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id -import com.raizlabs.android.dbflow.query.select -import com.raizlabs.android.dbflow.query.where -import com.raizlabs.android.dbflow.structure.BaseModel -import com.raizlabs.android.dbflow.structure.oneToMany +package com.raizlabs.dbflow5.dbflow.models + +import com.raizlabs.dbflow5.dbflow.TestDatabase +import com.raizlabs.dbflow5.annotation.OneToMany +import com.raizlabs.dbflow5.annotation.OneToManyMethod +import com.raizlabs.dbflow5.annotation.PrimaryKey +import com.raizlabs.dbflow5.annotation.Table +import com.raizlabs.dbflow5.config.databaseForTable +import com.raizlabs.dbflow5.database.DatabaseWrapper +import com.raizlabs.dbflow5.dbflow.models.TwoColumnModel_Table.id +import com.raizlabs.dbflow5.structure.BaseModel +import com.raizlabs.dbflow5.structure.oneToMany @Table(database = TestDatabase::class) class OneToManyModel(@PrimaryKey var name: String? = null) { diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ParentChildCachingTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/ParentChildCachingTest.kt similarity index 64% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ParentChildCachingTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/ParentChildCachingTest.kt index 9d42d50ec..bd47f0b14 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/ParentChildCachingTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/ParentChildCachingTest.kt @@ -1,12 +1,10 @@ -package com.raizlabs.android.dbflow.models +package com.raizlabs.dbflow5.dbflow.models -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.TestDatabase -import com.raizlabs.android.dbflow.config.database -import com.raizlabs.android.dbflow.query.result -import com.raizlabs.android.dbflow.query.select -import com.raizlabs.android.dbflow.structure.load -import com.raizlabs.android.dbflow.structure.save +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.dbflow.TestDatabase +import com.raizlabs.dbflow5.config.database +import com.raizlabs.dbflow5.structure.load +import com.raizlabs.dbflow5.structure.save import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/QueryModelTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/QueryModelTest.kt similarity index 59% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/QueryModelTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/QueryModelTest.kt index f88754735..a0000d829 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/QueryModelTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/QueryModelTest.kt @@ -1,16 +1,13 @@ -package com.raizlabs.android.dbflow.models +package com.raizlabs.dbflow5.dbflow.models -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.TestDatabase -import com.raizlabs.android.dbflow.config.database -import com.raizlabs.android.dbflow.models.Author_Table.id -import com.raizlabs.android.dbflow.models.Blog_Table.author_id -import com.raizlabs.android.dbflow.models.Blog_Table.name -import com.raizlabs.android.dbflow.query.innerJoin -import com.raizlabs.android.dbflow.query.on -import com.raizlabs.android.dbflow.query.select -import com.raizlabs.android.dbflow.structure.exists -import com.raizlabs.android.dbflow.structure.save +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.dbflow.TestDatabase +import com.raizlabs.dbflow5.config.database +import com.raizlabs.dbflow5.dbflow.models.Author_Table.id +import com.raizlabs.dbflow5.dbflow.models.Blog_Table.author_id +import com.raizlabs.dbflow5.dbflow.models.Blog_Table.name +import com.raizlabs.dbflow5.structure.exists +import com.raizlabs.dbflow5.structure.save import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/QueryModels.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/QueryModels.kt similarity index 64% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/QueryModels.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/QueryModels.kt index 8f963cbc6..a1dc0e94b 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/QueryModels.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/QueryModels.kt @@ -1,10 +1,10 @@ -package com.raizlabs.android.dbflow.models +package com.raizlabs.dbflow5.dbflow.models -import com.raizlabs.android.dbflow.TestDatabase -import com.raizlabs.android.dbflow.annotation.Column -import com.raizlabs.android.dbflow.annotation.QueryModel -import com.raizlabs.android.dbflow.converter.TypeConverter -import com.raizlabs.android.dbflow.data.Blob +import com.raizlabs.dbflow5.dbflow.TestDatabase +import com.raizlabs.dbflow5.annotation.Column +import com.raizlabs.dbflow5.annotation.QueryModel +import com.raizlabs.dbflow5.converter.TypeConverter +import com.raizlabs.dbflow5.data.Blob @QueryModel(database = TestDatabase::class, allFields = true) class AuthorNameQuery(var blogName: String = "", @@ -16,7 +16,7 @@ class CustomBlobModel(@Column var myBlob: MyBlob? = null) { class MyBlob(val blob: ByteArray) - @com.raizlabs.android.dbflow.annotation.TypeConverter + @com.raizlabs.dbflow5.dbflow.annotation.TypeConverter class MyTypeConverter : TypeConverter() { override fun getDBValue(model: MyBlob?) = model?.let { Blob(model.blob) } diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/SimpleTestModels.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/SimpleTestModels.kt similarity index 88% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/SimpleTestModels.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/SimpleTestModels.kt index c6b32e6e4..48a3613da 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/SimpleTestModels.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/SimpleTestModels.kt @@ -1,19 +1,19 @@ -package com.raizlabs.android.dbflow.models - -import com.raizlabs.android.dbflow.TestDatabase -import com.raizlabs.android.dbflow.annotation.Column -import com.raizlabs.android.dbflow.annotation.ColumnIgnore -import com.raizlabs.android.dbflow.annotation.ConflictAction -import com.raizlabs.android.dbflow.annotation.ForeignKey -import com.raizlabs.android.dbflow.annotation.ManyToMany -import com.raizlabs.android.dbflow.annotation.PrimaryKey -import com.raizlabs.android.dbflow.annotation.QueryModel -import com.raizlabs.android.dbflow.annotation.Table -import com.raizlabs.android.dbflow.converter.TypeConverter -import com.raizlabs.android.dbflow.data.Blob -import com.raizlabs.android.dbflow.database.DatabaseStatement -import com.raizlabs.android.dbflow.query.SQLiteStatementListener -import com.raizlabs.android.dbflow.structure.BaseModel +package com.raizlabs.dbflow5.dbflow.models + +import com.raizlabs.dbflow5.dbflow.TestDatabase +import com.raizlabs.dbflow5.annotation.Column +import com.raizlabs.dbflow5.annotation.ColumnIgnore +import com.raizlabs.dbflow5.annotation.ConflictAction +import com.raizlabs.dbflow5.annotation.ForeignKey +import com.raizlabs.dbflow5.annotation.ManyToMany +import com.raizlabs.dbflow5.annotation.PrimaryKey +import com.raizlabs.dbflow5.annotation.QueryModel +import com.raizlabs.dbflow5.annotation.Table +import com.raizlabs.dbflow5.converter.TypeConverter +import com.raizlabs.dbflow5.data.Blob +import com.raizlabs.dbflow5.database.DatabaseStatement +import com.raizlabs.dbflow5.query.SQLiteStatementListener +import com.raizlabs.dbflow5.structure.BaseModel import java.math.BigDecimal import java.math.BigInteger import java.util.* @@ -158,7 +158,7 @@ class CustomEnumTypeConverter : TypeConverter() { } -@com.raizlabs.android.dbflow.annotation.TypeConverter +@com.raizlabs.dbflow5.dbflow.annotation.TypeConverter class BlobConverter : TypeConverter() { override fun getDBValue(model: ByteArray?): Blob? { diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/Issue.java b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/issue/Issue.java similarity index 57% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/Issue.java rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/issue/Issue.java index 31c88aa66..716b1d0b9 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/Issue.java +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/issue/Issue.java @@ -1,16 +1,16 @@ -package com.raizlabs.android.dbflow.models.issue; +package com.raizlabs.dbflow5.dbflow.models.issue; -import com.raizlabs.android.dbflow.TestDatabase; -import com.raizlabs.android.dbflow.annotation.OneToMany; -import com.raizlabs.android.dbflow.annotation.OneToManyMethod; -import com.raizlabs.android.dbflow.annotation.PrimaryKey; -import com.raizlabs.android.dbflow.annotation.Table; -import com.raizlabs.android.dbflow.database.DatabaseWrapper; -import com.raizlabs.android.dbflow.structure.BaseModel; +import com.raizlabs.dbflow5.dbflow.TestDatabase; +import com.raizlabs.dbflow5.annotation.OneToMany; +import com.raizlabs.dbflow5.annotation.OneToManyMethod; +import com.raizlabs.dbflow5.annotation.PrimaryKey; +import com.raizlabs.dbflow5.annotation.Table; +import com.raizlabs.dbflow5.database.DatabaseWrapper; +import com.raizlabs.dbflow5.structure.BaseModel; import java.util.List; -import static com.raizlabs.android.dbflow.query.SQLite.select; +import static com.raizlabs.dbflow5.query.SQLite.select; /** * Description: diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/issue/Page.java b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/issue/Page.java new file mode 100644 index 000000000..904fffe2d --- /dev/null +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/issue/Page.java @@ -0,0 +1,25 @@ +package com.raizlabs.dbflow5.dbflow.models.issue; + +import com.raizlabs.dbflow5.dbflow.TestDatabase; +import com.raizlabs.dbflow5.annotation.Column; +import com.raizlabs.dbflow5.annotation.ForeignKey; +import com.raizlabs.dbflow5.annotation.PrimaryKey; +import com.raizlabs.dbflow5.annotation.Table; +import com.raizlabs.dbflow5.structure.BaseModel; + +/** + * Description: + */ +@Table(database = TestDatabase.class) +public class Page extends BaseModel { + + @PrimaryKey + @Column + String id; + + @PrimaryKey + String owningIssueId; + + @ForeignKey(stubbedRelationship = true) + SubIssue subIssue; +} diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/SubIssue.java b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/issue/SubIssue.java similarity index 61% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/SubIssue.java rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/issue/SubIssue.java index d5dedb7ed..a0c0ba83d 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/issue/SubIssue.java +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/issue/SubIssue.java @@ -1,17 +1,17 @@ -package com.raizlabs.android.dbflow.models.issue; +package com.raizlabs.dbflow5.dbflow.models.issue; -import com.raizlabs.android.dbflow.TestDatabase; -import com.raizlabs.android.dbflow.annotation.OneToMany; -import com.raizlabs.android.dbflow.annotation.OneToManyMethod; -import com.raizlabs.android.dbflow.annotation.PrimaryKey; -import com.raizlabs.android.dbflow.annotation.Table; -import com.raizlabs.android.dbflow.database.DatabaseWrapper; -import com.raizlabs.android.dbflow.structure.BaseModel; +import com.raizlabs.dbflow5.dbflow.TestDatabase; +import com.raizlabs.dbflow5.annotation.OneToMany; +import com.raizlabs.dbflow5.annotation.OneToManyMethod; +import com.raizlabs.dbflow5.annotation.PrimaryKey; +import com.raizlabs.dbflow5.annotation.Table; +import com.raizlabs.dbflow5.database.DatabaseWrapper; +import com.raizlabs.dbflow5.structure.BaseModel; import java.util.ArrayList; import java.util.List; -import static com.raizlabs.android.dbflow.query.SQLite.select; +import static com.raizlabs.dbflow5.query.SQLite.select; /** * Description: diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/java/DatabaseModel.java b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/java/DatabaseModel.java similarity index 56% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/java/DatabaseModel.java rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/java/DatabaseModel.java index 7589b96a8..de038aec8 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/models/java/DatabaseModel.java +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/java/DatabaseModel.java @@ -1,7 +1,7 @@ -package com.raizlabs.android.dbflow.models.java; +package com.raizlabs.dbflow5.dbflow.models.java; -import com.raizlabs.android.dbflow.annotation.PrimaryKey; -import com.raizlabs.android.dbflow.structure.BaseModel; +import com.raizlabs.dbflow5.annotation.PrimaryKey; +import com.raizlabs.dbflow5.structure.BaseModel; public class DatabaseModel extends BaseModel { @PrimaryKey diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/java/JavaModelView.java b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/java/JavaModelView.java new file mode 100644 index 000000000..24b486cee --- /dev/null +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/java/JavaModelView.java @@ -0,0 +1,26 @@ +package com.raizlabs.dbflow5.dbflow.models.java; + +import com.raizlabs.dbflow5.dbflow.TestDatabase; +import com.raizlabs.dbflow5.annotation.Column; +import com.raizlabs.dbflow5.annotation.ModelView; +import com.raizlabs.dbflow5.annotation.ModelViewQuery; +import com.raizlabs.dbflow5.database.DatabaseWrapper; +import com.raizlabs.dbflow5.dbflow.models.Author_Table; +import com.raizlabs.dbflow5.query.SQLite; +import com.raizlabs.dbflow5.sql.Query; + +@ModelView(database = TestDatabase.class) +public class JavaModelView { + + @ModelViewQuery + public static Query getQuery(DatabaseWrapper databaseWrapper) { + return SQLite.select(databaseWrapper, Author_Table.first_name.as("firstName"), Author_Table.id.as("id")); + } + + @Column + String id; + + @Column + Integer firstName; + +} diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/java/otherpackage/ExampleModel.java b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/java/otherpackage/ExampleModel.java new file mode 100644 index 000000000..7dc440f6b --- /dev/null +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/java/otherpackage/ExampleModel.java @@ -0,0 +1,12 @@ +package com.raizlabs.dbflow5.dbflow.models.java.otherpackage; + +import com.raizlabs.dbflow5.dbflow.TestDatabase; +import com.raizlabs.dbflow5.annotation.Column; +import com.raizlabs.dbflow5.annotation.Table; +import com.raizlabs.dbflow5.dbflow.models.java.DatabaseModel; + +@Table(database = TestDatabase.class) +public class ExampleModel extends DatabaseModel { + @Column + String name; +} diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/provider/ContentProviderObjects.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/provider/ContentProviderObjects.kt similarity index 79% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/provider/ContentProviderObjects.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/provider/ContentProviderObjects.kt index e1ba22958..6fac8533c 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/provider/ContentProviderObjects.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/provider/ContentProviderObjects.kt @@ -1,15 +1,18 @@ -package com.raizlabs.android.dbflow.provider - -import com.raizlabs.android.dbflow.annotation.Column -import com.raizlabs.android.dbflow.annotation.Database -import com.raizlabs.android.dbflow.annotation.ForeignKey -import com.raizlabs.android.dbflow.annotation.ForeignKeyReference -import com.raizlabs.android.dbflow.annotation.PrimaryKey -import com.raizlabs.android.dbflow.annotation.Table -import com.raizlabs.android.dbflow.annotation.provider.ContentProvider -import com.raizlabs.android.dbflow.annotation.provider.ContentType -import com.raizlabs.android.dbflow.annotation.provider.ContentUri -import com.raizlabs.android.dbflow.annotation.provider.TableEndpoint +package com.raizlabs.dbflow5.dbflow.provider + +import com.raizlabs.dbflow5.annotation.Column +import com.raizlabs.dbflow5.annotation.Database +import com.raizlabs.dbflow5.annotation.ForeignKey +import com.raizlabs.dbflow5.annotation.ForeignKeyReference +import com.raizlabs.dbflow5.annotation.PrimaryKey +import com.raizlabs.dbflow5.annotation.Table +import com.raizlabs.dbflow5.annotation.provider.ContentProvider +import com.raizlabs.dbflow5.annotation.provider.ContentType +import com.raizlabs.dbflow5.annotation.provider.ContentUri +import com.raizlabs.dbflow5.annotation.provider.TableEndpoint +import com.raizlabs.dbflow5.provider.BaseProviderModel +import com.raizlabs.dbflow5.provider.BaseSyncableProviderModel +import com.raizlabs.dbflow5.provider.ContentUtils /** diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/provider/ContentProviderTests.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/provider/ContentProviderTests.kt similarity index 86% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/provider/ContentProviderTests.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/provider/ContentProviderTests.kt index 11cf06006..15d554bf5 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/provider/ContentProviderTests.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/provider/ContentProviderTests.kt @@ -1,19 +1,17 @@ -package com.raizlabs.android.dbflow.provider +package com.raizlabs.dbflow5.dbflow.provider import android.content.ContentResolver import android.content.pm.ProviderInfo -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.config.database -import com.raizlabs.android.dbflow.query.Delete.Companion.table -import com.raizlabs.android.dbflow.query.Delete.Companion.tables -import com.raizlabs.android.dbflow.query.result -import com.raizlabs.android.dbflow.query.select -import com.raizlabs.android.dbflow.query.where -import com.raizlabs.android.dbflow.structure.delete -import com.raizlabs.android.dbflow.structure.exists -import com.raizlabs.android.dbflow.structure.insert -import com.raizlabs.android.dbflow.structure.save -import com.raizlabs.android.dbflow.structure.update +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.config.database +import com.raizlabs.dbflow5.query.Delete.Companion.table +import com.raizlabs.dbflow5.query.Delete.Companion.tables +import com.raizlabs.dbflow5.structure.delete +import com.raizlabs.dbflow5.structure.exists +import com.raizlabs.dbflow5.structure.insert +import com.raizlabs.dbflow5.structure.save +import com.raizlabs.dbflow5.structure.update +import com.raizlabs.dbflow5.provider.ContentUtils import org.junit.Assert.* import org.junit.Before import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/provider/RealContentProvider.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/provider/RealContentProvider.kt similarity index 79% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/provider/RealContentProvider.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/provider/RealContentProvider.kt index 07a0ba5af..19dba1947 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/provider/RealContentProvider.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/provider/RealContentProvider.kt @@ -1,13 +1,13 @@ -package com.raizlabs.android.dbflow.provider +package com.raizlabs.dbflow5.dbflow.provider import android.content.ContentProvider import android.content.ContentValues import android.database.Cursor import android.net.Uri -import com.raizlabs.android.dbflow.TestDatabase -import com.raizlabs.android.dbflow.config.FlowConfig -import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.dbflow5.dbflow.TestDatabase +import com.raizlabs.dbflow5.config.FlowConfig +import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.database.DatabaseWrapper class RealContentProvider : ContentProvider() { diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/provider/TestContentProvider.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/provider/TestContentProvider.kt similarity index 88% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/provider/TestContentProvider.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/provider/TestContentProvider.kt index a2c5df700..3a898e696 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/provider/TestContentProvider.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/provider/TestContentProvider.kt @@ -1,22 +1,22 @@ -package com.raizlabs.android.dbflow.provider +package com.raizlabs.dbflow5.dbflow.provider import android.content.ContentValues import android.content.Context import android.net.Uri -import com.raizlabs.android.dbflow.annotation.provider.ContentProvider -import com.raizlabs.android.dbflow.annotation.provider.ContentType -import com.raizlabs.android.dbflow.annotation.provider.ContentUri -import com.raizlabs.android.dbflow.annotation.provider.Notify -import com.raizlabs.android.dbflow.annotation.provider.NotifyMethod -import com.raizlabs.android.dbflow.annotation.provider.PathSegment -import com.raizlabs.android.dbflow.annotation.provider.TableEndpoint -import com.raizlabs.android.dbflow.getContentValuesKey +import com.raizlabs.dbflow5.annotation.provider.ContentProvider +import com.raizlabs.dbflow5.annotation.provider.ContentType +import com.raizlabs.dbflow5.annotation.provider.ContentUri +import com.raizlabs.dbflow5.annotation.provider.Notify +import com.raizlabs.dbflow5.annotation.provider.NotifyMethod +import com.raizlabs.dbflow5.annotation.provider.PathSegment +import com.raizlabs.dbflow5.annotation.provider.TableEndpoint +import com.raizlabs.dbflow5.getContentValuesKey @ContentProvider(authority = TestContentProvider.AUTHORITY, database = ContentDatabase::class, baseContentUri = TestContentProvider.BASE_CONTENT_URI) object TestContentProvider { - const val AUTHORITY = "com.raizlabs.android.dbflow.test.provider" + const val AUTHORITY = "com.raizlabs.dbflow5.dbflow.test.provider" const val BASE_CONTENT_URI = "content://" diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/query/cache/ModelLruCacheTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/query/cache/ModelLruCacheTest.kt similarity index 77% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/query/cache/ModelLruCacheTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/query/cache/ModelLruCacheTest.kt index cc80d78da..49dd26fa2 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/query/cache/ModelLruCacheTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/query/cache/ModelLruCacheTest.kt @@ -1,7 +1,8 @@ -package com.raizlabs.android.dbflow.query.cache +package com.raizlabs.dbflow5.dbflow.query.cache -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.models.NumberModel +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.dbflow.models.NumberModel +import com.raizlabs.dbflow5.query.cache.SimpleMapCache import org.junit.Assert import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/query/cache/SimpleMapCacheTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/query/cache/SimpleMapCacheTest.kt similarity index 78% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/query/cache/SimpleMapCacheTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/query/cache/SimpleMapCacheTest.kt index e17e2805e..d8f639d45 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/query/cache/SimpleMapCacheTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/query/cache/SimpleMapCacheTest.kt @@ -1,7 +1,8 @@ -package com.raizlabs.android.dbflow.query.cache +package com.raizlabs.dbflow5.dbflow.query.cache -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.query.cache.SimpleMapCache import org.junit.Assert.assertEquals import org.junit.Assert.assertTrue import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/query/list/FlowCursorIteratorTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/query/list/FlowCursorIteratorTest.kt similarity index 81% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/query/list/FlowCursorIteratorTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/query/list/FlowCursorIteratorTest.kt index 9d5abafa2..0c9616673 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/query/list/FlowCursorIteratorTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/query/list/FlowCursorIteratorTest.kt @@ -1,10 +1,9 @@ -package com.raizlabs.android.dbflow.query.list +package com.raizlabs.dbflow5.dbflow.query.list -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.config.databaseForTable -import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.query.select -import com.raizlabs.android.dbflow.structure.save +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.config.databaseForTable +import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.structure.save import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/query/list/FlowCursorListTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/query/list/FlowCursorListTest.kt similarity index 85% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/query/list/FlowCursorListTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/query/list/FlowCursorListTest.kt index ee5ebd3fc..cc029265c 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/query/list/FlowCursorListTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/query/list/FlowCursorListTest.kt @@ -1,14 +1,13 @@ -package com.raizlabs.android.dbflow.query.list +package com.raizlabs.dbflow5.dbflow.query.list import com.nhaarman.mockito_kotlin.mock import com.nhaarman.mockito_kotlin.times import com.nhaarman.mockito_kotlin.verify -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.config.databaseForTable -import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.query.cursor -import com.raizlabs.android.dbflow.query.select -import com.raizlabs.android.dbflow.structure.save +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.config.databaseForTable +import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.structure.save +import com.raizlabs.dbflow5.query.list.FlowCursorList import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/runtime/DirectNotifierTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/runtime/DirectNotifierTest.kt similarity index 71% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/runtime/DirectNotifierTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/runtime/DirectNotifierTest.kt index ac155e05a..a1c436034 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/runtime/DirectNotifierTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/runtime/DirectNotifierTest.kt @@ -1,27 +1,29 @@ -package com.raizlabs.android.dbflow.runtime +package com.raizlabs.dbflow5.dbflow.runtime import android.content.Context import com.nhaarman.mockito_kotlin.mock import com.nhaarman.mockito_kotlin.times import com.nhaarman.mockito_kotlin.verify -import com.raizlabs.android.dbflow.ImmediateTransactionManager2 -import com.raizlabs.android.dbflow.TestDatabase -import com.raizlabs.android.dbflow.config.DatabaseConfig -import com.raizlabs.android.dbflow.config.FlowConfig -import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.config.databaseForTable -import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.models.SimpleModel_Table -import com.raizlabs.android.dbflow.query.columnValues -import com.raizlabs.android.dbflow.query.delete -import com.raizlabs.android.dbflow.query.insert -import com.raizlabs.android.dbflow.query.set -import com.raizlabs.android.dbflow.query.update -import com.raizlabs.android.dbflow.structure.ChangeAction -import com.raizlabs.android.dbflow.structure.delete -import com.raizlabs.android.dbflow.structure.insert -import com.raizlabs.android.dbflow.structure.save -import com.raizlabs.android.dbflow.structure.update +import com.raizlabs.dbflow5.dbflow.ImmediateTransactionManager2 +import com.raizlabs.dbflow5.dbflow.TestDatabase +import com.raizlabs.dbflow5.config.DatabaseConfig +import com.raizlabs.dbflow5.config.FlowConfig +import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.config.databaseForTable +import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.dbflow.models.SimpleModel_Table +import com.raizlabs.dbflow5.query.columnValues +import com.raizlabs.dbflow5.query.delete +import com.raizlabs.dbflow5.query.insert +import com.raizlabs.dbflow5.query.set +import com.raizlabs.dbflow5.query.update +import com.raizlabs.dbflow5.structure.ChangeAction +import com.raizlabs.dbflow5.structure.delete +import com.raizlabs.dbflow5.structure.insert +import com.raizlabs.dbflow5.structure.save +import com.raizlabs.dbflow5.structure.update +import com.raizlabs.dbflow5.runtime.DirectModelNotifier +import com.raizlabs.dbflow5.runtime.OnTableChangedListener import org.junit.After import org.junit.Before import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CaseTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/CaseTest.kt similarity index 74% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CaseTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/CaseTest.kt index bf228591f..31925f2d8 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CaseTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/CaseTest.kt @@ -1,10 +1,10 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.dbflow5.dbflow.sql.language -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.models.SimpleModel_Table -import com.raizlabs.android.dbflow.query.case -import com.raizlabs.android.dbflow.query.caseWhen -import com.raizlabs.android.dbflow.query.property.propertyString +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.dbflow.models.SimpleModel_Table +import com.raizlabs.dbflow5.dbflow.query.case +import com.raizlabs.dbflow5.query.caseWhen +import com.raizlabs.dbflow5.query.property.propertyString import org.junit.Assert.* import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CursorResultTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/CursorResultTest.kt similarity index 81% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CursorResultTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/CursorResultTest.kt index f69177d7e..9b1961ab7 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/CursorResultTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/CursorResultTest.kt @@ -1,18 +1,16 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.dbflow5.dbflow.sql.language import android.database.StaleDataException -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.config.databaseForTable -import com.raizlabs.android.dbflow.models.SimpleCustomModel -import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.query.CursorResult -import com.raizlabs.android.dbflow.query.cursorResult -import com.raizlabs.android.dbflow.query.select -import com.raizlabs.android.dbflow.query.toCustomList -import com.raizlabs.android.dbflow.query.toCustomListClose -import com.raizlabs.android.dbflow.query.toCustomModel -import com.raizlabs.android.dbflow.query.toCustomModelClose -import com.raizlabs.android.dbflow.structure.save +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.config.databaseForTable +import com.raizlabs.dbflow5.dbflow.models.SimpleCustomModel +import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.query.CursorResult +import com.raizlabs.dbflow5.query.toCustomList +import com.raizlabs.dbflow5.query.toCustomListClose +import com.raizlabs.dbflow5.query.toCustomModel +import com.raizlabs.dbflow5.query.toCustomModelClose +import com.raizlabs.dbflow5.structure.save import org.junit.Assert.* import org.junit.Before import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/DeleteTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/DeleteTest.kt similarity index 68% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/DeleteTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/DeleteTest.kt index 5624f94e6..9118df0d4 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/DeleteTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/DeleteTest.kt @@ -1,13 +1,11 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.dbflow5.dbflow.sql.language -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.config.databaseForTable -import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.models.SimpleModel_Table -import com.raizlabs.android.dbflow.query.delete -import com.raizlabs.android.dbflow.query.list -import com.raizlabs.android.dbflow.query.select -import com.raizlabs.android.dbflow.structure.save +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.config.databaseForTable +import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.dbflow.models.SimpleModel_Table +import com.raizlabs.dbflow5.query.delete +import com.raizlabs.dbflow5.structure.save import org.junit.Assert.assertEquals import org.junit.Assert.assertFalse import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/ExistenceOperatorTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/ExistenceOperatorTest.kt similarity index 54% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/ExistenceOperatorTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/ExistenceOperatorTest.kt index 8ba168777..dd4d3f450 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/ExistenceOperatorTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/ExistenceOperatorTest.kt @@ -1,12 +1,10 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.dbflow5.dbflow.sql.language -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.config.databaseForTable -import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.models.SimpleModel_Table -import com.raizlabs.android.dbflow.query.ExistenceOperator -import com.raizlabs.android.dbflow.query.select -import com.raizlabs.android.dbflow.query.where +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.config.databaseForTable +import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.dbflow.models.SimpleModel_Table +import com.raizlabs.dbflow5.query.ExistenceOperator import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/FromTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/FromTest.kt similarity index 71% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/FromTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/FromTest.kt index b76156e88..1fb136904 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/FromTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/FromTest.kt @@ -1,15 +1,12 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.dbflow5.dbflow.sql.language -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.config.databaseForTable -import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.models.SimpleModel_Table.name -import com.raizlabs.android.dbflow.models.TwoColumnModel -import com.raizlabs.android.dbflow.models.TwoColumnModel_Table -import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id -import com.raizlabs.android.dbflow.query.innerJoin -import com.raizlabs.android.dbflow.query.on -import com.raizlabs.android.dbflow.query.select +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.config.databaseForTable +import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.dbflow.models.SimpleModel_Table.name +import com.raizlabs.dbflow5.dbflow.models.TwoColumnModel +import com.raizlabs.dbflow5.dbflow.models.TwoColumnModel_Table +import com.raizlabs.dbflow5.dbflow.models.TwoColumnModel_Table.id import org.junit.Assert.assertEquals import org.junit.Assert.assertTrue import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/IndexTest.kt similarity index 73% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/IndexTest.kt index 80e6865b2..3c93ec15f 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/IndexTest.kt @@ -1,11 +1,11 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.dbflow5.dbflow.sql.language -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.config.databaseForTable -import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.models.SimpleModel_Table -import com.raizlabs.android.dbflow.query.indexOn -import com.raizlabs.android.dbflow.query.nameAlias +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.config.databaseForTable +import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.dbflow.models.SimpleModel_Table +import com.raizlabs.dbflow5.query.indexOn +import com.raizlabs.dbflow5.query.nameAlias import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexedByTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/IndexedByTest.kt similarity index 54% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexedByTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/IndexedByTest.kt index 0e03d1f1d..55e981737 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/IndexedByTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/IndexedByTest.kt @@ -1,11 +1,10 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.dbflow5.dbflow.sql.language -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.config.databaseForTable -import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.models.SimpleModel_Table -import com.raizlabs.android.dbflow.query.property.IndexProperty -import com.raizlabs.android.dbflow.query.select +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.config.databaseForTable +import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.dbflow.models.SimpleModel_Table +import com.raizlabs.dbflow5.query.property.IndexProperty import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/InsertTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/InsertTest.kt similarity index 84% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/InsertTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/InsertTest.kt index d24bb5faa..0a2e5f725 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/InsertTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/InsertTest.kt @@ -1,18 +1,17 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.dbflow5.dbflow.sql.language import android.content.ContentValues -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.config.databaseForTable -import com.raizlabs.android.dbflow.database.set -import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.models.TwoColumnModel -import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id -import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.name -import com.raizlabs.android.dbflow.query.NameAlias -import com.raizlabs.android.dbflow.query.Operator -import com.raizlabs.android.dbflow.query.OperatorGroup -import com.raizlabs.android.dbflow.query.insert -import com.raizlabs.android.dbflow.query.select +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.config.databaseForTable +import com.raizlabs.dbflow5.database.set +import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.dbflow.models.TwoColumnModel +import com.raizlabs.dbflow5.dbflow.models.TwoColumnModel_Table.id +import com.raizlabs.dbflow5.dbflow.models.TwoColumnModel_Table.name +import com.raizlabs.dbflow5.query.NameAlias +import com.raizlabs.dbflow5.query.Operator +import com.raizlabs.dbflow5.query.OperatorGroup +import com.raizlabs.dbflow5.query.insert import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/JoinTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/JoinTest.kt similarity index 81% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/JoinTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/JoinTest.kt index dad9cc512..674e498e6 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/JoinTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/JoinTest.kt @@ -1,18 +1,11 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.dbflow5.dbflow.sql.language -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.config.databaseForTable -import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.models.SimpleModel_Table -import com.raizlabs.android.dbflow.models.TwoColumnModel -import com.raizlabs.android.dbflow.models.TwoColumnModel_Table -import com.raizlabs.android.dbflow.query.crossJoin -import com.raizlabs.android.dbflow.query.innerJoin -import com.raizlabs.android.dbflow.query.leftOuterJoin -import com.raizlabs.android.dbflow.query.naturalJoin -import com.raizlabs.android.dbflow.query.on -import com.raizlabs.android.dbflow.query.select -import com.raizlabs.android.dbflow.query.using +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.config.databaseForTable +import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.dbflow.models.SimpleModel_Table +import com.raizlabs.dbflow5.dbflow.models.TwoColumnModel +import com.raizlabs.dbflow5.dbflow.models.TwoColumnModel_Table import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/MethodTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/MethodTest.kt similarity index 68% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/MethodTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/MethodTest.kt index 9d15f554e..712d0915e 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/MethodTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/MethodTest.kt @@ -1,23 +1,23 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.dbflow5.dbflow.sql.language -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id -import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.name -import com.raizlabs.android.dbflow.query.avg -import com.raizlabs.android.dbflow.query.cast -import com.raizlabs.android.dbflow.query.count -import com.raizlabs.android.dbflow.query.date -import com.raizlabs.android.dbflow.query.datetime -import com.raizlabs.android.dbflow.query.group_concat -import com.raizlabs.android.dbflow.query.ifNull -import com.raizlabs.android.dbflow.query.max -import com.raizlabs.android.dbflow.query.min -import com.raizlabs.android.dbflow.query.nullIf -import com.raizlabs.android.dbflow.query.replace -import com.raizlabs.android.dbflow.query.strftime -import com.raizlabs.android.dbflow.query.sum -import com.raizlabs.android.dbflow.query.total -import com.raizlabs.android.dbflow.sql.SQLiteType +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.dbflow.models.TwoColumnModel_Table.id +import com.raizlabs.dbflow5.dbflow.models.TwoColumnModel_Table.name +import com.raizlabs.dbflow5.query.avg +import com.raizlabs.dbflow5.query.cast +import com.raizlabs.dbflow5.query.count +import com.raizlabs.dbflow5.query.date +import com.raizlabs.dbflow5.query.datetime +import com.raizlabs.dbflow5.query.group_concat +import com.raizlabs.dbflow5.query.ifNull +import com.raizlabs.dbflow5.query.max +import com.raizlabs.dbflow5.query.min +import com.raizlabs.dbflow5.query.nullIf +import com.raizlabs.dbflow5.query.replace +import com.raizlabs.dbflow5.query.strftime +import com.raizlabs.dbflow5.query.sum +import com.raizlabs.dbflow5.query.total +import com.raizlabs.dbflow5.sql.SQLiteType import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/NameAliasTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/NameAliasTest.kt similarity index 83% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/NameAliasTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/NameAliasTest.kt index 91ba1bbf7..55e454a09 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/NameAliasTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/NameAliasTest.kt @@ -1,9 +1,9 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.dbflow5.dbflow.sql.language -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.query.NameAlias -import com.raizlabs.android.dbflow.query.`as` -import com.raizlabs.android.dbflow.query.nameAlias +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.query.NameAlias +import com.raizlabs.dbflow5.query.`as` +import com.raizlabs.dbflow5.query.nameAlias import org.junit.Assert.assertEquals import org.junit.Assert.assertFalse import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OperatorGroupTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/OperatorGroupTest.kt similarity index 68% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OperatorGroupTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/OperatorGroupTest.kt index 8ca50a33b..67a7f62f0 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OperatorGroupTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/OperatorGroupTest.kt @@ -1,14 +1,14 @@ -package com.raizlabs.android.dbflow.sql.language - -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.assertEquals -import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id -import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.name -import com.raizlabs.android.dbflow.query.OperatorGroup -import com.raizlabs.android.dbflow.query.and -import com.raizlabs.android.dbflow.query.andAll -import com.raizlabs.android.dbflow.query.or -import com.raizlabs.android.dbflow.query.orAll +package com.raizlabs.dbflow5.dbflow.sql.language + +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.dbflow.assertEquals +import com.raizlabs.dbflow5.dbflow.models.TwoColumnModel_Table.id +import com.raizlabs.dbflow5.dbflow.models.TwoColumnModel_Table.name +import com.raizlabs.dbflow5.query.OperatorGroup +import com.raizlabs.dbflow5.query.and +import com.raizlabs.dbflow5.query.andAll +import com.raizlabs.dbflow5.query.or +import com.raizlabs.dbflow5.query.orAll import org.junit.Test class OperatorGroupTest : BaseUnitTest() { diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OperatorTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/OperatorTest.kt similarity index 78% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OperatorTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/OperatorTest.kt index 6f1264044..40e866bed 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OperatorTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/OperatorTest.kt @@ -1,15 +1,12 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.dbflow5.dbflow.sql.language -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.annotation.Collate -import com.raizlabs.android.dbflow.assertEquals -import com.raizlabs.android.dbflow.config.databaseForTable -import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id -import com.raizlabs.android.dbflow.query.and -import com.raizlabs.android.dbflow.query.collate -import com.raizlabs.android.dbflow.query.op -import com.raizlabs.android.dbflow.query.select +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.annotation.Collate +import com.raizlabs.dbflow5.dbflow.assertEquals +import com.raizlabs.dbflow5.config.databaseForTable +import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.dbflow.models.TwoColumnModel_Table.id +import com.raizlabs.dbflow5.query.op import org.junit.Test class OperatorTest : BaseUnitTest() { diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OrderByTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/OrderByTest.kt similarity index 60% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OrderByTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/OrderByTest.kt index 5583fbc25..36e222db7 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/OrderByTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/OrderByTest.kt @@ -1,12 +1,12 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.dbflow5.dbflow.sql.language -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.annotation.Collate -import com.raizlabs.android.dbflow.assertEquals -import com.raizlabs.android.dbflow.models.SimpleModel_Table.name -import com.raizlabs.android.dbflow.query.OrderBy -import com.raizlabs.android.dbflow.query.collate -import com.raizlabs.android.dbflow.query.nameAlias +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.annotation.Collate +import com.raizlabs.dbflow5.dbflow.assertEquals +import com.raizlabs.dbflow5.dbflow.models.SimpleModel_Table.name +import com.raizlabs.dbflow5.query.OrderBy +import com.raizlabs.dbflow5.query.collate +import com.raizlabs.dbflow5.query.nameAlias import org.junit.Test class OrderByTest : BaseUnitTest() { diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/SelectTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/SelectTest.kt similarity index 52% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/SelectTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/SelectTest.kt index dbf318525..b5eae64e2 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/SelectTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/SelectTest.kt @@ -1,13 +1,12 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.dbflow5.dbflow.sql.language -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.assertEquals -import com.raizlabs.android.dbflow.config.databaseForTable -import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.models.TwoColumnModel -import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id -import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.name -import com.raizlabs.android.dbflow.query.select +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.dbflow.assertEquals +import com.raizlabs.dbflow5.config.databaseForTable +import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.dbflow.models.TwoColumnModel +import com.raizlabs.dbflow5.dbflow.models.TwoColumnModel_Table.id +import com.raizlabs.dbflow5.dbflow.models.TwoColumnModel_Table.name import org.junit.Test class SelectTest : BaseUnitTest() { diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/SetTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/SetTest.kt similarity index 53% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/SetTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/SetTest.kt index daa73a763..ea8f0d0a7 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/SetTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/SetTest.kt @@ -1,13 +1,13 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.dbflow5.dbflow.sql.language -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.assertEquals -import com.raizlabs.android.dbflow.config.databaseForTable -import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.models.SimpleModel_Table.name -import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id -import com.raizlabs.android.dbflow.query.set -import com.raizlabs.android.dbflow.query.update +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.dbflow.assertEquals +import com.raizlabs.dbflow5.config.databaseForTable +import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.dbflow.models.SimpleModel_Table.name +import com.raizlabs.dbflow5.dbflow.models.TwoColumnModel_Table.id +import com.raizlabs.dbflow5.query.set +import com.raizlabs.dbflow5.query.update import org.junit.Test class SetTest : BaseUnitTest() { diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/TriggerTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/TriggerTest.kt similarity index 64% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/TriggerTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/TriggerTest.kt index c8c09d7ab..e30f3aa6e 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/TriggerTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/TriggerTest.kt @@ -1,26 +1,23 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.dbflow5.dbflow.sql.language -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.assertEquals -import com.raizlabs.android.dbflow.config.databaseForTable -import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.models.SimpleModel_Table.name -import com.raizlabs.android.dbflow.models.TwoColumnModel -import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id -import com.raizlabs.android.dbflow.query.NameAlias -import com.raizlabs.android.dbflow.query.and -import com.raizlabs.android.dbflow.query.begin -import com.raizlabs.android.dbflow.query.cast -import com.raizlabs.android.dbflow.query.columnValues -import com.raizlabs.android.dbflow.query.createTrigger -import com.raizlabs.android.dbflow.query.insert -import com.raizlabs.android.dbflow.query.insertOn -import com.raizlabs.android.dbflow.query.property.property -import com.raizlabs.android.dbflow.query.select -import com.raizlabs.android.dbflow.query.updateOn -import com.raizlabs.android.dbflow.query.where -import com.raizlabs.android.dbflow.sql.SQLiteType -import com.raizlabs.android.dbflow.structure.insert +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.dbflow.assertEquals +import com.raizlabs.dbflow5.config.databaseForTable +import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.dbflow.models.SimpleModel_Table.name +import com.raizlabs.dbflow5.dbflow.models.TwoColumnModel +import com.raizlabs.dbflow5.dbflow.models.TwoColumnModel_Table.id +import com.raizlabs.dbflow5.query.NameAlias +import com.raizlabs.dbflow5.query.begin +import com.raizlabs.dbflow5.query.cast +import com.raizlabs.dbflow5.query.columnValues +import com.raizlabs.dbflow5.query.createTrigger +import com.raizlabs.dbflow5.query.insert +import com.raizlabs.dbflow5.query.insertOn +import com.raizlabs.dbflow5.query.property.property +import com.raizlabs.dbflow5.query.updateOn +import com.raizlabs.dbflow5.sql.SQLiteType +import com.raizlabs.dbflow5.structure.insert import org.junit.Assert.assertNotNull import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UnsafeStringOperatorTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/UnsafeStringOperatorTest.kt similarity index 55% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UnsafeStringOperatorTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/UnsafeStringOperatorTest.kt index ac9d267a3..c3de27dd3 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UnsafeStringOperatorTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/UnsafeStringOperatorTest.kt @@ -1,12 +1,10 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.dbflow5.dbflow.sql.language -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.assertEquals -import com.raizlabs.android.dbflow.config.databaseForTable -import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.query.UnSafeStringOperator -import com.raizlabs.android.dbflow.query.select -import com.raizlabs.android.dbflow.query.where +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.dbflow.assertEquals +import com.raizlabs.dbflow5.config.databaseForTable +import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.query.UnSafeStringOperator import org.junit.Test class UnsafeStringOperatorTest : BaseUnitTest() { diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UpdateTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/UpdateTest.kt similarity index 71% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UpdateTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/UpdateTest.kt index ef91e8ee7..154f9a9bb 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/UpdateTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/UpdateTest.kt @@ -1,16 +1,16 @@ -package com.raizlabs.android.dbflow.sql.language +package com.raizlabs.dbflow5.dbflow.sql.language -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.annotation.ConflictAction -import com.raizlabs.android.dbflow.assertEquals -import com.raizlabs.android.dbflow.config.databaseForTable -import com.raizlabs.android.dbflow.models.NumberModel -import com.raizlabs.android.dbflow.models.NumberModel_Table.id -import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.models.SimpleModel_Table.name -import com.raizlabs.android.dbflow.query.property.Property -import com.raizlabs.android.dbflow.query.set -import com.raizlabs.android.dbflow.query.update +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.annotation.ConflictAction +import com.raizlabs.dbflow5.dbflow.assertEquals +import com.raizlabs.dbflow5.config.databaseForTable +import com.raizlabs.dbflow5.dbflow.models.NumberModel +import com.raizlabs.dbflow5.dbflow.models.NumberModel_Table.id +import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.dbflow.models.SimpleModel_Table.name +import com.raizlabs.dbflow5.query.property.Property +import com.raizlabs.dbflow5.query.set +import com.raizlabs.dbflow5.query.update import org.junit.Test class UpdateTest : BaseUnitTest() { diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/WhereTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/WhereTest.kt similarity index 84% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/WhereTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/WhereTest.kt index 7a1b0e60f..2cdd0063b 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/WhereTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/WhereTest.kt @@ -1,22 +1,18 @@ -package com.raizlabs.android.dbflow.sql.language - -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.assertEquals -import com.raizlabs.android.dbflow.config.databaseForTable -import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.models.SimpleModel_Table.name -import com.raizlabs.android.dbflow.models.TwoColumnModel -import com.raizlabs.android.dbflow.models.TwoColumnModel_Table.id -import com.raizlabs.android.dbflow.query.OrderBy.Companion.fromNameAlias -import com.raizlabs.android.dbflow.query.groupBy -import com.raizlabs.android.dbflow.query.having -import com.raizlabs.android.dbflow.query.list -import com.raizlabs.android.dbflow.query.nameAlias -import com.raizlabs.android.dbflow.query.or -import com.raizlabs.android.dbflow.query.result -import com.raizlabs.android.dbflow.query.select -import com.raizlabs.android.dbflow.query.update -import com.raizlabs.android.dbflow.query.where +package com.raizlabs.dbflow5.dbflow.sql.language + +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.dbflow.assertEquals +import com.raizlabs.dbflow5.config.databaseForTable +import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.dbflow.models.SimpleModel_Table.name +import com.raizlabs.dbflow5.dbflow.models.TwoColumnModel +import com.raizlabs.dbflow5.dbflow.models.TwoColumnModel_Table.id +import com.raizlabs.dbflow5.query.OrderBy.Companion.fromNameAlias +import com.raizlabs.dbflow5.query.list +import com.raizlabs.dbflow5.query.nameAlias +import com.raizlabs.dbflow5.query.or +import com.raizlabs.dbflow5.query.result +import com.raizlabs.dbflow5.query.update import org.junit.Assert.fail import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/BytePropertyTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/BytePropertyTest.kt similarity index 85% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/BytePropertyTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/BytePropertyTest.kt index b7c911e5b..f5581ea3d 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/BytePropertyTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/BytePropertyTest.kt @@ -1,9 +1,9 @@ -package com.raizlabs.android.dbflow.sql.language.property +package com.raizlabs.dbflow5.dbflow.sql.language.property -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.query.NameAlias -import com.raizlabs.android.dbflow.query.property.Property +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.query.NameAlias +import com.raizlabs.dbflow5.query.property.Property import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/CharPropertyTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/CharPropertyTest.kt similarity index 86% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/CharPropertyTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/CharPropertyTest.kt index 4c813a37a..a059d1815 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/CharPropertyTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/CharPropertyTest.kt @@ -1,9 +1,9 @@ -package com.raizlabs.android.dbflow.sql.language.property +package com.raizlabs.dbflow5.dbflow.sql.language.property -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.query.NameAlias -import com.raizlabs.android.dbflow.query.property.Property +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.query.NameAlias +import com.raizlabs.dbflow5.query.property.Property import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/DoublePropertyTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/DoublePropertyTest.kt similarity index 86% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/DoublePropertyTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/DoublePropertyTest.kt index dbb76279d..f0cef9c4b 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/DoublePropertyTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/DoublePropertyTest.kt @@ -1,9 +1,9 @@ -package com.raizlabs.android.dbflow.sql.language.property +package com.raizlabs.dbflow5.dbflow.sql.language.property -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.query.NameAlias -import com.raizlabs.android.dbflow.query.property.Property +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.query.NameAlias +import com.raizlabs.dbflow5.query.property.Property import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/FloatPropertyTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/FloatPropertyTest.kt similarity index 85% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/FloatPropertyTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/FloatPropertyTest.kt index 1d58b731f..66dc7d9ae 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/FloatPropertyTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/FloatPropertyTest.kt @@ -1,9 +1,9 @@ -package com.raizlabs.android.dbflow.sql.language.property +package com.raizlabs.dbflow5.dbflow.sql.language.property -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.query.NameAlias -import com.raizlabs.android.dbflow.query.property.Property +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.query.NameAlias +import com.raizlabs.dbflow5.query.property.Property import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/IndexPropertyTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/IndexPropertyTest.kt similarity index 56% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/IndexPropertyTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/IndexPropertyTest.kt index 2948a7fe3..35be3248b 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/IndexPropertyTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/IndexPropertyTest.kt @@ -1,10 +1,10 @@ -package com.raizlabs.android.dbflow.sql.language.property +package com.raizlabs.dbflow5.dbflow.sql.language.property -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.config.databaseForTable -import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.models.SimpleModel_Table -import com.raizlabs.android.dbflow.query.property.IndexProperty +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.config.databaseForTable +import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.dbflow.models.SimpleModel_Table +import com.raizlabs.dbflow5.query.property.IndexProperty import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/IntPropertyTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/IntPropertyTest.kt similarity index 85% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/IntPropertyTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/IntPropertyTest.kt index 0836933eb..22dcfdcc1 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/IntPropertyTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/IntPropertyTest.kt @@ -1,9 +1,9 @@ -package com.raizlabs.android.dbflow.sql.language.property +package com.raizlabs.dbflow5.dbflow.sql.language.property -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.query.NameAlias -import com.raizlabs.android.dbflow.query.property.Property +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.query.NameAlias +import com.raizlabs.dbflow5.query.property.Property import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/LongPropertyTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/LongPropertyTest.kt similarity index 85% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/LongPropertyTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/LongPropertyTest.kt index d2ceee099..74b333369 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/LongPropertyTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/LongPropertyTest.kt @@ -1,9 +1,9 @@ -package com.raizlabs.android.dbflow.sql.language.property +package com.raizlabs.dbflow5.dbflow.sql.language.property -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.query.NameAlias -import com.raizlabs.android.dbflow.query.property.Property +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.query.NameAlias +import com.raizlabs.dbflow5.query.property.Property import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/PropertyFactoryTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/PropertyFactoryTest.kt similarity index 67% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/PropertyFactoryTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/PropertyFactoryTest.kt index 6745c921c..61f3823e6 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/PropertyFactoryTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/PropertyFactoryTest.kt @@ -1,11 +1,10 @@ -package com.raizlabs.android.dbflow.sql.language.property +package com.raizlabs.dbflow5.dbflow.sql.language.property -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.config.databaseForTable -import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.query.property.property -import com.raizlabs.android.dbflow.query.property.propertyString -import com.raizlabs.android.dbflow.query.select +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.config.databaseForTable +import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.query.property.property +import com.raizlabs.dbflow5.query.property.propertyString import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/PropertyTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/PropertyTest.kt similarity index 88% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/PropertyTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/PropertyTest.kt index 1d2787831..b30e903ba 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/PropertyTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/PropertyTest.kt @@ -1,9 +1,9 @@ -package com.raizlabs.android.dbflow.sql.language.property +package com.raizlabs.dbflow5.dbflow.sql.language.property -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.query.NameAlias -import com.raizlabs.android.dbflow.query.property.Property +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.query.NameAlias +import com.raizlabs.dbflow5.query.property.Property import org.junit.Assert import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/ShortPropertyTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/ShortPropertyTest.kt similarity index 85% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/ShortPropertyTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/ShortPropertyTest.kt index 048399566..226acc41a 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/ShortPropertyTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/ShortPropertyTest.kt @@ -1,9 +1,9 @@ -package com.raizlabs.android.dbflow.sql.language.property +package com.raizlabs.dbflow5.dbflow.sql.language.property -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.query.NameAlias -import com.raizlabs.android.dbflow.query.property.Property +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.query.NameAlias +import com.raizlabs.dbflow5.query.property.Property import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/TypeConvertedPropertyTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/TypeConvertedPropertyTest.kt similarity index 71% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/TypeConvertedPropertyTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/TypeConvertedPropertyTest.kt index 64183f69c..68d6f6077 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/sql/language/property/TypeConvertedPropertyTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/TypeConvertedPropertyTest.kt @@ -1,13 +1,13 @@ -package com.raizlabs.android.dbflow.sql.language.property - -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.converter.DateConverter -import com.raizlabs.android.dbflow.converter.TypeConverter -import com.raizlabs.android.dbflow.models.Difficulty -import com.raizlabs.android.dbflow.models.EnumTypeConverterModel_Table -import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.query.NameAlias -import com.raizlabs.android.dbflow.query.property.TypeConvertedProperty +package com.raizlabs.dbflow5.dbflow.sql.language.property + +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.converter.DateConverter +import com.raizlabs.dbflow5.converter.TypeConverter +import com.raizlabs.dbflow5.dbflow.models.Difficulty +import com.raizlabs.dbflow5.dbflow.models.EnumTypeConverterModel_Table +import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.query.NameAlias +import com.raizlabs.dbflow5.query.property.TypeConvertedProperty import org.junit.Assert.assertEquals import org.junit.Test import java.util.* diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/query/CursorResultSubscriberTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/rx/query/CursorResultSubscriberTest.kt similarity index 66% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/query/CursorResultSubscriberTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/rx/query/CursorResultSubscriberTest.kt index cc3468e5d..2b8b34713 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/query/CursorResultSubscriberTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/rx/query/CursorResultSubscriberTest.kt @@ -1,10 +1,9 @@ -package com.raizlabs.android.dbflow.rx.query +package com.raizlabs.dbflow5.rx.query -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.config.databaseForTable -import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.query.select -import com.raizlabs.android.dbflow.structure.save +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.config.databaseForTable +import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.structure.save import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/query/RXQueryTests.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/rx/query/RXQueryTests.kt similarity index 76% rename from dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/query/RXQueryTests.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/rx/query/RXQueryTests.kt index 3b6fec85d..376d03d4d 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/android/dbflow/rx/query/RXQueryTests.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/rx/query/RXQueryTests.kt @@ -1,16 +1,15 @@ -package com.raizlabs.android.dbflow.rx.query +package com.raizlabs.dbflow5.rx.query import android.database.Cursor -import com.raizlabs.android.dbflow.BaseUnitTest -import com.raizlabs.android.dbflow.config.databaseForTable -import com.raizlabs.android.dbflow.database.DatabaseStatement -import com.raizlabs.android.dbflow.models.SimpleModel -import com.raizlabs.android.dbflow.models.SimpleModel_Table.name -import com.raizlabs.android.dbflow.query.insert -import com.raizlabs.android.dbflow.query.property.Property -import com.raizlabs.android.dbflow.query.select -import com.raizlabs.android.dbflow.query.selectCountOf -import com.raizlabs.android.dbflow.structure.save +import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.config.databaseForTable +import com.raizlabs.dbflow5.database.DatabaseStatement +import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.dbflow.models.SimpleModel_Table.name +import com.raizlabs.dbflow5.query.insert +import com.raizlabs.dbflow5.query.property.Property +import com.raizlabs.dbflow5.query.selectCountOf +import com.raizlabs.dbflow5.structure.save import org.junit.Assert.assertEquals import org.junit.Assert.assertNotNull import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/rx/query/RxModels.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/rx/query/RxModels.kt new file mode 100644 index 000000000..c88763bde --- /dev/null +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/rx/query/RxModels.kt @@ -0,0 +1,13 @@ +package com.raizlabs.dbflow5.rx.query + +import com.raizlabs.dbflow5.dbflow.TestDatabase +import com.raizlabs.dbflow5.annotation.PrimaryKey +import com.raizlabs.dbflow5.annotation.Table +import com.raizlabs.dbflow5.rx.structure.BaseRXModel + + +@Table(database = TestDatabase::class, allFields = true) +class SimpleRXModel(@PrimaryKey var id: String = "") : BaseRXModel() + +@Table(database = TestDatabase::class) +class SimpleRXModel2(@PrimaryKey var id: String = "") : com.raizlabs.dbflow5.rx2.structure.BaseRXModel() \ No newline at end of file diff --git a/dbflow/build.gradle b/dbflow/build.gradle index 32e403de3..389fdf466 100644 --- a/dbflow/build.gradle +++ b/dbflow/build.gradle @@ -5,12 +5,10 @@ project.ext.artifactId = bt_name android { compileSdkVersion Integer.valueOf(dbflow_target_sdk) - buildToolsVersion dbflow_build_tools_version defaultConfig { minSdkVersion dbflow_min_sdk targetSdkVersion Integer.valueOf(dbflow_target_sdk) - versionCode = version_code } lintOptions { @@ -28,7 +26,6 @@ dependencies { api project("${dbflow_project_prefix}dbflow-core") api "com.android.support:support-annotations:27.0.1" api "org.jetbrains.kotlin:kotlin-stdlib-jre8:$kotlin_version" - api "org.jetbrains.kotlinx:kotlinx-coroutines-core:0.19.2" } apply from: '../android-artifacts.gradle' diff --git a/dbflow/src/main/AndroidManifest.xml b/dbflow/src/main/AndroidManifest.xml index 166b778f3..67bbf30c5 100644 --- a/dbflow/src/main/AndroidManifest.xml +++ b/dbflow/src/main/AndroidManifest.xml @@ -1,8 +1,2 @@ - - - - - + diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/SqlUtils.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/SqlUtils.kt similarity index 93% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/SqlUtils.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/SqlUtils.kt index 26008fd20..a5812d536 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/SqlUtils.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/SqlUtils.kt @@ -1,17 +1,17 @@ @file:JvmName("SqlUtils") -package com.raizlabs.android.dbflow +package com.raizlabs.dbflow5 import android.content.ContentValues import android.net.Uri -import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.query.NameAlias -import com.raizlabs.android.dbflow.query.Operator -import com.raizlabs.android.dbflow.query.OperatorGroup -import com.raizlabs.android.dbflow.query.SQLOperator -import com.raizlabs.android.dbflow.structure.ChangeAction -import com.raizlabs.android.dbflow.structure.Model -import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.query.NameAlias +import com.raizlabs.dbflow5.query.Operator +import com.raizlabs.dbflow5.query.OperatorGroup +import com.raizlabs.dbflow5.query.SQLOperator +import com.raizlabs.dbflow5.structure.ChangeAction +import com.raizlabs.dbflow5.structure.Model +import com.raizlabs.dbflow5.database.DatabaseWrapper /** * Description: Provides some handy methods for dealing with SQL statements. It's purpose is to move the diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/InstanceAdapter.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/InstanceAdapter.kt similarity index 80% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/InstanceAdapter.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/adapter/InstanceAdapter.kt index 66224b107..3a113f5d3 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/InstanceAdapter.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/InstanceAdapter.kt @@ -1,6 +1,6 @@ -package com.raizlabs.android.dbflow.adapter +package com.raizlabs.dbflow5.adapter -import com.raizlabs.android.dbflow.config.DatabaseDefinition +import com.raizlabs.dbflow5.config.DatabaseDefinition /** * Description: Provides a [.newInstance] method to a [RetrievalAdapter] diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/InternalAdapter.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/InternalAdapter.kt similarity index 96% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/InternalAdapter.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/adapter/InternalAdapter.kt index 3940ec590..96ae35ebe 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/InternalAdapter.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/InternalAdapter.kt @@ -1,12 +1,12 @@ -package com.raizlabs.android.dbflow.adapter +package com.raizlabs.dbflow5.adapter import android.content.ContentValues import android.database.sqlite.SQLiteStatement import android.support.annotation.IntRange -import com.raizlabs.android.dbflow.annotation.PrimaryKey -import com.raizlabs.android.dbflow.database.DatabaseStatement -import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.dbflow5.annotation.PrimaryKey +import com.raizlabs.dbflow5.database.DatabaseStatement +import com.raizlabs.dbflow5.database.DatabaseWrapper /** * Description: Used for our internal Adapter classes such as generated [ModelAdapter]. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/ModelAdapter.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/ModelAdapter.kt similarity index 92% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/ModelAdapter.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/adapter/ModelAdapter.kt index 8d96a0cc6..d481a48b1 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/ModelAdapter.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/ModelAdapter.kt @@ -1,24 +1,24 @@ -package com.raizlabs.android.dbflow.adapter +package com.raizlabs.dbflow5.adapter import android.content.ContentValues import android.database.sqlite.SQLiteStatement -import com.raizlabs.android.dbflow.annotation.ConflictAction -import com.raizlabs.android.dbflow.annotation.DEFAULT_CACHE_SIZE -import com.raizlabs.android.dbflow.annotation.ForeignKey -import com.raizlabs.android.dbflow.annotation.PrimaryKey -import com.raizlabs.android.dbflow.annotation.Table -import com.raizlabs.android.dbflow.config.DatabaseDefinition -import com.raizlabs.android.dbflow.query.property.IProperty -import com.raizlabs.android.dbflow.query.property.Property -import com.raizlabs.android.dbflow.adapter.saveable.ListModelSaver -import com.raizlabs.android.dbflow.adapter.saveable.ModelSaver -import com.raizlabs.android.dbflow.query.cache.IMultiKeyCacheConverter -import com.raizlabs.android.dbflow.query.cache.ModelCache -import com.raizlabs.android.dbflow.query.cache.SimpleMapCache -import com.raizlabs.android.dbflow.structure.InvalidDBConfiguration -import com.raizlabs.android.dbflow.database.DatabaseStatement -import com.raizlabs.android.dbflow.database.DatabaseWrapper -import com.raizlabs.android.dbflow.database.FlowCursor +import com.raizlabs.dbflow5.annotation.ConflictAction +import com.raizlabs.dbflow5.annotation.DEFAULT_CACHE_SIZE +import com.raizlabs.dbflow5.annotation.ForeignKey +import com.raizlabs.dbflow5.annotation.PrimaryKey +import com.raizlabs.dbflow5.annotation.Table +import com.raizlabs.dbflow5.config.DatabaseDefinition +import com.raizlabs.dbflow5.query.property.IProperty +import com.raizlabs.dbflow5.query.property.Property +import com.raizlabs.dbflow5.adapter.saveable.ListModelSaver +import com.raizlabs.dbflow5.adapter.saveable.ModelSaver +import com.raizlabs.dbflow5.query.cache.IMultiKeyCacheConverter +import com.raizlabs.dbflow5.query.cache.ModelCache +import com.raizlabs.dbflow5.query.cache.SimpleMapCache +import com.raizlabs.dbflow5.structure.InvalidDBConfiguration +import com.raizlabs.dbflow5.database.DatabaseStatement +import com.raizlabs.dbflow5.database.DatabaseWrapper +import com.raizlabs.dbflow5.database.FlowCursor /** * Description: Used for generated classes from the combination of [Table] and [Model]. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/ModelViewAdapter.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/ModelViewAdapter.kt similarity index 75% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/ModelViewAdapter.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/adapter/ModelViewAdapter.kt index c2bf54242..8190aed06 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/ModelViewAdapter.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/ModelViewAdapter.kt @@ -1,7 +1,7 @@ -package com.raizlabs.android.dbflow.adapter +package com.raizlabs.dbflow5.adapter -import com.raizlabs.android.dbflow.config.DatabaseDefinition -import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.dbflow5.config.DatabaseDefinition +import com.raizlabs.dbflow5.database.DatabaseWrapper /** * Description: The base class for a [T] adapter that defines how it interacts with the DB. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/QueryModelAdapter.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/QueryModelAdapter.kt similarity index 74% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/QueryModelAdapter.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/adapter/QueryModelAdapter.kt index 751dce831..70b5b48e6 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/QueryModelAdapter.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/QueryModelAdapter.kt @@ -1,9 +1,9 @@ -package com.raizlabs.android.dbflow.adapter +package com.raizlabs.dbflow5.adapter -import com.raizlabs.android.dbflow.annotation.QueryModel -import com.raizlabs.android.dbflow.config.DatabaseDefinition -import com.raizlabs.android.dbflow.query.OperatorGroup -import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.dbflow5.annotation.QueryModel +import com.raizlabs.dbflow5.config.DatabaseDefinition +import com.raizlabs.dbflow5.query.OperatorGroup +import com.raizlabs.dbflow5.database.DatabaseWrapper /** * Description: The baseclass for adapters to [QueryModel] that defines how it interacts with the DB. The diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/RetrievalAdapter.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/RetrievalAdapter.kt similarity index 88% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/RetrievalAdapter.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/adapter/RetrievalAdapter.kt index d76366f61..0bd3964d6 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/RetrievalAdapter.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/RetrievalAdapter.kt @@ -1,16 +1,14 @@ -package com.raizlabs.android.dbflow.adapter +package com.raizlabs.dbflow5.adapter import android.database.Cursor -import com.raizlabs.android.dbflow.config.DatabaseDefinition -import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.config.TableConfig -import com.raizlabs.android.dbflow.query.OperatorGroup -import com.raizlabs.android.dbflow.query.select -import com.raizlabs.android.dbflow.query.where -import com.raizlabs.android.dbflow.adapter.queriable.ListModelLoader -import com.raizlabs.android.dbflow.adapter.queriable.SingleModelLoader -import com.raizlabs.android.dbflow.database.DatabaseWrapper -import com.raizlabs.android.dbflow.database.FlowCursor +import com.raizlabs.dbflow5.config.DatabaseDefinition +import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.config.TableConfig +import com.raizlabs.dbflow5.query.OperatorGroup +import com.raizlabs.dbflow5.adapter.queriable.ListModelLoader +import com.raizlabs.dbflow5.adapter.queriable.SingleModelLoader +import com.raizlabs.dbflow5.database.DatabaseWrapper +import com.raizlabs.dbflow5.database.FlowCursor /** * Description: Provides a base retrieval class for all [Model] backed diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/CacheableListModelLoader.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/CacheableListModelLoader.kt similarity index 79% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/CacheableListModelLoader.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/CacheableListModelLoader.kt index 6f2ed48ea..d1a6433e8 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/CacheableListModelLoader.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/CacheableListModelLoader.kt @@ -1,11 +1,11 @@ -package com.raizlabs.android.dbflow.adapter.queriable +package com.raizlabs.dbflow5.adapter.queriable -import com.raizlabs.android.dbflow.adapter.ModelAdapter -import com.raizlabs.android.dbflow.annotation.Table -import com.raizlabs.android.dbflow.database.DatabaseWrapper -import com.raizlabs.android.dbflow.database.FlowCursor -import com.raizlabs.android.dbflow.query.cache.ModelCache -import com.raizlabs.android.dbflow.query.cache.addOrReload +import com.raizlabs.dbflow5.adapter.ModelAdapter +import com.raizlabs.dbflow5.annotation.Table +import com.raizlabs.dbflow5.database.DatabaseWrapper +import com.raizlabs.dbflow5.database.FlowCursor +import com.raizlabs.dbflow5.query.cache.ModelCache +import com.raizlabs.dbflow5.query.cache.addOrReload /** * Description: Loads a [List] of [T] with [Table.cachingEnabled] true. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/CacheableModelLoader.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/CacheableModelLoader.kt similarity index 81% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/CacheableModelLoader.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/CacheableModelLoader.kt index 5042d6709..96d00ea92 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/CacheableModelLoader.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/CacheableModelLoader.kt @@ -1,11 +1,11 @@ -package com.raizlabs.android.dbflow.adapter.queriable +package com.raizlabs.dbflow5.adapter.queriable -import com.raizlabs.android.dbflow.adapter.ModelAdapter -import com.raizlabs.android.dbflow.annotation.Table -import com.raizlabs.android.dbflow.database.DatabaseWrapper -import com.raizlabs.android.dbflow.database.FlowCursor -import com.raizlabs.android.dbflow.query.cache.ModelCache -import com.raizlabs.android.dbflow.query.cache.addOrReload +import com.raizlabs.dbflow5.adapter.ModelAdapter +import com.raizlabs.dbflow5.annotation.Table +import com.raizlabs.dbflow5.database.DatabaseWrapper +import com.raizlabs.dbflow5.database.FlowCursor +import com.raizlabs.dbflow5.query.cache.ModelCache +import com.raizlabs.dbflow5.query.cache.addOrReload /** * Description: Loads model data that is backed by a [ModelCache]. Used when [Table.cachingEnabled] diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/ListModelLoader.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/ListModelLoader.kt similarity index 85% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/ListModelLoader.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/ListModelLoader.kt index ef21a7c58..1be3be9d1 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/ListModelLoader.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/ListModelLoader.kt @@ -1,7 +1,7 @@ -package com.raizlabs.android.dbflow.adapter.queriable +package com.raizlabs.dbflow5.adapter.queriable -import com.raizlabs.android.dbflow.database.DatabaseWrapper -import com.raizlabs.android.dbflow.database.FlowCursor +import com.raizlabs.dbflow5.database.DatabaseWrapper +import com.raizlabs.dbflow5.database.FlowCursor /** * Description: Loads a [List] of [T]. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/ModelLoader.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/ModelLoader.kt similarity index 86% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/ModelLoader.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/ModelLoader.kt index 5efa7e443..744d81265 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/ModelLoader.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/ModelLoader.kt @@ -1,11 +1,11 @@ -package com.raizlabs.android.dbflow.adapter.queriable +package com.raizlabs.dbflow5.adapter.queriable import android.database.Cursor import android.database.sqlite.SQLiteDatabase -import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.adapter.InstanceAdapter -import com.raizlabs.android.dbflow.database.DatabaseWrapper -import com.raizlabs.android.dbflow.database.FlowCursor +import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.adapter.InstanceAdapter +import com.raizlabs.dbflow5.database.DatabaseWrapper +import com.raizlabs.dbflow5.database.FlowCursor /** * Description: Represents how models load from DB. It will query a [SQLiteDatabase] diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/SingleKeyCacheableListModelLoader.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/SingleKeyCacheableListModelLoader.kt similarity index 78% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/SingleKeyCacheableListModelLoader.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/SingleKeyCacheableListModelLoader.kt index f1920e536..8a32e8dca 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/SingleKeyCacheableListModelLoader.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/SingleKeyCacheableListModelLoader.kt @@ -1,8 +1,8 @@ -package com.raizlabs.android.dbflow.adapter.queriable +package com.raizlabs.dbflow5.adapter.queriable -import com.raizlabs.android.dbflow.database.DatabaseWrapper -import com.raizlabs.android.dbflow.database.FlowCursor -import com.raizlabs.android.dbflow.query.cache.addOrReload +import com.raizlabs.dbflow5.database.DatabaseWrapper +import com.raizlabs.dbflow5.database.FlowCursor +import com.raizlabs.dbflow5.query.cache.addOrReload /** * Description: diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/SingleKeyCacheableModelLoader.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/SingleKeyCacheableModelLoader.kt similarity index 76% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/SingleKeyCacheableModelLoader.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/SingleKeyCacheableModelLoader.kt index d43445dc7..898f27583 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/SingleKeyCacheableModelLoader.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/SingleKeyCacheableModelLoader.kt @@ -1,9 +1,9 @@ -package com.raizlabs.android.dbflow.adapter.queriable +package com.raizlabs.dbflow5.adapter.queriable -import com.raizlabs.android.dbflow.database.DatabaseWrapper -import com.raizlabs.android.dbflow.database.FlowCursor -import com.raizlabs.android.dbflow.query.cache.addOrReload -import com.raizlabs.android.dbflow.structure.Model +import com.raizlabs.dbflow5.database.DatabaseWrapper +import com.raizlabs.dbflow5.database.FlowCursor +import com.raizlabs.dbflow5.query.cache.addOrReload +import com.raizlabs.dbflow5.structure.Model /** * Description: More optimized version of [CacheableModelLoader] which assumes that the [Model] diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/SingleModelLoader.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/SingleModelLoader.kt similarity index 82% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/SingleModelLoader.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/SingleModelLoader.kt index a076d0abc..f3380daa9 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/queriable/SingleModelLoader.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/SingleModelLoader.kt @@ -1,7 +1,7 @@ -package com.raizlabs.android.dbflow.adapter.queriable +package com.raizlabs.dbflow5.adapter.queriable -import com.raizlabs.android.dbflow.database.DatabaseWrapper -import com.raizlabs.android.dbflow.database.FlowCursor +import com.raizlabs.dbflow5.database.DatabaseWrapper +import com.raizlabs.dbflow5.database.FlowCursor /** * Description: Responsible for loading data into a single object. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/saveable/AutoIncrementModelSaver.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/saveable/AutoIncrementModelSaver.kt similarity index 81% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/saveable/AutoIncrementModelSaver.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/adapter/saveable/AutoIncrementModelSaver.kt index 550a807b9..38a973dad 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/saveable/AutoIncrementModelSaver.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/saveable/AutoIncrementModelSaver.kt @@ -1,10 +1,10 @@ -package com.raizlabs.android.dbflow.adapter.saveable +package com.raizlabs.dbflow5.adapter.saveable -import com.raizlabs.android.dbflow.config.FlowLog -import com.raizlabs.android.dbflow.runtime.NotifyDistributor -import com.raizlabs.android.dbflow.structure.ChangeAction -import com.raizlabs.android.dbflow.database.DatabaseStatement -import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.dbflow5.config.FlowLog +import com.raizlabs.dbflow5.runtime.NotifyDistributor +import com.raizlabs.dbflow5.structure.ChangeAction +import com.raizlabs.dbflow5.database.DatabaseStatement +import com.raizlabs.dbflow5.database.DatabaseWrapper /** * Description: Used to properly handle autoincrementing fields. @@ -26,7 +26,7 @@ class AutoIncrementModelSaver : ModelSaver() { modelAdapter.bindToInsertStatement(insertStatement, model) } id = insertStatement.executeInsert() - if (id > ModelSaver.INSERT_FAILED) { + if (id > INSERT_FAILED) { modelAdapter.updateAutoIncrement(model, id) NotifyDistributor.get().notifyModelChanged(model, modelAdapter, ChangeAction.INSERT) } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/saveable/CacheableListModelSaver.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/saveable/CacheableListModelSaver.kt similarity index 93% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/saveable/CacheableListModelSaver.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/adapter/saveable/CacheableListModelSaver.kt index 9adacb780..b7d000fb9 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/saveable/CacheableListModelSaver.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/saveable/CacheableListModelSaver.kt @@ -1,7 +1,7 @@ -package com.raizlabs.android.dbflow.adapter.saveable +package com.raizlabs.dbflow5.adapter.saveable -import com.raizlabs.android.dbflow.database.DatabaseStatement -import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.dbflow5.database.DatabaseStatement +import com.raizlabs.dbflow5.database.DatabaseWrapper /** * Description: Used for model caching, enables caching models when saving in list. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/saveable/ListModelSaver.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/saveable/ListModelSaver.kt similarity index 92% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/saveable/ListModelSaver.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/adapter/saveable/ListModelSaver.kt index 3f1420e0b..d374e2069 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/saveable/ListModelSaver.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/saveable/ListModelSaver.kt @@ -1,7 +1,7 @@ -package com.raizlabs.android.dbflow.adapter.saveable +package com.raizlabs.dbflow5.adapter.saveable -import com.raizlabs.android.dbflow.database.DatabaseStatement -import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.dbflow5.database.DatabaseStatement +import com.raizlabs.dbflow5.database.DatabaseWrapper open class ListModelSaver(val modelSaver: ModelSaver) { diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/saveable/ModelSaver.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/saveable/ModelSaver.kt similarity index 91% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/saveable/ModelSaver.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/adapter/saveable/ModelSaver.kt index 3f80528d4..ecf759cb3 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/adapter/saveable/ModelSaver.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/saveable/ModelSaver.kt @@ -1,11 +1,11 @@ -package com.raizlabs.android.dbflow.adapter.saveable +package com.raizlabs.dbflow5.adapter.saveable import android.content.ContentValues -import com.raizlabs.android.dbflow.runtime.NotifyDistributor -import com.raizlabs.android.dbflow.structure.ChangeAction -import com.raizlabs.android.dbflow.adapter.ModelAdapter -import com.raizlabs.android.dbflow.database.DatabaseStatement -import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.dbflow5.runtime.NotifyDistributor +import com.raizlabs.dbflow5.structure.ChangeAction +import com.raizlabs.dbflow5.adapter.ModelAdapter +import com.raizlabs.dbflow5.database.DatabaseStatement +import com.raizlabs.dbflow5.database.DatabaseWrapper /** * Description: Defines how models get saved into the DB. It will bind values to [DatabaseStatement] diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseConfig.kt similarity index 89% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseConfig.kt index 892e2a318..554b637f4 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseConfig.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseConfig.kt @@ -1,10 +1,10 @@ -package com.raizlabs.android.dbflow.config +package com.raizlabs.dbflow5.config -import com.raizlabs.android.dbflow.database.DatabaseHelperListener -import com.raizlabs.android.dbflow.database.OpenHelper -import com.raizlabs.android.dbflow.isNotNullOrEmpty -import com.raizlabs.android.dbflow.runtime.ModelNotifier -import com.raizlabs.android.dbflow.transaction.BaseTransactionManager +import com.raizlabs.dbflow5.database.DatabaseHelperListener +import com.raizlabs.dbflow5.database.OpenHelper +import com.raizlabs.dbflow5.isNotNullOrEmpty +import com.raizlabs.dbflow5.runtime.ModelNotifier +import com.raizlabs.dbflow5.transaction.BaseTransactionManager /** * Description: @@ -124,10 +124,10 @@ class DatabaseConfig( companion object { @JvmStatic - fun builder(database: Class<*>): DatabaseConfig.Builder = DatabaseConfig.Builder(database) + fun builder(database: Class<*>): Builder = Builder(database) @JvmStatic - fun inMemoryBuilder(database: Class<*>): DatabaseConfig.Builder = - DatabaseConfig.Builder(database).inMemory() + fun inMemoryBuilder(database: Class<*>): Builder = + Builder(database).inMemory() } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseDefinition.kt similarity index 90% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseDefinition.kt index f85bb817c..314cf2527 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseDefinition.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseDefinition.kt @@ -1,31 +1,32 @@ -package com.raizlabs.android.dbflow.config +package com.raizlabs.dbflow5.config import android.content.ContentValues import android.content.Context -import com.raizlabs.android.dbflow.adapter.ModelAdapter -import com.raizlabs.android.dbflow.adapter.ModelViewAdapter -import com.raizlabs.android.dbflow.adapter.QueryModelAdapter -import com.raizlabs.android.dbflow.adapter.queriable.ListModelLoader -import com.raizlabs.android.dbflow.adapter.queriable.SingleModelLoader -import com.raizlabs.android.dbflow.adapter.saveable.ModelSaver -import com.raizlabs.android.dbflow.annotation.Database -import com.raizlabs.android.dbflow.annotation.QueryModel -import com.raizlabs.android.dbflow.annotation.Table -import com.raizlabs.android.dbflow.database.DatabaseHelperListener -import com.raizlabs.android.dbflow.database.DatabaseStatement -import com.raizlabs.android.dbflow.database.DatabaseWrapper -import com.raizlabs.android.dbflow.database.FlowCursor -import com.raizlabs.android.dbflow.database.FlowSQLiteOpenHelper -import com.raizlabs.android.dbflow.database.OpenHelper -import com.raizlabs.android.dbflow.migration.Migration -import com.raizlabs.android.dbflow.runtime.DirectModelNotifier -import com.raizlabs.android.dbflow.runtime.ModelNotifier -import com.raizlabs.android.dbflow.structure.BaseModelView -import com.raizlabs.android.dbflow.transaction.BaseTransactionManager -import com.raizlabs.android.dbflow.transaction.DefaultTransactionManager -import com.raizlabs.android.dbflow.transaction.DefaultTransactionQueue -import com.raizlabs.android.dbflow.transaction.ITransaction -import com.raizlabs.android.dbflow.transaction.Transaction +import com.raizlabs.dbflow5.adapter.ModelAdapter +import com.raizlabs.dbflow5.adapter.ModelViewAdapter +import com.raizlabs.dbflow5.adapter.QueryModelAdapter +import com.raizlabs.dbflow5.adapter.queriable.ListModelLoader +import com.raizlabs.dbflow5.adapter.queriable.SingleModelLoader +import com.raizlabs.dbflow5.adapter.saveable.ModelSaver +import com.raizlabs.dbflow5.annotation.Database +import com.raizlabs.dbflow5.annotation.QueryModel +import com.raizlabs.dbflow5.annotation.Table +import com.raizlabs.dbflow5.dbflow.config.DatabaseHolder +import com.raizlabs.dbflow5.database.DatabaseHelperListener +import com.raizlabs.dbflow5.database.DatabaseStatement +import com.raizlabs.dbflow5.database.DatabaseWrapper +import com.raizlabs.dbflow5.database.FlowCursor +import com.raizlabs.dbflow5.database.FlowSQLiteOpenHelper +import com.raizlabs.dbflow5.database.OpenHelper +import com.raizlabs.dbflow5.migration.Migration +import com.raizlabs.dbflow5.runtime.DirectModelNotifier +import com.raizlabs.dbflow5.runtime.ModelNotifier +import com.raizlabs.dbflow5.structure.BaseModelView +import com.raizlabs.dbflow5.transaction.BaseTransactionManager +import com.raizlabs.dbflow5.transaction.DefaultTransactionManager +import com.raizlabs.dbflow5.transaction.DefaultTransactionQueue +import com.raizlabs.dbflow5.transaction.ITransaction +import com.raizlabs.dbflow5.transaction.Transaction /** * Description: The main interface that all Database implementations extend from. This is for internal usage only diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseHolder.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseHolder.kt similarity index 95% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseHolder.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseHolder.kt index 03eed762e..fc80ed5f6 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/DatabaseHolder.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseHolder.kt @@ -1,6 +1,6 @@ -package com.raizlabs.android.dbflow.config +package com.raizlabs.dbflow5.config -import com.raizlabs.android.dbflow.converter.TypeConverter +import com.raizlabs.dbflow5.converter.TypeConverter /** * Description: The base interface for interacting with all of the database and top-level data that's shared diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowConfig.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowConfig.kt similarity index 93% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowConfig.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowConfig.kt index 9e324e713..ed499ac71 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowConfig.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowConfig.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.config +package com.raizlabs.dbflow5.config import android.content.Context @@ -49,6 +49,6 @@ class FlowConfig(val context: Context, companion object { - fun builder(context: Context): FlowConfig.Builder = FlowConfig.Builder(context) + fun builder(context: Context): Builder = Builder(context) } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowLog.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowLog.kt similarity index 97% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowLog.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowLog.kt index 687613e5b..1af1b7285 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowLog.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowLog.kt @@ -1,8 +1,8 @@ -package com.raizlabs.android.dbflow.config +package com.raizlabs.dbflow5.config import android.os.Build import android.util.Log -import com.raizlabs.android.dbflow.config.FlowLog.Level +import com.raizlabs.dbflow5.config.FlowLog.Level /** * Description: Mirrors [Log] with its own [Level] flag. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowManager.kt similarity index 92% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowManager.kt index 69550cdf7..7bf06399b 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/FlowManager.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowManager.kt @@ -1,23 +1,23 @@ -package com.raizlabs.android.dbflow.config +package com.raizlabs.dbflow5.config import android.content.Context -import com.raizlabs.android.dbflow.annotation.Table -import com.raizlabs.android.dbflow.converter.TypeConverter -import com.raizlabs.android.dbflow.quote -import com.raizlabs.android.dbflow.runtime.ModelNotifier -import com.raizlabs.android.dbflow.runtime.TableNotifierRegister -import com.raizlabs.android.dbflow.migration.Migration -import com.raizlabs.android.dbflow.structure.BaseModel -import com.raizlabs.android.dbflow.structure.BaseModelView -import com.raizlabs.android.dbflow.structure.BaseQueryModel -import com.raizlabs.android.dbflow.adapter.InstanceAdapter -import com.raizlabs.android.dbflow.structure.InvalidDBConfiguration -import com.raizlabs.android.dbflow.structure.Model -import com.raizlabs.android.dbflow.adapter.ModelAdapter -import com.raizlabs.android.dbflow.adapter.ModelViewAdapter -import com.raizlabs.android.dbflow.adapter.QueryModelAdapter -import com.raizlabs.android.dbflow.adapter.RetrievalAdapter -import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.dbflow5.annotation.Table +import com.raizlabs.dbflow5.converter.TypeConverter +import com.raizlabs.dbflow5.quote +import com.raizlabs.dbflow5.runtime.ModelNotifier +import com.raizlabs.dbflow5.runtime.TableNotifierRegister +import com.raizlabs.dbflow5.migration.Migration +import com.raizlabs.dbflow5.structure.BaseModel +import com.raizlabs.dbflow5.structure.BaseModelView +import com.raizlabs.dbflow5.structure.BaseQueryModel +import com.raizlabs.dbflow5.adapter.InstanceAdapter +import com.raizlabs.dbflow5.structure.InvalidDBConfiguration +import com.raizlabs.dbflow5.structure.Model +import com.raizlabs.dbflow5.adapter.ModelAdapter +import com.raizlabs.dbflow5.adapter.ModelViewAdapter +import com.raizlabs.dbflow5.adapter.QueryModelAdapter +import com.raizlabs.dbflow5.adapter.RetrievalAdapter +import com.raizlabs.dbflow5.database.DatabaseWrapper import kotlin.reflect.KClass /** @@ -38,7 +38,7 @@ object FlowManager { private val DEFAULT_DATABASE_HOLDER_PACKAGE_NAME = FlowManager::class.java.`package`.name private val DEFAULT_DATABASE_HOLDER_CLASSNAME = - DEFAULT_DATABASE_HOLDER_PACKAGE_NAME + "." + DEFAULT_DATABASE_HOLDER_NAME + DEFAULT_DATABASE_HOLDER_PACKAGE_NAME + "" + DEFAULT_DATABASE_HOLDER_NAME /** * Will throw an exception if this class is not initialized yet in [.init] @@ -245,7 +245,7 @@ object FlowManager { */ @JvmStatic fun init(flowConfig: FlowConfig) { - FlowManager.config = flowConfig + config = flowConfig @Suppress("UNCHECKED_CAST") try { @@ -375,13 +375,13 @@ object FlowManager { getModelNotifierForTable(table).newRegister() private fun getModelAdapterOrNull(modelClass: Class): ModelAdapter? = - FlowManager.getDatabaseForTable(modelClass).getModelAdapterForTable(modelClass) + getDatabaseForTable(modelClass).getModelAdapterForTable(modelClass) private fun getModelViewAdapterOrNull(modelClass: Class): ModelViewAdapter? = - FlowManager.getDatabaseForTable(modelClass).getModelViewAdapterForTable(modelClass) + getDatabaseForTable(modelClass).getModelViewAdapterForTable(modelClass) private fun getQueryModelAdapterOrNull(modelClass: Class): QueryModelAdapter? = - FlowManager.getDatabaseForTable(modelClass).getQueryModelAdapterForQueryClass(modelClass) + getDatabaseForTable(modelClass).getQueryModelAdapterForQueryClass(modelClass) /** * @param databaseName The name of the database. Will throw an exception if the databaseForTable doesn't exist. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/NaturalOrderComparator.java b/dbflow/src/main/java/com/raizlabs/dbflow5/config/NaturalOrderComparator.java similarity index 98% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/config/NaturalOrderComparator.java rename to dbflow/src/main/java/com/raizlabs/dbflow5/config/NaturalOrderComparator.java index cf76afd14..94cbe7315 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/NaturalOrderComparator.java +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/config/NaturalOrderComparator.java @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.config; +package com.raizlabs.dbflow5.config; /* NaturalOrderComparator.java -- Perform 'natural order' comparisons of strings in Java. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/TableConfig.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/config/TableConfig.kt similarity index 83% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/config/TableConfig.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/config/TableConfig.kt index bb592ff50..940e10d18 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/config/TableConfig.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/config/TableConfig.kt @@ -1,9 +1,9 @@ -package com.raizlabs.android.dbflow.config +package com.raizlabs.dbflow5.config -import com.raizlabs.android.dbflow.adapter.queriable.ListModelLoader -import com.raizlabs.android.dbflow.adapter.queriable.SingleModelLoader -import com.raizlabs.android.dbflow.adapter.saveable.ModelSaver -import com.raizlabs.android.dbflow.adapter.ModelAdapter +import com.raizlabs.dbflow5.adapter.queriable.ListModelLoader +import com.raizlabs.dbflow5.adapter.queriable.SingleModelLoader +import com.raizlabs.dbflow5.adapter.saveable.ModelSaver +import com.raizlabs.dbflow5.adapter.ModelAdapter /** * Description: Represents certain table configuration options. This allows you to easily specify @@ -61,7 +61,7 @@ class TableConfig(val tableClass: Class, companion object { @JvmStatic - fun builder(tableClass: Class): TableConfig.Builder = - TableConfig.Builder(tableClass) + fun builder(tableClass: Class): Builder = + Builder(tableClass) } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/database/AndroidDatabase.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidDatabase.kt similarity index 98% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/database/AndroidDatabase.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidDatabase.kt index f259ad84b..7835121a2 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/database/AndroidDatabase.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidDatabase.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.database +package com.raizlabs.dbflow5.database import android.content.ContentValues import android.database.sqlite.SQLiteDatabase diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/database/AndroidDatabaseStatement.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidDatabaseStatement.kt similarity index 98% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/database/AndroidDatabaseStatement.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidDatabaseStatement.kt index da3246d3a..bf7c45bfb 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/database/AndroidDatabaseStatement.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidDatabaseStatement.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.database +package com.raizlabs.dbflow5.database import android.database.Cursor import android.database.SQLException diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/database/BaseDatabaseHelper.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/database/BaseDatabaseHelper.kt similarity index 93% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/database/BaseDatabaseHelper.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/database/BaseDatabaseHelper.kt index 865f16105..f85f2bcdb 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/database/BaseDatabaseHelper.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/database/BaseDatabaseHelper.kt @@ -1,10 +1,10 @@ -package com.raizlabs.android.dbflow.database +package com.raizlabs.dbflow5.database import android.database.sqlite.SQLiteException -import com.raizlabs.android.dbflow.config.DatabaseDefinition -import com.raizlabs.android.dbflow.config.FlowLog -import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.config.NaturalOrderComparator +import com.raizlabs.dbflow5.config.DatabaseDefinition +import com.raizlabs.dbflow5.config.FlowLog +import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.config.NaturalOrderComparator import java.io.BufferedReader import java.io.IOException import java.io.InputStreamReader @@ -95,7 +95,7 @@ open class BaseDatabaseHelper(val databaseDefinition: DatabaseDefinition) { // will try migrations file or execute migrations from code try { val files = FlowManager.context.assets.list( - "$MIGRATION_PATH/${databaseDefinition.databaseName}") + "${MIGRATION_PATH}/${databaseDefinition.databaseName}") .sortedWith(NaturalOrderComparator()) val migrationFileMap = hashMapOf>() @@ -161,7 +161,7 @@ open class BaseDatabaseHelper(val databaseDefinition: DatabaseDefinition) { private fun executeSqlScript(db: DatabaseWrapper, file: String) { try { - val input = FlowManager.context.assets.open("$MIGRATION_PATH/${databaseDefinition.databaseName}/$file") + val input = FlowManager.context.assets.open("${MIGRATION_PATH}/${databaseDefinition.databaseName}/$file") val reader = BufferedReader(InputStreamReader(input)) // ends line with SQL diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/database/BaseDatabaseStatement.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/database/BaseDatabaseStatement.kt similarity index 96% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/database/BaseDatabaseStatement.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/database/BaseDatabaseStatement.kt index b5823066f..927d601b5 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/database/BaseDatabaseStatement.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/database/BaseDatabaseStatement.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.database +package com.raizlabs.dbflow5.database /** * Description: Default implementation for some [DatabaseStatement] methods. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/database/ContentValueExtensions.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/database/ContentValueExtensions.kt similarity index 94% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/database/ContentValueExtensions.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/database/ContentValueExtensions.kt index 8ed252e0a..4977a8fa8 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/database/ContentValueExtensions.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/database/ContentValueExtensions.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.database +package com.raizlabs.dbflow5.database import android.content.ContentValues diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/database/DatabaseHelperDelegate.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseHelperDelegate.kt similarity index 96% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/database/DatabaseHelperDelegate.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseHelperDelegate.kt index 318edb822..7dbc0b646 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/database/DatabaseHelperDelegate.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseHelperDelegate.kt @@ -1,11 +1,11 @@ -package com.raizlabs.android.dbflow.database +package com.raizlabs.dbflow5.database import android.database.sqlite.SQLiteOpenHelper -import com.raizlabs.android.dbflow.config.DatabaseDefinition -import com.raizlabs.android.dbflow.config.FlowLog -import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.transaction.DefaultTransactionQueue -import com.raizlabs.android.dbflow.transaction.ITransaction +import com.raizlabs.dbflow5.config.DatabaseDefinition +import com.raizlabs.dbflow5.config.FlowLog +import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.transaction.DefaultTransactionQueue +import com.raizlabs.dbflow5.transaction.ITransaction import java.io.File import java.io.FileInputStream import java.io.FileOutputStream diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/database/DatabaseHelperListener.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseHelperListener.kt similarity index 96% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/database/DatabaseHelperListener.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseHelperListener.kt index 27e163eb9..59b0a0158 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/database/DatabaseHelperListener.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseHelperListener.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.database +package com.raizlabs.dbflow5.database /** * Description: Provides callbacks for [OpenHelper] methods diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/database/DatabaseStatement.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseStatement.kt similarity index 94% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/database/DatabaseStatement.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseStatement.kt index 4a58bcf2c..4114d07b9 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/database/DatabaseStatement.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseStatement.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.database +package com.raizlabs.dbflow5.database import android.database.sqlite.SQLiteStatement diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/database/DatabaseStatementWrapper.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseStatementWrapper.kt similarity index 91% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/database/DatabaseStatementWrapper.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseStatementWrapper.kt index c13b3bdbe..b150bde94 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/database/DatabaseStatementWrapper.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseStatementWrapper.kt @@ -1,7 +1,7 @@ -package com.raizlabs.android.dbflow.database +package com.raizlabs.dbflow5.database -import com.raizlabs.android.dbflow.runtime.NotifyDistributor -import com.raizlabs.android.dbflow.query.BaseQueriable +import com.raizlabs.dbflow5.runtime.NotifyDistributor +import com.raizlabs.dbflow5.query.BaseQueriable /** * Description: Delegates all of its calls to the contained [DatabaseStatement], while diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/database/DatabaseWrapper.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseWrapper.kt similarity index 96% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/database/DatabaseWrapper.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseWrapper.kt index 950c0997e..4e8e7a7fc 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/database/DatabaseWrapper.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseWrapper.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.database +package com.raizlabs.dbflow5.database import android.content.ContentValues diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/database/FlowCursor.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/database/FlowCursor.kt similarity index 99% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/database/FlowCursor.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/database/FlowCursor.kt index d546c5b35..869d01d88 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/database/FlowCursor.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/database/FlowCursor.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.database +package com.raizlabs.dbflow5.database import android.database.Cursor import android.database.CursorWrapper diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/database/FlowSQLiteOpenHelper.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/database/FlowSQLiteOpenHelper.kt similarity index 96% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/database/FlowSQLiteOpenHelper.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/database/FlowSQLiteOpenHelper.kt index 9dfaf5145..ea93b99a5 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/database/FlowSQLiteOpenHelper.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/database/FlowSQLiteOpenHelper.kt @@ -1,11 +1,11 @@ -package com.raizlabs.android.dbflow.database +package com.raizlabs.dbflow5.database import android.content.Context import android.database.sqlite.SQLiteDatabase import android.database.sqlite.SQLiteOpenHelper -import com.raizlabs.android.dbflow.config.DatabaseDefinition -import com.raizlabs.android.dbflow.config.FlowManager +import com.raizlabs.dbflow5.config.DatabaseDefinition +import com.raizlabs.dbflow5.config.FlowManager /** * Description: Wraps around the [SQLiteOpenHelper] and provides extra features for use in this library. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/database/OpenHelper.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/database/OpenHelper.kt similarity index 64% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/database/OpenHelper.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/database/OpenHelper.kt index 7dc207997..53434742f 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/database/OpenHelper.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/database/OpenHelper.kt @@ -1,4 +1,8 @@ -package com.raizlabs.android.dbflow.database +package com.raizlabs.dbflow5.database + +import com.raizlabs.dbflow5.database.DatabaseHelperDelegate +import com.raizlabs.dbflow5.database.DatabaseHelperListener +import com.raizlabs.dbflow5.database.DatabaseWrapper /** * Description: Abstracts out the [DatabaseHelperDelegate] into the one used in this library. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/migration/AlterTableMigration.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/migration/AlterTableMigration.kt similarity index 90% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/migration/AlterTableMigration.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/migration/AlterTableMigration.kt index 0574a9e6f..a1e632963 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/migration/AlterTableMigration.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/migration/AlterTableMigration.kt @@ -1,13 +1,12 @@ -package com.raizlabs.android.dbflow.migration +package com.raizlabs.dbflow5.migration import android.support.annotation.CallSuper -import com.raizlabs.android.dbflow.appendQuotedIfNeeded -import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.quoteIfNeeded -import com.raizlabs.android.dbflow.sql.SQLiteType -import com.raizlabs.android.dbflow.query.select -import com.raizlabs.android.dbflow.stripQuotes -import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.dbflow5.appendQuotedIfNeeded +import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.quoteIfNeeded +import com.raizlabs.dbflow5.sql.SQLiteType +import com.raizlabs.dbflow5.stripQuotes +import com.raizlabs.dbflow5.database.DatabaseWrapper /** * Description: Provides a very nice way to alter a single table quickly and easily. @@ -128,7 +127,7 @@ class AlterTableMigration( * @return A List of column definitions that add op to a table in the DB. */ fun getColumnDefinitions(): List { - val sql = "$ALTER_TABLE${FlowManager.getTableName(table)}" + val sql = "${ALTER_TABLE}${FlowManager.getTableName(table)}" return internalColumnDefinitions.map { "$sql ADD COLUMN $it" } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/migration/BaseMigration.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/migration/BaseMigration.kt similarity index 77% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/migration/BaseMigration.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/migration/BaseMigration.kt index a37af2760..843075fd8 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/migration/BaseMigration.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/migration/BaseMigration.kt @@ -1,6 +1,6 @@ -package com.raizlabs.android.dbflow.migration +package com.raizlabs.dbflow5.migration -import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.dbflow5.database.DatabaseWrapper /** * Description: Provides the base implementation of [com.raizlabs.android.dbflow.sql.migration.Migration] with diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/migration/IndexMigration.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/migration/IndexMigration.kt similarity index 82% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/migration/IndexMigration.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/migration/IndexMigration.kt index 1c996da71..e10bbf79c 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/migration/IndexMigration.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/migration/IndexMigration.kt @@ -1,8 +1,8 @@ -package com.raizlabs.android.dbflow.migration +package com.raizlabs.dbflow5.migration -import com.raizlabs.android.dbflow.database.DatabaseWrapper -import com.raizlabs.android.dbflow.query.index -import com.raizlabs.android.dbflow.query.property.IProperty +import com.raizlabs.dbflow5.database.DatabaseWrapper +import com.raizlabs.dbflow5.query.index +import com.raizlabs.dbflow5.query.property.IProperty /** * Description: Defines and enables an Index structurally through a migration. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/migration/IndexPropertyMigration.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/migration/IndexPropertyMigration.kt similarity index 73% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/migration/IndexPropertyMigration.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/migration/IndexPropertyMigration.kt index 07340cc39..5504427a4 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/migration/IndexPropertyMigration.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/migration/IndexPropertyMigration.kt @@ -1,7 +1,8 @@ -package com.raizlabs.android.dbflow.migration +package com.raizlabs.dbflow5.migration -import com.raizlabs.android.dbflow.query.property.IndexProperty -import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.dbflow5.query.property.IndexProperty +import com.raizlabs.dbflow5.database.DatabaseWrapper +import com.raizlabs.dbflow5.migration.BaseMigration /** * Description: Allows you to specify if and when an [IndexProperty] gets used or created. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/migration/Migration.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/migration/Migration.kt similarity index 86% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/migration/Migration.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/migration/Migration.kt index 665a3be3c..4e88cf5fb 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/migration/Migration.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/migration/Migration.kt @@ -1,6 +1,6 @@ -package com.raizlabs.android.dbflow.migration +package com.raizlabs.dbflow5.migration -import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.dbflow5.database.DatabaseWrapper /** * Description: Called when the Database is migrating. We can perform custom migrations here. A [com.raizlabs.android.dbflow.annotation.Migration] diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/migration/UpdateTableMigration.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/migration/UpdateTableMigration.kt similarity index 83% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/migration/UpdateTableMigration.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/migration/UpdateTableMigration.kt index dc1cc297f..d14c72640 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/migration/UpdateTableMigration.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/migration/UpdateTableMigration.kt @@ -1,10 +1,10 @@ -package com.raizlabs.android.dbflow.migration +package com.raizlabs.dbflow5.migration -import com.raizlabs.android.dbflow.query.BaseQueriable -import com.raizlabs.android.dbflow.query.OperatorGroup -import com.raizlabs.android.dbflow.query.SQLOperator -import com.raizlabs.android.dbflow.query.update -import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.dbflow5.query.BaseQueriable +import com.raizlabs.dbflow5.query.OperatorGroup +import com.raizlabs.dbflow5.query.SQLOperator +import com.raizlabs.dbflow5.query.update +import com.raizlabs.dbflow5.database.DatabaseWrapper /** * Description: Provides a simple way to update a table's field or fields quickly in a migration. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/provider/BaseContentProvider.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/provider/BaseContentProvider.kt similarity index 83% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/provider/BaseContentProvider.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/provider/BaseContentProvider.kt index b4ee7b3c0..e4a4cd14e 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/provider/BaseContentProvider.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/provider/BaseContentProvider.kt @@ -1,13 +1,13 @@ -package com.raizlabs.android.dbflow.provider +package com.raizlabs.dbflow5.provider import android.content.ContentProvider import android.content.ContentValues import android.net.Uri -import com.raizlabs.android.dbflow.config.DatabaseDefinition -import com.raizlabs.android.dbflow.config.DatabaseHolder -import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.database.DatabaseWrapper -import com.raizlabs.android.dbflow.transaction.ITransaction +import com.raizlabs.dbflow5.config.DatabaseDefinition +import com.raizlabs.dbflow5.dbflow.config.DatabaseHolder +import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.database.DatabaseWrapper +import com.raizlabs.dbflow5.transaction.ITransaction /** * Description: The base provider class that [com.raizlabs.android.dbflow.annotation.provider.ContentProvider] diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/provider/BaseProviderModel.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/provider/BaseProviderModel.kt similarity index 85% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/provider/BaseProviderModel.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/provider/BaseProviderModel.kt index 8b6df2e8c..30ce0b0b1 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/provider/BaseProviderModel.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/provider/BaseProviderModel.kt @@ -1,12 +1,12 @@ -package com.raizlabs.android.dbflow.provider +package com.raizlabs.dbflow5.provider import android.content.ContentProvider -import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.query.OperatorGroup -import com.raizlabs.android.dbflow.structure.BaseModel -import com.raizlabs.android.dbflow.structure.Model -import com.raizlabs.android.dbflow.database.DatabaseWrapper -import com.raizlabs.android.dbflow.database.FlowCursor +import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.query.OperatorGroup +import com.raizlabs.dbflow5.structure.BaseModel +import com.raizlabs.dbflow5.structure.Model +import com.raizlabs.dbflow5.database.DatabaseWrapper +import com.raizlabs.dbflow5.database.FlowCursor /** * Description: Provides a base implementation of a [Model] backed diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/provider/BaseSyncableProviderModel.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/provider/BaseSyncableProviderModel.kt similarity index 82% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/provider/BaseSyncableProviderModel.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/provider/BaseSyncableProviderModel.kt index e7f820c7b..2c5ac9154 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/provider/BaseSyncableProviderModel.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/provider/BaseSyncableProviderModel.kt @@ -1,13 +1,13 @@ -package com.raizlabs.android.dbflow.provider +package com.raizlabs.dbflow5.provider import android.content.ContentProvider -import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.query.OperatorGroup -import com.raizlabs.android.dbflow.structure.BaseModel -import com.raizlabs.android.dbflow.structure.Model -import com.raizlabs.android.dbflow.database.DatabaseWrapper -import com.raizlabs.android.dbflow.database.FlowCursor +import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.query.OperatorGroup +import com.raizlabs.dbflow5.structure.BaseModel +import com.raizlabs.dbflow5.structure.Model +import com.raizlabs.dbflow5.database.DatabaseWrapper +import com.raizlabs.dbflow5.database.FlowCursor /** * Description: Provides a base implementation of a [Model] backed diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/provider/ContentUtils.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/provider/ContentUtils.kt similarity index 96% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/provider/ContentUtils.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/provider/ContentUtils.kt index 82ba27559..7d02dea07 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/provider/ContentUtils.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/provider/ContentUtils.kt @@ -1,17 +1,17 @@ -package com.raizlabs.android.dbflow.provider +package com.raizlabs.dbflow5.provider import android.content.ContentResolver import android.content.ContentValues import android.database.Cursor import android.net.Uri -import com.raizlabs.android.dbflow.annotation.provider.ContentProvider -import com.raizlabs.android.dbflow.config.FlowLog -import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.query.Operator -import com.raizlabs.android.dbflow.query.OperatorGroup -import com.raizlabs.android.dbflow.adapter.ModelAdapter -import com.raizlabs.android.dbflow.database.DatabaseWrapper -import com.raizlabs.android.dbflow.database.FlowCursor +import com.raizlabs.dbflow5.annotation.provider.ContentProvider +import com.raizlabs.dbflow5.config.FlowLog +import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.query.Operator +import com.raizlabs.dbflow5.query.OperatorGroup +import com.raizlabs.dbflow5.adapter.ModelAdapter +import com.raizlabs.dbflow5.database.DatabaseWrapper +import com.raizlabs.dbflow5.database.FlowCursor /** * Description: Provides handy wrapper mechanisms for [android.content.ContentProvider] diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/provider/ModelProvider.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/provider/ModelProvider.kt similarity index 88% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/provider/ModelProvider.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/provider/ModelProvider.kt index e920f646e..2b009a515 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/provider/ModelProvider.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/provider/ModelProvider.kt @@ -1,11 +1,11 @@ -package com.raizlabs.android.dbflow.provider +package com.raizlabs.dbflow5.provider import android.content.ContentResolver import android.net.Uri -import com.raizlabs.android.dbflow.query.Operator -import com.raizlabs.android.dbflow.query.OperatorGroup -import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.dbflow5.query.Operator +import com.raizlabs.dbflow5.query.OperatorGroup +import com.raizlabs.dbflow5.database.DatabaseWrapper /** * Description: A base interface for Models that are connected to providers. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Actionable.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Actionable.kt similarity index 55% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/Actionable.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/Actionable.kt index 6d173c715..46e6acb8c 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Actionable.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Actionable.kt @@ -1,6 +1,6 @@ -package com.raizlabs.android.dbflow.query +package com.raizlabs.dbflow5.query -import com.raizlabs.android.dbflow.structure.ChangeAction +import com.raizlabs.dbflow5.structure.ChangeAction /** * Description: Provides [Action] for SQL constructs. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/BaseModelQueriable.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseModelQueriable.kt similarity index 80% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/BaseModelQueriable.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseModelQueriable.kt index 55d719750..91920b49f 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/BaseModelQueriable.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseModelQueriable.kt @@ -1,15 +1,15 @@ -package com.raizlabs.android.dbflow.query +package com.raizlabs.dbflow5.query -import com.raizlabs.android.dbflow.config.FlowLog -import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.query.list.FlowCursorList -import com.raizlabs.android.dbflow.query.list.FlowQueryList -import com.raizlabs.android.dbflow.runtime.NotifyDistributor -import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.adapter.queriable.ListModelLoader -import com.raizlabs.android.dbflow.adapter.queriable.SingleModelLoader -import com.raizlabs.android.dbflow.adapter.InstanceAdapter -import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.dbflow5.config.FlowLog +import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.query.list.FlowCursorList +import com.raizlabs.dbflow5.query.list.FlowQueryList +import com.raizlabs.dbflow5.runtime.NotifyDistributor +import com.raizlabs.dbflow5.sql.Query +import com.raizlabs.dbflow5.adapter.queriable.ListModelLoader +import com.raizlabs.dbflow5.adapter.queriable.SingleModelLoader +import com.raizlabs.dbflow5.adapter.InstanceAdapter +import com.raizlabs.dbflow5.database.DatabaseWrapper /** * Description: Provides a base implementation of [ModelQueriable] to simplify a lot of code. It provides the diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/BaseOperator.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseOperator.kt similarity index 96% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/BaseOperator.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseOperator.kt index 604e52945..ad84ba6a5 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/BaseOperator.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseOperator.kt @@ -1,11 +1,11 @@ -package com.raizlabs.android.dbflow.query +package com.raizlabs.dbflow5.query import android.database.DatabaseUtils -import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.converter.TypeConverter -import com.raizlabs.android.dbflow.data.Blob -import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.byteArrayToHexString +import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.converter.TypeConverter +import com.raizlabs.dbflow5.data.Blob +import com.raizlabs.dbflow5.sql.Query +import com.raizlabs.dbflow5.byteArrayToHexString /** * Description: Base class for all kinds of [SQLOperator] diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/BaseQueriable.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseQueriable.kt similarity index 80% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/BaseQueriable.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseQueriable.kt index 69d90fb30..cef319dd4 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/BaseQueriable.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseQueriable.kt @@ -1,14 +1,14 @@ -package com.raizlabs.android.dbflow.query +package com.raizlabs.dbflow5.query import android.database.sqlite.SQLiteDoneException -import com.raizlabs.android.dbflow.config.FlowLog -import com.raizlabs.android.dbflow.runtime.NotifyDistributor -import com.raizlabs.android.dbflow.longForQuery -import com.raizlabs.android.dbflow.structure.ChangeAction -import com.raizlabs.android.dbflow.database.DatabaseStatement -import com.raizlabs.android.dbflow.database.DatabaseStatementWrapper -import com.raizlabs.android.dbflow.database.DatabaseWrapper -import com.raizlabs.android.dbflow.database.FlowCursor +import com.raizlabs.dbflow5.config.FlowLog +import com.raizlabs.dbflow5.runtime.NotifyDistributor +import com.raizlabs.dbflow5.longForQuery +import com.raizlabs.dbflow5.structure.ChangeAction +import com.raizlabs.dbflow5.database.DatabaseStatement +import com.raizlabs.dbflow5.database.DatabaseStatementWrapper +import com.raizlabs.dbflow5.database.DatabaseWrapper +import com.raizlabs.dbflow5.database.FlowCursor /** * Description: Base implementation of something that can be queried from the database. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/BaseTransformable.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseTransformable.kt similarity index 91% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/BaseTransformable.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseTransformable.kt index ef1cc8c86..c76d203a9 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/BaseTransformable.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseTransformable.kt @@ -1,8 +1,8 @@ -package com.raizlabs.android.dbflow.query +package com.raizlabs.dbflow5.query -import com.raizlabs.android.dbflow.query.property.IProperty -import com.raizlabs.android.dbflow.database.DatabaseWrapper -import com.raizlabs.android.dbflow.database.FlowCursor +import com.raizlabs.dbflow5.query.property.IProperty +import com.raizlabs.dbflow5.database.DatabaseWrapper +import com.raizlabs.dbflow5.database.FlowCursor /** * Description: Combines basic transformations and query ops into a base class. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Case.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Case.kt similarity index 93% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/Case.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/Case.kt index 6d069c280..662a18105 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Case.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Case.kt @@ -1,9 +1,9 @@ -package com.raizlabs.android.dbflow.query +package com.raizlabs.dbflow5.query -import com.raizlabs.android.dbflow.quoteIfNeeded -import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.query.property.IProperty -import com.raizlabs.android.dbflow.query.property.Property +import com.raizlabs.dbflow5.quoteIfNeeded +import com.raizlabs.dbflow5.sql.Query +import com.raizlabs.dbflow5.query.property.IProperty +import com.raizlabs.dbflow5.query.property.Property /** * Description: Represents a SQLITE CASE argument. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/CaseCondition.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/CaseCondition.kt similarity index 92% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/CaseCondition.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/CaseCondition.kt index f90511115..0a3ddc3bb 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/CaseCondition.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/CaseCondition.kt @@ -1,7 +1,7 @@ -package com.raizlabs.android.dbflow.query +package com.raizlabs.dbflow5.query -import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.query.property.IProperty +import com.raizlabs.dbflow5.sql.Query +import com.raizlabs.dbflow5.query.property.IProperty /** * Description: Represents an individual condition inside a CASE. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/CompletedTrigger.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/CompletedTrigger.kt similarity index 87% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/CompletedTrigger.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/CompletedTrigger.kt index 80b5d29e0..588ce7d24 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/CompletedTrigger.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/CompletedTrigger.kt @@ -1,8 +1,8 @@ -package com.raizlabs.android.dbflow.query +package com.raizlabs.dbflow5.query -import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.dropTrigger -import com.raizlabs.android.dbflow.sql.Query +import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.dropTrigger +import com.raizlabs.dbflow5.sql.Query /** * Description: The last piece of a TRIGGER statement, this class contains the BEGIN...END and the logic in between. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/ContentValuesListener.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/ContentValuesListener.kt similarity index 85% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/ContentValuesListener.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/ContentValuesListener.kt index 54121764e..dba6bdff0 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/ContentValuesListener.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/ContentValuesListener.kt @@ -1,10 +1,10 @@ -package com.raizlabs.android.dbflow.query +package com.raizlabs.dbflow5.query import android.content.ContentValues -import com.raizlabs.android.dbflow.annotation.provider.ContentProvider -import com.raizlabs.android.dbflow.structure.Model -import com.raizlabs.android.dbflow.adapter.ModelAdapter +import com.raizlabs.dbflow5.annotation.provider.ContentProvider +import com.raizlabs.dbflow5.structure.Model +import com.raizlabs.dbflow5.adapter.ModelAdapter /** * Description: Called after the declared [ContentValues] are binded. It enables diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/CursorResult.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/CursorResult.kt similarity index 92% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/CursorResult.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/CursorResult.kt index ecdd0fee2..e783c5505 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/CursorResult.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/CursorResult.kt @@ -1,12 +1,12 @@ -package com.raizlabs.android.dbflow.query +package com.raizlabs.dbflow5.query import android.database.Cursor -import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.query.list.FlowCursorIterator -import com.raizlabs.android.dbflow.query.list.IFlowCursorIterator -import com.raizlabs.android.dbflow.adapter.InstanceAdapter -import com.raizlabs.android.dbflow.database.DatabaseWrapper -import com.raizlabs.android.dbflow.database.FlowCursor +import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.query.list.FlowCursorIterator +import com.raizlabs.dbflow5.query.list.IFlowCursorIterator +import com.raizlabs.dbflow5.adapter.InstanceAdapter +import com.raizlabs.dbflow5.database.DatabaseWrapper +import com.raizlabs.dbflow5.database.FlowCursor /** * Description: A class that contains a [Cursor] and handy methods for retrieving data from it. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Delete.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Delete.kt similarity index 92% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/Delete.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/Delete.kt index fad1cf54b..43386cc92 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Delete.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Delete.kt @@ -1,7 +1,7 @@ -package com.raizlabs.android.dbflow.query +package com.raizlabs.dbflow5.query -import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.dbflow5.sql.Query +import com.raizlabs.dbflow5.database.DatabaseWrapper import kotlin.reflect.KClass /** diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/ExistenceOperator.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/ExistenceOperator.kt similarity index 87% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/ExistenceOperator.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/ExistenceOperator.kt index 1cebb82e2..ecf6f39b3 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/ExistenceOperator.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/ExistenceOperator.kt @@ -1,7 +1,7 @@ -package com.raizlabs.android.dbflow.query +package com.raizlabs.dbflow5.query -import com.raizlabs.android.dbflow.appendQualifier -import com.raizlabs.android.dbflow.sql.Query +import com.raizlabs.dbflow5.appendQualifier +import com.raizlabs.dbflow5.sql.Query /** * Description: The condition that represents EXISTS in a SQL statement. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/From.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/From.kt similarity index 94% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/From.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/From.kt index a1766093f..8a64d92ad 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/From.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/From.kt @@ -1,11 +1,11 @@ -package com.raizlabs.android.dbflow.query - -import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.query.Join.JoinType -import com.raizlabs.android.dbflow.query.property.IndexProperty -import com.raizlabs.android.dbflow.structure.ChangeAction -import com.raizlabs.android.dbflow.database.DatabaseWrapper +package com.raizlabs.dbflow5.query + +import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.sql.Query +import com.raizlabs.dbflow5.query.Join.JoinType +import com.raizlabs.dbflow5.query.property.IndexProperty +import com.raizlabs.dbflow5.structure.ChangeAction +import com.raizlabs.dbflow5.database.DatabaseWrapper import kotlin.collections.Set as KSet /** diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/IConditional.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/IConditional.kt similarity index 97% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/IConditional.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/IConditional.kt index ce5bd076a..f2148003d 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/IConditional.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/IConditional.kt @@ -1,6 +1,6 @@ -package com.raizlabs.android.dbflow.query +package com.raizlabs.dbflow5.query -import com.raizlabs.android.dbflow.sql.Query +import com.raizlabs.dbflow5.sql.Query /** * Description: Simple interface for objects that can be used as [Operator]. This class diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/IOperator.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/IOperator.kt similarity index 98% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/IOperator.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/IOperator.kt index c6b2bb9fa..a03ef8b20 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/IOperator.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/IOperator.kt @@ -1,6 +1,6 @@ -package com.raizlabs.android.dbflow.query +package com.raizlabs.dbflow5.query -import com.raizlabs.android.dbflow.sql.Query +import com.raizlabs.dbflow5.sql.Query /** * Description: Interface for objects that can be used as [Operator] that have a type parameter. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Index.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Index.kt similarity index 90% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/Index.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/Index.kt index f8e19c59f..d825ae7c9 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Index.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Index.kt @@ -1,12 +1,12 @@ -package com.raizlabs.android.dbflow.query +package com.raizlabs.dbflow5.query -import com.raizlabs.android.dbflow.appendList -import com.raizlabs.android.dbflow.appendQuotedIfNeeded -import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.dropIndex -import com.raizlabs.android.dbflow.query.property.IProperty -import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.dbflow5.appendList +import com.raizlabs.dbflow5.appendQuotedIfNeeded +import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.sql.Query +import com.raizlabs.dbflow5.dropIndex +import com.raizlabs.dbflow5.query.property.IProperty +import com.raizlabs.dbflow5.database.DatabaseWrapper /** * Description: an INDEX class that enables you to index a specific column from a table. This enables diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/IndexedBy.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/IndexedBy.kt similarity index 76% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/IndexedBy.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/IndexedBy.kt index 81224b41e..7452cedba 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/IndexedBy.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/IndexedBy.kt @@ -1,9 +1,9 @@ -package com.raizlabs.android.dbflow.query +package com.raizlabs.dbflow5.query -import com.raizlabs.android.dbflow.quoteIfNeeded -import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.query.property.IndexProperty -import com.raizlabs.android.dbflow.structure.ChangeAction +import com.raizlabs.dbflow5.quoteIfNeeded +import com.raizlabs.dbflow5.sql.Query +import com.raizlabs.dbflow5.query.property.IndexProperty +import com.raizlabs.dbflow5.structure.ChangeAction /** * Description: The INDEXED BY part of a SELECT/UPDATE/DELETE diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Insert.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Insert.kt similarity index 95% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/Insert.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/Insert.kt index 94ebb67dd..ed8babd61 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Insert.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Insert.kt @@ -1,13 +1,13 @@ -package com.raizlabs.android.dbflow.query +package com.raizlabs.dbflow5.query import android.content.ContentValues -import com.raizlabs.android.dbflow.annotation.ConflictAction -import com.raizlabs.android.dbflow.appendArray -import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.query.property.IProperty -import com.raizlabs.android.dbflow.structure.ChangeAction -import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.dbflow5.annotation.ConflictAction +import com.raizlabs.dbflow5.appendArray +import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.sql.Query +import com.raizlabs.dbflow5.query.property.IProperty +import com.raizlabs.dbflow5.structure.ChangeAction +import com.raizlabs.dbflow5.database.DatabaseWrapper /** * Description: The SQLite INSERT command diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Join.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Join.kt similarity index 94% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/Join.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/Join.kt index 7c4e42112..30de53461 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Join.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Join.kt @@ -1,10 +1,10 @@ -package com.raizlabs.android.dbflow.query +package com.raizlabs.dbflow5.query -import com.raizlabs.android.dbflow.appendList -import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.query.property.IProperty -import com.raizlabs.android.dbflow.query.property.PropertyFactory -import com.raizlabs.android.dbflow.sql.Query +import com.raizlabs.dbflow5.appendList +import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.query.property.IProperty +import com.raizlabs.dbflow5.query.property.PropertyFactory +import com.raizlabs.dbflow5.sql.Query import kotlin.reflect.KClass /** diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/LoadFromCursorListener.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/LoadFromCursorListener.kt similarity index 79% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/LoadFromCursorListener.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/LoadFromCursorListener.kt index bcdf83fde..27f111279 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/LoadFromCursorListener.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/LoadFromCursorListener.kt @@ -1,8 +1,8 @@ -package com.raizlabs.android.dbflow.query +package com.raizlabs.dbflow5.query import android.database.Cursor -import com.raizlabs.android.dbflow.structure.Model +import com.raizlabs.dbflow5.structure.Model /** * Description: Marks a [Model] as listening to [Cursor] diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Method.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Method.kt similarity index 96% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/Method.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/Method.kt index 1deb0fc30..d85f2d902 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Method.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Method.kt @@ -1,10 +1,10 @@ -package com.raizlabs.android.dbflow.query +package com.raizlabs.dbflow5.query -import com.raizlabs.android.dbflow.query.property.IProperty -import com.raizlabs.android.dbflow.query.property.Property -import com.raizlabs.android.dbflow.query.property.PropertyFactory -import com.raizlabs.android.dbflow.sql.SQLiteType +import com.raizlabs.dbflow5.query.property.IProperty +import com.raizlabs.dbflow5.query.property.Property +import com.raizlabs.dbflow5.query.property.PropertyFactory +import com.raizlabs.dbflow5.sql.SQLiteType /** * Represents SQLite methods on columns. These act as [Property] so we can use them in complex diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/ModelQueriable.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/ModelQueriable.kt similarity index 91% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/ModelQueriable.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/ModelQueriable.kt index 297262f39..a228c1aea 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/ModelQueriable.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/ModelQueriable.kt @@ -1,9 +1,9 @@ -package com.raizlabs.android.dbflow.query +package com.raizlabs.dbflow5.query import android.database.Cursor -import com.raizlabs.android.dbflow.query.list.FlowCursorList -import com.raizlabs.android.dbflow.query.list.FlowQueryList -import com.raizlabs.android.dbflow.structure.BaseQueryModel +import com.raizlabs.dbflow5.query.list.FlowCursorList +import com.raizlabs.dbflow5.query.list.FlowQueryList +import com.raizlabs.dbflow5.structure.BaseQueryModel /** * Description: An interface for query objects to enable you to query from the database in a structured way. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/NameAlias.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/NameAlias.kt similarity index 97% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/NameAlias.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/NameAlias.kt index 018aa56b8..cba8741b1 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/NameAlias.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/NameAlias.kt @@ -1,9 +1,9 @@ -package com.raizlabs.android.dbflow.query +package com.raizlabs.dbflow5.query -import com.raizlabs.android.dbflow.isNotNullOrEmpty -import com.raizlabs.android.dbflow.quoteIfNeeded -import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.stripQuotes +import com.raizlabs.dbflow5.isNotNullOrEmpty +import com.raizlabs.dbflow5.quoteIfNeeded +import com.raizlabs.dbflow5.sql.Query +import com.raizlabs.dbflow5.stripQuotes /** * Description: Rewritten from the ground up, this class makes it easier to build an alias. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Operator.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Operator.kt similarity index 98% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/Operator.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/Operator.kt index a26de9464..cf1830296 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Operator.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Operator.kt @@ -1,14 +1,14 @@ @file:Suppress("UNCHECKED_CAST") -package com.raizlabs.android.dbflow.query - -import com.raizlabs.android.dbflow.annotation.Collate -import com.raizlabs.android.dbflow.appendOptional -import com.raizlabs.android.dbflow.config.FlowLog -import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.converter.TypeConverter -import com.raizlabs.android.dbflow.query.property.Property -import com.raizlabs.android.dbflow.sql.Query +package com.raizlabs.dbflow5.query + +import com.raizlabs.dbflow5.annotation.Collate +import com.raizlabs.dbflow5.appendOptional +import com.raizlabs.dbflow5.config.FlowLog +import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.converter.TypeConverter +import com.raizlabs.dbflow5.query.property.Property +import com.raizlabs.dbflow5.sql.Query /** * Description: The class that contains a column name, Operator, and value. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/OperatorGroup.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/OperatorGroup.kt similarity index 97% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/OperatorGroup.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/OperatorGroup.kt index 600409d46..1cf8e4243 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/OperatorGroup.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/OperatorGroup.kt @@ -1,7 +1,7 @@ -package com.raizlabs.android.dbflow.query +package com.raizlabs.dbflow5.query -import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.query.Operator.Operation +import com.raizlabs.dbflow5.sql.Query +import com.raizlabs.dbflow5.query.Operator.Operation /** * Allows combining of [SQLOperator] into one condition. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/OrderBy.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/OrderBy.kt similarity index 89% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/OrderBy.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/OrderBy.kt index 120cf57b1..be1833bd1 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/OrderBy.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/OrderBy.kt @@ -1,8 +1,8 @@ -package com.raizlabs.android.dbflow.query +package com.raizlabs.dbflow5.query -import com.raizlabs.android.dbflow.annotation.Collate -import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.query.property.IProperty +import com.raizlabs.dbflow5.annotation.Collate +import com.raizlabs.dbflow5.sql.Query +import com.raizlabs.dbflow5.query.property.IProperty /** * Description: Class that represents a SQL order-by. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Queriable.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Queriable.kt similarity index 81% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/Queriable.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/Queriable.kt index 1a71b2890..e89e573a7 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Queriable.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Queriable.kt @@ -1,10 +1,10 @@ -package com.raizlabs.android.dbflow.query +package com.raizlabs.dbflow5.query -import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.structure.ChangeAction -import com.raizlabs.android.dbflow.structure.Model -import com.raizlabs.android.dbflow.database.DatabaseStatement -import com.raizlabs.android.dbflow.database.FlowCursor +import com.raizlabs.dbflow5.sql.Query +import com.raizlabs.dbflow5.structure.ChangeAction +import com.raizlabs.dbflow5.structure.Model +import com.raizlabs.dbflow5.database.DatabaseStatement +import com.raizlabs.dbflow5.database.FlowCursor /** * Description: The most basic interface that some of the classes such as [Insert], [ModelQueriable], diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/SQLOperator.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/SQLOperator.kt similarity index 96% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/SQLOperator.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/SQLOperator.kt index df1843055..2a628afd6 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/SQLOperator.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/SQLOperator.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.query +package com.raizlabs.dbflow5.query /** * Description: Basic interface for all of the Operator classes. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/SQLite.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/SQLite.kt similarity index 92% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/SQLite.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/SQLite.kt index 93c3e4736..ca08b6cf8 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/SQLite.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/SQLite.kt @@ -1,12 +1,12 @@ @file:JvmName("SQLite") -package com.raizlabs.android.dbflow.query +package com.raizlabs.dbflow5.query -import com.raizlabs.android.dbflow.query.property.IProperty -import com.raizlabs.android.dbflow.query.property.Property -import com.raizlabs.android.dbflow.structure.Model -import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.dbflow5.query.property.IProperty +import com.raizlabs.dbflow5.query.property.Property +import com.raizlabs.dbflow5.structure.Model +import com.raizlabs.dbflow5.database.DatabaseWrapper import kotlin.reflect.KClass diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/SQLiteStatementListener.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/SQLiteStatementListener.kt similarity index 80% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/SQLiteStatementListener.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/SQLiteStatementListener.kt index 6ec7a21b4..07f1eab14 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/SQLiteStatementListener.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/SQLiteStatementListener.kt @@ -1,9 +1,9 @@ -package com.raizlabs.android.dbflow.query +package com.raizlabs.dbflow5.query -import com.raizlabs.android.dbflow.adapter.InternalAdapter -import com.raizlabs.android.dbflow.structure.Model -import com.raizlabs.android.dbflow.adapter.ModelAdapter -import com.raizlabs.android.dbflow.database.DatabaseStatement +import com.raizlabs.dbflow5.adapter.InternalAdapter +import com.raizlabs.dbflow5.structure.Model +import com.raizlabs.dbflow5.adapter.ModelAdapter +import com.raizlabs.dbflow5.database.DatabaseStatement /** * Description: Marks a [Model] as subscribing to the [DatabaseStatement] diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Select.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Select.kt similarity index 91% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/Select.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/Select.kt index d416f60ca..d957dc714 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Select.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Select.kt @@ -1,9 +1,9 @@ -package com.raizlabs.android.dbflow.query +package com.raizlabs.dbflow5.query -import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.query.property.IProperty -import com.raizlabs.android.dbflow.query.property.Property -import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.dbflow5.sql.Query +import com.raizlabs.dbflow5.query.property.IProperty +import com.raizlabs.dbflow5.query.property.Property +import com.raizlabs.dbflow5.database.DatabaseWrapper import kotlin.reflect.KClass /** diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Set.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Set.kt similarity index 83% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/Set.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/Set.kt index 3e7345d2f..96f6769f6 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Set.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Set.kt @@ -1,10 +1,10 @@ -package com.raizlabs.android.dbflow.query +package com.raizlabs.dbflow5.query import android.content.ContentValues -import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.addContentValues -import com.raizlabs.android.dbflow.structure.ChangeAction -import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.dbflow5.sql.Query +import com.raizlabs.dbflow5.addContentValues +import com.raizlabs.dbflow5.structure.ChangeAction +import com.raizlabs.dbflow5.database.DatabaseWrapper /** * Description: Used to specify the SET part of an [com.raizlabs.android.dbflow.sql.language.Update] query. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/StringQuery.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/StringQuery.kt similarity index 81% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/StringQuery.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/StringQuery.kt index ff4fd1320..c604a58f0 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/StringQuery.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/StringQuery.kt @@ -1,10 +1,10 @@ -package com.raizlabs.android.dbflow.query +package com.raizlabs.dbflow5.query import android.database.sqlite.SQLiteDatabase -import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.structure.ChangeAction -import com.raizlabs.android.dbflow.database.DatabaseWrapper -import com.raizlabs.android.dbflow.database.FlowCursor +import com.raizlabs.dbflow5.sql.Query +import com.raizlabs.dbflow5.structure.ChangeAction +import com.raizlabs.dbflow5.database.DatabaseWrapper +import com.raizlabs.dbflow5.database.FlowCursor /** * Description: Provides a very basic query mechanism for strings. Allows you to easily perform custom SQL query string diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Transformable.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Transformable.kt similarity index 90% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/Transformable.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/Transformable.kt index 810c8ccd1..dc74dcd0b 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Transformable.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Transformable.kt @@ -1,6 +1,6 @@ -package com.raizlabs.android.dbflow.query +package com.raizlabs.dbflow5.query -import com.raizlabs.android.dbflow.query.property.IProperty +import com.raizlabs.dbflow5.query.property.IProperty /** * Description: Provides a standard set of methods for ending a SQLite query method. These include diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Trigger.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Trigger.kt similarity index 93% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/Trigger.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/Trigger.kt index 9a59d45d7..a0445ebb6 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Trigger.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Trigger.kt @@ -1,9 +1,9 @@ -package com.raizlabs.android.dbflow.query +package com.raizlabs.dbflow5.query -import com.raizlabs.android.dbflow.appendOptional -import com.raizlabs.android.dbflow.appendQuotedIfNeeded -import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.query.property.IProperty +import com.raizlabs.dbflow5.appendOptional +import com.raizlabs.dbflow5.appendQuotedIfNeeded +import com.raizlabs.dbflow5.sql.Query +import com.raizlabs.dbflow5.query.property.IProperty import kotlin.reflect.KClass /** diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/TriggerMethod.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/TriggerMethod.kt similarity index 90% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/TriggerMethod.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/TriggerMethod.kt index db2fcdf64..255c2c113 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/TriggerMethod.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/TriggerMethod.kt @@ -1,9 +1,9 @@ -package com.raizlabs.android.dbflow.query +package com.raizlabs.dbflow5.query -import com.raizlabs.android.dbflow.appendArray -import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.query.property.IProperty +import com.raizlabs.dbflow5.appendArray +import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.sql.Query +import com.raizlabs.dbflow5.query.property.IProperty /** * Description: Describes the method that the trigger uses. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/UnSafeStringOperator.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/UnSafeStringOperator.kt similarity index 89% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/UnSafeStringOperator.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/UnSafeStringOperator.kt index b3ca07c42..b70770a3b 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/UnSafeStringOperator.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/UnSafeStringOperator.kt @@ -1,7 +1,7 @@ -package com.raizlabs.android.dbflow.query +package com.raizlabs.dbflow5.query -import com.raizlabs.android.dbflow.isNotNullOrEmpty -import com.raizlabs.android.dbflow.sql.Query +import com.raizlabs.dbflow5.isNotNullOrEmpty +import com.raizlabs.dbflow5.sql.Query /** * Description: This class will use a String to describe its condition. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Update.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Update.kt similarity index 89% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/Update.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/Update.kt index 6028b16c6..f96f0b1dd 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Update.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Update.kt @@ -1,9 +1,9 @@ -package com.raizlabs.android.dbflow.query +package com.raizlabs.dbflow5.query -import com.raizlabs.android.dbflow.annotation.ConflictAction -import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.dbflow5.annotation.ConflictAction +import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.sql.Query +import com.raizlabs.dbflow5.database.DatabaseWrapper /** * Description: The SQLite UPDATE query. Will update rows in the DB. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Where.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Where.kt similarity index 94% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/Where.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/Where.kt index 4c7a09743..b1c00b2f6 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/Where.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Where.kt @@ -1,11 +1,11 @@ -package com.raizlabs.android.dbflow.query +package com.raizlabs.dbflow5.query import android.database.Cursor -import com.raizlabs.android.dbflow.annotation.provider.ContentProvider -import com.raizlabs.android.dbflow.appendQualifier -import com.raizlabs.android.dbflow.database.FlowCursor -import com.raizlabs.android.dbflow.query.property.IProperty -import com.raizlabs.android.dbflow.structure.ChangeAction +import com.raizlabs.dbflow5.annotation.provider.ContentProvider +import com.raizlabs.dbflow5.appendQualifier +import com.raizlabs.dbflow5.database.FlowCursor +import com.raizlabs.dbflow5.query.property.IProperty +import com.raizlabs.dbflow5.structure.ChangeAction /** * Description: Defines the SQL WHERE statement of the query. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/WhereBase.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/WhereBase.kt similarity index 69% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/WhereBase.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/WhereBase.kt index 8662b8c96..cd2460a66 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/WhereBase.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/WhereBase.kt @@ -1,7 +1,7 @@ -package com.raizlabs.android.dbflow.query +package com.raizlabs.dbflow5.query -import com.raizlabs.android.dbflow.sql.Query -import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.dbflow5.sql.Query +import com.raizlabs.dbflow5.database.DatabaseWrapper /** * Description: The base for a [Where] statement. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/cache/IMultiKeyCacheConverter.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/cache/IMultiKeyCacheConverter.kt similarity index 86% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/cache/IMultiKeyCacheConverter.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/cache/IMultiKeyCacheConverter.kt index 17d5c7b4a..d1984249a 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/cache/IMultiKeyCacheConverter.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/cache/IMultiKeyCacheConverter.kt @@ -1,6 +1,6 @@ -package com.raizlabs.android.dbflow.query.cache +package com.raizlabs.dbflow5.query.cache -import com.raizlabs.android.dbflow.structure.Model +import com.raizlabs.dbflow5.structure.Model /** * Description: This interface allows for [Model] to have multiple primary keys in a cache. This diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/cache/ModelCache.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/cache/ModelCache.kt similarity index 89% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/cache/ModelCache.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/cache/ModelCache.kt index 81fc6fde3..f6f0635e0 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/cache/ModelCache.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/cache/ModelCache.kt @@ -1,8 +1,8 @@ -package com.raizlabs.android.dbflow.query.cache +package com.raizlabs.dbflow5.query.cache -import com.raizlabs.android.dbflow.adapter.ModelAdapter -import com.raizlabs.android.dbflow.database.DatabaseWrapper -import com.raizlabs.android.dbflow.database.FlowCursor +import com.raizlabs.dbflow5.adapter.ModelAdapter +import com.raizlabs.dbflow5.database.DatabaseWrapper +import com.raizlabs.dbflow5.database.FlowCursor /** * Description: A generic cache for models that is implemented or can be implemented to your liking. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/cache/ModelLruCache.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/cache/ModelLruCache.kt similarity index 94% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/cache/ModelLruCache.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/cache/ModelLruCache.kt index b233f4040..0f5811c52 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/cache/ModelLruCache.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/cache/ModelLruCache.kt @@ -1,7 +1,7 @@ -package com.raizlabs.android.dbflow.query.cache +package com.raizlabs.dbflow5.query.cache import android.util.LruCache -import com.raizlabs.android.dbflow.annotation.DEFAULT_CACHE_SIZE +import com.raizlabs.dbflow5.annotation.DEFAULT_CACHE_SIZE /** * Description: Provides an [android.util.LruCache] under its hood diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/cache/SimpleMapCache.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/cache/SimpleMapCache.kt similarity index 87% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/cache/SimpleMapCache.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/cache/SimpleMapCache.kt index d8fcd55fe..68433c180 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/cache/SimpleMapCache.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/cache/SimpleMapCache.kt @@ -1,7 +1,7 @@ -package com.raizlabs.android.dbflow.query.cache +package com.raizlabs.dbflow5.query.cache -import com.raizlabs.android.dbflow.config.FlowLog -import com.raizlabs.android.dbflow.structure.Model +import com.raizlabs.dbflow5.config.FlowLog +import com.raizlabs.dbflow5.structure.Model import java.util.* /** diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/cache/SparseArrayBasedCache.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/cache/SparseArrayBasedCache.kt similarity index 95% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/cache/SparseArrayBasedCache.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/cache/SparseArrayBasedCache.kt index 6ea513f7e..c231cc585 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/cache/SparseArrayBasedCache.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/cache/SparseArrayBasedCache.kt @@ -1,8 +1,8 @@ -package com.raizlabs.android.dbflow.query.cache +package com.raizlabs.dbflow5.query.cache import android.util.SparseArray -import com.raizlabs.android.dbflow.config.FlowLog +import com.raizlabs.dbflow5.config.FlowLog /** * Description: A cache backed by a [android.util.SparseArray] diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/list/FlowCursorIterator.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowCursorIterator.kt similarity index 97% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/list/FlowCursorIterator.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowCursorIterator.kt index 280915d9f..1ae1fbfb1 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/list/FlowCursorIterator.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowCursorIterator.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.query.list +package com.raizlabs.dbflow5.query.list import java.util.* diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/list/FlowCursorList.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowCursorList.kt similarity index 94% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/list/FlowCursorList.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowCursorList.kt index 2677400d1..6c56a90b8 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/list/FlowCursorList.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowCursorList.kt @@ -1,12 +1,12 @@ -package com.raizlabs.android.dbflow.query.list +package com.raizlabs.dbflow5.query.list import android.database.Cursor import android.widget.ListView -import com.raizlabs.android.dbflow.config.FlowLog -import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.query.ModelQueriable -import com.raizlabs.android.dbflow.adapter.InstanceAdapter -import com.raizlabs.android.dbflow.database.FlowCursor +import com.raizlabs.dbflow5.config.FlowLog +import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.query.ModelQueriable +import com.raizlabs.dbflow5.adapter.InstanceAdapter +import com.raizlabs.dbflow5.database.FlowCursor /** * Description: A non-modifiable, cursor-backed list that you can use in [ListView] or other data sources. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/list/FlowQueryList.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowQueryList.kt similarity index 94% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/list/FlowQueryList.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowQueryList.kt index d8e94bc32..c1df2c309 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/list/FlowQueryList.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowQueryList.kt @@ -1,13 +1,13 @@ -package com.raizlabs.android.dbflow.query.list +package com.raizlabs.dbflow5.query.list import android.database.Cursor import android.os.Handler import android.os.Looper -import com.raizlabs.android.dbflow.query.list.FlowCursorList.OnCursorRefreshListener -import com.raizlabs.android.dbflow.query.ModelQueriable -import com.raizlabs.android.dbflow.adapter.InstanceAdapter -import com.raizlabs.android.dbflow.transaction.DefaultTransactionQueue -import com.raizlabs.android.dbflow.transaction.Transaction +import com.raizlabs.dbflow5.query.list.FlowCursorList.OnCursorRefreshListener +import com.raizlabs.dbflow5.query.ModelQueriable +import com.raizlabs.dbflow5.adapter.InstanceAdapter +import com.raizlabs.dbflow5.transaction.DefaultTransactionQueue +import com.raizlabs.dbflow5.transaction.Transaction /** * Description: Operates very similiar to a [java.util.List] except its backed by a table cursor. All of diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/list/IFlowCursorIterator.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/IFlowCursorIterator.kt similarity index 95% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/list/IFlowCursorIterator.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/list/IFlowCursorIterator.kt index fc0e22967..c28237cf0 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/list/IFlowCursorIterator.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/IFlowCursorIterator.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.query.list +package com.raizlabs.dbflow5.query.list import android.database.Cursor diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/property/IProperty.java b/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/IProperty.java similarity index 90% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/property/IProperty.java rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/property/IProperty.java index 3dd125baf..924f0c702 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/property/IProperty.java +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/IProperty.java @@ -1,14 +1,14 @@ -package com.raizlabs.android.dbflow.query.property; +package com.raizlabs.dbflow5.query.property; import android.support.annotation.NonNull; import android.support.annotation.Nullable; -import com.raizlabs.android.dbflow.sql.Query; -import com.raizlabs.android.dbflow.query.Join; -import com.raizlabs.android.dbflow.query.Method; -import com.raizlabs.android.dbflow.query.NameAlias; -import com.raizlabs.android.dbflow.query.OrderBy; -import com.raizlabs.android.dbflow.structure.Model; +import com.raizlabs.dbflow5.sql.Query; +import com.raizlabs.dbflow5.query.Join; +import com.raizlabs.dbflow5.query.Method; +import com.raizlabs.dbflow5.query.NameAlias; +import com.raizlabs.dbflow5.query.OrderBy; +import com.raizlabs.dbflow5.structure.Model; /** * Description: Defines the base interface all property classes implement. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/property/IndexProperty.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/IndexProperty.kt similarity index 78% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/property/IndexProperty.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/property/IndexProperty.kt index dfc86b514..b53600367 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/property/IndexProperty.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/IndexProperty.kt @@ -1,9 +1,9 @@ -package com.raizlabs.android.dbflow.query.property +package com.raizlabs.dbflow5.query.property -import com.raizlabs.android.dbflow.annotation.Table -import com.raizlabs.android.dbflow.quoteIfNeeded -import com.raizlabs.android.dbflow.query.Index -import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.dbflow5.annotation.Table +import com.raizlabs.dbflow5.quoteIfNeeded +import com.raizlabs.dbflow5.query.Index +import com.raizlabs.dbflow5.database.DatabaseWrapper /** * Description: Defines an INDEX in Sqlite. It basically speeds up data retrieval over large datasets. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/property/Property.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/Property.kt similarity index 96% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/property/Property.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/property/Property.kt index e31702bc9..61a23c1b9 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/property/Property.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/Property.kt @@ -1,12 +1,12 @@ -package com.raizlabs.android.dbflow.query.property - -import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.query.BaseModelQueriable -import com.raizlabs.android.dbflow.query.IConditional -import com.raizlabs.android.dbflow.query.IOperator -import com.raizlabs.android.dbflow.query.NameAlias -import com.raizlabs.android.dbflow.query.Operator -import com.raizlabs.android.dbflow.query.OrderBy +package com.raizlabs.dbflow5.query.property + +import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.query.BaseModelQueriable +import com.raizlabs.dbflow5.query.IConditional +import com.raizlabs.dbflow5.query.IOperator +import com.raizlabs.dbflow5.query.NameAlias +import com.raizlabs.dbflow5.query.Operator +import com.raizlabs.dbflow5.query.OrderBy /** * Description: The main, immutable property class that gets generated from a table definition. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/property/PropertyFactory.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/PropertyFactory.kt similarity index 95% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/property/PropertyFactory.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/property/PropertyFactory.kt index 9020d6025..06579b54a 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/property/PropertyFactory.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/PropertyFactory.kt @@ -1,8 +1,8 @@ -package com.raizlabs.android.dbflow.query.property +package com.raizlabs.dbflow5.query.property -import com.raizlabs.android.dbflow.query.NameAlias -import com.raizlabs.android.dbflow.query.Operator -import com.raizlabs.android.dbflow.query.ModelQueriable +import com.raizlabs.dbflow5.query.NameAlias +import com.raizlabs.dbflow5.query.Operator +import com.raizlabs.dbflow5.query.ModelQueriable import kotlin.reflect.KClass /** diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/property/TypeConvertedProperty.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/TypeConvertedProperty.kt similarity index 89% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/property/TypeConvertedProperty.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/property/TypeConvertedProperty.kt index b1fa3f742..bb4576491 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/property/TypeConvertedProperty.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/TypeConvertedProperty.kt @@ -1,9 +1,9 @@ -package com.raizlabs.android.dbflow.query.property +package com.raizlabs.dbflow5.query.property -import com.raizlabs.android.dbflow.converter.TypeConverter -import com.raizlabs.android.dbflow.query.NameAlias -import com.raizlabs.android.dbflow.query.Operator -import com.raizlabs.android.dbflow.adapter.ModelAdapter +import com.raizlabs.dbflow5.converter.TypeConverter +import com.raizlabs.dbflow5.query.NameAlias +import com.raizlabs.dbflow5.query.Operator +import com.raizlabs.dbflow5.adapter.ModelAdapter /** * Description: Provides convenience methods for [TypeConverter] when constructing queries. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/property/WrapperProperty.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/WrapperProperty.kt similarity index 88% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/query/property/WrapperProperty.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/query/property/WrapperProperty.kt index 2b002e207..1c9c142a8 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/query/property/WrapperProperty.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/WrapperProperty.kt @@ -1,6 +1,6 @@ -package com.raizlabs.android.dbflow.query.property +package com.raizlabs.dbflow5.query.property -import com.raizlabs.android.dbflow.query.NameAlias +import com.raizlabs.dbflow5.query.NameAlias /** * Description: Provides convenience for types that are represented in different ways in the DB. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ContentResolverNotifier.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/ContentResolverNotifier.kt similarity index 89% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ContentResolverNotifier.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/runtime/ContentResolverNotifier.kt index eba5f6184..cb68f6abb 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ContentResolverNotifier.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/ContentResolverNotifier.kt @@ -1,12 +1,12 @@ -package com.raizlabs.android.dbflow.runtime +package com.raizlabs.dbflow5.runtime import android.content.ContentResolver -import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.getNotificationUri -import com.raizlabs.android.dbflow.query.SQLOperator -import com.raizlabs.android.dbflow.structure.ChangeAction -import com.raizlabs.android.dbflow.adapter.ModelAdapter +import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.getNotificationUri +import com.raizlabs.dbflow5.query.SQLOperator +import com.raizlabs.dbflow5.structure.ChangeAction +import com.raizlabs.dbflow5.adapter.ModelAdapter /** * The default use case, it notifies via the [ContentResolver] system. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DBBatchSaveQueue.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/DBBatchSaveQueue.kt similarity index 92% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DBBatchSaveQueue.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/runtime/DBBatchSaveQueue.kt index a86352d0f..a704eb0e2 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DBBatchSaveQueue.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/DBBatchSaveQueue.kt @@ -1,15 +1,15 @@ -package com.raizlabs.android.dbflow.runtime +package com.raizlabs.dbflow5.runtime import android.os.Looper -import com.raizlabs.android.dbflow.config.DatabaseDefinition -import com.raizlabs.android.dbflow.config.FlowLog -import com.raizlabs.android.dbflow.structure.Model -import com.raizlabs.android.dbflow.structure.save -import com.raizlabs.android.dbflow.transaction.ProcessModelTransaction -import com.raizlabs.android.dbflow.transaction.Transaction -import com.raizlabs.android.dbflow.transaction.processModel -import com.raizlabs.android.dbflow.transaction.transactionError -import com.raizlabs.android.dbflow.transaction.transactionSuccess +import com.raizlabs.dbflow5.config.DatabaseDefinition +import com.raizlabs.dbflow5.config.FlowLog +import com.raizlabs.dbflow5.structure.Model +import com.raizlabs.dbflow5.structure.save +import com.raizlabs.dbflow5.transaction.ProcessModelTransaction +import com.raizlabs.dbflow5.transaction.Transaction +import com.raizlabs.dbflow5.transaction.processModel +import com.raizlabs.dbflow5.transaction.transactionError +import com.raizlabs.dbflow5.transaction.transactionSuccess /** * Description: This queue will bulk save items added to it when it gets access to the DB. It should only exist as one entity. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DirectModelNotifier.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/DirectModelNotifier.kt similarity index 95% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DirectModelNotifier.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/runtime/DirectModelNotifier.kt index 9d323b966..9e75a1d8e 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/DirectModelNotifier.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/DirectModelNotifier.kt @@ -1,8 +1,8 @@ -package com.raizlabs.android.dbflow.runtime +package com.raizlabs.dbflow5.runtime -import com.raizlabs.android.dbflow.adapter.ModelAdapter -import com.raizlabs.android.dbflow.config.DatabaseConfig -import com.raizlabs.android.dbflow.structure.ChangeAction +import com.raizlabs.dbflow5.adapter.ModelAdapter +import com.raizlabs.dbflow5.config.DatabaseConfig +import com.raizlabs.dbflow5.structure.ChangeAction /** * Description: Directly notifies about model changes. Users should use [.get] to use the shared diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/FlowContentObserver.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/FlowContentObserver.kt similarity index 94% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/FlowContentObserver.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/runtime/FlowContentObserver.kt index 874349c71..d92305f16 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/FlowContentObserver.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/FlowContentObserver.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.runtime +package com.raizlabs.dbflow5.runtime import android.annotation.TargetApi import android.content.ContentResolver @@ -8,15 +8,15 @@ import android.net.Uri import android.os.Build import android.os.Build.VERSION_CODES import android.os.Handler -import com.raizlabs.android.dbflow.config.DatabaseConfig -import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.TABLE_QUERY_PARAM -import com.raizlabs.android.dbflow.getNotificationUri -import com.raizlabs.android.dbflow.query.NameAlias -import com.raizlabs.android.dbflow.query.Operator -import com.raizlabs.android.dbflow.query.SQLOperator -import com.raizlabs.android.dbflow.structure.ChangeAction -import com.raizlabs.android.dbflow.structure.Model +import com.raizlabs.dbflow5.config.DatabaseConfig +import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.TABLE_QUERY_PARAM +import com.raizlabs.dbflow5.getNotificationUri +import com.raizlabs.dbflow5.query.NameAlias +import com.raizlabs.dbflow5.query.Operator +import com.raizlabs.dbflow5.query.SQLOperator +import com.raizlabs.dbflow5.structure.ChangeAction +import com.raizlabs.dbflow5.structure.Model import java.util.concurrent.CopyOnWriteArraySet import java.util.concurrent.atomic.AtomicInteger @@ -272,7 +272,7 @@ open class FlowContentObserver(private val contentAuthority: String, * an observer (appears to be) is not registered. */ fun setShouldForceNotify(forceNotify: Boolean) { - FlowContentObserver.forceNotify = forceNotify + Companion.forceNotify = forceNotify } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ModelNotifier.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/ModelNotifier.kt similarity index 66% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ModelNotifier.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/runtime/ModelNotifier.kt index 76fbf86f9..af926d21b 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/ModelNotifier.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/ModelNotifier.kt @@ -1,7 +1,7 @@ -package com.raizlabs.android.dbflow.runtime +package com.raizlabs.dbflow5.runtime -import com.raizlabs.android.dbflow.structure.ChangeAction -import com.raizlabs.android.dbflow.adapter.ModelAdapter +import com.raizlabs.dbflow5.structure.ChangeAction +import com.raizlabs.dbflow5.adapter.ModelAdapter /** * Interface for defining how we notify model changes. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/NotifyDistributor.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/NotifyDistributor.kt similarity index 83% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/NotifyDistributor.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/runtime/NotifyDistributor.kt index 365b8ffbf..1aad1221a 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/NotifyDistributor.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/NotifyDistributor.kt @@ -1,8 +1,8 @@ -package com.raizlabs.android.dbflow.runtime +package com.raizlabs.dbflow5.runtime -import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.structure.ChangeAction -import com.raizlabs.android.dbflow.adapter.ModelAdapter +import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.structure.ChangeAction +import com.raizlabs.dbflow5.adapter.ModelAdapter /** * Description: Distributes notifications to the [ModelNotifier]. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/OnTableChangedListener.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/OnTableChangedListener.kt similarity index 80% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/OnTableChangedListener.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/runtime/OnTableChangedListener.kt index be88ef2ac..15e793d56 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/OnTableChangedListener.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/OnTableChangedListener.kt @@ -1,8 +1,8 @@ -package com.raizlabs.android.dbflow.runtime +package com.raizlabs.dbflow5.runtime import android.os.Build -import com.raizlabs.android.dbflow.structure.ChangeAction +import com.raizlabs.dbflow5.structure.ChangeAction /** * Interface for when a generic change on a table occurs. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/TableNotifierRegister.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/TableNotifierRegister.kt similarity index 88% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/TableNotifierRegister.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/runtime/TableNotifierRegister.kt index 1465e1476..d5247128c 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/runtime/TableNotifierRegister.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/TableNotifierRegister.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.runtime +package com.raizlabs.dbflow5.runtime /** * Description: Defines how [ModelNotifier] registers listeners. Abstracts that away. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/Action.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/structure/Action.kt similarity index 88% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/Action.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/structure/Action.kt index f2d65c714..050a121fe 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/Action.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/structure/Action.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.structure +package com.raizlabs.dbflow5.structure /** * Specifies the Action that was taken when data changes diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseModel.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/structure/BaseModel.kt similarity index 81% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseModel.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/structure/BaseModel.kt index 50455b4cf..23eaccaba 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseModel.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/structure/BaseModel.kt @@ -1,9 +1,9 @@ -package com.raizlabs.android.dbflow.structure +package com.raizlabs.dbflow5.structure -import com.raizlabs.android.dbflow.adapter.ModelAdapter -import com.raizlabs.android.dbflow.annotation.ColumnIgnore -import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.dbflow5.adapter.ModelAdapter +import com.raizlabs.dbflow5.annotation.ColumnIgnore +import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.database.DatabaseWrapper /** * Description: The base implementation of [Model]. It is recommended to use this class as diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseModelView.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/structure/BaseModelView.kt similarity index 66% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseModelView.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/structure/BaseModelView.kt index 358ceb03c..3007593a0 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseModelView.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/structure/BaseModelView.kt @@ -1,7 +1,7 @@ -package com.raizlabs.android.dbflow.structure +package com.raizlabs.dbflow5.structure -import com.raizlabs.android.dbflow.annotation.ModelView -import com.raizlabs.android.dbflow.annotation.ModelViewQuery +import com.raizlabs.dbflow5.annotation.ModelView +import com.raizlabs.dbflow5.annotation.ModelViewQuery /** * Description: Provides a base implementation for a ModelView. Use a [ModelView] diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseQueryModel.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/structure/BaseQueryModel.kt similarity index 59% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseQueryModel.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/structure/BaseQueryModel.kt index a24fe60ef..db6ec6646 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/BaseQueryModel.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/structure/BaseQueryModel.kt @@ -1,7 +1,7 @@ -package com.raizlabs.android.dbflow.structure +package com.raizlabs.dbflow5.structure -import com.raizlabs.android.dbflow.annotation.QueryModel -import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.dbflow5.annotation.QueryModel +import com.raizlabs.dbflow5.database.DatabaseWrapper /** * Description: Provides a base class for objects that represent [QueryModel]. @@ -10,7 +10,7 @@ import com.raizlabs.android.dbflow.database.DatabaseWrapper class BaseQueryModel : NoModificationModel() { override fun exists(wrapper: DatabaseWrapper): Boolean { - throw NoModificationModel.InvalidSqlViewOperationException("Query " + wrapper.javaClass.name + + throw InvalidSqlViewOperationException("Query " + wrapper.javaClass.name + " does not exist as a table." + "It's a convenient representation of a complex SQLite query.") } } diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/InvalidDBConfiguration.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/structure/InvalidDBConfiguration.kt similarity index 86% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/InvalidDBConfiguration.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/structure/InvalidDBConfiguration.kt index 4a2539d2f..eaf60e2a7 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/InvalidDBConfiguration.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/structure/InvalidDBConfiguration.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.structure +package com.raizlabs.dbflow5.structure /** * Description: Thrown when a DB is incorrectly configured. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/Model.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/structure/Model.kt similarity index 89% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/Model.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/structure/Model.kt index b581df92e..e906b85d2 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/Model.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/structure/Model.kt @@ -1,8 +1,8 @@ -package com.raizlabs.android.dbflow.structure +package com.raizlabs.dbflow5.structure -import com.raizlabs.android.dbflow.config.databaseForTable -import com.raizlabs.android.dbflow.config.modelAdapter -import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.dbflow5.config.databaseForTable +import com.raizlabs.dbflow5.config.modelAdapter +import com.raizlabs.dbflow5.database.DatabaseWrapper interface Model : ReadOnlyModel { diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/NoModificationModel.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/structure/NoModificationModel.kt similarity index 75% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/NoModificationModel.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/structure/NoModificationModel.kt index 873627668..bf1b36a60 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/NoModificationModel.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/structure/NoModificationModel.kt @@ -1,8 +1,8 @@ -package com.raizlabs.android.dbflow.structure +package com.raizlabs.dbflow5.structure -import com.raizlabs.android.dbflow.adapter.RetrievalAdapter -import com.raizlabs.android.dbflow.config.FlowManager -import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.dbflow5.adapter.RetrievalAdapter +import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.database.DatabaseWrapper /** * Description: A convenience class for [ReadOnlyModel]. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/OneToMany.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/structure/OneToMany.kt similarity index 82% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/OneToMany.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/structure/OneToMany.kt index 99c72e248..3dde702ef 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/OneToMany.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/structure/OneToMany.kt @@ -1,7 +1,7 @@ -package com.raizlabs.android.dbflow.structure +package com.raizlabs.dbflow5.structure -import com.raizlabs.android.dbflow.query.ModelQueriable -import com.raizlabs.android.dbflow.query.list +import com.raizlabs.dbflow5.query.ModelQueriable +import com.raizlabs.dbflow5.query.list import kotlin.properties.ReadWriteProperty import kotlin.reflect.KProperty diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ReadOnlyModel.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/structure/ReadOnlyModel.kt similarity index 79% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ReadOnlyModel.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/structure/ReadOnlyModel.kt index e4b1ffa3a..2d202d30e 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/structure/ReadOnlyModel.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/structure/ReadOnlyModel.kt @@ -1,6 +1,6 @@ -package com.raizlabs.android.dbflow.structure +package com.raizlabs.dbflow5.structure -import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.dbflow5.database.DatabaseWrapper interface ReadOnlyModel { diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/BaseTransactionManager.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/BaseTransactionManager.kt similarity index 85% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/BaseTransactionManager.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/transaction/BaseTransactionManager.kt index 7640bb309..b847311e2 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/BaseTransactionManager.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/BaseTransactionManager.kt @@ -1,8 +1,8 @@ -package com.raizlabs.android.dbflow.transaction +package com.raizlabs.dbflow5.transaction -import com.raizlabs.android.dbflow.config.DatabaseDefinition -import com.raizlabs.android.dbflow.config.FlowLog -import com.raizlabs.android.dbflow.runtime.DBBatchSaveQueue +import com.raizlabs.dbflow5.config.DatabaseDefinition +import com.raizlabs.dbflow5.config.FlowLog +import com.raizlabs.dbflow5.runtime.DBBatchSaveQueue /** * Description: The base implementation of Transaction manager. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/DefaultTransactionManager.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/DefaultTransactionManager.kt similarity index 82% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/DefaultTransactionManager.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/transaction/DefaultTransactionManager.kt index 00f22268b..d533337e2 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/DefaultTransactionManager.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/DefaultTransactionManager.kt @@ -1,6 +1,6 @@ -package com.raizlabs.android.dbflow.transaction +package com.raizlabs.dbflow5.transaction -import com.raizlabs.android.dbflow.config.DatabaseDefinition +import com.raizlabs.dbflow5.config.DatabaseDefinition /** * Description: This class manages batch database interactions. Places DB operations onto the same Thread. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/DefaultTransactionQueue.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/DefaultTransactionQueue.kt similarity index 96% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/DefaultTransactionQueue.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/transaction/DefaultTransactionQueue.kt index 1ff0e32d5..6a0b918b0 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/DefaultTransactionQueue.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/DefaultTransactionQueue.kt @@ -1,8 +1,8 @@ -package com.raizlabs.android.dbflow.transaction +package com.raizlabs.dbflow5.transaction import android.os.Looper -import com.raizlabs.android.dbflow.config.FlowLog +import com.raizlabs.dbflow5.config.FlowLog import java.util.concurrent.LinkedBlockingQueue /** diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/FastStoreModelTransaction.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/FastStoreModelTransaction.kt similarity index 93% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/FastStoreModelTransaction.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/transaction/FastStoreModelTransaction.kt index 68fae7fda..c89952dfe 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/FastStoreModelTransaction.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/FastStoreModelTransaction.kt @@ -1,9 +1,9 @@ -package com.raizlabs.android.dbflow.transaction +package com.raizlabs.dbflow5.transaction -import com.raizlabs.android.dbflow.adapter.InternalAdapter -import com.raizlabs.android.dbflow.config.modelAdapter -import com.raizlabs.android.dbflow.database.DatabaseWrapper -import com.raizlabs.android.dbflow.structure.Model +import com.raizlabs.dbflow5.adapter.InternalAdapter +import com.raizlabs.dbflow5.config.modelAdapter +import com.raizlabs.dbflow5.database.DatabaseWrapper +import com.raizlabs.dbflow5.structure.Model /** * Description: Simple interface for acting on a model in a Transaction or list of [Model] diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/ITransaction.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/ITransaction.kt similarity index 82% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/ITransaction.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/transaction/ITransaction.kt index bde57cd77..1f8769050 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/ITransaction.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/ITransaction.kt @@ -1,8 +1,8 @@ -package com.raizlabs.android.dbflow.transaction +package com.raizlabs.dbflow5.transaction import android.database.sqlite.SQLiteDatabaseLockedException -import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.dbflow5.database.DatabaseWrapper /** * Description: Simplest form of a transaction. It represents an interface by which code is executed diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/ITransactionQueue.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/ITransactionQueue.kt similarity index 93% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/ITransactionQueue.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/transaction/ITransactionQueue.kt index d3e653b1d..2f67325e0 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/ITransactionQueue.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/ITransactionQueue.kt @@ -1,4 +1,4 @@ -package com.raizlabs.android.dbflow.transaction +package com.raizlabs.dbflow5.transaction /** * Description: Interface for a queue that manages transactions. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/PriorityTransactionQueue.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/PriorityTransactionQueue.kt similarity index 97% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/PriorityTransactionQueue.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/transaction/PriorityTransactionQueue.kt index 95f3a5940..056f8637e 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/PriorityTransactionQueue.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/PriorityTransactionQueue.kt @@ -1,8 +1,8 @@ -package com.raizlabs.android.dbflow.transaction +package com.raizlabs.dbflow5.transaction import android.os.Looper -import com.raizlabs.android.dbflow.config.FlowLog +import com.raizlabs.dbflow5.config.FlowLog import java.util.concurrent.PriorityBlockingQueue /** diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/PriorityTransactionWrapper.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/PriorityTransactionWrapper.kt similarity index 95% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/PriorityTransactionWrapper.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/transaction/PriorityTransactionWrapper.kt index 080ea71ec..3043ff168 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/PriorityTransactionWrapper.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/PriorityTransactionWrapper.kt @@ -1,8 +1,8 @@ -package com.raizlabs.android.dbflow.transaction +package com.raizlabs.dbflow5.transaction import android.support.annotation.IntDef -import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.dbflow5.database.DatabaseWrapper /** * Description: Provides transaction with priority. Meant to be used in a [PriorityTransactionQueue]. diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/ProcessModelTransaction.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/ProcessModelTransaction.kt similarity index 96% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/ProcessModelTransaction.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/transaction/ProcessModelTransaction.kt index 51a045041..28eda33ae 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/ProcessModelTransaction.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/ProcessModelTransaction.kt @@ -1,8 +1,8 @@ -package com.raizlabs.android.dbflow.transaction +package com.raizlabs.dbflow5.transaction -import com.raizlabs.android.dbflow.config.databaseForTable -import com.raizlabs.android.dbflow.database.DatabaseWrapper -import com.raizlabs.android.dbflow.structure.Model +import com.raizlabs.dbflow5.config.databaseForTable +import com.raizlabs.dbflow5.database.DatabaseWrapper +import com.raizlabs.dbflow5.structure.Model typealias ProcessFunction = (T, DatabaseWrapper) -> Unit diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/Transaction.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/Transaction.kt similarity index 93% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/Transaction.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/transaction/Transaction.kt index b20970253..41c1391c9 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/Transaction.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/Transaction.kt @@ -1,10 +1,10 @@ -package com.raizlabs.android.dbflow.transaction +package com.raizlabs.dbflow5.transaction import android.os.Handler import android.os.Looper -import com.raizlabs.android.dbflow.config.DatabaseDefinition -import com.raizlabs.android.dbflow.config.FlowLog +import com.raizlabs.dbflow5.config.DatabaseDefinition +import com.raizlabs.dbflow5.config.FlowLog /** * Description: The main transaction class. It represents a transaction that occurs in the database. @@ -16,12 +16,12 @@ import com.raizlabs.android.dbflow.config.FlowLog * To create one, the recommended method is to use the [DatabaseDefinition.beginTransactionAsync]. */ class Transaction(private val transaction: ITransaction, - private val databaseDefinition: DatabaseDefinition, - private val errorCallback: Error? = null, - private val successCallback: Success? = null, - private val name: String?, - private val shouldRunInTransaction: Boolean = true, - private val runCallbacksOnSameThread: Boolean = true) { + private val databaseDefinition: DatabaseDefinition, + private val errorCallback: Error? = null, + private val successCallback: Success? = null, + private val name: String?, + private val shouldRunInTransaction: Boolean = true, + private val runCallbacksOnSameThread: Boolean = true) { /** diff --git a/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/TransactionWrapper.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/TransactionWrapper.kt similarity index 83% rename from dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/TransactionWrapper.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/transaction/TransactionWrapper.kt index 8799cb9b4..d0fecd4d1 100644 --- a/dbflow/src/main/java/com/raizlabs/android/dbflow/transaction/TransactionWrapper.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/TransactionWrapper.kt @@ -1,6 +1,6 @@ -package com.raizlabs.android.dbflow.transaction +package com.raizlabs.dbflow5.transaction -import com.raizlabs.android.dbflow.database.DatabaseWrapper +import com.raizlabs.dbflow5.database.DatabaseWrapper /** * Description: Wraps multiple transactions together. diff --git a/usage2/ContentProviderGeneration.md b/usage2/ContentProviderGeneration.md index 3bf2d5566..4b1509b92 100644 --- a/usage2/ContentProviderGeneration.md +++ b/usage2/ContentProviderGeneration.md @@ -15,7 +15,7 @@ In order to define a `ContentProvider`, you must define it in a placeholder clas baseContentUri = TestContentProvider.BASE_CONTENT_URI) public class TestContentProvider { - public static final String AUTHORITY = "com.raizlabs.android.dbflow.test.provider"; + public static final String AUTHORITY = "com.raizlabs.dbflow5.dbflow.test.provider"; public static final String BASE_CONTENT_URI = "content://"; @@ -36,7 +36,7 @@ public class TestDatabase { public static final int VERSION = "1"; - public static final String AUTHORITY = "com.raizlabs.android.dbflow.test.provider"; + public static final String AUTHORITY = "com.raizlabs.dbflow5.dbflow.test.provider"; public static final String BASE_CONTENT_URI = "content://"; @@ -49,7 +49,7 @@ In other applications or your current's `AndroidManifest.xml` add the **generate ```xml ``` diff --git a/usage2/Intro.md b/usage2/Intro.md index 32047cf28..630f5fdd4 100644 --- a/usage2/Intro.md +++ b/usage2/Intro.md @@ -63,7 +63,7 @@ Since DBFlow uses annotation processing, which is run pre-proguard phase, the configuration is highly minimal: ``` --keep class * extends com.raizlabs.android.dbflow.config.DatabaseHolder { *; } +-keep class * extends com.raizlabs.dbflow5.dbflow.config.DatabaseHolder { *; } ``` ## Sections diff --git a/usage2/Relationships.md b/usage2/Relationships.md index f10c24759..fdcaca01b 100644 --- a/usage2/Relationships.md +++ b/usage2/Relationships.md @@ -230,7 +230,7 @@ A class can use both: @Table(database = TestDatabase.class) @ManyToMany(referencedTable = TestModel1.class) @MultipleManyToMany({@ManyToMany(referencedTable = TestModel2.class), - @ManyToMany(referencedTable = com.raizlabs.android.dbflow.test.sql.TestModel3.class)}) + @ManyToMany(referencedTable = com.raizlabs.dbflow5.dbflow.test.sql.TestModel3.class)}) public class ManyToManyModel extends BaseModel { @PrimaryKey diff --git a/usage2/TypeConverters.md b/usage2/TypeConverters.md index 26e958643..b4c40b39e 100644 --- a/usage2/TypeConverters.md +++ b/usage2/TypeConverters.md @@ -27,7 +27,7 @@ This example creates a `TypeConverter` for a field that is `JSONObject` and conv ```java -@com.raizlabs.android.dbflow.annotation.TypeConverter +@com.raizlabs.dbflow5.dbflow.annotation.TypeConverter public class JSONConverter extends TypeConverter { @Override diff --git a/usage2/proguard.md b/usage2/proguard.md index 20a2015cc..26901d3ae 100644 --- a/usage2/proguard.md +++ b/usage2/proguard.md @@ -3,7 +3,7 @@ Since DBFlow uses annotation processing, which is run pre-proguard phase, the configuration is highly minimal. Also since we combine all generated files into the `GeneratedDatabaseHolder`, any other class generated can be obfuscated. ``` --keep class * extends com.raizlabs.android.dbflow.config.DatabaseHolder { *; } +-keep class * extends com.raizlabs.dbflow5.dbflow.config.DatabaseHolder { *; } ``` This also works on modules from other library projects that use DBFlow. From b87ca4c6e68bcdc925f83c7dcba23ea1e74782b9 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sun, 3 Dec 2017 17:27:07 -0500 Subject: [PATCH 105/234] fix compile. fix package moving. --- .../dbflow5/converter/TypeConverters.kt | 6 +-- dbflow-coroutines/build.gradle | 2 +- .../{dbflow => }/processor/ClassNames.kt | 4 +- .../{dbflow => }/processor/DBFlowProcessor.kt | 6 +-- .../{dbflow => }/processor/Handlers.kt | 26 ++++++------ .../processor/ProcessorManager.kt | 32 +++++++-------- .../{dbflow => }/processor/ProcessorUtils.kt | 10 ++--- .../{dbflow => }/processor/SQLiteHelper.kt | 2 +- .../{dbflow => }/processor/Validators.kt | 16 ++++---- .../processor/definition/Adders.kt | 2 +- .../processor/definition/BaseDefinition.kt | 14 +++---- .../definition/BaseTableDefinition.kt | 22 +++++----- .../processor/definition/ContentProvider.kt | 16 ++++---- .../definition/DatabaseDefinition.kt | 14 +++---- .../definition/DatabaseHolderDefinition.kt | 8 ++-- .../definition/DatabaseObjectHolder.kt | 2 +- .../definition/IndexGroupsDefinition.kt | 6 +-- .../definition/ManyToManyDefinition.kt | 16 ++++---- .../processor/definition/Methods.kt | 14 +++---- .../definition/MigrationDefinition.kt | 8 ++-- .../definition/ModelViewDefinition.kt | 32 +++++++-------- .../processor/definition/NotifyDefinition.kt | 8 ++-- .../definition/OneToManyDefinition.kt | 32 +++++++-------- .../definition/QueryModelDefinition.kt | 22 +++++----- .../processor/definition/TableDefinition.kt | 40 +++++++++---------- .../definition/TableEndpointDefinition.kt | 8 ++-- .../definition/TypeConverterDefinition.kt | 10 ++--- .../processor/definition/TypeDefinition.kt | 2 +- .../definition/UniqueGroupsDefinition.kt | 6 +-- .../definition/column/ColumnAccessCombiner.kt | 14 +++---- .../definition/column/ColumnAccessor.kt | 8 ++-- .../definition/column/ColumnDefinition.kt | 26 ++++++------ .../definition/column/DefinitionUtils.kt | 4 +- .../column/ForeignKeyAccessCombiner.kt | 8 ++-- .../column/ReferenceColumnDefinition.kt | 26 ++++++------ .../definition/column/ReferenceDefinition.kt | 10 ++--- .../processor/utils/CodeExtensions.kt | 4 +- .../processor/utils/DependencyUtils.kt | 4 +- .../processor/utils/ElementExtensions.kt | 4 +- .../processor/utils/ElementUtility.kt | 4 +- .../processor/utils/JavaPoetExtensions.kt | 2 +- .../processor/utils/ModelUtils.kt | 2 +- .../processor/utils/ProcessorUtils.kt | 6 +-- .../processor/utils/StringUtils.kt | 2 +- .../processor/utils/WriterUtils.kt | 6 +-- .../javax.annotation.processing.Processor | 2 +- .../test/ColumnAccessCombinerTests.kt | 6 +-- .../test/ForeignKeyAccessCombinerTests.kt | 24 +++++------ .../test/SimpleColumnAccessorTests.kt | 6 +-- .../src/androidTest/AndroidManifest.xml | 6 +-- .../dbflow5/{dbflow => }/BaseUnitTest.kt | 2 +- .../DBFlowInstrumentedTestRule.kt | 4 +- .../ImmediateTransactionManager.kt | 2 +- .../contentobserver/ContentObserverTest.kt | 10 ++--- .../prepackaged/PrepackagedDBTest.kt | 6 ++- .../raizlabs/dbflow5/sqlcipher/CipherTest.kt | 5 ++- dbflow-tests/src/main/AndroidManifest.xml | 8 ++-- .../dbflow5/{dbflow => }/AppDatabase.kt | 2 +- .../raizlabs/dbflow5/{dbflow => }/DemoApp.kt | 2 +- .../{dbflow => }/StubContentProvider.kt | 2 +- .../com/raizlabs/dbflow5/{dbflow => }/User.kt | 2 +- .../{dbflow => }/contentobserver/User.kt | 4 +- .../{dbflow => }/prepackaged/PrepackagedDB.kt | 2 +- .../{dbflow => }/test/DemoActivity.java | 5 ++- .../src/main/res/layout/activity_demo.xml | 2 +- dbflow-tests/src/main/res/menu/menu_demo.xml | 2 +- dbflow-tests/src/test/AndroidManifest.xml | 4 +- .../dbflow5/{dbflow => }/BaseUnitTest.kt | 2 +- .../dbflow5/{dbflow => }/DBFlowTestRule.kt | 4 +- .../ImmediateTransactionManager.kt | 2 +- .../dbflow5/{dbflow => }/TestDatabase.kt | 4 +- .../dbflow5/{dbflow => }/TestExtensions.kt | 2 +- .../config/ConfigIntegrationTest.kt | 15 +++---- .../{dbflow => }/config/DatabaseConfigTest.kt | 11 ++--- .../database/transaction/CoroutinesTest.kt | 13 +++--- .../FastStoreModelTransactionTest.kt | 12 +++--- .../migration/UpdateTableMigrationTest.kt | 9 ++--- .../{dbflow => }/models/AutoIncrementTest.kt | 6 +-- .../{dbflow => }/models/CachingModels.kt | 4 +- .../{dbflow => }/models/CachingModelsTest.kt | 9 +++-- .../models/DontCreateModelTest.kt | 8 ++-- .../{dbflow => }/models/ForeignKeyModels.kt | 4 +- .../{dbflow => }/models/IndexModels.kt | 4 +- .../{dbflow => }/models/InnerClassExample.kt | 4 +- .../dbflow5/{dbflow => }/models/ManyToMany.kt | 4 +- .../{dbflow => }/models/ManyToManyTest.kt | 6 ++- .../{dbflow => }/models/ModelViewTest.kt | 10 ++--- .../dbflow5/{dbflow => }/models/ModelViews.kt | 7 ++-- .../models/NonTypical/nonTypicalClassName.kt | 4 +- .../{dbflow => }/models/OneToManyModelTest.kt | 9 +++-- .../{dbflow => }/models/OneToManyModels.kt | 7 ++-- .../models/ParentChildCachingTest.kt | 8 ++-- .../{dbflow => }/models/QueryModelTest.kt | 15 ++++--- .../{dbflow => }/models/QueryModels.kt | 6 +-- .../{dbflow => }/models/SimpleTestModels.kt | 6 +-- .../{dbflow => }/models/issue/Issue.java | 4 +- .../{dbflow => }/models/issue/Page.java | 4 +- .../{dbflow => }/models/issue/SubIssue.java | 4 +- .../models/java/DatabaseModel.java | 2 +- .../models/java/JavaModelView.java | 6 +-- .../java/otherpackage/ExampleModel.java | 6 +-- .../provider/ContentProviderObjects.kt | 7 +--- .../provider/ContentProviderTests.kt | 11 +++-- .../provider/RealContentProvider.kt | 4 +- .../provider/TestContentProvider.kt | 12 +++--- .../query/cache/ModelLruCacheTest.kt | 7 ++-- .../query/cache/SimpleMapCacheTest.kt | 7 ++-- .../query/list/FlowCursorIteratorTest.kt | 7 ++-- .../query/list/FlowCursorListTest.kt | 9 +++-- .../runtime/DirectNotifierTest.kt | 12 +++--- .../rx/query/CursorResultSubscriberTest.kt | 5 ++- .../raizlabs/dbflow5/rx/query/RXQueryTests.kt | 7 ++-- .../com/raizlabs/dbflow5/rx/query/RxModels.kt | 2 +- .../{dbflow => }/sql/language/CaseTest.kt | 8 ++-- .../sql/language/CursorResultTest.kt | 10 +++-- .../{dbflow => }/sql/language/DeleteTest.kt | 10 +++-- .../sql/language/ExistenceOperatorTest.kt | 9 +++-- .../{dbflow => }/sql/language/FromTest.kt | 17 ++++---- .../{dbflow => }/sql/language/IndexTest.kt | 8 ++-- .../sql/language/IndexedByTest.kt | 9 +++-- .../{dbflow => }/sql/language/InsertTest.kt | 13 +++--- .../{dbflow => }/sql/language/JoinTest.kt | 18 ++++++--- .../{dbflow => }/sql/language/MethodTest.kt | 8 ++-- .../sql/language/NameAliasTest.kt | 4 +- .../sql/language/OperatorGroupTest.kt | 10 ++--- .../{dbflow => }/sql/language/OperatorTest.kt | 11 ++--- .../{dbflow => }/sql/language/OrderByTest.kt | 8 ++-- .../{dbflow => }/sql/language/SelectTest.kt | 15 +++---- .../{dbflow => }/sql/language/SetTest.kt | 12 +++--- .../{dbflow => }/sql/language/TriggerTest.kt | 15 +++---- .../sql/language/UnsafeStringOperatorTest.kt | 9 +++-- .../{dbflow => }/sql/language/UpdateTest.kt | 14 +++---- .../{dbflow => }/sql/language/WhereTest.kt | 17 ++++---- .../sql/language/property/BytePropertyTest.kt | 6 +-- .../sql/language/property/CharPropertyTest.kt | 6 +-- .../language/property/DoublePropertyTest.kt | 6 +-- .../language/property/FloatPropertyTest.kt | 6 +-- .../language/property/IndexPropertyTest.kt | 8 ++-- .../sql/language/property/IntPropertyTest.kt | 6 +-- .../sql/language/property/LongPropertyTest.kt | 6 +-- .../language/property/PropertyFactoryTest.kt | 7 ++-- .../sql/language/property/PropertyTest.kt | 6 +-- .../language/property/ShortPropertyTest.kt | 6 +-- .../property/TypeConvertedPropertyTest.kt | 10 ++--- .../dbflow5/adapter/RetrievalAdapter.kt | 1 + .../dbflow5/config/DatabaseDefinition.kt | 1 - .../raizlabs/dbflow5/config/FlowManager.kt | 2 +- .../dbflow5/migration/AlterTableMigration.kt | 3 +- .../dbflow5/provider/BaseContentProvider.kt | 4 +- .../dbflow5/query/BaseTransformable.kt | 4 +- .../dbflow5/query/CompletedTrigger.kt | 2 +- .../java/com/raizlabs/dbflow5/query/Join.kt | 29 ++++++++++++-- usage2/ContentProviderGeneration.md | 6 +-- usage2/Intro.md | 2 +- usage2/Relationships.md | 2 +- usage2/TypeConverters.md | 2 +- usage2/proguard.md | 2 +- 157 files changed, 677 insertions(+), 616 deletions(-) rename dbflow-processor/src/main/java/com/raizlabs/dbflow5/{dbflow => }/processor/ClassNames.kt (97%) rename dbflow-processor/src/main/java/com/raizlabs/dbflow5/{dbflow => }/processor/DBFlowProcessor.kt (93%) rename dbflow-processor/src/main/java/com/raizlabs/dbflow5/{dbflow => }/processor/Handlers.kt (90%) rename dbflow-processor/src/main/java/com/raizlabs/dbflow5/{dbflow => }/processor/ProcessorManager.kt (93%) rename dbflow-processor/src/main/java/com/raizlabs/dbflow5/{dbflow => }/processor/ProcessorUtils.kt (93%) rename dbflow-processor/src/main/java/com/raizlabs/dbflow5/{dbflow => }/processor/SQLiteHelper.kt (98%) rename dbflow-processor/src/main/java/com/raizlabs/dbflow5/{dbflow => }/processor/Validators.kt (95%) rename dbflow-processor/src/main/java/com/raizlabs/dbflow5/{dbflow => }/processor/definition/Adders.kt (83%) rename dbflow-processor/src/main/java/com/raizlabs/dbflow5/{dbflow => }/processor/definition/BaseDefinition.kt (93%) rename dbflow-processor/src/main/java/com/raizlabs/dbflow5/{dbflow => }/processor/definition/BaseTableDefinition.kt (91%) rename dbflow-processor/src/main/java/com/raizlabs/dbflow5/{dbflow => }/processor/definition/ContentProvider.kt (97%) rename dbflow-processor/src/main/java/com/raizlabs/dbflow5/{dbflow => }/processor/definition/DatabaseDefinition.kt (95%) rename dbflow-processor/src/main/java/com/raizlabs/dbflow5/{dbflow => }/processor/definition/DatabaseHolderDefinition.kt (89%) rename dbflow-processor/src/main/java/com/raizlabs/dbflow5/{dbflow => }/processor/definition/DatabaseObjectHolder.kt (96%) rename dbflow-processor/src/main/java/com/raizlabs/dbflow5/{dbflow => }/processor/definition/IndexGroupsDefinition.kt (87%) rename dbflow-processor/src/main/java/com/raizlabs/dbflow5/{dbflow => }/processor/definition/ManyToManyDefinition.kt (91%) rename dbflow-processor/src/main/java/com/raizlabs/dbflow5/{dbflow => }/processor/definition/Methods.kt (98%) rename dbflow-processor/src/main/java/com/raizlabs/dbflow5/{dbflow => }/processor/definition/MigrationDefinition.kt (91%) rename dbflow-processor/src/main/java/com/raizlabs/dbflow5/{dbflow => }/processor/definition/ModelViewDefinition.kt (86%) rename dbflow-processor/src/main/java/com/raizlabs/dbflow5/{dbflow => }/processor/definition/NotifyDefinition.kt (90%) rename dbflow-processor/src/main/java/com/raizlabs/dbflow5/{dbflow => }/processor/definition/OneToManyDefinition.kt (86%) rename dbflow-processor/src/main/java/com/raizlabs/dbflow5/{dbflow => }/processor/definition/QueryModelDefinition.kt (86%) rename dbflow-processor/src/main/java/com/raizlabs/dbflow5/{dbflow => }/processor/definition/TableDefinition.kt (95%) rename dbflow-processor/src/main/java/com/raizlabs/dbflow5/{dbflow => }/processor/definition/TableEndpointDefinition.kt (90%) rename dbflow-processor/src/main/java/com/raizlabs/dbflow5/{dbflow => }/processor/definition/TypeConverterDefinition.kt (86%) rename dbflow-processor/src/main/java/com/raizlabs/dbflow5/{dbflow => }/processor/definition/TypeDefinition.kt (81%) rename dbflow-processor/src/main/java/com/raizlabs/dbflow5/{dbflow => }/processor/definition/UniqueGroupsDefinition.kt (85%) rename dbflow-processor/src/main/java/com/raizlabs/dbflow5/{dbflow => }/processor/definition/column/ColumnAccessCombiner.kt (97%) rename dbflow-processor/src/main/java/com/raizlabs/dbflow5/{dbflow => }/processor/definition/column/ColumnAccessor.kt (97%) rename dbflow-processor/src/main/java/com/raizlabs/dbflow5/{dbflow => }/processor/definition/column/ColumnDefinition.kt (95%) rename dbflow-processor/src/main/java/com/raizlabs/dbflow5/{dbflow => }/processor/definition/column/DefinitionUtils.kt (88%) rename dbflow-processor/src/main/java/com/raizlabs/dbflow5/{dbflow => }/processor/definition/column/ForeignKeyAccessCombiner.kt (96%) rename dbflow-processor/src/main/java/com/raizlabs/dbflow5/{dbflow => }/processor/definition/column/ReferenceColumnDefinition.kt (95%) rename dbflow-processor/src/main/java/com/raizlabs/dbflow5/{dbflow => }/processor/definition/column/ReferenceDefinition.kt (95%) rename dbflow-processor/src/main/java/com/raizlabs/dbflow5/{dbflow => }/processor/utils/CodeExtensions.kt (90%) rename dbflow-processor/src/main/java/com/raizlabs/dbflow5/{dbflow => }/processor/utils/DependencyUtils.kt (65%) rename dbflow-processor/src/main/java/com/raizlabs/dbflow5/{dbflow => }/processor/utils/ElementExtensions.kt (91%) rename dbflow-processor/src/main/java/com/raizlabs/dbflow5/{dbflow => }/processor/utils/ElementUtility.kt (95%) rename dbflow-processor/src/main/java/com/raizlabs/dbflow5/{dbflow => }/processor/utils/JavaPoetExtensions.kt (97%) rename dbflow-processor/src/main/java/com/raizlabs/dbflow5/{dbflow => }/processor/utils/ModelUtils.kt (60%) rename dbflow-processor/src/main/java/com/raizlabs/dbflow5/{dbflow => }/processor/utils/ProcessorUtils.kt (96%) rename dbflow-processor/src/main/java/com/raizlabs/dbflow5/{dbflow => }/processor/utils/StringUtils.kt (90%) rename dbflow-processor/src/main/java/com/raizlabs/dbflow5/{dbflow => }/processor/utils/WriterUtils.kt (81%) rename dbflow-processor/src/test/java/com/raizlabs/dbflow5/{dbflow => }/processor/test/ColumnAccessCombinerTests.kt (97%) rename dbflow-processor/src/test/java/com/raizlabs/dbflow5/{dbflow => }/processor/test/ForeignKeyAccessCombinerTests.kt (85%) rename dbflow-processor/src/test/java/com/raizlabs/dbflow5/{dbflow => }/processor/test/SimpleColumnAccessorTests.kt (95%) rename dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/{dbflow => }/BaseUnitTest.kt (81%) rename dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/{dbflow => }/DBFlowInstrumentedTestRule.kt (94%) rename dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/{dbflow => }/ImmediateTransactionManager.kt (96%) rename dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/{dbflow => }/contentobserver/ContentObserverTest.kt (93%) rename dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/{dbflow => }/prepackaged/PrepackagedDBTest.kt (70%) rename dbflow-tests/src/main/java/com/raizlabs/dbflow5/{dbflow => }/AppDatabase.kt (79%) rename dbflow-tests/src/main/java/com/raizlabs/dbflow5/{dbflow => }/DemoApp.kt (87%) rename dbflow-tests/src/main/java/com/raizlabs/dbflow5/{dbflow => }/StubContentProvider.kt (96%) rename dbflow-tests/src/main/java/com/raizlabs/dbflow5/{dbflow => }/User.kt (91%) rename dbflow-tests/src/main/java/com/raizlabs/dbflow5/{dbflow => }/contentobserver/User.kt (73%) rename dbflow-tests/src/main/java/com/raizlabs/dbflow5/{dbflow => }/prepackaged/PrepackagedDB.kt (91%) rename dbflow-tests/src/main/java/com/raizlabs/dbflow5/{dbflow => }/test/DemoActivity.java (92%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/BaseUnitTest.kt (92%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/DBFlowTestRule.kt (93%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/ImmediateTransactionManager.kt (96%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/TestDatabase.kt (85%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/TestExtensions.kt (94%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/config/ConfigIntegrationTest.kt (85%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/config/DatabaseConfigTest.kt (89%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/database/transaction/CoroutinesTest.kt (88%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/database/transaction/FastStoreModelTransactionTest.kt (85%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/migration/UpdateTableMigrationTest.kt (58%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/models/AutoIncrementTest.kt (83%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/models/CachingModels.kt (91%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/models/CachingModelsTest.kt (84%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/models/DontCreateModelTest.kt (67%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/models/ForeignKeyModels.kt (97%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/models/IndexModels.kt (91%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/models/InnerClassExample.kt (73%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/models/ManyToMany.kt (85%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/models/ManyToManyTest.kt (75%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/models/ModelViewTest.kt (68%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/models/ModelViews.kt (88%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/models/NonTypical/nonTypicalClassName.kt (71%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/models/OneToManyModelTest.kt (84%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/models/OneToManyModels.kt (91%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/models/ParentChildCachingTest.kt (80%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/models/QueryModelTest.kt (72%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/models/QueryModels.kt (85%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/models/SimpleTestModels.kt (98%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/models/issue/Issue.java (91%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/models/issue/Page.java (83%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/models/issue/SubIssue.java (92%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/models/java/DatabaseModel.java (86%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/models/java/JavaModelView.java (80%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/models/java/otherpackage/ExampleModel.java (55%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/provider/ContentProviderObjects.kt (93%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/provider/ContentProviderTests.kt (94%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/provider/RealContentProvider.kt (92%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/provider/TestContentProvider.kt (94%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/query/cache/ModelLruCacheTest.kt (77%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/query/cache/SimpleMapCacheTest.kt (78%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/query/list/FlowCursorIteratorTest.kt (89%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/query/list/FlowCursorListTest.kt (90%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/runtime/DirectNotifierTest.kt (89%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/sql/language/CaseTest.kt (83%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/sql/language/CursorResultTest.kt (92%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/sql/language/DeleteTest.kt (81%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/sql/language/ExistenceOperatorTest.kt (73%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/sql/language/FromTest.kt (77%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/sql/language/IndexTest.kt (84%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/sql/language/IndexedByTest.kt (71%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/sql/language/InsertTest.kt (92%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/sql/language/JoinTest.kt (85%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/sql/language/MethodTest.kt (92%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/sql/language/NameAliasTest.kt (93%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/sql/language/OperatorGroupTest.kt (82%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/sql/language/OperatorTest.kt (88%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/sql/language/OrderByTest.kt (79%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/sql/language/SelectTest.kt (60%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/sql/language/SetTest.kt (67%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/sql/language/TriggerTest.kt (87%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/sql/language/UnsafeStringOperatorTest.kt (74%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/sql/language/UpdateTest.kt (82%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/sql/language/WhereTest.kt (91%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/sql/language/property/BytePropertyTest.kt (91%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/sql/language/property/CharPropertyTest.kt (91%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/sql/language/property/DoublePropertyTest.kt (91%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/sql/language/property/FloatPropertyTest.kt (91%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/sql/language/property/IndexPropertyTest.kt (71%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/sql/language/property/IntPropertyTest.kt (91%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/sql/language/property/LongPropertyTest.kt (91%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/sql/language/property/PropertyFactoryTest.kt (84%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/sql/language/property/PropertyTest.kt (92%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/sql/language/property/ShortPropertyTest.kt (91%) rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/{dbflow => }/sql/language/property/TypeConvertedPropertyTest.kt (84%) diff --git a/dbflow-core/src/main/java/com/raizlabs/dbflow5/converter/TypeConverters.kt b/dbflow-core/src/main/java/com/raizlabs/dbflow5/converter/TypeConverters.kt index f13cef837..961ea36ee 100644 --- a/dbflow-core/src/main/java/com/raizlabs/dbflow5/converter/TypeConverters.kt +++ b/dbflow-core/src/main/java/com/raizlabs/dbflow5/converter/TypeConverters.kt @@ -11,7 +11,7 @@ import java.util.* * Description: This class is responsible for converting the stored database value into the field value in * a Model. */ -@com.raizlabs.dbflow5.dbflow.annotation.TypeConverter +@com.raizlabs.dbflow5.annotation.TypeConverter abstract class TypeConverter { /** @@ -61,7 +61,7 @@ class BooleanConverter : TypeConverter() { /** * Description: Defines how we store and retrieve a [java.util.Calendar] */ -@com.raizlabs.dbflow5.dbflow.annotation.TypeConverter(allowedSubtypes = arrayOf(GregorianCalendar::class)) +@com.raizlabs.dbflow5.annotation.TypeConverter(allowedSubtypes = [(GregorianCalendar::class)]) class CalendarConverter : TypeConverter() { override fun getDBValue(model: Calendar?): Long? = model?.timeInMillis @@ -94,7 +94,7 @@ class DateConverter : TypeConverter() { /** * Description: Defines how we store and retrieve a [java.sql.Date] */ -@com.raizlabs.dbflow5.dbflow.annotation.TypeConverter(allowedSubtypes = arrayOf(Time::class, Timestamp::class)) +@com.raizlabs.dbflow5.annotation.TypeConverter(allowedSubtypes = [(Time::class), (Timestamp::class)]) class SqlDateConverter : TypeConverter() { override fun getDBValue(model: java.sql.Date?): Long? = model?.time diff --git a/dbflow-coroutines/build.gradle b/dbflow-coroutines/build.gradle index f07f9942b..84d62cae7 100644 --- a/dbflow-coroutines/build.gradle +++ b/dbflow-coroutines/build.gradle @@ -18,7 +18,7 @@ android { dependencies { implementation project("${dbflow_project_prefix}dbflow") - implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:0.19.2" + api "org.jetbrains.kotlinx:kotlinx-coroutines-core:0.19.2" } kotlin { diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/ClassNames.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/ClassNames.kt similarity index 97% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/ClassNames.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/ClassNames.kt index f3c1ae9d1..d7c01ef2a 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/ClassNames.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/ClassNames.kt @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5.dbflow.processor +package com.raizlabs.dbflow5.processor import com.raizlabs.dbflow5.annotation.ConflictAction import com.squareup.javapoet.ClassName @@ -9,7 +9,7 @@ import com.squareup.javapoet.ClassName object ClassNames { - val BASE_PACKAGE = "com.raizlabs.dbflow5.dbflow" + val BASE_PACKAGE = "com.raizlabs.dbflow5" val FLOW_MANAGER_PACKAGE = BASE_PACKAGE + ".config" val DATABASE_HOLDER_STATIC_CLASS_NAME = "GeneratedDatabaseHolder" val CONVERTER = BASE_PACKAGE + ".converter" diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/DBFlowProcessor.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/DBFlowProcessor.kt similarity index 93% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/DBFlowProcessor.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/DBFlowProcessor.kt index f21c0a4d6..e2ccd9d6e 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/DBFlowProcessor.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/DBFlowProcessor.kt @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5.dbflow.processor +package com.raizlabs.dbflow5.processor import com.raizlabs.dbflow5.annotation.Column import com.raizlabs.dbflow5.annotation.ColumnIgnore @@ -6,10 +6,10 @@ import com.raizlabs.dbflow5.annotation.Migration import com.raizlabs.dbflow5.annotation.ModelView import com.raizlabs.dbflow5.annotation.QueryModel import com.raizlabs.dbflow5.annotation.Table -import com.raizlabs.dbflow5.dbflow.annotation.TypeConverter +import com.raizlabs.dbflow5.annotation.TypeConverter import com.raizlabs.dbflow5.annotation.provider.ContentProvider import com.raizlabs.dbflow5.annotation.provider.TableEndpoint -import com.raizlabs.dbflow5.dbflow.processor.definition.DatabaseHolderDefinition +import com.raizlabs.dbflow5.processor.definition.DatabaseHolderDefinition import javax.annotation.processing.AbstractProcessor import javax.annotation.processing.ProcessingEnvironment import javax.annotation.processing.RoundEnvironment diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/Handlers.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/Handlers.kt similarity index 90% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/Handlers.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/Handlers.kt index dfc9b74e2..977c36e19 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/Handlers.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/Handlers.kt @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5.dbflow.processor +package com.raizlabs.dbflow5.processor import com.raizlabs.dbflow5.annotation.Database import com.raizlabs.dbflow5.annotation.ManyToMany @@ -7,7 +7,7 @@ import com.raizlabs.dbflow5.annotation.ModelView import com.raizlabs.dbflow5.annotation.MultipleManyToMany import com.raizlabs.dbflow5.annotation.QueryModel import com.raizlabs.dbflow5.annotation.Table -import com.raizlabs.dbflow5.dbflow.annotation.TypeConverter +import com.raizlabs.dbflow5.annotation.TypeConverter import com.raizlabs.dbflow5.annotation.provider.ContentProvider import com.raizlabs.dbflow5.annotation.provider.TableEndpoint import com.raizlabs.dbflow5.converter.BigDecimalConverter @@ -18,16 +18,16 @@ import com.raizlabs.dbflow5.converter.CharConverter import com.raizlabs.dbflow5.converter.DateConverter import com.raizlabs.dbflow5.converter.SqlDateConverter import com.raizlabs.dbflow5.converter.UUIDConverter -import com.raizlabs.dbflow5.dbflow.processor.definition.ContentProviderDefinition -import com.raizlabs.dbflow5.dbflow.processor.definition.DatabaseDefinition -import com.raizlabs.dbflow5.dbflow.processor.definition.ManyToManyDefinition -import com.raizlabs.dbflow5.dbflow.processor.definition.MigrationDefinition -import com.raizlabs.dbflow5.dbflow.processor.definition.ModelViewDefinition -import com.raizlabs.dbflow5.dbflow.processor.definition.QueryModelDefinition -import com.raizlabs.dbflow5.dbflow.processor.definition.TableDefinition -import com.raizlabs.dbflow5.dbflow.processor.definition.TableEndpointDefinition -import com.raizlabs.dbflow5.dbflow.processor.definition.TypeConverterDefinition -import com.raizlabs.dbflow5.dbflow.processor.utils.annotation +import com.raizlabs.dbflow5.processor.definition.ContentProviderDefinition +import com.raizlabs.dbflow5.processor.definition.DatabaseDefinition +import com.raizlabs.dbflow5.processor.definition.ManyToManyDefinition +import com.raizlabs.dbflow5.processor.definition.MigrationDefinition +import com.raizlabs.dbflow5.processor.definition.ModelViewDefinition +import com.raizlabs.dbflow5.processor.definition.QueryModelDefinition +import com.raizlabs.dbflow5.processor.definition.TableDefinition +import com.raizlabs.dbflow5.processor.definition.TableEndpointDefinition +import com.raizlabs.dbflow5.processor.definition.TypeConverterDefinition +import com.raizlabs.dbflow5.processor.utils.annotation import javax.annotation.processing.RoundEnvironment import javax.lang.model.element.Element import javax.lang.model.element.PackageElement @@ -155,7 +155,7 @@ class TypeConverterHandler : BaseContainerHandler() { override fun onProcessElement(processorManager: ProcessorManager, element: Element) { if (element is TypeElement) { - val className = com.raizlabs.dbflow5.dbflow.processor.utils.fromTypeMirror(element.asType(), processorManager) + val className = com.raizlabs.dbflow5.processor.utils.fromTypeMirror(element.asType(), processorManager) val converterDefinition = className?.let { TypeConverterDefinition(it, element.asType(), processorManager, element) } converterDefinition?.let { if (VALIDATOR.validate(processorManager, converterDefinition)) { diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/ProcessorManager.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/ProcessorManager.kt similarity index 93% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/ProcessorManager.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/ProcessorManager.kt index 75934419c..ba1c3b7ed 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/ProcessorManager.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/ProcessorManager.kt @@ -1,18 +1,18 @@ -package com.raizlabs.dbflow5.dbflow.processor - -import com.raizlabs.dbflow5.dbflow.processor.definition.BaseTableDefinition -import com.raizlabs.dbflow5.dbflow.processor.definition.ContentProviderDefinition -import com.raizlabs.dbflow5.dbflow.processor.definition.DatabaseDefinition -import com.raizlabs.dbflow5.dbflow.processor.definition.DatabaseHolderDefinition -import com.raizlabs.dbflow5.dbflow.processor.definition.DatabaseObjectHolder -import com.raizlabs.dbflow5.dbflow.processor.definition.ManyToManyDefinition -import com.raizlabs.dbflow5.dbflow.processor.definition.MigrationDefinition -import com.raizlabs.dbflow5.dbflow.processor.definition.ModelViewDefinition -import com.raizlabs.dbflow5.dbflow.processor.definition.QueryModelDefinition -import com.raizlabs.dbflow5.dbflow.processor.definition.TableDefinition -import com.raizlabs.dbflow5.dbflow.processor.definition.TableEndpointDefinition -import com.raizlabs.dbflow5.dbflow.processor.definition.TypeConverterDefinition -import com.raizlabs.dbflow5.dbflow.processor.utils.WriterUtils +package com.raizlabs.dbflow5.processor + +import com.raizlabs.dbflow5.processor.definition.BaseTableDefinition +import com.raizlabs.dbflow5.processor.definition.ContentProviderDefinition +import com.raizlabs.dbflow5.processor.definition.DatabaseDefinition +import com.raizlabs.dbflow5.processor.definition.DatabaseHolderDefinition +import com.raizlabs.dbflow5.processor.definition.DatabaseObjectHolder +import com.raizlabs.dbflow5.processor.definition.ManyToManyDefinition +import com.raizlabs.dbflow5.processor.definition.MigrationDefinition +import com.raizlabs.dbflow5.processor.definition.ModelViewDefinition +import com.raizlabs.dbflow5.processor.definition.QueryModelDefinition +import com.raizlabs.dbflow5.processor.definition.TableDefinition +import com.raizlabs.dbflow5.processor.definition.TableEndpointDefinition +import com.raizlabs.dbflow5.processor.definition.TypeConverterDefinition +import com.raizlabs.dbflow5.processor.utils.WriterUtils import com.squareup.javapoet.ClassName import com.squareup.javapoet.JavaFile import com.squareup.javapoet.TypeName @@ -216,7 +216,7 @@ class ProcessorManager internal constructor(val processingEnvironment: Processin stackTraceElements.forEach { messager.printMessage(Diagnostic.Kind.ERROR, it.toString()) } } - fun logError(error: String?, vararg args: Any?) = logError(callingClass = null, error = error, args = args) + fun logError(error: String?, vararg args: Any?) = logError(callingClass = null, error = error, args = *args) fun logWarning(error: String?, vararg args: Any) { messager.printMessage(Diagnostic.Kind.WARNING, String.format("*==========*\n$error\n*==========*", *args)) diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/ProcessorUtils.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/ProcessorUtils.kt similarity index 93% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/ProcessorUtils.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/ProcessorUtils.kt index f551b9edd..4ed91e9f7 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/ProcessorUtils.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/ProcessorUtils.kt @@ -1,9 +1,9 @@ -package com.raizlabs.dbflow5.dbflow.processor +package com.raizlabs.dbflow5.processor -import com.raizlabs.dbflow5.dbflow.processor.ProcessorManager.Companion.manager -import com.raizlabs.dbflow5.dbflow.processor.utils.ElementUtility -import com.raizlabs.dbflow5.dbflow.processor.utils.erasure -import com.raizlabs.dbflow5.dbflow.processor.utils.toTypeElement +import com.raizlabs.dbflow5.processor.ProcessorManager.Companion.manager +import com.raizlabs.dbflow5.processor.utils.ElementUtility +import com.raizlabs.dbflow5.processor.utils.erasure +import com.raizlabs.dbflow5.processor.utils.toTypeElement import com.squareup.javapoet.ClassName import javax.annotation.processing.ProcessingEnvironment import javax.lang.model.element.Element diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/SQLiteHelper.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/SQLiteHelper.kt similarity index 98% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/SQLiteHelper.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/SQLiteHelper.kt index 0501f2047..941124791 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/SQLiteHelper.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/SQLiteHelper.kt @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5.dbflow.processor +package com.raizlabs.dbflow5.processor import com.raizlabs.dbflow5.data.Blob import com.squareup.javapoet.ArrayTypeName diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/Validators.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/Validators.kt similarity index 95% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/Validators.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/Validators.kt index eeec25c62..d81d8e4d0 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/Validators.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/Validators.kt @@ -1,11 +1,11 @@ -package com.raizlabs.dbflow5.dbflow.processor - -import com.raizlabs.dbflow5.dbflow.processor.definition.* -import com.raizlabs.dbflow5.dbflow.processor.definition.column.ColumnDefinition -import com.raizlabs.dbflow5.dbflow.processor.definition.column.EnumColumnAccessor -import com.raizlabs.dbflow5.dbflow.processor.definition.column.ReferenceColumnDefinition -import com.raizlabs.dbflow5.dbflow.processor.definition.column.PrivateScopeColumnAccessor -import com.raizlabs.dbflow5.dbflow.processor.utils.isNullOrEmpty +package com.raizlabs.dbflow5.processor + +import com.raizlabs.dbflow5.processor.definition.* +import com.raizlabs.dbflow5.processor.definition.column.ColumnDefinition +import com.raizlabs.dbflow5.processor.definition.column.EnumColumnAccessor +import com.raizlabs.dbflow5.processor.definition.column.ReferenceColumnDefinition +import com.raizlabs.dbflow5.processor.definition.column.PrivateScopeColumnAccessor +import com.raizlabs.dbflow5.processor.utils.isNullOrEmpty /** diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/Adders.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/Adders.kt similarity index 83% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/Adders.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/Adders.kt index 92cfe7c18..1fac24cf0 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/Adders.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/Adders.kt @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5.dbflow.processor.definition +package com.raizlabs.dbflow5.processor.definition import com.squareup.javapoet.CodeBlock import com.squareup.javapoet.TypeSpec diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/BaseDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/BaseDefinition.kt similarity index 93% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/BaseDefinition.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/BaseDefinition.kt index 33749299c..ace9ece44 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/BaseDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/BaseDefinition.kt @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5.dbflow.processor.definition +package com.raizlabs.dbflow5.processor.definition import com.grosner.kpoet.S import com.grosner.kpoet.`@` @@ -7,12 +7,12 @@ import com.grosner.kpoet.extends import com.grosner.kpoet.implements import com.grosner.kpoet.javadoc import com.grosner.kpoet.typeName -import com.raizlabs.dbflow5.dbflow.processor.ClassNames -import com.raizlabs.dbflow5.dbflow.processor.DBFlowProcessor -import com.raizlabs.dbflow5.dbflow.processor.ProcessorManager -import com.raizlabs.dbflow5.dbflow.processor.utils.ElementUtility -import com.raizlabs.dbflow5.dbflow.processor.utils.hasJavaX -import com.raizlabs.dbflow5.dbflow.processor.utils.toTypeElement +import com.raizlabs.dbflow5.processor.ClassNames +import com.raizlabs.dbflow5.processor.DBFlowProcessor +import com.raizlabs.dbflow5.processor.ProcessorManager +import com.raizlabs.dbflow5.processor.utils.ElementUtility +import com.raizlabs.dbflow5.processor.utils.hasJavaX +import com.raizlabs.dbflow5.processor.utils.toTypeElement import com.squareup.javapoet.ClassName import com.squareup.javapoet.ParameterizedTypeName import com.squareup.javapoet.TypeName diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/BaseTableDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/BaseTableDefinition.kt similarity index 91% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/BaseTableDefinition.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/BaseTableDefinition.kt index f377c7eda..a38a485f3 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/BaseTableDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/BaseTableDefinition.kt @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5.dbflow.processor.definition +package com.raizlabs.dbflow5.processor.definition import com.grosner.kpoet.`public static final` import com.grosner.kpoet.`return` @@ -9,16 +9,16 @@ import com.grosner.kpoet.modifiers import com.grosner.kpoet.param import com.grosner.kpoet.public import com.grosner.kpoet.statement -import com.raizlabs.dbflow5.dbflow.processor.ClassNames -import com.raizlabs.dbflow5.dbflow.processor.ProcessorManager -import com.raizlabs.dbflow5.dbflow.processor.definition.column.ColumnDefinition -import com.raizlabs.dbflow5.dbflow.processor.definition.column.PackagePrivateScopeColumnAccessor -import com.raizlabs.dbflow5.dbflow.processor.definition.column.ReferenceColumnDefinition -import com.raizlabs.dbflow5.dbflow.processor.utils.ElementUtility -import com.raizlabs.dbflow5.dbflow.processor.utils.ModelUtils -import com.raizlabs.dbflow5.dbflow.processor.utils.`override fun` -import com.raizlabs.dbflow5.dbflow.processor.utils.getPackage -import com.raizlabs.dbflow5.dbflow.processor.utils.toClassName +import com.raizlabs.dbflow5.processor.ClassNames +import com.raizlabs.dbflow5.processor.ProcessorManager +import com.raizlabs.dbflow5.processor.definition.column.ColumnDefinition +import com.raizlabs.dbflow5.processor.definition.column.PackagePrivateScopeColumnAccessor +import com.raizlabs.dbflow5.processor.definition.column.ReferenceColumnDefinition +import com.raizlabs.dbflow5.processor.utils.ElementUtility +import com.raizlabs.dbflow5.processor.utils.ModelUtils +import com.raizlabs.dbflow5.processor.utils.`override fun` +import com.raizlabs.dbflow5.processor.utils.getPackage +import com.raizlabs.dbflow5.processor.utils.toClassName import com.squareup.javapoet.ClassName import com.squareup.javapoet.JavaFile import com.squareup.javapoet.ParameterizedTypeName diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/ContentProvider.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/ContentProvider.kt similarity index 97% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/ContentProvider.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/ContentProvider.kt index 18989a40e..df865cfa6 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/ContentProvider.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/ContentProvider.kt @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5.dbflow.processor.definition +package com.raizlabs.dbflow5.processor.definition import com.grosner.kpoet.L import com.grosner.kpoet.`=` @@ -19,13 +19,13 @@ import com.raizlabs.dbflow5.annotation.provider.ContentUri import com.raizlabs.dbflow5.annotation.provider.NotifyMethod import com.raizlabs.dbflow5.annotation.provider.PathSegment import com.raizlabs.dbflow5.annotation.provider.TableEndpoint -import com.raizlabs.dbflow5.dbflow.processor.ClassNames -import com.raizlabs.dbflow5.dbflow.processor.ProcessorManager -import com.raizlabs.dbflow5.dbflow.processor.TableEndpointValidator -import com.raizlabs.dbflow5.dbflow.processor.utils.`override fun` -import com.raizlabs.dbflow5.dbflow.processor.utils.annotation -import com.raizlabs.dbflow5.dbflow.processor.utils.controlFlow -import com.raizlabs.dbflow5.dbflow.processor.utils.isNullOrEmpty +import com.raizlabs.dbflow5.processor.ClassNames +import com.raizlabs.dbflow5.processor.ProcessorManager +import com.raizlabs.dbflow5.processor.TableEndpointValidator +import com.raizlabs.dbflow5.processor.utils.`override fun` +import com.raizlabs.dbflow5.processor.utils.annotation +import com.raizlabs.dbflow5.processor.utils.controlFlow +import com.raizlabs.dbflow5.processor.utils.isNullOrEmpty import com.squareup.javapoet.ArrayTypeName import com.squareup.javapoet.ClassName import com.squareup.javapoet.CodeBlock diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/DatabaseDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/DatabaseDefinition.kt similarity index 95% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/DatabaseDefinition.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/DatabaseDefinition.kt index da035901d..0790b23ab 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/DatabaseDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/DatabaseDefinition.kt @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5.dbflow.processor.definition +package com.raizlabs.dbflow5.processor.definition import com.grosner.kpoet.L import com.grosner.kpoet.S @@ -11,12 +11,12 @@ import com.grosner.kpoet.public import com.grosner.kpoet.statement import com.raizlabs.dbflow5.annotation.ConflictAction import com.raizlabs.dbflow5.annotation.Database -import com.raizlabs.dbflow5.dbflow.processor.ClassNames -import com.raizlabs.dbflow5.dbflow.processor.ModelViewValidator -import com.raizlabs.dbflow5.dbflow.processor.ProcessorManager -import com.raizlabs.dbflow5.dbflow.processor.TableValidator -import com.raizlabs.dbflow5.dbflow.processor.utils.`override fun` -import com.raizlabs.dbflow5.dbflow.processor.utils.annotation +import com.raizlabs.dbflow5.processor.ClassNames +import com.raizlabs.dbflow5.processor.ModelViewValidator +import com.raizlabs.dbflow5.processor.ProcessorManager +import com.raizlabs.dbflow5.processor.TableValidator +import com.raizlabs.dbflow5.processor.utils.`override fun` +import com.raizlabs.dbflow5.processor.utils.annotation import com.squareup.javapoet.ClassName import com.squareup.javapoet.ParameterizedTypeName import com.squareup.javapoet.TypeName diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/DatabaseHolderDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/DatabaseHolderDefinition.kt similarity index 89% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/DatabaseHolderDefinition.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/DatabaseHolderDefinition.kt index 5fda43833..ec6cd8f95 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/DatabaseHolderDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/DatabaseHolderDefinition.kt @@ -1,9 +1,9 @@ -package com.raizlabs.dbflow5.dbflow.processor.definition +package com.raizlabs.dbflow5.processor.definition import com.grosner.kpoet.* -import com.raizlabs.dbflow5.dbflow.processor.ClassNames -import com.raizlabs.dbflow5.dbflow.processor.DatabaseHandler -import com.raizlabs.dbflow5.dbflow.processor.ProcessorManager +import com.raizlabs.dbflow5.processor.ClassNames +import com.raizlabs.dbflow5.processor.DatabaseHandler +import com.raizlabs.dbflow5.processor.ProcessorManager import com.squareup.javapoet.TypeSpec /** diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/DatabaseObjectHolder.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/DatabaseObjectHolder.kt similarity index 96% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/DatabaseObjectHolder.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/DatabaseObjectHolder.kt index 8c958ce63..1afc46275 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/DatabaseObjectHolder.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/DatabaseObjectHolder.kt @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5.dbflow.processor.definition +package com.raizlabs.dbflow5.processor.definition import com.squareup.javapoet.TypeName diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/IndexGroupsDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/IndexGroupsDefinition.kt similarity index 87% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/IndexGroupsDefinition.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/IndexGroupsDefinition.kt index aa5c61581..9d06b9da8 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/IndexGroupsDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/IndexGroupsDefinition.kt @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5.dbflow.processor.definition +package com.raizlabs.dbflow5.processor.definition import com.grosner.kpoet.S import com.grosner.kpoet.`=` @@ -7,8 +7,8 @@ import com.grosner.kpoet.final import com.grosner.kpoet.public import com.grosner.kpoet.static import com.raizlabs.dbflow5.annotation.IndexGroup -import com.raizlabs.dbflow5.dbflow.processor.ClassNames -import com.raizlabs.dbflow5.dbflow.processor.definition.column.ColumnDefinition +import com.raizlabs.dbflow5.processor.ClassNames +import com.raizlabs.dbflow5.processor.definition.column.ColumnDefinition import com.squareup.javapoet.ParameterizedTypeName import java.util.concurrent.atomic.AtomicInteger diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/ManyToManyDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/ManyToManyDefinition.kt similarity index 91% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/ManyToManyDefinition.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/ManyToManyDefinition.kt index 7f36e03fc..bc6912808 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/ManyToManyDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/ManyToManyDefinition.kt @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5.dbflow.processor.definition +package com.raizlabs.dbflow5.processor.definition import com.grosner.kpoet.L import com.grosner.kpoet.`@` @@ -15,13 +15,13 @@ import com.raizlabs.dbflow5.annotation.ForeignKey import com.raizlabs.dbflow5.annotation.ManyToMany import com.raizlabs.dbflow5.annotation.PrimaryKey import com.raizlabs.dbflow5.annotation.Table -import com.raizlabs.dbflow5.dbflow.processor.ClassNames -import com.raizlabs.dbflow5.dbflow.processor.ProcessorManager -import com.raizlabs.dbflow5.dbflow.processor.utils.annotation -import com.raizlabs.dbflow5.dbflow.processor.utils.extractTypeNameFromAnnotation -import com.raizlabs.dbflow5.dbflow.processor.utils.isNullOrEmpty -import com.raizlabs.dbflow5.dbflow.processor.utils.lower -import com.raizlabs.dbflow5.dbflow.processor.utils.toTypeElement +import com.raizlabs.dbflow5.processor.ClassNames +import com.raizlabs.dbflow5.processor.ProcessorManager +import com.raizlabs.dbflow5.processor.utils.annotation +import com.raizlabs.dbflow5.processor.utils.extractTypeNameFromAnnotation +import com.raizlabs.dbflow5.processor.utils.isNullOrEmpty +import com.raizlabs.dbflow5.processor.utils.lower +import com.raizlabs.dbflow5.processor.utils.toTypeElement import com.squareup.javapoet.AnnotationSpec import com.squareup.javapoet.TypeName import com.squareup.javapoet.TypeSpec diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/Methods.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/Methods.kt similarity index 98% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/Methods.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/Methods.kt index 5f31382a2..1d884ac5d 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/Methods.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/Methods.kt @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5.dbflow.processor.definition +package com.raizlabs.dbflow5.processor.definition import com.grosner.kpoet.S import com.grosner.kpoet.`=` @@ -10,12 +10,12 @@ import com.grosner.kpoet.modifiers import com.grosner.kpoet.param import com.grosner.kpoet.public import com.grosner.kpoet.statement -import com.raizlabs.dbflow5.dbflow.processor.ClassNames -import com.raizlabs.dbflow5.dbflow.processor.definition.column.wrapperCommaIfBaseModel -import com.raizlabs.dbflow5.dbflow.processor.utils.ModelUtils -import com.raizlabs.dbflow5.dbflow.processor.utils.`override fun` -import com.raizlabs.dbflow5.dbflow.processor.utils.codeBlock -import com.raizlabs.dbflow5.dbflow.processor.utils.isNullOrEmpty +import com.raizlabs.dbflow5.processor.ClassNames +import com.raizlabs.dbflow5.processor.definition.column.wrapperCommaIfBaseModel +import com.raizlabs.dbflow5.processor.utils.ModelUtils +import com.raizlabs.dbflow5.processor.utils.`override fun` +import com.raizlabs.dbflow5.processor.utils.codeBlock +import com.raizlabs.dbflow5.processor.utils.isNullOrEmpty import com.raizlabs.dbflow5.quote import com.squareup.javapoet.ClassName import com.squareup.javapoet.CodeBlock diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/MigrationDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/MigrationDefinition.kt similarity index 91% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/MigrationDefinition.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/MigrationDefinition.kt index 3ea9dff20..ac267d5e9 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/MigrationDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/MigrationDefinition.kt @@ -1,10 +1,10 @@ -package com.raizlabs.dbflow5.dbflow.processor.definition +package com.raizlabs.dbflow5.processor.definition import com.grosner.kpoet.typeName import com.raizlabs.dbflow5.annotation.Migration -import com.raizlabs.dbflow5.dbflow.processor.ProcessorManager -import com.raizlabs.dbflow5.dbflow.processor.utils.annotation -import com.raizlabs.dbflow5.dbflow.processor.utils.isNullOrEmpty +import com.raizlabs.dbflow5.processor.ProcessorManager +import com.raizlabs.dbflow5.processor.utils.annotation +import com.raizlabs.dbflow5.processor.utils.isNullOrEmpty import com.squareup.javapoet.ClassName import com.squareup.javapoet.CodeBlock import com.squareup.javapoet.ParameterizedTypeName diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/ModelViewDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/ModelViewDefinition.kt similarity index 86% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/ModelViewDefinition.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/ModelViewDefinition.kt index 8f3a53340..fd6f66a5a 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/ModelViewDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/ModelViewDefinition.kt @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5.dbflow.processor.definition +package com.raizlabs.dbflow5.processor.definition import com.grosner.kpoet.S import com.grosner.kpoet.`=` @@ -12,21 +12,21 @@ import com.raizlabs.dbflow5.annotation.Column import com.raizlabs.dbflow5.annotation.ColumnMap import com.raizlabs.dbflow5.annotation.ModelView import com.raizlabs.dbflow5.annotation.ModelViewQuery -import com.raizlabs.dbflow5.dbflow.processor.ClassNames -import com.raizlabs.dbflow5.dbflow.processor.ColumnValidator -import com.raizlabs.dbflow5.dbflow.processor.ProcessorManager -import com.raizlabs.dbflow5.dbflow.processor.definition.column.ColumnDefinition -import com.raizlabs.dbflow5.dbflow.processor.definition.column.ReferenceColumnDefinition -import com.raizlabs.dbflow5.dbflow.processor.utils.ElementUtility -import com.raizlabs.dbflow5.dbflow.processor.utils.ModelUtils -import com.raizlabs.dbflow5.dbflow.processor.utils.`override fun` -import com.raizlabs.dbflow5.dbflow.processor.utils.annotation -import com.raizlabs.dbflow5.dbflow.processor.utils.ensureVisibleStatic -import com.raizlabs.dbflow5.dbflow.processor.utils.implementsClass -import com.raizlabs.dbflow5.dbflow.processor.utils.isNullOrEmpty -import com.raizlabs.dbflow5.dbflow.processor.utils.simpleString -import com.raizlabs.dbflow5.dbflow.processor.utils.toTypeElement -import com.raizlabs.dbflow5.dbflow.processor.utils.toTypeErasedElement +import com.raizlabs.dbflow5.processor.ClassNames +import com.raizlabs.dbflow5.processor.ColumnValidator +import com.raizlabs.dbflow5.processor.ProcessorManager +import com.raizlabs.dbflow5.processor.definition.column.ColumnDefinition +import com.raizlabs.dbflow5.processor.definition.column.ReferenceColumnDefinition +import com.raizlabs.dbflow5.processor.utils.ElementUtility +import com.raizlabs.dbflow5.processor.utils.ModelUtils +import com.raizlabs.dbflow5.processor.utils.`override fun` +import com.raizlabs.dbflow5.processor.utils.annotation +import com.raizlabs.dbflow5.processor.utils.ensureVisibleStatic +import com.raizlabs.dbflow5.processor.utils.implementsClass +import com.raizlabs.dbflow5.processor.utils.isNullOrEmpty +import com.raizlabs.dbflow5.processor.utils.simpleString +import com.raizlabs.dbflow5.processor.utils.toTypeElement +import com.raizlabs.dbflow5.processor.utils.toTypeErasedElement import com.squareup.javapoet.ParameterizedTypeName import com.squareup.javapoet.TypeName import com.squareup.javapoet.TypeSpec diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/NotifyDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/NotifyDefinition.kt similarity index 90% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/NotifyDefinition.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/NotifyDefinition.kt index 259223d17..048370a78 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/NotifyDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/NotifyDefinition.kt @@ -1,10 +1,10 @@ -package com.raizlabs.dbflow5.dbflow.processor.definition +package com.raizlabs.dbflow5.processor.definition import com.raizlabs.dbflow5.annotation.provider.Notify import com.raizlabs.dbflow5.annotation.provider.NotifyMethod -import com.raizlabs.dbflow5.dbflow.processor.ClassNames -import com.raizlabs.dbflow5.dbflow.processor.ProcessorManager -import com.raizlabs.dbflow5.dbflow.processor.utils.annotation +import com.raizlabs.dbflow5.processor.ClassNames +import com.raizlabs.dbflow5.processor.ProcessorManager +import com.raizlabs.dbflow5.processor.utils.annotation import com.squareup.javapoet.ClassName import javax.lang.model.element.Element import javax.lang.model.element.ExecutableElement diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/OneToManyDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/OneToManyDefinition.kt similarity index 86% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/OneToManyDefinition.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/OneToManyDefinition.kt index f5865a5db..a7f2d79cb 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/OneToManyDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/OneToManyDefinition.kt @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5.dbflow.processor.definition +package com.raizlabs.dbflow5.processor.definition import com.grosner.kpoet.`for` import com.grosner.kpoet.`if` @@ -7,21 +7,21 @@ import com.grosner.kpoet.statement import com.grosner.kpoet.typeName import com.raizlabs.dbflow5.annotation.OneToMany import com.raizlabs.dbflow5.annotation.OneToManyMethod -import com.raizlabs.dbflow5.dbflow.processor.ClassNames -import com.raizlabs.dbflow5.dbflow.processor.ProcessorManager -import com.raizlabs.dbflow5.dbflow.processor.definition.column.ColumnAccessor -import com.raizlabs.dbflow5.dbflow.processor.definition.column.GetterSetter -import com.raizlabs.dbflow5.dbflow.processor.definition.column.PrivateScopeColumnAccessor -import com.raizlabs.dbflow5.dbflow.processor.definition.column.VisibleScopeColumnAccessor -import com.raizlabs.dbflow5.dbflow.processor.definition.column.modelBlock -import com.raizlabs.dbflow5.dbflow.processor.definition.column.wrapperCommaIfBaseModel -import com.raizlabs.dbflow5.dbflow.processor.definition.column.wrapperIfBaseModel -import com.raizlabs.dbflow5.dbflow.processor.utils.ModelUtils -import com.raizlabs.dbflow5.dbflow.processor.utils.annotation -import com.raizlabs.dbflow5.dbflow.processor.utils.isSubclass -import com.raizlabs.dbflow5.dbflow.processor.utils.simpleString -import com.raizlabs.dbflow5.dbflow.processor.utils.statement -import com.raizlabs.dbflow5.dbflow.processor.utils.toTypeElement +import com.raizlabs.dbflow5.processor.ClassNames +import com.raizlabs.dbflow5.processor.ProcessorManager +import com.raizlabs.dbflow5.processor.definition.column.ColumnAccessor +import com.raizlabs.dbflow5.processor.definition.column.GetterSetter +import com.raizlabs.dbflow5.processor.definition.column.PrivateScopeColumnAccessor +import com.raizlabs.dbflow5.processor.definition.column.VisibleScopeColumnAccessor +import com.raizlabs.dbflow5.processor.definition.column.modelBlock +import com.raizlabs.dbflow5.processor.definition.column.wrapperCommaIfBaseModel +import com.raizlabs.dbflow5.processor.definition.column.wrapperIfBaseModel +import com.raizlabs.dbflow5.processor.utils.ModelUtils +import com.raizlabs.dbflow5.processor.utils.annotation +import com.raizlabs.dbflow5.processor.utils.isSubclass +import com.raizlabs.dbflow5.processor.utils.simpleString +import com.raizlabs.dbflow5.processor.utils.statement +import com.raizlabs.dbflow5.processor.utils.toTypeElement import com.squareup.javapoet.ClassName import com.squareup.javapoet.CodeBlock import com.squareup.javapoet.MethodSpec diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/QueryModelDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/QueryModelDefinition.kt similarity index 86% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/QueryModelDefinition.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/QueryModelDefinition.kt index 6287ddea6..9d8593f75 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/QueryModelDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/QueryModelDefinition.kt @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5.dbflow.processor.definition +package com.raizlabs.dbflow5.processor.definition import com.grosner.kpoet.`return` import com.grosner.kpoet.final @@ -7,16 +7,16 @@ import com.grosner.kpoet.public import com.raizlabs.dbflow5.annotation.Column import com.raizlabs.dbflow5.annotation.ColumnMap import com.raizlabs.dbflow5.annotation.QueryModel -import com.raizlabs.dbflow5.dbflow.processor.ClassNames -import com.raizlabs.dbflow5.dbflow.processor.ColumnValidator -import com.raizlabs.dbflow5.dbflow.processor.ProcessorManager -import com.raizlabs.dbflow5.dbflow.processor.definition.column.ColumnDefinition -import com.raizlabs.dbflow5.dbflow.processor.definition.column.ReferenceColumnDefinition -import com.raizlabs.dbflow5.dbflow.processor.utils.ElementUtility -import com.raizlabs.dbflow5.dbflow.processor.utils.`override fun` -import com.raizlabs.dbflow5.dbflow.processor.utils.annotation -import com.raizlabs.dbflow5.dbflow.processor.utils.extractTypeNameFromAnnotation -import com.raizlabs.dbflow5.dbflow.processor.utils.implementsClass +import com.raizlabs.dbflow5.processor.ClassNames +import com.raizlabs.dbflow5.processor.ColumnValidator +import com.raizlabs.dbflow5.processor.ProcessorManager +import com.raizlabs.dbflow5.processor.definition.column.ColumnDefinition +import com.raizlabs.dbflow5.processor.definition.column.ReferenceColumnDefinition +import com.raizlabs.dbflow5.processor.utils.ElementUtility +import com.raizlabs.dbflow5.processor.utils.`override fun` +import com.raizlabs.dbflow5.processor.utils.annotation +import com.raizlabs.dbflow5.processor.utils.extractTypeNameFromAnnotation +import com.raizlabs.dbflow5.processor.utils.implementsClass import com.squareup.javapoet.ParameterizedTypeName import com.squareup.javapoet.TypeName import com.squareup.javapoet.TypeSpec diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/TableDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/TableDefinition.kt similarity index 95% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/TableDefinition.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/TableDefinition.kt index f67e1e937..37928fd44 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/TableDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/TableDefinition.kt @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5.dbflow.processor.definition +package com.raizlabs.dbflow5.processor.definition import com.grosner.kpoet.L import com.grosner.kpoet.S @@ -27,25 +27,25 @@ import com.raizlabs.dbflow5.annotation.MultiCacheField import com.raizlabs.dbflow5.annotation.OneToMany import com.raizlabs.dbflow5.annotation.PrimaryKey import com.raizlabs.dbflow5.annotation.Table -import com.raizlabs.dbflow5.dbflow.processor.ClassNames -import com.raizlabs.dbflow5.dbflow.processor.ColumnValidator -import com.raizlabs.dbflow5.dbflow.processor.OneToManyValidator -import com.raizlabs.dbflow5.dbflow.processor.ProcessorManager -import com.raizlabs.dbflow5.dbflow.processor.definition.BindToStatementMethod.Mode.DELETE -import com.raizlabs.dbflow5.dbflow.processor.definition.BindToStatementMethod.Mode.INSERT -import com.raizlabs.dbflow5.dbflow.processor.definition.BindToStatementMethod.Mode.NON_INSERT -import com.raizlabs.dbflow5.dbflow.processor.definition.BindToStatementMethod.Mode.UPDATE -import com.raizlabs.dbflow5.dbflow.processor.definition.column.ColumnDefinition -import com.raizlabs.dbflow5.dbflow.processor.definition.column.DefinitionUtils -import com.raizlabs.dbflow5.dbflow.processor.definition.column.ReferenceColumnDefinition -import com.raizlabs.dbflow5.dbflow.processor.utils.ElementUtility -import com.raizlabs.dbflow5.dbflow.processor.utils.ModelUtils -import com.raizlabs.dbflow5.dbflow.processor.utils.ModelUtils.wrapper -import com.raizlabs.dbflow5.dbflow.processor.utils.`override fun` -import com.raizlabs.dbflow5.dbflow.processor.utils.annotation -import com.raizlabs.dbflow5.dbflow.processor.utils.ensureVisibleStatic -import com.raizlabs.dbflow5.dbflow.processor.utils.implementsClass -import com.raizlabs.dbflow5.dbflow.processor.utils.isNullOrEmpty +import com.raizlabs.dbflow5.processor.ClassNames +import com.raizlabs.dbflow5.processor.ColumnValidator +import com.raizlabs.dbflow5.processor.OneToManyValidator +import com.raizlabs.dbflow5.processor.ProcessorManager +import com.raizlabs.dbflow5.processor.definition.BindToStatementMethod.Mode.DELETE +import com.raizlabs.dbflow5.processor.definition.BindToStatementMethod.Mode.INSERT +import com.raizlabs.dbflow5.processor.definition.BindToStatementMethod.Mode.NON_INSERT +import com.raizlabs.dbflow5.processor.definition.BindToStatementMethod.Mode.UPDATE +import com.raizlabs.dbflow5.processor.definition.column.ColumnDefinition +import com.raizlabs.dbflow5.processor.definition.column.DefinitionUtils +import com.raizlabs.dbflow5.processor.definition.column.ReferenceColumnDefinition +import com.raizlabs.dbflow5.processor.utils.ElementUtility +import com.raizlabs.dbflow5.processor.utils.ModelUtils +import com.raizlabs.dbflow5.processor.utils.ModelUtils.wrapper +import com.raizlabs.dbflow5.processor.utils.`override fun` +import com.raizlabs.dbflow5.processor.utils.annotation +import com.raizlabs.dbflow5.processor.utils.ensureVisibleStatic +import com.raizlabs.dbflow5.processor.utils.implementsClass +import com.raizlabs.dbflow5.processor.utils.isNullOrEmpty import com.raizlabs.dbflow5.quote import com.raizlabs.dbflow5.quoteIfNeeded import com.raizlabs.dbflow5.stripQuotes diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/TableEndpointDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/TableEndpointDefinition.kt similarity index 90% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/TableEndpointDefinition.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/TableEndpointDefinition.kt index 0e1e2597e..519be77ff 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/TableEndpointDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/TableEndpointDefinition.kt @@ -1,12 +1,12 @@ -package com.raizlabs.dbflow5.dbflow.processor.definition +package com.raizlabs.dbflow5.processor.definition import com.raizlabs.dbflow5.annotation.provider.ContentUri import com.raizlabs.dbflow5.annotation.provider.Notify import com.raizlabs.dbflow5.annotation.provider.NotifyMethod import com.raizlabs.dbflow5.annotation.provider.TableEndpoint -import com.raizlabs.dbflow5.dbflow.processor.ProcessorManager -import com.raizlabs.dbflow5.dbflow.processor.utils.annotation -import com.raizlabs.dbflow5.dbflow.processor.utils.extractTypeNameFromAnnotation +import com.raizlabs.dbflow5.processor.ProcessorManager +import com.raizlabs.dbflow5.processor.utils.annotation +import com.raizlabs.dbflow5.processor.utils.extractTypeNameFromAnnotation import com.squareup.javapoet.TypeName import javax.lang.model.element.Element import javax.lang.model.element.PackageElement diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/TypeConverterDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/TypeConverterDefinition.kt similarity index 86% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/TypeConverterDefinition.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/TypeConverterDefinition.kt index ae66dcda2..88a611de5 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/TypeConverterDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/TypeConverterDefinition.kt @@ -1,9 +1,9 @@ -package com.raizlabs.dbflow5.dbflow.processor.definition +package com.raizlabs.dbflow5.processor.definition -import com.raizlabs.dbflow5.dbflow.annotation.TypeConverter -import com.raizlabs.dbflow5.dbflow.processor.ClassNames -import com.raizlabs.dbflow5.dbflow.processor.ProcessorManager -import com.raizlabs.dbflow5.dbflow.processor.utils.annotation +import com.raizlabs.dbflow5.annotation.TypeConverter +import com.raizlabs.dbflow5.processor.ClassNames +import com.raizlabs.dbflow5.processor.ProcessorManager +import com.raizlabs.dbflow5.processor.utils.annotation import com.squareup.javapoet.ClassName import com.squareup.javapoet.TypeName import javax.lang.model.element.TypeElement diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/TypeDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/TypeDefinition.kt similarity index 81% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/TypeDefinition.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/TypeDefinition.kt index b02484495..4d1b378e0 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/TypeDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/TypeDefinition.kt @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5.dbflow.processor.definition +package com.raizlabs.dbflow5.processor.definition import com.squareup.javapoet.TypeSpec diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/UniqueGroupsDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/UniqueGroupsDefinition.kt similarity index 85% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/UniqueGroupsDefinition.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/UniqueGroupsDefinition.kt index f19c015f1..158670145 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/UniqueGroupsDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/UniqueGroupsDefinition.kt @@ -1,9 +1,9 @@ -package com.raizlabs.dbflow5.dbflow.processor.definition +package com.raizlabs.dbflow5.processor.definition import com.raizlabs.dbflow5.annotation.ConflictAction import com.raizlabs.dbflow5.annotation.UniqueGroup -import com.raizlabs.dbflow5.dbflow.processor.definition.column.ColumnDefinition -import com.raizlabs.dbflow5.dbflow.processor.definition.column.ReferenceColumnDefinition +import com.raizlabs.dbflow5.processor.definition.column.ColumnDefinition +import com.raizlabs.dbflow5.processor.definition.column.ReferenceColumnDefinition import com.raizlabs.dbflow5.quote import com.squareup.javapoet.CodeBlock diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/column/ColumnAccessCombiner.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/column/ColumnAccessCombiner.kt similarity index 97% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/column/ColumnAccessCombiner.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/column/ColumnAccessCombiner.kt index d56b2e89c..44e162cdc 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/column/ColumnAccessCombiner.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/column/ColumnAccessCombiner.kt @@ -1,16 +1,16 @@ -package com.raizlabs.dbflow5.dbflow.processor.definition.column +package com.raizlabs.dbflow5.processor.definition.column import com.grosner.kpoet.S import com.grosner.kpoet.`else` import com.grosner.kpoet.`if` import com.grosner.kpoet.end import com.grosner.kpoet.statement -import com.raizlabs.dbflow5.dbflow.processor.ClassNames -import com.raizlabs.dbflow5.dbflow.processor.SQLiteHelper -import com.raizlabs.dbflow5.dbflow.processor.utils.ModelUtils -import com.raizlabs.dbflow5.dbflow.processor.utils.catch -import com.raizlabs.dbflow5.dbflow.processor.utils.isNullOrEmpty -import com.raizlabs.dbflow5.dbflow.processor.utils.statement +import com.raizlabs.dbflow5.processor.ClassNames +import com.raizlabs.dbflow5.processor.SQLiteHelper +import com.raizlabs.dbflow5.processor.utils.ModelUtils +import com.raizlabs.dbflow5.processor.utils.catch +import com.raizlabs.dbflow5.processor.utils.isNullOrEmpty +import com.raizlabs.dbflow5.processor.utils.statement import com.raizlabs.dbflow5.quote import com.squareup.javapoet.ClassName import com.squareup.javapoet.CodeBlock diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/column/ColumnAccessor.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/column/ColumnAccessor.kt similarity index 97% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/column/ColumnAccessor.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/column/ColumnAccessor.kt index 0ce94935a..15272b9bb 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/column/ColumnAccessor.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/column/ColumnAccessor.kt @@ -1,10 +1,10 @@ -package com.raizlabs.dbflow5.dbflow.processor.definition.column +package com.raizlabs.dbflow5.processor.definition.column import com.grosner.kpoet.code import com.raizlabs.dbflow5.data.Blob -import com.raizlabs.dbflow5.dbflow.processor.utils.capitalizeFirstLetter -import com.raizlabs.dbflow5.dbflow.processor.utils.isNullOrEmpty -import com.raizlabs.dbflow5.dbflow.processor.utils.lower +import com.raizlabs.dbflow5.processor.utils.capitalizeFirstLetter +import com.raizlabs.dbflow5.processor.utils.isNullOrEmpty +import com.raizlabs.dbflow5.processor.utils.lower import com.squareup.javapoet.ClassName import com.squareup.javapoet.CodeBlock import com.squareup.javapoet.TypeName diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/column/ColumnDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/column/ColumnDefinition.kt similarity index 95% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/column/ColumnDefinition.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/column/ColumnDefinition.kt index 1d8981aa7..4723f7446 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/column/ColumnDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/column/ColumnDefinition.kt @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5.dbflow.processor.definition.column +package com.raizlabs.dbflow5.processor.definition.column import com.grosner.kpoet.code import com.raizlabs.dbflow5.annotation.Collate @@ -10,18 +10,18 @@ import com.raizlabs.dbflow5.annotation.NotNull import com.raizlabs.dbflow5.annotation.PrimaryKey import com.raizlabs.dbflow5.annotation.Unique import com.raizlabs.dbflow5.data.Blob -import com.raizlabs.dbflow5.dbflow.processor.ClassNames -import com.raizlabs.dbflow5.dbflow.processor.ProcessorManager -import com.raizlabs.dbflow5.dbflow.processor.definition.BaseDefinition -import com.raizlabs.dbflow5.dbflow.processor.definition.BaseTableDefinition -import com.raizlabs.dbflow5.dbflow.processor.definition.TableDefinition -import com.raizlabs.dbflow5.dbflow.processor.definition.TypeConverterDefinition -import com.raizlabs.dbflow5.dbflow.processor.utils.annotation -import com.raizlabs.dbflow5.dbflow.processor.utils.fromTypeMirror -import com.raizlabs.dbflow5.dbflow.processor.utils.getTypeElement -import com.raizlabs.dbflow5.dbflow.processor.utils.isNullOrEmpty -import com.raizlabs.dbflow5.dbflow.processor.utils.toClassName -import com.raizlabs.dbflow5.dbflow.processor.utils.toTypeElement +import com.raizlabs.dbflow5.processor.ClassNames +import com.raizlabs.dbflow5.processor.ProcessorManager +import com.raizlabs.dbflow5.processor.definition.BaseDefinition +import com.raizlabs.dbflow5.processor.definition.BaseTableDefinition +import com.raizlabs.dbflow5.processor.definition.TableDefinition +import com.raizlabs.dbflow5.processor.definition.TypeConverterDefinition +import com.raizlabs.dbflow5.processor.utils.annotation +import com.raizlabs.dbflow5.processor.utils.fromTypeMirror +import com.raizlabs.dbflow5.processor.utils.getTypeElement +import com.raizlabs.dbflow5.processor.utils.isNullOrEmpty +import com.raizlabs.dbflow5.processor.utils.toClassName +import com.raizlabs.dbflow5.processor.utils.toTypeElement import com.raizlabs.dbflow5.quote import com.squareup.javapoet.ArrayTypeName import com.squareup.javapoet.ClassName diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/column/DefinitionUtils.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/column/DefinitionUtils.kt similarity index 88% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/column/DefinitionUtils.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/column/DefinitionUtils.kt index 2503d1761..2471709eb 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/column/DefinitionUtils.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/column/DefinitionUtils.kt @@ -1,6 +1,6 @@ -package com.raizlabs.dbflow5.dbflow.processor.definition.column +package com.raizlabs.dbflow5.processor.definition.column -import com.raizlabs.dbflow5.dbflow.processor.SQLiteHelper +import com.raizlabs.dbflow5.processor.SQLiteHelper import com.raizlabs.dbflow5.quote import com.squareup.javapoet.CodeBlock import com.squareup.javapoet.TypeName diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/column/ForeignKeyAccessCombiner.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/column/ForeignKeyAccessCombiner.kt similarity index 96% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/column/ForeignKeyAccessCombiner.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/column/ForeignKeyAccessCombiner.kt index a26687a0d..aa0e361c9 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/column/ForeignKeyAccessCombiner.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/column/ForeignKeyAccessCombiner.kt @@ -1,8 +1,8 @@ -package com.raizlabs.dbflow5.dbflow.processor.definition.column +package com.raizlabs.dbflow5.processor.definition.column -import com.raizlabs.dbflow5.dbflow.processor.ClassNames -import com.raizlabs.dbflow5.dbflow.processor.SQLiteHelper -import com.raizlabs.dbflow5.dbflow.processor.utils.statement +import com.raizlabs.dbflow5.processor.ClassNames +import com.raizlabs.dbflow5.processor.SQLiteHelper +import com.raizlabs.dbflow5.processor.utils.statement import com.squareup.javapoet.ClassName import com.squareup.javapoet.CodeBlock import com.squareup.javapoet.NameAllocator diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/column/ReferenceColumnDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/column/ReferenceColumnDefinition.kt similarity index 95% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/column/ReferenceColumnDefinition.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/column/ReferenceColumnDefinition.kt index 2646b76de..0efe34fb0 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/column/ReferenceColumnDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/column/ReferenceColumnDefinition.kt @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5.dbflow.processor.definition.column +package com.raizlabs.dbflow5.processor.definition.column import com.grosner.kpoet.S import com.grosner.kpoet.`return` @@ -10,18 +10,18 @@ import com.raizlabs.dbflow5.annotation.ForeignKeyAction import com.raizlabs.dbflow5.annotation.ForeignKeyReference import com.raizlabs.dbflow5.annotation.QueryModel import com.raizlabs.dbflow5.annotation.Table -import com.raizlabs.dbflow5.dbflow.processor.ClassNames -import com.raizlabs.dbflow5.dbflow.processor.ProcessorManager -import com.raizlabs.dbflow5.dbflow.processor.definition.BaseTableDefinition -import com.raizlabs.dbflow5.dbflow.processor.definition.QueryModelDefinition -import com.raizlabs.dbflow5.dbflow.processor.definition.TableDefinition -import com.raizlabs.dbflow5.dbflow.processor.utils.annotation -import com.raizlabs.dbflow5.dbflow.processor.utils.fromTypeMirror -import com.raizlabs.dbflow5.dbflow.processor.utils.implementsClass -import com.raizlabs.dbflow5.dbflow.processor.utils.isNullOrEmpty -import com.raizlabs.dbflow5.dbflow.processor.utils.isSubclass -import com.raizlabs.dbflow5.dbflow.processor.utils.toTypeElement -import com.raizlabs.dbflow5.dbflow.processor.utils.toTypeErasedElement +import com.raizlabs.dbflow5.processor.ClassNames +import com.raizlabs.dbflow5.processor.ProcessorManager +import com.raizlabs.dbflow5.processor.definition.BaseTableDefinition +import com.raizlabs.dbflow5.processor.definition.QueryModelDefinition +import com.raizlabs.dbflow5.processor.definition.TableDefinition +import com.raizlabs.dbflow5.processor.utils.annotation +import com.raizlabs.dbflow5.processor.utils.fromTypeMirror +import com.raizlabs.dbflow5.processor.utils.implementsClass +import com.raizlabs.dbflow5.processor.utils.isNullOrEmpty +import com.raizlabs.dbflow5.processor.utils.isSubclass +import com.raizlabs.dbflow5.processor.utils.toTypeElement +import com.raizlabs.dbflow5.processor.utils.toTypeErasedElement import com.raizlabs.dbflow5.quote import com.raizlabs.dbflow5.quoteIfNeeded import com.squareup.javapoet.ClassName diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/column/ReferenceDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/column/ReferenceDefinition.kt similarity index 95% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/column/ReferenceDefinition.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/column/ReferenceDefinition.kt index 4e1156223..f54d1345e 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/definition/column/ReferenceDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/column/ReferenceDefinition.kt @@ -1,11 +1,11 @@ -package com.raizlabs.dbflow5.dbflow.processor.definition.column +package com.raizlabs.dbflow5.processor.definition.column import com.raizlabs.dbflow5.annotation.ConflictAction import com.raizlabs.dbflow5.data.Blob -import com.raizlabs.dbflow5.dbflow.processor.ProcessorManager -import com.raizlabs.dbflow5.dbflow.processor.definition.TypeConverterDefinition -import com.raizlabs.dbflow5.dbflow.processor.utils.ElementUtility -import com.raizlabs.dbflow5.dbflow.processor.utils.isNullOrEmpty +import com.raizlabs.dbflow5.processor.ProcessorManager +import com.raizlabs.dbflow5.processor.definition.TypeConverterDefinition +import com.raizlabs.dbflow5.processor.utils.ElementUtility +import com.raizlabs.dbflow5.processor.utils.isNullOrEmpty import com.raizlabs.dbflow5.quote import com.squareup.javapoet.ClassName import com.squareup.javapoet.CodeBlock diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/CodeExtensions.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/utils/CodeExtensions.kt similarity index 90% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/CodeExtensions.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/utils/CodeExtensions.kt index de11857f0..75d66597b 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/CodeExtensions.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/utils/CodeExtensions.kt @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5.dbflow.processor.utils +package com.raizlabs.dbflow5.processor.utils import com.grosner.kpoet.end import com.grosner.kpoet.nextControl @@ -37,7 +37,7 @@ fun MethodSpec.Builder.statement(codeBlock: CodeBlock?): MethodSpec.Builder inline fun CodeBlock.Builder.catch(exception: KClass, function: CodeBlock.Builder.() -> CodeBlock.Builder) - = nextControl("catch", statement = "\$T e", args = exception.java, function = function).end() + = nextControl("catch", statement = "\$T e", args = *arrayOf(exception.java), function = function).end() fun codeBlock(function: CodeBlock.Builder.() -> CodeBlock.Builder) = CodeBlock.builder().function().build() diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/DependencyUtils.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/utils/DependencyUtils.kt similarity index 65% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/DependencyUtils.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/utils/DependencyUtils.kt index 478e81795..6c11cda17 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/DependencyUtils.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/utils/DependencyUtils.kt @@ -1,6 +1,6 @@ -package com.raizlabs.dbflow5.dbflow.processor.utils +package com.raizlabs.dbflow5.processor.utils -import com.raizlabs.dbflow5.dbflow.processor.ProcessorManager +import com.raizlabs.dbflow5.processor.ProcessorManager /** * Used to check if class exists on class path, if so, we add the annotation to generated class files. diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/ElementExtensions.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/utils/ElementExtensions.kt similarity index 91% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/ElementExtensions.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/utils/ElementExtensions.kt index d596320fa..27c1d0373 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/ElementExtensions.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/utils/ElementExtensions.kt @@ -1,6 +1,6 @@ -package com.raizlabs.dbflow5.dbflow.processor.utils +package com.raizlabs.dbflow5.processor.utils -import com.raizlabs.dbflow5.dbflow.processor.ProcessorManager +import com.raizlabs.dbflow5.processor.ProcessorManager import com.squareup.javapoet.ClassName import com.squareup.javapoet.TypeName import javax.lang.model.element.Element diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/ElementUtility.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/utils/ElementUtility.kt similarity index 95% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/ElementUtility.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/utils/ElementUtility.kt index 93f30ed48..4b506d724 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/ElementUtility.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/utils/ElementUtility.kt @@ -1,7 +1,7 @@ -package com.raizlabs.dbflow5.dbflow.processor.utils +package com.raizlabs.dbflow5.processor.utils import com.raizlabs.dbflow5.annotation.ColumnIgnore -import com.raizlabs.dbflow5.dbflow.processor.ProcessorManager +import com.raizlabs.dbflow5.processor.ProcessorManager import com.squareup.javapoet.ClassName import javax.lang.model.element.Element import javax.lang.model.element.Modifier diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/JavaPoetExtensions.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/utils/JavaPoetExtensions.kt similarity index 97% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/JavaPoetExtensions.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/utils/JavaPoetExtensions.kt index b3654a4ab..bcb0443a8 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/JavaPoetExtensions.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/utils/JavaPoetExtensions.kt @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5.dbflow.processor.utils +package com.raizlabs.dbflow5.processor.utils import com.grosner.kpoet.returns import com.squareup.javapoet.MethodSpec diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/ModelUtils.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/utils/ModelUtils.kt similarity index 60% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/ModelUtils.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/utils/ModelUtils.kt index bc64a8bdb..67f307c37 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/ModelUtils.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/utils/ModelUtils.kt @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5.dbflow.processor.utils +package com.raizlabs.dbflow5.processor.utils object ModelUtils { diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/ProcessorUtils.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/utils/ProcessorUtils.kt similarity index 96% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/ProcessorUtils.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/utils/ProcessorUtils.kt index c330b1f9e..375bbf53c 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/ProcessorUtils.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/utils/ProcessorUtils.kt @@ -1,7 +1,7 @@ -package com.raizlabs.dbflow5.dbflow.processor.utils +package com.raizlabs.dbflow5.processor.utils -import com.raizlabs.dbflow5.dbflow.processor.ProcessorManager -import com.raizlabs.dbflow5.dbflow.processor.ProcessorManager.Companion.manager +import com.raizlabs.dbflow5.processor.ProcessorManager +import com.raizlabs.dbflow5.processor.ProcessorManager.Companion.manager import com.squareup.javapoet.ClassName import com.squareup.javapoet.TypeName import javax.annotation.processing.ProcessingEnvironment diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/StringUtils.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/utils/StringUtils.kt similarity index 90% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/StringUtils.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/utils/StringUtils.kt index ffe3201f0..0ff397016 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/StringUtils.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/utils/StringUtils.kt @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5.dbflow.processor.utils +package com.raizlabs.dbflow5.processor.utils /** * Description: diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/WriterUtils.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/utils/WriterUtils.kt similarity index 81% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/WriterUtils.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/utils/WriterUtils.kt index c6c661eef..fed113426 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/dbflow/processor/utils/WriterUtils.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/utils/WriterUtils.kt @@ -1,8 +1,8 @@ -package com.raizlabs.dbflow5.dbflow.processor.utils +package com.raizlabs.dbflow5.processor.utils import com.grosner.kpoet.javaFile -import com.raizlabs.dbflow5.dbflow.processor.ProcessorManager -import com.raizlabs.dbflow5.dbflow.processor.definition.BaseDefinition +import com.raizlabs.dbflow5.processor.ProcessorManager +import com.raizlabs.dbflow5.processor.definition.BaseDefinition import java.io.IOException /** diff --git a/dbflow-processor/src/main/resources/META-INF/services/javax.annotation.processing.Processor b/dbflow-processor/src/main/resources/META-INF/services/javax.annotation.processing.Processor index 1dd33ebb1..d6c2ce391 100644 --- a/dbflow-processor/src/main/resources/META-INF/services/javax.annotation.processing.Processor +++ b/dbflow-processor/src/main/resources/META-INF/services/javax.annotation.processing.Processor @@ -1 +1 @@ -com.raizlabs.dbflow5.dbflow.processor.DBFlowProcessor \ No newline at end of file +com.raizlabs.dbflow5.processor.DBFlowProcessor \ No newline at end of file diff --git a/dbflow-processor/src/test/java/com/raizlabs/dbflow5/dbflow/processor/test/ColumnAccessCombinerTests.kt b/dbflow-processor/src/test/java/com/raizlabs/dbflow5/processor/test/ColumnAccessCombinerTests.kt similarity index 97% rename from dbflow-processor/src/test/java/com/raizlabs/dbflow5/dbflow/processor/test/ColumnAccessCombinerTests.kt rename to dbflow-processor/src/test/java/com/raizlabs/dbflow5/processor/test/ColumnAccessCombinerTests.kt index 519e0fe3e..9b7a57384 100644 --- a/dbflow-processor/src/test/java/com/raizlabs/dbflow5/dbflow/processor/test/ColumnAccessCombinerTests.kt +++ b/dbflow-processor/src/test/java/com/raizlabs/dbflow5/processor/test/ColumnAccessCombinerTests.kt @@ -1,7 +1,7 @@ -package com.raizlabs.dbflow5.dbflow.processor.test +package com.raizlabs.dbflow5.processor.test -import com.raizlabs.dbflow5.dbflow.processor.definition.column.* -import com.raizlabs.dbflow5.dbflow.processor.definition.column.PrimaryReferenceAccessCombiner +import com.raizlabs.dbflow5.processor.definition.column.* +import com.raizlabs.dbflow5.processor.definition.column.PrimaryReferenceAccessCombiner import com.squareup.javapoet.CodeBlock import com.squareup.javapoet.TypeName import org.junit.Assert.assertEquals diff --git a/dbflow-processor/src/test/java/com/raizlabs/dbflow5/dbflow/processor/test/ForeignKeyAccessCombinerTests.kt b/dbflow-processor/src/test/java/com/raizlabs/dbflow5/processor/test/ForeignKeyAccessCombinerTests.kt similarity index 85% rename from dbflow-processor/src/test/java/com/raizlabs/dbflow5/dbflow/processor/test/ForeignKeyAccessCombinerTests.kt rename to dbflow-processor/src/test/java/com/raizlabs/dbflow5/processor/test/ForeignKeyAccessCombinerTests.kt index 774d5004d..976150892 100644 --- a/dbflow-processor/src/test/java/com/raizlabs/dbflow5/dbflow/processor/test/ForeignKeyAccessCombinerTests.kt +++ b/dbflow-processor/src/test/java/com/raizlabs/dbflow5/processor/test/ForeignKeyAccessCombinerTests.kt @@ -1,7 +1,7 @@ -package com.raizlabs.dbflow5.dbflow.processor.test +package com.raizlabs.dbflow5.processor.test -import com.raizlabs.dbflow5.dbflow.processor.definition.column.* -import com.raizlabs.dbflow5.dbflow.processor.definition.column.PrimaryReferenceAccessCombiner +import com.raizlabs.dbflow5.processor.definition.column.* +import com.raizlabs.dbflow5.processor.definition.column.PrimaryReferenceAccessCombiner import com.squareup.javapoet.ClassName import com.squareup.javapoet.CodeBlock import com.squareup.javapoet.NameAllocator @@ -73,7 +73,7 @@ class ForeignKeyAccessCombinerTest { assertEquals("if (com.fuzz.android.TestHelper_Helper.getName(model) != null) {" + "\n clause.and(test.eq(com.fuzz.android.TestHelper2_Helper.getTest(com.fuzz.android.TestHelper_Helper.getName(model))));" + "\n} else {" + - "\n clause.and(test.eq((com.raizlabs.dbflow5.dbflow.sql.language.IConditional) null));" + + "\n clause.and(test.eq((com.raizlabs.dbflow5.sql.language.IConditional) null));" + "\n}", builder.build().toString().trim()) } @@ -105,8 +105,8 @@ class ForeignKeyAccessCombinerTest { @Test fun test_canLoadFromCursor() { val foreignKeyAccessCombiner = ForeignKeyLoadFromCursorCombiner(VisibleScopeColumnAccessor("testModel1"), - ClassName.get("com.raizlabs.dbflow5.dbflow.test.container", "ParentModel"), - ClassName.get("com.raizlabs.dbflow5.dbflow.test.container", "ParentModel_Table"), false, + ClassName.get("com.raizlabs.dbflow5.test.container", "ParentModel"), + ClassName.get("com.raizlabs.dbflow5.test.container", "ParentModel_Table"), false, NameAllocator()) foreignKeyAccessCombiner.fieldAccesses += PartialLoadFromCursorAccessCombiner("testmodel_id", "name", TypeName.get(String::class.java), false, null) @@ -119,9 +119,9 @@ class ForeignKeyAccessCombinerTest { assertEquals("int index_testmodel_id = cursor.getColumnIndex(\"testmodel_id\");" + "\nint index_testmodel_type = cursor.getColumnIndex(\"testmodel_type\");" + "\nif (index_testmodel_id != -1 && !cursor.isNull(index_testmodel_id) && index_testmodel_type != -1 && !cursor.isNull(index_testmodel_type)) {" + - "\n model.testModel1 = com.raizlabs.dbflow5.dbflow.sql.language.SQLite.select().from(com.raizlabs.dbflow5.dbflow.test.container.ParentModel.class).where()" + - "\n .and(com.raizlabs.dbflow5.dbflow.test.container.ParentModel_Table.name.eq(cursor.getString(index_testmodel_id)))" + - "\n .and(com.raizlabs.dbflow5.dbflow.test.container.ParentModel_Table.type.eq(cursor.getString(index_testmodel_type)))" + + "\n model.testModel1 = com.raizlabs.dbflow5.sql.language.SQLite.select().from(com.raizlabs.dbflow5.test.container.ParentModel.class).where()" + + "\n .and(com.raizlabs.dbflow5.test.container.ParentModel_Table.name.eq(cursor.getString(index_testmodel_id)))" + + "\n .and(com.raizlabs.dbflow5.test.container.ParentModel_Table.type.eq(cursor.getString(index_testmodel_type)))" + "\n .querySingle();" + "\n} else {" + "\n model.testModel1 = null;" + @@ -131,8 +131,8 @@ class ForeignKeyAccessCombinerTest { @Test fun test_canLoadFromCursorStubbed() { val foreignKeyAccessCombiner = ForeignKeyLoadFromCursorCombiner(VisibleScopeColumnAccessor("testModel1"), - ClassName.get("com.raizlabs.dbflow5.dbflow.test.container", "ParentModel"), - ClassName.get("com.raizlabs.dbflow5.dbflow.test.container", "ParentModel_Table"), true, + ClassName.get("com.raizlabs.dbflow5.test.container", "ParentModel"), + ClassName.get("com.raizlabs.dbflow5.test.container", "ParentModel_Table"), true, NameAllocator()) foreignKeyAccessCombiner.fieldAccesses += PartialLoadFromCursorAccessCombiner("testmodel_id", "name", TypeName.get(String::class.java), false, VisibleScopeColumnAccessor("name")) @@ -145,7 +145,7 @@ class ForeignKeyAccessCombinerTest { assertEquals("int index_testmodel_id = cursor.getColumnIndex(\"testmodel_id\");" + "\nint index_testmodel_type = cursor.getColumnIndex(\"testmodel_type\");" + "\nif (index_testmodel_id != -1 && !cursor.isNull(index_testmodel_id) && index_testmodel_type != -1 && !cursor.isNull(index_testmodel_type)) {" + - "\n model.testModel1 = new com.raizlabs.dbflow5.dbflow.test.container.ParentModel();" + + "\n model.testModel1 = new com.raizlabs.dbflow5.test.container.ParentModel();" + "\n model.testModel1.name = cursor.getString(index_testmodel_id);" + "\n model.testModel1.type = cursor.getString(index_testmodel_type);" + "\n} else {" + diff --git a/dbflow-processor/src/test/java/com/raizlabs/dbflow5/dbflow/processor/test/SimpleColumnAccessorTests.kt b/dbflow-processor/src/test/java/com/raizlabs/dbflow5/processor/test/SimpleColumnAccessorTests.kt similarity index 95% rename from dbflow-processor/src/test/java/com/raizlabs/dbflow5/dbflow/processor/test/SimpleColumnAccessorTests.kt rename to dbflow-processor/src/test/java/com/raizlabs/dbflow5/processor/test/SimpleColumnAccessorTests.kt index 580497f7b..62a26103b 100644 --- a/dbflow-processor/src/test/java/com/raizlabs/dbflow5/dbflow/processor/test/SimpleColumnAccessorTests.kt +++ b/dbflow-processor/src/test/java/com/raizlabs/dbflow5/processor/test/SimpleColumnAccessorTests.kt @@ -1,6 +1,6 @@ -package com.raizlabs.dbflow5.dbflow.processor.test +package com.raizlabs.dbflow5.processor.test -import com.raizlabs.dbflow5.dbflow.processor.definition.column.* +import com.raizlabs.dbflow5.processor.definition.column.* import com.squareup.javapoet.CodeBlock import com.squareup.javapoet.TypeName import org.junit.Assert.assertEquals @@ -118,7 +118,7 @@ class EnumColumnAccessorTest { @Test fun test_canSetEnum() { val access = EnumColumnAccessor(TypeName.get(TestEnum::class.java)) - assertEquals("com.raizlabs.dbflow5.dbflow.processor.test.EnumColumnAccessorTest.TestEnum.valueOf(model.test)", + assertEquals("com.raizlabs.dbflow5.processor.test.EnumColumnAccessorTest.TestEnum.valueOf(model.test)", access.set(CodeBlock.of("model.test")).toString()) } } diff --git a/dbflow-tests/src/androidTest/AndroidManifest.xml b/dbflow-tests/src/androidTest/AndroidManifest.xml index 40517d16c..0ad683537 100644 --- a/dbflow-tests/src/androidTest/AndroidManifest.xml +++ b/dbflow-tests/src/androidTest/AndroidManifest.xml @@ -1,12 +1,12 @@ + android:name="com.raizlabs.dbflow5.test.DemoActivity"> diff --git a/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/dbflow/BaseUnitTest.kt b/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/BaseUnitTest.kt similarity index 81% rename from dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/dbflow/BaseUnitTest.kt rename to dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/BaseUnitTest.kt index 0c64be061..6da4576f6 100644 --- a/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/dbflow/BaseUnitTest.kt +++ b/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/BaseUnitTest.kt @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5.dbflow +package com.raizlabs.dbflow5 import org.junit.Rule diff --git a/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/dbflow/DBFlowInstrumentedTestRule.kt b/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/DBFlowInstrumentedTestRule.kt similarity index 94% rename from dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/dbflow/DBFlowInstrumentedTestRule.kt rename to dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/DBFlowInstrumentedTestRule.kt index 186b559dc..90306fa0a 100644 --- a/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/dbflow/DBFlowInstrumentedTestRule.kt +++ b/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/DBFlowInstrumentedTestRule.kt @@ -1,10 +1,10 @@ -package com.raizlabs.dbflow5.dbflow +package com.raizlabs.dbflow5 import com.raizlabs.dbflow5.config.DatabaseConfig import com.raizlabs.dbflow5.config.DatabaseDefinition import com.raizlabs.dbflow5.config.FlowConfig import com.raizlabs.dbflow5.config.FlowManager -import com.raizlabs.dbflow5.dbflow.prepackaged.PrepackagedDB +import com.raizlabs.dbflow5.prepackaged.PrepackagedDB import com.raizlabs.dbflow5.runtime.ContentResolverNotifier import com.raizlabs.dbflow5.sqlcipher.CipherDatabase import org.junit.rules.TestRule diff --git a/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/dbflow/ImmediateTransactionManager.kt b/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/ImmediateTransactionManager.kt similarity index 96% rename from dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/dbflow/ImmediateTransactionManager.kt rename to dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/ImmediateTransactionManager.kt index 6913293f2..4b0cbcc9a 100644 --- a/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/dbflow/ImmediateTransactionManager.kt +++ b/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/ImmediateTransactionManager.kt @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5.dbflow +package com.raizlabs.dbflow5 import com.raizlabs.dbflow5.config.DatabaseDefinition import com.raizlabs.dbflow5.transaction.BaseTransactionManager diff --git a/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/dbflow/contentobserver/ContentObserverTest.kt b/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/contentobserver/ContentObserverTest.kt similarity index 93% rename from dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/dbflow/contentobserver/ContentObserverTest.kt rename to dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/contentobserver/ContentObserverTest.kt index 37d48f8d1..3f48d7a40 100644 --- a/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/dbflow/contentobserver/ContentObserverTest.kt +++ b/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/contentobserver/ContentObserverTest.kt @@ -1,14 +1,14 @@ -package com.raizlabs.dbflow5.dbflow.contentobserver +package com.raizlabs.dbflow5.contentobserver import android.net.Uri -import com.raizlabs.dbflow5.dbflow.BaseInstrumentedUnitTest -import com.raizlabs.dbflow5.dbflow.DemoApp +import com.raizlabs.dbflow5.BaseInstrumentedUnitTest +import com.raizlabs.dbflow5.DemoApp import com.raizlabs.dbflow5.TABLE_QUERY_PARAM import com.raizlabs.dbflow5.config.FlowManager import com.raizlabs.dbflow5.config.databaseForTable import com.raizlabs.dbflow5.config.tableName -import com.raizlabs.dbflow5.dbflow.contentobserver.User_Table.id -import com.raizlabs.dbflow5.dbflow.contentobserver.User_Table.name +import com.raizlabs.dbflow5.contentobserver.User_Table.id +import com.raizlabs.dbflow5.contentobserver.User_Table.name import com.raizlabs.dbflow5.getNotificationUri import com.raizlabs.dbflow5.query.SQLOperator import com.raizlabs.dbflow5.query.delete diff --git a/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/dbflow/prepackaged/PrepackagedDBTest.kt b/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/prepackaged/PrepackagedDBTest.kt similarity index 70% rename from dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/dbflow/prepackaged/PrepackagedDBTest.kt rename to dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/prepackaged/PrepackagedDBTest.kt index d86eae7c7..ce971ff60 100644 --- a/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/dbflow/prepackaged/PrepackagedDBTest.kt +++ b/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/prepackaged/PrepackagedDBTest.kt @@ -1,7 +1,9 @@ -package com.raizlabs.dbflow5.dbflow.prepackaged +package com.raizlabs.dbflow5.prepackaged -import com.raizlabs.dbflow5.dbflow.BaseInstrumentedUnitTest +import com.raizlabs.dbflow5.BaseInstrumentedUnitTest import com.raizlabs.dbflow5.config.databaseForTable +import com.raizlabs.dbflow5.query.list +import com.raizlabs.dbflow5.query.select import org.junit.Assert.assertTrue import org.junit.Test diff --git a/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/sqlcipher/CipherTest.kt b/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/sqlcipher/CipherTest.kt index 5f3186215..f4373bdf6 100644 --- a/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/sqlcipher/CipherTest.kt +++ b/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/sqlcipher/CipherTest.kt @@ -1,8 +1,11 @@ package com.raizlabs.dbflow5.sqlcipher -import com.raizlabs.dbflow5.dbflow.BaseInstrumentedUnitTest +import com.raizlabs.dbflow5.BaseInstrumentedUnitTest import com.raizlabs.dbflow5.config.database import com.raizlabs.dbflow5.query.delete +import com.raizlabs.dbflow5.query.result +import com.raizlabs.dbflow5.query.select +import com.raizlabs.dbflow5.query.where import org.junit.Assert.assertTrue import org.junit.Test diff --git a/dbflow-tests/src/main/AndroidManifest.xml b/dbflow-tests/src/main/AndroidManifest.xml index 15b815b16..863f9d6c8 100644 --- a/dbflow-tests/src/main/AndroidManifest.xml +++ b/dbflow-tests/src/main/AndroidManifest.xml @@ -1,16 +1,16 @@ + android:name="com.raizlabs.dbflow5.test.DemoActivity"> diff --git a/dbflow-tests/src/main/java/com/raizlabs/dbflow5/dbflow/AppDatabase.kt b/dbflow-tests/src/main/java/com/raizlabs/dbflow5/AppDatabase.kt similarity index 79% rename from dbflow-tests/src/main/java/com/raizlabs/dbflow5/dbflow/AppDatabase.kt rename to dbflow-tests/src/main/java/com/raizlabs/dbflow5/AppDatabase.kt index f0ff75f67..055038824 100644 --- a/dbflow-tests/src/main/java/com/raizlabs/dbflow5/dbflow/AppDatabase.kt +++ b/dbflow-tests/src/main/java/com/raizlabs/dbflow5/AppDatabase.kt @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5.dbflow +package com.raizlabs.dbflow5 import com.raizlabs.dbflow5.annotation.Database diff --git a/dbflow-tests/src/main/java/com/raizlabs/dbflow5/dbflow/DemoApp.kt b/dbflow-tests/src/main/java/com/raizlabs/dbflow5/DemoApp.kt similarity index 87% rename from dbflow-tests/src/main/java/com/raizlabs/dbflow5/dbflow/DemoApp.kt rename to dbflow-tests/src/main/java/com/raizlabs/dbflow5/DemoApp.kt index 90ec23f57..89beaa8ae 100644 --- a/dbflow-tests/src/main/java/com/raizlabs/dbflow5/dbflow/DemoApp.kt +++ b/dbflow-tests/src/main/java/com/raizlabs/dbflow5/DemoApp.kt @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5.dbflow +package com.raizlabs.dbflow5 import android.app.Application import android.content.Context diff --git a/dbflow-tests/src/main/java/com/raizlabs/dbflow5/dbflow/StubContentProvider.kt b/dbflow-tests/src/main/java/com/raizlabs/dbflow5/StubContentProvider.kt similarity index 96% rename from dbflow-tests/src/main/java/com/raizlabs/dbflow5/dbflow/StubContentProvider.kt rename to dbflow-tests/src/main/java/com/raizlabs/dbflow5/StubContentProvider.kt index e5667f831..56589c445 100644 --- a/dbflow-tests/src/main/java/com/raizlabs/dbflow5/dbflow/StubContentProvider.kt +++ b/dbflow-tests/src/main/java/com/raizlabs/dbflow5/StubContentProvider.kt @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5.dbflow +package com.raizlabs.dbflow5 import android.content.ContentProvider import android.content.ContentValues diff --git a/dbflow-tests/src/main/java/com/raizlabs/dbflow5/dbflow/User.kt b/dbflow-tests/src/main/java/com/raizlabs/dbflow5/User.kt similarity index 91% rename from dbflow-tests/src/main/java/com/raizlabs/dbflow5/dbflow/User.kt rename to dbflow-tests/src/main/java/com/raizlabs/dbflow5/User.kt index d2295e1d4..822d55df9 100644 --- a/dbflow-tests/src/main/java/com/raizlabs/dbflow5/dbflow/User.kt +++ b/dbflow-tests/src/main/java/com/raizlabs/dbflow5/User.kt @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5.dbflow +package com.raizlabs.dbflow5 import com.raizlabs.dbflow5.annotation.Column import com.raizlabs.dbflow5.annotation.PrimaryKey diff --git a/dbflow-tests/src/main/java/com/raizlabs/dbflow5/dbflow/contentobserver/User.kt b/dbflow-tests/src/main/java/com/raizlabs/dbflow5/contentobserver/User.kt similarity index 73% rename from dbflow-tests/src/main/java/com/raizlabs/dbflow5/dbflow/contentobserver/User.kt rename to dbflow-tests/src/main/java/com/raizlabs/dbflow5/contentobserver/User.kt index 29c348aa9..643625529 100644 --- a/dbflow-tests/src/main/java/com/raizlabs/dbflow5/dbflow/contentobserver/User.kt +++ b/dbflow-tests/src/main/java/com/raizlabs/dbflow5/contentobserver/User.kt @@ -1,6 +1,6 @@ -package com.raizlabs.dbflow5.dbflow.contentobserver +package com.raizlabs.dbflow5.contentobserver -import com.raizlabs.dbflow5.dbflow.AppDatabase +import com.raizlabs.dbflow5.AppDatabase import com.raizlabs.dbflow5.annotation.Column import com.raizlabs.dbflow5.annotation.PrimaryKey import com.raizlabs.dbflow5.annotation.Table diff --git a/dbflow-tests/src/main/java/com/raizlabs/dbflow5/dbflow/prepackaged/PrepackagedDB.kt b/dbflow-tests/src/main/java/com/raizlabs/dbflow5/prepackaged/PrepackagedDB.kt similarity index 91% rename from dbflow-tests/src/main/java/com/raizlabs/dbflow5/dbflow/prepackaged/PrepackagedDB.kt rename to dbflow-tests/src/main/java/com/raizlabs/dbflow5/prepackaged/PrepackagedDB.kt index 5c7260afd..fbc0b9c5f 100644 --- a/dbflow-tests/src/main/java/com/raizlabs/dbflow5/dbflow/prepackaged/PrepackagedDB.kt +++ b/dbflow-tests/src/main/java/com/raizlabs/dbflow5/prepackaged/PrepackagedDB.kt @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5.dbflow.prepackaged +package com.raizlabs.dbflow5.prepackaged import com.raizlabs.dbflow5.annotation.Column import com.raizlabs.dbflow5.annotation.Database diff --git a/dbflow-tests/src/main/java/com/raizlabs/dbflow5/dbflow/test/DemoActivity.java b/dbflow-tests/src/main/java/com/raizlabs/dbflow5/test/DemoActivity.java similarity index 92% rename from dbflow-tests/src/main/java/com/raizlabs/dbflow5/dbflow/test/DemoActivity.java rename to dbflow-tests/src/main/java/com/raizlabs/dbflow5/test/DemoActivity.java index 76e1b74f8..4c17e0342 100644 --- a/dbflow-tests/src/main/java/com/raizlabs/dbflow5/dbflow/test/DemoActivity.java +++ b/dbflow-tests/src/main/java/com/raizlabs/dbflow5/test/DemoActivity.java @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5.dbflow.test; +package com.raizlabs.dbflow5.test; import android.app.Activity; import android.os.Bundle; @@ -8,7 +8,8 @@ import com.raizlabs.dbflow5.config.DatabaseConfig; import com.raizlabs.dbflow5.config.FlowConfig; import com.raizlabs.dbflow5.config.FlowManager; -import com.raizlabs.dbflow5.dbflow.prepackaged.PrepackagedDB; +import com.raizlabs.dbflow5.test.R; +import com.raizlabs.dbflow5.prepackaged.PrepackagedDB; public class DemoActivity extends Activity { diff --git a/dbflow-tests/src/main/res/layout/activity_demo.xml b/dbflow-tests/src/main/res/layout/activity_demo.xml index d5d0c395b..a097220b6 100644 --- a/dbflow-tests/src/main/res/layout/activity_demo.xml +++ b/dbflow-tests/src/main/res/layout/activity_demo.xml @@ -6,7 +6,7 @@ android:paddingRight="@dimen/activity_horizontal_margin" android:paddingTop="@dimen/activity_vertical_margin" android:paddingBottom="@dimen/activity_vertical_margin" - tools:context=".DemoActivity"> + tools:context="com.raizlabs.dbflow5.test.DemoActivity"> + tools:context="com.raizlabs.dbflow5.DemoActivity"> @@ -9,7 +9,7 @@ diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/BaseUnitTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/BaseUnitTest.kt similarity index 92% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/BaseUnitTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/BaseUnitTest.kt index c90e55041..3f960b816 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/BaseUnitTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/BaseUnitTest.kt @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5.dbflow +package com.raizlabs.dbflow5 import android.content.Context import org.junit.Rule diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/DBFlowTestRule.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/DBFlowTestRule.kt similarity index 93% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/DBFlowTestRule.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/DBFlowTestRule.kt index a07c470c8..f938de74e 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/DBFlowTestRule.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/DBFlowTestRule.kt @@ -1,9 +1,9 @@ -package com.raizlabs.dbflow5.dbflow +package com.raizlabs.dbflow5 import com.raizlabs.dbflow5.config.DatabaseConfig import com.raizlabs.dbflow5.config.FlowConfig import com.raizlabs.dbflow5.config.FlowManager -import com.raizlabs.dbflow5.dbflow.provider.ContentDatabase +import com.raizlabs.dbflow5.provider.ContentDatabase import org.junit.rules.TestRule import org.junit.runner.Description import org.junit.runners.model.Statement diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/ImmediateTransactionManager.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/ImmediateTransactionManager.kt similarity index 96% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/ImmediateTransactionManager.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/ImmediateTransactionManager.kt index cf4a12d7c..d0795d9b4 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/ImmediateTransactionManager.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/ImmediateTransactionManager.kt @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5.dbflow +package com.raizlabs.dbflow5 import com.raizlabs.dbflow5.config.DatabaseDefinition import com.raizlabs.dbflow5.transaction.BaseTransactionManager diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/TestDatabase.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/TestDatabase.kt similarity index 85% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/TestDatabase.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/TestDatabase.kt index 5ae85d348..573315a9c 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/TestDatabase.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/TestDatabase.kt @@ -1,9 +1,9 @@ -package com.raizlabs.dbflow5.dbflow +package com.raizlabs.dbflow5 import com.raizlabs.dbflow5.annotation.Database import com.raizlabs.dbflow5.annotation.Migration import com.raizlabs.dbflow5.migration.UpdateTableMigration -import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.models.SimpleModel /** * Description: diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/TestExtensions.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/TestExtensions.kt similarity index 94% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/TestExtensions.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/TestExtensions.kt index bfc033b69..cebf0dcc4 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/TestExtensions.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/TestExtensions.kt @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5.dbflow +package com.raizlabs.dbflow5 import com.raizlabs.dbflow5.sql.Query import org.junit.Assert.assertEquals diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/config/ConfigIntegrationTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/config/ConfigIntegrationTest.kt similarity index 85% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/config/ConfigIntegrationTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/config/ConfigIntegrationTest.kt index b9c941c35..afe3832aa 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/config/ConfigIntegrationTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/config/ConfigIntegrationTest.kt @@ -1,16 +1,11 @@ -package com.raizlabs.dbflow5.dbflow.config - -import com.raizlabs.dbflow5.config.DatabaseConfig -import com.raizlabs.dbflow5.config.FlowConfig -import com.raizlabs.dbflow5.config.FlowLog -import com.raizlabs.dbflow5.config.FlowManager -import com.raizlabs.dbflow5.dbflow.BaseUnitTest -import com.raizlabs.dbflow5.dbflow.TestDatabase +package com.raizlabs.dbflow5.config + +import com.raizlabs.dbflow5.BaseUnitTest +import com.raizlabs.dbflow5.TestDatabase import com.raizlabs.dbflow5.adapter.queriable.ListModelLoader import com.raizlabs.dbflow5.adapter.queriable.SingleModelLoader import com.raizlabs.dbflow5.adapter.saveable.ModelSaver -import com.raizlabs.dbflow5.config.TableConfig -import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.models.SimpleModel import org.junit.Assert.* import org.junit.Before import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/config/DatabaseConfigTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/config/DatabaseConfigTest.kt similarity index 89% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/config/DatabaseConfigTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/config/DatabaseConfigTest.kt index a30eac6f9..dbfef312c 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/config/DatabaseConfigTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/config/DatabaseConfigTest.kt @@ -1,13 +1,8 @@ -package com.raizlabs.dbflow5.dbflow.config +package com.raizlabs.dbflow5.config import com.nhaarman.mockito_kotlin.mock -import com.raizlabs.dbflow5.config.DatabaseConfig -import com.raizlabs.dbflow5.config.DatabaseDefinition -import com.raizlabs.dbflow5.config.FlowConfig -import com.raizlabs.dbflow5.config.FlowLog -import com.raizlabs.dbflow5.config.FlowManager -import com.raizlabs.dbflow5.dbflow.BaseUnitTest -import com.raizlabs.dbflow5.dbflow.TestDatabase +import com.raizlabs.dbflow5.BaseUnitTest +import com.raizlabs.dbflow5.TestDatabase import com.raizlabs.dbflow5.database.DatabaseHelperListener import com.raizlabs.dbflow5.database.OpenHelper import com.raizlabs.dbflow5.transaction.BaseTransactionManager diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/database/transaction/CoroutinesTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/database/transaction/CoroutinesTest.kt similarity index 88% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/database/transaction/CoroutinesTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/database/transaction/CoroutinesTest.kt index 0e6654139..9a75debab 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/database/transaction/CoroutinesTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/database/transaction/CoroutinesTest.kt @@ -1,18 +1,19 @@ -package com.raizlabs.dbflow5.dbflow.database.transaction +package com.raizlabs.dbflow5.database.transaction -import com.raizlabs.dbflow5.dbflow.BaseUnitTest -import com.raizlabs.dbflow5.dbflow.TestDatabase +import com.raizlabs.dbflow5.BaseUnitTest +import com.raizlabs.dbflow5.TestDatabase import com.raizlabs.dbflow5.config.database -import com.raizlabs.dbflow5.dbflow.models.SimpleModel -import com.raizlabs.dbflow5.dbflow.models.SimpleModel_Table +import com.raizlabs.dbflow5.models.SimpleModel +import com.raizlabs.dbflow5.models.SimpleModel_Table import com.raizlabs.dbflow5.query.delete -import com.raizlabs.dbflow5.query.where import com.raizlabs.dbflow5.structure.save import com.raizlabs.dbflow5.coroutines.awaitDelete import com.raizlabs.dbflow5.coroutines.awaitInsert import com.raizlabs.dbflow5.coroutines.awaitSave import com.raizlabs.dbflow5.coroutines.awaitUpdate import com.raizlabs.dbflow5.coroutines.transact +import com.raizlabs.dbflow5.query.list +import com.raizlabs.dbflow5.query.select import kotlinx.coroutines.experimental.runBlocking import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/database/transaction/FastStoreModelTransactionTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/database/transaction/FastStoreModelTransactionTest.kt similarity index 85% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/database/transaction/FastStoreModelTransactionTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/database/transaction/FastStoreModelTransactionTest.kt index 554a6c0c7..eaf83dccb 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/database/transaction/FastStoreModelTransactionTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/database/transaction/FastStoreModelTransactionTest.kt @@ -1,13 +1,15 @@ -package com.raizlabs.dbflow5.dbflow.database.transaction +package com.raizlabs.dbflow5.database.transaction -import com.raizlabs.dbflow5.dbflow.BaseUnitTest -import com.raizlabs.dbflow5.dbflow.TestDatabase +import com.raizlabs.dbflow5.BaseUnitTest +import com.raizlabs.dbflow5.TestDatabase import com.raizlabs.dbflow5.config.database -import com.raizlabs.dbflow5.dbflow.models.SimpleModel -import com.raizlabs.dbflow5.dbflow.models.TwoColumnModel +import com.raizlabs.dbflow5.models.SimpleModel +import com.raizlabs.dbflow5.models.TwoColumnModel import com.raizlabs.dbflow5.coroutines.awaitInsert import com.raizlabs.dbflow5.coroutines.awaitSave import com.raizlabs.dbflow5.coroutines.awaitUpdate +import com.raizlabs.dbflow5.query.list +import com.raizlabs.dbflow5.query.select import kotlinx.coroutines.experimental.runBlocking import org.junit.Assert.assertEquals import org.junit.Assert.assertNotEquals diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/migration/UpdateTableMigrationTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/migration/UpdateTableMigrationTest.kt similarity index 58% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/migration/UpdateTableMigrationTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/migration/UpdateTableMigrationTest.kt index 04b7cc554..f31196a1f 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/migration/UpdateTableMigrationTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/migration/UpdateTableMigrationTest.kt @@ -1,10 +1,9 @@ -package com.raizlabs.dbflow5.dbflow.migration +package com.raizlabs.dbflow5.migration -import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.BaseUnitTest import com.raizlabs.dbflow5.config.databaseForTable -import com.raizlabs.dbflow5.dbflow.models.SimpleModel -import com.raizlabs.dbflow5.dbflow.models.SimpleModel_Table -import com.raizlabs.dbflow5.migration.UpdateTableMigration +import com.raizlabs.dbflow5.models.SimpleModel +import com.raizlabs.dbflow5.models.SimpleModel_Table import org.junit.Test /** diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/AutoIncrementTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/AutoIncrementTest.kt similarity index 83% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/AutoIncrementTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/AutoIncrementTest.kt index 8e646fc52..2b9c465be 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/AutoIncrementTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/AutoIncrementTest.kt @@ -1,7 +1,7 @@ -package com.raizlabs.dbflow5.dbflow.models +package com.raizlabs.dbflow5.models -import com.raizlabs.dbflow5.dbflow.BaseUnitTest -import com.raizlabs.dbflow5.dbflow.TestDatabase +import com.raizlabs.dbflow5.BaseUnitTest +import com.raizlabs.dbflow5.TestDatabase import com.raizlabs.dbflow5.annotation.PrimaryKey import com.raizlabs.dbflow5.annotation.Table import com.raizlabs.dbflow5.structure.insert diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/CachingModels.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/CachingModels.kt similarity index 91% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/CachingModels.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/CachingModels.kt index c2cdfc1d0..947ceff5a 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/CachingModels.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/CachingModels.kt @@ -1,6 +1,6 @@ -package com.raizlabs.dbflow5.dbflow.models +package com.raizlabs.dbflow5.models -import com.raizlabs.dbflow5.dbflow.TestDatabase +import com.raizlabs.dbflow5.TestDatabase import com.raizlabs.dbflow5.annotation.Column import com.raizlabs.dbflow5.annotation.ForeignKey import com.raizlabs.dbflow5.annotation.MultiCacheField diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/CachingModelsTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/CachingModelsTest.kt similarity index 84% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/CachingModelsTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/CachingModelsTest.kt index 2fe488f9f..3a6e2fb11 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/CachingModelsTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/CachingModelsTest.kt @@ -1,8 +1,11 @@ -package com.raizlabs.dbflow5.dbflow.models +package com.raizlabs.dbflow5.models -import com.raizlabs.dbflow5.dbflow.BaseUnitTest -import com.raizlabs.dbflow5.dbflow.TestDatabase +import com.raizlabs.dbflow5.BaseUnitTest +import com.raizlabs.dbflow5.TestDatabase import com.raizlabs.dbflow5.config.database +import com.raizlabs.dbflow5.query.list +import com.raizlabs.dbflow5.query.result +import com.raizlabs.dbflow5.query.select import com.raizlabs.dbflow5.structure.save import org.junit.Assert.assertEquals import org.junit.Assert.assertNotEquals diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/DontCreateModelTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/DontCreateModelTest.kt similarity index 67% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/DontCreateModelTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/DontCreateModelTest.kt index d61beade1..b753d6a14 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/DontCreateModelTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/DontCreateModelTest.kt @@ -1,9 +1,11 @@ -package com.raizlabs.dbflow5.dbflow.models +package com.raizlabs.dbflow5.models import android.database.sqlite.SQLiteException -import com.raizlabs.dbflow5.dbflow.BaseUnitTest -import com.raizlabs.dbflow5.dbflow.assertThrowsException +import com.raizlabs.dbflow5.BaseUnitTest +import com.raizlabs.dbflow5.assertThrowsException import com.raizlabs.dbflow5.config.databaseForTable +import com.raizlabs.dbflow5.query.list +import com.raizlabs.dbflow5.query.select import org.junit.Test /** diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/ForeignKeyModels.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/ForeignKeyModels.kt similarity index 97% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/ForeignKeyModels.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/ForeignKeyModels.kt index b8f52de09..abcbb55e3 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/ForeignKeyModels.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/ForeignKeyModels.kt @@ -1,7 +1,7 @@ -package com.raizlabs.dbflow5.dbflow.models +package com.raizlabs.dbflow5.models import android.database.Cursor -import com.raizlabs.dbflow5.dbflow.TestDatabase +import com.raizlabs.dbflow5.TestDatabase import com.raizlabs.dbflow5.annotation.Column import com.raizlabs.dbflow5.annotation.ColumnMap import com.raizlabs.dbflow5.annotation.ColumnMapReference diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/IndexModels.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/IndexModels.kt similarity index 91% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/IndexModels.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/IndexModels.kt index 7f54dee68..1b4ee29ff 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/IndexModels.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/IndexModels.kt @@ -1,6 +1,6 @@ -package com.raizlabs.dbflow5.dbflow.models +package com.raizlabs.dbflow5.models -import com.raizlabs.dbflow5.dbflow.TestDatabase +import com.raizlabs.dbflow5.TestDatabase import com.raizlabs.dbflow5.annotation.Column import com.raizlabs.dbflow5.annotation.Index import com.raizlabs.dbflow5.annotation.IndexGroup diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/InnerClassExample.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/InnerClassExample.kt similarity index 73% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/InnerClassExample.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/InnerClassExample.kt index 8aedff3f6..633a1b718 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/InnerClassExample.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/InnerClassExample.kt @@ -1,6 +1,6 @@ -package com.raizlabs.dbflow5.dbflow.models +package com.raizlabs.dbflow5.models -import com.raizlabs.dbflow5.dbflow.TestDatabase +import com.raizlabs.dbflow5.TestDatabase import com.raizlabs.dbflow5.annotation.PrimaryKey import com.raizlabs.dbflow5.annotation.Table diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/ManyToMany.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/ManyToMany.kt similarity index 85% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/ManyToMany.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/ManyToMany.kt index 448bdb852..424a11e72 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/ManyToMany.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/ManyToMany.kt @@ -1,6 +1,6 @@ -package com.raizlabs.dbflow5.dbflow.models +package com.raizlabs.dbflow5.models -import com.raizlabs.dbflow5.dbflow.TestDatabase +import com.raizlabs.dbflow5.TestDatabase import com.raizlabs.dbflow5.annotation.Column import com.raizlabs.dbflow5.annotation.ManyToMany import com.raizlabs.dbflow5.annotation.PrimaryKey diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/ManyToManyTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/ManyToManyTest.kt similarity index 75% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/ManyToManyTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/ManyToManyTest.kt index 1421b6bd5..63d9bb62c 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/ManyToManyTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/ManyToManyTest.kt @@ -1,6 +1,8 @@ -package com.raizlabs.dbflow5.dbflow.models +package com.raizlabs.dbflow5.models -import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.BaseUnitTest +import com.raizlabs.dbflow5.models.Artist +import com.raizlabs.dbflow5.models.Song import com.raizlabs.dbflow5.structure.save import org.junit.Assert.assertTrue import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/ModelViewTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/ModelViewTest.kt similarity index 68% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/ModelViewTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/ModelViewTest.kt index 4aa9b4b93..81be0d3f7 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/ModelViewTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/ModelViewTest.kt @@ -1,10 +1,10 @@ -package com.raizlabs.dbflow5.dbflow.models +package com.raizlabs.dbflow5.models -import com.raizlabs.dbflow5.dbflow.BaseUnitTest -import com.raizlabs.dbflow5.dbflow.TestDatabase -import com.raizlabs.dbflow5.dbflow.assertEquals +import com.raizlabs.dbflow5.BaseUnitTest +import com.raizlabs.dbflow5.TestDatabase +import com.raizlabs.dbflow5.assertEquals import com.raizlabs.dbflow5.config.database -import com.raizlabs.dbflow5.dbflow.models.java.JavaModelView +import com.raizlabs.dbflow5.models.java.JavaModelView import org.junit.Test class ModelViewTest : BaseUnitTest() { diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/ModelViews.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/ModelViews.kt similarity index 88% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/ModelViews.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/ModelViews.kt index b0958a0ad..4c09ca5fd 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/ModelViews.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/ModelViews.kt @@ -1,14 +1,15 @@ -package com.raizlabs.dbflow5.dbflow.models +package com.raizlabs.dbflow5.models -import com.raizlabs.dbflow5.dbflow.TestDatabase +import com.raizlabs.dbflow5.TestDatabase import com.raizlabs.dbflow5.annotation.Column import com.raizlabs.dbflow5.annotation.ColumnMap import com.raizlabs.dbflow5.annotation.ModelView import com.raizlabs.dbflow5.annotation.ModelViewQuery import com.raizlabs.dbflow5.database.DatabaseWrapper -import com.raizlabs.dbflow5.dbflow.models.Author_Table.* +import com.raizlabs.dbflow5.models.Author_Table.* import com.raizlabs.dbflow5.query.property.IProperty import com.raizlabs.dbflow5.query.property.property +import com.raizlabs.dbflow5.query.select class AuthorName(var name: String = "", var age: Int = 0) diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/NonTypical/nonTypicalClassName.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/NonTypical/nonTypicalClassName.kt similarity index 71% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/NonTypical/nonTypicalClassName.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/NonTypical/nonTypicalClassName.kt index bf5cde466..d2cbd434d 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/NonTypical/nonTypicalClassName.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/NonTypical/nonTypicalClassName.kt @@ -1,6 +1,6 @@ -package com.raizlabs.dbflow5.dbflow.models.NonTypical +package com.raizlabs.dbflow5.models.NonTypical -import com.raizlabs.dbflow5.dbflow.TestDatabase +import com.raizlabs.dbflow5.TestDatabase import com.raizlabs.dbflow5.annotation.PrimaryKey import com.raizlabs.dbflow5.annotation.Table diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/OneToManyModelTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/OneToManyModelTest.kt similarity index 84% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/OneToManyModelTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/OneToManyModelTest.kt index e5679d7ae..d0de70e0a 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/OneToManyModelTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/OneToManyModelTest.kt @@ -1,8 +1,11 @@ -package com.raizlabs.dbflow5.dbflow.models +package com.raizlabs.dbflow5.models -import com.raizlabs.dbflow5.dbflow.BaseUnitTest -import com.raizlabs.dbflow5.dbflow.TestDatabase +import com.raizlabs.dbflow5.BaseUnitTest +import com.raizlabs.dbflow5.TestDatabase import com.raizlabs.dbflow5.config.database +import com.raizlabs.dbflow5.query.list +import com.raizlabs.dbflow5.query.result +import com.raizlabs.dbflow5.query.select import com.raizlabs.dbflow5.structure.delete import com.raizlabs.dbflow5.structure.exists import com.raizlabs.dbflow5.structure.save diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/OneToManyModels.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/OneToManyModels.kt similarity index 91% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/OneToManyModels.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/OneToManyModels.kt index e0392be26..f789d1f2d 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/OneToManyModels.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/OneToManyModels.kt @@ -1,13 +1,14 @@ -package com.raizlabs.dbflow5.dbflow.models +package com.raizlabs.dbflow5.models -import com.raizlabs.dbflow5.dbflow.TestDatabase +import com.raizlabs.dbflow5.TestDatabase import com.raizlabs.dbflow5.annotation.OneToMany import com.raizlabs.dbflow5.annotation.OneToManyMethod import com.raizlabs.dbflow5.annotation.PrimaryKey import com.raizlabs.dbflow5.annotation.Table import com.raizlabs.dbflow5.config.databaseForTable import com.raizlabs.dbflow5.database.DatabaseWrapper -import com.raizlabs.dbflow5.dbflow.models.TwoColumnModel_Table.id +import com.raizlabs.dbflow5.models.TwoColumnModel_Table.id +import com.raizlabs.dbflow5.query.select import com.raizlabs.dbflow5.structure.BaseModel import com.raizlabs.dbflow5.structure.oneToMany diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/ParentChildCachingTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/ParentChildCachingTest.kt similarity index 80% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/ParentChildCachingTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/ParentChildCachingTest.kt index bd47f0b14..f734a5e2d 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/ParentChildCachingTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/ParentChildCachingTest.kt @@ -1,8 +1,10 @@ -package com.raizlabs.dbflow5.dbflow.models +package com.raizlabs.dbflow5.models -import com.raizlabs.dbflow5.dbflow.BaseUnitTest -import com.raizlabs.dbflow5.dbflow.TestDatabase +import com.raizlabs.dbflow5.BaseUnitTest +import com.raizlabs.dbflow5.TestDatabase import com.raizlabs.dbflow5.config.database +import com.raizlabs.dbflow5.query.result +import com.raizlabs.dbflow5.query.select import com.raizlabs.dbflow5.structure.load import com.raizlabs.dbflow5.structure.save import org.junit.Assert.assertEquals diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/QueryModelTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/QueryModelTest.kt similarity index 72% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/QueryModelTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/QueryModelTest.kt index a0000d829..9e2501bb5 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/QueryModelTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/QueryModelTest.kt @@ -1,11 +1,14 @@ -package com.raizlabs.dbflow5.dbflow.models +package com.raizlabs.dbflow5.models -import com.raizlabs.dbflow5.dbflow.BaseUnitTest -import com.raizlabs.dbflow5.dbflow.TestDatabase +import com.raizlabs.dbflow5.BaseUnitTest +import com.raizlabs.dbflow5.TestDatabase import com.raizlabs.dbflow5.config.database -import com.raizlabs.dbflow5.dbflow.models.Author_Table.id -import com.raizlabs.dbflow5.dbflow.models.Blog_Table.author_id -import com.raizlabs.dbflow5.dbflow.models.Blog_Table.name +import com.raizlabs.dbflow5.models.Author_Table.id +import com.raizlabs.dbflow5.models.Blog_Table.author_id +import com.raizlabs.dbflow5.models.Blog_Table.name +import com.raizlabs.dbflow5.query.innerJoin +import com.raizlabs.dbflow5.query.on +import com.raizlabs.dbflow5.query.select import com.raizlabs.dbflow5.structure.exists import com.raizlabs.dbflow5.structure.save import org.junit.Assert.assertEquals diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/QueryModels.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/QueryModels.kt similarity index 85% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/QueryModels.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/QueryModels.kt index a1dc0e94b..c800b703f 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/QueryModels.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/QueryModels.kt @@ -1,6 +1,6 @@ -package com.raizlabs.dbflow5.dbflow.models +package com.raizlabs.dbflow5.models -import com.raizlabs.dbflow5.dbflow.TestDatabase +import com.raizlabs.dbflow5.TestDatabase import com.raizlabs.dbflow5.annotation.Column import com.raizlabs.dbflow5.annotation.QueryModel import com.raizlabs.dbflow5.converter.TypeConverter @@ -16,7 +16,7 @@ class CustomBlobModel(@Column var myBlob: MyBlob? = null) { class MyBlob(val blob: ByteArray) - @com.raizlabs.dbflow5.dbflow.annotation.TypeConverter + @com.raizlabs.dbflow5.annotation.TypeConverter class MyTypeConverter : TypeConverter() { override fun getDBValue(model: MyBlob?) = model?.let { Blob(model.blob) } diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/SimpleTestModels.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/SimpleTestModels.kt similarity index 98% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/SimpleTestModels.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/SimpleTestModels.kt index 48a3613da..a92c9eaae 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/SimpleTestModels.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/SimpleTestModels.kt @@ -1,6 +1,6 @@ -package com.raizlabs.dbflow5.dbflow.models +package com.raizlabs.dbflow5.models -import com.raizlabs.dbflow5.dbflow.TestDatabase +import com.raizlabs.dbflow5.TestDatabase import com.raizlabs.dbflow5.annotation.Column import com.raizlabs.dbflow5.annotation.ColumnIgnore import com.raizlabs.dbflow5.annotation.ConflictAction @@ -158,7 +158,7 @@ class CustomEnumTypeConverter : TypeConverter() { } -@com.raizlabs.dbflow5.dbflow.annotation.TypeConverter +@com.raizlabs.dbflow5.annotation.TypeConverter class BlobConverter : TypeConverter() { override fun getDBValue(model: ByteArray?): Blob? { diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/issue/Issue.java b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/issue/Issue.java similarity index 91% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/issue/Issue.java rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/issue/Issue.java index 716b1d0b9..d52448436 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/issue/Issue.java +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/issue/Issue.java @@ -1,6 +1,6 @@ -package com.raizlabs.dbflow5.dbflow.models.issue; +package com.raizlabs.dbflow5.models.issue; -import com.raizlabs.dbflow5.dbflow.TestDatabase; +import com.raizlabs.dbflow5.TestDatabase; import com.raizlabs.dbflow5.annotation.OneToMany; import com.raizlabs.dbflow5.annotation.OneToManyMethod; import com.raizlabs.dbflow5.annotation.PrimaryKey; diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/issue/Page.java b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/issue/Page.java similarity index 83% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/issue/Page.java rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/issue/Page.java index 904fffe2d..28e0a327b 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/issue/Page.java +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/issue/Page.java @@ -1,6 +1,6 @@ -package com.raizlabs.dbflow5.dbflow.models.issue; +package com.raizlabs.dbflow5.models.issue; -import com.raizlabs.dbflow5.dbflow.TestDatabase; +import com.raizlabs.dbflow5.TestDatabase; import com.raizlabs.dbflow5.annotation.Column; import com.raizlabs.dbflow5.annotation.ForeignKey; import com.raizlabs.dbflow5.annotation.PrimaryKey; diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/issue/SubIssue.java b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/issue/SubIssue.java similarity index 92% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/issue/SubIssue.java rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/issue/SubIssue.java index a0c0ba83d..5e29cd3c5 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/issue/SubIssue.java +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/issue/SubIssue.java @@ -1,6 +1,6 @@ -package com.raizlabs.dbflow5.dbflow.models.issue; +package com.raizlabs.dbflow5.models.issue; -import com.raizlabs.dbflow5.dbflow.TestDatabase; +import com.raizlabs.dbflow5.TestDatabase; import com.raizlabs.dbflow5.annotation.OneToMany; import com.raizlabs.dbflow5.annotation.OneToManyMethod; import com.raizlabs.dbflow5.annotation.PrimaryKey; diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/java/DatabaseModel.java b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/java/DatabaseModel.java similarity index 86% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/java/DatabaseModel.java rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/java/DatabaseModel.java index de038aec8..5c174fd6c 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/java/DatabaseModel.java +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/java/DatabaseModel.java @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5.dbflow.models.java; +package com.raizlabs.dbflow5.models.java; import com.raizlabs.dbflow5.annotation.PrimaryKey; import com.raizlabs.dbflow5.structure.BaseModel; diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/java/JavaModelView.java b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/java/JavaModelView.java similarity index 80% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/java/JavaModelView.java rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/java/JavaModelView.java index 24b486cee..b0b5cb386 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/java/JavaModelView.java +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/java/JavaModelView.java @@ -1,11 +1,11 @@ -package com.raizlabs.dbflow5.dbflow.models.java; +package com.raizlabs.dbflow5.models.java; -import com.raizlabs.dbflow5.dbflow.TestDatabase; +import com.raizlabs.dbflow5.TestDatabase; import com.raizlabs.dbflow5.annotation.Column; import com.raizlabs.dbflow5.annotation.ModelView; import com.raizlabs.dbflow5.annotation.ModelViewQuery; import com.raizlabs.dbflow5.database.DatabaseWrapper; -import com.raizlabs.dbflow5.dbflow.models.Author_Table; +import com.raizlabs.dbflow5.models.Author_Table; import com.raizlabs.dbflow5.query.SQLite; import com.raizlabs.dbflow5.sql.Query; diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/java/otherpackage/ExampleModel.java b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/java/otherpackage/ExampleModel.java similarity index 55% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/java/otherpackage/ExampleModel.java rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/java/otherpackage/ExampleModel.java index 7dc440f6b..11e1b3862 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/models/java/otherpackage/ExampleModel.java +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/java/otherpackage/ExampleModel.java @@ -1,9 +1,9 @@ -package com.raizlabs.dbflow5.dbflow.models.java.otherpackage; +package com.raizlabs.dbflow5.models.java.otherpackage; -import com.raizlabs.dbflow5.dbflow.TestDatabase; +import com.raizlabs.dbflow5.TestDatabase; import com.raizlabs.dbflow5.annotation.Column; import com.raizlabs.dbflow5.annotation.Table; -import com.raizlabs.dbflow5.dbflow.models.java.DatabaseModel; +import com.raizlabs.dbflow5.models.java.DatabaseModel; @Table(database = TestDatabase.class) public class ExampleModel extends DatabaseModel { diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/provider/ContentProviderObjects.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/provider/ContentProviderObjects.kt similarity index 93% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/provider/ContentProviderObjects.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/provider/ContentProviderObjects.kt index 6fac8533c..d7bf22f60 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/provider/ContentProviderObjects.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/provider/ContentProviderObjects.kt @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5.dbflow.provider +package com.raizlabs.dbflow5.provider import com.raizlabs.dbflow5.annotation.Column import com.raizlabs.dbflow5.annotation.Database @@ -10,9 +10,6 @@ import com.raizlabs.dbflow5.annotation.provider.ContentProvider import com.raizlabs.dbflow5.annotation.provider.ContentType import com.raizlabs.dbflow5.annotation.provider.ContentUri import com.raizlabs.dbflow5.annotation.provider.TableEndpoint -import com.raizlabs.dbflow5.provider.BaseProviderModel -import com.raizlabs.dbflow5.provider.BaseSyncableProviderModel -import com.raizlabs.dbflow5.provider.ContentUtils /** @@ -52,7 +49,7 @@ class ContentProviderModel(@PrimaryKey(autoincrement = true) const val NAME = "ContentProviderModel" - @ContentUri(path = NAME, type = "${ContentType.VND_MULTIPLE}$NAME") + @ContentUri(path = NAME, type = "${ContentType.VND_MULTIPLE}${NAME}") val CONTENT_URI = ContentUtils.buildUriWithAuthority(ContentDatabase.AUTHORITY) } } diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/provider/ContentProviderTests.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/provider/ContentProviderTests.kt similarity index 94% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/provider/ContentProviderTests.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/provider/ContentProviderTests.kt index 15d554bf5..9fa5ee3fb 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/provider/ContentProviderTests.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/provider/ContentProviderTests.kt @@ -1,18 +1,21 @@ -package com.raizlabs.dbflow5.dbflow.provider +package com.raizlabs.dbflow5.provider import android.content.ContentResolver import android.content.pm.ProviderInfo -import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.BaseUnitTest import com.raizlabs.dbflow5.config.database import com.raizlabs.dbflow5.query.Delete.Companion.table import com.raizlabs.dbflow5.query.Delete.Companion.tables +import com.raizlabs.dbflow5.query.result +import com.raizlabs.dbflow5.query.select import com.raizlabs.dbflow5.structure.delete import com.raizlabs.dbflow5.structure.exists import com.raizlabs.dbflow5.structure.insert import com.raizlabs.dbflow5.structure.save import com.raizlabs.dbflow5.structure.update -import com.raizlabs.dbflow5.provider.ContentUtils -import org.junit.Assert.* +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue import org.junit.Before import org.junit.Test import org.robolectric.Robolectric diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/provider/RealContentProvider.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/provider/RealContentProvider.kt similarity index 92% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/provider/RealContentProvider.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/provider/RealContentProvider.kt index 19dba1947..5e491341c 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/provider/RealContentProvider.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/provider/RealContentProvider.kt @@ -1,10 +1,10 @@ -package com.raizlabs.dbflow5.dbflow.provider +package com.raizlabs.dbflow5.provider import android.content.ContentProvider import android.content.ContentValues import android.database.Cursor import android.net.Uri -import com.raizlabs.dbflow5.dbflow.TestDatabase +import com.raizlabs.dbflow5.TestDatabase import com.raizlabs.dbflow5.config.FlowConfig import com.raizlabs.dbflow5.config.FlowManager import com.raizlabs.dbflow5.database.DatabaseWrapper diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/provider/TestContentProvider.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/provider/TestContentProvider.kt similarity index 94% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/provider/TestContentProvider.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/provider/TestContentProvider.kt index 3a898e696..3290a797a 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/provider/TestContentProvider.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/provider/TestContentProvider.kt @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5.dbflow.provider +package com.raizlabs.dbflow5.provider import android.content.ContentValues import android.content.Context @@ -16,7 +16,7 @@ import com.raizlabs.dbflow5.getContentValuesKey baseContentUri = TestContentProvider.BASE_CONTENT_URI) object TestContentProvider { - const val AUTHORITY = "com.raizlabs.dbflow5.dbflow.test.provider" + const val AUTHORITY = "com.raizlabs.dbflow5.test.provider" const val BASE_CONTENT_URI = "content://" @@ -34,12 +34,12 @@ object TestContentProvider { const val ENDPOINT = "ContentProviderModel" @JvmStatic - @ContentUri(path = ContentProviderModel.ENDPOINT, + @ContentUri(path = ENDPOINT, type = ContentType.VND_MULTIPLE + ENDPOINT) var CONTENT_URI = buildUri(ENDPOINT) @JvmStatic - @ContentUri(path = ContentProviderModel.ENDPOINT + "/#", + @ContentUri(path = ENDPOINT + "/#", type = ContentType.VND_SINGLE + ENDPOINT, segments = arrayOf(PathSegment(segment = 1, column = "id"))) fun withId(id: Long): Uri { @@ -47,7 +47,7 @@ object TestContentProvider { } @JvmStatic - @Notify(notifyMethod = NotifyMethod.INSERT, paths = arrayOf(ContentProviderModel.ENDPOINT + "/#")) + @Notify(notifyMethod = NotifyMethod.INSERT, paths = arrayOf(ENDPOINT + "/#")) fun onInsert(contentValues: ContentValues): Array { val id = contentValues.getAsLong("id")!! return arrayOf(withId(id)) @@ -131,7 +131,7 @@ object TestContentProvider { const val ENDPOINT = "TestSyncableModel" - @ContentUri(path = ENDPOINT, type = "${ContentType.VND_MULTIPLE}$ENDPOINT") + @ContentUri(path = ENDPOINT, type = "${ContentType.VND_MULTIPLE}${ENDPOINT}") var CONTENT_URI = buildUri(ENDPOINT) } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/query/cache/ModelLruCacheTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/query/cache/ModelLruCacheTest.kt similarity index 77% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/query/cache/ModelLruCacheTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/query/cache/ModelLruCacheTest.kt index 49dd26fa2..ea4fbb46c 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/query/cache/ModelLruCacheTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/query/cache/ModelLruCacheTest.kt @@ -1,8 +1,7 @@ -package com.raizlabs.dbflow5.dbflow.query.cache +package com.raizlabs.dbflow5.query.cache -import com.raizlabs.dbflow5.dbflow.BaseUnitTest -import com.raizlabs.dbflow5.dbflow.models.NumberModel -import com.raizlabs.dbflow5.query.cache.SimpleMapCache +import com.raizlabs.dbflow5.BaseUnitTest +import com.raizlabs.dbflow5.models.NumberModel import org.junit.Assert import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/query/cache/SimpleMapCacheTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/query/cache/SimpleMapCacheTest.kt similarity index 78% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/query/cache/SimpleMapCacheTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/query/cache/SimpleMapCacheTest.kt index d8f639d45..adae8b6f6 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/query/cache/SimpleMapCacheTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/query/cache/SimpleMapCacheTest.kt @@ -1,8 +1,7 @@ -package com.raizlabs.dbflow5.dbflow.query.cache +package com.raizlabs.dbflow5.query.cache -import com.raizlabs.dbflow5.dbflow.BaseUnitTest -import com.raizlabs.dbflow5.dbflow.models.SimpleModel -import com.raizlabs.dbflow5.query.cache.SimpleMapCache +import com.raizlabs.dbflow5.BaseUnitTest +import com.raizlabs.dbflow5.models.SimpleModel import org.junit.Assert.assertEquals import org.junit.Assert.assertTrue import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/query/list/FlowCursorIteratorTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/query/list/FlowCursorIteratorTest.kt similarity index 89% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/query/list/FlowCursorIteratorTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/query/list/FlowCursorIteratorTest.kt index 0c9616673..e8f9601c1 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/query/list/FlowCursorIteratorTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/query/list/FlowCursorIteratorTest.kt @@ -1,8 +1,9 @@ -package com.raizlabs.dbflow5.dbflow.query.list +package com.raizlabs.dbflow5.query.list -import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.BaseUnitTest import com.raizlabs.dbflow5.config.databaseForTable -import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.models.SimpleModel +import com.raizlabs.dbflow5.query.select import com.raizlabs.dbflow5.structure.save import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/query/list/FlowCursorListTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/query/list/FlowCursorListTest.kt similarity index 90% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/query/list/FlowCursorListTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/query/list/FlowCursorListTest.kt index cc029265c..322fe3215 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/query/list/FlowCursorListTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/query/list/FlowCursorListTest.kt @@ -1,13 +1,14 @@ -package com.raizlabs.dbflow5.dbflow.query.list +package com.raizlabs.dbflow5.query.list import com.nhaarman.mockito_kotlin.mock import com.nhaarman.mockito_kotlin.times import com.nhaarman.mockito_kotlin.verify -import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.BaseUnitTest import com.raizlabs.dbflow5.config.databaseForTable -import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.models.SimpleModel +import com.raizlabs.dbflow5.query.cursor +import com.raizlabs.dbflow5.query.select import com.raizlabs.dbflow5.structure.save -import com.raizlabs.dbflow5.query.list.FlowCursorList import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/runtime/DirectNotifierTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/runtime/DirectNotifierTest.kt similarity index 89% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/runtime/DirectNotifierTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/runtime/DirectNotifierTest.kt index a1c436034..cf141ad96 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/runtime/DirectNotifierTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/runtime/DirectNotifierTest.kt @@ -1,17 +1,17 @@ -package com.raizlabs.dbflow5.dbflow.runtime +package com.raizlabs.dbflow5.runtime import android.content.Context import com.nhaarman.mockito_kotlin.mock import com.nhaarman.mockito_kotlin.times import com.nhaarman.mockito_kotlin.verify -import com.raizlabs.dbflow5.dbflow.ImmediateTransactionManager2 -import com.raizlabs.dbflow5.dbflow.TestDatabase +import com.raizlabs.dbflow5.ImmediateTransactionManager2 +import com.raizlabs.dbflow5.TestDatabase import com.raizlabs.dbflow5.config.DatabaseConfig import com.raizlabs.dbflow5.config.FlowConfig import com.raizlabs.dbflow5.config.FlowManager import com.raizlabs.dbflow5.config.databaseForTable -import com.raizlabs.dbflow5.dbflow.models.SimpleModel -import com.raizlabs.dbflow5.dbflow.models.SimpleModel_Table +import com.raizlabs.dbflow5.models.SimpleModel +import com.raizlabs.dbflow5.models.SimpleModel_Table import com.raizlabs.dbflow5.query.columnValues import com.raizlabs.dbflow5.query.delete import com.raizlabs.dbflow5.query.insert @@ -22,8 +22,6 @@ import com.raizlabs.dbflow5.structure.delete import com.raizlabs.dbflow5.structure.insert import com.raizlabs.dbflow5.structure.save import com.raizlabs.dbflow5.structure.update -import com.raizlabs.dbflow5.runtime.DirectModelNotifier -import com.raizlabs.dbflow5.runtime.OnTableChangedListener import org.junit.After import org.junit.Before import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/rx/query/CursorResultSubscriberTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/rx/query/CursorResultSubscriberTest.kt index 2b8b34713..bfeebe7e4 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/rx/query/CursorResultSubscriberTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/rx/query/CursorResultSubscriberTest.kt @@ -1,8 +1,9 @@ package com.raizlabs.dbflow5.rx.query -import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.BaseUnitTest import com.raizlabs.dbflow5.config.databaseForTable -import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.models.SimpleModel +import com.raizlabs.dbflow5.query.select import com.raizlabs.dbflow5.structure.save import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/rx/query/RXQueryTests.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/rx/query/RXQueryTests.kt index 376d03d4d..fd5ebdba3 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/rx/query/RXQueryTests.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/rx/query/RXQueryTests.kt @@ -1,13 +1,14 @@ package com.raizlabs.dbflow5.rx.query import android.database.Cursor -import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.BaseUnitTest import com.raizlabs.dbflow5.config.databaseForTable import com.raizlabs.dbflow5.database.DatabaseStatement -import com.raizlabs.dbflow5.dbflow.models.SimpleModel -import com.raizlabs.dbflow5.dbflow.models.SimpleModel_Table.name +import com.raizlabs.dbflow5.models.SimpleModel +import com.raizlabs.dbflow5.models.SimpleModel_Table.name import com.raizlabs.dbflow5.query.insert import com.raizlabs.dbflow5.query.property.Property +import com.raizlabs.dbflow5.query.select import com.raizlabs.dbflow5.query.selectCountOf import com.raizlabs.dbflow5.structure.save import org.junit.Assert.assertEquals diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/rx/query/RxModels.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/rx/query/RxModels.kt index c88763bde..31290e571 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/rx/query/RxModels.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/rx/query/RxModels.kt @@ -1,6 +1,6 @@ package com.raizlabs.dbflow5.rx.query -import com.raizlabs.dbflow5.dbflow.TestDatabase +import com.raizlabs.dbflow5.TestDatabase import com.raizlabs.dbflow5.annotation.PrimaryKey import com.raizlabs.dbflow5.annotation.Table import com.raizlabs.dbflow5.rx.structure.BaseRXModel diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/CaseTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/CaseTest.kt similarity index 83% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/CaseTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/CaseTest.kt index 31925f2d8..5f13551e5 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/CaseTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/CaseTest.kt @@ -1,8 +1,8 @@ -package com.raizlabs.dbflow5.dbflow.sql.language +package com.raizlabs.dbflow5.sql.language -import com.raizlabs.dbflow5.dbflow.BaseUnitTest -import com.raizlabs.dbflow5.dbflow.models.SimpleModel_Table -import com.raizlabs.dbflow5.dbflow.query.case +import com.raizlabs.dbflow5.BaseUnitTest +import com.raizlabs.dbflow5.models.SimpleModel_Table +import com.raizlabs.dbflow5.query.case import com.raizlabs.dbflow5.query.caseWhen import com.raizlabs.dbflow5.query.property.propertyString import org.junit.Assert.* diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/CursorResultTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/CursorResultTest.kt similarity index 92% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/CursorResultTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/CursorResultTest.kt index 9b1961ab7..e627e4b6e 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/CursorResultTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/CursorResultTest.kt @@ -1,11 +1,13 @@ -package com.raizlabs.dbflow5.dbflow.sql.language +package com.raizlabs.dbflow5.sql.language import android.database.StaleDataException -import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.BaseUnitTest import com.raizlabs.dbflow5.config.databaseForTable -import com.raizlabs.dbflow5.dbflow.models.SimpleCustomModel -import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.models.SimpleCustomModel +import com.raizlabs.dbflow5.models.SimpleModel import com.raizlabs.dbflow5.query.CursorResult +import com.raizlabs.dbflow5.query.cursorResult +import com.raizlabs.dbflow5.query.select import com.raizlabs.dbflow5.query.toCustomList import com.raizlabs.dbflow5.query.toCustomListClose import com.raizlabs.dbflow5.query.toCustomModel diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/DeleteTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/DeleteTest.kt similarity index 81% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/DeleteTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/DeleteTest.kt index 9118df0d4..56ebffbbd 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/DeleteTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/DeleteTest.kt @@ -1,10 +1,12 @@ -package com.raizlabs.dbflow5.dbflow.sql.language +package com.raizlabs.dbflow5.sql.language -import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.BaseUnitTest import com.raizlabs.dbflow5.config.databaseForTable -import com.raizlabs.dbflow5.dbflow.models.SimpleModel -import com.raizlabs.dbflow5.dbflow.models.SimpleModel_Table +import com.raizlabs.dbflow5.models.SimpleModel +import com.raizlabs.dbflow5.models.SimpleModel_Table import com.raizlabs.dbflow5.query.delete +import com.raizlabs.dbflow5.query.list +import com.raizlabs.dbflow5.query.select import com.raizlabs.dbflow5.structure.save import org.junit.Assert.assertEquals import org.junit.Assert.assertFalse diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/ExistenceOperatorTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/ExistenceOperatorTest.kt similarity index 73% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/ExistenceOperatorTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/ExistenceOperatorTest.kt index dd4d3f450..9ca031d56 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/ExistenceOperatorTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/ExistenceOperatorTest.kt @@ -1,10 +1,11 @@ -package com.raizlabs.dbflow5.dbflow.sql.language +package com.raizlabs.dbflow5.sql.language -import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.BaseUnitTest import com.raizlabs.dbflow5.config.databaseForTable -import com.raizlabs.dbflow5.dbflow.models.SimpleModel -import com.raizlabs.dbflow5.dbflow.models.SimpleModel_Table +import com.raizlabs.dbflow5.models.SimpleModel +import com.raizlabs.dbflow5.models.SimpleModel_Table import com.raizlabs.dbflow5.query.ExistenceOperator +import com.raizlabs.dbflow5.query.select import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/FromTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/FromTest.kt similarity index 77% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/FromTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/FromTest.kt index 1fb136904..9d63c4c36 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/FromTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/FromTest.kt @@ -1,12 +1,15 @@ -package com.raizlabs.dbflow5.dbflow.sql.language +package com.raizlabs.dbflow5.sql.language -import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.BaseUnitTest import com.raizlabs.dbflow5.config.databaseForTable -import com.raizlabs.dbflow5.dbflow.models.SimpleModel -import com.raizlabs.dbflow5.dbflow.models.SimpleModel_Table.name -import com.raizlabs.dbflow5.dbflow.models.TwoColumnModel -import com.raizlabs.dbflow5.dbflow.models.TwoColumnModel_Table -import com.raizlabs.dbflow5.dbflow.models.TwoColumnModel_Table.id +import com.raizlabs.dbflow5.models.SimpleModel +import com.raizlabs.dbflow5.models.SimpleModel_Table.name +import com.raizlabs.dbflow5.models.TwoColumnModel +import com.raizlabs.dbflow5.models.TwoColumnModel_Table +import com.raizlabs.dbflow5.models.TwoColumnModel_Table.id +import com.raizlabs.dbflow5.query.innerJoin +import com.raizlabs.dbflow5.query.on +import com.raizlabs.dbflow5.query.select import org.junit.Assert.assertEquals import org.junit.Assert.assertTrue import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/IndexTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/IndexTest.kt similarity index 84% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/IndexTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/IndexTest.kt index 3c93ec15f..f6c8f6a19 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/IndexTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/IndexTest.kt @@ -1,9 +1,9 @@ -package com.raizlabs.dbflow5.dbflow.sql.language +package com.raizlabs.dbflow5.sql.language -import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.BaseUnitTest import com.raizlabs.dbflow5.config.databaseForTable -import com.raizlabs.dbflow5.dbflow.models.SimpleModel -import com.raizlabs.dbflow5.dbflow.models.SimpleModel_Table +import com.raizlabs.dbflow5.models.SimpleModel +import com.raizlabs.dbflow5.models.SimpleModel_Table import com.raizlabs.dbflow5.query.indexOn import com.raizlabs.dbflow5.query.nameAlias import org.junit.Assert.assertEquals diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/IndexedByTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/IndexedByTest.kt similarity index 71% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/IndexedByTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/IndexedByTest.kt index 55e981737..6b776f666 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/IndexedByTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/IndexedByTest.kt @@ -1,10 +1,11 @@ -package com.raizlabs.dbflow5.dbflow.sql.language +package com.raizlabs.dbflow5.sql.language -import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.BaseUnitTest import com.raizlabs.dbflow5.config.databaseForTable -import com.raizlabs.dbflow5.dbflow.models.SimpleModel -import com.raizlabs.dbflow5.dbflow.models.SimpleModel_Table +import com.raizlabs.dbflow5.models.SimpleModel +import com.raizlabs.dbflow5.models.SimpleModel_Table import com.raizlabs.dbflow5.query.property.IndexProperty +import com.raizlabs.dbflow5.query.select import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/InsertTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/InsertTest.kt similarity index 92% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/InsertTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/InsertTest.kt index 0a2e5f725..96b97c4f5 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/InsertTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/InsertTest.kt @@ -1,17 +1,18 @@ -package com.raizlabs.dbflow5.dbflow.sql.language +package com.raizlabs.dbflow5.sql.language import android.content.ContentValues -import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.BaseUnitTest import com.raizlabs.dbflow5.config.databaseForTable import com.raizlabs.dbflow5.database.set -import com.raizlabs.dbflow5.dbflow.models.SimpleModel -import com.raizlabs.dbflow5.dbflow.models.TwoColumnModel -import com.raizlabs.dbflow5.dbflow.models.TwoColumnModel_Table.id -import com.raizlabs.dbflow5.dbflow.models.TwoColumnModel_Table.name +import com.raizlabs.dbflow5.models.SimpleModel +import com.raizlabs.dbflow5.models.TwoColumnModel +import com.raizlabs.dbflow5.models.TwoColumnModel_Table.id +import com.raizlabs.dbflow5.models.TwoColumnModel_Table.name import com.raizlabs.dbflow5.query.NameAlias import com.raizlabs.dbflow5.query.Operator import com.raizlabs.dbflow5.query.OperatorGroup import com.raizlabs.dbflow5.query.insert +import com.raizlabs.dbflow5.query.select import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/JoinTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/JoinTest.kt similarity index 85% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/JoinTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/JoinTest.kt index 674e498e6..640c06450 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/JoinTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/JoinTest.kt @@ -1,11 +1,17 @@ -package com.raizlabs.dbflow5.dbflow.sql.language +package com.raizlabs.dbflow5.sql.language -import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.BaseUnitTest import com.raizlabs.dbflow5.config.databaseForTable -import com.raizlabs.dbflow5.dbflow.models.SimpleModel -import com.raizlabs.dbflow5.dbflow.models.SimpleModel_Table -import com.raizlabs.dbflow5.dbflow.models.TwoColumnModel -import com.raizlabs.dbflow5.dbflow.models.TwoColumnModel_Table +import com.raizlabs.dbflow5.models.SimpleModel +import com.raizlabs.dbflow5.models.SimpleModel_Table +import com.raizlabs.dbflow5.models.TwoColumnModel +import com.raizlabs.dbflow5.models.TwoColumnModel_Table +import com.raizlabs.dbflow5.query.crossJoin +import com.raizlabs.dbflow5.query.innerJoin +import com.raizlabs.dbflow5.query.leftOuterJoin +import com.raizlabs.dbflow5.query.naturalJoin +import com.raizlabs.dbflow5.query.on +import com.raizlabs.dbflow5.query.select import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/MethodTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/MethodTest.kt similarity index 92% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/MethodTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/MethodTest.kt index 712d0915e..ec4a16f98 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/MethodTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/MethodTest.kt @@ -1,8 +1,8 @@ -package com.raizlabs.dbflow5.dbflow.sql.language +package com.raizlabs.dbflow5.sql.language -import com.raizlabs.dbflow5.dbflow.BaseUnitTest -import com.raizlabs.dbflow5.dbflow.models.TwoColumnModel_Table.id -import com.raizlabs.dbflow5.dbflow.models.TwoColumnModel_Table.name +import com.raizlabs.dbflow5.BaseUnitTest +import com.raizlabs.dbflow5.models.TwoColumnModel_Table.id +import com.raizlabs.dbflow5.models.TwoColumnModel_Table.name import com.raizlabs.dbflow5.query.avg import com.raizlabs.dbflow5.query.cast import com.raizlabs.dbflow5.query.count diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/NameAliasTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/NameAliasTest.kt similarity index 93% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/NameAliasTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/NameAliasTest.kt index 55e454a09..5688d8c60 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/NameAliasTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/NameAliasTest.kt @@ -1,6 +1,6 @@ -package com.raizlabs.dbflow5.dbflow.sql.language +package com.raizlabs.dbflow5.sql.language -import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.BaseUnitTest import com.raizlabs.dbflow5.query.NameAlias import com.raizlabs.dbflow5.query.`as` import com.raizlabs.dbflow5.query.nameAlias diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/OperatorGroupTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/OperatorGroupTest.kt similarity index 82% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/OperatorGroupTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/OperatorGroupTest.kt index 67a7f62f0..da2eeb133 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/OperatorGroupTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/OperatorGroupTest.kt @@ -1,9 +1,9 @@ -package com.raizlabs.dbflow5.dbflow.sql.language +package com.raizlabs.dbflow5.sql.language -import com.raizlabs.dbflow5.dbflow.BaseUnitTest -import com.raizlabs.dbflow5.dbflow.assertEquals -import com.raizlabs.dbflow5.dbflow.models.TwoColumnModel_Table.id -import com.raizlabs.dbflow5.dbflow.models.TwoColumnModel_Table.name +import com.raizlabs.dbflow5.BaseUnitTest +import com.raizlabs.dbflow5.assertEquals +import com.raizlabs.dbflow5.models.TwoColumnModel_Table.id +import com.raizlabs.dbflow5.models.TwoColumnModel_Table.name import com.raizlabs.dbflow5.query.OperatorGroup import com.raizlabs.dbflow5.query.and import com.raizlabs.dbflow5.query.andAll diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/OperatorTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/OperatorTest.kt similarity index 88% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/OperatorTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/OperatorTest.kt index 40e866bed..9f7ec6203 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/OperatorTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/OperatorTest.kt @@ -1,12 +1,13 @@ -package com.raizlabs.dbflow5.dbflow.sql.language +package com.raizlabs.dbflow5.sql.language -import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.BaseUnitTest import com.raizlabs.dbflow5.annotation.Collate -import com.raizlabs.dbflow5.dbflow.assertEquals +import com.raizlabs.dbflow5.assertEquals import com.raizlabs.dbflow5.config.databaseForTable -import com.raizlabs.dbflow5.dbflow.models.SimpleModel -import com.raizlabs.dbflow5.dbflow.models.TwoColumnModel_Table.id +import com.raizlabs.dbflow5.models.SimpleModel +import com.raizlabs.dbflow5.models.TwoColumnModel_Table.id import com.raizlabs.dbflow5.query.op +import com.raizlabs.dbflow5.query.select import org.junit.Test class OperatorTest : BaseUnitTest() { diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/OrderByTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/OrderByTest.kt similarity index 79% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/OrderByTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/OrderByTest.kt index 36e222db7..b4fb4910c 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/OrderByTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/OrderByTest.kt @@ -1,9 +1,9 @@ -package com.raizlabs.dbflow5.dbflow.sql.language +package com.raizlabs.dbflow5.sql.language -import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.BaseUnitTest import com.raizlabs.dbflow5.annotation.Collate -import com.raizlabs.dbflow5.dbflow.assertEquals -import com.raizlabs.dbflow5.dbflow.models.SimpleModel_Table.name +import com.raizlabs.dbflow5.assertEquals +import com.raizlabs.dbflow5.models.SimpleModel_Table.name import com.raizlabs.dbflow5.query.OrderBy import com.raizlabs.dbflow5.query.collate import com.raizlabs.dbflow5.query.nameAlias diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/SelectTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/SelectTest.kt similarity index 60% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/SelectTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/SelectTest.kt index b5eae64e2..03e239e34 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/SelectTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/SelectTest.kt @@ -1,12 +1,13 @@ -package com.raizlabs.dbflow5.dbflow.sql.language +package com.raizlabs.dbflow5.sql.language -import com.raizlabs.dbflow5.dbflow.BaseUnitTest -import com.raizlabs.dbflow5.dbflow.assertEquals +import com.raizlabs.dbflow5.BaseUnitTest +import com.raizlabs.dbflow5.assertEquals import com.raizlabs.dbflow5.config.databaseForTable -import com.raizlabs.dbflow5.dbflow.models.SimpleModel -import com.raizlabs.dbflow5.dbflow.models.TwoColumnModel -import com.raizlabs.dbflow5.dbflow.models.TwoColumnModel_Table.id -import com.raizlabs.dbflow5.dbflow.models.TwoColumnModel_Table.name +import com.raizlabs.dbflow5.models.SimpleModel +import com.raizlabs.dbflow5.models.TwoColumnModel +import com.raizlabs.dbflow5.models.TwoColumnModel_Table.id +import com.raizlabs.dbflow5.models.TwoColumnModel_Table.name +import com.raizlabs.dbflow5.query.select import org.junit.Test class SelectTest : BaseUnitTest() { diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/SetTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/SetTest.kt similarity index 67% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/SetTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/SetTest.kt index ea8f0d0a7..ab7ac1473 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/SetTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/SetTest.kt @@ -1,11 +1,11 @@ -package com.raizlabs.dbflow5.dbflow.sql.language +package com.raizlabs.dbflow5.sql.language -import com.raizlabs.dbflow5.dbflow.BaseUnitTest -import com.raizlabs.dbflow5.dbflow.assertEquals +import com.raizlabs.dbflow5.BaseUnitTest +import com.raizlabs.dbflow5.assertEquals import com.raizlabs.dbflow5.config.databaseForTable -import com.raizlabs.dbflow5.dbflow.models.SimpleModel -import com.raizlabs.dbflow5.dbflow.models.SimpleModel_Table.name -import com.raizlabs.dbflow5.dbflow.models.TwoColumnModel_Table.id +import com.raizlabs.dbflow5.models.SimpleModel +import com.raizlabs.dbflow5.models.SimpleModel_Table.name +import com.raizlabs.dbflow5.models.TwoColumnModel_Table.id import com.raizlabs.dbflow5.query.set import com.raizlabs.dbflow5.query.update import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/TriggerTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/TriggerTest.kt similarity index 87% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/TriggerTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/TriggerTest.kt index e30f3aa6e..c68335b0f 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/TriggerTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/TriggerTest.kt @@ -1,12 +1,12 @@ -package com.raizlabs.dbflow5.dbflow.sql.language +package com.raizlabs.dbflow5.sql.language -import com.raizlabs.dbflow5.dbflow.BaseUnitTest -import com.raizlabs.dbflow5.dbflow.assertEquals +import com.raizlabs.dbflow5.BaseUnitTest +import com.raizlabs.dbflow5.assertEquals import com.raizlabs.dbflow5.config.databaseForTable -import com.raizlabs.dbflow5.dbflow.models.SimpleModel -import com.raizlabs.dbflow5.dbflow.models.SimpleModel_Table.name -import com.raizlabs.dbflow5.dbflow.models.TwoColumnModel -import com.raizlabs.dbflow5.dbflow.models.TwoColumnModel_Table.id +import com.raizlabs.dbflow5.models.SimpleModel +import com.raizlabs.dbflow5.models.SimpleModel_Table.name +import com.raizlabs.dbflow5.models.TwoColumnModel +import com.raizlabs.dbflow5.models.TwoColumnModel_Table.id import com.raizlabs.dbflow5.query.NameAlias import com.raizlabs.dbflow5.query.begin import com.raizlabs.dbflow5.query.cast @@ -15,6 +15,7 @@ import com.raizlabs.dbflow5.query.createTrigger import com.raizlabs.dbflow5.query.insert import com.raizlabs.dbflow5.query.insertOn import com.raizlabs.dbflow5.query.property.property +import com.raizlabs.dbflow5.query.select import com.raizlabs.dbflow5.query.updateOn import com.raizlabs.dbflow5.sql.SQLiteType import com.raizlabs.dbflow5.structure.insert diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/UnsafeStringOperatorTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/UnsafeStringOperatorTest.kt similarity index 74% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/UnsafeStringOperatorTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/UnsafeStringOperatorTest.kt index c3de27dd3..e37b0b22e 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/UnsafeStringOperatorTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/UnsafeStringOperatorTest.kt @@ -1,10 +1,11 @@ -package com.raizlabs.dbflow5.dbflow.sql.language +package com.raizlabs.dbflow5.sql.language -import com.raizlabs.dbflow5.dbflow.BaseUnitTest -import com.raizlabs.dbflow5.dbflow.assertEquals +import com.raizlabs.dbflow5.BaseUnitTest +import com.raizlabs.dbflow5.assertEquals import com.raizlabs.dbflow5.config.databaseForTable -import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.models.SimpleModel import com.raizlabs.dbflow5.query.UnSafeStringOperator +import com.raizlabs.dbflow5.query.select import org.junit.Test class UnsafeStringOperatorTest : BaseUnitTest() { diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/UpdateTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/UpdateTest.kt similarity index 82% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/UpdateTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/UpdateTest.kt index 154f9a9bb..03a12eedd 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/UpdateTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/UpdateTest.kt @@ -1,13 +1,13 @@ -package com.raizlabs.dbflow5.dbflow.sql.language +package com.raizlabs.dbflow5.sql.language -import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.BaseUnitTest import com.raizlabs.dbflow5.annotation.ConflictAction -import com.raizlabs.dbflow5.dbflow.assertEquals +import com.raizlabs.dbflow5.assertEquals import com.raizlabs.dbflow5.config.databaseForTable -import com.raizlabs.dbflow5.dbflow.models.NumberModel -import com.raizlabs.dbflow5.dbflow.models.NumberModel_Table.id -import com.raizlabs.dbflow5.dbflow.models.SimpleModel -import com.raizlabs.dbflow5.dbflow.models.SimpleModel_Table.name +import com.raizlabs.dbflow5.models.NumberModel +import com.raizlabs.dbflow5.models.NumberModel_Table.id +import com.raizlabs.dbflow5.models.SimpleModel +import com.raizlabs.dbflow5.models.SimpleModel_Table.name import com.raizlabs.dbflow5.query.property.Property import com.raizlabs.dbflow5.query.set import com.raizlabs.dbflow5.query.update diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/WhereTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/WhereTest.kt similarity index 91% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/WhereTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/WhereTest.kt index 2cdd0063b..829753466 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/WhereTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/WhereTest.kt @@ -1,17 +1,20 @@ -package com.raizlabs.dbflow5.dbflow.sql.language +package com.raizlabs.dbflow5.sql.language -import com.raizlabs.dbflow5.dbflow.BaseUnitTest -import com.raizlabs.dbflow5.dbflow.assertEquals +import com.raizlabs.dbflow5.BaseUnitTest +import com.raizlabs.dbflow5.assertEquals import com.raizlabs.dbflow5.config.databaseForTable -import com.raizlabs.dbflow5.dbflow.models.SimpleModel -import com.raizlabs.dbflow5.dbflow.models.SimpleModel_Table.name -import com.raizlabs.dbflow5.dbflow.models.TwoColumnModel -import com.raizlabs.dbflow5.dbflow.models.TwoColumnModel_Table.id +import com.raizlabs.dbflow5.models.SimpleModel +import com.raizlabs.dbflow5.models.SimpleModel_Table.name +import com.raizlabs.dbflow5.models.TwoColumnModel +import com.raizlabs.dbflow5.models.TwoColumnModel_Table.id import com.raizlabs.dbflow5.query.OrderBy.Companion.fromNameAlias +import com.raizlabs.dbflow5.query.groupBy +import com.raizlabs.dbflow5.query.having import com.raizlabs.dbflow5.query.list import com.raizlabs.dbflow5.query.nameAlias import com.raizlabs.dbflow5.query.or import com.raizlabs.dbflow5.query.result +import com.raizlabs.dbflow5.query.select import com.raizlabs.dbflow5.query.update import org.junit.Assert.fail import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/BytePropertyTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/BytePropertyTest.kt similarity index 91% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/BytePropertyTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/BytePropertyTest.kt index f5581ea3d..563bf32c7 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/BytePropertyTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/BytePropertyTest.kt @@ -1,7 +1,7 @@ -package com.raizlabs.dbflow5.dbflow.sql.language.property +package com.raizlabs.dbflow5.sql.language.property -import com.raizlabs.dbflow5.dbflow.BaseUnitTest -import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.BaseUnitTest +import com.raizlabs.dbflow5.models.SimpleModel import com.raizlabs.dbflow5.query.NameAlias import com.raizlabs.dbflow5.query.property.Property import org.junit.Assert.assertEquals diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/CharPropertyTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/CharPropertyTest.kt similarity index 91% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/CharPropertyTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/CharPropertyTest.kt index a059d1815..b959d2f25 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/CharPropertyTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/CharPropertyTest.kt @@ -1,7 +1,7 @@ -package com.raizlabs.dbflow5.dbflow.sql.language.property +package com.raizlabs.dbflow5.sql.language.property -import com.raizlabs.dbflow5.dbflow.BaseUnitTest -import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.BaseUnitTest +import com.raizlabs.dbflow5.models.SimpleModel import com.raizlabs.dbflow5.query.NameAlias import com.raizlabs.dbflow5.query.property.Property import org.junit.Assert.assertEquals diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/DoublePropertyTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/DoublePropertyTest.kt similarity index 91% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/DoublePropertyTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/DoublePropertyTest.kt index f0cef9c4b..e12e4912c 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/DoublePropertyTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/DoublePropertyTest.kt @@ -1,7 +1,7 @@ -package com.raizlabs.dbflow5.dbflow.sql.language.property +package com.raizlabs.dbflow5.sql.language.property -import com.raizlabs.dbflow5.dbflow.BaseUnitTest -import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.BaseUnitTest +import com.raizlabs.dbflow5.models.SimpleModel import com.raizlabs.dbflow5.query.NameAlias import com.raizlabs.dbflow5.query.property.Property import org.junit.Assert.assertEquals diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/FloatPropertyTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/FloatPropertyTest.kt similarity index 91% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/FloatPropertyTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/FloatPropertyTest.kt index 66dc7d9ae..348baf360 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/FloatPropertyTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/FloatPropertyTest.kt @@ -1,7 +1,7 @@ -package com.raizlabs.dbflow5.dbflow.sql.language.property +package com.raizlabs.dbflow5.sql.language.property -import com.raizlabs.dbflow5.dbflow.BaseUnitTest -import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.BaseUnitTest +import com.raizlabs.dbflow5.models.SimpleModel import com.raizlabs.dbflow5.query.NameAlias import com.raizlabs.dbflow5.query.property.Property import org.junit.Assert.assertEquals diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/IndexPropertyTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/IndexPropertyTest.kt similarity index 71% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/IndexPropertyTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/IndexPropertyTest.kt index 35be3248b..419cf934d 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/IndexPropertyTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/IndexPropertyTest.kt @@ -1,9 +1,9 @@ -package com.raizlabs.dbflow5.dbflow.sql.language.property +package com.raizlabs.dbflow5.sql.language.property -import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.BaseUnitTest import com.raizlabs.dbflow5.config.databaseForTable -import com.raizlabs.dbflow5.dbflow.models.SimpleModel -import com.raizlabs.dbflow5.dbflow.models.SimpleModel_Table +import com.raizlabs.dbflow5.models.SimpleModel +import com.raizlabs.dbflow5.models.SimpleModel_Table import com.raizlabs.dbflow5.query.property.IndexProperty import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/IntPropertyTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/IntPropertyTest.kt similarity index 91% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/IntPropertyTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/IntPropertyTest.kt index 22dcfdcc1..04dfe9aa3 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/IntPropertyTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/IntPropertyTest.kt @@ -1,7 +1,7 @@ -package com.raizlabs.dbflow5.dbflow.sql.language.property +package com.raizlabs.dbflow5.sql.language.property -import com.raizlabs.dbflow5.dbflow.BaseUnitTest -import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.BaseUnitTest +import com.raizlabs.dbflow5.models.SimpleModel import com.raizlabs.dbflow5.query.NameAlias import com.raizlabs.dbflow5.query.property.Property import org.junit.Assert.assertEquals diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/LongPropertyTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/LongPropertyTest.kt similarity index 91% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/LongPropertyTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/LongPropertyTest.kt index 74b333369..b9ef8175c 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/LongPropertyTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/LongPropertyTest.kt @@ -1,7 +1,7 @@ -package com.raizlabs.dbflow5.dbflow.sql.language.property +package com.raizlabs.dbflow5.sql.language.property -import com.raizlabs.dbflow5.dbflow.BaseUnitTest -import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.BaseUnitTest +import com.raizlabs.dbflow5.models.SimpleModel import com.raizlabs.dbflow5.query.NameAlias import com.raizlabs.dbflow5.query.property.Property import org.junit.Assert.assertEquals diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/PropertyFactoryTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/PropertyFactoryTest.kt similarity index 84% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/PropertyFactoryTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/PropertyFactoryTest.kt index 61f3823e6..672b78786 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/PropertyFactoryTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/PropertyFactoryTest.kt @@ -1,10 +1,11 @@ -package com.raizlabs.dbflow5.dbflow.sql.language.property +package com.raizlabs.dbflow5.sql.language.property -import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.BaseUnitTest import com.raizlabs.dbflow5.config.databaseForTable -import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.models.SimpleModel import com.raizlabs.dbflow5.query.property.property import com.raizlabs.dbflow5.query.property.propertyString +import com.raizlabs.dbflow5.query.select import org.junit.Assert.assertEquals import org.junit.Test diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/PropertyTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/PropertyTest.kt similarity index 92% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/PropertyTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/PropertyTest.kt index b30e903ba..80aee56b1 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/PropertyTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/PropertyTest.kt @@ -1,7 +1,7 @@ -package com.raizlabs.dbflow5.dbflow.sql.language.property +package com.raizlabs.dbflow5.sql.language.property -import com.raizlabs.dbflow5.dbflow.BaseUnitTest -import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.BaseUnitTest +import com.raizlabs.dbflow5.models.SimpleModel import com.raizlabs.dbflow5.query.NameAlias import com.raizlabs.dbflow5.query.property.Property import org.junit.Assert diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/ShortPropertyTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/ShortPropertyTest.kt similarity index 91% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/ShortPropertyTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/ShortPropertyTest.kt index 226acc41a..0e54eb960 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/ShortPropertyTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/ShortPropertyTest.kt @@ -1,7 +1,7 @@ -package com.raizlabs.dbflow5.dbflow.sql.language.property +package com.raizlabs.dbflow5.sql.language.property -import com.raizlabs.dbflow5.dbflow.BaseUnitTest -import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.BaseUnitTest +import com.raizlabs.dbflow5.models.SimpleModel import com.raizlabs.dbflow5.query.NameAlias import com.raizlabs.dbflow5.query.property.Property import org.junit.Assert.assertEquals diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/TypeConvertedPropertyTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/TypeConvertedPropertyTest.kt similarity index 84% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/TypeConvertedPropertyTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/TypeConvertedPropertyTest.kt index 68d6f6077..2207850b2 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/dbflow/sql/language/property/TypeConvertedPropertyTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/TypeConvertedPropertyTest.kt @@ -1,11 +1,11 @@ -package com.raizlabs.dbflow5.dbflow.sql.language.property +package com.raizlabs.dbflow5.sql.language.property -import com.raizlabs.dbflow5.dbflow.BaseUnitTest +import com.raizlabs.dbflow5.BaseUnitTest import com.raizlabs.dbflow5.converter.DateConverter import com.raizlabs.dbflow5.converter.TypeConverter -import com.raizlabs.dbflow5.dbflow.models.Difficulty -import com.raizlabs.dbflow5.dbflow.models.EnumTypeConverterModel_Table -import com.raizlabs.dbflow5.dbflow.models.SimpleModel +import com.raizlabs.dbflow5.models.Difficulty +import com.raizlabs.dbflow5.models.EnumTypeConverterModel_Table +import com.raizlabs.dbflow5.models.SimpleModel import com.raizlabs.dbflow5.query.NameAlias import com.raizlabs.dbflow5.query.property.TypeConvertedProperty import org.junit.Assert.assertEquals diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/RetrievalAdapter.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/RetrievalAdapter.kt index 0bd3964d6..3a2dd0d0b 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/RetrievalAdapter.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/RetrievalAdapter.kt @@ -9,6 +9,7 @@ import com.raizlabs.dbflow5.adapter.queriable.ListModelLoader import com.raizlabs.dbflow5.adapter.queriable.SingleModelLoader import com.raizlabs.dbflow5.database.DatabaseWrapper import com.raizlabs.dbflow5.database.FlowCursor +import com.raizlabs.dbflow5.query.select /** * Description: Provides a base retrieval class for all [Model] backed diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseDefinition.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseDefinition.kt index 314cf2527..eb56e264e 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseDefinition.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseDefinition.kt @@ -11,7 +11,6 @@ import com.raizlabs.dbflow5.adapter.saveable.ModelSaver import com.raizlabs.dbflow5.annotation.Database import com.raizlabs.dbflow5.annotation.QueryModel import com.raizlabs.dbflow5.annotation.Table -import com.raizlabs.dbflow5.dbflow.config.DatabaseHolder import com.raizlabs.dbflow5.database.DatabaseHelperListener import com.raizlabs.dbflow5.database.DatabaseStatement import com.raizlabs.dbflow5.database.DatabaseWrapper diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowManager.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowManager.kt index 7bf06399b..9fdd457e3 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowManager.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowManager.kt @@ -38,7 +38,7 @@ object FlowManager { private val DEFAULT_DATABASE_HOLDER_PACKAGE_NAME = FlowManager::class.java.`package`.name private val DEFAULT_DATABASE_HOLDER_CLASSNAME = - DEFAULT_DATABASE_HOLDER_PACKAGE_NAME + "" + DEFAULT_DATABASE_HOLDER_NAME + DEFAULT_DATABASE_HOLDER_PACKAGE_NAME + "." + DEFAULT_DATABASE_HOLDER_NAME /** * Will throw an exception if this class is not initialized yet in [.init] diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/migration/AlterTableMigration.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/migration/AlterTableMigration.kt index a1e632963..0b3339790 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/migration/AlterTableMigration.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/migration/AlterTableMigration.kt @@ -3,10 +3,11 @@ package com.raizlabs.dbflow5.migration import android.support.annotation.CallSuper import com.raizlabs.dbflow5.appendQuotedIfNeeded import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.database.DatabaseWrapper +import com.raizlabs.dbflow5.query.select import com.raizlabs.dbflow5.quoteIfNeeded import com.raizlabs.dbflow5.sql.SQLiteType import com.raizlabs.dbflow5.stripQuotes -import com.raizlabs.dbflow5.database.DatabaseWrapper /** * Description: Provides a very nice way to alter a single table quickly and easily. diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/provider/BaseContentProvider.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/provider/BaseContentProvider.kt index e4a4cd14e..07e13ec49 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/provider/BaseContentProvider.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/provider/BaseContentProvider.kt @@ -4,13 +4,13 @@ import android.content.ContentProvider import android.content.ContentValues import android.net.Uri import com.raizlabs.dbflow5.config.DatabaseDefinition -import com.raizlabs.dbflow5.dbflow.config.DatabaseHolder +import com.raizlabs.dbflow5.config.DatabaseHolder import com.raizlabs.dbflow5.config.FlowManager import com.raizlabs.dbflow5.database.DatabaseWrapper import com.raizlabs.dbflow5.transaction.ITransaction /** - * Description: The base provider class that [com.raizlabs.android.dbflow.annotation.provider.ContentProvider] + * Description: The base provider class that [com.raizlabs.android.dbflow5.annotation.provider.ContentProvider] * extend when generated. */ abstract class BaseContentProvider diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseTransformable.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseTransformable.kt index c76d203a9..f0ffc9d30 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseTransformable.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseTransformable.kt @@ -21,6 +21,8 @@ protected constructor(databaseWrapper: DatabaseWrapper, fun where(vararg conditions: SQLOperator): Where = Where(this, *conditions) + infix fun where(condition: SQLOperator) : Where = Where(this, condition) + override fun query(): FlowCursor? = where().query() override fun groupBy(vararg nameAliases: NameAlias): Where = @@ -62,5 +64,3 @@ protected constructor(databaseWrapper: DatabaseWrapper, } } } - -infix fun BaseTransformable.where(sqlOperator: SQLOperator) = where(sqlOperator) diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/CompletedTrigger.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/CompletedTrigger.kt index 588ce7d24..9661b2877 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/CompletedTrigger.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/CompletedTrigger.kt @@ -29,7 +29,7 @@ class CompletedTrigger internal constructor( /** * Appends the nextStatement to this query as another line to be executed by trigger. */ - fun and(nextStatement: Query) = apply { + infix fun and(nextStatement: Query) = apply { this.triggerLogicQuery.add(nextStatement) } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/Join.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Join.kt index 30de53461..371b0eac6 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/Join.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Join.kt @@ -140,9 +140,19 @@ class Join : Query { */ fun on(vararg onConditions: SQLOperator): From { checkNatural() - onGroup = OperatorGroup.nonGroupingClause().apply { - andAll(*onConditions) - } + onGroup = OperatorGroup.nonGroupingClause().andAll(*onConditions) + return from + } + + /** + * Specify the conditions that the JOIN is on + * + * @param onConditions The conditions it is on + * @return The FROM that this JOIN came from + */ + fun on(onCondition: SQLOperator): From { + checkNatural() + onGroup = OperatorGroup.nonGroupingClause().and(onCondition) return from } @@ -158,6 +168,18 @@ class Join : Query { return from } + /** + * The USING statement of the JOIN + * + * @param columns THe columns to use + * @return The FROM that this JOIN came from + */ + infix fun using(property: IProperty<*>): From { + checkNatural() + using.add(property) + return from + } + /** * @return End this [Join]. Used for [Join.JoinType.NATURAL] */ @@ -180,4 +202,3 @@ infix fun From.naturalJoin(joinTable: KClass): Join Join.on(sqlOperator: SQLOperator): From = on(sqlOperator) -infix fun Join.using(property: IProperty<*>): From = using(property) diff --git a/usage2/ContentProviderGeneration.md b/usage2/ContentProviderGeneration.md index 4b1509b92..fd461cb72 100644 --- a/usage2/ContentProviderGeneration.md +++ b/usage2/ContentProviderGeneration.md @@ -15,7 +15,7 @@ In order to define a `ContentProvider`, you must define it in a placeholder clas baseContentUri = TestContentProvider.BASE_CONTENT_URI) public class TestContentProvider { - public static final String AUTHORITY = "com.raizlabs.dbflow5.dbflow.test.provider"; + public static final String AUTHORITY = "com.raizlabs.dbflow5.test.provider"; public static final String BASE_CONTENT_URI = "content://"; @@ -36,7 +36,7 @@ public class TestDatabase { public static final int VERSION = "1"; - public static final String AUTHORITY = "com.raizlabs.dbflow5.dbflow.test.provider"; + public static final String AUTHORITY = "com.raizlabs.dbflow5.test.provider"; public static final String BASE_CONTENT_URI = "content://"; @@ -49,7 +49,7 @@ In other applications or your current's `AndroidManifest.xml` add the **generate ```xml ``` diff --git a/usage2/Intro.md b/usage2/Intro.md index 630f5fdd4..fda88f05a 100644 --- a/usage2/Intro.md +++ b/usage2/Intro.md @@ -63,7 +63,7 @@ Since DBFlow uses annotation processing, which is run pre-proguard phase, the configuration is highly minimal: ``` --keep class * extends com.raizlabs.dbflow5.dbflow.config.DatabaseHolder { *; } +-keep class * extends com.raizlabs.dbflow5.config.DatabaseHolder { *; } ``` ## Sections diff --git a/usage2/Relationships.md b/usage2/Relationships.md index fdcaca01b..6692dc434 100644 --- a/usage2/Relationships.md +++ b/usage2/Relationships.md @@ -230,7 +230,7 @@ A class can use both: @Table(database = TestDatabase.class) @ManyToMany(referencedTable = TestModel1.class) @MultipleManyToMany({@ManyToMany(referencedTable = TestModel2.class), - @ManyToMany(referencedTable = com.raizlabs.dbflow5.dbflow.test.sql.TestModel3.class)}) + @ManyToMany(referencedTable = com.raizlabs.dbflow5.test.sql.TestModel3.class)}) public class ManyToManyModel extends BaseModel { @PrimaryKey diff --git a/usage2/TypeConverters.md b/usage2/TypeConverters.md index b4c40b39e..31def043a 100644 --- a/usage2/TypeConverters.md +++ b/usage2/TypeConverters.md @@ -27,7 +27,7 @@ This example creates a `TypeConverter` for a field that is `JSONObject` and conv ```java -@com.raizlabs.dbflow5.dbflow.annotation.TypeConverter +@com.raizlabs.dbflow5.annotation.TypeConverter public class JSONConverter extends TypeConverter { @Override diff --git a/usage2/proguard.md b/usage2/proguard.md index 26901d3ae..3c27c2978 100644 --- a/usage2/proguard.md +++ b/usage2/proguard.md @@ -3,7 +3,7 @@ Since DBFlow uses annotation processing, which is run pre-proguard phase, the configuration is highly minimal. Also since we combine all generated files into the `GeneratedDatabaseHolder`, any other class generated can be obfuscated. ``` --keep class * extends com.raizlabs.dbflow5.dbflow.config.DatabaseHolder { *; } +-keep class * extends com.raizlabs.dbflow5.config.DatabaseHolder { *; } ``` This also works on modules from other library projects that use DBFlow. From 8c6da15c1a07781e5ad4150f7fbfcc9f0910e424 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sun, 3 Dec 2017 17:50:04 -0500 Subject: [PATCH 106/234] [saver] more efficient use of save on single object. --- .../dbflow5/adapter/saveable/ModelSaver.kt | 25 +++++++++++++++---- 1 file changed, 20 insertions(+), 5 deletions(-) diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/saveable/ModelSaver.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/saveable/ModelSaver.kt index ecf759cb3..b4c34041e 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/saveable/ModelSaver.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/saveable/ModelSaver.kt @@ -1,11 +1,11 @@ package com.raizlabs.dbflow5.adapter.saveable import android.content.ContentValues -import com.raizlabs.dbflow5.runtime.NotifyDistributor -import com.raizlabs.dbflow5.structure.ChangeAction import com.raizlabs.dbflow5.adapter.ModelAdapter import com.raizlabs.dbflow5.database.DatabaseStatement import com.raizlabs.dbflow5.database.DatabaseWrapper +import com.raizlabs.dbflow5.runtime.NotifyDistributor +import com.raizlabs.dbflow5.structure.ChangeAction /** * Description: Defines how models get saved into the DB. It will bind values to [DatabaseStatement] @@ -16,9 +16,24 @@ open class ModelSaver { lateinit var modelAdapter: ModelAdapter @Synchronized - fun save(model: T, wrapper: DatabaseWrapper): Boolean = - save(model, modelAdapter.getInsertStatement(wrapper), - modelAdapter.getUpdateStatement(wrapper), wrapper) + fun save(model: T, wrapper: DatabaseWrapper): Boolean { + var exists = modelAdapter.exists(model, wrapper) + + if (exists) { + exists = update(model, wrapper) + } + + if (!exists) { + exists = insert(model, wrapper) > INSERT_FAILED + } + + if (exists) { + NotifyDistributor().notifyModelChanged(model, modelAdapter, ChangeAction.SAVE) + } + + // return successful store into db. + return exists + } @Synchronized fun save(model: T, From 8b0401a3b7a909d4bd05d89107e5067d485d9b60 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sun, 3 Dec 2017 18:13:44 -0500 Subject: [PATCH 107/234] [doc] update readme main for kotlin. add execute transaction method that makes it simpler to execute transaction. --- .../main/java/com/raizlabs/dbflow5/User.kt | 18 +-- .../dbflow5/config/DatabaseDefinition.kt | 12 ++ .../dbflow5/transaction/Transaction.kt | 22 ++-- usage2/README.md | 107 +++++++----------- 4 files changed, 69 insertions(+), 90 deletions(-) diff --git a/dbflow-tests/src/main/java/com/raizlabs/dbflow5/User.kt b/dbflow-tests/src/main/java/com/raizlabs/dbflow5/User.kt index 822d55df9..7f417004e 100644 --- a/dbflow-tests/src/main/java/com/raizlabs/dbflow5/User.kt +++ b/dbflow-tests/src/main/java/com/raizlabs/dbflow5/User.kt @@ -5,17 +5,7 @@ import com.raizlabs.dbflow5.annotation.PrimaryKey import com.raizlabs.dbflow5.annotation.Table @Table(database = AppDatabase::class, name = "User2") -class User { - - @PrimaryKey - var id: Int = 0 - - @Column - var firstName: String? = null - - @Column - var lastName: String? = null - - @Column - var email: String? = null -} +class User(@PrimaryKey var id: Int = 0, + @Column var firstName: String? = null, + @Column var lastName: String? = null, + @Column var email: String? = null) diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseDefinition.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseDefinition.kt index eb56e264e..4cc1b5b5a 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseDefinition.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseDefinition.kt @@ -268,6 +268,18 @@ abstract class DatabaseDefinition : DatabaseWrapper { return modelNotifier!! } + /** + * Executes and returns the executed transaction. + */ + fun executeTransactionAsync(transaction: ITransaction, + success: ((Transaction, R) -> Unit)? = null, + error: ((Transaction, Throwable) -> Unit)? = null): Transaction + = beginTransactionAsync(transaction) + .success(success) + .error(error) + .execute() + + fun beginTransactionAsync(transaction: ITransaction): Transaction.Builder = Transaction.Builder(transaction, this) diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/Transaction.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/Transaction.kt index 41c1391c9..871d37c6e 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/Transaction.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/Transaction.kt @@ -73,7 +73,7 @@ class Transaction(private val transaction: ITransaction, /** * Runs the transaction in the [BaseTransactionManager] of the associated database. */ - fun execute() { + fun execute() = apply { databaseDefinition.transactionManager.addTransaction(this) } @@ -153,8 +153,10 @@ class Transaction(private val transaction: ITransaction, /** * Specify an error callback to return all and any [Throwable] that occured during a [Transaction]. */ - fun error(errorCallback: (Transaction, Throwable) -> Unit) = apply { - this.errorCallback = transactionError { transaction, throwable -> errorCallback(transaction, throwable) } + fun error(errorCallback: ((Transaction, Throwable) -> Unit)?) = apply { + if (errorCallback != null) { + this.errorCallback = transactionError { transaction, throwable -> errorCallback(transaction, throwable) } + } } /** @@ -173,8 +175,10 @@ class Transaction(private val transaction: ITransaction, * * @param successCallback The callback, invoked on the UI thread. */ - fun success(successCallback: (Transaction, R) -> Unit) = apply { - this.successCallback = transactionSuccess { transaction, r -> successCallback(transaction, r) } + fun success(successCallback: ((Transaction, R) -> Unit)?) = apply { + if (successCallback != null) { + this.successCallback = transactionSuccess { transaction, r -> successCallback(transaction, r) } + } } /** @@ -215,9 +219,7 @@ class Transaction(private val transaction: ITransaction, /** * Convenience method to simply execute a transaction. */ - fun execute() { - build().execute() - } + fun execute() = build().execute() } companion object { @@ -226,10 +228,10 @@ class Transaction(private val transaction: ITransaction, } } -inline fun transactionSuccess(crossinline function: (Transaction, R) -> Unit) = object : Transaction.Success { +inline fun transactionSuccess(crossinline function: (Transaction, R) -> Unit) = object : Transaction.Success { override fun onSuccess(transaction: Transaction, result: R) = function(transaction, result) } -inline fun transactionError(crossinline function: (Transaction, Throwable) -> Unit) = object : Transaction.Error { +inline fun transactionError(crossinline function: (Transaction, Throwable) -> Unit) = object : Transaction.Error { override fun onError(transaction: Transaction, error: Throwable) = function(transaction, error) } diff --git a/usage2/README.md b/usage2/README.md index 6185659d7..c84bd93e6 100644 --- a/usage2/README.md +++ b/usage2/README.md @@ -1,34 +1,30 @@ # DBFlow -DBFlow is a SQLite library for Android that makes it ridiculously easy to interact and use databases. Built with Annotation Processing that generates most of the boilerplate code for you, code use within a DB is fast, efficient, and type-safe. It removes the tedious \(and tough-to-maintain\) database interaction code. +DBFlow is a Kotlin SQLite library for Android that makes it ridiculously easy to interact and use databases. Built with Annotation Processing, code use within a DB is fast, efficient, and type-safe. It removes the tedious \(and tough-to-maintain\) database interaction code, while providing a very SQLite-like query syntax. Creating a database is as easy as a few lines of code: -```java -@Database(name = AppDatabase.NAME, version = AppDatabase.VERSION) -public class AppDatabase { - - public static final String NAME = "AppDatabase"; - - public static final int VERSION = 1; +```kotlin +@Database(version = AppDatabase.VERSION) +object AppDatabase { + const val VERSION = 1 } ``` The `@Database` annotation generates a `DatabaseDefinition` which now references your SQLite Database on disk in the file named "AppDatabase.db". You can reference it in code as: ```java -DatabaseDefinition db = FlowManager.getDatabase(AppDatabase.class); +val db: DatabaseDefinition = database(); ``` To ensure generated code in DBFlow is found by the library, initialize the library in your `Application` class: -```java -public class MyApp extends Application { +```kotlin +class MyApp : Application { - @Override - public void onCreate() { - super.onCreate(); - FlowManager.init(this); + override fun onCreate() { + super.onCreate() + FlowManager.init(this) } } ``` @@ -37,68 +33,47 @@ By default, DBFlow generates the `GeneratedDatabaseHolder` class, which is insta Creating a table is also very simple: -```java -@Table(database = AppDatabase.class) -public class User { - - @PrimaryKey // at least one primary key required - UUID id; - - @Column - String name; - - @Column - int age; -} +```kotlin +@Table(database = AppDatabase::class, name = "User2") +class User(@PrimaryKey var id: Int = 0, + @Column var firstName: String? = null, + @Column var lastName: String? = null, + @Column var email: String? = null) ``` Then to create, read, update, and delete the model: -```java -User user = new User(); -user.id = UUID.randomUUID(); -user.name = "Andrew Grosner"; -user.age = 27; +```kotlin +val user = User(id = UUID.randomUUID(), + name = "Andrew Grosner", + age = 27) -ModelAdapter adapter = FlowManager.getModelAdapter(User.class); -adapter.insert(user); +val db = databaseForTable() +user.insert(db) user.name = "Not Andrew Grosner"; -adapter.update(user); +user.update(db) -adapter.delete(user); +user.delete(db) -// if you extend BaseModel or implement Model -user.insert(); -user.update(); -user.delete(); -user.save(); +// Db optional on extension method +user.insert() +user.update() +user.delete() +user.save() // find adult users -List users = SQLite.select() - .from(User.class) - .where(User_Table.age.greaterThan(18)) - .queryList(); +val users = database() + .(select from User::class + where (User_Table.age greaterThan 18)) + .list // or asynchronous retrieval -SQLite.select() - .from(User.class) - .where(User_Table.age.greaterThan(18)) - .async() - .queryListCallback((QueryTransaction transaction, @NonNull CursorResult result) -> { - // called when query returns on UI thread - try { - List users = result.toList(); - // do something with users - } finally { - result.close(); - } - }) - .error((Transaction transaction, Throwable error) -> { - // handle any errors - }) - .execute(); +database().executeTransactionAsync({ (select from User::class where User_Table.age.greaterThan(18)).list }), +success = { transaction, result -> + // use result here +}, +error = { transaction, error -> + // handle any errors +}); ``` - - - From 89f5641b3a98ba36c9d7f47ae016910d961eec71 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sun, 3 Dec 2017 18:20:11 -0500 Subject: [PATCH 108/234] [doc] make kotlin preferred first. --- usage2/Databases.md | 115 ++++++++++++++++++++++++-------------------- 1 file changed, 62 insertions(+), 53 deletions(-) diff --git a/usage2/Databases.md b/usage2/Databases.md index 257252b65..629fda39f 100644 --- a/usage2/Databases.md +++ b/usage2/Databases.md @@ -9,6 +9,14 @@ In DBFlow, creating a database is as simple as only a few lines of code. DBFlow supports any number of databases, however individual tables and other related files can only be associated with one database. +```kotlin +@Database(version = AppDatabase.VERSION) +object AppDatabase { + const val VERSION = 1 +} +``` +or in Java: + ```java @Database(version = AppDatabase.VERSION) @@ -17,17 +25,10 @@ public class AppDatabase { public static final int VERSION = 1; } -``` - -```kotlin -@Database(version = AppDatabase.VERSION) -object AppDatabase { - const val VERSION = 1 -} ``` ## Initialization -To specify a custom **name** to the database, in previous versions of DBFlow (< 4.1.0), you had to specify it in the `@Database` annotation. As of 4.1.0, that method is deprecated and now it's preferred to pass it in the initialization of the `FlowManager`: +To specify a custom **name** to the database, in previous versions of DBFlow (< 4.1.0), you had to specify it in the `@Database` annotation. As of 5.0 now you pass it in the initialization of the `FlowManager`: ```java @@ -40,18 +41,18 @@ FlowManager.init(FlowConfig.builder() ``` To dynamically change the database name, call: -```java +```kotlin -FlowManager.getDatabase(AppDatabase.class) +database() .reset(DatabaseConfig.builder(AppDatabase.class) .databaseName("AppDatabase-2") .build()) ``` +or in Java: +```java -```kotlin - -database() +FlowManager.getDatabase(AppDatabase.class) .reset(DatabaseConfig.builder(AppDatabase.class) .databaseName("AppDatabase-2") .build()) @@ -62,7 +63,17 @@ This will close the open DB, reopen the DB, and replace previous `DatabaseConfig ### In Memory Databases -As with **name**, in previous versions of DBFlow (< 4.1.0), you specified `inMemory` in the `@Database` annotation. Starting with 4.1.0 that is deprecated, and replaced with: +As with **name**, in previous versions of DBFlow (< 5.0), you specified `inMemory` in the `@Database` annotation. Starting with 5.0 that is replaced with: +```kotlin + +FlowManager.init(FlowConfig.builder() + .addDatabaseConfig(DatabaseConfig.inMemoryBuilder(AppDatabase::class.java) + .databaseName("AppDatabase") + .build()) + .build()) + +``` + ```java FlowManager.init(FlowConfig.builder() @@ -84,6 +95,25 @@ It is preferred that `Migration` files go in the same file as the database, for organizational purposes. An example migration: + +```kotlin + +@Database(version = AppDatabase.VERSION) +object AppDatabase { + + const val VERSION = 2 + + @Migration(version = 2, database = MigrationDatabase.class) + class AddEmailToUserMigration : AlterTableMigration(User::class.java) { + + override fun onPreMigrate() { + addColumn(SQLiteType.TEXT, "email") + } + } +} + +``` + ```java @Database(name = AppDatabase.NAME, version = AppDatabase.VERSION) @@ -109,23 +139,6 @@ public class AppDatabase { ``` -```kotlin - -@Database(version = AppDatabase.VERSION) -object AppDatabase { - - const val VERSION = 2 - - @Migration(version = 2, database = MigrationDatabase.class) - class AddEmailToUserMigration : AlterTableMigration(User::class.java) { - - override fun onPreMigrate() { - addColumn(SQLiteType.TEXT, "email") - } - } -} - -``` This simple example adds a column to the `User` table named "email". In code, just add the column to the `Model` class and this migration runs only on existing dbs. @@ -144,18 +157,17 @@ of the database for the app. ### Global Conflict Handling In DBFlow when an INSERT or UPDATE are performed, by default, we use `NONE`. If you wish to configure this globally, you can define it to apply for all tables from a given database: - -```java - +```kotlin @Database(version = AppDatabase.VERSION, insertConflict = ConflictAction.IGNORE, updateConflict= ConflictAction.REPLACE) -public class AppDatabase { +object AppDatabase { } ``` -```kotlin +```java + @Database(version = AppDatabase.VERSION, insertConflict = ConflictAction.IGNORE, updateConflict= ConflictAction.REPLACE) -object AppDatabase { +public class AppDatabase { } ``` @@ -177,8 +189,14 @@ to manage database interactions. To do so, you must implement `OpenHelper`, but for convenience you should extend `FlowSQLiteOpenHelper` (for Android databases), or `SQLCipherOpenHelper` for SQLCipher. Read more [here](SQLCipherSupport.md) -```java +```kotlin + +class CustomFlowSQliteOpenHelper(databaseDefinition: DatabaseDefinition, listener: DatabaseHelperListener) : FlowSQLiteOpenHelper(databaseDefinition, listener) + +``` + +```java public class CustomFlowSQliteOpenHelper extends FlowSQLiteOpenHelper { @@ -187,16 +205,18 @@ public class CustomFlowSQliteOpenHelper extends FlowSQLiteOpenHelper { } } - ``` +Then in your `DatabaseConfig`: ```kotlin - -class CustomFlowSQliteOpenHelper(databaseDefinition: DatabaseDefinition, listener: DatabaseHelperListener) : FlowSQLiteOpenHelper(databaseDefinition, listener) +FlowManager.init(FlowConfig.builder(context) + .addDatabaseConfig(DatabaseConfig.Builder(CipherDatabase::class.java) + .openHelper(::CustomFlowSQliteOpenHelper) + .build()) + .build()) ``` -Then in your `DatabaseConfig`: ```java @@ -211,15 +231,4 @@ FlowManager.init(FlowConfig.builder(context) }) .build()) .build()); - - -``` - -```kotlin -FlowManager.init(FlowConfig.builder(context) - .addDatabaseConfig(DatabaseConfig.Builder(CipherDatabase.class) - .openHelper(::CustomFlowSQliteOpenHelper) - .build()) - .build()) - ``` From 7bf7e53b1584dbe6f82496707e3b5c1c4bed15bc Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sun, 3 Dec 2017 20:38:46 -0500 Subject: [PATCH 109/234] [doc] make kotlin preferred first. --- usage2/GettingStarted.md | 88 ++++++++++++++++++++-------------------- 1 file changed, 44 insertions(+), 44 deletions(-) diff --git a/usage2/GettingStarted.md b/usage2/GettingStarted.md index 6514d9f6f..27278e5ba 100644 --- a/usage2/GettingStarted.md +++ b/usage2/GettingStarted.md @@ -9,23 +9,21 @@ In DBFlow, creating a database is as simple as only a few lines of code. DBFlow supports any number of databases, however individual tables and other related files can only be associated with one database. -```java +```kotlin @Database(version = AppDatabase.VERSION) -public class AppDatabase { - public static final int VERSION = 1; +object AppDatabase { + const val VERSION = 1 } - - ``` - -```kotlin +```java @Database(version = AppDatabase.VERSION) -object AppDatabase { - const val VERSION = 1 +public class AppDatabase { + public static final int VERSION = 1; } + ``` The name of the database by default is the class name. To change it, read [here](Databases.md). @@ -46,6 +44,17 @@ as reading from assets, content observing, and generating `ContentProvider`. Initialize in your `Application` subclass. You can also initialize it from other `Context` but we always grab the `Application` `Context` (this is done only once). + +```kotlin +class ExampleApplication : Application { + + override fun onCreate() { + super.onCreate() + FlowManager.init(this) + } +} +``` + ```java public class ExampleApplication extends Application { @@ -58,16 +67,6 @@ public class ExampleApplication extends Application { ``` -```kotlin -class ExampleApplication : Application { - - override fun onCreate() { - super.onCreate() - FlowManager.init(this) - } -} -``` - Finally, add the definition to the manifest (with the name that you chose for your custom application): ```xml Date: Sun, 3 Dec 2017 20:41:37 -0500 Subject: [PATCH 110/234] [config] add KClass methods for kotlin. --- .../src/test/java/com/raizlabs/dbflow5/DBFlowTestRule.kt | 4 ++-- .../java/com/raizlabs/dbflow5/config/DatabaseConfig.kt | 8 ++++++++ .../main/java/com/raizlabs/dbflow5/config/TableConfig.kt | 8 +++++++- 3 files changed, 17 insertions(+), 3 deletions(-) diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/DBFlowTestRule.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/DBFlowTestRule.kt index f938de74e..966d48615 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/DBFlowTestRule.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/DBFlowTestRule.kt @@ -17,10 +17,10 @@ class DBFlowTestRule : TestRule { @Throws(Throwable::class) override fun evaluate() { FlowManager.init(FlowConfig.Builder(RuntimeEnvironment.application) - .addDatabaseConfig(DatabaseConfig.Builder(TestDatabase::class.java) + .addDatabaseConfig(DatabaseConfig.Builder(TestDatabase::class) .transactionManagerCreator(::ImmediateTransactionManager2) .build()) - .addDatabaseConfig(DatabaseConfig.builder(ContentDatabase::class.java) + .addDatabaseConfig(DatabaseConfig.builder(ContentDatabase::class) .databaseName("content") .build()) .build()) diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseConfig.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseConfig.kt index 554b637f4..30ee24d82 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseConfig.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseConfig.kt @@ -5,6 +5,7 @@ import com.raizlabs.dbflow5.database.OpenHelper import com.raizlabs.dbflow5.isNotNullOrEmpty import com.raizlabs.dbflow5.runtime.ModelNotifier import com.raizlabs.dbflow5.transaction.BaseTransactionManager +import kotlin.reflect.KClass /** * Description: @@ -65,6 +66,8 @@ class DatabaseConfig( internal var databaseName: String? = null internal var databaseExtensionName: String? = null + constructor(kClass: KClass<*>) : this(kClass.java) + fun transactionManagerCreator(transactionManager: TransactionManagerCreator) = transactionManagerCreator { databaseDefinition -> transactionManager.createManager(databaseDefinition) } @@ -126,8 +129,13 @@ class DatabaseConfig( @JvmStatic fun builder(database: Class<*>): Builder = Builder(database) + fun builder(database: KClass<*>): Builder = Builder(database) + @JvmStatic fun inMemoryBuilder(database: Class<*>): Builder = Builder(database).inMemory() + + fun inMemoryBuilder(database: KClass<*>): Builder = + Builder(database).inMemory() } } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/config/TableConfig.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/config/TableConfig.kt index 940e10d18..9ed8cc374 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/config/TableConfig.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/config/TableConfig.kt @@ -1,9 +1,10 @@ package com.raizlabs.dbflow5.config +import com.raizlabs.dbflow5.adapter.ModelAdapter import com.raizlabs.dbflow5.adapter.queriable.ListModelLoader import com.raizlabs.dbflow5.adapter.queriable.SingleModelLoader import com.raizlabs.dbflow5.adapter.saveable.ModelSaver -import com.raizlabs.dbflow5.adapter.ModelAdapter +import kotlin.reflect.KClass /** * Description: Represents certain table configuration options. This allows you to easily specify @@ -29,6 +30,8 @@ class TableConfig(val tableClass: Class, internal var singleModelLoader: SingleModelLoader? = null internal var listModelLoader: ListModelLoader? = null + constructor(tableClass: KClass) : this(tableClass.java) + /** * Define how the [ModelAdapter] saves data into the DB from its associated [T]. This * will override the default. @@ -63,5 +66,8 @@ class TableConfig(val tableClass: Class, @JvmStatic fun builder(tableClass: Class): Builder = Builder(tableClass) + + fun builder(tableClass: KClass): Builder = + Builder(tableClass) } } From 4a9bb873b26a2b67a7d4f7180d5b808c5bfe57c8 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sun, 3 Dec 2017 20:48:29 -0500 Subject: [PATCH 111/234] [property] convert IProperty into Kotlin. --- .../java/com/raizlabs/dbflow5/query/Method.kt | 37 ++--- .../dbflow5/query/property/IProperty.java | 128 ------------------ .../dbflow5/query/property/IProperty.kt | 113 ++++++++++++++++ .../dbflow5/query/property/Property.kt | 13 +- .../query/property/TypeConvertedProperty.kt | 6 +- .../dbflow5/query/property/WrapperProperty.kt | 2 +- 6 files changed, 143 insertions(+), 156 deletions(-) delete mode 100644 dbflow/src/main/java/com/raizlabs/dbflow5/query/property/IProperty.java create mode 100644 dbflow/src/main/java/com/raizlabs/dbflow5/query/property/IProperty.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/Method.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Method.kt index d85f2d902..050b0d176 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/Method.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Method.kt @@ -15,7 +15,7 @@ class Method(methodName: String, vararg properties: IProperty<*>) : Property>() private val operationsList = arrayListOf() private val methodProperty: IProperty<*> - private var nameAlias: NameAlias? = null + private var _nameAlias: NameAlias? = null constructor(vararg properties: IProperty<*>) : this("", *properties) @@ -68,27 +68,28 @@ class Method(methodName: String, vararg properties: IProperty<*>) : Property> = propertyList - override fun getNameAlias(): NameAlias { - if (this.nameAlias == null) { - var query: String? = methodProperty.query - if (query == null) { - query = "" - } - query += "(" - val propertyList = getPropertyList() - for (i in propertyList.indices) { - val property = propertyList[i] - if (i > 0) { - query += operationsList[i] + " " + override val nameAlias: NameAlias + get() { + if (this._nameAlias == null) { + var query: String? = methodProperty.query + if (query == null) { + query = "" } - query += property.toString() + query += "(" + val propertyList = getPropertyList() + for (i in propertyList.indices) { + val property = propertyList[i] + if (i > 0) { + query += operationsList[i] + " " + } + query += property.toString() + } + query += ")" + this._nameAlias = NameAlias.rawBuilder(query).build() } - query += ")" - this.nameAlias = NameAlias.rawBuilder(query).build() + return this._nameAlias!! } - return this.nameAlias!! - } /** * Represents the SQLite CAST operator. diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/IProperty.java b/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/IProperty.java deleted file mode 100644 index 924f0c702..000000000 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/IProperty.java +++ /dev/null @@ -1,128 +0,0 @@ -package com.raizlabs.dbflow5.query.property; - -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.dbflow5.sql.Query; -import com.raizlabs.dbflow5.query.Join; -import com.raizlabs.dbflow5.query.Method; -import com.raizlabs.dbflow5.query.NameAlias; -import com.raizlabs.dbflow5.query.OrderBy; -import com.raizlabs.dbflow5.structure.Model; - -/** - * Description: Defines the base interface all property classes implement. - */ -public interface IProperty

extends Query { - - /** - * @param aliasName The name of the alias. - * @return A new {@link P} that expresses the current column name with the specified Alias name. - */ - @NonNull - P as(@NonNull String aliasName); - - /** - * Adds another property and returns as a new property. i.e p1 + p2 - * - * @param property the property to add. - * @return A new instance. - */ - @NonNull - P plus(@NonNull IProperty property); - - /** - * Subtracts another property and returns as a new property. i.e p1 - p2 - * - * @param property the property to subtract. - * @return A new instance. - */ - @NonNull - P minus(@NonNull IProperty property); - - /** - * Divides another property and returns as a new property. i.e p1 / p2 - * - * @param property the property to divide. - * @return A new instance. - */ - @NonNull - P div(@NonNull IProperty property); - - /** - * Multiplies another property and returns as a new property. i.e p1 * p2 - * - * @param property the property to multiply. - * @return A new instance. - */ - P times(@NonNull IProperty property); - - /** - * Modulous another property and returns as a new property. i.e p1 % p2 - * - * @param property the property to calculate remainder of. - * @return A new instance. - */ - @NonNull - P rem(@NonNull IProperty property); - - /** - * Concats another property and returns as a new propert.y i.e. p1 || p2 - * - * @param property The property to concatenate. - * @return A new instance. - */ - @NonNull - P concatenate(@NonNull IProperty property); - - /** - * @return Appends DISTINCT to the property name. This is handy in {@link Method} queries. - * This distinct {@link P} can only be used with one column within a {@link Method}. - */ - @NonNull - P distinct(); - - /** - * @return A property that represents the {@link Model} from which it belongs to. This is useful - * in {@link Join} queries to represent this property. - *

- * The resulting {@link P} becomes `tableName`.`columnName`. - */ - @NonNull - P withTable(); - - /** - * @param tableNameAlias The name of the table to append. This may be different because of complex queries - * that use a {@link NameAlias} for the table name. - * @return A property that represents the {@link Model} from which it belongs to. This is useful - * in {@link Join} queries to represent this property. - *

- * The resulting column name becomes `tableName`.`columnName`. - */ - @NonNull - P withTable(@NonNull NameAlias tableNameAlias); - - /** - * @return The underlying {@link NameAlias} that represents the name of this property. - */ - @NonNull - NameAlias getNameAlias(); - - /** - * @return The key used in placing values into cursor. - */ - @NonNull - String getCursorKey(); - - /** - * @return the table this property belongs to. - */ - @Nullable - Class getTable(); - - @NonNull - OrderBy asc(); - - @NonNull - OrderBy desc(); -} diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/IProperty.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/IProperty.kt new file mode 100644 index 000000000..374566a60 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/IProperty.kt @@ -0,0 +1,113 @@ +package com.raizlabs.dbflow5.query.property + +import com.raizlabs.dbflow5.query.Join +import com.raizlabs.dbflow5.query.Method +import com.raizlabs.dbflow5.query.NameAlias +import com.raizlabs.dbflow5.query.OrderBy +import com.raizlabs.dbflow5.sql.Query +import com.raizlabs.dbflow5.structure.Model + +/** + * Description: Defines the base interface all property classes implement. + */ +interface IProperty

> : Query { + + /** + * @return The underlying [NameAlias] that represents the name of this property. + */ + val nameAlias: NameAlias + + /** + * @return The key used in placing values into cursor. + */ + val cursorKey: String + + /** + * @return the table this property belongs to. + */ + val table: Class<*>? + + /** + * @param aliasName The name of the alias. + * @return A new [P] that expresses the current column name with the specified Alias name. + */ + fun `as`(aliasName: String): P + + /** + * Adds another property and returns as a new property. i.e p1 + p2 + * + * @param property the property to add. + * @return A new instance. + */ + operator fun plus(property: IProperty<*>): P + + /** + * Subtracts another property and returns as a new property. i.e p1 - p2 + * + * @param property the property to subtract. + * @return A new instance. + */ + operator fun minus(property: IProperty<*>): P + + /** + * Divides another property and returns as a new property. i.e p1 / p2 + * + * @param property the property to divide. + * @return A new instance. + */ + operator fun div(property: IProperty<*>): P + + /** + * Multiplies another property and returns as a new property. i.e p1 * p2 + * + * @param property the property to multiply. + * @return A new instance. + */ + operator fun times(property: IProperty<*>): P + + /** + * Modulous another property and returns as a new property. i.e p1 % p2 + * + * @param property the property to calculate remainder of. + * @return A new instance. + */ + operator fun rem(property: IProperty<*>): P + + /** + * Concats another property and returns as a new propert.y i.e. p1 || p2 + * + * @param property The property to concatenate. + * @return A new instance. + */ + fun concatenate(property: IProperty<*>): P + + /** + * @return Appends DISTINCT to the property name. This is handy in [Method] queries. + * This distinct [P] can only be used with one column within a [Method]. + */ + fun distinct(): P + + /** + * @return A property that represents the [Model] from which it belongs to. This is useful + * in [Join] queries to represent this property. + * + * + * The resulting [P] becomes `tableName`.`columnName`. + */ + fun withTable(): P + + /** + * @param tableNameAlias The name of the table to append. This may be different because of complex queries + * that use a [NameAlias] for the table name. + * @return A property that represents the [Model] from which it belongs to. This is useful + * in [Join] queries to represent this property. + * + * + * The resulting column name becomes `tableName`.`columnName`. + */ + fun withTable(tableNameAlias: NameAlias): P + + fun asc(): OrderBy + + fun desc(): OrderBy +} diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/Property.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/Property.kt index 61a23c1b9..8c7865a17 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/Property.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/Property.kt @@ -24,7 +24,7 @@ import com.raizlabs.dbflow5.query.OrderBy */ open class Property : IProperty>, IConditional, IOperator { - internal val table: Class<*>? + override val table: Class<*>? private lateinit var internalNameAlias: NameAlias @@ -55,17 +55,20 @@ open class Property : IProperty>, IConditional, IOperator { } } - constructor(table: Class<*>?, columnName: String, aliasName: String) : this(table, NameAlias.builder(columnName).`as`(aliasName).build()) + constructor(table: Class<*>?, columnName: String, aliasName: String) + : this(table, NameAlias.builder(columnName).`as`(aliasName).build()) override fun withTable(): Property = withTable(NameAlias.Builder(FlowManager.getTableName(table!!)).build()) - override fun getNameAlias(): NameAlias = internalNameAlias + override val nameAlias: NameAlias + get() = internalNameAlias override val query: String get() = nameAlias.query - override fun getCursorKey(): String = nameAlias.query + override val cursorKey: String + get() = nameAlias.query override fun toString(): String = nameAlias.toString() @@ -170,8 +173,6 @@ open class Property : IProperty>, IConditional, IOperator { override fun rem(value: BaseModelQueriable<*>): Operator<*> = operator.rem(value) - override fun getTable(): Class<*>? = table - override fun plus(property: IProperty<*>): Property { return Property(table, NameAlias.joinNames(Operator.Operation.PLUS, internalNameAlias.fullName(), property.toString())) diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/TypeConvertedProperty.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/TypeConvertedProperty.kt index bb4576491..a7464bf57 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/TypeConvertedProperty.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/TypeConvertedProperty.kt @@ -20,7 +20,7 @@ class TypeConvertedProperty : Property { private val getter: TypeConverterGetter override val operator: Operator - get() = Operator.op(nameAlias, getter.getTypeConverter(getTable()!!), convertToDB) + get() = Operator.op(nameAlias, getter.getTypeConverter(table!!), convertToDB) /** * Generated by the compiler, looks up the type converter based on [ModelAdapter] when needed. @@ -51,7 +51,7 @@ class TypeConvertedProperty : Property { */ fun invertProperty(): Property { if (databaseProperty == null) { - databaseProperty = TypeConvertedProperty(getTable()!!, nameAlias, + databaseProperty = TypeConvertedProperty(table!!, nameAlias, !convertToDB, object : TypeConverterGetter { override fun getTypeConverter(modelClass: Class<*>): TypeConverter<*, *> = getter.getTypeConverter(modelClass) @@ -65,6 +65,6 @@ class TypeConvertedProperty : Property { .newBuilder() .withTable(tableNameAlias.query) .build() - return TypeConvertedProperty(this.getTable()!!, nameAlias, this.convertToDB, this.getter) + return TypeConvertedProperty(this.table!!, nameAlias, this.convertToDB, this.getter) } } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/WrapperProperty.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/WrapperProperty.kt index 1c9c142a8..d61c92605 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/WrapperProperty.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/WrapperProperty.kt @@ -21,7 +21,7 @@ class WrapperProperty : Property { */ fun invertProperty(): Property { if (databaseProperty == null) { - databaseProperty = WrapperProperty(getTable()!!, nameAlias) + databaseProperty = WrapperProperty(table!!, nameAlias) } return databaseProperty!! } From 97844a090ba0495e95bcea387b90b62f8de9379c Mon Sep 17 00:00:00 2001 From: fuzzagrosner Date: Mon, 4 Dec 2017 09:24:53 -0500 Subject: [PATCH 112/234] [gitbook] use version plugin with tags to display versioning. --- usage2/book.json | 8 ++++++++ 1 file changed, 8 insertions(+) create mode 100644 usage2/book.json diff --git a/usage2/book.json b/usage2/book.json new file mode 100644 index 000000000..77682128e --- /dev/null +++ b/usage2/book.json @@ -0,0 +1,8 @@ +{ + "plugins": [ "versions" ], + "pluginsConfig": { + "versions": { + "type": "tags" + } + } +} \ No newline at end of file From 8ba3c55febecedb85da874851b1f982848805807 Mon Sep 17 00:00:00 2001 From: fuzzagrosner Date: Mon, 4 Dec 2017 09:58:02 -0500 Subject: [PATCH 113/234] [caching] move cache methods into own separate cache adapter. This moves out logic and potential for errors. --- .../raizlabs/dbflow5/processor/ClassNames.kt | 3 +- .../dbflow5/processor/definition/Methods.kt | 88 +++--- .../processor/definition/TableDefinition.kt | 297 +++++++++--------- .../raizlabs/dbflow5/adapter/CacheAdapter.kt | 95 ++++++ .../raizlabs/dbflow5/adapter/ModelAdapter.kt | 142 ++------- .../queriable/CacheableListModelLoader.kt | 14 +- .../adapter/queriable/CacheableModelLoader.kt | 12 +- .../SingleKeyCacheableListModelLoader.kt | 10 +- .../SingleKeyCacheableModelLoader.kt | 11 +- .../saveable/CacheableListModelSaver.kt | 13 +- .../dbflow5/query/cache/ModelCache.kt | 4 +- 11 files changed, 355 insertions(+), 334 deletions(-) create mode 100644 dbflow/src/main/java/com/raizlabs/dbflow5/adapter/CacheAdapter.kt diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/ClassNames.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/ClassNames.kt index d7c01ef2a..01771dda2 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/ClassNames.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/ClassNames.kt @@ -47,7 +47,7 @@ object ClassNames { val TYPE_CONVERTER = ClassName.get(CONVERTER, "TypeConverter") val TYPE_CONVERTER_GETTER: ClassName = ClassName.get(PROPERTY_PACKAGE, - "TypeConvertedProperty.TypeConverterGetter") + "TypeConvertedProperty.TypeConverterGetter") val CONFLICT_ACTION = ClassName.get(ConflictAction::class.java) @@ -76,6 +76,7 @@ object ClassNames { val SINGLE_MODEL_LOADER = ClassName.get(QUERIABLE, "SingleModelLoader") val CACHEABLE_LIST_MODEL_LOADER = ClassName.get(QUERIABLE, "CacheableListModelLoader") val LIST_MODEL_LOADER = ClassName.get(QUERIABLE, "ListModelLoader") + val CACHE_ADAPTER = ClassName.get(ADAPTER, "CacheAdapter") val DATABASE_WRAPPER = ClassName.get(DATABASE, "DatabaseWrapper") diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/Methods.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/Methods.kt index 1d884ac5d..bf248470a 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/Methods.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/Methods.kt @@ -49,11 +49,11 @@ class BindToContentValuesMethod(private val baseTableDefinition: BaseTableDefini override val methodSpec: MethodSpec? get() { val methodBuilder = MethodSpec.methodBuilder(if (isInsert) "bindToInsertValues" else "bindToContentValues") - .addAnnotation(Override::class.java) - .addModifiers(Modifier.PUBLIC, Modifier.FINAL) - .addParameter(ClassNames.CONTENT_VALUES, PARAM_CONTENT_VALUES) - .addParameter(baseTableDefinition.parameterClassName, ModelUtils.variable) - .returns(TypeName.VOID) + .addAnnotation(Override::class.java) + .addModifiers(Modifier.PUBLIC, Modifier.FINAL) + .addParameter(ClassNames.CONTENT_VALUES, PARAM_CONTENT_VALUES) + .addParameter(baseTableDefinition.parameterClassName, ModelUtils.variable) + .returns(TypeName.VOID) var retMethodBuilder: MethodSpec.Builder? = methodBuilder @@ -66,7 +66,7 @@ class BindToContentValuesMethod(private val baseTableDefinition: BaseTableDefini if (implementsContentValuesListener) { methodBuilder.addStatement("\$L.onBindTo\$LValues(\$L)", - ModelUtils.variable, if (isInsert) "Insert" else "Content", PARAM_CONTENT_VALUES) + ModelUtils.variable, if (isInsert) "Insert" else "Content", PARAM_CONTENT_VALUES) } } else { if (baseTableDefinition.hasAutoIncrement || baseTableDefinition.hasRowID) { @@ -81,7 +81,7 @@ class BindToContentValuesMethod(private val baseTableDefinition: BaseTableDefini methodBuilder.addStatement("bindToInsertValues(\$L, \$L)", PARAM_CONTENT_VALUES, ModelUtils.variable) if (implementsContentValuesListener) { methodBuilder.addStatement("\$L.onBindTo\$LValues(\$L)", - ModelUtils.variable, if (isInsert) "Insert" else "Content", PARAM_CONTENT_VALUES) + ModelUtils.variable, if (isInsert) "Insert" else "Content", PARAM_CONTENT_VALUES) } } @@ -128,37 +128,37 @@ class BindToStatementMethod(private val tableDefinition: TableDefinition, privat override val methodSpec: MethodSpec? get() { val methodBuilder = MethodSpec.methodBuilder(mode.methodName) - .addAnnotation(Override::class.java) - .addModifiers(Modifier.PUBLIC, Modifier.FINAL) - .addParameter(ClassNames.DATABASE_STATEMENT, PARAM_STATEMENT) - .addParameter(tableDefinition.parameterClassName, - ModelUtils.variable).returns(TypeName.VOID) + .addAnnotation(Override::class.java) + .addModifiers(Modifier.PUBLIC, Modifier.FINAL) + .addParameter(ClassNames.DATABASE_STATEMENT, PARAM_STATEMENT) + .addParameter(tableDefinition.parameterClassName, + ModelUtils.variable).returns(TypeName.VOID) // write the reference method if (mode == Mode.INSERT) { methodBuilder.addParameter(TypeName.INT, PARAM_START) val realCount = AtomicInteger(1) tableDefinition.columnDefinitions - .filter { !it.isPrimaryKeyAutoIncrement && !it.isRowId } - .forEach { - methodBuilder.addCode(it.getSQLiteStatementMethod(realCount, true)) - realCount.incrementAndGet() - } + .filter { !it.isPrimaryKeyAutoIncrement && !it.isRowId } + .forEach { + methodBuilder.addCode(it.getSQLiteStatementMethod(realCount, true)) + realCount.incrementAndGet() + } } else { if (mode == Mode.UPDATE) { val realCount = AtomicInteger(1) // attach non rowid first, then go onto the WHERE clause tableDefinition.columnDefinitions - .filter { !it.isRowId } - .forEach { - methodBuilder.addCode(it.getSQLiteStatementMethod(realCount, - useStart = false)) - realCount.incrementAndGet() - } + .filter { !it.isRowId } + .forEach { + methodBuilder.addCode(it.getSQLiteStatementMethod(realCount, + useStart = false)) + realCount.incrementAndGet() + } tableDefinition.primaryColumnDefinitions.forEach { methodBuilder.addCode(it.getSQLiteStatementMethod(realCount, - useStart = false, defineProperty = false)) + useStart = false, defineProperty = false)) realCount.incrementAndGet() } } else if (mode == Mode.DELETE) { @@ -233,7 +233,7 @@ class CreationQueryMethod(private val tableDefinition: TableDefinition) : Method } val codeBuilder = CodeBlock.builder() - .add("return ${creationBuilder.toString().S}") + .add("return ${creationBuilder.toString().S}") val foreignKeyBlocks = arrayListOf() val tableNameBlocks = arrayListOf() @@ -301,7 +301,7 @@ class CustomTypeConverterPropertyMethod(private val baseTableDefinition: BaseTab val firstDef = def?.get(0) firstDef?.typeConverterElementNames?.forEach { elementName -> code.statement("global_typeConverter${it.simpleName()} " + - "= (\$T) holder.getTypeConverterForClass(\$T.class)", it, elementName) + "= (\$T) holder.getTypeConverterForClass(\$T.class)", it, elementName) } } return code @@ -315,8 +315,8 @@ class ExistenceMethod(private val tableDefinition: BaseTableDefinition) : Method override val methodSpec get() = `override fun`(TypeName.BOOLEAN, "exists", - param(tableDefinition.parameterClassName!!, ModelUtils.variable), - param(ClassNames.DATABASE_WRAPPER, "wrapper")) { + param(tableDefinition.parameterClassName!!, ModelUtils.variable), + param(ClassNames.DATABASE_WRAPPER, "wrapper")) { modifiers(public, final) code { // only quick check if enabled. @@ -341,10 +341,10 @@ class InsertStatementQueryMethod(private val tableDefinition: TableDefinition, p return null // dont write method here because we reuse the compiled statement query method } return `override fun`(String::class, - if (isInsert) "getInsertStatementQuery" else "getCompiledStatementQuery") { + if (isInsert) "getInsertStatementQuery" else "getCompiledStatementQuery") { modifiers(public, final) val isSingleAutoincrement = tableDefinition.hasAutoIncrement - && tableDefinition.columnDefinitions.size == 1 && isInsert + && tableDefinition.columnDefinitions.size == 1 && isInsert `return`(codeBlock { add("INSERT ") if (!tableDefinition.insertConflictActionName.isEmpty()) { @@ -362,10 +362,10 @@ class InsertStatementQueryMethod(private val tableDefinition: TableDefinition, p add(") VALUES (") tableDefinition.columnDefinitions.filter { !it.isPrimaryKeyAutoIncrement && !it.isRowId || !isInsert } - .forEachIndexed { index, columnDefinition -> - if (index > 0) add(",") - add(columnDefinition.insertStatementValuesString) - } + .forEachIndexed { index, columnDefinition -> + if (index > 0) add(",") + add(columnDefinition.insertStatementValuesString) + } if (isSingleAutoincrement) add("NULL") @@ -440,9 +440,9 @@ class LoadFromCursorMethod(private val baseTableDefinition: BaseTableDefinition) override val methodSpec: MethodSpec get() = `override fun`(TypeName.VOID, "loadFromCursor", - param(ClassNames.FLOW_CURSOR, PARAM_CURSOR), - param(baseTableDefinition.parameterClassName!!, ModelUtils.variable), - param(ClassNames.DATABASE_WRAPPER, ModelUtils.wrapper)) { + param(ClassNames.FLOW_CURSOR, PARAM_CURSOR), + param(baseTableDefinition.parameterClassName!!, ModelUtils.variable), + param(ClassNames.DATABASE_WRAPPER, ModelUtils.wrapper)) { modifiers(public, final) val index = AtomicInteger(0) val nameAllocator = NameAllocator() // unique names @@ -454,8 +454,8 @@ class LoadFromCursorMethod(private val baseTableDefinition: BaseTableDefinition) if (baseTableDefinition is TableDefinition) { code { baseTableDefinition.oneToManyDefinitions - .filter { it.isLoad } - .forEach { it.writeLoad(this) } + .filter { it.isLoad } + .forEach { it.writeLoad(this) } this } } @@ -483,11 +483,11 @@ class OneToManyDeleteMethod(private val tableDefinition: TableDefinition) : Meth val shouldWrite = tableDefinition.oneToManyDefinitions.any { it.isDelete } if (shouldWrite || tableDefinition.cachingEnabled) { return `override fun`(TypeName.BOOLEAN, "delete", - param(tableDefinition.elementClassName!!, ModelUtils.variable)) { + param(tableDefinition.elementClassName!!, ModelUtils.variable)) { modifiers(public, final) addParameter(ClassNames.DATABASE_WRAPPER, ModelUtils.wrapper) if (tableDefinition.cachingEnabled) { - statement("getModelCache().removeModel(getCachingId(${ModelUtils.variable}))") + statement("cacheAdapter.removeModelFromCache(${ModelUtils.variable})") } statement("boolean successful = super.delete(${ModelUtils.variable}${wrapperCommaIfBaseModel(true)})") @@ -520,7 +520,7 @@ class OneToManySaveMethod(private val tableDefinition: TableDefinition, } return `override fun`(retType, methodName, - param(tableDefinition.elementClassName!!, ModelUtils.variable)) { + param(tableDefinition.elementClassName!!, ModelUtils.variable)) { modifiers(public, final) addParameter(ClassNames.DATABASE_WRAPPER, ModelUtils.wrapper) code { @@ -532,7 +532,7 @@ class OneToManySaveMethod(private val tableDefinition: TableDefinition, statement("super.$methodName(${ModelUtils.variable}${wrapperCommaIfBaseModel(true)})") if (tableDefinition.cachingEnabled) { - statement("getModelCache().addModel(getCachingId(${ModelUtils.variable}), ${ModelUtils.variable})") + statement("cacheAdapter.storeModelInCache(${ModelUtils.variable})") } this } @@ -567,7 +567,7 @@ class PrimaryConditionMethod(private val tableDefinition: BaseTableDefinition) : override val methodSpec: MethodSpec? get() = `override fun`(ClassNames.OPERATOR_GROUP, "getPrimaryConditionClause", - param(tableDefinition.parameterClassName!!, ModelUtils.variable)) { + param(tableDefinition.parameterClassName!!, ModelUtils.variable)) { modifiers(public, final) code { statement("\$T clause = \$T.clause()", ClassNames.OPERATOR_GROUP, ClassNames.OPERATOR_GROUP) diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/TableDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/TableDefinition.kt index 37928fd44..34414e97d 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/TableDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/TableDefinition.kt @@ -3,6 +3,7 @@ package com.raizlabs.dbflow5.processor.definition import com.grosner.kpoet.L import com.grosner.kpoet.S import com.grosner.kpoet.`=` +import com.grosner.kpoet.`private final field` import com.grosner.kpoet.`public static final field` import com.grosner.kpoet.`return` import com.grosner.kpoet.`throw new` @@ -144,7 +145,7 @@ class TableDefinition(manager: ProcessorManager, element: TypeElement) : BaseTab inheritedColumns.forEach { if (inheritedFieldNameList.contains(it.fieldName)) { manager.logError("A duplicate inherited column with name %1s was found for %1s", - it.fieldName, tableName) + it.fieldName, tableName) } inheritedFieldNameList.add(it.fieldName) inheritedColumnMap.put(it.fieldName, it) @@ -154,36 +155,36 @@ class TableDefinition(manager: ProcessorManager, element: TypeElement) : BaseTab inheritedPrimaryKeys.forEach { if (inheritedFieldNameList.contains(it.fieldName)) { manager.logError("A duplicate inherited column with name %1s was found for %1s", - it.fieldName, tableName) + it.fieldName, tableName) } inheritedFieldNameList.add(it.fieldName) inheritedPrimaryKeyMap.put(it.fieldName, it) } implementsLoadFromCursorListener = element.implementsClass(manager.processingEnvironment, - ClassNames.LOAD_FROM_CURSOR_LISTENER) + ClassNames.LOAD_FROM_CURSOR_LISTENER) implementsContentValuesListener = element.implementsClass(manager.processingEnvironment, - ClassNames.CONTENT_VALUES_LISTENER) + ClassNames.CONTENT_VALUES_LISTENER) implementsSqlStatementListener = element.implementsClass(manager.processingEnvironment, - ClassNames.SQLITE_STATEMENT_LISTENER) + ClassNames.SQLITE_STATEMENT_LISTENER) } methods = arrayOf(BindToContentValuesMethod(this, true, implementsContentValuesListener), - BindToContentValuesMethod(this, false, implementsContentValuesListener), - BindToStatementMethod(this, INSERT), BindToStatementMethod(this, NON_INSERT), - BindToStatementMethod(this, UPDATE), BindToStatementMethod(this, DELETE), - InsertStatementQueryMethod(this, true), InsertStatementQueryMethod(this, false), - UpdateStatementQueryMethod(this), DeleteStatementQueryMethod(this), - CreationQueryMethod(this), - LoadFromCursorMethod(this), - ExistenceMethod(this), - PrimaryConditionMethod(this), - OneToManyDeleteMethod(this), - OneToManySaveMethod(this, OneToManySaveMethod.METHOD_SAVE), - OneToManySaveMethod(this, OneToManySaveMethod.METHOD_INSERT), - OneToManySaveMethod(this, OneToManySaveMethod.METHOD_UPDATE)) + BindToContentValuesMethod(this, false, implementsContentValuesListener), + BindToStatementMethod(this, INSERT), BindToStatementMethod(this, NON_INSERT), + BindToStatementMethod(this, UPDATE), BindToStatementMethod(this, DELETE), + InsertStatementQueryMethod(this, true), InsertStatementQueryMethod(this, false), + UpdateStatementQueryMethod(this), DeleteStatementQueryMethod(this), + CreationQueryMethod(this), + LoadFromCursorMethod(this), + ExistenceMethod(this), + PrimaryConditionMethod(this), + OneToManyDeleteMethod(this), + OneToManySaveMethod(this, OneToManySaveMethod.METHOD_SAVE), + OneToManySaveMethod(this, OneToManySaveMethod.METHOD_INSERT), + OneToManySaveMethod(this, OneToManySaveMethod.METHOD_UPDATE)) } override fun prepareForWrite() { @@ -237,7 +238,7 @@ class TableDefinition(manager: ProcessorManager, element: TypeElement) : BaseTab } val definition = UniqueGroupsDefinition(uniqueGroup) columnDefinitions.filter { it.uniqueGroups.contains(definition.number) } - .forEach { definition.addColumnDefinition(it) } + .forEach { definition.addColumnDefinition(it) } uniqueGroupsDefinitions.add(definition) uniqueNumbersSet.add(uniqueGroup.groupNumber) } @@ -250,7 +251,7 @@ class TableDefinition(manager: ProcessorManager, element: TypeElement) : BaseTab } val definition = IndexGroupsDefinition(this, indexGroup) columnDefinitions.filter { it.indexGroups.contains(definition.indexNumber) } - .forEach { definition.columnDefinitionList.add(it) } + .forEach { definition.columnDefinitionList.add(it) } indexGroupsDefinitions.add(definition) uniqueNumbersSet.add(indexGroup.number) } @@ -264,9 +265,9 @@ class TableDefinition(manager: ProcessorManager, element: TypeElement) : BaseTab for (element in elements) { classElementLookUpMap.put(element.simpleName.toString(), element) if (element is ExecutableElement && element.parameters.isEmpty() - && element.simpleName.toString() == "" - && element.enclosingElement == typeElement - && !element.modifiers.contains(Modifier.PRIVATE)) { + && element.simpleName.toString() == "" + && element.enclosingElement == typeElement + && !element.modifiers.contains(Modifier.PRIVATE)) { hasPrimaryConstructor = true } } @@ -287,24 +288,24 @@ class TableDefinition(manager: ProcessorManager, element: TypeElement) : BaseTab val isInheritedPrimaryKey = inheritedPrimaryKeyMap.containsKey(element.simpleName.toString()) val isColumnMap = element.annotation() != null if (element.annotation() != null || isForeign || isPrimary - || isAllFields || isInherited || isInheritedPrimaryKey || isColumnMap) { + || isAllFields || isInherited || isInheritedPrimaryKey || isColumnMap) { if (checkInheritancePackagePrivate(isPackagePrivateNotInSamePackage, element)) return val columnDefinition = if (isInheritedPrimaryKey) { val inherited = inheritedPrimaryKeyMap[element.simpleName.toString()] ColumnDefinition(manager, element, this, isPackagePrivateNotInSamePackage, - inherited?.column, inherited?.primaryKey) + inherited?.column, inherited?.primaryKey) } else if (isInherited) { val inherited = inheritedColumnMap[element.simpleName.toString()] ColumnDefinition(manager, element, this, isPackagePrivateNotInSamePackage, - inherited?.column, null, inherited?.nonNullConflict ?: ConflictAction.NONE) + inherited?.column, null, inherited?.nonNullConflict ?: ConflictAction.NONE) } else if (isForeign || isColumnMap) { ReferenceColumnDefinition(manager, this, - element, isPackagePrivateNotInSamePackage) + element, isPackagePrivateNotInSamePackage) } else { ColumnDefinition(manager, element, - this, isPackagePrivateNotInSamePackage) + this, isPackagePrivateNotInSamePackage) } if (columnValidator.validate(manager, columnDefinition)) { @@ -324,10 +325,10 @@ class TableDefinition(manager: ProcessorManager, element: TypeElement) : BaseTab // check to ensure not null. if (it.isNullableType) { manager.logWarning("Attempting to use nullable field type on an autoincrementing column. " + - "To suppress or remove this warning " + - "switch to java primitive, add @android.support.annotation.NonNull," + - "@org.jetbrains.annotation.NotNull, or in Kotlin don't make it nullable. Check the column ${it.columnName} " + - "on $tableName") + "To suppress or remove this warning " + + "switch to java primitive, add @android.support.annotation.NonNull," + + "@org.jetbrains.annotation.NotNull, or in Kotlin don't make it nullable. Check the column ${it.columnName} " + + "on $tableName") } } @@ -416,7 +417,7 @@ class TableDefinition(manager: ProcessorManager, element: TypeElement) : BaseTab val getPropertiesBuilder = CodeBlock.builder() `override fun`(ClassNames.PROPERTY, "getProperty", - param(String::class, paramColumnName)) { + param(String::class, paramColumnName)) { modifiers(public, final) statement("$paramColumnName = \$T.quoteIfNeeded($paramColumnName)", ClassNames.STRING_UTILS) @@ -450,7 +451,7 @@ class TableDefinition(manager: ProcessorManager, element: TypeElement) : BaseTab val autoIncrement = autoIncrementColumn autoIncrement?.let { `override fun`(TypeName.VOID, "updateAutoIncrement", param(elementClassName!!, ModelUtils.variable), - param(Number::class, "id")) { + param(Number::class, "id")) { modifiers(public, final) addCode(autoIncrement.updateAutoIncrementMethod) } @@ -472,28 +473,28 @@ class TableDefinition(manager: ProcessorManager, element: TypeElement) : BaseTab } val saveForeignKeyFields = columnDefinitions - .filter { (it is ReferenceColumnDefinition) && it.saveForeignKeyModel } - .map { it as ReferenceColumnDefinition } + .filter { (it is ReferenceColumnDefinition) && it.saveForeignKeyModel } + .map { it as ReferenceColumnDefinition } if (saveForeignKeyFields.isNotEmpty()) { val code = CodeBlock.builder() saveForeignKeyFields.forEach { it.appendSaveMethod(code) } `override fun`(TypeName.VOID, "saveForeignKeys", param(elementClassName!!, ModelUtils.variable), - param(ClassNames.DATABASE_WRAPPER, ModelUtils.wrapper)) { + param(ClassNames.DATABASE_WRAPPER, ModelUtils.wrapper)) { modifiers(public, final) addCode(code.build()) } } val deleteForeignKeyFields = columnDefinitions - .filter { (it is ReferenceColumnDefinition) && it.deleteForeignKeyModel } - .map { it as ReferenceColumnDefinition } + .filter { (it is ReferenceColumnDefinition) && it.deleteForeignKeyModel } + .map { it as ReferenceColumnDefinition } if (deleteForeignKeyFields.isNotEmpty()) { val code = CodeBlock.builder() deleteForeignKeyFields.forEach { it.appendDeleteMethod(code) } `override fun`(TypeName.VOID, "deleteForeignKeys", param(elementClassName!!, ModelUtils.variable), - param(ClassNames.DATABASE_WRAPPER, ModelUtils.wrapper)) { + param(ClassNames.DATABASE_WRAPPER, ModelUtils.wrapper)) { modifiers(public, final) addCode(code.build()) } @@ -512,29 +513,127 @@ class TableDefinition(manager: ProcessorManager, element: TypeElement) : BaseTab } if (cachingEnabled) { + `private final field`(ClassNames.CACHE_ADAPTER, "cacheAdapter") { + `=` { + addStatement("\$L", + TypeSpec.anonymousClassBuilder("this") + .addSuperinterface(ParameterizedTypeName.get(ClassNames.CACHE_ADAPTER, elementTypeName)) + .apply { + val primaryColumns = primaryColumnDefinitions + if (primaryColumns.size > 1) { + `override fun`(ArrayTypeName.of(Any::class.java), "getCachingColumnValuesFromModel", + param(ArrayTypeName.of(Any::class.java), "inValues"), + param(elementClassName!!, ModelUtils.variable)) { + modifiers(public, final) + for (i in primaryColumns.indices) { + val column = primaryColumns[i] + addCode(column.getColumnAccessString(i)) + } + + `return`("inValues") + } + + `override fun`(ArrayTypeName.of(Any::class.java), "getCachingColumnValuesFromCursor", + param(ArrayTypeName.of(Any::class.java), "inValues"), + param(ClassNames.FLOW_CURSOR, "cursor")) { + modifiers(public, final) + for (i in primaryColumns.indices) { + val column = primaryColumns[i] + val method = DefinitionUtils.getLoadFromCursorMethodString(column.elementTypeName, column.wrapperTypeName) + statement("inValues[$i] = ${LoadFromCursorMethod.PARAM_CURSOR}" + + ".$method(${LoadFromCursorMethod.PARAM_CURSOR}.getColumnIndex(${column.columnName.S}))") + } + `return`("inValues") + } + } else { + // single primary key + `override fun`(Any::class, "getCachingColumnValueFromModel", + param(elementClassName!!, ModelUtils.variable)) { + modifiers(public, final) + addCode(primaryColumns[0].getSimpleAccessString()) + } + + `override fun`(Any::class, "getCachingColumnValueFromCursor", param(ClassNames.FLOW_CURSOR, "cursor")) { + modifiers(public, final) + val column = primaryColumns[0] + val method = DefinitionUtils.getLoadFromCursorMethodString(column.elementTypeName, column.wrapperTypeName) + `return`("${LoadFromCursorMethod.PARAM_CURSOR}.$method(${LoadFromCursorMethod.PARAM_CURSOR}.getColumnIndex(${column.columnName.S}))") + } + `override fun`(Any::class, "getCachingId", param(elementClassName!!, ModelUtils.variable)) { + modifiers(public, final) + `return`("getCachingColumnValueFromModel(${ModelUtils.variable})") + } + } + + + `override fun`(ArrayTypeName.of(ClassName.get(String::class.java)), "createCachingColumns") { + modifiers(public, final) + `return`("new String[]{${primaryColumns.joinToString { it.columnName.quoteIfNeeded().S }}}") + } + + if (cacheSize != DEFAULT_CACHE_SIZE) { + `override fun`(TypeName.INT, "getCacheSize") { + modifiers(public, final) + `return`(cacheSize.L) + } + } + + if (!customCacheFieldName.isNullOrEmpty()) { + `override fun`(ParameterizedTypeName.get(ClassNames.MODEL_CACHE, elementClassName, + WildcardTypeName.subtypeOf(Any::class.java)), "createModelCache") { + modifiers(public, final) + `return`("\$T.$customCacheFieldName", elementClassName) + } + } + + if (!customMultiCacheFieldName.isNullOrEmpty()) { + `override fun`(ParameterizedTypeName.get(ClassNames.MULTI_KEY_CACHE_CONVERTER, + WildcardTypeName.subtypeOf(Any::class.java)), "getCacheConverter") { + modifiers(public, final) + `return`("\$T.$customMultiCacheFieldName", elementClassName) + } + } + if (foreignKeyDefinitions.isNotEmpty()) { + `override fun`(TypeName.VOID, "reloadRelationships", + param(elementClassName!!, ModelUtils.variable), + param(ClassNames.FLOW_CURSOR, LoadFromCursorMethod.PARAM_CURSOR), + param(ClassNames.DATABASE_WRAPPER, ModelUtils.wrapper)) { + modifiers(public, final) + code { + val noIndex = AtomicInteger(-1) + val nameAllocator = NameAllocator() + foreignKeyDefinitions.forEach { add(it.getLoadFromCursorMethod(false, noIndex, nameAllocator)) } + this + } + } + } + } + .build()) + } + } val singlePrimaryKey = primaryColumnDefinitions.size == 1 `override fun`(ClassNames.SINGLE_MODEL_LOADER, "createSingleModelLoader") { modifiers(public, final) - addStatement("return new \$T<>(getModelClass())", - if (singlePrimaryKey) - ClassNames.SINGLE_KEY_CACHEABLE_MODEL_LOADER - else - ClassNames.CACHEABLE_MODEL_LOADER) + addStatement("return new \$T<>(getModelClass(), cacheAdapter)", + if (singlePrimaryKey) + ClassNames.SINGLE_KEY_CACHEABLE_MODEL_LOADER + else + ClassNames.CACHEABLE_MODEL_LOADER) } `override fun`(ClassNames.LIST_MODEL_LOADER, "createListModelLoader") { modifiers(public, final) - `return`("new \$T<>(getModelClass())", - if (singlePrimaryKey) - ClassNames.SINGLE_KEY_CACHEABLE_LIST_MODEL_LOADER - else - ClassNames.CACHEABLE_LIST_MODEL_LOADER) + `return`("new \$T<>(getModelClass(), cacheAdapter)", + if (singlePrimaryKey) + ClassNames.SINGLE_KEY_CACHEABLE_LIST_MODEL_LOADER + else + ClassNames.CACHEABLE_LIST_MODEL_LOADER) } `override fun`(ParameterizedTypeName.get(ClassNames.CACHEABLE_LIST_MODEL_SAVER, elementClassName), - "createListModelSaver") { + "createListModelSaver") { modifiers(protected) - `return`("new \$T<>(getModelSaver())", ClassNames.CACHEABLE_LIST_MODEL_SAVER) + `return`("new \$T<>(getModelSaver(), cacheAdapter)", ClassNames.CACHEABLE_LIST_MODEL_SAVER) } `override fun`(TypeName.BOOLEAN, "cachingEnabled") { modifiers(public, final) @@ -542,104 +641,16 @@ class TableDefinition(manager: ProcessorManager, element: TypeElement) : BaseTab } `override fun`(TypeName.VOID, "load", param(elementClassName!!, "model"), - param(ClassNames.DATABASE_WRAPPER, wrapper)) { + param(ClassNames.DATABASE_WRAPPER, wrapper)) { modifiers(public, final) statement("super.load(model, $wrapper)") - statement("getModelCache().addModel(getCachingId(${ModelUtils.variable}), ${ModelUtils.variable})") + statement("cacheAdapter.storeModelInCache(model)") } - val primaryColumns = primaryColumnDefinitions - if (primaryColumns.size > 1) { - `override fun`(ArrayTypeName.of(Any::class.java), "getCachingColumnValuesFromModel", - param(ArrayTypeName.of(Any::class.java), "inValues"), - param(elementClassName!!, ModelUtils.variable)) { - modifiers(public, final) - for (i in primaryColumns.indices) { - val column = primaryColumns[i] - addCode(column.getColumnAccessString(i)) - } - - `return`("inValues") - } - - `override fun`(ArrayTypeName.of(Any::class.java), "getCachingColumnValuesFromCursor", - param(ArrayTypeName.of(Any::class.java), "inValues"), - param(ClassNames.FLOW_CURSOR, "cursor")) { - modifiers(public, final) - for (i in primaryColumns.indices) { - val column = primaryColumns[i] - val method = DefinitionUtils.getLoadFromCursorMethodString(column.elementTypeName, column.wrapperTypeName) - statement("inValues[$i] = ${LoadFromCursorMethod.PARAM_CURSOR}" + - ".$method(${LoadFromCursorMethod.PARAM_CURSOR}.getColumnIndex(${column.columnName.S}))") - } - `return`("inValues") - } - } else { - // single primary key - `override fun`(Any::class, "getCachingColumnValueFromModel", - param(elementClassName!!, ModelUtils.variable)) { - modifiers(public, final) - addCode(primaryColumns[0].getSimpleAccessString()) - } - - `override fun`(Any::class, "getCachingColumnValueFromCursor", param(ClassNames.FLOW_CURSOR, "cursor")) { - modifiers(public, final) - val column = primaryColumns[0] - val method = DefinitionUtils.getLoadFromCursorMethodString(column.elementTypeName, column.wrapperTypeName) - `return`("${LoadFromCursorMethod.PARAM_CURSOR}.$method(${LoadFromCursorMethod.PARAM_CURSOR}.getColumnIndex(${column.columnName.S}))") - } - `override fun`(Any::class, "getCachingId", param(elementClassName!!, ModelUtils.variable)) { - modifiers(public, final) - `return`("getCachingColumnValueFromModel(${ModelUtils.variable})") - } - } - - `override fun`(ArrayTypeName.of(ClassName.get(String::class.java)), "createCachingColumns") { - modifiers(public, final) - `return`("new String[]{${primaryColumns.joinToString { it.columnName.quoteIfNeeded().S }}}") - } - - if (cacheSize != DEFAULT_CACHE_SIZE) { - `override fun`(TypeName.INT, "getCacheSize") { - modifiers(public, final) - `return`(cacheSize.L) - } - } - - if (!customCacheFieldName.isNullOrEmpty()) { - `override fun`(ParameterizedTypeName.get(ClassNames.MODEL_CACHE, elementClassName, - WildcardTypeName.subtypeOf(Any::class.java)), "createModelCache") { - modifiers(public, final) - `return`("\$T.$customCacheFieldName", elementClassName) - } - } - - if (!customMultiCacheFieldName.isNullOrEmpty()) { - `override fun`(ParameterizedTypeName.get(ClassNames.MULTI_KEY_CACHE_CONVERTER, - WildcardTypeName.subtypeOf(Any::class.java)), "getCacheConverter") { - modifiers(public, final) - `return`("\$T.$customMultiCacheFieldName", elementClassName) - } - } - - if (foreignKeyDefinitions.isNotEmpty()) { - `override fun`(TypeName.VOID, "reloadRelationships", - param(elementClassName!!, ModelUtils.variable), - param(ClassNames.FLOW_CURSOR, LoadFromCursorMethod.PARAM_CURSOR), - param(ClassNames.DATABASE_WRAPPER, ModelUtils.wrapper)) { - modifiers(public, final) - code { - val noIndex = AtomicInteger(-1) - val nameAllocator = NameAllocator() - foreignKeyDefinitions.forEach { add(it.getLoadFromCursorMethod(false, noIndex, nameAllocator)) } - this - } - } - } } } methods.mapNotNull { it.methodSpec } - .forEach { typeBuilder.addMethod(it) } + .forEach { typeBuilder.addMethod(it) } } } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/CacheAdapter.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/CacheAdapter.kt new file mode 100644 index 000000000..335df901e --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/CacheAdapter.kt @@ -0,0 +1,95 @@ +package com.raizlabs.dbflow5.adapter + +import com.raizlabs.dbflow5.annotation.DEFAULT_CACHE_SIZE +import com.raizlabs.dbflow5.database.DatabaseWrapper +import com.raizlabs.dbflow5.database.FlowCursor +import com.raizlabs.dbflow5.query.cache.IMultiKeyCacheConverter +import com.raizlabs.dbflow5.query.cache.ModelCache +import com.raizlabs.dbflow5.query.cache.SimpleMapCache +import com.raizlabs.dbflow5.structure.InvalidDBConfiguration + +/** + * Description: + */ +abstract class CacheAdapter(private val modelAdapter: ModelAdapter) { + + val modelCache: ModelCache by lazy { createModelCache() } + val cachingColumns: Array by lazy { createCachingColumns() } + + open val cacheSize: Int + get() = DEFAULT_CACHE_SIZE + + open val cacheConverter: IMultiKeyCacheConverter<*> + get() = throw InvalidDBConfiguration("For multiple primary keys, a public static IMultiKeyCacheConverter field must" + + "be marked with @MultiCacheField in the corresponding model class. The resulting key" + + "must be a unique combination of the multiple keys, otherwise inconsistencies may occur.") + + /** + * @param cursor The cursor to load caching id from. + * @return The single cache column from cursor (if single). + */ + open fun getCachingColumnValueFromCursor(cursor: FlowCursor): Any? = Unit + + /** + * @param model The model to load cache column data from. + * @return The single cache column from model (if single). + */ + open fun getCachingColumnValueFromModel(model: T): Any? = Unit + + + /** + * @return A set of columns that represent the caching columns. + */ + open fun createCachingColumns(): Array = arrayOf(modelAdapter.autoIncrementingColumnName) + + /** + * Loads all primary keys from the [FlowCursor] into the inValues. The size of the array must + * match all primary keys. This method gets generated when caching is enabled. + * + * @param inValues The reusable array of values to populate. + * @param cursor The cursor to load from. + * @return The populated set of values to load from cache. + */ + open fun getCachingColumnValuesFromCursor(inValues: Array, cursor: FlowCursor): Array? = null + + /** + * Loads all primary keys from the [TModel] into the inValues. The size of the array must + * match all primary keys. This method gets generated when caching is enabled. It converts the primary fields + * of the [TModel] into the array of values the caching mechanism uses. + * + * @param inValues The reusable array of values to populate. + * @param TModel The model to load from. + * @return The populated set of values to load from cache. + */ + open fun getCachingColumnValuesFromModel(inValues: Array, TModel: T): Array? = null + + fun storeModelInCache(model: T) { + modelCache.addModel(getCachingId(model), model) + } + + fun removeModelFromCache(model: T) { + getCachingId(model)?.let { modelCache.removeModel(it) } + } + + fun getCachingId(inValues: Array?): Any? = when { + inValues?.size == 1 -> // if it exists in cache no matter the query we will use that one + inValues.getOrNull(0) + inValues != null -> cacheConverter.getCachingKey(inValues) + else -> null + } + + open fun getCachingId(model: T): Any? = + getCachingId(getCachingColumnValuesFromModel(arrayOfNulls(cachingColumns.size), model)) + + + open fun createModelCache(): ModelCache = SimpleMapCache(cacheSize) + + /** + * Reloads relationships when loading from [FlowCursor] in a model that's cacheable. By having + * relationships with cached models, the retrieval will be very fast. + * + * @param cursor The cursor to reload from. + */ + open fun reloadRelationships(model: T, cursor: FlowCursor, databaseWrapper: DatabaseWrapper) = Unit + +} \ No newline at end of file diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/ModelAdapter.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/ModelAdapter.kt index d481a48b1..17977fe3e 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/ModelAdapter.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/ModelAdapter.kt @@ -2,23 +2,19 @@ package com.raizlabs.dbflow5.adapter import android.content.ContentValues import android.database.sqlite.SQLiteStatement +import com.raizlabs.dbflow5.adapter.saveable.ListModelSaver +import com.raizlabs.dbflow5.adapter.saveable.ModelSaver import com.raizlabs.dbflow5.annotation.ConflictAction -import com.raizlabs.dbflow5.annotation.DEFAULT_CACHE_SIZE import com.raizlabs.dbflow5.annotation.ForeignKey import com.raizlabs.dbflow5.annotation.PrimaryKey import com.raizlabs.dbflow5.annotation.Table import com.raizlabs.dbflow5.config.DatabaseDefinition -import com.raizlabs.dbflow5.query.property.IProperty -import com.raizlabs.dbflow5.query.property.Property -import com.raizlabs.dbflow5.adapter.saveable.ListModelSaver -import com.raizlabs.dbflow5.adapter.saveable.ModelSaver -import com.raizlabs.dbflow5.query.cache.IMultiKeyCacheConverter -import com.raizlabs.dbflow5.query.cache.ModelCache -import com.raizlabs.dbflow5.query.cache.SimpleMapCache -import com.raizlabs.dbflow5.structure.InvalidDBConfiguration import com.raizlabs.dbflow5.database.DatabaseStatement import com.raizlabs.dbflow5.database.DatabaseWrapper import com.raizlabs.dbflow5.database.FlowCursor +import com.raizlabs.dbflow5.query.property.IProperty +import com.raizlabs.dbflow5.query.property.Property +import com.raizlabs.dbflow5.structure.InvalidDBConfiguration /** * Description: Used for generated classes from the combination of [Table] and [Model]. @@ -31,8 +27,6 @@ abstract class ModelAdapter(databaseDefinition: DatabaseDefinition) private var updateStatement: DatabaseStatement? = null private var deleteStatement: DatabaseStatement? = null - val cachingColumns: Array by lazy { createCachingColumns() } - val modelCache: ModelCache by lazy { createModelCache() } private var _modelSaver: ModelSaver? = null val listModelSaver: ListModelSaver by lazy { createListModelSaver() } @@ -43,16 +37,8 @@ abstract class ModelAdapter(databaseDefinition: DatabaseDefinition) */ open val autoIncrementingColumnName: String get() = throw InvalidDBConfiguration("This method may have been called in error." + - " The model class $modelClass must contain an autoincrementing" + - " or single int/long primary key (if used in a ModelCache, this method may be called)") - - open val cacheSize: Int - get() = DEFAULT_CACHE_SIZE - - open val cacheConverter: IMultiKeyCacheConverter<*> - get() = throw InvalidDBConfiguration("For multiple primary keys, a public static IMultiKeyCacheConverter field must" + - "be marked with @MultiCacheField in the corresponding model class. The resulting key" + - "must be a unique combination of the multiple keys, otherwise inconsistencies may occur.") + " The model class $modelClass must contain an autoincrementing" + + " or single int/long primary key (if used in a ModelCache, this method may be called)") /** * @return The query used to create this table. @@ -119,7 +105,7 @@ abstract class ModelAdapter(databaseDefinition: DatabaseDefinition) * To bind values use [.bindToInsertStatement]. */ fun getInsertStatement(databaseWrapper: DatabaseWrapper): DatabaseStatement = - databaseWrapper.compileStatement(insertStatementQuery) + databaseWrapper.compileStatement(insertStatementQuery) /** * @param databaseWrapper The database used to do an update statement. @@ -127,7 +113,7 @@ abstract class ModelAdapter(databaseDefinition: DatabaseDefinition) * To bind values use [.bindToUpdateStatement]. */ fun getUpdateStatement(databaseWrapper: DatabaseWrapper): DatabaseStatement = - databaseWrapper.compileStatement(updateStatementQuery) + databaseWrapper.compileStatement(updateStatementQuery) /** * @param databaseWrapper The database used to do a delete statement. @@ -135,7 +121,7 @@ abstract class ModelAdapter(databaseDefinition: DatabaseDefinition) * To bind values use [.bindToDeleteStatement]. */ fun getDeleteStatement(databaseWrapper: DatabaseWrapper): DatabaseStatement = - databaseWrapper.compileStatement(deleteStatementQuery) + databaseWrapper.compileStatement(deleteStatementQuery) fun closeCompiledStatement() { compiledStatement?.close() @@ -148,7 +134,7 @@ abstract class ModelAdapter(databaseDefinition: DatabaseDefinition) * To bind values use [.bindToInsertStatement]. */ fun getCompiledStatement(databaseWrapper: DatabaseWrapper): DatabaseStatement = - databaseWrapper.compileStatement(compiledStatementQuery) + databaseWrapper.compileStatement(compiledStatementQuery) /** * Creates a new [T] and Loads the cursor into a the object. @@ -157,31 +143,31 @@ abstract class ModelAdapter(databaseDefinition: DatabaseDefinition) * @return A new [T] */ fun loadFromCursor(cursor: FlowCursor, databaseWrapper: DatabaseWrapper): T = - newInstance().apply { loadFromCursor(cursor, this, databaseWrapper) } + newInstance().apply { loadFromCursor(cursor, this, databaseWrapper) } override fun save(model: T, databaseWrapper: DatabaseWrapper): Boolean = - modelSaver.save(model, databaseWrapper) + modelSaver.save(model, databaseWrapper) override fun saveAll(models: Collection, databaseWrapper: DatabaseWrapper): Long - = listModelSaver.saveAll(models, databaseWrapper) + = listModelSaver.saveAll(models, databaseWrapper) override fun insert(model: T, databaseWrapper: DatabaseWrapper): Long = - modelSaver.insert(model, databaseWrapper) + modelSaver.insert(model, databaseWrapper) override fun insertAll(models: Collection, databaseWrapper: DatabaseWrapper): Long - = listModelSaver.insertAll(models, databaseWrapper) + = listModelSaver.insertAll(models, databaseWrapper) override fun update(model: T, databaseWrapper: DatabaseWrapper): Boolean = - modelSaver.update(model, databaseWrapper) + modelSaver.update(model, databaseWrapper) override fun updateAll(models: Collection, databaseWrapper: DatabaseWrapper): Long - = listModelSaver.updateAll(models, databaseWrapper) + = listModelSaver.updateAll(models, databaseWrapper) override fun delete(model: T, databaseWrapper: DatabaseWrapper): Boolean = - modelSaver.delete(model, databaseWrapper) + modelSaver.delete(model, databaseWrapper) override fun deleteAll(models: Collection, databaseWrapper: DatabaseWrapper): Long - = listModelSaver.deleteAll(models, databaseWrapper) + = listModelSaver.deleteAll(models, databaseWrapper) override fun bindToInsertStatement(sqLiteStatement: DatabaseStatement, model: T) { bindToInsertStatement(sqLiteStatement, model, 0) @@ -211,7 +197,7 @@ abstract class ModelAdapter(databaseDefinition: DatabaseDefinition) * if it has the field. This method is overridden when its specified for the [T] */ override fun getAutoIncrementingId(model: T): Number? { - throwCachingError() + throw RuntimeException("Table $modelClass does not have an auto-incrementing id.") } fun hasAutoIncrement(model: T): Boolean { @@ -236,70 +222,7 @@ abstract class ModelAdapter(databaseDefinition: DatabaseDefinition) } - /** - * @return A set of columns that represent the caching columns. - */ - open fun createCachingColumns(): Array = arrayOf(autoIncrementingColumnName) - - /** - * Loads all primary keys from the [FlowCursor] into the inValues. The size of the array must - * match all primary keys. This method gets generated when caching is enabled. - * - * @param inValues The reusable array of values to populate. - * @param cursor The cursor to load from. - * @return The populated set of values to load from cache. - */ - open fun getCachingColumnValuesFromCursor(inValues: Array, - cursor: FlowCursor): Array? { - throwCachingError() - } - - /** - * @param cursor The cursor to load caching id from. - * @return The single cache column from cursor (if single). - */ - open fun getCachingColumnValueFromCursor(cursor: FlowCursor): Any? { - throwCachingError() - } - - /** - * Loads all primary keys from the [TModel] into the inValues. The size of the array must - * match all primary keys. This method gets generated when caching is enabled. It converts the primary fields - * of the [TModel] into the array of values the caching mechanism uses. - * - * @param inValues The reusable array of values to populate. - * @param TModel The model to load from. - * @return The populated set of values to load from cache. - */ - open fun getCachingColumnValuesFromModel(inValues: Array, TModel: T): Array? { - throwCachingError() - } - - /** - * @param model The model to load cache column data from. - * @return The single cache column from model (if single). - */ - open fun getCachingColumnValueFromModel(model: T): Any? { - throwCachingError() - } - - fun storeModelInCache(model: T) { - modelCache.addModel(getCachingId(model), model) - } - - fun removeModelFromCache(model: T) { - getCachingId(model)?.let { modelCache.removeModel(it) } - } - - fun getCachingId(inValues: Array?): Any? = when { - inValues?.size == 1 -> // if it exists in cache no matter the query we will use that one - inValues.getOrNull(0) - inValues != null -> cacheConverter.getCachingKey(inValues) - else -> null - } - - open fun getCachingId(model: T): Any? = - getCachingId(getCachingColumnValuesFromModel(arrayOfNulls(cachingColumns.size), model)) + override fun cachingEnabled(): Boolean = false var modelSaver: ModelSaver get() { @@ -317,22 +240,6 @@ abstract class ModelAdapter(databaseDefinition: DatabaseDefinition) protected open fun createListModelSaver(): ListModelSaver = ListModelSaver(modelSaver) - /** - * Reloads relationships when loading from [FlowCursor] in a model that's cacheable. By having - * relationships with cached models, the retrieval will be very fast. - * - * @param cursor The cursor to reload from. - */ - open fun reloadRelationships(model: T, cursor: FlowCursor, databaseWrapper: DatabaseWrapper) { - if (!cachingEnabled()) { - throwCachingError() - } - } - - override fun cachingEnabled(): Boolean = false - - open fun createModelCache(): ModelCache = SimpleMapCache(cacheSize) - /** * Retrieves a property by name from the table via the corresponding generated "_Table" class. Useful * when you want to dynamically get a property from an [ModelAdapter] and do an operation on it. @@ -348,9 +255,4 @@ abstract class ModelAdapter(databaseDefinition: DatabaseDefinition) */ open fun createWithDatabase(): Boolean = true - private fun throwCachingError(): Nothing = throw InvalidDBConfiguration("This method may have been called in error. " + - "The model class $modelClass must contain an auto-incrementing " + - "or at least one primary key (if used in a ModelCache, " + - "this method may be called)") - } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/CacheableListModelLoader.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/CacheableListModelLoader.kt index d1a6433e8..93b1b196b 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/CacheableListModelLoader.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/CacheableListModelLoader.kt @@ -1,5 +1,6 @@ package com.raizlabs.dbflow5.adapter.queriable +import com.raizlabs.dbflow5.adapter.CacheAdapter import com.raizlabs.dbflow5.adapter.ModelAdapter import com.raizlabs.dbflow5.annotation.Table import com.raizlabs.dbflow5.database.DatabaseWrapper @@ -10,7 +11,8 @@ import com.raizlabs.dbflow5.query.cache.addOrReload /** * Description: Loads a [List] of [T] with [Table.cachingEnabled] true. */ -open class CacheableListModelLoader(modelClass: Class) +open class CacheableListModelLoader(modelClass: Class, + protected val cacheAdapter: CacheAdapter) : ListModelLoader(modelClass) { val modelAdapter: ModelAdapter by lazy { @@ -24,18 +26,18 @@ open class CacheableListModelLoader(modelClass: Class) return@lazy modelAdapter } - val modelCache: ModelCache by lazy { modelAdapter.modelCache } + val modelCache: ModelCache by lazy { cacheAdapter.modelCache } override fun convertToData(cursor: FlowCursor, data: MutableList?, databaseWrapper: DatabaseWrapper): MutableList { val _data = data ?: arrayListOf() - val cacheValues = arrayOfNulls(modelAdapter.cachingColumns.size) + val cacheValues = arrayOfNulls(cacheAdapter.cachingColumns.size) // Ensure that we aren't iterating over this cursor concurrently from different threads if (cursor.moveToFirst()) { do { - val values = modelAdapter.getCachingColumnValuesFromCursor(cacheValues, cursor) - val model = modelCache.addOrReload(modelAdapter.getCachingId(values), - modelAdapter, cursor, databaseWrapper) + val values = cacheAdapter.getCachingColumnValuesFromCursor(cacheValues, cursor) + val model = modelCache.addOrReload(cacheAdapter.getCachingId(values), + cacheAdapter, modelAdapter, cursor, databaseWrapper) _data.add(model) } while (cursor.moveToNext()) } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/CacheableModelLoader.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/CacheableModelLoader.kt index 96d00ea92..a5f9be95b 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/CacheableModelLoader.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/CacheableModelLoader.kt @@ -1,5 +1,6 @@ package com.raizlabs.dbflow5.adapter.queriable +import com.raizlabs.dbflow5.adapter.CacheAdapter import com.raizlabs.dbflow5.adapter.ModelAdapter import com.raizlabs.dbflow5.annotation.Table import com.raizlabs.dbflow5.database.DatabaseWrapper @@ -11,7 +12,8 @@ import com.raizlabs.dbflow5.query.cache.addOrReload * Description: Loads model data that is backed by a [ModelCache]. Used when [Table.cachingEnabled] * is true. */ -open class CacheableModelLoader(modelClass: Class) +open class CacheableModelLoader(modelClass: Class, + protected val cacheAdapter: CacheAdapter) : SingleModelLoader(modelClass) { val modelAdapter: ModelAdapter by lazy { @@ -29,7 +31,7 @@ open class CacheableModelLoader(modelClass: Class) } } - val modelCache: ModelCache by lazy { modelAdapter.modelCache } + val modelCache: ModelCache by lazy { cacheAdapter.modelCache } /** * Converts data by loading from cache based on its sequence of caching ids. Will reuse the passed @@ -40,9 +42,9 @@ open class CacheableModelLoader(modelClass: Class) override fun convertToData(cursor: FlowCursor, data: T?, moveToFirst: Boolean, databaseWrapper: DatabaseWrapper): T? { return if (!moveToFirst || cursor.moveToFirst()) { - val values = modelAdapter.getCachingColumnValuesFromCursor( - arrayOfNulls(modelAdapter.cachingColumns.size), cursor) - modelCache.addOrReload(modelAdapter.getCachingId(values), modelAdapter, + val values = cacheAdapter.getCachingColumnValuesFromCursor( + arrayOfNulls(cacheAdapter.cachingColumns.size), cursor) + modelCache.addOrReload(cacheAdapter.getCachingId(values), cacheAdapter, modelAdapter, cursor, databaseWrapper, data) } else null } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/SingleKeyCacheableListModelLoader.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/SingleKeyCacheableListModelLoader.kt index 8a32e8dca..a3f7e5465 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/SingleKeyCacheableListModelLoader.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/SingleKeyCacheableListModelLoader.kt @@ -1,5 +1,6 @@ package com.raizlabs.dbflow5.adapter.queriable +import com.raizlabs.dbflow5.adapter.CacheAdapter import com.raizlabs.dbflow5.database.DatabaseWrapper import com.raizlabs.dbflow5.database.FlowCursor import com.raizlabs.dbflow5.query.cache.addOrReload @@ -7,8 +8,9 @@ import com.raizlabs.dbflow5.query.cache.addOrReload /** * Description: */ -class SingleKeyCacheableListModelLoader(tModelClass: Class) - : CacheableListModelLoader(tModelClass) { +class SingleKeyCacheableListModelLoader(tModelClass: Class, + cacheAdapter: CacheAdapter) + : CacheableListModelLoader(tModelClass, cacheAdapter) { override fun convertToData(cursor: FlowCursor, data: MutableList?, databaseWrapper: DatabaseWrapper): MutableList { @@ -17,8 +19,8 @@ class SingleKeyCacheableListModelLoader(tModelClass: Class) // Ensure that we aren't iterating over this cursor concurrently from different threads if (cursor.moveToFirst()) { do { - cacheValue = modelAdapter.getCachingColumnValueFromCursor(cursor) - val model = modelCache.addOrReload(cacheValue, modelAdapter, cursor, databaseWrapper) + cacheValue = cacheAdapter.getCachingColumnValueFromCursor(cursor) + val model = modelCache.addOrReload(cacheValue, cacheAdapter, modelAdapter, cursor, databaseWrapper) _data.add(model) } while (cursor.moveToNext()) } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/SingleKeyCacheableModelLoader.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/SingleKeyCacheableModelLoader.kt index 898f27583..831a2f370 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/SingleKeyCacheableModelLoader.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/SingleKeyCacheableModelLoader.kt @@ -1,5 +1,6 @@ package com.raizlabs.dbflow5.adapter.queriable +import com.raizlabs.dbflow5.adapter.CacheAdapter import com.raizlabs.dbflow5.database.DatabaseWrapper import com.raizlabs.dbflow5.database.FlowCursor import com.raizlabs.dbflow5.query.cache.addOrReload @@ -9,8 +10,9 @@ import com.raizlabs.dbflow5.structure.Model * Description: More optimized version of [CacheableModelLoader] which assumes that the [Model] * only utilizes a single primary key. */ -class SingleKeyCacheableModelLoader(modelClass: Class) - : CacheableModelLoader(modelClass) { +class SingleKeyCacheableModelLoader(modelClass: Class, + cacheAdapter: CacheAdapter) + : CacheableModelLoader(modelClass, cacheAdapter) { /** * Converts data by loading from cache based on its sequence of caching ids. Will reuse the passed @@ -22,9 +24,8 @@ class SingleKeyCacheableModelLoader(modelClass: Class) moveToFirst: Boolean, databaseWrapper: DatabaseWrapper): T? { return if (!moveToFirst || cursor.moveToFirst()) { - val value = modelAdapter.getCachingColumnValueFromCursor(cursor) - modelCache.addOrReload(value, modelAdapter, - cursor, databaseWrapper, data) + val value = cacheAdapter.getCachingColumnValueFromCursor(cursor) + modelCache.addOrReload(value, cacheAdapter, modelAdapter, cursor, databaseWrapper, data) } else null } } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/saveable/CacheableListModelSaver.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/saveable/CacheableListModelSaver.kt index b7d000fb9..b7a801728 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/saveable/CacheableListModelSaver.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/saveable/CacheableListModelSaver.kt @@ -1,18 +1,21 @@ package com.raizlabs.dbflow5.adapter.saveable +import com.raizlabs.dbflow5.adapter.CacheAdapter import com.raizlabs.dbflow5.database.DatabaseStatement import com.raizlabs.dbflow5.database.DatabaseWrapper /** * Description: Used for model caching, enables caching models when saving in list. */ -class CacheableListModelSaver(modelSaver: ModelSaver) : ListModelSaver(modelSaver) { +class CacheableListModelSaver(modelSaver: ModelSaver, + private val cacheAdapter: CacheAdapter) + : ListModelSaver(modelSaver) { @Synchronized override fun saveAll(tableCollection: Collection, wrapper: DatabaseWrapper): Long { val statement = modelAdapter.getInsertStatement(wrapper) val updateStatement = modelAdapter.getUpdateStatement(wrapper) - return applyAndCount(tableCollection, statement, updateStatement, modelAdapter::storeModelInCache) { + return applyAndCount(tableCollection, statement, updateStatement, cacheAdapter::storeModelInCache) { modelSaver.save(it, statement, updateStatement, wrapper) } } @@ -21,7 +24,7 @@ class CacheableListModelSaver(modelSaver: ModelSaver) : ListModelSav wrapper: DatabaseWrapper): Long { val statement = modelAdapter.getInsertStatement(wrapper) return applyAndCount(tableCollection, statement, - cacheFn = modelAdapter::storeModelInCache) { + cacheFn = cacheAdapter::storeModelInCache) { modelSaver.insert(it, statement, wrapper) > 0 } } @@ -30,7 +33,7 @@ class CacheableListModelSaver(modelSaver: ModelSaver) : ListModelSav wrapper: DatabaseWrapper): Long { val statement = modelAdapter.getUpdateStatement(wrapper) return applyAndCount(tableCollection, statement, - cacheFn = modelAdapter::storeModelInCache) { + cacheFn = cacheAdapter::storeModelInCache) { modelSaver.update(it, statement, wrapper) } } @@ -39,7 +42,7 @@ class CacheableListModelSaver(modelSaver: ModelSaver) : ListModelSav wrapper: DatabaseWrapper): Long { val statement = modelAdapter.getDeleteStatement(wrapper) return applyAndCount(tableCollection, statement, - cacheFn = modelAdapter::removeModelFromCache) { + cacheFn = cacheAdapter::removeModelFromCache) { modelSaver.delete(it, statement, wrapper) } } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/cache/ModelCache.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/cache/ModelCache.kt index f6f0635e0..610f4f615 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/cache/ModelCache.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/cache/ModelCache.kt @@ -1,5 +1,6 @@ package com.raizlabs.dbflow5.query.cache +import com.raizlabs.dbflow5.adapter.CacheAdapter import com.raizlabs.dbflow5.adapter.ModelAdapter import com.raizlabs.dbflow5.database.DatabaseWrapper import com.raizlabs.dbflow5.database.FlowCursor @@ -55,13 +56,14 @@ abstract class ModelCache @Suppress("NOTHING_TO_INLINE") inline fun ModelCache.addOrReload(cacheValue: Any?, + cacheAdapter: CacheAdapter, modelAdapter: ModelAdapter, cursor: FlowCursor, databaseWrapper: DatabaseWrapper, data: T? = null): T { var model: T? = get(cacheValue) if (model != null) { - modelAdapter.reloadRelationships(model, cursor, databaseWrapper) + cacheAdapter.reloadRelationships(model, cursor, databaseWrapper) } else { model = data ?: modelAdapter.newInstance() modelAdapter.loadFromCursor(cursor, model, databaseWrapper) From 2190a619136c45791cb5d4c608d88fbe42929b4c Mon Sep 17 00:00:00 2001 From: fuzzagrosner Date: Mon, 4 Dec 2017 10:12:47 -0500 Subject: [PATCH 114/234] [caching] remove need for creating caching columns array. instead just return size. --- .../dbflow5/processor/definition/TableDefinition.kt | 8 +++----- .../com/raizlabs/dbflow5/adapter/CacheAdapter.kt | 13 +++++-------- .../adapter/queriable/CacheableListModelLoader.kt | 2 +- .../adapter/queriable/CacheableModelLoader.kt | 2 +- 4 files changed, 10 insertions(+), 15 deletions(-) diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/TableDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/TableDefinition.kt index 34414e97d..6b7261c2e 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/TableDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/TableDefinition.kt @@ -48,10 +48,8 @@ import com.raizlabs.dbflow5.processor.utils.ensureVisibleStatic import com.raizlabs.dbflow5.processor.utils.implementsClass import com.raizlabs.dbflow5.processor.utils.isNullOrEmpty import com.raizlabs.dbflow5.quote -import com.raizlabs.dbflow5.quoteIfNeeded import com.raizlabs.dbflow5.stripQuotes import com.squareup.javapoet.ArrayTypeName -import com.squareup.javapoet.ClassName import com.squareup.javapoet.CodeBlock import com.squareup.javapoet.NameAllocator import com.squareup.javapoet.ParameterizedTypeName @@ -516,7 +514,7 @@ class TableDefinition(manager: ProcessorManager, element: TypeElement) : BaseTab `private final field`(ClassNames.CACHE_ADAPTER, "cacheAdapter") { `=` { addStatement("\$L", - TypeSpec.anonymousClassBuilder("this") + TypeSpec.anonymousClassBuilder("") .addSuperinterface(ParameterizedTypeName.get(ClassNames.CACHE_ADAPTER, elementTypeName)) .apply { val primaryColumns = primaryColumnDefinitions @@ -566,9 +564,9 @@ class TableDefinition(manager: ProcessorManager, element: TypeElement) : BaseTab } - `override fun`(ArrayTypeName.of(ClassName.get(String::class.java)), "createCachingColumns") { + `override fun`(TypeName.INT, "getCachingColumnSize") { modifiers(public, final) - `return`("new String[]{${primaryColumns.joinToString { it.columnName.quoteIfNeeded().S }}}") + `return`(primaryColumns.size.L) } if (cacheSize != DEFAULT_CACHE_SIZE) { diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/CacheAdapter.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/CacheAdapter.kt index 335df901e..bc9880558 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/CacheAdapter.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/CacheAdapter.kt @@ -11,14 +11,16 @@ import com.raizlabs.dbflow5.structure.InvalidDBConfiguration /** * Description: */ -abstract class CacheAdapter(private val modelAdapter: ModelAdapter) { +abstract class CacheAdapter { val modelCache: ModelCache by lazy { createModelCache() } - val cachingColumns: Array by lazy { createCachingColumns() } open val cacheSize: Int get() = DEFAULT_CACHE_SIZE + open val cachingColumnSize: Int + get() = 1 + open val cacheConverter: IMultiKeyCacheConverter<*> get() = throw InvalidDBConfiguration("For multiple primary keys, a public static IMultiKeyCacheConverter field must" + "be marked with @MultiCacheField in the corresponding model class. The resulting key" + @@ -37,11 +39,6 @@ abstract class CacheAdapter(private val modelAdapter: ModelAdapter) open fun getCachingColumnValueFromModel(model: T): Any? = Unit - /** - * @return A set of columns that represent the caching columns. - */ - open fun createCachingColumns(): Array = arrayOf(modelAdapter.autoIncrementingColumnName) - /** * Loads all primary keys from the [FlowCursor] into the inValues. The size of the array must * match all primary keys. This method gets generated when caching is enabled. @@ -79,7 +76,7 @@ abstract class CacheAdapter(private val modelAdapter: ModelAdapter) } open fun getCachingId(model: T): Any? = - getCachingId(getCachingColumnValuesFromModel(arrayOfNulls(cachingColumns.size), model)) + getCachingId(getCachingColumnValuesFromModel(arrayOfNulls(cachingColumnSize), model)) open fun createModelCache(): ModelCache = SimpleMapCache(cacheSize) diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/CacheableListModelLoader.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/CacheableListModelLoader.kt index 93b1b196b..549d583df 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/CacheableListModelLoader.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/CacheableListModelLoader.kt @@ -31,7 +31,7 @@ open class CacheableListModelLoader(modelClass: Class, override fun convertToData(cursor: FlowCursor, data: MutableList?, databaseWrapper: DatabaseWrapper): MutableList { val _data = data ?: arrayListOf() - val cacheValues = arrayOfNulls(cacheAdapter.cachingColumns.size) + val cacheValues = arrayOfNulls(cacheAdapter.cachingColumnSize) // Ensure that we aren't iterating over this cursor concurrently from different threads if (cursor.moveToFirst()) { do { diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/CacheableModelLoader.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/CacheableModelLoader.kt index a5f9be95b..5b0f23d6f 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/CacheableModelLoader.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/CacheableModelLoader.kt @@ -43,7 +43,7 @@ open class CacheableModelLoader(modelClass: Class, databaseWrapper: DatabaseWrapper): T? { return if (!moveToFirst || cursor.moveToFirst()) { val values = cacheAdapter.getCachingColumnValuesFromCursor( - arrayOfNulls(cacheAdapter.cachingColumns.size), cursor) + arrayOfNulls(cacheAdapter.cachingColumnSize), cursor) modelCache.addOrReload(cacheAdapter.getCachingId(values), cacheAdapter, modelAdapter, cursor, databaseWrapper, data) } else null From 742cc949711d137c8fc4913dcf8a27e6a6a0c0ae Mon Sep 17 00:00:00 2001 From: fuzzagrosner Date: Mon, 4 Dec 2017 10:41:05 -0500 Subject: [PATCH 115/234] [model] rename getModelClass to getTable. Dont generate ContentValues for every table automatically anymore to cut down on generated code. Explicitly enable it via generateContentValues. --- .../com/raizlabs/dbflow5/annotation/Table.kt | 155 +++++++++--------- .../definition/BaseTableDefinition.kt | 14 +- .../processor/definition/TableDefinition.kt | 19 ++- .../provider/ContentProviderObjects.kt | 8 +- .../raizlabs/dbflow5/adapter/ModelAdapter.kt | 9 +- .../dbflow5/adapter/RetrievalAdapter.kt | 16 +- .../dbflow5/config/DatabaseDefinition.kt | 14 +- .../dbflow5/query/BaseModelQueriable.kt | 2 +- .../runtime/ContentResolverNotifier.kt | 2 +- .../dbflow5/runtime/DirectModelNotifier.kt | 2 +- .../dbflow5/runtime/NotifyDistributor.kt | 2 +- 11 files changed, 131 insertions(+), 112 deletions(-) diff --git a/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/Table.kt b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/Table.kt index 4bf540a44..7ba79a964 100644 --- a/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/Table.kt +++ b/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/Table.kt @@ -13,78 +13,83 @@ val DEFAULT_CACHE_SIZE = 25 @Retention(AnnotationRetention.SOURCE) @Target(AnnotationTarget.CLASS, AnnotationTarget.FILE) annotation class Table( - /** - * @return Specifies a different name for the table than the name of the Model class. - */ - val name: String = "", - /** - * @return Specify the database class that this table belongs to. It must have the [Database] annotation. - */ - val database: KClass<*>, - /** - * @return Specify the general conflict algorithm used by this table when updating records. - */ - val updateConflict: ConflictAction = ConflictAction.NONE, - /** - * @return Specify the general insert conflict algorithm used by this table. - */ - val insertConflict: ConflictAction = ConflictAction.NONE, - /** - * @return An optional [ConflictAction] that we append to creation for conflict handling in PK. - */ - val primaryKeyConflict: ConflictAction = ConflictAction.NONE, - /** - * @return When true, all public, package-private , non-static, and non-final fields of the reference class are considered as [com.raizlabs.android.dbflow.annotation.Column] . - * The only required annotated field becomes The [PrimaryKey] - * or [PrimaryKey.autoincrement]. - */ - val allFields: Boolean = false, - /** - * @return If true, all private boolean fields will use "is" instead of "get" for its getter and - * "set" without the "is" if it starts with "is" - */ - val useBooleanGetterSetters: Boolean = true, - /** - * @return If true, caching mechanism is enabled. This works for single primary key tables. For - * multi-primary key tables, IMultiKeyCacheModel interface is required to specify the caching key. - */ - val cachingEnabled: Boolean = false, - /** - * @return If true, we throw away checks for column indexing and simply assume that the cursor returns - * all our columns in order. This may provide a slight performance boost. - */ - val orderedCursorLookUp: Boolean = false, - /** - * @return When true, we reassign the corresponding Model's fields to default values when loading - * from cursor. If false, we assign values only if present in Cursor. - */ - val assignDefaultValuesFromCursor: Boolean = true, - /** - * @return When false, this table gets generated and associated with database, however it will not immediately - * get created upon startup. This is useful for keeping around legacy tables for migrations. - */ - val createWithDatabase: Boolean = true, - /** - * @return The cache size for this Table. - */ - val cacheSize: Int = 25, - /** - * @return Declares a set of UNIQUE columns with the corresponding [ConflictAction]. A [Column] - * will point to this group using [Unique.uniqueGroups] - */ - val uniqueColumnGroups: Array = arrayOf(), - /** - * @return The set of INDEX clauses that specific columns can define to belong to, using the [Index] annotation. - * The generated Index properties belong to the corresponding property class to this table. - */ - val indexGroups: Array = arrayOf(), - /** - * @return A set of inherited accessible fields not necessarily defined as columns in the super class of this table. - * Each must be accessible via: public, package private, or protected or getter/setters. - */ - val inheritedColumns: Array = arrayOf(), - /** - * @return A set of inherited accessible fields not necessarily defined as columns in the super class of this table. - * Each must be accessible via: public, package private, or protected or getter/setters. - */ - val inheritedPrimaryKeys: Array = arrayOf()) + /** + * @return Specifies a different name for the table than the name of the Model class. + */ + val name: String = "", + /** + * @return Specify the database class that this table belongs to. It must have the [Database] annotation. + */ + val database: KClass<*>, + /** + * @return Specify the general conflict algorithm used by this table when updating records. + */ + val updateConflict: ConflictAction = ConflictAction.NONE, + /** + * @return Specify the general insert conflict algorithm used by this table. + */ + val insertConflict: ConflictAction = ConflictAction.NONE, + /** + * @return An optional [ConflictAction] that we append to creation for conflict handling in PK. + */ + val primaryKeyConflict: ConflictAction = ConflictAction.NONE, + /** + * @return When true, all public, package-private , non-static, and non-final fields of the reference class are considered as [com.raizlabs.android.dbflow.annotation.Column] . + * The only required annotated field becomes The [PrimaryKey] + * or [PrimaryKey.autoincrement]. + */ + val allFields: Boolean = false, + /** + * @return If true, all private boolean fields will use "is" instead of "get" for its getter and + * "set" without the "is" if it starts with "is" + */ + val useBooleanGetterSetters: Boolean = true, + /** + * @return If true, caching mechanism is enabled. This works for single primary key tables. For + * multi-primary key tables, IMultiKeyCacheModel interface is required to specify the caching key. + */ + val cachingEnabled: Boolean = false, + /** + * @return If true, we throw away checks for column indexing and simply assume that the cursor returns + * all our columns in order. This may provide a slight performance boost. + */ + val orderedCursorLookUp: Boolean = false, + /** + * @return When true, we reassign the corresponding Model's fields to default values when loading + * from cursor. If false, we assign values only if present in Cursor. + */ + val assignDefaultValuesFromCursor: Boolean = true, + /** + * @return When false, this table gets generated and associated with database, however it will not immediately + * get created upon startup. This is useful for keeping around legacy tables for migrations. + */ + val createWithDatabase: Boolean = true, + + /** + * If true, generates ContentValues bindings for a table. By default it no longer does. + */ + val generateContentValues: Boolean = false, + /** + * @return The cache size for this Table. + */ + val cacheSize: Int = 25, + /** + * @return Declares a set of UNIQUE columns with the corresponding [ConflictAction]. A [Column] + * will point to this group using [Unique.uniqueGroups] + */ + val uniqueColumnGroups: Array = arrayOf(), + /** + * @return The set of INDEX clauses that specific columns can define to belong to, using the [Index] annotation. + * The generated Index properties belong to the corresponding property class to this table. + */ + val indexGroups: Array = arrayOf(), + /** + * @return A set of inherited accessible fields not necessarily defined as columns in the super class of this table. + * Each must be accessible via: public, package private, or protected or getter/setters. + */ + val inheritedColumns: Array = arrayOf(), + /** + * @return A set of inherited accessible fields not necessarily defined as columns in the super class of this table. + * Each must be accessible via: public, package private, or protected or getter/setters. + */ + val inheritedPrimaryKeys: Array = arrayOf()) diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/BaseTableDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/BaseTableDefinition.kt index a38a485f3..1065a0d46 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/BaseTableDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/BaseTableDefinition.kt @@ -107,7 +107,7 @@ abstract class BaseTableDefinition(typeElement: Element, processorManager: Proce } fun writeGetModelClass(typeBuilder: TypeSpec.Builder, modelClassName: ClassName?) = typeBuilder.apply { - `override fun`(ParameterizedTypeName.get(ClassName.get(Class::class.java), modelClassName), "getModelClass") { + `override fun`(ParameterizedTypeName.get(ClassName.get(Class::class.java), modelClassName), "getTable") { modifiers(public, final) `return`("\$T.class", modelClassName) } @@ -120,7 +120,7 @@ abstract class BaseTableDefinition(typeElement: Element, processorManager: Proce if (!packagePrivateList.isEmpty()) { val classSeparator = databaseDefinition?.classSeparator val typeBuilder = TypeSpec.classBuilder("${elementClassName?.simpleName()}${classSeparator}Helper") - .addModifiers(Modifier.PUBLIC, Modifier.FINAL) + .addModifiers(Modifier.PUBLIC, Modifier.FINAL) for (columnDefinition in packagePrivateList) { var helperClassName = "${columnDefinition.element.getPackage()}.${columnDefinition.element.enclosingElement.toClassName()?.simpleName()}${classSeparator}Helper" @@ -138,7 +138,7 @@ abstract class BaseTableDefinition(typeElement: Element, processorManager: Proce val methodName = columnDefinition.columnName.capitalize() `public static final`(columnDefinition.elementTypeName!!, "get$methodName", - param(elementTypeName!!, ModelUtils.variable)) { + param(elementTypeName!!, ModelUtils.variable)) { if (samePackage) { `return`("${ModelUtils.variable}.${columnDefinition.elementName}") } else { @@ -147,8 +147,8 @@ abstract class BaseTableDefinition(typeElement: Element, processorManager: Proce } `public static final`(TypeName.VOID, "set$methodName", - param(elementTypeName!!, ModelUtils.variable), - param(columnDefinition.elementTypeName!!, "var")) { + param(elementTypeName!!, ModelUtils.variable), + param(columnDefinition.elementTypeName!!, "var")) { if (samePackage) { statement("${ModelUtils.variable}.${columnDefinition.elementName} = var") } else { @@ -174,8 +174,8 @@ abstract class BaseTableDefinition(typeElement: Element, processorManager: Proce internal fun checkInheritancePackagePrivate(isPackagePrivateNotInSamePackage: Boolean, element: Element): Boolean { if (isPackagePrivateNotInSamePackage && !manager.elementBelongsInTable(element)) { manager.logError("Package private inheritance on non-table/querymodel/view " + - "is not supported without a @InheritedColumn annotation." + - " Make $element from ${element.enclosingElement} public or private.") + "is not supported without a @InheritedColumn annotation." + + " Make $element from ${element.enclosingElement} public or private.") return true } return false diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/TableDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/TableDefinition.kt index 6b7261c2e..67a126b29 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/TableDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/TableDefinition.kt @@ -87,6 +87,7 @@ class TableDefinition(manager: ProcessorManager, element: TypeElement) : BaseTab var implementsLoadFromCursorListener = false private val methods: Array + private val contentValueMethods: Array var cachingEnabled = false var cacheSize: Int = 0 @@ -97,6 +98,7 @@ class TableDefinition(manager: ProcessorManager, element: TypeElement) : BaseTab var allFields = false var useIsForPrivateBooleans: Boolean = false + var generateContentValues = false val columnMap = mutableMapOf() @@ -125,6 +127,7 @@ class TableDefinition(manager: ProcessorManager, element: TypeElement) : BaseTab databaseTypeName = TypeName.get(mte.typeMirror) } + generateContentValues = table.generateContentValues cachingEnabled = table.cachingEnabled cacheSize = table.cacheSize @@ -169,8 +172,10 @@ class TableDefinition(manager: ProcessorManager, element: TypeElement) : BaseTab ClassNames.SQLITE_STATEMENT_LISTENER) } - methods = arrayOf(BindToContentValuesMethod(this, true, implementsContentValuesListener), - BindToContentValuesMethod(this, false, implementsContentValuesListener), + contentValueMethods = arrayOf(BindToContentValuesMethod(this, true, implementsContentValuesListener), + BindToContentValuesMethod(this, false, implementsContentValuesListener)) + + methods = arrayOf( BindToStatementMethod(this, INSERT), BindToStatementMethod(this, NON_INSERT), BindToStatementMethod(this, UPDATE), BindToStatementMethod(this, DELETE), InsertStatementQueryMethod(this, true), InsertStatementQueryMethod(this, false), @@ -513,7 +518,7 @@ class TableDefinition(manager: ProcessorManager, element: TypeElement) : BaseTab if (cachingEnabled) { `private final field`(ClassNames.CACHE_ADAPTER, "cacheAdapter") { `=` { - addStatement("\$L", + add("\$L", TypeSpec.anonymousClassBuilder("") .addSuperinterface(ParameterizedTypeName.get(ClassNames.CACHE_ADAPTER, elementTypeName)) .apply { @@ -614,7 +619,7 @@ class TableDefinition(manager: ProcessorManager, element: TypeElement) : BaseTab `override fun`(ClassNames.SINGLE_MODEL_LOADER, "createSingleModelLoader") { modifiers(public, final) - addStatement("return new \$T<>(getModelClass(), cacheAdapter)", + addStatement("return new \$T<>(getTable(), cacheAdapter)", if (singlePrimaryKey) ClassNames.SINGLE_KEY_CACHEABLE_MODEL_LOADER else @@ -622,7 +627,7 @@ class TableDefinition(manager: ProcessorManager, element: TypeElement) : BaseTab } `override fun`(ClassNames.LIST_MODEL_LOADER, "createListModelLoader") { modifiers(public, final) - `return`("new \$T<>(getModelClass(), cacheAdapter)", + `return`("new \$T<>(getTable(), cacheAdapter)", if (singlePrimaryKey) ClassNames.SINGLE_KEY_CACHEABLE_LIST_MODEL_LOADER else @@ -650,5 +655,9 @@ class TableDefinition(manager: ProcessorManager, element: TypeElement) : BaseTab methods.mapNotNull { it.methodSpec } .forEach { typeBuilder.addMethod(it) } + if (generateContentValues) { + contentValueMethods.mapNotNull { it.methodSpec } + .forEach { typeBuilder.addMethod(it) } + } } } diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/provider/ContentProviderObjects.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/provider/ContentProviderObjects.kt index d7bf22f60..dfdcebcbf 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/provider/ContentProviderObjects.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/provider/ContentProviderObjects.kt @@ -16,7 +16,7 @@ import com.raizlabs.dbflow5.annotation.provider.TableEndpoint * Description: */ @ContentProvider(authority = ContentDatabase.AUTHORITY, database = ContentDatabase::class, - baseContentUri = ContentDatabase.BASE_CONTENT_URI) + baseContentUri = ContentDatabase.BASE_CONTENT_URI) @Database(version = ContentDatabase.VERSION) object ContentDatabase { @@ -29,7 +29,7 @@ object ContentDatabase { } @TableEndpoint(name = ContentProviderModel.NAME, contentProvider = ContentDatabase::class) -@Table(database = ContentDatabase::class, name = ContentProviderModel.NAME) +@Table(database = ContentDatabase::class, name = ContentProviderModel.NAME, generateContentValues = true) class ContentProviderModel(@PrimaryKey(autoincrement = true) var id: Long = 0, @Column @@ -54,12 +54,12 @@ class ContentProviderModel(@PrimaryKey(autoincrement = true) } } -@Table(database = ContentDatabase::class) +@Table(database = ContentDatabase::class, generateContentValues = true) class NoteModel(@PrimaryKey(autoincrement = true) var id: Long = 0, @ForeignKey(references = arrayOf(ForeignKeyReference(columnName = "providerModel", - foreignKeyColumnName = "id"))) + foreignKeyColumnName = "id"))) var contentProviderModel: ContentProviderModel? = null, @Column diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/ModelAdapter.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/ModelAdapter.kt index 17977fe3e..61533edfd 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/ModelAdapter.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/ModelAdapter.kt @@ -37,7 +37,7 @@ abstract class ModelAdapter(databaseDefinition: DatabaseDefinition) */ open val autoIncrementingColumnName: String get() = throw InvalidDBConfiguration("This method may have been called in error." + - " The model class $modelClass must contain an autoincrementing" + + " The model class $table must contain an autoincrementing" + " or single int/long primary key (if used in a ModelCache, this method may be called)") /** @@ -177,6 +177,11 @@ abstract class ModelAdapter(databaseDefinition: DatabaseDefinition) bindToInsertValues(contentValues, model) } + override fun bindToInsertValues(contentValues: ContentValues, model: T) { + throw RuntimeException("ContentValues are no longer generated automatically. To enable it," + + " set generateContentValues = true in @Table for $table.") + } + override fun bindToStatement(sqLiteStatement: DatabaseStatement, model: T) { bindToInsertStatement(sqLiteStatement, model, 0) } @@ -197,7 +202,7 @@ abstract class ModelAdapter(databaseDefinition: DatabaseDefinition) * if it has the field. This method is overridden when its specified for the [T] */ override fun getAutoIncrementingId(model: T): Number? { - throw RuntimeException("Table $modelClass does not have an auto-incrementing id.") + throw RuntimeException("Table $table does not have an auto-incrementing id.") } fun hasAutoIncrement(model: T): Boolean { diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/RetrievalAdapter.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/RetrievalAdapter.kt index 3a2dd0d0b..6813e60ca 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/RetrievalAdapter.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/RetrievalAdapter.kt @@ -63,27 +63,27 @@ abstract class RetrievalAdapter(databaseDefinition: DatabaseDefinition) /** * @return the model class this adapter corresponds to */ - abstract val modelClass: Class + abstract val table: Class /** * @return A new instance of a [SingleModelLoader]. Subsequent calls do not cache * this object so it's recommended only calling this in bulk if possible. */ val nonCacheableSingleModelLoader: SingleModelLoader - get() = SingleModelLoader(modelClass) + get() = SingleModelLoader(table) /** * @return A new instance of a [ListModelLoader]. Subsequent calls do not cache * this object so it's recommended only calling this in bulk if possible. */ val nonCacheableListModelLoader: ListModelLoader - get() = ListModelLoader(modelClass) + get() = ListModelLoader(table) init { val databaseConfig = FlowManager.getConfig() .getConfigForDatabase(databaseDefinition.associatedDatabaseClassFile) if (databaseConfig != null) { - tableConfig = databaseConfig.getTableConfigForTable(modelClass) + tableConfig = databaseConfig.getTableConfigForTable(table) if (tableConfig != null) { tableConfig?.singleModelLoader?.let { _singleModelLoader = it } tableConfig?.listModelLoader?.let { _listModelLoader = it } @@ -97,7 +97,7 @@ abstract class RetrievalAdapter(databaseDefinition: DatabaseDefinition) open fun load(model: T, databaseWrapper: DatabaseWrapper) { nonCacheableSingleModelLoader.load(databaseWrapper, (databaseWrapper.select - from modelClass + from table where getPrimaryConditionClause(model)).query, model) } @@ -115,7 +115,7 @@ abstract class RetrievalAdapter(databaseDefinition: DatabaseDefinition) * @return True if it exists as a row in the corresponding database table */ open fun exists(model: T): Boolean = - exists(model, FlowManager.getDatabaseForTable(modelClass).writableDatabase) + exists(model, FlowManager.getDatabaseForTable(table).writableDatabase) /** * @param model The model to query values from @@ -132,12 +132,12 @@ abstract class RetrievalAdapter(databaseDefinition: DatabaseDefinition) /** * @return A new [ListModelLoader], caching will override this loader instance. */ - protected open fun createListModelLoader(): ListModelLoader = ListModelLoader(modelClass) + protected open fun createListModelLoader(): ListModelLoader = ListModelLoader(table) /** * @return A new [SingleModelLoader], caching will override this loader instance. */ - protected open fun createSingleModelLoader(): SingleModelLoader = SingleModelLoader(modelClass) + protected open fun createSingleModelLoader(): SingleModelLoader = SingleModelLoader(table) } /** diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseDefinition.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseDefinition.kt index 4cc1b5b5a..d098534df 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseDefinition.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseDefinition.kt @@ -189,19 +189,19 @@ abstract class DatabaseDefinition : DatabaseWrapper { } protected fun addModelAdapter(modelAdapter: ModelAdapter, holder: DatabaseHolder) { - holder.putDatabaseForTable(modelAdapter.modelClass, this) - modelTableNames.put(modelAdapter.tableName, modelAdapter.modelClass) - modelAdapters.put(modelAdapter.modelClass, modelAdapter) + holder.putDatabaseForTable(modelAdapter.table, this) + modelTableNames.put(modelAdapter.tableName, modelAdapter.table) + modelAdapters.put(modelAdapter.table, modelAdapter) } protected fun addModelViewAdapter(modelViewAdapter: ModelViewAdapter, holder: DatabaseHolder) { - holder.putDatabaseForTable(modelViewAdapter.modelClass, this) - modelViewAdapterMap.put(modelViewAdapter.modelClass, modelViewAdapter) + holder.putDatabaseForTable(modelViewAdapter.table, this) + modelViewAdapterMap.put(modelViewAdapter.table, modelViewAdapter) } protected fun addQueryModelAdapter(queryModelAdapter: QueryModelAdapter, holder: DatabaseHolder) { - holder.putDatabaseForTable(queryModelAdapter.modelClass, this) - queryModelAdapterMap.put(queryModelAdapter.modelClass, queryModelAdapter) + holder.putDatabaseForTable(queryModelAdapter.table, this) + queryModelAdapterMap.put(queryModelAdapter.table, queryModelAdapter) } protected fun addMigration(version: Int, migration: Migration) { diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseModelQueriable.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseModelQueriable.kt index 91920b49f..c03281369 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseModelQueriable.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseModelQueriable.kt @@ -33,7 +33,7 @@ protected constructor(val databaseWrapper: DatabaseWrapper, private val singleModelLoader: SingleModelLoader get() = retrievalAdapter.singleModelLoader - override fun queryResults(): CursorResult = CursorResult(retrievalAdapter.modelClass, query(), databaseWrapper) + override fun queryResults(): CursorResult = CursorResult(retrievalAdapter.table, query(), databaseWrapper) override fun queryList(): MutableList { val query = query diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/ContentResolverNotifier.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/ContentResolverNotifier.kt index cb68f6abb..4784c4000 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/ContentResolverNotifier.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/ContentResolverNotifier.kt @@ -21,7 +21,7 @@ class ContentResolverNotifier(val authority: String) : ModelNotifier { if (FlowContentObserver.shouldNotify()) { FlowManager.context.contentResolver .notifyChange(getNotificationUri(authority, - adapter.modelClass, action, + adapter.table, action, adapter.getPrimaryConditionClause(model).conditions), null, true) } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/DirectModelNotifier.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/DirectModelNotifier.kt index 9e75a1d8e..c5dc82ab7 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/DirectModelNotifier.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/DirectModelNotifier.kt @@ -39,7 +39,7 @@ private constructor() : ModelNotifier { @Suppress("UNCHECKED_CAST") override fun notifyModelChanged(model: T, adapter: ModelAdapter, action: ChangeAction) { - modelChangedListenerMap[adapter.modelClass]?.forEach { listener -> + modelChangedListenerMap[adapter.table]?.forEach { listener -> (listener as OnModelStateChangedListener).onModelChanged(model, action) } } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/NotifyDistributor.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/NotifyDistributor.kt index 1aad1221a..514b42e48 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/NotifyDistributor.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/NotifyDistributor.kt @@ -16,7 +16,7 @@ class NotifyDistributor : ModelNotifier { override fun notifyModelChanged(model: T, adapter: ModelAdapter, action: ChangeAction) { - FlowManager.getModelNotifierForTable(adapter.modelClass) + FlowManager.getModelNotifierForTable(adapter.table) .notifyModelChanged(model, adapter, action) } From de5698f83fd2a74214d329ecff65b5719618a623 Mon Sep 17 00:00:00 2001 From: fuzzagrosner Date: Mon, 4 Dec 2017 10:48:38 -0500 Subject: [PATCH 116/234] [database] use DatabaseDefinition directly instead of wrapper where possible. --- .../processor/definition/ContentProvider.kt | 146 +++++++++--------- .../dbflow5/provider/RealContentProvider.kt | 2 +- .../java/com/raizlabs/dbflow5/SqlUtils.kt | 27 ++-- .../dbflow5/adapter/RetrievalAdapter.kt | 19 ++- .../database/DatabaseHelperDelegate.kt | 2 +- .../dbflow5/query/CompletedTrigger.kt | 11 +- .../dbflow5/transaction/Transaction.kt | 2 +- 7 files changed, 102 insertions(+), 107 deletions(-) diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/ContentProvider.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/ContentProvider.kt index df865cfa6..575bdc884 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/ContentProvider.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/ContentProvider.kt @@ -41,9 +41,9 @@ import javax.lang.model.type.MirroredTypeException internal fun appendDefault(code: CodeBlock.Builder) { code.beginControlFlow("default:") - .addStatement("throw new \$T(\$S + \$L)", - ClassName.get(IllegalArgumentException::class.java), "Unknown URI", Constants.PARAM_URI) - .endControlFlow() + .addStatement("throw new \$T(\$S + \$L)", + ClassName.get(IllegalArgumentException::class.java), "Unknown URI", Constants.PARAM_URI) + .endControlFlow() } object Constants { @@ -59,7 +59,7 @@ object Constants { internal fun ContentUriDefinition.getSegmentsPreparation() = code { if (segments.isNotEmpty()) { statement("\$T segments = uri.getPathSegments()", - parameterized(List::class)) + parameterized(List::class)) } this } @@ -73,7 +73,7 @@ internal fun ContentUriDefinition.getSelectionAndSelectionArgs(): CodeBlock { } else { val selectionBuilder = CodeBlock.builder().add("\$T.concatenateWhere(selection, \"", ClassNames.DATABASE_UTILS) val selectionArgsBuilder = CodeBlock.builder().add("\$T.appendSelectionArgs(selectionArgs, new \$T[] {", - ClassNames.DATABASE_UTILS, String::class.java) + ClassNames.DATABASE_UTILS, String::class.java) var isFirst = true for (segment in segments) { if (!isFirst) { @@ -109,9 +109,9 @@ class DeleteMethod(private val contentProviderDefinition: ContentProviderDefinit code.apply { case(uriDefinition.name.L) { add(uriDefinition.getSegmentsPreparation()) - add("long count = \$T.getDatabase(\$T.class).getWritableDatabase().delete(\$S, ", - ClassNames.FLOW_MANAGER, contentProviderDefinition.databaseTypeName, - it.tableName) + add("long count = \$T.getDatabase(\$T.class).delete(\$S, ", + ClassNames.FLOW_MANAGER, contentProviderDefinition.databaseTypeName, + it.tableName) add(uriDefinition.getSelectionAndSelectionArgs()) add(");\n") @@ -128,12 +128,12 @@ class DeleteMethod(private val contentProviderDefinition: ContentProviderDefinit code.endControlFlow() return MethodSpec.methodBuilder("delete") - .addAnnotation(Override::class.java) - .addModifiers(Modifier.PUBLIC, Modifier.FINAL) - .addParameter(ClassNames.URI, PARAM_URI) - .addParameter(ClassName.get(String::class.java), PARAM_SELECTION) - .addParameter(ArrayTypeName.of(String::class.java), PARAM_SELECTION_ARGS) - .addCode(code.build()).returns(TypeName.INT).build() + .addAnnotation(Override::class.java) + .addModifiers(Modifier.PUBLIC, Modifier.FINAL) + .addParameter(ClassNames.URI, PARAM_URI) + .addParameter(ClassName.get(String::class.java), PARAM_SELECTION) + .addParameter(ArrayTypeName.of(String::class.java), PARAM_SELECTION_ARGS) + .addCode(code.build()).returns(TypeName.INT).build() } companion object { @@ -162,14 +162,14 @@ class InsertMethod(private val contentProviderDefinition: ContentProviderDefinit code.apply { beginControlFlow("case \$L:", uriDefinition.name) addStatement("\$T adapter = \$T.getModelAdapter(\$T.getTableClassForName(\$T.class, \$S))", - ClassNames.MODEL_ADAPTER, ClassNames.FLOW_MANAGER, ClassNames.FLOW_MANAGER, - contentProviderDefinition.databaseTypeName, it.tableName) + ClassNames.MODEL_ADAPTER, ClassNames.FLOW_MANAGER, ClassNames.FLOW_MANAGER, + contentProviderDefinition.databaseTypeName, it.tableName) - add("final long id = FlowManager.getDatabase(\$T.class).getWritableDatabase()", - contentProviderDefinition.databaseTypeName).add( - ".insertWithOnConflict(\$S, null, values, " + - "\$T.getSQLiteDatabaseAlgorithmInt(adapter.getInsertOnConflictAction()));\n", it.tableName, - ClassNames.CONFLICT_ACTION) + add("final long id = FlowManager.getDatabase(\$T.class)", + contentProviderDefinition.databaseTypeName).add( + ".insertWithOnConflict(\$S, null, values, " + + "\$T.getSQLiteDatabaseAlgorithmInt(adapter.getInsertOnConflictAction()));\n", it.tableName, + ClassNames.CONFLICT_ACTION) NotifyMethod(it, uriDefinition, NotifyMethod.INSERT).addCode(this) @@ -187,10 +187,10 @@ class InsertMethod(private val contentProviderDefinition: ContentProviderDefinit appendDefault(code) code.endControlFlow() return MethodSpec.methodBuilder(if (isBulk) "bulkInsert" else "insert") - .addAnnotation(Override::class.java).addParameter(ClassNames.URI, Constants.PARAM_URI) - .addParameter(ClassNames.CONTENT_VALUES, Constants.PARAM_CONTENT_VALUES) - .addModifiers(if (isBulk) Modifier.PROTECTED else Modifier.PUBLIC, Modifier.FINAL) - .addCode(code.build()).returns(if (isBulk) TypeName.INT else ClassNames.URI).build() + .addAnnotation(Override::class.java).addParameter(ClassNames.URI, Constants.PARAM_URI) + .addParameter(ClassNames.CONTENT_VALUES, Constants.PARAM_CONTENT_VALUES) + .addModifiers(if (isBulk) Modifier.PROTECTED else Modifier.PUBLIC, Modifier.FINAL) + .addCode(code.build()).returns(if (isBulk) TypeName.INT else ClassNames.URI).build() } } @@ -211,16 +211,16 @@ class NotifyMethod(private val tableEndpointDefinition: TableEndpointDefinition, val notifyDefinition = notifyDefinitionList[i] if (notifyDefinition.returnsArray) { code.addStatement("\$T[] notifyUris\$L = \$L.\$L(\$L)", ClassNames.URI, - notifyDefinition.methodName, notifyDefinition.parent, - notifyDefinition.methodName, notifyDefinition.params) + notifyDefinition.methodName, notifyDefinition.parent, + notifyDefinition.methodName, notifyDefinition.params) code.beginControlFlow("for (\$T notifyUri: notifyUris\$L)", ClassNames.URI, notifyDefinition.methodName) } else { code.addStatement("\$T notifyUri\$L = \$L.\$L(\$L)", ClassNames.URI, - notifyDefinition.methodName, notifyDefinition.parent, - notifyDefinition.methodName, notifyDefinition.params) + notifyDefinition.methodName, notifyDefinition.parent, + notifyDefinition.methodName, notifyDefinition.params) } code.addStatement("getContext().getContentResolver().notifyChange(notifyUri\$L, null)", - if (notifyDefinition.returnsArray) "" else notifyDefinition.methodName) + if (notifyDefinition.returnsArray) "" else notifyDefinition.methodName) if (notifyDefinition.returnsArray) { code.endControlFlow() } @@ -256,14 +256,14 @@ class QueryMethod(private val contentProviderDefinition: ContentProviderDefiniti override val methodSpec: MethodSpec? get() { val method = MethodSpec.methodBuilder("query") - .addAnnotation(Override::class.java) - .addModifiers(Modifier.PUBLIC, Modifier.FINAL) - .addParameter(ClassNames.URI, "uri") - .addParameter(ArrayTypeName.of(String::class.java), "projection") - .addParameter(ClassName.get(String::class.java), "selection") - .addParameter(ArrayTypeName.of(String::class.java), "selectionArgs") - .addParameter(ClassName.get(String::class.java), "sortOrder") - .returns(ClassNames.CURSOR) + .addAnnotation(Override::class.java) + .addModifiers(Modifier.PUBLIC, Modifier.FINAL) + .addParameter(ClassNames.URI, "uri") + .addParameter(ArrayTypeName.of(String::class.java), "projection") + .addParameter(ClassName.get(String::class.java), "selection") + .addParameter(ArrayTypeName.of(String::class.java), "selectionArgs") + .addParameter(ClassName.get(String::class.java), "sortOrder") + .returns(ClassNames.CURSOR) method.addStatement("\$L cursor = null", ClassNames.CURSOR) method.beginControlFlow("switch(\$L.match(uri))", ContentProviderDefinition.URI_MATCHER) @@ -273,9 +273,9 @@ class QueryMethod(private val contentProviderDefinition: ContentProviderDefiniti method.apply { beginControlFlow("case \$L:", uriDefinition.name) addCode(uriDefinition.getSegmentsPreparation()) - addCode("cursor = \$T.getDatabase(\$T.class).getWritableDatabase().query(\$S, projection, ", - ClassNames.FLOW_MANAGER, contentProviderDefinition.databaseTypeName, - tableEndpointDefinition.tableName) + addCode("cursor = \$T.getDatabase(\$T.class).query(\$S, projection, ", + ClassNames.FLOW_MANAGER, contentProviderDefinition.databaseTypeName, + tableEndpointDefinition.tableName) addCode(uriDefinition.getSelectionAndSelectionArgs()) addCode(", null, null, sortOrder);\n") addStatement("break") @@ -304,13 +304,13 @@ class UpdateMethod(private val contentProviderDefinition: ContentProviderDefinit override val methodSpec: MethodSpec? get() { val method = MethodSpec.methodBuilder("update") - .addAnnotation(Override::class.java) - .addModifiers(Modifier.PUBLIC) - .addParameter(ClassNames.URI, Constants.PARAM_URI) - .addParameter(ClassNames.CONTENT_VALUES, Constants.PARAM_CONTENT_VALUES) - .addParameter(ClassName.get(String::class.java), "selection") - .addParameter(ArrayTypeName.of(String::class.java), "selectionArgs") - .returns(TypeName.INT) + .addAnnotation(Override::class.java) + .addModifiers(Modifier.PUBLIC) + .addParameter(ClassNames.URI, Constants.PARAM_URI) + .addParameter(ClassNames.CONTENT_VALUES, Constants.PARAM_CONTENT_VALUES) + .addParameter(ClassName.get(String::class.java), "selection") + .addParameter(ArrayTypeName.of(String::class.java), "selectionArgs") + .returns(TypeName.INT) method.beginControlFlow("switch(MATCHER.match(\$L))", Constants.PARAM_URI) for (tableEndpointDefinition in contentProviderDefinition.endpointDefinitions) { @@ -319,23 +319,23 @@ class UpdateMethod(private val contentProviderDefinition: ContentProviderDefinit method.apply { beginControlFlow("case \$L:", uriDefinition.name) addStatement("\$T adapter = \$T.getModelAdapter(\$T.getTableClassForName(\$T.class, \$S))", - ClassNames.MODEL_ADAPTER, ClassNames.FLOW_MANAGER, ClassNames.FLOW_MANAGER, - contentProviderDefinition.databaseTypeName, - tableEndpointDefinition.tableName) + ClassNames.MODEL_ADAPTER, ClassNames.FLOW_MANAGER, ClassNames.FLOW_MANAGER, + contentProviderDefinition.databaseTypeName, + tableEndpointDefinition.tableName) addCode(uriDefinition.getSegmentsPreparation()) addCode( - "long count = \$T.getDatabase(\$T.class).getWritableDatabase().updateWithOnConflict(\$S, \$L, ", - ClassNames.FLOW_MANAGER, contentProviderDefinition.databaseTypeName, - tableEndpointDefinition.tableName, - Constants.PARAM_CONTENT_VALUES) + "long count = \$T.getDatabase(\$T.class).updateWithOnConflict(\$S, \$L, ", + ClassNames.FLOW_MANAGER, contentProviderDefinition.databaseTypeName, + tableEndpointDefinition.tableName, + Constants.PARAM_CONTENT_VALUES) addCode(uriDefinition.getSelectionAndSelectionArgs()) addCode( - ", \$T.getSQLiteDatabaseAlgorithmInt(adapter.getUpdateOnConflictAction()));\n", - ClassNames.CONFLICT_ACTION) + ", \$T.getSQLiteDatabaseAlgorithmInt(adapter.getUpdateOnConflictAction()));\n", + ClassNames.CONFLICT_ACTION) val code = CodeBlock.builder() NotifyMethod(tableEndpointDefinition, uriDefinition, - NotifyMethod.UPDATE).addCode(code) + NotifyMethod.UPDATE).addCode(code) addCode(code.build()) addStatement("return (int) count") @@ -369,10 +369,10 @@ class ContentProviderDefinition(typeElement: Element, processorManager: Processo var endpointDefinitions = arrayListOf() private val methods: Array = arrayOf(QueryMethod(this, manager), - InsertMethod(this, false), - InsertMethod(this, true), - DeleteMethod(this, manager), - UpdateMethod(this, manager)) + InsertMethod(this, false), + InsertMethod(this, true), + DeleteMethod(this, manager), + UpdateMethod(this, manager)) init { element.annotation()?.let { provider -> @@ -423,10 +423,10 @@ class ContentProviderDefinition(typeElement: Element, processorManager: Processo `override fun`(TypeName.BOOLEAN, "onCreate") { modifiers(public, final) addStatement("final \$T $AUTHORITY = \$L", String::class.java, - if (authority.contains("R.string.")) - "getContext().getString($authority)" - else - "\"$authority\"") + if (authority.contains("R.string.")) + "getContext().getString($authority)" + else + "\"$authority\"") for (endpointDefinition in endpointDefinitions) { endpointDefinition.contentUriDefinitions.forEach { @@ -435,7 +435,7 @@ class ContentProviderDefinition(typeElement: Element, processorManager: Processo path = "\"" + it.path + "\"" } else { path = CodeBlock.builder().add("\$L.\$L.getPath()", it.elementClassName, - it.name).build().toString() + it.name).build().toString() } addStatement("\$L.addURI(\$L, \$L, \$L)", URI_MATCHER, AUTHORITY, path, it.name) } @@ -455,12 +455,12 @@ class ContentProviderDefinition(typeElement: Element, processorManager: Processo statement("\$T type = null", ClassName.get(String::class.java)) controlFlow("switch(\$L.match(uri))", URI_MATCHER) { endpointDefinitions.flatMap { it.contentUriDefinitions } - .forEach { uri -> - controlFlow("case \$L:", uri.name) { - statement("type = \$S", uri.type) - `break`() - } + .forEach { uri -> + controlFlow("case \$L:", uri.name) { + statement("type = \$S", uri.type) + `break`() } + } appendDefault(this) } `return`("type") @@ -469,7 +469,7 @@ class ContentProviderDefinition(typeElement: Element, processorManager: Processo } methods.mapNotNull { it.methodSpec } - .forEach { typeBuilder.addMethod(it) } + .forEach { typeBuilder.addMethod(it) } } companion object { diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/provider/RealContentProvider.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/provider/RealContentProvider.kt index 5e491341c..0f9a4753a 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/provider/RealContentProvider.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/provider/RealContentProvider.kt @@ -15,7 +15,7 @@ class RealContentProvider : ContentProvider() { override fun onCreate(): Boolean { FlowManager.init(FlowConfig.Builder(context).build()) - database = FlowManager.getDatabase(TestDatabase::class.java).writableDatabase + database = FlowManager.getDatabase(TestDatabase::class.java) return true } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/SqlUtils.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/SqlUtils.kt index a5812d536..1a8e54f2a 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/SqlUtils.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/SqlUtils.kt @@ -5,13 +5,13 @@ package com.raizlabs.dbflow5 import android.content.ContentValues import android.net.Uri import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.database.DatabaseWrapper import com.raizlabs.dbflow5.query.NameAlias import com.raizlabs.dbflow5.query.Operator import com.raizlabs.dbflow5.query.OperatorGroup import com.raizlabs.dbflow5.query.SQLOperator import com.raizlabs.dbflow5.structure.ChangeAction import com.raizlabs.dbflow5.structure.Model -import com.raizlabs.dbflow5.database.DatabaseWrapper /** * Description: Provides some handy methods for dealing with SQL statements. It's purpose is to move the @@ -34,8 +34,8 @@ fun getNotificationUri(contentAuthority: String, action: ChangeAction?, conditions: Iterable?): Uri { val uriBuilder = Uri.Builder().scheme("dbflow") - .authority(contentAuthority) - .appendQueryParameter(TABLE_QUERY_PARAM, FlowManager.getTableName(modelClass)) + .authority(contentAuthority) + .appendQueryParameter(TABLE_QUERY_PARAM, FlowManager.getTableName(modelClass)) if (action != null) { uriBuilder.fragment(action.name) } @@ -61,13 +61,13 @@ fun getNotificationUri(contentAuthority: String, action: ChangeAction?, conditions: Array?): Uri { val uriBuilder = Uri.Builder().scheme("dbflow") - .authority(contentAuthority) - .appendQueryParameter(TABLE_QUERY_PARAM, FlowManager.getTableName(modelClass)) + .authority(contentAuthority) + .appendQueryParameter(TABLE_QUERY_PARAM, FlowManager.getTableName(modelClass)) action?.let { uriBuilder.fragment(action.name) } if (conditions != null && conditions.isNotEmpty()) { for (condition in conditions) { uriBuilder.appendQueryParameter(Uri.encode(condition.columnName()), - Uri.encode(condition.value().toString())) + Uri.encode(condition.value().toString())) } } return uriBuilder.build() @@ -93,7 +93,7 @@ fun getNotificationUri(contentAuthority: String, operator = Operator.op(NameAlias.Builder(notifyKey).build()).value(notifyValue) } return getNotificationUri(contentAuthority, modelClass, action, - if (operator != null) arrayOf(operator) else null) + if (operator != null) arrayOf(operator) else null) } @@ -104,8 +104,7 @@ fun getNotificationUri(contentAuthority: String, * @param triggerName The name of the trigger */ fun dropTrigger(mOnTable: Class<*>, triggerName: String) { - FlowManager.getDatabaseForTable(mOnTable).writableDatabase - .execSQL("DROP TRIGGER IF EXISTS " + triggerName) + FlowManager.getDatabaseForTable(mOnTable).execSQL("DROP TRIGGER IF EXISTS " + triggerName) } /** @@ -113,14 +112,12 @@ fun dropTrigger(mOnTable: Class<*>, triggerName: String) { * * @param indexName The name of the index. */ -fun dropIndex(databaseWrapper: DatabaseWrapper, - indexName: String) { +fun dropIndex(databaseWrapper: DatabaseWrapper, indexName: String) { databaseWrapper.execSQL("DROP INDEX IF EXISTS " + indexName.quoteIfNeeded()!!) } -fun dropIndex(onTable: Class<*>, - indexName: String) { - dropIndex(FlowManager.getDatabaseForTable(onTable).writableDatabase, indexName) +fun dropIndex(onTable: Class<*>, indexName: String) { + dropIndex(FlowManager.getDatabaseForTable(onTable), indexName) } /** @@ -134,7 +131,7 @@ fun addContentValues(contentValues: ContentValues, operatorGroup: OperatorGroup) for ((key) in entries) { operatorGroup.and(Operator.op(NameAlias.Builder(key).build()) - .`is`(contentValues.get(key))) + .`is`(contentValues.get(key))) } } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/RetrievalAdapter.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/RetrievalAdapter.kt index 6813e60ca..11ca26b7b 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/RetrievalAdapter.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/RetrievalAdapter.kt @@ -1,14 +1,14 @@ package com.raizlabs.dbflow5.adapter import android.database.Cursor +import com.raizlabs.dbflow5.adapter.queriable.ListModelLoader +import com.raizlabs.dbflow5.adapter.queriable.SingleModelLoader import com.raizlabs.dbflow5.config.DatabaseDefinition import com.raizlabs.dbflow5.config.FlowManager import com.raizlabs.dbflow5.config.TableConfig -import com.raizlabs.dbflow5.query.OperatorGroup -import com.raizlabs.dbflow5.adapter.queriable.ListModelLoader -import com.raizlabs.dbflow5.adapter.queriable.SingleModelLoader import com.raizlabs.dbflow5.database.DatabaseWrapper import com.raizlabs.dbflow5.database.FlowCursor +import com.raizlabs.dbflow5.query.OperatorGroup import com.raizlabs.dbflow5.query.select /** @@ -81,7 +81,7 @@ abstract class RetrievalAdapter(databaseDefinition: DatabaseDefinition) init { val databaseConfig = FlowManager.getConfig() - .getConfigForDatabase(databaseDefinition.associatedDatabaseClassFile) + .getConfigForDatabase(databaseDefinition.associatedDatabaseClassFile) if (databaseConfig != null) { tableConfig = databaseConfig.getTableConfigForTable(table) if (tableConfig != null) { @@ -96,10 +96,10 @@ abstract class RetrievalAdapter(databaseDefinition: DatabaseDefinition) */ open fun load(model: T, databaseWrapper: DatabaseWrapper) { nonCacheableSingleModelLoader.load(databaseWrapper, - (databaseWrapper.select - from table - where getPrimaryConditionClause(model)).query, - model) + (databaseWrapper.select + from table + where getPrimaryConditionClause(model)).query, + model) } /** @@ -114,8 +114,7 @@ abstract class RetrievalAdapter(databaseDefinition: DatabaseDefinition) * @param model The model to query values from * @return True if it exists as a row in the corresponding database table */ - open fun exists(model: T): Boolean = - exists(model, FlowManager.getDatabaseForTable(table).writableDatabase) + open fun exists(model: T): Boolean = exists(model, FlowManager.getDatabaseForTable(table)) /** * @param model The model to query values from diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseHelperDelegate.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseHelperDelegate.kt index 7dbc0b646..20708063f 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseHelperDelegate.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseHelperDelegate.kt @@ -40,7 +40,7 @@ class DatabaseHelperDelegate( get() = isDatabaseIntegrityOk(writableDatabase) val writableDatabase: DatabaseWrapper - get() = databaseDefinition.writableDatabase + get() = databaseDefinition fun performRestoreFromBackup() { movePrepackagedDB(databaseDefinition.databaseFileName, diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/CompletedTrigger.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/CompletedTrigger.kt index 9661b2877..8c5afe6a5 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/CompletedTrigger.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/CompletedTrigger.kt @@ -8,10 +8,10 @@ import com.raizlabs.dbflow5.sql.Query * Description: The last piece of a TRIGGER statement, this class contains the BEGIN...END and the logic in between. */ class CompletedTrigger internal constructor( - /** - * The first pieces of this TRIGGER statement - */ - private val triggerMethod: TriggerMethod, triggerLogicQuery: Query) : Query { + /** + * The first pieces of this TRIGGER statement + */ + private val triggerMethod: TriggerMethod, triggerLogicQuery: Query) : Query { /** * The query to run between the BEGIN and END of this statement @@ -38,8 +38,7 @@ class CompletedTrigger internal constructor( * Turns on this trigger */ fun enable() { - val databaseDefinition = FlowManager.getDatabaseForTable(triggerMethod.onTable) - databaseDefinition.writableDatabase.execSQL(query) + FlowManager.getDatabaseForTable(triggerMethod.onTable).execSQL(query) } /** diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/Transaction.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/Transaction.kt index 871d37c6e..4cc80547a 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/Transaction.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/Transaction.kt @@ -94,7 +94,7 @@ class Transaction(private val transaction: ITransaction, val result = if (shouldRunInTransaction) { databaseDefinition.executeTransaction(transaction) } else { - transaction.execute(databaseDefinition.writableDatabase) + transaction.execute(databaseDefinition) } if (successCallback != null) { if (runCallbacksOnSameThread) { From ff75852f48a9651be1e024607da4782faffea934 Mon Sep 17 00:00:00 2001 From: fuzzagrosner Date: Mon, 4 Dec 2017 10:57:32 -0500 Subject: [PATCH 117/234] [database] add standalone extension inline methods that accept a KCLass to retrieve database object. --- .../dbflow5/config/DatabaseConfigTest.kt | 22 ++-- .../dbflow5/provider/RealContentProvider.kt | 3 +- .../raizlabs/dbflow5/config/FlowManager.kt | 111 +++++++++--------- 3 files changed, 70 insertions(+), 66 deletions(-) diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/config/DatabaseConfigTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/config/DatabaseConfigTest.kt index dbfef312c..c138b0fff 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/config/DatabaseConfigTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/config/DatabaseConfigTest.kt @@ -41,13 +41,13 @@ class DatabaseConfigTest : BaseUnitTest() { } FlowManager.init(builder - .addDatabaseConfig(DatabaseConfig.Builder(TestDatabase::class.java) - .databaseName("Test") - .helperListener(helperListener) - .openHelper(openHelperCreator) - .transactionManagerCreator(managerCreator) - .build()) + .addDatabaseConfig(DatabaseConfig.Builder(TestDatabase::class.java) + .databaseName("Test") + .helperListener(helperListener) + .openHelper(openHelperCreator) + .transactionManagerCreator(managerCreator) .build()) + .build()) val flowConfig = FlowManager.getConfig() Assert.assertNotNull(flowConfig) @@ -62,7 +62,7 @@ class DatabaseConfigTest : BaseUnitTest() { Assert.assertTrue(databaseConfig.tableConfigMap.isEmpty()) - val databaseDefinition = FlowManager.getDatabase(TestDatabase::class.java) + val databaseDefinition = database() Assert.assertEquals(databaseDefinition.transactionManager, testTransactionManager) Assert.assertEquals(databaseDefinition.helper, customOpenHelper) } @@ -70,11 +70,11 @@ class DatabaseConfigTest : BaseUnitTest() { @Test fun test_EmptyName() { FlowManager.init(builder - .addDatabaseConfig(DatabaseConfig.Builder(TestDatabase::class.java) - .databaseName("Test") - .extensionName("") - .build()) + .addDatabaseConfig(DatabaseConfig.Builder(TestDatabase::class.java) + .databaseName("Test") + .extensionName("") .build()) + .build()) val databaseConfig = FlowManager.getConfig().databaseConfigMap[TestDatabase::class.java]!! Assert.assertEquals("Test", databaseConfig.databaseName) diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/provider/RealContentProvider.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/provider/RealContentProvider.kt index 0f9a4753a..5cc1676ca 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/provider/RealContentProvider.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/provider/RealContentProvider.kt @@ -7,6 +7,7 @@ import android.net.Uri import com.raizlabs.dbflow5.TestDatabase import com.raizlabs.dbflow5.config.FlowConfig import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.config.database import com.raizlabs.dbflow5.database.DatabaseWrapper class RealContentProvider : ContentProvider() { @@ -15,7 +16,7 @@ class RealContentProvider : ContentProvider() { override fun onCreate(): Boolean { FlowManager.init(FlowConfig.Builder(context).build()) - database = FlowManager.getDatabase(TestDatabase::class.java) + database = database() return true } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowManager.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowManager.kt index 9fdd457e3..6490d31e3 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowManager.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowManager.kt @@ -1,23 +1,25 @@ +@file:Suppress("NOTHING_TO_INLINE") + package com.raizlabs.dbflow5.config import android.content.Context +import com.raizlabs.dbflow5.adapter.InstanceAdapter +import com.raizlabs.dbflow5.adapter.ModelAdapter +import com.raizlabs.dbflow5.adapter.ModelViewAdapter +import com.raizlabs.dbflow5.adapter.QueryModelAdapter +import com.raizlabs.dbflow5.adapter.RetrievalAdapter import com.raizlabs.dbflow5.annotation.Table import com.raizlabs.dbflow5.converter.TypeConverter +import com.raizlabs.dbflow5.database.DatabaseWrapper +import com.raizlabs.dbflow5.migration.Migration import com.raizlabs.dbflow5.quote import com.raizlabs.dbflow5.runtime.ModelNotifier import com.raizlabs.dbflow5.runtime.TableNotifierRegister -import com.raizlabs.dbflow5.migration.Migration import com.raizlabs.dbflow5.structure.BaseModel import com.raizlabs.dbflow5.structure.BaseModelView import com.raizlabs.dbflow5.structure.BaseQueryModel -import com.raizlabs.dbflow5.adapter.InstanceAdapter import com.raizlabs.dbflow5.structure.InvalidDBConfiguration import com.raizlabs.dbflow5.structure.Model -import com.raizlabs.dbflow5.adapter.ModelAdapter -import com.raizlabs.dbflow5.adapter.ModelViewAdapter -import com.raizlabs.dbflow5.adapter.QueryModelAdapter -import com.raizlabs.dbflow5.adapter.RetrievalAdapter -import com.raizlabs.dbflow5.database.DatabaseWrapper import kotlin.reflect.KClass /** @@ -38,7 +40,7 @@ object FlowManager { private val DEFAULT_DATABASE_HOLDER_PACKAGE_NAME = FlowManager::class.java.`package`.name private val DEFAULT_DATABASE_HOLDER_CLASSNAME = - DEFAULT_DATABASE_HOLDER_PACKAGE_NAME + "." + DEFAULT_DATABASE_HOLDER_NAME + DEFAULT_DATABASE_HOLDER_PACKAGE_NAME + "." + DEFAULT_DATABASE_HOLDER_NAME /** * Will throw an exception if this class is not initialized yet in [.init] @@ -48,8 +50,8 @@ object FlowManager { @JvmStatic val context: Context get() = config?.context ?: - throw IllegalStateException("You must provide a valid FlowConfig instance." + - " We recommend calling init() in your application class.") + throw IllegalStateException("You must provide a valid FlowConfig instance." + + " We recommend calling init() in your application class.") private class GlobalDatabaseHolder : DatabaseHolder() { @@ -74,8 +76,8 @@ object FlowManager { @JvmStatic fun getTableName(table: Class<*>): String { return getModelAdapterOrNull(table)?.tableName - ?: getModelViewAdapterOrNull(table)?.viewName - ?: throwCannotFindAdapter("ModelAdapter/ModelViewAdapter", table) + ?: getModelViewAdapterOrNull(table)?.viewName + ?: throwCannotFindAdapter("ModelAdapter/ModelViewAdapter", table) } /** @@ -87,9 +89,9 @@ object FlowManager { fun getTableClassForName(databaseName: String, tableName: String): Class<*> { val databaseDefinition = getDatabase(databaseName) return databaseDefinition.getModelClassForName(tableName) - ?: databaseDefinition.getModelClassForName(tableName.quote()) - ?: throw IllegalArgumentException("The specified table $tableName was not found." + - " Did you forget to add the @Table annotation and point it to $databaseName?") + ?: databaseDefinition.getModelClassForName(tableName.quote()) + ?: throw IllegalArgumentException("The specified table $tableName was not found." + + " Did you forget to add the @Table annotation and point it to $databaseName?") } /** @@ -101,9 +103,9 @@ object FlowManager { fun getTableClassForName(databaseClass: Class<*>, tableName: String): Class<*> { val databaseDefinition = getDatabase(databaseClass) return databaseDefinition.getModelClassForName(tableName) - ?: databaseDefinition.getModelClassForName(tableName.quote()) - ?: throw IllegalArgumentException("The specified table $tableName was not found." + - " Did you forget to add the @Table annotation and point it to $databaseClass?") + ?: databaseDefinition.getModelClassForName(tableName.quote()) + ?: throw IllegalArgumentException("The specified table $tableName was not found." + + " Did you forget to add the @Table annotation and point it to $databaseClass?") } /** @@ -114,16 +116,16 @@ object FlowManager { fun getDatabaseForTable(table: Class<*>): DatabaseDefinition { checkDatabaseHolder() return globalDatabaseHolder.getDatabaseForTable(table) ?: - throw InvalidDBConfiguration("Model object: ${table.name} is not registered with a Database." + - " Did you forget an annotation?") + throw InvalidDBConfiguration("Model object: ${table.name} is not registered with a Database." + + " Did you forget an annotation?") } @JvmStatic fun getDatabase(databaseClass: Class<*>): DatabaseDefinition { checkDatabaseHolder() return globalDatabaseHolder.getDatabase(databaseClass) ?: - throw InvalidDBConfiguration("Database: ${databaseClass.name} is not a registered Database. " + - "Did you forget the @Database annotation?") + throw InvalidDBConfiguration("Database: ${databaseClass.name} is not a registered Database. " + + "Did you forget the @Database annotation?") } @JvmStatic @@ -137,27 +139,27 @@ object FlowManager { fun getDatabase(databaseName: String): DatabaseDefinition { checkDatabaseHolder() return globalDatabaseHolder.getDatabase(databaseName) ?: - throw InvalidDBConfiguration("The specified database $databaseName was not found. " + - "Did you forget the @Database annotation?") + throw InvalidDBConfiguration("The specified database $databaseName was not found. " + + "Did you forget the @Database annotation?") } @Deprecated(replaceWith = ReplaceWith("FlowManager.getDatabaseForTable(table)"), - message = "This method is no longer needed. DatabaseDefinition now delegates to the DatabaseWrapper.") + message = "This method is no longer needed. DatabaseDefinition now delegates to the DatabaseWrapper.") @JvmStatic fun getWritableDatabaseForTable(table: Class<*>): DatabaseWrapper = - getDatabaseForTable(table).writableDatabase + getDatabaseForTable(table).writableDatabase @Deprecated(replaceWith = ReplaceWith("FlowManager.getDatabase(databaseName)"), - message = "This method is no longer needed. DatabaseDefinition now delegates to the DatabaseWrapper.") + message = "This method is no longer needed. DatabaseDefinition now delegates to the DatabaseWrapper.") @JvmStatic fun getWritableDatabase(databaseName: String): DatabaseWrapper = - getDatabase(databaseName).writableDatabase + getDatabase(databaseName).writableDatabase @Deprecated(replaceWith = ReplaceWith("FlowManager.getDatabase(databaseClass)"), - message = "This method is no longer needed. DatabaseDefinition now delegates to the DatabaseWrapper.") + message = "This method is no longer needed. DatabaseDefinition now delegates to the DatabaseWrapper.") @JvmStatic fun getWritableDatabase(databaseClass: Class<*>): DatabaseWrapper = - getDatabase(databaseClass).writableDatabase + getDatabase(databaseClass).writableDatabase /** * Loading the module Database holder via reflection. @@ -174,8 +176,8 @@ object FlowManager { @JvmStatic fun getConfig(): FlowConfig = config ?: - throw IllegalStateException("Configuration is not initialized. " + - "Please call init(FlowConfig) in your application class.") + throw IllegalStateException("Configuration is not initialized. " + + "Please call init(FlowConfig) in your application class.") /** * @return The database holder, creating if necessary using reflection. @@ -342,7 +344,7 @@ object FlowManager { */ @JvmStatic fun getModelAdapter(modelClass: Class): ModelAdapter = - getModelAdapterOrNull(modelClass) ?: throwCannotFindAdapter("ModelAdapter", modelClass) + getModelAdapterOrNull(modelClass) ?: throwCannotFindAdapter("ModelAdapter", modelClass) /** * Returns the model view adapter for a SQLite VIEW. These are only created with the [com.raizlabs.android.dbflow.annotation.ModelView] annotation. @@ -353,7 +355,7 @@ object FlowManager { */ @JvmStatic fun getModelViewAdapter(modelViewClass: Class): ModelViewAdapter = - getModelViewAdapterOrNull(modelViewClass) ?: throwCannotFindAdapter("ModelViewAdapter", modelViewClass) + getModelViewAdapterOrNull(modelViewClass) ?: throwCannotFindAdapter("ModelViewAdapter", modelViewClass) /** * Returns the query model adapter for an undefined query. These are only created with the [T] annotation. @@ -364,24 +366,24 @@ object FlowManager { */ @JvmStatic fun getQueryModelAdapter(queryModelClass: Class): QueryModelAdapter = - getQueryModelAdapterOrNull(queryModelClass) ?: throwCannotFindAdapter("QueryModelAdapter", queryModelClass) + getQueryModelAdapterOrNull(queryModelClass) ?: throwCannotFindAdapter("QueryModelAdapter", queryModelClass) @JvmStatic fun getModelNotifierForTable(table: Class<*>): ModelNotifier = - getDatabaseForTable(table).getModelNotifier() + getDatabaseForTable(table).getModelNotifier() @JvmStatic fun newRegisterForTable(table: Class<*>): TableNotifierRegister = - getModelNotifierForTable(table).newRegister() + getModelNotifierForTable(table).newRegister() private fun getModelAdapterOrNull(modelClass: Class): ModelAdapter? = - getDatabaseForTable(modelClass).getModelAdapterForTable(modelClass) + getDatabaseForTable(modelClass).getModelAdapterForTable(modelClass) private fun getModelViewAdapterOrNull(modelClass: Class): ModelViewAdapter? = - getDatabaseForTable(modelClass).getModelViewAdapterForTable(modelClass) + getDatabaseForTable(modelClass).getModelViewAdapterForTable(modelClass) private fun getQueryModelAdapterOrNull(modelClass: Class): QueryModelAdapter? = - getDatabaseForTable(modelClass).getQueryModelAdapterForQueryClass(modelClass) + getDatabaseForTable(modelClass).getQueryModelAdapterForQueryClass(modelClass) /** * @param databaseName The name of the database. Will throw an exception if the databaseForTable doesn't exist. @@ -389,7 +391,7 @@ object FlowManager { */ @JvmStatic internal fun getMigrations(databaseName: String): Map> = - getDatabase(databaseName).migrations + getDatabase(databaseName).migrations /** * Checks a standard database helper for integrity using quick_check(1). @@ -401,12 +403,12 @@ object FlowManager { fun isDatabaseIntegrityOk(databaseName: String) = getDatabase(databaseName).helper.isDatabaseIntegrityOk private fun throwCannotFindAdapter(type: String, clazz: Class<*>): Nothing = - throw IllegalArgumentException("Cannot find $type for $clazz. Ensure the class is annotated with proper annotation.") + throw IllegalArgumentException("Cannot find $type for $clazz. Ensure the class is annotated with proper annotation.") private fun checkDatabaseHolder() { if (!globalDatabaseHolder.isInitialized) { throw IllegalStateException("The global databaseForTable holder is not initialized. Ensure you call " - + "FlowManager.init() before accessing the databaseForTable.") + + "FlowManager.init() before accessing the databaseForTable.") } } @@ -431,35 +433,36 @@ object FlowManager { /** * Easily get access to its [DatabaseDefinition] directly. */ -inline fun database(): DatabaseDefinition - = FlowManager.getDatabase(T::class.java) +inline fun database(): DatabaseDefinition = database(T::class) + +inline fun database(kClass: KClass): DatabaseDefinition = FlowManager.getDatabase(kClass.java) /** * Easily get access to its [DatabaseDefinition] directly. */ -inline fun database(kClass: KClass, f: DatabaseDefinition.() -> R): R - = FlowManager.getDatabase(kClass.java).f() +inline fun database(kClass: KClass, f: DatabaseDefinition.() -> R): R = database(kClass).f() inline fun database(f: DatabaseDefinition.() -> Unit): DatabaseDefinition - = FlowManager.getDatabase(T::class.java).apply(f) + = database(T::class).apply(f) + +inline fun databaseForTable(kClass: KClass, f: DatabaseDefinition.() -> R): R + = databaseForTable(kClass).f() -fun databaseForTable(kClass: KClass, f: DatabaseDefinition.() -> R): R - = FlowManager.getDatabaseForTable(kClass.java).f() +inline fun databaseForTable(kClass: KClass): DatabaseDefinition = FlowManager.getDatabaseForTable(kClass.java) inline fun databaseForTable(f: DatabaseDefinition.() -> Unit): DatabaseDefinition - = FlowManager.getDatabaseForTable(T::class.java).apply(f) + = databaseForTable(T::class).apply(f) /** * Easily get access to its [DatabaseDefinition] directly. */ -inline fun databaseForTable(): DatabaseDefinition - = FlowManager.getDatabaseForTable(T::class.java) +inline fun databaseForTable(): DatabaseDefinition = databaseForTable(T::class) /** * Easily get its table name. */ inline fun tableName(): String - = FlowManager.getTableName(T::class.java) + = FlowManager.getTableName(T::class.java) /** * Easily get its [ModelAdapter]. From 62b0cbe605269bf11f509fbd57a87d82f2fe0cec Mon Sep 17 00:00:00 2001 From: fuzzagrosner Date: Mon, 4 Dec 2017 12:03:30 -0500 Subject: [PATCH 118/234] [model] create new instance of model inside loadFromCursor in order to prepare for immutable constructor support. --- .../processor/definition/BaseDefinition.kt | 14 ++++----- .../dbflow5/processor/definition/Methods.kt | 6 ++-- .../processor/definition/TableDefinition.kt | 5 ++-- .../dbflow5/models/OneToManyModels.kt | 12 ++++---- .../dbflow5/models/ParentChildCachingTest.kt | 4 +-- .../dbflow5/provider/ContentProviderTests.kt | 18 ++++++------ .../raizlabs/dbflow5/adapter/ModelAdapter.kt | 10 ------- .../dbflow5/adapter/RetrievalAdapter.kt | 15 ++++------ .../queriable/CacheableListModelLoader.kt | 5 ++-- .../adapter/queriable/CacheableModelLoader.kt | 4 +-- .../adapter/queriable/ListModelLoader.kt | 14 ++------- .../dbflow5/adapter/queriable/ModelLoader.kt | 19 +++++------- .../SingleKeyCacheableListModelLoader.kt | 5 ++-- .../SingleKeyCacheableModelLoader.kt | 6 ++-- .../adapter/queriable/SingleModelLoader.kt | 13 ++++----- .../dbflow5/provider/BaseProviderModel.kt | 26 +++++++++-------- .../provider/BaseSyncableProviderModel.kt | 29 ++++++++++--------- .../dbflow5/provider/ModelProvider.kt | 13 ++++----- .../raizlabs/dbflow5/query/CursorResult.kt | 23 ++++++++------- .../dbflow5/query/cache/ModelCache.kt | 14 ++++----- .../dbflow5/query/list/FlowCursorList.kt | 15 +++++----- .../raizlabs/dbflow5/structure/BaseModel.kt | 5 ++-- .../dbflow5/structure/NoModificationModel.kt | 5 ++-- .../dbflow5/structure/ReadOnlyModel.kt | 2 +- 24 files changed, 125 insertions(+), 157 deletions(-) diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/BaseDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/BaseDefinition.kt index ace9ece44..2f12591a1 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/BaseDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/BaseDefinition.kt @@ -115,13 +115,13 @@ abstract class BaseDefinition : TypeDefinition { protected fun setOutputClassName(postfix: String) { val outputName: String if (elementClassName == null) { - if (elementTypeName is ClassName) { - outputName = (elementTypeName as ClassName).simpleName() - } else if (elementTypeName is ParameterizedTypeName) { - outputName = (elementTypeName as ParameterizedTypeName).rawType.simpleName() - elementClassName = (elementTypeName as ParameterizedTypeName).rawType - } else { - outputName = elementTypeName.toString() + when (elementTypeName) { + is ClassName -> outputName = (elementTypeName as ClassName).simpleName() + is ParameterizedTypeName -> { + outputName = (elementTypeName as ParameterizedTypeName).rawType.simpleName() + elementClassName = (elementTypeName as ParameterizedTypeName).rawType + } + else -> outputName = elementTypeName.toString() } } else { outputName = elementClassName!!.simpleName() diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/Methods.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/Methods.kt index bf248470a..7c5fbeca9 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/Methods.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/Methods.kt @@ -439,11 +439,11 @@ class DeleteStatementQueryMethod(private val tableDefinition: TableDefinition) : class LoadFromCursorMethod(private val baseTableDefinition: BaseTableDefinition) : MethodDefinition { override val methodSpec: MethodSpec - get() = `override fun`(TypeName.VOID, "loadFromCursor", + get() = `override fun`(baseTableDefinition.parameterClassName!!, "loadFromCursor", param(ClassNames.FLOW_CURSOR, PARAM_CURSOR), - param(baseTableDefinition.parameterClassName!!, ModelUtils.variable), param(ClassNames.DATABASE_WRAPPER, ModelUtils.wrapper)) { modifiers(public, final) + statement("\$1T ${ModelUtils.variable} = new \$1T()", baseTableDefinition.parameterClassName) val index = AtomicInteger(0) val nameAllocator = NameAllocator() // unique names baseTableDefinition.columnDefinitions.forEach { @@ -463,7 +463,7 @@ class LoadFromCursorMethod(private val baseTableDefinition: BaseTableDefinition) if (baseTableDefinition is TableDefinition && baseTableDefinition.implementsLoadFromCursorListener) { statement("${ModelUtils.variable}.onLoadFromCursor($PARAM_CURSOR)") } - this + `return`(ModelUtils.variable) } diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/TableDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/TableDefinition.kt index 67a126b29..389ad4bb3 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/TableDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/TableDefinition.kt @@ -643,11 +643,12 @@ class TableDefinition(manager: ProcessorManager, element: TypeElement) : BaseTab `return`(true.L) } - `override fun`(TypeName.VOID, "load", param(elementClassName!!, "model"), + `override fun`(elementClassName!!, "load", param(elementClassName!!, "model"), param(ClassNames.DATABASE_WRAPPER, wrapper)) { modifiers(public, final) - statement("super.load(model, $wrapper)") + statement("\$T loaded = super.load(model, $wrapper)", elementClassName!!) statement("cacheAdapter.storeModelInCache(model)") + `return`("loaded") } } diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/OneToManyModels.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/OneToManyModels.kt index f789d1f2d..deb8ea829 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/OneToManyModels.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/OneToManyModels.kt @@ -19,27 +19,27 @@ class OneToManyModel(@PrimaryKey var name: String? = null) { var models: List? = null - @get:OneToMany(oneToManyMethods = arrayOf(OneToManyMethod.ALL)) + @get:OneToMany(oneToManyMethods = [OneToManyMethod.ALL]) var simpleModels by oneToMany { databaseForTable(OneToManyBaseModel::class) { select from OneToManyBaseModel::class } } - @OneToMany(oneToManyMethods = arrayOf(OneToManyMethod.ALL), isVariablePrivate = true, - variableName = "orders", efficientMethods = false) + @OneToMany(oneToManyMethods = [OneToManyMethod.ALL], isVariablePrivate = true, + variableName = "orders", efficientMethods = false) fun getRelatedOrders(wrapper: DatabaseWrapper): List { var localOrders = orders if (localOrders == null) { localOrders = (wrapper.select from TwoColumnModel::class where id.greaterThan(3)) - .queryList() + .queryList() } orders = localOrders return localOrders } - @OneToMany(oneToManyMethods = arrayOf(OneToManyMethod.DELETE), isVariablePrivate = true, - variableName = "models") + @OneToMany(oneToManyMethods = [OneToManyMethod.DELETE], isVariablePrivate = true, + variableName = "models") fun getRelatedModels(wrapper: DatabaseWrapper): List { var localModels = models if (localModels == null) { diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/ParentChildCachingTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/ParentChildCachingTest.kt index f734a5e2d..960013436 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/ParentChildCachingTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/ParentChildCachingTest.kt @@ -30,8 +30,8 @@ class ParentChildCachingTest : BaseUnitTest() { parent.save() parent = (select from TestModelParent::class).result!! - val parentChild = parent.child!! - parentChild.load() + var parentChild = parent.child!! + parentChild = parentChild.load()!! assertEquals(1, parentChild.id) assertEquals("Test child", parentChild.name) diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/provider/ContentProviderTests.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/provider/ContentProviderTests.kt index 9fa5ee3fb..344cb1bde 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/provider/ContentProviderTests.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/provider/ContentProviderTests.kt @@ -39,7 +39,7 @@ class ContentProviderTests : BaseUnitTest() { fun testContentProviderUtils() = database(ContentDatabase::class) { tables(NoteModel::class.java, ContentProviderModel::class.java) - val contentProviderModel = ContentProviderModel() + var contentProviderModel = ContentProviderModel() contentProviderModel.notes = "Test" var uri = ContentUtils.insert(mockContentResolver, TestContentProvider.ContentProviderModel.CONTENT_URI, contentProviderModel) assertEquals(TestContentProvider.ContentProviderModel.CONTENT_URI.toString() + "/" + contentProviderModel.id, uri.toString()) @@ -49,7 +49,7 @@ class ContentProviderTests : BaseUnitTest() { val update = ContentUtils.update(mockContentResolver, TestContentProvider.ContentProviderModel.CONTENT_URI, contentProviderModel) assertEquals(update.toLong(), 1) assertTrue(contentProviderModel.exists()) - contentProviderModel.load(this) + contentProviderModel = contentProviderModel.load(this)!! assertEquals("NewTest", contentProviderModel.notes) val noteModel = NoteModel() @@ -72,21 +72,21 @@ class ContentProviderTests : BaseUnitTest() { fun testContentProviderNative() = database(ContentDatabase::class) { tables(NoteModel::class.java, ContentProviderModel::class.java) - val contentProviderModel = ContentProviderModel(notes = "Test") + var contentProviderModel = ContentProviderModel(notes = "Test") contentProviderModel.insert() assertTrue(contentProviderModel.exists()) contentProviderModel.notes = "NewTest" contentProviderModel.update() - contentProviderModel.load(this) + contentProviderModel = contentProviderModel.load(this)!! assertEquals("NewTest", contentProviderModel.notes) - val noteModel = NoteModel(note = "Test", contentProviderModel = contentProviderModel) + var noteModel = NoteModel(note = "Test", contentProviderModel = contentProviderModel) noteModel.insert() noteModel.note = "NewTest" noteModel.update() - noteModel.load(this) + noteModel = noteModel.load(this)!! assertEquals("NewTest", noteModel.note) assertTrue(noteModel.exists()) @@ -114,10 +114,10 @@ class ContentProviderTests : BaseUnitTest() { assertEquals(testSyncableModel.name, "TestName") testSyncableModel = (select from TestSyncableModel::class - where (TestSyncableModel_Table.id.`is`(testSyncableModel.id))).result!! + where (TestSyncableModel_Table.id.`is`(testSyncableModel.id))).result!! - val fromContentProvider = TestSyncableModel(id = testSyncableModel.id) - fromContentProvider.load(this) + var fromContentProvider = TestSyncableModel(id = testSyncableModel.id) + fromContentProvider = fromContentProvider.load(this)!! assertEquals(fromContentProvider.name, testSyncableModel.name) assertEquals(fromContentProvider.id, testSyncableModel.id) diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/ModelAdapter.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/ModelAdapter.kt index 61533edfd..0b6115b0a 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/ModelAdapter.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/ModelAdapter.kt @@ -11,7 +11,6 @@ import com.raizlabs.dbflow5.annotation.Table import com.raizlabs.dbflow5.config.DatabaseDefinition import com.raizlabs.dbflow5.database.DatabaseStatement import com.raizlabs.dbflow5.database.DatabaseWrapper -import com.raizlabs.dbflow5.database.FlowCursor import com.raizlabs.dbflow5.query.property.IProperty import com.raizlabs.dbflow5.query.property.Property import com.raizlabs.dbflow5.structure.InvalidDBConfiguration @@ -136,15 +135,6 @@ abstract class ModelAdapter(databaseDefinition: DatabaseDefinition) fun getCompiledStatement(databaseWrapper: DatabaseWrapper): DatabaseStatement = databaseWrapper.compileStatement(compiledStatementQuery) - /** - * Creates a new [T] and Loads the cursor into a the object. - * - * @param cursor The cursor to load - * @return A new [T] - */ - fun loadFromCursor(cursor: FlowCursor, databaseWrapper: DatabaseWrapper): T = - newInstance().apply { loadFromCursor(cursor, this, databaseWrapper) } - override fun save(model: T, databaseWrapper: DatabaseWrapper): Boolean = modelSaver.save(model, databaseWrapper) diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/RetrievalAdapter.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/RetrievalAdapter.kt index 11ca26b7b..370eb2005 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/RetrievalAdapter.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/RetrievalAdapter.kt @@ -1,6 +1,5 @@ package com.raizlabs.dbflow5.adapter -import android.database.Cursor import com.raizlabs.dbflow5.adapter.queriable.ListModelLoader import com.raizlabs.dbflow5.adapter.queriable.SingleModelLoader import com.raizlabs.dbflow5.config.DatabaseDefinition @@ -92,23 +91,21 @@ abstract class RetrievalAdapter(databaseDefinition: DatabaseDefinition) } /** - * Force loads the model from the DB. Even if caching is enabled it will requery the object. + * Returns a new [model] based on the object passed in. Will not overwrite existing object. */ - open fun load(model: T, databaseWrapper: DatabaseWrapper) { + open fun load(model: T, databaseWrapper: DatabaseWrapper): T? = nonCacheableSingleModelLoader.load(databaseWrapper, (databaseWrapper.select from table - where getPrimaryConditionClause(model)).query, - model) - } + where getPrimaryConditionClause(model)).query) /** - * Assigns the [Cursor] data into the specified [T] + * Converts the specified [FlowCursor] into a new [T] * - * @param model The model to assign cursor data to * @param cursor The cursor to load into the model + * @param wrapper The database instance to use. */ - abstract fun loadFromCursor(cursor: FlowCursor, model: T, wrapper: DatabaseWrapper) + abstract fun loadFromCursor(cursor: FlowCursor, wrapper: DatabaseWrapper): T /** * @param model The model to query values from diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/CacheableListModelLoader.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/CacheableListModelLoader.kt index 549d583df..187047f7e 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/CacheableListModelLoader.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/CacheableListModelLoader.kt @@ -28,9 +28,8 @@ open class CacheableListModelLoader(modelClass: Class, val modelCache: ModelCache by lazy { cacheAdapter.modelCache } - override fun convertToData(cursor: FlowCursor, data: MutableList?, - databaseWrapper: DatabaseWrapper): MutableList { - val _data = data ?: arrayListOf() + override fun convertToData(cursor: FlowCursor, databaseWrapper: DatabaseWrapper): MutableList { + val _data = mutableListOf() val cacheValues = arrayOfNulls(cacheAdapter.cachingColumnSize) // Ensure that we aren't iterating over this cursor concurrently from different threads if (cursor.moveToFirst()) { diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/CacheableModelLoader.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/CacheableModelLoader.kt index 5b0f23d6f..09ca61bc4 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/CacheableModelLoader.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/CacheableModelLoader.kt @@ -39,13 +39,13 @@ open class CacheableModelLoader(modelClass: Class, * * @return A model from cache. */ - override fun convertToData(cursor: FlowCursor, data: T?, moveToFirst: Boolean, + override fun convertToData(cursor: FlowCursor, moveToFirst: Boolean, databaseWrapper: DatabaseWrapper): T? { return if (!moveToFirst || cursor.moveToFirst()) { val values = cacheAdapter.getCachingColumnValuesFromCursor( arrayOfNulls(cacheAdapter.cachingColumnSize), cursor) modelCache.addOrReload(cacheAdapter.getCachingId(values), cacheAdapter, modelAdapter, - cursor, databaseWrapper, data) + cursor, databaseWrapper) } else null } } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/ListModelLoader.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/ListModelLoader.kt index 1be3be9d1..3cbdf166e 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/ListModelLoader.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/ListModelLoader.kt @@ -9,20 +9,12 @@ import com.raizlabs.dbflow5.database.FlowCursor open class ListModelLoader(modelClass: Class) : ModelLoader>(modelClass) { - override fun load(cursor: FlowCursor?, data: MutableList?, - databaseWrapper: DatabaseWrapper): MutableList? { - val emptyData = data?.apply { clear() } ?: arrayListOf() - return super.load(cursor, emptyData, databaseWrapper) - } - - override fun convertToData(cursor: FlowCursor, data: MutableList?, + override fun convertToData(cursor: FlowCursor, databaseWrapper: DatabaseWrapper): MutableList { - val retData = data?.apply { clear() } ?: arrayListOf() + val retData = arrayListOf() if (cursor.moveToFirst()) { do { - val model = instanceAdapter.newInstance() - instanceAdapter.loadFromCursor(cursor, model, databaseWrapper) - retData.add(model) + retData.add(instanceAdapter.loadFromCursor(cursor, databaseWrapper)) } while (cursor.moveToNext()) } return retData diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/ModelLoader.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/ModelLoader.kt index 744d81265..b31c42195 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/ModelLoader.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/ModelLoader.kt @@ -2,8 +2,8 @@ package com.raizlabs.dbflow5.adapter.queriable import android.database.Cursor import android.database.sqlite.SQLiteDatabase -import com.raizlabs.dbflow5.config.FlowManager import com.raizlabs.dbflow5.adapter.InstanceAdapter +import com.raizlabs.dbflow5.config.FlowManager import com.raizlabs.dbflow5.database.DatabaseWrapper import com.raizlabs.dbflow5.database.FlowCursor @@ -11,7 +11,7 @@ import com.raizlabs.dbflow5.database.FlowCursor * Description: Represents how models load from DB. It will query a [SQLiteDatabase] * and query for a [Cursor]. Then the cursor is used to convert itself into an object. */ -abstract class ModelLoader(val modelClass: Class) { +abstract class ModelLoader(val modelClass: Class) { val instanceAdapter: InstanceAdapter by lazy { FlowManager.getInstanceAdapter(modelClass) } @@ -23,16 +23,11 @@ abstract class ModelLoader(val modelClass: Class(val modelClass: Class(tModelClass: Class, cacheAdapter: CacheAdapter) : CacheableListModelLoader(tModelClass, cacheAdapter) { - override fun convertToData(cursor: FlowCursor, data: MutableList?, - databaseWrapper: DatabaseWrapper): MutableList { - val _data = data ?: arrayListOf() + override fun convertToData(cursor: FlowCursor, databaseWrapper: DatabaseWrapper): MutableList { + val _data = arrayListOf() var cacheValue: Any? // Ensure that we aren't iterating over this cursor concurrently from different threads if (cursor.moveToFirst()) { diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/SingleKeyCacheableModelLoader.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/SingleKeyCacheableModelLoader.kt index 831a2f370..bb04ad288 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/SingleKeyCacheableModelLoader.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/SingleKeyCacheableModelLoader.kt @@ -20,12 +20,10 @@ class SingleKeyCacheableModelLoader(modelClass: Class, * * @return A model from cache. */ - override fun convertToData(cursor: FlowCursor, data: T?, - moveToFirst: Boolean, - databaseWrapper: DatabaseWrapper): T? { + override fun convertToData(cursor: FlowCursor, moveToFirst: Boolean, databaseWrapper: DatabaseWrapper): T? { return if (!moveToFirst || cursor.moveToFirst()) { val value = cacheAdapter.getCachingColumnValueFromCursor(cursor) - modelCache.addOrReload(value, cacheAdapter, modelAdapter, cursor, databaseWrapper, data) + modelCache.addOrReload(value, cacheAdapter, modelAdapter, cursor, databaseWrapper) } else null } } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/SingleModelLoader.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/SingleModelLoader.kt index f3380daa9..cd6e81ea9 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/SingleModelLoader.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/SingleModelLoader.kt @@ -9,20 +9,17 @@ import com.raizlabs.dbflow5.database.FlowCursor open class SingleModelLoader(modelClass: Class) : ModelLoader(modelClass) { - open fun convertToData(cursor: FlowCursor, data: T?, + open fun convertToData(cursor: FlowCursor, moveToFirst: Boolean, databaseWrapper: DatabaseWrapper): T? { - var _data = data + var _data: T? = null if (!moveToFirst || cursor.moveToFirst()) { - if (_data == null) { - _data = instanceAdapter.newInstance() - } - instanceAdapter.loadFromCursor(cursor, _data, databaseWrapper) + _data = instanceAdapter.loadFromCursor(cursor, databaseWrapper) } return _data } - override fun convertToData(cursor: FlowCursor, data: T?, databaseWrapper: DatabaseWrapper): T? { - return convertToData(cursor, data, true, databaseWrapper) + override fun convertToData(cursor: FlowCursor, databaseWrapper: DatabaseWrapper): T? { + return convertToData(cursor, true, databaseWrapper) } } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/provider/BaseProviderModel.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/provider/BaseProviderModel.kt index 30ce0b0b1..e6e1522e1 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/provider/BaseProviderModel.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/provider/BaseProviderModel.kt @@ -2,11 +2,11 @@ package com.raizlabs.dbflow5.provider import android.content.ContentProvider import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.database.DatabaseWrapper +import com.raizlabs.dbflow5.database.FlowCursor import com.raizlabs.dbflow5.query.OperatorGroup import com.raizlabs.dbflow5.structure.BaseModel import com.raizlabs.dbflow5.structure.Model -import com.raizlabs.dbflow5.database.DatabaseWrapper -import com.raizlabs.dbflow5.database.FlowCursor /** * Description: Provides a base implementation of a [Model] backed @@ -41,29 +41,31 @@ abstract class BaseProviderModel : BaseModel(), ModelProvider { */ override fun exists(wrapper: DatabaseWrapper): Boolean { val cursor = ContentUtils.query(FlowManager.context.contentResolver, - queryUri, modelAdapter.getPrimaryConditionClause(this), "") + queryUri, modelAdapter.getPrimaryConditionClause(this), "") val exists = cursor != null && cursor.count > 0 cursor?.close() return exists } - override fun load(whereOperatorGroup: OperatorGroup, - orderBy: String?, - wrapper: DatabaseWrapper, - vararg columns: String?) { + @Suppress("UNCHECKED_CAST") + override fun load(whereOperatorGroup: OperatorGroup, + orderBy: String?, + wrapper: DatabaseWrapper, + vararg columns: String?): T? { val cursor = ContentUtils.query(FlowManager.context.contentResolver, - queryUri, whereOperatorGroup, orderBy, *columns) + queryUri, whereOperatorGroup, orderBy, *columns) if (cursor != null) { val flowCursor = FlowCursor.from(cursor) if (flowCursor.moveToFirst()) { - modelAdapter.loadFromCursor(flowCursor, this, wrapper) + val model: T = modelAdapter.loadFromCursor(flowCursor, wrapper) as T flowCursor.close() + return model } } + return null } - override fun load(wrapper: DatabaseWrapper) { - load(modelAdapter.getPrimaryConditionClause(this), "", wrapper) - } + @Suppress("UNCHECKED_CAST") + override fun load(wrapper: DatabaseWrapper): T? = load(modelAdapter.getPrimaryConditionClause(this), "", wrapper) as T? } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/provider/BaseSyncableProviderModel.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/provider/BaseSyncableProviderModel.kt index 2c5ac9154..f2ef03a41 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/provider/BaseSyncableProviderModel.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/provider/BaseSyncableProviderModel.kt @@ -1,13 +1,12 @@ package com.raizlabs.dbflow5.provider import android.content.ContentProvider - import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.database.DatabaseWrapper +import com.raizlabs.dbflow5.database.FlowCursor import com.raizlabs.dbflow5.query.OperatorGroup import com.raizlabs.dbflow5.structure.BaseModel import com.raizlabs.dbflow5.structure.Model -import com.raizlabs.dbflow5.database.DatabaseWrapper -import com.raizlabs.dbflow5.database.FlowCursor /** * Description: Provides a base implementation of a [Model] backed @@ -30,27 +29,29 @@ abstract class BaseSyncableProviderModel : BaseModel(), ModelProvider { } override fun delete(wrapper: DatabaseWrapper): Boolean - = super.delete(wrapper) && ContentUtils.delete(deleteUri, wrapper) > 0 + = super.delete(wrapper) && ContentUtils.delete(deleteUri, wrapper) > 0 override fun update(wrapper: DatabaseWrapper): Boolean - = super.update(wrapper) && ContentUtils.update(updateUri, wrapper) > 0 + = super.update(wrapper) && ContentUtils.update(updateUri, wrapper) > 0 - override fun load(whereOperatorGroup: OperatorGroup, - orderBy: String?, - wrapper: DatabaseWrapper, - vararg columns: String?) { + @Suppress("UNCHECKED_CAST") + override fun load(whereOperatorGroup: OperatorGroup, + orderBy: String?, + wrapper: DatabaseWrapper, + vararg columns: String?): T? { val cursor = ContentUtils.query(FlowManager.context.contentResolver, - queryUri, whereOperatorGroup, orderBy, *columns) + queryUri, whereOperatorGroup, orderBy, *columns) cursor?.let { val flowCursor = FlowCursor.from(cursor) if (flowCursor.moveToFirst()) { - modelAdapter.loadFromCursor(flowCursor, this, wrapper) + val model: T = modelAdapter.loadFromCursor(flowCursor, wrapper) as T flowCursor.close() + return model } } + return null } - override fun load(wrapper: DatabaseWrapper) { - load(modelAdapter.getPrimaryConditionClause(this), "", wrapper) - } + @Suppress("UNCHECKED_CAST") + override fun load(wrapper: DatabaseWrapper): T? = load(modelAdapter.getPrimaryConditionClause(this), "", wrapper) as T? } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/provider/ModelProvider.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/provider/ModelProvider.kt index 2b009a515..516252331 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/provider/ModelProvider.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/provider/ModelProvider.kt @@ -2,10 +2,9 @@ package com.raizlabs.dbflow5.provider import android.content.ContentResolver import android.net.Uri - +import com.raizlabs.dbflow5.database.DatabaseWrapper import com.raizlabs.dbflow5.query.Operator import com.raizlabs.dbflow5.query.OperatorGroup -import com.raizlabs.dbflow5.database.DatabaseWrapper /** * Description: A base interface for Models that are connected to providers. @@ -40,14 +39,14 @@ interface ModelProvider { * @param orderBy The order by without the ORDER BY * @param columns The list of columns to select. Leave blank for * */ - fun load(whereOperatorGroup: OperatorGroup, + fun load(whereOperatorGroup: OperatorGroup, orderBy: String?, wrapper: DatabaseWrapper, - vararg columns: String?) + vararg columns: String?) : T? /** - * Queries the [ContentResolver] of the app based on the primary keys of the object and populates - * this object with the first row from the returned data. + * Queries the [ContentResolver] of the app based on the primary keys of the object and returns a + * new object with the first row from the returned data. */ - fun load(wrapper: DatabaseWrapper) + fun load(wrapper: DatabaseWrapper): T? } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/CursorResult.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/CursorResult.kt index e783c5505..30a90566b 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/CursorResult.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/CursorResult.kt @@ -1,12 +1,12 @@ package com.raizlabs.dbflow5.query import android.database.Cursor -import com.raizlabs.dbflow5.config.FlowManager -import com.raizlabs.dbflow5.query.list.FlowCursorIterator -import com.raizlabs.dbflow5.query.list.IFlowCursorIterator import com.raizlabs.dbflow5.adapter.InstanceAdapter +import com.raizlabs.dbflow5.config.FlowManager import com.raizlabs.dbflow5.database.DatabaseWrapper import com.raizlabs.dbflow5.database.FlowCursor +import com.raizlabs.dbflow5.query.list.FlowCursorIterator +import com.raizlabs.dbflow5.query.list.IFlowCursorIterator /** * Description: A class that contains a [Cursor] and handy methods for retrieving data from it. @@ -46,7 +46,7 @@ class CursorResult internal constructor(modelClass: Class, cursor: C * @return A [List] of items from this object. You must call [.close] when finished. */ fun toList(): List = cursor?.let { cursor -> - retrievalAdapter.listModelLoader.convertToData(cursor, null, databaseWrapper) + retrievalAdapter.listModelLoader.convertToData(cursor, databaseWrapper) } ?: arrayListOf() /** @@ -64,7 +64,7 @@ class CursorResult internal constructor(modelClass: Class, cursor: C fun toCustomList(customClass: Class): List { return cursor?.let { cursor -> return@let FlowManager.getQueryModelAdapter(customClass) - .listModelLoader.convertToData(cursor, null, databaseWrapper) + .listModelLoader.convertToData(cursor, databaseWrapper) } ?: arrayListOf() } @@ -72,7 +72,8 @@ class CursorResult internal constructor(modelClass: Class, cursor: C * @return Converts the [Cursor] to a [List] of [T] and then closes it. */ fun toCustomListClose(customClass: Class): List { - val customList = FlowManager.getQueryModelAdapter(customClass).listModelLoader.load(cursor, databaseWrapper) ?: arrayListOf() + val customList = FlowManager.getQueryModelAdapter(customClass).listModelLoader + .load(cursor, databaseWrapper) ?: arrayListOf() close() return customList } @@ -80,7 +81,9 @@ class CursorResult internal constructor(modelClass: Class, cursor: C /** * @return The first [T] of items from the contained [Cursor]. You must call [.close] when finished. */ - fun toModel(): T? = cursor?.let { cursor -> retrievalAdapter.singleModelLoader.convertToData(cursor, null, databaseWrapper) } + fun toModel(): T? = cursor?.let { cursor -> + retrievalAdapter.singleModelLoader.convertToData(cursor, databaseWrapper) + } /** * @return Converts the [Cursor] into the first [T] from the cursor and then closes it. @@ -97,7 +100,7 @@ class CursorResult internal constructor(modelClass: Class, cursor: C fun toCustomModel(customClass: Class): TCustom? { return if (cursor != null) FlowManager.getQueryModelAdapter(customClass) - .singleModelLoader.convertToData(cursor!!, null, databaseWrapper) + .singleModelLoader.convertToData(cursor!!, databaseWrapper) else null } @@ -114,7 +117,7 @@ class CursorResult internal constructor(modelClass: Class, cursor: C var model: T? = null cursor?.let { cursor -> if (cursor.moveToPosition(position.toInt())) { - model = retrievalAdapter.singleModelLoader.convertToData(cursor, null, false, databaseWrapper) + model = retrievalAdapter.singleModelLoader.convertToData(cursor, false, databaseWrapper) } } return model!! @@ -123,7 +126,7 @@ class CursorResult internal constructor(modelClass: Class, cursor: C override fun iterator(): FlowCursorIterator = FlowCursorIterator(this) override fun iterator(startingLocation: Int, limit: Long): FlowCursorIterator = - FlowCursorIterator(this, startingLocation, limit) + FlowCursorIterator(this, startingLocation, limit) override fun cursor(): Cursor? = cursor diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/cache/ModelCache.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/cache/ModelCache.kt index 610f4f615..3be74a0c3 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/cache/ModelCache.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/cache/ModelCache.kt @@ -15,10 +15,10 @@ abstract class ModelCache * @param cache The arbitrary underlying cache class. */ ( - /** - * @return The cache that's backing this cache. - */ - val cache: CacheClass) { + /** + * @return The cache that's backing this cache. + */ + val cache: CacheClass) { /** * Adds a model to this cache. @@ -59,14 +59,12 @@ inline fun ModelCache.addOrReload(cacheValue: Any?, cacheAdapter: CacheAdapter, modelAdapter: ModelAdapter, cursor: FlowCursor, - databaseWrapper: DatabaseWrapper, - data: T? = null): T { + databaseWrapper: DatabaseWrapper): T { var model: T? = get(cacheValue) if (model != null) { cacheAdapter.reloadRelationships(model, cursor, databaseWrapper) } else { - model = data ?: modelAdapter.newInstance() - modelAdapter.loadFromCursor(cursor, model, databaseWrapper) + model = modelAdapter.loadFromCursor(cursor, databaseWrapper) addModel(cacheValue, model) } return model diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowCursorList.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowCursorList.kt index 6c56a90b8..f40291a07 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowCursorList.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowCursorList.kt @@ -2,11 +2,11 @@ package com.raizlabs.dbflow5.query.list import android.database.Cursor import android.widget.ListView +import com.raizlabs.dbflow5.adapter.InstanceAdapter import com.raizlabs.dbflow5.config.FlowLog import com.raizlabs.dbflow5.config.FlowManager -import com.raizlabs.dbflow5.query.ModelQueriable -import com.raizlabs.dbflow5.adapter.InstanceAdapter import com.raizlabs.dbflow5.database.FlowCursor +import com.raizlabs.dbflow5.query.ModelQueriable /** * Description: A non-modifiable, cursor-backed list that you can use in [ListView] or other data sources. @@ -45,8 +45,7 @@ class FlowCursorList private constructor(builder: Builder) : IFlowCu throwIfCursorClosed() warnEmptyCursor() return cursor?.let { cursor -> - instanceAdapter.listModelLoader.convertToData(cursor, null, - FlowManager.getDatabaseForTable(table)) + instanceAdapter.listModelLoader.convertToData(cursor, FlowManager.getDatabaseForTable(table)) } ?: listOf() } @@ -70,7 +69,7 @@ class FlowCursorList private constructor(builder: Builder) : IFlowCu override operator fun iterator(): FlowCursorIterator = FlowCursorIterator(this) override fun iterator(startingLocation: Int, limit: Long): FlowCursorIterator = - FlowCursorIterator(this, startingLocation, limit) + FlowCursorIterator(this, startingLocation, limit) /** * Register listener for when cursor refreshes. @@ -113,9 +112,9 @@ class FlowCursorList private constructor(builder: Builder) : IFlowCu val cursor = unpackCursor() return if (cursor.moveToPosition(position.toInt())) { instanceAdapter.singleModelLoader.convertToData( - FlowCursor.from(cursor), null, false, - FlowManager.getDatabaseForTable(table)) - ?: throw IndexOutOfBoundsException("Invalid item at position $position. Check your cursor data.") + FlowCursor.from(cursor), false, + FlowManager.getDatabaseForTable(table)) + ?: throw IndexOutOfBoundsException("Invalid item at position $position. Check your cursor data.") } else { throw IndexOutOfBoundsException("Invalid item at position $position. Check your cursor data.") } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/structure/BaseModel.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/structure/BaseModel.kt index 23eaccaba..999ff3321 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/structure/BaseModel.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/structure/BaseModel.kt @@ -21,9 +21,8 @@ open class BaseModel : Model { @delegate:Transient val modelAdapter: ModelAdapter by lazy { FlowManager.getModelAdapter(javaClass) } - override fun load(wrapper: DatabaseWrapper) { - modelAdapter.load(this, wrapper) - } + @Suppress("UNCHECKED_CAST") + override fun load(wrapper: DatabaseWrapper): T? = modelAdapter.load(this, wrapper) as T? override fun save(wrapper: DatabaseWrapper): Boolean = modelAdapter.save(this@BaseModel, wrapper) diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/structure/NoModificationModel.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/structure/NoModificationModel.kt index bf1b36a60..e1b84ca8c 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/structure/NoModificationModel.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/structure/NoModificationModel.kt @@ -14,9 +14,8 @@ abstract class NoModificationModel : ReadOnlyModel { override fun exists(wrapper: DatabaseWrapper): Boolean = retrievalAdapter.exists(this, wrapper) - override fun load(wrapper: DatabaseWrapper) { - retrievalAdapter.load(this, wrapper) - } + @Suppress("UNCHECKED_CAST") + override fun load(wrapper: DatabaseWrapper): T? = retrievalAdapter.load(this, wrapper) as T? /** * Gets thrown when an operation is not valid for the SQL View diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/structure/ReadOnlyModel.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/structure/ReadOnlyModel.kt index 2d202d30e..cc8ad9b1e 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/structure/ReadOnlyModel.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/structure/ReadOnlyModel.kt @@ -7,7 +7,7 @@ interface ReadOnlyModel { /** * Loads from the database the most recent version of the model based on it's primary keys. */ - fun load(wrapper: DatabaseWrapper) + fun load(wrapper: DatabaseWrapper): T? /** * @return true if this object exists in the DB. It combines all of it's primary key fields From 1b7c6eb53be86d5e1b0ff6df3fbdb4bc0a2d1fca Mon Sep 17 00:00:00 2001 From: fuzzagrosner Date: Mon, 4 Dec 2017 12:42:36 -0500 Subject: [PATCH 119/234] [content] return 1 if insert succeeds. --- .../raizlabs/dbflow5/provider/BaseProviderModel.kt | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/provider/BaseProviderModel.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/provider/BaseProviderModel.kt index e6e1522e1..7445c61af 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/provider/BaseProviderModel.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/provider/BaseProviderModel.kt @@ -21,18 +21,17 @@ abstract class BaseProviderModel : BaseModel(), ModelProvider { override fun save(wrapper: DatabaseWrapper): Boolean { val count = ContentUtils.update(updateUri, this) return if (count == 0) { - ContentUtils.insert(insertUri, this) != null + insert(wrapper) > 0 } else { count > 0 } } - override fun update(wrapper: DatabaseWrapper): Boolean = ContentUtils.update(updateUri, this) > 0 + override fun update(wrapper: DatabaseWrapper): Boolean + = ContentUtils.update(updateUri, this) > 0 - override fun insert(wrapper: DatabaseWrapper): Long { - ContentUtils.insert(insertUri, wrapper) - return 0 - } + override fun insert(wrapper: DatabaseWrapper): Long + = if (ContentUtils.insert(insertUri, wrapper) != null) 1 else 0 /** * Runs a query on the [ContentProvider] to see if it returns data. From 8ab44a2ddaba0ddce986590547d1d4f199c6abf2 Mon Sep 17 00:00:00 2001 From: fuzzagrosner Date: Mon, 4 Dec 2017 12:53:27 -0500 Subject: [PATCH 120/234] [cursorlist] rename cursor() to cursor property. --- .../dbflow5/query/list/FlowCursorListTest.kt | 2 +- .../raizlabs/dbflow5/query/CursorResult.kt | 35 +++++++++--------- .../dbflow5/query/list/FlowCursorIterator.kt | 2 +- .../dbflow5/query/list/FlowCursorList.kt | 37 ++++++++++--------- .../dbflow5/query/list/FlowQueryList.kt | 34 ++++++++--------- .../dbflow5/query/list/IFlowCursorIterator.kt | 2 +- 6 files changed, 56 insertions(+), 56 deletions(-) diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/query/list/FlowCursorListTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/query/list/FlowCursorListTest.kt index 322fe3215..bad7e668a 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/query/list/FlowCursorListTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/query/list/FlowCursorListTest.kt @@ -25,7 +25,7 @@ class FlowCursorListTest : BaseUnitTest() { .cursor(cursor) .build() - assertEquals(cursor, list.cursor()) + assertEquals(cursor, list.cursor) } } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/CursorResult.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/CursorResult.kt index 30a90566b..512b774e5 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/CursorResult.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/CursorResult.kt @@ -18,14 +18,14 @@ class CursorResult internal constructor(modelClass: Class, cursor: C private val retrievalAdapter: InstanceAdapter - private var cursor: FlowCursor? = null + private var _cursor: FlowCursor? = null override val count: Long - get() = cursor?.count?.toLong() ?: 0 + get() = _cursor?.count?.toLong() ?: 0 init { if (cursor != null) { - this.cursor = FlowCursor.from(cursor) + this._cursor = FlowCursor.from(cursor) } retrievalAdapter = FlowManager.getInstanceAdapter(modelClass) } @@ -34,18 +34,18 @@ class CursorResult internal constructor(modelClass: Class, cursor: C * Swaps the current cursor and will close existing one. */ fun swapCursor(cursor: FlowCursor?) { - this.cursor?.let { _cursor -> + this._cursor?.let { _cursor -> if (!_cursor.isClosed) { _cursor.close() } } - this.cursor = cursor + this._cursor = cursor } /** * @return A [List] of items from this object. You must call [.close] when finished. */ - fun toList(): List = cursor?.let { cursor -> + fun toList(): List = _cursor?.let { cursor -> retrievalAdapter.listModelLoader.convertToData(cursor, databaseWrapper) } ?: arrayListOf() @@ -53,7 +53,7 @@ class CursorResult internal constructor(modelClass: Class, cursor: C * @return Converts the [Cursor] to a [List] of [T] and then closes it. */ fun toListClose(): List { - val list = retrievalAdapter.listModelLoader.load(cursor, databaseWrapper) ?: arrayListOf() + val list = retrievalAdapter.listModelLoader.load(_cursor, databaseWrapper) ?: arrayListOf() close() return list } @@ -62,7 +62,7 @@ class CursorResult internal constructor(modelClass: Class, cursor: C * @return A [List] of items from this object. You must call [.close] when finished. */ fun toCustomList(customClass: Class): List { - return cursor?.let { cursor -> + return _cursor?.let { cursor -> return@let FlowManager.getQueryModelAdapter(customClass) .listModelLoader.convertToData(cursor, databaseWrapper) } ?: arrayListOf() @@ -73,7 +73,7 @@ class CursorResult internal constructor(modelClass: Class, cursor: C */ fun toCustomListClose(customClass: Class): List { val customList = FlowManager.getQueryModelAdapter(customClass).listModelLoader - .load(cursor, databaseWrapper) ?: arrayListOf() + .load(_cursor, databaseWrapper) ?: arrayListOf() close() return customList } @@ -81,7 +81,7 @@ class CursorResult internal constructor(modelClass: Class, cursor: C /** * @return The first [T] of items from the contained [Cursor]. You must call [.close] when finished. */ - fun toModel(): T? = cursor?.let { cursor -> + fun toModel(): T? = _cursor?.let { cursor -> retrievalAdapter.singleModelLoader.convertToData(cursor, databaseWrapper) } @@ -89,7 +89,7 @@ class CursorResult internal constructor(modelClass: Class, cursor: C * @return Converts the [Cursor] into the first [T] from the cursor and then closes it. */ fun toModelClose(): T? { - val model = retrievalAdapter.singleModelLoader.load(cursor, databaseWrapper) + val model = retrievalAdapter.singleModelLoader.load(_cursor, databaseWrapper) close() return model } @@ -98,9 +98,9 @@ class CursorResult internal constructor(modelClass: Class, cursor: C * @return The first [T] of items from the contained [Cursor]. You must call [.close] when finished. */ fun toCustomModel(customClass: Class): TCustom? { - return if (cursor != null) + return if (_cursor != null) FlowManager.getQueryModelAdapter(customClass) - .singleModelLoader.convertToData(cursor!!, databaseWrapper) + .singleModelLoader.convertToData(_cursor!!, databaseWrapper) else null } @@ -108,14 +108,14 @@ class CursorResult internal constructor(modelClass: Class, cursor: C * @return Converts the [Cursor] to a [T] and then closes it. */ fun toCustomModelClose(customClass: Class): TCustom? { - val customList = FlowManager.getQueryModelAdapter(customClass).singleModelLoader.load(cursor, databaseWrapper) + val customList = FlowManager.getQueryModelAdapter(customClass).singleModelLoader.load(_cursor, databaseWrapper) close() return customList } override fun get(position: Long): T { var model: T? = null - cursor?.let { cursor -> + _cursor?.let { cursor -> if (cursor.moveToPosition(position.toInt())) { model = retrievalAdapter.singleModelLoader.convertToData(cursor, false, databaseWrapper) } @@ -128,10 +128,11 @@ class CursorResult internal constructor(modelClass: Class, cursor: C override fun iterator(startingLocation: Int, limit: Long): FlowCursorIterator = FlowCursorIterator(this, startingLocation, limit) - override fun cursor(): Cursor? = cursor + override val cursor: Cursor? + get() = _cursor override fun close() { - cursor?.close() + _cursor?.close() } } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowCursorIterator.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowCursorIterator.kt index 1ae1fbfb1..24f3f32eb 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowCursorIterator.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowCursorIterator.kt @@ -17,7 +17,7 @@ class FlowCursorIterator constructor(cursorList: IFlowCursorIterator) : this(cursorList, 0, cursorList.count) init { - cursorList.cursor()?.let { cursor -> + cursorList.cursor?.let { cursor -> // request larger than actual count. if (this.count > cursor.count - startingLocation) { this.count = (cursor.count - startingLocation).toLong() diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowCursorList.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowCursorList.kt index f40291a07..354592d13 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowCursorList.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowCursorList.kt @@ -28,7 +28,7 @@ class FlowCursorList private constructor(builder: Builder) : IFlowCu val table: Class val modelQueriable: ModelQueriable - private var cursor: FlowCursor? = null + private var _cursor: FlowCursor? = null private val cursorFunc: () -> FlowCursor internal val instanceAdapter: InstanceAdapter @@ -44,7 +44,7 @@ class FlowCursorList private constructor(builder: Builder) : IFlowCu unpackCursor() throwIfCursorClosed() warnEmptyCursor() - return cursor?.let { cursor -> + return _cursor?.let { cursor -> instanceAdapter.listModelLoader.convertToData(cursor, FlowManager.getDatabaseForTable(table)) } ?: listOf() } @@ -93,7 +93,7 @@ class FlowCursorList private constructor(builder: Builder) : IFlowCu fun refresh() { val cursor = unpackCursor() cursor.close() - this.cursor = modelQueriable.query() + this._cursor = modelQueriable.query() synchronized(cursorRefreshListenerSet) { cursorRefreshListenerSet.forEach { listener -> listener.onCursorRefreshed(this) } } @@ -128,7 +128,7 @@ class FlowCursorList private constructor(builder: Builder) : IFlowCu unpackCursor() throwIfCursorClosed() warnEmptyCursor() - return (cursor?.count ?: 0).toLong() + return (_cursor?.count ?: 0).toLong() } /** @@ -136,32 +136,33 @@ class FlowCursorList private constructor(builder: Builder) : IFlowCu */ override fun close() { warnEmptyCursor() - cursor?.close() - cursor = null + _cursor?.close() + _cursor = null } - override fun cursor(): Cursor? { - unpackCursor() - throwIfCursorClosed() - warnEmptyCursor() - return cursor - } + override val cursor: Cursor? + get() { + unpackCursor() + throwIfCursorClosed() + warnEmptyCursor() + return _cursor + } private fun unpackCursor(): Cursor { - if (cursor == null) { - cursor = cursorFunc() + if (_cursor == null) { + _cursor = cursorFunc() } - return cursor!! + return _cursor!! } private fun throwIfCursorClosed() { - if (cursor?.isClosed == true) { + if (_cursor?.isClosed == true) { throw IllegalStateException("Cursor has been closed for FlowCursorList") } } private fun warnEmptyCursor() { - if (cursor == null) { + if (_cursor == null) { FlowLog.log(FlowLog.Level.W, "Cursor was null for FlowCursorList") } } @@ -170,7 +171,7 @@ class FlowCursorList private constructor(builder: Builder) : IFlowCu * @return A new [Builder] that contains the same cache, query statement, and other * underlying data, but allows for modification. */ - fun newBuilder(): Builder = Builder(modelQueriable).cursor(cursor()) + fun newBuilder(): Builder = Builder(modelQueriable).cursor(_cursor) /** * Provides easy way to construct a [FlowCursorList]. diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowQueryList.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowQueryList.kt index c1df2c309..18f6dc4cb 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowQueryList.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowQueryList.kt @@ -3,9 +3,9 @@ package com.raizlabs.dbflow5.query.list import android.database.Cursor import android.os.Handler import android.os.Looper -import com.raizlabs.dbflow5.query.list.FlowCursorList.OnCursorRefreshListener -import com.raizlabs.dbflow5.query.ModelQueriable import com.raizlabs.dbflow5.adapter.InstanceAdapter +import com.raizlabs.dbflow5.query.ModelQueriable +import com.raizlabs.dbflow5.query.list.FlowCursorList.OnCursorRefreshListener import com.raizlabs.dbflow5.transaction.DefaultTransactionQueue import com.raizlabs.dbflow5.transaction.Transaction @@ -17,10 +17,10 @@ import com.raizlabs.dbflow5.transaction.Transaction * on the underlying table. */ class FlowQueryList( - /** - * Holds the table cursor - */ - val internalCursorList: FlowCursorList) + /** + * Holds the table cursor + */ + val internalCursorList: FlowCursorList) : List, IFlowCursorIterator { private var pendingRefresh = false @@ -47,9 +47,9 @@ class FlowQueryList( } internal constructor(builder: Builder) : this( - internalCursorList = FlowCursorList.Builder(builder.modelQueriable) - .cursor(builder.cursor) - .build() + internalCursorList = FlowCursorList.Builder(builder.modelQueriable) + .cursor(builder.cursor) + .build() ) fun addOnCursorRefreshListener(onCursorRefreshListener: OnCursorRefreshListener) { @@ -90,6 +90,7 @@ class FlowQueryList( REFRESH_HANDLER.post(refreshRunnable) } + /** * Checks to see if the table contains the object only if its a [T] * @@ -114,13 +115,10 @@ class FlowQueryList( return contains } - override fun get(position: Long): T { - return internalCursorList.get(position) - } + override fun get(position: Long): T = internalCursorList[position] - override fun cursor(): Cursor? { - return internalCursorList.cursor() - } + override val cursor: Cursor? + get() = internalCursorList.cursor /** * Returns the item from the backing [FlowCursorList]. First call @@ -134,7 +132,7 @@ class FlowQueryList( override fun indexOf(element: T): Int { throw UnsupportedOperationException( - "We cannot determine which index in the table this item exists at efficiently") + "We cannot determine which index in the table this item exists at efficiently") } override fun isEmpty(): Boolean { @@ -155,7 +153,7 @@ class FlowQueryList( override fun lastIndexOf(element: T): Int { throw UnsupportedOperationException( - "We cannot determine which index in the table this item exists at efficiently") + "We cannot determine which index in the table this item exists at efficiently") } /** @@ -196,7 +194,7 @@ class FlowQueryList( internal constructor(cursorList: FlowCursorList) { table = cursorList.table - cursor = cursorList.cursor() + cursor = cursorList.cursor modelQueriable = cursorList.modelQueriable } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/IFlowCursorIterator.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/IFlowCursorIterator.kt index c28237cf0..5c6f22f3c 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/IFlowCursorIterator.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/IFlowCursorIterator.kt @@ -23,7 +23,7 @@ interface IFlowCursorIterator : Closeable, Iterable { /** * @return The cursor. */ - fun cursor(): Cursor? + val cursor: Cursor? override fun iterator(): FlowCursorIterator From 5a9fd369b23194c0dd8c5b2bdbd23bdb40ea5d27 Mon Sep 17 00:00:00 2001 From: fuzzagrosner Date: Mon, 4 Dec 2017 13:06:44 -0500 Subject: [PATCH 121/234] [cursor] erase usages of Cursor and replace with FlowCursor. --- .../raizlabs/dbflow5/rx/query/RXQueriable.kt | 8 ++--- .../dbflow5/rx/query/RXQueriableImpl.kt | 14 ++++---- .../raizlabs/dbflow5/rx2/query/RXQueriable.kt | 8 ++--- .../dbflow5/rx2/query/RXQueriableImpl.kt | 12 +++---- .../dbflow5/models/ForeignKeyModels.kt | 12 +++---- .../raizlabs/dbflow5/rx/query/RXQueryTests.kt | 32 ++++++++--------- .../dbflow5/adapter/queriable/ModelLoader.kt | 8 ++--- .../raizlabs/dbflow5/provider/ContentUtils.kt | 35 +++++++++---------- .../raizlabs/dbflow5/query/CursorResult.kt | 19 +++++----- .../dbflow5/query/LoadFromCursorListener.kt | 7 ++-- .../raizlabs/dbflow5/query/ModelQueriable.kt | 4 +-- .../java/com/raizlabs/dbflow5/query/Where.kt | 29 ++++++++------- .../dbflow5/query/list/FlowCursorList.kt | 13 ++++--- .../dbflow5/query/list/FlowQueryList.kt | 29 +++++++-------- .../dbflow5/query/list/IFlowCursorIterator.kt | 13 ++++--- 15 files changed, 116 insertions(+), 127 deletions(-) diff --git a/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/query/RXQueriable.kt b/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/query/RXQueriable.kt index 53885a416..aee551cc4 100644 --- a/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/query/RXQueriable.kt +++ b/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/query/RXQueriable.kt @@ -1,12 +1,12 @@ package com.raizlabs.dbflow5.rx.query -import android.database.Cursor +import com.raizlabs.dbflow5.database.DatabaseStatement +import com.raizlabs.dbflow5.database.FlowCursor import com.raizlabs.dbflow5.query.Delete import com.raizlabs.dbflow5.query.Insert -import com.raizlabs.dbflow5.query.Set import com.raizlabs.dbflow5.query.Queriable +import com.raizlabs.dbflow5.query.Set import com.raizlabs.dbflow5.structure.Model -import com.raizlabs.dbflow5.database.DatabaseStatement import rx.Single /** @@ -17,7 +17,7 @@ interface RXQueriable { /** * @return An [Single] from the DB based on this query */ - fun query(): Single + fun query(): Single /** * @return An [Single] of [DatabaseStatement] from this query. diff --git a/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/query/RXQueriableImpl.kt b/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/query/RXQueriableImpl.kt index 09fd23b34..390b23fdb 100644 --- a/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/query/RXQueriableImpl.kt +++ b/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/query/RXQueriableImpl.kt @@ -1,9 +1,9 @@ package com.raizlabs.dbflow5.rx.query -import android.database.Cursor +import com.raizlabs.dbflow5.database.DatabaseStatement +import com.raizlabs.dbflow5.database.FlowCursor import com.raizlabs.dbflow5.query.BaseQueriable import com.raizlabs.dbflow5.query.Queriable -import com.raizlabs.dbflow5.database.DatabaseStatement import rx.Single import rx.Single.fromCallable @@ -11,20 +11,20 @@ import rx.Single.fromCallable * Description: Represents [BaseQueriable] with RX constructs. */ open class RXQueriableImpl internal constructor( - private val innerQueriable: Queriable) : RXQueriable { + private val innerQueriable: Queriable) : RXQueriable { - override fun query(): Single = fromCallable { innerQueriable.query() } + override fun query(): Single = fromCallable { innerQueriable.query() } override fun compileStatement(): Single = - fromCallable { innerQueriable.compileStatement() } + fromCallable { innerQueriable.compileStatement() } override fun longValue(): Single = fromCallable { innerQueriable.longValue() } override fun executeInsert(): Single = - fromCallable { innerQueriable.executeInsert() } + fromCallable { innerQueriable.executeInsert() } override fun executeUpdateDelete(): Single = - fromCallable { innerQueriable.executeUpdateDelete() } + fromCallable { innerQueriable.executeUpdateDelete() } override fun hasData(): Single = fromCallable { innerQueriable.hasData() } diff --git a/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/query/RXQueriable.kt b/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/query/RXQueriable.kt index 1d78ef62c..4531b5bc5 100644 --- a/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/query/RXQueriable.kt +++ b/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/query/RXQueriable.kt @@ -1,12 +1,12 @@ package com.raizlabs.dbflow5.rx2.query -import android.database.Cursor +import com.raizlabs.dbflow5.database.DatabaseStatement +import com.raizlabs.dbflow5.database.FlowCursor import com.raizlabs.dbflow5.query.Delete import com.raizlabs.dbflow5.query.Insert -import com.raizlabs.dbflow5.query.Set import com.raizlabs.dbflow5.query.Queriable +import com.raizlabs.dbflow5.query.Set import com.raizlabs.dbflow5.structure.Model -import com.raizlabs.dbflow5.database.DatabaseStatement import io.reactivex.Completable import io.reactivex.Maybe import io.reactivex.Single @@ -19,7 +19,7 @@ interface RXQueriable { /** * @return An [Single] from the DB based on this query */ - fun query(): Maybe + fun query(): Maybe /** * @return An [Single] of [DatabaseStatement] from this query. diff --git a/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/query/RXQueriableImpl.kt b/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/query/RXQueriableImpl.kt index 40399899f..963eb4926 100644 --- a/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/query/RXQueriableImpl.kt +++ b/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/query/RXQueriableImpl.kt @@ -1,9 +1,9 @@ package com.raizlabs.dbflow5.rx2.query -import android.database.Cursor +import com.raizlabs.dbflow5.database.DatabaseStatement +import com.raizlabs.dbflow5.database.FlowCursor import com.raizlabs.dbflow5.query.BaseQueriable import com.raizlabs.dbflow5.query.Queriable -import com.raizlabs.dbflow5.database.DatabaseStatement import io.reactivex.Completable import io.reactivex.Maybe import io.reactivex.Single @@ -14,18 +14,18 @@ import io.reactivex.Single.fromCallable */ open class RXQueriableImpl(private val innerQueriable: Queriable) : RXQueriable { - override fun query(): Maybe = Maybe.fromCallable { innerQueriable.query() } + override fun query(): Maybe = Maybe.fromCallable { innerQueriable.query() } override fun compileStatement(): Single = - fromCallable { innerQueriable.compileStatement() } + fromCallable { innerQueriable.compileStatement() } override fun longValue(): Single = fromCallable { innerQueriable.longValue() } override fun executeInsert(): Single = - fromCallable { innerQueriable.executeInsert() } + fromCallable { innerQueriable.executeInsert() } override fun executeUpdateDelete(): Single = - fromCallable { innerQueriable.executeUpdateDelete() } + fromCallable { innerQueriable.executeUpdateDelete() } override fun hasData(): Single = fromCallable { innerQueriable.hasData() } diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/ForeignKeyModels.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/ForeignKeyModels.kt index abcbb55e3..a519a46ef 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/ForeignKeyModels.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/ForeignKeyModels.kt @@ -1,6 +1,5 @@ package com.raizlabs.dbflow5.models -import android.database.Cursor import com.raizlabs.dbflow5.TestDatabase import com.raizlabs.dbflow5.annotation.Column import com.raizlabs.dbflow5.annotation.ColumnMap @@ -12,6 +11,7 @@ import com.raizlabs.dbflow5.annotation.ForeignKeyReference import com.raizlabs.dbflow5.annotation.NotNull import com.raizlabs.dbflow5.annotation.PrimaryKey import com.raizlabs.dbflow5.annotation.Table +import com.raizlabs.dbflow5.database.FlowCursor import com.raizlabs.dbflow5.query.LoadFromCursorListener /** @@ -50,7 +50,7 @@ class BlogRef(@PrimaryKey(autoincrement = true) var id: Int = 0, @Column var nam @Table(database = TestDatabase::class) class BlogRefNoModel(@PrimaryKey(autoincrement = true) var id: Int = 0, @Column var name: String = "", @ForeignKey(references = arrayOf(ForeignKeyReference(columnName = "authorId", foreignKeyColumnName = "id", notNull = NotNull(onNullConflict = ConflictAction.FAIL))), - tableClass = Author::class) + tableClass = Author::class) var authorId: String? = null) @@ -67,9 +67,9 @@ class BlogPrimary(@PrimaryKey @ForeignKey var author: Author? = null, @Column va @Table(database = TestDatabase::class) class BlogStubbed(@PrimaryKey(autoincrement = true) var id: Int = 0, @Column var name: String = "", @ForeignKey(stubbedRelationship = true, deleteForeignKeyModel = true, saveForeignKeyModel = true, - onDelete = ForeignKeyAction.CASCADE, onUpdate = ForeignKeyAction.RESTRICT) + onDelete = ForeignKeyAction.CASCADE, onUpdate = ForeignKeyAction.RESTRICT) var author: Author? = null) : LoadFromCursorListener { - override fun onLoadFromCursor(cursor: Cursor) { + override fun onLoadFromCursor(cursor: FlowCursor) { } } @@ -82,6 +82,6 @@ class Position(@PrimaryKey var id: Int = 0, @ColumnMap var location: Location? = @Table(database = TestDatabase::class) class Position2(@PrimaryKey var id: Int = 0, @ColumnMap(references = arrayOf( - ColumnMapReference(columnName = "latitude", columnMapFieldName = "latitude"), - ColumnMapReference(columnName = "longitude", columnMapFieldName = "longitude"))) + ColumnMapReference(columnName = "latitude", columnMapFieldName = "latitude"), + ColumnMapReference(columnName = "longitude", columnMapFieldName = "longitude"))) var location: Location? = null) diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/rx/query/RXQueryTests.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/rx/query/RXQueryTests.kt index fd5ebdba3..6a3135d04 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/rx/query/RXQueryTests.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/rx/query/RXQueryTests.kt @@ -1,9 +1,9 @@ package com.raizlabs.dbflow5.rx.query -import android.database.Cursor import com.raizlabs.dbflow5.BaseUnitTest import com.raizlabs.dbflow5.config.databaseForTable import com.raizlabs.dbflow5.database.DatabaseStatement +import com.raizlabs.dbflow5.database.FlowCursor import com.raizlabs.dbflow5.models.SimpleModel import com.raizlabs.dbflow5.models.SimpleModel_Table.name import com.raizlabs.dbflow5.query.insert @@ -22,12 +22,12 @@ class RXQueryTests : BaseUnitTest() { databaseForTable { SimpleModel("Name").save() - var cursor: Cursor? = null + var cursor: FlowCursor? = null (select from SimpleModel::class).rx() - .query() - .subscribe { - cursor = it - } + .query() + .subscribe { + cursor = it + } assertEquals(1, cursor!!.count) cursor!!.close() @@ -39,10 +39,10 @@ class RXQueryTests : BaseUnitTest() { databaseForTable { var databaseStatement: DatabaseStatement? = null (insert().columnValues(name.`is`("name"))) - .rxBaseQueriable().compileStatement() - .subscribe { - databaseStatement = it - } + .rxBaseQueriable().compileStatement() + .subscribe { + databaseStatement = it + } assertNotNull(databaseStatement) databaseStatement!!.close() } @@ -55,7 +55,7 @@ class RXQueryTests : BaseUnitTest() { SimpleModel("name2").save() var count = 0L (selectCountOf(Property.ALL_PROPERTY) from SimpleModel::class).rx() - .longValue().subscribe { + .longValue().subscribe { count = it } @@ -68,11 +68,11 @@ class RXQueryTests : BaseUnitTest() { databaseForTable { var count = 0L (insert().columnValues(name.eq("name"))) - .rxBaseQueriable() - .executeInsert() - .subscribe { - count = it - } + .rxBaseQueriable() + .executeInsert() + .subscribe { + count = it + } assertEquals(1, count) } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/ModelLoader.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/ModelLoader.kt index b31c42195..7dc8e9fe1 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/ModelLoader.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/ModelLoader.kt @@ -1,6 +1,5 @@ package com.raizlabs.dbflow5.adapter.queriable -import android.database.Cursor import android.database.sqlite.SQLiteDatabase import com.raizlabs.dbflow5.adapter.InstanceAdapter import com.raizlabs.dbflow5.config.FlowManager @@ -9,7 +8,7 @@ import com.raizlabs.dbflow5.database.FlowCursor /** * Description: Represents how models load from DB. It will query a [SQLiteDatabase] - * and query for a [Cursor]. Then the cursor is used to convert itself into an object. + * and query for a [FlowCursor]. Then the cursor is used to convert itself into an object. */ abstract class ModelLoader(val modelClass: Class) { @@ -32,11 +31,10 @@ abstract class ModelLoader(val modelClass: Clas } /** - * Specify how to convert the [Cursor] data into a [TReturn]. Can be null. + * Specify how to convert the [FlowCursor] data into a [TReturn]. Can be null. * * @param cursor The cursor resulting from a query passed into [.load] - * @param data The data (if not null) that we can reuse without need to create new object. - * @return A new (or reused) instance that represents the [Cursor]. + * @return A new (or reused) instance that represents the [FlowCursor]. */ abstract fun convertToData(cursor: FlowCursor, databaseWrapper: DatabaseWrapper): TReturn? } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/provider/ContentUtils.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/provider/ContentUtils.kt index 7d02dea07..c92ee6098 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/provider/ContentUtils.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/provider/ContentUtils.kt @@ -2,16 +2,15 @@ package com.raizlabs.dbflow5.provider import android.content.ContentResolver import android.content.ContentValues -import android.database.Cursor import android.net.Uri +import com.raizlabs.dbflow5.adapter.ModelAdapter import com.raizlabs.dbflow5.annotation.provider.ContentProvider import com.raizlabs.dbflow5.config.FlowLog import com.raizlabs.dbflow5.config.FlowManager -import com.raizlabs.dbflow5.query.Operator -import com.raizlabs.dbflow5.query.OperatorGroup -import com.raizlabs.dbflow5.adapter.ModelAdapter import com.raizlabs.dbflow5.database.DatabaseWrapper import com.raizlabs.dbflow5.database.FlowCursor +import com.raizlabs.dbflow5.query.Operator +import com.raizlabs.dbflow5.query.OperatorGroup /** * Description: Provides handy wrapper mechanisms for [android.content.ContentProvider] @@ -32,7 +31,7 @@ object ContentUtils { */ @JvmStatic fun buildUriWithAuthority(authority: String, vararg paths: String): Uri = - buildUri(BASE_CONTENT_URI, authority, *paths) + buildUri(BASE_CONTENT_URI, authority, *paths) /** * Constructs an Uri with the specified baseContent uri and authority. Add paths to append to the Uri. @@ -61,7 +60,7 @@ object ContentUtils { */ @JvmStatic fun insert(insertUri: Uri, model: TableClass): Uri? = - insert(FlowManager.context.contentResolver, insertUri, model) + insert(FlowManager.context.contentResolver, insertUri, model) /** * Inserts the model into the [android.content.ContentResolver]. Uses the insertUri to resolve @@ -126,7 +125,7 @@ object ContentUtils { */ @JvmStatic fun bulkInsert(bulkInsertUri: Uri, table: Class, models: List): Int = - bulkInsert(FlowManager.context.contentResolver, bulkInsertUri, table, models) + bulkInsert(FlowManager.context.contentResolver, bulkInsertUri, table, models) /** * Updates the model through the [android.content.ContentResolver]. Uses the updateUri to @@ -138,7 +137,7 @@ object ContentUtils { */ @JvmStatic fun update(updateUri: Uri, model: TableClass): Int = - update(FlowManager.context.contentResolver, updateUri, model) + update(FlowManager.context.contentResolver, updateUri, model) /** * Updates the model through the [android.content.ContentResolver]. Uses the updateUri to @@ -172,7 +171,7 @@ object ContentUtils { */ @JvmStatic fun delete(deleteUri: Uri, model: TableClass): Int = - delete(FlowManager.context.contentResolver, deleteUri, model) + delete(FlowManager.context.contentResolver, deleteUri, model) /** * Deletes the specified model through the [android.content.ContentResolver]. Uses the deleteUri @@ -212,8 +211,8 @@ object ContentUtils { @JvmStatic fun query(contentResolver: ContentResolver, queryUri: Uri, whereConditions: OperatorGroup, - orderBy: String?, vararg columns: String?): Cursor? = - contentResolver.query(queryUri, columns, whereConditions.query, null, orderBy) + orderBy: String?, vararg columns: String?): FlowCursor? = + FlowCursor.from(contentResolver.query(queryUri, columns, whereConditions.query, null, orderBy)) /** * Queries the [android.content.ContentResolver] with the specified queryUri. It will generate @@ -231,8 +230,8 @@ object ContentUtils { databaseWrapper: DatabaseWrapper, whereConditions: OperatorGroup, orderBy: String, vararg columns: String): List? = - queryList(FlowManager.context.contentResolver, queryUri, table, - databaseWrapper, whereConditions, orderBy, *columns) + queryList(FlowManager.context.contentResolver, queryUri, table, + databaseWrapper, whereConditions, orderBy, *columns) /** @@ -255,8 +254,8 @@ object ContentUtils { orderBy: String, vararg columns: String): List? { val cursor = FlowCursor.from(contentResolver.query(queryUri, columns, whereConditions.query, null, orderBy)!!) return FlowManager.getModelAdapter(table) - .listModelLoader - .load(cursor, databaseWrapper) + .listModelLoader + .load(cursor, databaseWrapper) } /** @@ -275,8 +274,8 @@ object ContentUtils { databaseWrapper: DatabaseWrapper, whereConditions: OperatorGroup, orderBy: String, vararg columns: String): TableClass? = - querySingle(FlowManager.context.contentResolver, queryUri, table, - databaseWrapper, whereConditions, orderBy, *columns) + querySingle(FlowManager.context.contentResolver, queryUri, table, + databaseWrapper, whereConditions, orderBy, *columns) /** * Queries the [android.content.ContentResolver] with the specified queryUri. It will generate @@ -297,7 +296,7 @@ object ContentUtils { whereConditions: OperatorGroup, orderBy: String, vararg columns: String): TableClass? { val list = queryList(contentResolver, queryUri, table, - databaseWrapper, whereConditions, orderBy, *columns) + databaseWrapper, whereConditions, orderBy, *columns) return list?.let { if (list.isNotEmpty()) list[0] else null } } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/CursorResult.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/CursorResult.kt index 512b774e5..aeef3f8ef 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/CursorResult.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/CursorResult.kt @@ -1,6 +1,5 @@ package com.raizlabs.dbflow5.query -import android.database.Cursor import com.raizlabs.dbflow5.adapter.InstanceAdapter import com.raizlabs.dbflow5.config.FlowManager import com.raizlabs.dbflow5.database.DatabaseWrapper @@ -9,10 +8,10 @@ import com.raizlabs.dbflow5.query.list.FlowCursorIterator import com.raizlabs.dbflow5.query.list.IFlowCursorIterator /** - * Description: A class that contains a [Cursor] and handy methods for retrieving data from it. + * Description: A class that contains a [FlowCursor] and handy methods for retrieving data from it. * You must close this object post use via [.close]. */ -class CursorResult internal constructor(modelClass: Class, cursor: Cursor?, +class CursorResult internal constructor(modelClass: Class, cursor: FlowCursor?, private val databaseWrapper: DatabaseWrapper) : IFlowCursorIterator { @@ -50,7 +49,7 @@ class CursorResult internal constructor(modelClass: Class, cursor: C } ?: arrayListOf() /** - * @return Converts the [Cursor] to a [List] of [T] and then closes it. + * @return Converts the [FlowCursor] to a [List] of [T] and then closes it. */ fun toListClose(): List { val list = retrievalAdapter.listModelLoader.load(_cursor, databaseWrapper) ?: arrayListOf() @@ -69,7 +68,7 @@ class CursorResult internal constructor(modelClass: Class, cursor: C } /** - * @return Converts the [Cursor] to a [List] of [T] and then closes it. + * @return Converts the [FlowCursor] to a [List] of [T] and then closes it. */ fun toCustomListClose(customClass: Class): List { val customList = FlowManager.getQueryModelAdapter(customClass).listModelLoader @@ -79,14 +78,14 @@ class CursorResult internal constructor(modelClass: Class, cursor: C } /** - * @return The first [T] of items from the contained [Cursor]. You must call [.close] when finished. + * @return The first [T] of items from the contained [FlowCursor]. You must call [.close] when finished. */ fun toModel(): T? = _cursor?.let { cursor -> retrievalAdapter.singleModelLoader.convertToData(cursor, databaseWrapper) } /** - * @return Converts the [Cursor] into the first [T] from the cursor and then closes it. + * @return Converts the [FlowCursor] into the first [T] from the cursor and then closes it. */ fun toModelClose(): T? { val model = retrievalAdapter.singleModelLoader.load(_cursor, databaseWrapper) @@ -95,7 +94,7 @@ class CursorResult internal constructor(modelClass: Class, cursor: C } /** - * @return The first [T] of items from the contained [Cursor]. You must call [.close] when finished. + * @return The first [T] of items from the contained [FlowCursor]. You must call [.close] when finished. */ fun toCustomModel(customClass: Class): TCustom? { return if (_cursor != null) @@ -105,7 +104,7 @@ class CursorResult internal constructor(modelClass: Class, cursor: C } /** - * @return Converts the [Cursor] to a [T] and then closes it. + * @return Converts the [FlowCursor] to a [T] and then closes it. */ fun toCustomModelClose(customClass: Class): TCustom? { val customList = FlowManager.getQueryModelAdapter(customClass).singleModelLoader.load(_cursor, databaseWrapper) @@ -128,7 +127,7 @@ class CursorResult internal constructor(modelClass: Class, cursor: C override fun iterator(startingLocation: Int, limit: Long): FlowCursorIterator = FlowCursorIterator(this, startingLocation, limit) - override val cursor: Cursor? + override val cursor: FlowCursor? get() = _cursor override fun close() { diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/LoadFromCursorListener.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/LoadFromCursorListener.kt index 27f111279..35f590958 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/LoadFromCursorListener.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/LoadFromCursorListener.kt @@ -1,11 +1,10 @@ package com.raizlabs.dbflow5.query -import android.database.Cursor - +import com.raizlabs.dbflow5.database.FlowCursor import com.raizlabs.dbflow5.structure.Model /** - * Description: Marks a [Model] as listening to [Cursor] + * Description: Marks a [Model] as listening to [FlowCursor] * events for custom handling when loading from the DB. */ interface LoadFromCursorListener { @@ -15,5 +14,5 @@ interface LoadFromCursorListener { * * @param cursor The cursor that is loaded. */ - fun onLoadFromCursor(cursor: Cursor) + fun onLoadFromCursor(cursor: FlowCursor) } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/ModelQueriable.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/ModelQueriable.kt index a228c1aea..f8bcc08a5 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/ModelQueriable.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/ModelQueriable.kt @@ -1,9 +1,9 @@ package com.raizlabs.dbflow5.query -import android.database.Cursor import com.raizlabs.dbflow5.query.list.FlowCursorList import com.raizlabs.dbflow5.query.list.FlowQueryList import com.raizlabs.dbflow5.structure.BaseQueryModel +import com.raizlabs.dbflow5.database.FlowCursor /** * Description: An interface for query objects to enable you to query from the database in a structured way. @@ -17,7 +17,7 @@ interface ModelQueriable : Queriable { val table: Class /** - * @return A wrapper class around [Cursor] that allows you to convert its data into results. + * @return A wrapper class around [FlowCursor] that allows you to convert its data into results. */ fun queryResults(): CursorResult diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/Where.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Where.kt index b1c00b2f6..35ddbf839 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/Where.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Where.kt @@ -1,6 +1,5 @@ package com.raizlabs.dbflow5.query -import android.database.Cursor import com.raizlabs.dbflow5.annotation.provider.ContentProvider import com.raizlabs.dbflow5.appendQualifier import com.raizlabs.dbflow5.database.FlowCursor @@ -18,12 +17,12 @@ class Where * @param whereBase The FROM or SET statement chunk */ internal constructor( - /** - * The first chunk of the SQL statement before this query. - */ - val whereBase: WhereBase, vararg conditions: SQLOperator) + /** + * The first chunk of the SQL statement before this query. + */ + val whereBase: WhereBase, vararg conditions: SQLOperator) : BaseModelQueriable(whereBase.databaseWrapper, whereBase.table), - ModelQueriable, Transformable { + ModelQueriable, Transformable { /** * Helps to build the where statement easily @@ -49,10 +48,10 @@ internal constructor( get() { val fromQuery = whereBase.query.trim { it <= ' ' } val queryBuilder = StringBuilder(fromQuery).append(" ") - .appendQualifier("WHERE", operatorGroup.query) - .appendQualifier("GROUP BY", groupByList.joinToString(separator = ",")) - .appendQualifier("HAVING", havingGroup.query) - .appendQualifier("ORDER BY", orderByList.joinToString(separator = ",")) + .appendQualifier("WHERE", operatorGroup.query) + .appendQualifier("GROUP BY", groupByList.joinToString(separator = ",")) + .appendQualifier("HAVING", havingGroup.query) + .appendQualifier("ORDER BY", orderByList.joinToString(separator = ",")) if (limit > VALUE_UNSET) { queryBuilder.appendQualifier("LIMIT", limit.toString()) @@ -155,13 +154,13 @@ internal constructor( } /** - * @return the result of the query as a [Cursor]. + * @return the result of the query as a [FlowCursor]. */ override fun query(): FlowCursor? =// Query the sql here - when { - whereBase.queryBuilderBase is Select -> databaseWrapper.rawQuery(query, null) - else -> super.query() - } + when { + whereBase.queryBuilderBase is Select -> databaseWrapper.rawQuery(query, null) + else -> super.query() + } /** * Queries for all of the results this statement returns from a DB cursor in the form of the [T] diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowCursorList.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowCursorList.kt index 354592d13..542f119ed 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowCursorList.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowCursorList.kt @@ -1,6 +1,5 @@ package com.raizlabs.dbflow5.query.list -import android.database.Cursor import android.widget.ListView import com.raizlabs.dbflow5.adapter.InstanceAdapter import com.raizlabs.dbflow5.config.FlowLog @@ -103,7 +102,7 @@ class FlowCursorList private constructor(builder: Builder) : IFlowCu * Returns a model at the specified position. If we are using the cache and it does not contain a model * at that position, we move the cursor to the specified position and construct the [T]. * - * @param position The row number in the [android.database.Cursor] to look at + * @param position The row number in the [FlowCursor] to look at * @return The [T] converted from the cursor */ override fun get(position: Long): T { @@ -121,7 +120,7 @@ class FlowCursorList private constructor(builder: Builder) : IFlowCu } /** - * @return the count of the rows in the [android.database.Cursor] backed by this list. + * @return the count of the rows in the [FlowCursor] backed by this list. */ override val count: Long get() { @@ -140,7 +139,7 @@ class FlowCursorList private constructor(builder: Builder) : IFlowCu _cursor = null } - override val cursor: Cursor? + override val cursor: FlowCursor? get() { unpackCursor() throwIfCursorClosed() @@ -148,7 +147,7 @@ class FlowCursorList private constructor(builder: Builder) : IFlowCu return _cursor } - private fun unpackCursor(): Cursor { + private fun unpackCursor(): FlowCursor { if (_cursor == null) { _cursor = cursorFunc() } @@ -183,8 +182,8 @@ class FlowCursorList private constructor(builder: Builder) : IFlowCu internal val modelClass: Class = modelQueriable.table internal var cursor: FlowCursor? = null - fun cursor(cursor: Cursor?) = apply { - cursor?.let { this.cursor = FlowCursor.from(cursor) } + fun cursor(cursor: FlowCursor?) = apply { + this.cursor = cursor } fun build() = FlowCursorList(this) diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowQueryList.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowQueryList.kt index 18f6dc4cb..408cd231b 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowQueryList.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowQueryList.kt @@ -1,20 +1,16 @@ package com.raizlabs.dbflow5.query.list -import android.database.Cursor import android.os.Handler import android.os.Looper import com.raizlabs.dbflow5.adapter.InstanceAdapter +import com.raizlabs.dbflow5.database.FlowCursor import com.raizlabs.dbflow5.query.ModelQueriable import com.raizlabs.dbflow5.query.list.FlowCursorList.OnCursorRefreshListener -import com.raizlabs.dbflow5.transaction.DefaultTransactionQueue -import com.raizlabs.dbflow5.transaction.Transaction /** - * Description: Operates very similiar to a [java.util.List] except its backed by a table cursor. All of - * the [java.util.List] modifications default to the main thread, but it can be set to - * run on the [DefaultTransactionQueue]. Register a [Transaction.Success] - * on this list to know when the results complete. NOTE: any modifications to this list will be reflected - * on the underlying table. + * Description: A query-backed immutable [List]. Represents the results of a query without loading + * the full query out into an actual [List]. Avoid keeping this class around without calling [close] as + * it leaves a [FlowCursor] object active. */ class FlowQueryList( /** @@ -37,6 +33,12 @@ class FlowQueryList( override val count: Long get() = internalCursorList.count + override val cursor: FlowCursor? + get() = internalCursorList.cursor + + override val size: Int + get() = internalCursorList.count.toInt() + private val refreshRunnable = object : Runnable { override fun run() { synchronized(this) { @@ -64,7 +66,7 @@ class FlowQueryList( get() = internalCursorList /** - * @return Constructs a new [Builder] that reuses the underlying [Cursor], cache, + * @return Constructs a new [Builder] that reuses the underlying [FlowCursor], cache, * callbacks, and other properties. */ fun newBuilder(): Builder = Builder(internalCursorList) @@ -117,8 +119,6 @@ class FlowQueryList( override fun get(position: Long): T = internalCursorList[position] - override val cursor: Cursor? - get() = internalCursorList.cursor /** * Returns the item from the backing [FlowCursorList]. First call @@ -173,9 +173,6 @@ class FlowQueryList( return FlowCursorIterator(this, location) } - override val size: Int - get() = internalCursorList.count.toInt() - override fun subList(fromIndex: Int, toIndex: Int): List { val tableList = internalCursorList.all return tableList.subList(fromIndex, toIndex) @@ -189,7 +186,7 @@ class FlowQueryList( internal val table: Class - internal var cursor: Cursor? = null + internal var cursor: FlowCursor? = null internal var modelQueriable: ModelQueriable internal constructor(cursorList: FlowCursorList) { @@ -203,7 +200,7 @@ class FlowQueryList( this.modelQueriable = modelQueriable } - fun cursor(cursor: Cursor) = apply { + fun cursor(cursor: FlowCursor) = apply { this.cursor = cursor } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/IFlowCursorIterator.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/IFlowCursorIterator.kt index 5c6f22f3c..5cab4a827 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/IFlowCursorIterator.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/IFlowCursorIterator.kt @@ -1,34 +1,33 @@ package com.raizlabs.dbflow5.query.list -import android.database.Cursor - +import com.raizlabs.dbflow5.database.FlowCursor import java.io.Closeable import java.io.IOException /** - * Description: Simple interface that allows you to iterate a [Cursor]. + * Description: Simple interface that allows you to iterate a [FlowCursor]. */ interface IFlowCursorIterator : Closeable, Iterable { /** - * @return Count of the [Cursor]. + * @return Count of the [FlowCursor]. */ val count: Long /** - * @param position The position within the [Cursor] to retrieve and convert into a [TModel] + * @param position The position within the [FlowCursor] to retrieve and convert into a [TModel] */ operator fun get(position: Long): TModel /** * @return The cursor. */ - val cursor: Cursor? + val cursor: FlowCursor? override fun iterator(): FlowCursorIterator /** - * @return Can iterate the [Cursor]. Specifies a starting location + count limit of results. + * @return Can iterate the [FlowCursor]. Specifies a starting location + count limit of results. */ fun iterator(startingLocation: Int, limit: Long): FlowCursorIterator From a125110de6260e5572bb54541777f0f2938abf09 Mon Sep 17 00:00:00 2001 From: fuzzagrosner Date: Mon, 4 Dec 2017 13:22:52 -0500 Subject: [PATCH 122/234] [database] make custom SQLiteException that mirrors Android one. have both database implementations rethrow the exception into it. --- .../dbflow5/sqlcipher/SQLCipherDatabase.kt | 45 +++++++++----- .../com/raizlabs/dbflow5/TestExtensions.kt | 1 + .../dbflow5/models/DontCreateModelTest.kt | 2 +- .../dbflow5/database/AndroidDatabase.kt | 62 +++++++++++++------ .../dbflow5/database/BaseDatabaseHelper.kt | 1 - .../dbflow5/database/SQLiteException.kt | 13 ++++ 6 files changed, 87 insertions(+), 37 deletions(-) create mode 100644 dbflow/src/main/java/com/raizlabs/dbflow5/database/SQLiteException.kt diff --git a/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherDatabase.kt b/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherDatabase.kt index 296976f7e..d674a5136 100644 --- a/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherDatabase.kt +++ b/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherDatabase.kt @@ -1,12 +1,11 @@ package com.raizlabs.dbflow5.sqlcipher import android.content.ContentValues - import com.raizlabs.dbflow5.database.DatabaseStatement import com.raizlabs.dbflow5.database.DatabaseWrapper import com.raizlabs.dbflow5.database.FlowCursor - import net.sqlcipher.database.SQLiteDatabase +import net.sqlcipher.database.SQLiteException /** * Description: Implements the code necessary to use a [SQLiteDatabase] in dbflow. @@ -17,8 +16,10 @@ internal constructor(val database: SQLiteDatabase) : DatabaseWrapper { override val version: Int get() = database.version - override fun execSQL(query: String) { + override fun execSQL(query: String) = try { database.execSQL(query) + } catch (e: SQLiteException) { + throw e.toSqliteException() } override fun beginTransaction() { @@ -34,20 +35,28 @@ internal constructor(val database: SQLiteDatabase) : DatabaseWrapper { } override fun compileStatement(rawQuery: String): DatabaseStatement = - SQLCipherStatement.from(database.compileStatement(rawQuery)) + SQLCipherStatement.from(database.compileStatement(rawQuery)) - override fun rawQuery(query: String, selectionArgs: Array?): FlowCursor = - FlowCursor.from(database.rawQuery(query, selectionArgs)) + override fun rawQuery(query: String, selectionArgs: Array?): FlowCursor = try { + FlowCursor.from(database.rawQuery(query, selectionArgs)) + } catch (e: SQLiteException) { + throw e.toSqliteException() + } override fun updateWithOnConflict(tableName: String, contentValues: ContentValues, where: String?, whereArgs: Array?, - conflictAlgorithm: Int): Long = - database.updateWithOnConflict(tableName, contentValues, - where, whereArgs, conflictAlgorithm).toLong() + conflictAlgorithm: Int): Long = try { + database.updateWithOnConflict(tableName, contentValues, + where, whereArgs, conflictAlgorithm).toLong() + } catch (e: SQLiteException) { + throw e.toSqliteException() + } - override fun insertWithOnConflict(tableName: String, nullColumnHack: String?, values: ContentValues, sqLiteDatabaseAlgorithmInt: Int): Long { - return database.insertWithOnConflict(tableName, nullColumnHack, values, sqLiteDatabaseAlgorithmInt) + override fun insertWithOnConflict(tableName: String, nullColumnHack: String?, values: ContentValues, sqLiteDatabaseAlgorithmInt: Int): Long = try { + database.insertWithOnConflict(tableName, nullColumnHack, values, sqLiteDatabaseAlgorithmInt) + } catch (e: SQLiteException) { + throw e.toSqliteException() } override fun query(tableName: String, @@ -56,12 +65,16 @@ internal constructor(val database: SQLiteDatabase) : DatabaseWrapper { selectionArgs: Array?, groupBy: String?, having: String?, - orderBy: String?): FlowCursor { - return FlowCursor.from(database.query(tableName, columns, selection, selectionArgs, groupBy, having, orderBy)) + orderBy: String?): FlowCursor = try { + FlowCursor.from(database.query(tableName, columns, selection, selectionArgs, groupBy, having, orderBy)) + } catch (e: SQLiteException) { + throw e.toSqliteException() } - override fun delete(tableName: String, whereClause: String?, whereArgs: Array?): Int { - return database.delete(tableName, whereClause, whereArgs) + override fun delete(tableName: String, whereClause: String?, whereArgs: Array?): Int = try { + database.delete(tableName, whereClause, whereArgs) + } catch (e: SQLiteException) { + throw e.toSqliteException() } companion object { @@ -70,3 +83,5 @@ internal constructor(val database: SQLiteDatabase) : DatabaseWrapper { fun from(database: SQLiteDatabase): SQLCipherDatabase = SQLCipherDatabase(database) } } + +fun SQLiteException.toSqliteException() = com.raizlabs.dbflow5.database.SQLiteException("A Database Error Occurred", this) \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/TestExtensions.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/TestExtensions.kt index cebf0dcc4..d81f1b657 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/TestExtensions.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/TestExtensions.kt @@ -14,6 +14,7 @@ fun assertThrowsException(expectedException: KClass, function: () fail("Expected call to fail. Unexpectedly passed") } catch (e: Exception) { if (e.javaClass != expectedException.java) { + e.printStackTrace() fail("Expected $expectedException but got ${e.javaClass}") } } diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/DontCreateModelTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/DontCreateModelTest.kt index b753d6a14..e11dcb67d 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/DontCreateModelTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/DontCreateModelTest.kt @@ -1,9 +1,9 @@ package com.raizlabs.dbflow5.models -import android.database.sqlite.SQLiteException import com.raizlabs.dbflow5.BaseUnitTest import com.raizlabs.dbflow5.assertThrowsException import com.raizlabs.dbflow5.config.databaseForTable +import com.raizlabs.dbflow5.database.SQLiteException import com.raizlabs.dbflow5.query.list import com.raizlabs.dbflow5.query.select import org.junit.Test diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidDatabase.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidDatabase.kt index 7835121a2..70c68c03c 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidDatabase.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidDatabase.kt @@ -2,6 +2,7 @@ package com.raizlabs.dbflow5.database import android.content.ContentValues import android.database.sqlite.SQLiteDatabase +import android.database.sqlite.SQLiteException import android.os.Build /** @@ -10,7 +11,11 @@ import android.os.Build class AndroidDatabase internal constructor(val database: SQLiteDatabase) : DatabaseWrapper { override fun execSQL(query: String) { - database.execSQL(query) + try { + database.execSQL(query) + } catch (e: SQLiteException) { + throw e.toSqliteException() + } } override fun beginTransaction() { @@ -29,31 +34,40 @@ class AndroidDatabase internal constructor(val database: SQLiteDatabase) : Datab get() = database.version override fun compileStatement(rawQuery: String): DatabaseStatement = - AndroidDatabaseStatement.from(database.compileStatement(rawQuery), database) + AndroidDatabaseStatement.from(database.compileStatement(rawQuery), database) - override fun rawQuery(query: String, selectionArgs: Array?): FlowCursor = - FlowCursor.from(database.rawQuery(query, selectionArgs)) + override fun rawQuery(query: String, selectionArgs: Array?): FlowCursor = try { + FlowCursor.from(database.rawQuery(query, selectionArgs)) + } catch (e: SQLiteException) { + throw e.toSqliteException() + } override fun updateWithOnConflict(tableName: String, contentValues: ContentValues, where: String?, whereArgs: Array?, - conflictAlgorithm: Int): Long = - if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.FROYO) { - database.updateWithOnConflict(tableName, contentValues, where, whereArgs, conflictAlgorithm).toLong() - } else { - database.update(tableName, contentValues, where, whereArgs).toLong() - } + conflictAlgorithm: Int): Long = try { + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.FROYO) { + database.updateWithOnConflict(tableName, contentValues, where, whereArgs, conflictAlgorithm).toLong() + } else { + database.update(tableName, contentValues, where, whereArgs).toLong() + } + } catch (e: SQLiteException) { + throw e.toSqliteException() + } override fun insertWithOnConflict(tableName: String, nullColumnHack: String?, values: ContentValues, - sqLiteDatabaseAlgorithmInt: Int): Long = - if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.FROYO) { - database.insertWithOnConflict(tableName, nullColumnHack, values, sqLiteDatabaseAlgorithmInt) - } else { - database.insert(tableName, nullColumnHack, values) - } + sqLiteDatabaseAlgorithmInt: Int): Long = try { + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.FROYO) { + database.insertWithOnConflict(tableName, nullColumnHack, values, sqLiteDatabaseAlgorithmInt) + } else { + database.insert(tableName, nullColumnHack, values) + } + } catch (e: SQLiteException) { + throw e.toSqliteException() + } override fun query(tableName: String, columns: Array?, @@ -61,11 +75,17 @@ class AndroidDatabase internal constructor(val database: SQLiteDatabase) : Datab selectionArgs: Array?, groupBy: String?, having: String?, - orderBy: String?): FlowCursor = - FlowCursor.from(database.query(tableName, columns, selection, selectionArgs, groupBy, having, orderBy)) + orderBy: String?): FlowCursor = try { + FlowCursor.from(database.query(tableName, columns, selection, selectionArgs, groupBy, having, orderBy)) + } catch (e: SQLiteException) { + throw e.toSqliteException() + } - override fun delete(tableName: String, whereClause: String?, whereArgs: Array?): Int = - database.delete(tableName, whereClause, whereArgs) + override fun delete(tableName: String, whereClause: String?, whereArgs: Array?): Int = try { + database.delete(tableName, whereClause, whereArgs) + } catch (e: SQLiteException) { + throw e.toSqliteException() + } companion object { @@ -73,3 +93,5 @@ class AndroidDatabase internal constructor(val database: SQLiteDatabase) : Datab fun from(database: SQLiteDatabase): AndroidDatabase = AndroidDatabase(database) } } + +fun SQLiteException.toSqliteException() = com.raizlabs.dbflow5.database.SQLiteException("A Database Error Occurred", this) \ No newline at end of file diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/database/BaseDatabaseHelper.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/database/BaseDatabaseHelper.kt index f85f2bcdb..37e7c515f 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/database/BaseDatabaseHelper.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/database/BaseDatabaseHelper.kt @@ -1,6 +1,5 @@ package com.raizlabs.dbflow5.database -import android.database.sqlite.SQLiteException import com.raizlabs.dbflow5.config.DatabaseDefinition import com.raizlabs.dbflow5.config.FlowLog import com.raizlabs.dbflow5.config.FlowManager diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/database/SQLiteException.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/database/SQLiteException.kt new file mode 100644 index 000000000..cfa372c35 --- /dev/null +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/database/SQLiteException.kt @@ -0,0 +1,13 @@ +package com.raizlabs.dbflow5.database + +/** + * Description: DBFlow mirror to an Android SQLiteException. + */ +class SQLiteException : RuntimeException { + constructor() {} + + constructor(error: String) : super(error) + + constructor(error: String, cause: Throwable) : super(error, cause) +} + From ef21e08d5f86583d1ab2f3ddb1a38fb5c3515f60 Mon Sep 17 00:00:00 2001 From: fuzzagrosner Date: Mon, 4 Dec 2017 13:33:14 -0500 Subject: [PATCH 123/234] [database] remove most existences of Android-specific classes from main library other than Android files. Rename FlowSQLiteOpenHelper to AndroidSQLiteOpenHelper. --- .../dbflow5/sqlcipher/SQLCipherDatabase.kt | 5 ++- .../java/com/raizlabs/dbflow5/SqlUtils.kt | 24 ++++++++++--- .../dbflow5/adapter/InternalAdapter.kt | 4 +-- .../raizlabs/dbflow5/adapter/ModelAdapter.kt | 5 ++- .../dbflow5/adapter/queriable/ModelLoader.kt | 3 +- .../dbflow5/config/DatabaseDefinition.kt | 6 ++-- .../dbflow5/database/AndroidDatabase.kt | 5 ++- ...enHelper.kt => AndroidSQLiteOpenHelper.kt} | 2 +- .../database/DatabaseHelperDelegate.kt | 19 +++++----- .../dbflow5/database/DatabaseStatement.kt | 4 +-- .../raizlabs/dbflow5/query/BaseOperator.kt | 36 +++++++++---------- .../raizlabs/dbflow5/query/BaseQueriable.kt | 22 ++++++------ .../java/com/raizlabs/dbflow5/query/Index.kt | 21 +++++------ .../com/raizlabs/dbflow5/query/StringQuery.kt | 8 ++--- .../dbflow5/transaction/ITransaction.kt | 4 +-- 15 files changed, 90 insertions(+), 78 deletions(-) rename dbflow/src/main/java/com/raizlabs/dbflow5/database/{FlowSQLiteOpenHelper.kt => AndroidSQLiteOpenHelper.kt} (99%) diff --git a/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherDatabase.kt b/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherDatabase.kt index d674a5136..278712030 100644 --- a/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherDatabase.kt +++ b/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherDatabase.kt @@ -34,8 +34,11 @@ internal constructor(val database: SQLiteDatabase) : DatabaseWrapper { database.endTransaction() } - override fun compileStatement(rawQuery: String): DatabaseStatement = + override fun compileStatement(rawQuery: String): DatabaseStatement = try { SQLCipherStatement.from(database.compileStatement(rawQuery)) + } catch (e: SQLiteException) { + throw e.toSqliteException() + } override fun rawQuery(query: String, selectionArgs: Array?): FlowCursor = try { FlowCursor.from(database.rawQuery(query, selectionArgs)) diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/SqlUtils.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/SqlUtils.kt index 1a8e54f2a..014f71323 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/SqlUtils.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/SqlUtils.kt @@ -187,9 +187,23 @@ fun byteArrayToHexString(bytes: ByteArray?): String { } return String(hexChars) } -/** - * @param modelClass The model class to use. - * @param action The [Action] to use. - * @return The uri for updates to [Model], meant for general changes. - */ +fun sqlEscapeString(value: String): String = buildString { appendEscapedSQLString(this, value) } + +fun appendEscapedSQLString(sb: StringBuilder, sqlString: String) { + sb.apply { + append('\'') + if (sqlString.indexOf('\'') != -1) { + val length = sqlString.length + for (i in 0 until length) { + val c = sqlString[i] + if (c == '\'') { + append('\'') + } + append(c) + } + } else + append(sqlString) + append('\'') + } +} diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/InternalAdapter.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/InternalAdapter.kt index 96ae35ebe..74e7c5de3 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/InternalAdapter.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/InternalAdapter.kt @@ -1,9 +1,7 @@ package com.raizlabs.dbflow5.adapter import android.content.ContentValues -import android.database.sqlite.SQLiteStatement import android.support.annotation.IntRange - import com.raizlabs.dbflow5.annotation.PrimaryKey import com.raizlabs.dbflow5.database.DatabaseStatement import com.raizlabs.dbflow5.database.DatabaseWrapper @@ -105,7 +103,7 @@ interface InternalAdapter { @IntRange(from = 0, to = 1) start: Int) /** - * Binds to a [SQLiteStatement]. It leaves out an autoincrementing primary key (if specified) + * Binds to a [DatabaseStatement]. It leaves out an autoincrementing primary key (if specified) * to keep the true nature of AI keys. * * @param sqLiteStatement The statement to bind to. diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/ModelAdapter.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/ModelAdapter.kt index 0b6115b0a..45eb0593f 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/ModelAdapter.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/ModelAdapter.kt @@ -1,7 +1,6 @@ package com.raizlabs.dbflow5.adapter import android.content.ContentValues -import android.database.sqlite.SQLiteStatement import com.raizlabs.dbflow5.adapter.saveable.ListModelSaver import com.raizlabs.dbflow5.adapter.saveable.ModelSaver import com.raizlabs.dbflow5.annotation.ConflictAction @@ -50,13 +49,13 @@ abstract class ModelAdapter(databaseDefinition: DatabaseDefinition) abstract val allColumnProperties: Array> /** - * @return The query used to insert a model using a [SQLiteStatement] + * @return The query used to insert a model using a [DatabaseStatement] */ protected open val insertStatementQuery: String get() = compiledStatementQuery /** - * @return The normal query used in saving a model if we use a [SQLiteStatement]. + * @return The normal query used in saving a model if we use a [DatabaseStatement]. */ protected abstract val compiledStatementQuery: String diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/ModelLoader.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/ModelLoader.kt index 7dc8e9fe1..7eeca1092 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/ModelLoader.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/ModelLoader.kt @@ -1,13 +1,12 @@ package com.raizlabs.dbflow5.adapter.queriable -import android.database.sqlite.SQLiteDatabase import com.raizlabs.dbflow5.adapter.InstanceAdapter import com.raizlabs.dbflow5.config.FlowManager import com.raizlabs.dbflow5.database.DatabaseWrapper import com.raizlabs.dbflow5.database.FlowCursor /** - * Description: Represents how models load from DB. It will query a [SQLiteDatabase] + * Description: Represents how models load from DB. It will query a [DatabaseWrapper] * and query for a [FlowCursor]. Then the cursor is used to convert itself into an object. */ abstract class ModelLoader(val modelClass: Class) { diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseDefinition.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseDefinition.kt index d098534df..fef8299a6 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseDefinition.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseDefinition.kt @@ -15,7 +15,7 @@ import com.raizlabs.dbflow5.database.DatabaseHelperListener import com.raizlabs.dbflow5.database.DatabaseStatement import com.raizlabs.dbflow5.database.DatabaseWrapper import com.raizlabs.dbflow5.database.FlowCursor -import com.raizlabs.dbflow5.database.FlowSQLiteOpenHelper +import com.raizlabs.dbflow5.database.AndroidSQLiteOpenHelper import com.raizlabs.dbflow5.database.OpenHelper import com.raizlabs.dbflow5.migration.Migration import com.raizlabs.dbflow5.runtime.DirectModelNotifier @@ -103,7 +103,7 @@ abstract class DatabaseDefinition : DatabaseWrapper { openHelper = if (config?.openHelperCreator != null) { config.openHelperCreator.invoke(this, helperListener) } else { - FlowSQLiteOpenHelper(this, helperListener) + AndroidSQLiteOpenHelper(this, helperListener) } openHelper?.performRestoreFromBackup() } @@ -321,7 +321,7 @@ abstract class DatabaseDefinition : DatabaseWrapper { } /** - * Performs a full deletion of this database. Reopens the [FlowSQLiteOpenHelper] as well. + * Performs a full deletion of this database. Reopens the [AndroidSQLiteOpenHelper] as well. * * Reapplies the [DatabaseConfig] if we have one. * @param databaseConfig sets a new [DatabaseConfig] on this class. diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidDatabase.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidDatabase.kt index 70c68c03c..172ba54e8 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidDatabase.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidDatabase.kt @@ -33,8 +33,11 @@ class AndroidDatabase internal constructor(val database: SQLiteDatabase) : Datab override val version: Int get() = database.version - override fun compileStatement(rawQuery: String): DatabaseStatement = + override fun compileStatement(rawQuery: String): DatabaseStatement = try { AndroidDatabaseStatement.from(database.compileStatement(rawQuery), database) + } catch (e: SQLiteException) { + throw e.toSqliteException() + } override fun rawQuery(query: String, selectionArgs: Array?): FlowCursor = try { FlowCursor.from(database.rawQuery(query, selectionArgs)) diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/database/FlowSQLiteOpenHelper.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidSQLiteOpenHelper.kt similarity index 99% rename from dbflow/src/main/java/com/raizlabs/dbflow5/database/FlowSQLiteOpenHelper.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidSQLiteOpenHelper.kt index ea93b99a5..7f52a9dde 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/database/FlowSQLiteOpenHelper.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidSQLiteOpenHelper.kt @@ -10,7 +10,7 @@ import com.raizlabs.dbflow5.config.FlowManager /** * Description: Wraps around the [SQLiteOpenHelper] and provides extra features for use in this library. */ -class FlowSQLiteOpenHelper( +class AndroidSQLiteOpenHelper( databaseDefinition: DatabaseDefinition, listener: DatabaseHelperListener?) : SQLiteOpenHelper(FlowManager.context, diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseHelperDelegate.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseHelperDelegate.kt index 20708063f..070a9e638 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseHelperDelegate.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseHelperDelegate.kt @@ -1,6 +1,5 @@ package com.raizlabs.dbflow5.database -import android.database.sqlite.SQLiteOpenHelper import com.raizlabs.dbflow5.config.DatabaseDefinition import com.raizlabs.dbflow5.config.FlowLog import com.raizlabs.dbflow5.config.FlowManager @@ -13,13 +12,13 @@ import java.io.IOException import java.io.InputStream /** - * Description: An abstraction from some parts of the [SQLiteOpenHelper] where this can be + * Description: An abstraction from some parts of the Android SQLiteOpenHelper where this can be * used in other helper class definitions. */ class DatabaseHelperDelegate( - private var databaseHelperListener: DatabaseHelperListener?, - databaseDefinition: DatabaseDefinition, - private val backupHelper: OpenHelper?) + private var databaseHelperListener: DatabaseHelperListener?, + databaseDefinition: DatabaseDefinition, + private val backupHelper: OpenHelper?) : BaseDatabaseHelper(databaseDefinition) { /** @@ -44,7 +43,7 @@ class DatabaseHelperDelegate( fun performRestoreFromBackup() { movePrepackagedDB(databaseDefinition.databaseFileName, - databaseDefinition.databaseFileName) + databaseDefinition.databaseFileName) if (databaseDefinition.backupEnabled()) { if (backupHelper == null) { @@ -116,7 +115,7 @@ class DatabaseHelperDelegate( val inputStream: InputStream // if it exists and the integrity is ok we use backup as the main DB is no longer valid if (existingDb.exists() && (!databaseDefinition.backupEnabled() || (databaseDefinition.backupEnabled() - && backupHelper != null && isDatabaseIntegrityOk(backupHelper.database)))) { + && backupHelper != null && isDatabaseIntegrityOk(backupHelper.database)))) { inputStream = FileInputStream(existingDb) } else { inputStream = FlowManager.context.assets.open(prepackagedName) @@ -146,7 +145,7 @@ class DatabaseHelperDelegate( if (!result!!.equals("ok", ignoreCase = true)) { // integrity_checker failed on main or attached databases FlowLog.log(FlowLog.Level.E, "PRAGMA integrity_check on " + - databaseDefinition.databaseName + " returned: " + result) + databaseDefinition.databaseName + " returned: " + result) integrityOk = false @@ -233,7 +232,7 @@ class DatabaseHelperDelegate( val inputStream: InputStream // if it exists and the integrity is ok if (existingDb.exists() && (databaseDefinition.backupEnabled() - && backupHelper != null && isDatabaseIntegrityOk(backupHelper.database))) { + && backupHelper != null && isDatabaseIntegrityOk(backupHelper.database))) { inputStream = FileInputStream(existingDb) } else { inputStream = FlowManager.context.assets.open(prepackagedName) @@ -253,7 +252,7 @@ class DatabaseHelperDelegate( fun backupDB() { if (!databaseDefinition.backupEnabled() || !databaseDefinition.areConsistencyChecksEnabled()) { throw IllegalStateException("Backups are not enabled for : " + databaseDefinition.databaseName + ". Please consider adding " + - "both backupEnabled and consistency checks enabled to the Database annotation") + "both backupEnabled and consistency checks enabled to the Database annotation") } databaseDefinition.beginTransactionAsync(object : ITransaction { diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseStatement.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseStatement.kt index 4114d07b9..f64e00b40 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseStatement.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseStatement.kt @@ -1,9 +1,7 @@ package com.raizlabs.dbflow5.database -import android.database.sqlite.SQLiteStatement - /** - * Description: Abstracts out a [SQLiteStatement]. + * Description: Abstracts out an Android SQLiteStatement. */ interface DatabaseStatement { diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseOperator.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseOperator.kt index ad84ba6a5..63ba361be 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseOperator.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseOperator.kt @@ -1,20 +1,20 @@ package com.raizlabs.dbflow5.query -import android.database.DatabaseUtils +import com.raizlabs.dbflow5.byteArrayToHexString import com.raizlabs.dbflow5.config.FlowManager import com.raizlabs.dbflow5.converter.TypeConverter import com.raizlabs.dbflow5.data.Blob import com.raizlabs.dbflow5.sql.Query -import com.raizlabs.dbflow5.byteArrayToHexString +import com.raizlabs.dbflow5.sqlEscapeString /** * Description: Base class for all kinds of [SQLOperator] */ abstract class BaseOperator internal constructor( - /** - * The column name - */ - protected var nameAlias: NameAlias?) : SQLOperator { + /** + * The column name + */ + protected var nameAlias: NameAlias?) : SQLOperator { /** * The operation such as "=", "<", and more @@ -79,13 +79,13 @@ abstract class BaseOperator internal constructor( internal fun columnAlias(): NameAlias? = nameAlias open fun convertObjectToString(obj: Any?, appendInnerParenthesis: Boolean): String? = - convertValueToString(obj, appendInnerParenthesis) + convertValueToString(obj, appendInnerParenthesis) companion object { @JvmStatic fun convertValueToString(value: Any?, appendInnerQueryParenthesis: Boolean): String? = - convertValueToString(value, appendInnerQueryParenthesis, true) + convertValueToString(value, appendInnerQueryParenthesis, true) /** * Converts a value input into a String representation of that. @@ -129,7 +129,7 @@ abstract class BaseOperator internal constructor( var stringVal: String if (typeConvert) { val typeConverter: TypeConverter<*, Any?>? - = FlowManager.getTypeConverterForClass(_value.javaClass) as TypeConverter<*, Any?>? + = FlowManager.getTypeConverterForClass(_value.javaClass) as TypeConverter<*, Any?>? if (typeConverter != null) { _value = typeConverter.getDBValue(_value) } @@ -138,7 +138,7 @@ abstract class BaseOperator internal constructor( if (_value is Number) { stringVal = _value.toString() } else if (_value is Enum<*>) { - stringVal = DatabaseUtils.sqlEscapeString(_value.name) + stringVal = sqlEscapeString(_value.name) } else { if (appendInnerQueryParenthesis && _value is BaseModelQueriable<*>) { stringVal = String.format("(%1s)", _value.query.trim { it <= ' ' }) @@ -157,11 +157,11 @@ abstract class BaseOperator internal constructor( } else { bytes = _value as ByteArray? } - stringVal = "X" + DatabaseUtils.sqlEscapeString(byteArrayToHexString(bytes)) + stringVal = "X" + sqlEscapeString(byteArrayToHexString(bytes)) } else { stringVal = _value.toString() if (stringVal != Operator.Operation.EMPTY_PARAM) { - stringVal = DatabaseUtils.sqlEscapeString(stringVal) + stringVal = sqlEscapeString(stringVal) } } } @@ -206,9 +206,9 @@ abstract class BaseOperator internal constructor( */ @JvmStatic fun joinArguments(delimiter: CharSequence, tokens: Array): String = - tokens.joinToString(separator = delimiter) { - convertValueToString(it, false, true) ?: "" - } + tokens.joinToString(separator = delimiter) { + convertValueToString(it, false, true) ?: "" + } /** * Returns a string containing the tokens converted into DBValues joined by delimiters. @@ -220,9 +220,9 @@ abstract class BaseOperator internal constructor( */ @JvmStatic fun joinArguments(delimiter: CharSequence, tokens: Iterable): String = - tokens.joinToString(separator = delimiter) { - convertValueToString(it, false, true) ?: "" - } + tokens.joinToString(separator = delimiter) { + convertValueToString(it, false, true) ?: "" + } } } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseQueriable.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseQueriable.kt index cef319dd4..4cfe9354e 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseQueriable.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseQueriable.kt @@ -1,24 +1,24 @@ package com.raizlabs.dbflow5.query -import android.database.sqlite.SQLiteDoneException import com.raizlabs.dbflow5.config.FlowLog -import com.raizlabs.dbflow5.runtime.NotifyDistributor -import com.raizlabs.dbflow5.longForQuery -import com.raizlabs.dbflow5.structure.ChangeAction import com.raizlabs.dbflow5.database.DatabaseStatement import com.raizlabs.dbflow5.database.DatabaseStatementWrapper import com.raizlabs.dbflow5.database.DatabaseWrapper import com.raizlabs.dbflow5.database.FlowCursor +import com.raizlabs.dbflow5.database.SQLiteException +import com.raizlabs.dbflow5.longForQuery +import com.raizlabs.dbflow5.runtime.NotifyDistributor +import com.raizlabs.dbflow5.structure.ChangeAction /** * Description: Base implementation of something that can be queried from the database. */ abstract class BaseQueriable protected constructor( - private val databaseWrapper: DatabaseWrapper, - /** - * @return The table associated with this INSERT - */ - val table: Class) : Queriable, Actionable { + private val databaseWrapper: DatabaseWrapper, + /** + * @return The table associated with this INSERT + */ + val table: Class) : Queriable, Actionable { abstract override val primaryAction: ChangeAction @@ -27,7 +27,7 @@ abstract class BaseQueriable protected constructor( val query = query FlowLog.log(FlowLog.Level.V, "Executing query: " + query) return longForQuery(databaseWrapper, query) - } catch (sde: SQLiteDoneException) { + } catch (sde: SQLiteException) { // catch exception here, log it but return 0; FlowLog.logWarning(sde) } @@ -52,7 +52,7 @@ abstract class BaseQueriable protected constructor( } override fun executeInsert(): Long = - compileStatement().executeInsert() + compileStatement().executeInsert() override fun execute() { val cursor = query() diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/Index.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Index.kt index d825ae7c9..3115121be 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/Index.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Index.kt @@ -3,10 +3,11 @@ package com.raizlabs.dbflow5.query import com.raizlabs.dbflow5.appendList import com.raizlabs.dbflow5.appendQuotedIfNeeded import com.raizlabs.dbflow5.config.FlowManager -import com.raizlabs.dbflow5.sql.Query +import com.raizlabs.dbflow5.database.DatabaseWrapper +import com.raizlabs.dbflow5.database.SQLiteException import com.raizlabs.dbflow5.dropIndex import com.raizlabs.dbflow5.query.property.IProperty -import com.raizlabs.dbflow5.database.DatabaseWrapper +import com.raizlabs.dbflow5.sql.Query /** * Description: an INDEX class that enables you to index a specific column from a table. This enables @@ -19,11 +20,11 @@ class Index * @param indexName The name of this index. */ ( - private val databaseWrapper: DatabaseWrapper, - /** - * @return The name of this index. - */ - val indexName: String) : Query { + private val databaseWrapper: DatabaseWrapper, + /** + * @return The name of this index. + */ + val indexName: String) : Query { /** * @return The table this INDEX belongs to. @@ -50,7 +51,7 @@ class Index /** * If true, will append the UNIQUE statement to this trigger. * - * @param unique true if unique. If created again, a [android.database.SQLException] is thrown. + * @param unique true if unique. If created again, a [SQLiteException] is thrown. * @return This instance. */ fun unique(unique: Boolean) = apply { @@ -123,9 +124,9 @@ class Index inline fun DatabaseWrapper.indexOn(indexName: String, vararg property: IProperty<*>) - = index(indexName).on(T::class.java, *property) + = index(indexName).on(T::class.java, *property) inline fun DatabaseWrapper.indexOn(indexName: String, firstNameAlias: NameAlias, vararg arrayOfNameAlias: NameAlias) - = index(indexName).on(T::class.java, firstNameAlias, *arrayOfNameAlias) + = index(indexName).on(T::class.java, firstNameAlias, *arrayOfNameAlias) diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/StringQuery.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/StringQuery.kt index c604a58f0..6528f5905 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/StringQuery.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/StringQuery.kt @@ -1,10 +1,10 @@ package com.raizlabs.dbflow5.query import android.database.sqlite.SQLiteDatabase -import com.raizlabs.dbflow5.sql.Query -import com.raizlabs.dbflow5.structure.ChangeAction import com.raizlabs.dbflow5.database.DatabaseWrapper import com.raizlabs.dbflow5.database.FlowCursor +import com.raizlabs.dbflow5.sql.Query +import com.raizlabs.dbflow5.structure.ChangeAction /** * Description: Provides a very basic query mechanism for strings. Allows you to easily perform custom SQL query string @@ -16,8 +16,8 @@ class StringQuery * Creates an instance of this class * * @param table The table to use - * @param sql The sql statement to query the DB with. Does not work with [Delete], - * this must be done with [SQLiteDatabase.execSQL] + * @param query The sql statement to query the DB with. Does not work with [Delete], + * this must be done with [DatabaseWrapper.execSQL] */ (databaseWrapper: DatabaseWrapper, table: Class, diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/ITransaction.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/ITransaction.kt index 1f8769050..7bd10b213 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/ITransaction.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/ITransaction.kt @@ -1,7 +1,5 @@ package com.raizlabs.dbflow5.transaction -import android.database.sqlite.SQLiteDatabaseLockedException - import com.raizlabs.dbflow5.database.DatabaseWrapper /** @@ -14,7 +12,7 @@ interface ITransaction { * Called within a database transaction. * * @param databaseWrapper The database to save data into. Use this access to operate on the DB - * without causing [SQLiteDatabaseLockedException]. + * without causing an Android SQLiteDatabaseLockedException or other problems due to locking. */ fun execute(databaseWrapper: DatabaseWrapper): R } From d5585320f6a500c8fed4a769b6c5c077016c521f Mon Sep 17 00:00:00 2001 From: fuzzagrosner Date: Mon, 4 Dec 2017 14:10:33 -0500 Subject: [PATCH 124/234] [database] remove more java imports. add an execute transaction async with a function call. make try..catch on SQLiteException into DBFlow SQLiteException an inline extension method to cut down on code dupes. --- .../java/com/raizlabs/dbflow5/StringUtils.kt | 6 +-- .../dbflow5/sqlcipher/SQLCipherDatabase.kt | 44 ++++++++---------- .../dbflow5/sqlcipher/SQLCipherStatement.kt | 14 ++---- .../dbflow5/config/DatabaseDefinition.kt | 11 +++++ .../com/raizlabs/dbflow5/config/FlowLog.kt | 6 +-- .../dbflow5/database/AndroidDatabase.kt | 39 ++++++---------- .../database/AndroidDatabaseStatement.kt | 8 ++-- .../dbflow5/database/BaseDatabaseHelper.kt | 46 +++++++++---------- .../database/DatabaseHelperDelegate.kt | 45 ++++++++---------- .../java/com/raizlabs/dbflow5/query/Insert.kt | 28 +++++------ .../dbflow5/query/cache/SimpleMapCache.kt | 4 +- .../query/cache/SparseArrayBasedCache.kt | 11 ++--- .../dbflow5/query/list/FlowCursorIterator.kt | 10 ++-- .../dbflow5/runtime/DBBatchSaveQueue.kt | 16 +++---- 14 files changed, 133 insertions(+), 155 deletions(-) diff --git a/dbflow-core/src/main/java/com/raizlabs/dbflow5/StringUtils.kt b/dbflow-core/src/main/java/com/raizlabs/dbflow5/StringUtils.kt index f1af066d2..63412b5a4 100644 --- a/dbflow-core/src/main/java/com/raizlabs/dbflow5/StringUtils.kt +++ b/dbflow-core/src/main/java/com/raizlabs/dbflow5/StringUtils.kt @@ -10,13 +10,13 @@ import java.util.regex.Pattern * @return true if the string is not null, empty string "", or the length is greater than 0 */ fun String?.isNullOrEmpty(): Boolean = - this == null || this == "" || isEmpty() + this == null || this == "" || isEmpty() /** * @return true if the string is null, empty string "", or the length is less than equal to 0 */ fun String?.isNotNullOrEmpty(): Boolean = - this != null && this != "" && isNotEmpty() + this != null && this != "" && isNotEmpty() fun StringBuilder.appendQuotedIfNeeded(string: String?) = apply { if (string == "*") @@ -27,7 +27,7 @@ fun StringBuilder.appendQuotedIfNeeded(string: String?) = apply { } private val QUOTE = '`' -private val QUOTE_PATTERN = Pattern.compile(QUOTE + ".*" + QUOTE) +private val QUOTE_PATTERN: Pattern = (QUOTE + ".*" + QUOTE).toPattern() /** * Helper method to check if name is quoted. diff --git a/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherDatabase.kt b/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherDatabase.kt index 278712030..f2059fea9 100644 --- a/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherDatabase.kt +++ b/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherDatabase.kt @@ -16,10 +16,8 @@ internal constructor(val database: SQLiteDatabase) : DatabaseWrapper { override val version: Int get() = database.version - override fun execSQL(query: String) = try { + override fun execSQL(query: String) = rethrowDBFlowException { database.execSQL(query) - } catch (e: SQLiteException) { - throw e.toSqliteException() } override fun beginTransaction() { @@ -34,32 +32,26 @@ internal constructor(val database: SQLiteDatabase) : DatabaseWrapper { database.endTransaction() } - override fun compileStatement(rawQuery: String): DatabaseStatement = try { + override fun compileStatement(rawQuery: String): DatabaseStatement = rethrowDBFlowException { SQLCipherStatement.from(database.compileStatement(rawQuery)) - } catch (e: SQLiteException) { - throw e.toSqliteException() } - override fun rawQuery(query: String, selectionArgs: Array?): FlowCursor = try { + override fun rawQuery(query: String, selectionArgs: Array?): FlowCursor = rethrowDBFlowException { FlowCursor.from(database.rawQuery(query, selectionArgs)) - } catch (e: SQLiteException) { - throw e.toSqliteException() } override fun updateWithOnConflict(tableName: String, contentValues: ContentValues, where: String?, whereArgs: Array?, - conflictAlgorithm: Int): Long = try { - database.updateWithOnConflict(tableName, contentValues, - where, whereArgs, conflictAlgorithm).toLong() - } catch (e: SQLiteException) { - throw e.toSqliteException() + conflictAlgorithm: Int): Long = rethrowDBFlowException { + database.updateWithOnConflict(tableName, contentValues, where, whereArgs, conflictAlgorithm).toLong() } - override fun insertWithOnConflict(tableName: String, nullColumnHack: String?, values: ContentValues, sqLiteDatabaseAlgorithmInt: Int): Long = try { + override fun insertWithOnConflict(tableName: String, + nullColumnHack: String?, + values: ContentValues, + sqLiteDatabaseAlgorithmInt: Int): Long = rethrowDBFlowException { database.insertWithOnConflict(tableName, nullColumnHack, values, sqLiteDatabaseAlgorithmInt) - } catch (e: SQLiteException) { - throw e.toSqliteException() } override fun query(tableName: String, @@ -68,16 +60,14 @@ internal constructor(val database: SQLiteDatabase) : DatabaseWrapper { selectionArgs: Array?, groupBy: String?, having: String?, - orderBy: String?): FlowCursor = try { + orderBy: String?): FlowCursor = rethrowDBFlowException { FlowCursor.from(database.query(tableName, columns, selection, selectionArgs, groupBy, having, orderBy)) - } catch (e: SQLiteException) { - throw e.toSqliteException() } - override fun delete(tableName: String, whereClause: String?, whereArgs: Array?): Int = try { + override fun delete(tableName: String, + whereClause: String?, + whereArgs: Array?): Int = rethrowDBFlowException { database.delete(tableName, whereClause, whereArgs) - } catch (e: SQLiteException) { - throw e.toSqliteException() } companion object { @@ -87,4 +77,10 @@ internal constructor(val database: SQLiteDatabase) : DatabaseWrapper { } } -fun SQLiteException.toSqliteException() = com.raizlabs.dbflow5.database.SQLiteException("A Database Error Occurred", this) \ No newline at end of file +fun SQLiteException.toSqliteException() = com.raizlabs.dbflow5.database.SQLiteException("A Database Error Occurred", this) + +inline fun rethrowDBFlowException(fn: () -> T) = try { + fn() +} catch (e: SQLiteException) { + throw e.toSqliteException() +} \ No newline at end of file diff --git a/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherStatement.kt b/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherStatement.kt index e6a624395..5defd2f3d 100644 --- a/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherStatement.kt +++ b/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherStatement.kt @@ -12,7 +12,7 @@ import net.sqlcipher.database.SQLiteStatement class SQLCipherStatement internal constructor(val statement: SQLiteStatement) : BaseDatabaseStatement() { - override fun executeUpdateDelete(): Long = statement.executeUpdateDelete().toLong() + override fun executeUpdateDelete(): Long = rethrowDBFlowException { statement.executeUpdateDelete().toLong() } override fun execute() { statement.execute() @@ -22,17 +22,11 @@ internal constructor(val statement: SQLiteStatement) : BaseDatabaseStatement() { statement.close() } - override fun simpleQueryForLong(): Long { - return statement.simpleQueryForLong() - } + override fun simpleQueryForLong(): Long = rethrowDBFlowException { statement.simpleQueryForLong() } - override fun simpleQueryForString(): String? { - return statement.simpleQueryForString() - } + override fun simpleQueryForString(): String? = rethrowDBFlowException { statement.simpleQueryForString() } - override fun executeInsert(): Long { - return statement.executeInsert() - } + override fun executeInsert(): Long = rethrowDBFlowException { statement.executeInsert() } override fun bindString(index: Int, s: String) { statement.bindString(index, s) diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseDefinition.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseDefinition.kt index fef8299a6..52443709f 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseDefinition.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseDefinition.kt @@ -279,6 +279,17 @@ abstract class DatabaseDefinition : DatabaseWrapper { .error(error) .execute() + /** + * Executes and returns the executed transaction. + */ + fun executeTransactionAsync(transaction: (DatabaseWrapper) -> R, + success: ((Transaction, R) -> Unit)? = null, + error: ((Transaction, Throwable) -> Unit)? = null): Transaction + = beginTransactionAsync(transaction) + .success(success) + .error(error) + .execute() + fun beginTransactionAsync(transaction: ITransaction): Transaction.Builder = Transaction.Builder(transaction, this) diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowLog.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowLog.kt index 1af1b7285..87905f18d 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowLog.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowLog.kt @@ -9,7 +9,7 @@ import com.raizlabs.dbflow5.config.FlowLog.Level */ object FlowLog { - val TAG = FlowLog::class.java.simpleName + val TAG = "FlowLog" private var level = Level.E /** @@ -59,7 +59,7 @@ object FlowLog { fun isEnabled(level: Level) = level.ordinal >= FlowLog.level.ordinal /** - * Logs a [java.lang.Throwable] as an error. + * Logs a [Throwable] as an error. * * @param throwable The stack trace to print */ @@ -69,7 +69,7 @@ object FlowLog { } /** - * Logs a [java.lang.Throwable] as a warning. + * Logs a [Throwable] as a warning. * * @param throwable The stack trace to print */ diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidDatabase.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidDatabase.kt index 172ba54e8..f8b4b0f05 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidDatabase.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidDatabase.kt @@ -11,11 +11,7 @@ import android.os.Build class AndroidDatabase internal constructor(val database: SQLiteDatabase) : DatabaseWrapper { override fun execSQL(query: String) { - try { - database.execSQL(query) - } catch (e: SQLiteException) { - throw e.toSqliteException() - } + rethrowDBFlowException { database.execSQL(query) } } override fun beginTransaction() { @@ -33,43 +29,36 @@ class AndroidDatabase internal constructor(val database: SQLiteDatabase) : Datab override val version: Int get() = database.version - override fun compileStatement(rawQuery: String): DatabaseStatement = try { + override fun compileStatement(rawQuery: String): DatabaseStatement = rethrowDBFlowException { AndroidDatabaseStatement.from(database.compileStatement(rawQuery), database) - } catch (e: SQLiteException) { - throw e.toSqliteException() } - override fun rawQuery(query: String, selectionArgs: Array?): FlowCursor = try { + override fun rawQuery(query: String, selectionArgs: Array?): FlowCursor = rethrowDBFlowException { FlowCursor.from(database.rawQuery(query, selectionArgs)) - } catch (e: SQLiteException) { - throw e.toSqliteException() } override fun updateWithOnConflict(tableName: String, contentValues: ContentValues, where: String?, whereArgs: Array?, - conflictAlgorithm: Int): Long = try { + conflictAlgorithm: Int): Long + = rethrowDBFlowException { if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.FROYO) { database.updateWithOnConflict(tableName, contentValues, where, whereArgs, conflictAlgorithm).toLong() } else { database.update(tableName, contentValues, where, whereArgs).toLong() } - } catch (e: SQLiteException) { - throw e.toSqliteException() } override fun insertWithOnConflict(tableName: String, nullColumnHack: String?, values: ContentValues, - sqLiteDatabaseAlgorithmInt: Int): Long = try { + sqLiteDatabaseAlgorithmInt: Int): Long = rethrowDBFlowException { if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.FROYO) { database.insertWithOnConflict(tableName, nullColumnHack, values, sqLiteDatabaseAlgorithmInt) } else { database.insert(tableName, nullColumnHack, values) } - } catch (e: SQLiteException) { - throw e.toSqliteException() } override fun query(tableName: String, @@ -78,16 +67,12 @@ class AndroidDatabase internal constructor(val database: SQLiteDatabase) : Datab selectionArgs: Array?, groupBy: String?, having: String?, - orderBy: String?): FlowCursor = try { + orderBy: String?): FlowCursor = rethrowDBFlowException { FlowCursor.from(database.query(tableName, columns, selection, selectionArgs, groupBy, having, orderBy)) - } catch (e: SQLiteException) { - throw e.toSqliteException() } - override fun delete(tableName: String, whereClause: String?, whereArgs: Array?): Int = try { + override fun delete(tableName: String, whereClause: String?, whereArgs: Array?): Int = rethrowDBFlowException { database.delete(tableName, whereClause, whereArgs) - } catch (e: SQLiteException) { - throw e.toSqliteException() } companion object { @@ -97,4 +82,10 @@ class AndroidDatabase internal constructor(val database: SQLiteDatabase) : Datab } } -fun SQLiteException.toSqliteException() = com.raizlabs.dbflow5.database.SQLiteException("A Database Error Occurred", this) \ No newline at end of file +fun SQLiteException.toSqliteException() = com.raizlabs.dbflow5.database.SQLiteException("A Database Error Occurred", this) + +inline fun rethrowDBFlowException(fn: () -> T) = try { + fn() +} catch (e: SQLiteException) { + throw e.toSqliteException() +} \ No newline at end of file diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidDatabaseStatement.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidDatabaseStatement.kt index bf7c45bfb..5bd8e647c 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidDatabaseStatement.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidDatabaseStatement.kt @@ -45,11 +45,11 @@ internal constructor(val statement: SQLiteStatement, statement.close() } - override fun simpleQueryForLong(): Long = statement.simpleQueryForLong() + override fun simpleQueryForLong(): Long = rethrowDBFlowException { statement.simpleQueryForLong() } - override fun simpleQueryForString(): String? = statement.simpleQueryForString() + override fun simpleQueryForString(): String? = rethrowDBFlowException { statement.simpleQueryForString() } - override fun executeInsert(): Long = statement.executeInsert() + override fun executeInsert(): Long = rethrowDBFlowException { statement.executeInsert() } override fun bindString(index: Int, s: String) { statement.bindString(index, s) @@ -76,6 +76,6 @@ internal constructor(val statement: SQLiteStatement, @JvmStatic fun from(sqLiteStatement: SQLiteStatement, database: SQLiteDatabase): AndroidDatabaseStatement = - AndroidDatabaseStatement(sqLiteStatement, database) + AndroidDatabaseStatement(sqLiteStatement, database) } } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/database/BaseDatabaseHelper.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/database/BaseDatabaseHelper.kt index 37e7c515f..f9a298fcb 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/database/BaseDatabaseHelper.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/database/BaseDatabaseHelper.kt @@ -4,9 +4,8 @@ import com.raizlabs.dbflow5.config.DatabaseDefinition import com.raizlabs.dbflow5.config.FlowLog import com.raizlabs.dbflow5.config.FlowManager import com.raizlabs.dbflow5.config.NaturalOrderComparator -import java.io.BufferedReader import java.io.IOException -import java.io.InputStreamReader +import java.io.InputStream /** * Description: @@ -50,15 +49,15 @@ open class BaseDatabaseHelper(val databaseDefinition: DatabaseDefinition) { database.beginTransaction() val modelAdapters = databaseDefinition.getModelAdapters() modelAdapters - .asSequence() - .filter { it.createWithDatabase() } - .forEach { - try { - database.execSQL(it.creationQuery) - } catch (e: SQLiteException) { - FlowLog.logError(e) - } + .asSequence() + .filter { it.createWithDatabase() } + .forEach { + try { + database.execSQL(it.creationQuery) + } catch (e: SQLiteException) { + FlowLog.logError(e) } + } database.setTransactionSuccessful() } finally { database.endTransaction() @@ -73,15 +72,15 @@ open class BaseDatabaseHelper(val databaseDefinition: DatabaseDefinition) { database.beginTransaction() val modelViews = databaseDefinition.modelViewAdapters modelViews - .asSequence() - .map { "CREATE VIEW IF NOT EXISTS ${it.viewName} AS ${it.getCreationQuery(database)}" } - .forEach { - try { - database.execSQL(it) - } catch (e: SQLiteException) { - FlowLog.logError(e) - } + .asSequence() + .map { "CREATE VIEW IF NOT EXISTS ${it.viewName} AS ${it.getCreationQuery(database)}" } + .forEach { + try { + database.execSQL(it) + } catch (e: SQLiteException) { + FlowLog.logError(e) } + } database.setTransactionSuccessful() } finally { database.endTransaction() @@ -93,9 +92,9 @@ open class BaseDatabaseHelper(val databaseDefinition: DatabaseDefinition) { // will try migrations file or execute migrations from code try { - val files = FlowManager.context.assets.list( - "${MIGRATION_PATH}/${databaseDefinition.databaseName}") - .sortedWith(NaturalOrderComparator()) + val files: List = FlowManager.context.assets.list( + "$MIGRATION_PATH/${databaseDefinition.databaseName}") + .sortedWith(NaturalOrderComparator()) val migrationFileMap = hashMapOf>() for (file in files) { @@ -160,8 +159,7 @@ open class BaseDatabaseHelper(val databaseDefinition: DatabaseDefinition) { private fun executeSqlScript(db: DatabaseWrapper, file: String) { try { - val input = FlowManager.context.assets.open("${MIGRATION_PATH}/${databaseDefinition.databaseName}/$file") - val reader = BufferedReader(InputStreamReader(input)) + val input: InputStream = FlowManager.context.assets.open("$MIGRATION_PATH/${databaseDefinition.databaseName}/$file") // ends line with SQL val querySuffix = ";" @@ -170,7 +168,7 @@ open class BaseDatabaseHelper(val databaseDefinition: DatabaseDefinition) { val queryCommentPrefix = "--" var query = StringBuffer() - reader.forEachLine { fileLine -> + input.reader().buffered().forEachLine { fileLine -> var line = fileLine.trim { it <= ' ' } val isEndOfQuery = line.endsWith(querySuffix) if (line.startsWith(queryCommentPrefix)) { diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseHelperDelegate.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseHelperDelegate.kt index 070a9e638..02f9f6311 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseHelperDelegate.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseHelperDelegate.kt @@ -4,7 +4,6 @@ import com.raizlabs.dbflow5.config.DatabaseDefinition import com.raizlabs.dbflow5.config.FlowLog import com.raizlabs.dbflow5.config.FlowManager import com.raizlabs.dbflow5.transaction.DefaultTransactionQueue -import com.raizlabs.dbflow5.transaction.ITransaction import java.io.File import java.io.FileInputStream import java.io.FileOutputStream @@ -255,35 +254,31 @@ class DatabaseHelperDelegate( "both backupEnabled and consistency checks enabled to the Database annotation") } - databaseDefinition.beginTransactionAsync(object : ITransaction { - override fun execute(databaseWrapper: DatabaseWrapper) { - val context = FlowManager.context - val backup = context.getDatabasePath(tempDbFileName) - val temp = context.getDatabasePath(TEMP_DB_NAME + "-2-" + databaseDefinition.databaseFileName) + databaseDefinition.executeTransactionAsync({ + val context = FlowManager.context + val backup = context.getDatabasePath(tempDbFileName) + val temp = context.getDatabasePath(TEMP_DB_NAME + "-2-" + databaseDefinition.databaseFileName) - // if exists we want to delete it before rename - if (temp.exists()) { - temp.delete() - } - - backup.renameTo(temp) - if (backup.exists()) { - backup.delete() - } - val existing = context.getDatabasePath(databaseDefinition.databaseFileName) - - try { - backup.parentFile.mkdirs() - writeDB(backup, FileInputStream(existing)) + // if exists we want to delete it before rename + if (temp.exists()) { + temp.delete() + } - temp.delete() - } catch (e: Exception) { - FlowLog.logError(e) + backup.renameTo(temp) + if (backup.exists()) { + backup.delete() + } + val existing = context.getDatabasePath(databaseDefinition.databaseFileName) - } + try { + backup.parentFile.mkdirs() + writeDB(backup, FileInputStream(existing)) + temp.delete() + } catch (e: Exception) { + FlowLog.logError(e) } - }).build().execute() + }) } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/Insert.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Insert.kt index ed8babd61..27482b503 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/Insert.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Insert.kt @@ -4,10 +4,10 @@ import android.content.ContentValues import com.raizlabs.dbflow5.annotation.ConflictAction import com.raizlabs.dbflow5.appendArray import com.raizlabs.dbflow5.config.FlowManager -import com.raizlabs.dbflow5.sql.Query +import com.raizlabs.dbflow5.database.DatabaseWrapper import com.raizlabs.dbflow5.query.property.IProperty +import com.raizlabs.dbflow5.sql.Query import com.raizlabs.dbflow5.structure.ChangeAction -import com.raizlabs.dbflow5.database.DatabaseWrapper /** * Description: The SQLite INSERT command @@ -47,29 +47,29 @@ internal constructor(databaseWrapper: DatabaseWrapper, queryBuilder.append("OR").append(" $conflictAction ") } queryBuilder.append("INTO") - .append(" ") - .append(FlowManager.getTableName(table)) + .append(" ") + .append(FlowManager.getTableName(table)) columns?.let { columns -> queryBuilder.append("(") - .appendArray(*columns.toTypedArray()) - .append(")") + .appendArray(*columns.toTypedArray()) + .append(")") } if (selectFrom != null) { queryBuilder.append(" ").append(selectFrom!!.query) } else { if (valuesList.size < 1) { throw IllegalStateException("The insert of " + FlowManager.getTableName(table) + " should have" + - "at least one value specified for the insert") + "at least one value specified for the insert") } else columns?.let { columns -> valuesList.asSequence() - .filter { it.size != columns.size } - .forEach { - throw IllegalStateException( - """The Insert of ${FlowManager.getTableName(table)} + .filter { it.size != columns.size } + .forEach { + throw IllegalStateException( + """The Insert of ${FlowManager.getTableName(table)} |when specifyingcolumns needs to have the same amount |of values and columns""".trimMargin()) - } + } } queryBuilder.append(" VALUES(") @@ -283,8 +283,8 @@ infix fun Insert.select(from: From<*>): Insert = select(from) fun columnValues(vararg pairs: Pair, *>): Array, *>> = pairs fun Insert.columnValues(vararg pairs: Pair, *>): Insert { - val columns: MutableList> = java.util.ArrayList() - val values = java.util.ArrayList() + val columns: MutableList> = mutableListOf() + val values = mutableListOf() pairs.forEach { columns.add(it.first) values.add(it.second) diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/cache/SimpleMapCache.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/cache/SimpleMapCache.kt index 68433c180..98a471bf5 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/cache/SimpleMapCache.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/cache/SimpleMapCache.kt @@ -2,7 +2,7 @@ package com.raizlabs.dbflow5.query.cache import com.raizlabs.dbflow5.config.FlowLog import com.raizlabs.dbflow5.structure.Model -import java.util.* +import java.util.HashMap /** * Description: A simple implementation that keeps [Model] you interact with in memory. @@ -36,6 +36,6 @@ class SimpleMapCache : ModelCache> { override fun get(id: Any?): TModel? = cache[id] override fun setCacheSize(size: Int) { - FlowLog.log(FlowLog.Level.W, "The cache size for ${SimpleMapCache::class.java.simpleName} is not re-configurable.") + FlowLog.log(FlowLog.Level.W, "The cache size for SimpleMapCache is not re-configurable.") } } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/cache/SparseArrayBasedCache.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/cache/SparseArrayBasedCache.kt index c231cc585..5c9374439 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/cache/SparseArrayBasedCache.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/cache/SparseArrayBasedCache.kt @@ -10,7 +10,7 @@ import com.raizlabs.dbflow5.config.FlowLog class SparseArrayBasedCache : ModelCache> { /** - * Constructs new instance with a [android.util.SparseArray] cache + * Constructs new instance with a [SparseArray] cache */ constructor() : super(SparseArray()) {} @@ -21,11 +21,6 @@ class SparseArrayBasedCache : ModelCache> { */ constructor(initialCapacity: Int) : super(SparseArray(initialCapacity)) {} - /** - * Constructs new instance with the specified [java.util.List] - * - * @param sparseArray The sparse array to use. - */ constructor(sparseArray: SparseArray) : super(sparseArray) {} override fun addModel(id: Any?, model: TModel) { @@ -53,7 +48,7 @@ class SparseArrayBasedCache : ModelCache> { } override fun setCacheSize(size: Int) { - FlowLog.log(FlowLog.Level.I, "The cache size for ${SparseArrayBasedCache::class.java.simpleName} is not re-configurable.") + FlowLog.log(FlowLog.Level.I, "The cache size for SparseArrayBasedCache is not re-configurable.") } override fun get(id: Any?): TModel? { @@ -61,7 +56,7 @@ class SparseArrayBasedCache : ModelCache> { cache.get(id.toInt()) } else { throw IllegalArgumentException("A SparseArrayBasedCache uses an id that can cast to " - + "a Number to convert it into a int") + + "a Number to convert it into a int") } } } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowCursorIterator.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowCursorIterator.kt index 24f3f32eb..158e97d7d 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowCursorIterator.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowCursorIterator.kt @@ -1,15 +1,13 @@ package com.raizlabs.dbflow5.query.list -import java.util.* - /** * Description: Provides iteration capabilities to a [FlowCursorList]. */ class FlowCursorIterator @JvmOverloads constructor( - private val cursorList: IFlowCursorIterator, - startingLocation: Int, - private var count: Long = cursorList.count - startingLocation) + private val cursorList: IFlowCursorIterator, + startingLocation: Int, + private var count: Long = cursorList.count - startingLocation) : ListIterator, AutoCloseable { private var reverseIndex: Long = 0 private var startingCount: Long = 0 @@ -69,7 +67,7 @@ class FlowCursorIterator private fun checkSizes() { if (startingCount != cursorList.count) { - throw ConcurrentModificationException("Cannot change Cursor data during iteration.") + throw RuntimeException("Concurrent Modification: Cannot change Cursor data during iteration.") } } } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/DBBatchSaveQueue.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/DBBatchSaveQueue.kt index a704eb0e2..205bdac8b 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/DBBatchSaveQueue.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/DBBatchSaveQueue.kt @@ -113,10 +113,10 @@ internal constructor(private val databaseDefinition: DatabaseDefinition) : Threa val builder = ProcessModelTransaction.Builder(modelSaver) tmpModels.forEach { builder.add(it) } databaseDefinition.beginTransactionAsync(builder.build()) - .success(successCallback) - .error(errorCallback) - .build() - .execute() + .success(successCallback) + .error(errorCallback) + .build() + .execute() } else { emptyTransactionListener?.run() } @@ -155,7 +155,7 @@ internal constructor(private val databaseDefinition: DatabaseDefinition) : Threa } /** - * Adds a [java.util.Collection] of DB objects to this queue + * Adds a [Collection] of DB objects to this queue */ fun addAll(list: MutableCollection) { synchronized(models) { @@ -168,7 +168,7 @@ internal constructor(private val databaseDefinition: DatabaseDefinition) : Threa } /** - * Adds a [java.util.Collection] of class that extend Object to this queue + * Adds a [Collection] of class that extend Object to this queue */ fun addAll2(list: Collection) { synchronized(models) { @@ -190,7 +190,7 @@ internal constructor(private val databaseDefinition: DatabaseDefinition) : Threa } /** - * Removes a [java.util.Collection] of DB object from this queue + * Removes a [Collection] of DB object from this queue * before it is processed. */ fun removeAll(outCollection: Collection) { @@ -200,7 +200,7 @@ internal constructor(private val databaseDefinition: DatabaseDefinition) : Threa } /** - * Removes a [java.util.Collection] of DB objects from this queue + * Removes a [Collection] of DB objects from this queue * before it is processed. */ fun removeAll2(outCollection: Collection<*>) { From d77c42504b676d085d78634459ed8245713e32fa Mon Sep 17 00:00:00 2001 From: fuzzagrosner Date: Mon, 4 Dec 2017 14:11:46 -0500 Subject: [PATCH 125/234] [database] rename methods. --- .../java/com/raizlabs/dbflow5/sqlcipher/SQLCipherDatabase.kt | 4 ++-- .../java/com/raizlabs/dbflow5/database/AndroidDatabase.kt | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherDatabase.kt b/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherDatabase.kt index f2059fea9..62a4b0600 100644 --- a/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherDatabase.kt +++ b/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherDatabase.kt @@ -77,10 +77,10 @@ internal constructor(val database: SQLiteDatabase) : DatabaseWrapper { } } -fun SQLiteException.toSqliteException() = com.raizlabs.dbflow5.database.SQLiteException("A Database Error Occurred", this) +fun SQLiteException.toDBFlowSQLiteException() = com.raizlabs.dbflow5.database.SQLiteException("A Database Error Occurred", this) inline fun rethrowDBFlowException(fn: () -> T) = try { fn() } catch (e: SQLiteException) { - throw e.toSqliteException() + throw e.toDBFlowSQLiteException() } \ No newline at end of file diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidDatabase.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidDatabase.kt index f8b4b0f05..a926d3613 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidDatabase.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidDatabase.kt @@ -82,10 +82,10 @@ class AndroidDatabase internal constructor(val database: SQLiteDatabase) : Datab } } -fun SQLiteException.toSqliteException() = com.raizlabs.dbflow5.database.SQLiteException("A Database Error Occurred", this) +fun SQLiteException.toDBFlowSQLiteException() = com.raizlabs.dbflow5.database.SQLiteException("A Database Error Occurred", this) inline fun rethrowDBFlowException(fn: () -> T) = try { fn() } catch (e: SQLiteException) { - throw e.toSqliteException() + throw e.toDBFlowSQLiteException() } \ No newline at end of file From fc3353bf58af72f6c5150f5be256b02f9bb3f125 Mon Sep 17 00:00:00 2001 From: fuzzagrosner Date: Mon, 4 Dec 2017 14:20:16 -0500 Subject: [PATCH 126/234] [lib] optimize imports and fix code style. --- .../dbflow5/adapter/QueryModelAdapter.kt | 2 +- .../adapter/queriable/CacheableModelLoader.kt | 4 +- .../saveable/AutoIncrementModelSaver.kt | 4 +- .../saveable/CacheableListModelSaver.kt | 6 +- .../raizlabs/dbflow5/config/DatabaseConfig.kt | 54 ++++---- .../dbflow5/config/DatabaseDefinition.kt | 58 ++++----- .../raizlabs/dbflow5/config/DatabaseHolder.kt | 2 +- .../com/raizlabs/dbflow5/config/FlowConfig.kt | 8 +- .../config/NaturalOrderComparator.java | 3 +- .../raizlabs/dbflow5/config/TableConfig.kt | 12 +- .../database/AndroidSQLiteOpenHelper.kt | 14 +- .../database/DatabaseStatementWrapper.kt | 10 +- .../raizlabs/dbflow5/database/FlowCursor.kt | 42 +++--- .../raizlabs/dbflow5/database/OpenHelper.kt | 4 - .../dbflow5/migration/AlterTableMigration.kt | 8 +- .../dbflow5/migration/IndexMigration.kt | 8 +- .../migration/IndexPropertyMigration.kt | 11 +- .../dbflow5/migration/UpdateTableMigration.kt | 14 +- .../dbflow5/provider/BaseContentProvider.kt | 4 +- .../dbflow5/provider/ModelProvider.kt | 6 +- .../dbflow5/query/BaseModelQueriable.kt | 10 +- .../dbflow5/query/BaseTransformable.kt | 12 +- .../java/com/raizlabs/dbflow5/query/Case.kt | 4 +- .../raizlabs/dbflow5/query/CaseCondition.kt | 4 +- .../dbflow5/query/ContentValuesListener.kt | 3 +- .../java/com/raizlabs/dbflow5/query/Delete.kt | 2 +- .../java/com/raizlabs/dbflow5/query/From.kt | 36 +++--- .../com/raizlabs/dbflow5/query/IndexedBy.kt | 2 +- .../java/com/raizlabs/dbflow5/query/Join.kt | 22 ++-- .../java/com/raizlabs/dbflow5/query/Method.kt | 24 ++-- .../raizlabs/dbflow5/query/ModelQueriable.kt | 2 +- .../com/raizlabs/dbflow5/query/NameAlias.kt | 66 +++++----- .../com/raizlabs/dbflow5/query/Operator.kt | 120 +++++++++--------- .../raizlabs/dbflow5/query/OperatorGroup.kt | 6 +- .../com/raizlabs/dbflow5/query/OrderBy.kt | 6 +- .../com/raizlabs/dbflow5/query/Queriable.kt | 4 +- .../java/com/raizlabs/dbflow5/query/SQLite.kt | 2 +- .../dbflow5/query/SQLiteStatementListener.kt | 2 +- .../java/com/raizlabs/dbflow5/query/Select.kt | 4 +- .../java/com/raizlabs/dbflow5/query/Set.kt | 8 +- .../com/raizlabs/dbflow5/query/Trigger.kt | 26 ++-- .../raizlabs/dbflow5/query/TriggerMethod.kt | 8 +- .../java/com/raizlabs/dbflow5/query/Update.kt | 4 +- .../com/raizlabs/dbflow5/query/WhereBase.kt | 2 +- .../dbflow5/query/property/IndexProperty.kt | 4 +- .../dbflow5/query/property/Property.kt | 82 ++++++------ .../dbflow5/query/property/PropertyFactory.kt | 24 ++-- .../query/property/TypeConvertedProperty.kt | 12 +- .../runtime/ContentResolverNotifier.kt | 15 +-- .../dbflow5/runtime/FlowContentObserver.kt | 18 +-- .../raizlabs/dbflow5/runtime/ModelNotifier.kt | 2 +- .../dbflow5/runtime/NotifyDistributor.kt | 4 +- .../dbflow5/structure/BaseQueryModel.kt | 2 +- .../com/raizlabs/dbflow5/structure/Model.kt | 12 +- .../transaction/DefaultTransactionManager.kt | 4 +- .../transaction/FastStoreModelTransaction.kt | 8 +- .../transaction/PriorityTransactionQueue.kt | 14 +- .../transaction/PriorityTransactionWrapper.kt | 12 +- .../transaction/ProcessModelTransaction.kt | 41 +++--- .../dbflow5/transaction/Transaction.kt | 24 ++-- 60 files changed, 462 insertions(+), 469 deletions(-) diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/QueryModelAdapter.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/QueryModelAdapter.kt index 70b5b48e6..c86988c79 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/QueryModelAdapter.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/QueryModelAdapter.kt @@ -2,8 +2,8 @@ package com.raizlabs.dbflow5.adapter import com.raizlabs.dbflow5.annotation.QueryModel import com.raizlabs.dbflow5.config.DatabaseDefinition -import com.raizlabs.dbflow5.query.OperatorGroup import com.raizlabs.dbflow5.database.DatabaseWrapper +import com.raizlabs.dbflow5.query.OperatorGroup /** * Description: The baseclass for adapters to [QueryModel] that defines how it interacts with the DB. The diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/CacheableModelLoader.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/CacheableModelLoader.kt index 09ca61bc4..fb762fc5f 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/CacheableModelLoader.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/CacheableModelLoader.kt @@ -43,9 +43,9 @@ open class CacheableModelLoader(modelClass: Class, databaseWrapper: DatabaseWrapper): T? { return if (!moveToFirst || cursor.moveToFirst()) { val values = cacheAdapter.getCachingColumnValuesFromCursor( - arrayOfNulls(cacheAdapter.cachingColumnSize), cursor) + arrayOfNulls(cacheAdapter.cachingColumnSize), cursor) modelCache.addOrReload(cacheAdapter.getCachingId(values), cacheAdapter, modelAdapter, - cursor, databaseWrapper) + cursor, databaseWrapper) } else null } } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/saveable/AutoIncrementModelSaver.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/saveable/AutoIncrementModelSaver.kt index 38a973dad..dc9fe1594 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/saveable/AutoIncrementModelSaver.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/saveable/AutoIncrementModelSaver.kt @@ -1,10 +1,10 @@ package com.raizlabs.dbflow5.adapter.saveable import com.raizlabs.dbflow5.config.FlowLog -import com.raizlabs.dbflow5.runtime.NotifyDistributor -import com.raizlabs.dbflow5.structure.ChangeAction import com.raizlabs.dbflow5.database.DatabaseStatement import com.raizlabs.dbflow5.database.DatabaseWrapper +import com.raizlabs.dbflow5.runtime.NotifyDistributor +import com.raizlabs.dbflow5.structure.ChangeAction /** * Description: Used to properly handle autoincrementing fields. diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/saveable/CacheableListModelSaver.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/saveable/CacheableListModelSaver.kt index b7a801728..a230599fe 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/saveable/CacheableListModelSaver.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/saveable/CacheableListModelSaver.kt @@ -24,7 +24,7 @@ class CacheableListModelSaver(modelSaver: ModelSaver, wrapper: DatabaseWrapper): Long { val statement = modelAdapter.getInsertStatement(wrapper) return applyAndCount(tableCollection, statement, - cacheFn = cacheAdapter::storeModelInCache) { + cacheFn = cacheAdapter::storeModelInCache) { modelSaver.insert(it, statement, wrapper) > 0 } } @@ -33,7 +33,7 @@ class CacheableListModelSaver(modelSaver: ModelSaver, wrapper: DatabaseWrapper): Long { val statement = modelAdapter.getUpdateStatement(wrapper) return applyAndCount(tableCollection, statement, - cacheFn = cacheAdapter::storeModelInCache) { + cacheFn = cacheAdapter::storeModelInCache) { modelSaver.update(it, statement, wrapper) } } @@ -42,7 +42,7 @@ class CacheableListModelSaver(modelSaver: ModelSaver, wrapper: DatabaseWrapper): Long { val statement = modelAdapter.getDeleteStatement(wrapper) return applyAndCount(tableCollection, statement, - cacheFn = cacheAdapter::removeModelFromCache) { + cacheFn = cacheAdapter::removeModelFromCache) { modelSaver.delete(it, statement, wrapper) } } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseConfig.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseConfig.kt index 30ee24d82..e78dad64e 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseConfig.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseConfig.kt @@ -11,15 +11,15 @@ import kotlin.reflect.KClass * Description: */ class DatabaseConfig( - val databaseClass: Class<*>, - val openHelperCreator: ((DatabaseDefinition, DatabaseHelperListener?) -> OpenHelper)? = null, - val transactionManagerCreator: ((DatabaseDefinition) -> BaseTransactionManager)? = null, - val helperListener: DatabaseHelperListener? = null, - val tableConfigMap: Map, TableConfig<*>> = mapOf(), - val modelNotifier: ModelNotifier? = null, - val isInMemory: Boolean = false, - val databaseName: String? = null, - val databaseExtensionName: String? = null) { + val databaseClass: Class<*>, + val openHelperCreator: ((DatabaseDefinition, DatabaseHelperListener?) -> OpenHelper)? = null, + val transactionManagerCreator: ((DatabaseDefinition) -> BaseTransactionManager)? = null, + val helperListener: DatabaseHelperListener? = null, + val tableConfigMap: Map, TableConfig<*>> = mapOf(), + val modelNotifier: ModelNotifier? = null, + val isInMemory: Boolean = false, + val databaseName: String? = null, + val databaseExtensionName: String? = null) { interface OpenHelperCreator { @@ -33,24 +33,24 @@ class DatabaseConfig( } internal constructor(builder: Builder) : this( - // convert java interface to kotlin function. - openHelperCreator = builder.openHelperCreator, - databaseClass = builder.databaseClass, - transactionManagerCreator = builder.transactionManagerCreator, - helperListener = builder.helperListener, - tableConfigMap = builder.tableConfigMap, - modelNotifier = builder.modelNotifier, - isInMemory = builder.inMemory, - databaseName = builder.databaseName ?: builder.databaseClass.simpleName, - databaseExtensionName = when { - builder.databaseExtensionName == null -> ".db" - builder.databaseExtensionName.isNotNullOrEmpty() -> ".${builder.databaseExtensionName}" - else -> "" - }) + // convert java interface to kotlin function. + openHelperCreator = builder.openHelperCreator, + databaseClass = builder.databaseClass, + transactionManagerCreator = builder.transactionManagerCreator, + helperListener = builder.helperListener, + tableConfigMap = builder.tableConfigMap, + modelNotifier = builder.modelNotifier, + isInMemory = builder.inMemory, + databaseName = builder.databaseName ?: builder.databaseClass.simpleName, + databaseExtensionName = when { + builder.databaseExtensionName == null -> ".db" + builder.databaseExtensionName.isNotNullOrEmpty() -> ".${builder.databaseExtensionName}" + else -> "" + }) @Suppress("UNCHECKED_CAST") fun getTableConfigForTable(modelClass: Class): TableConfig? = - tableConfigMap[modelClass] as TableConfig? + tableConfigMap[modelClass] as TableConfig? /** * Build compatibility class for Java. Use the [DatabaseConfig] class directly if Kotlin consumer. @@ -69,7 +69,7 @@ class DatabaseConfig( constructor(kClass: KClass<*>) : this(kClass.java) fun transactionManagerCreator(transactionManager: TransactionManagerCreator) = - transactionManagerCreator { databaseDefinition -> transactionManager.createManager(databaseDefinition) } + transactionManagerCreator { databaseDefinition -> transactionManager.createManager(databaseDefinition) } fun transactionManagerCreator(creator: (DatabaseDefinition) -> BaseTransactionManager) = apply { this.transactionManagerCreator = creator @@ -133,9 +133,9 @@ class DatabaseConfig( @JvmStatic fun inMemoryBuilder(database: Class<*>): Builder = - Builder(database).inMemory() + Builder(database).inMemory() fun inMemoryBuilder(database: KClass<*>): Builder = - Builder(database).inMemory() + Builder(database).inMemory() } } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseDefinition.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseDefinition.kt index 52443709f..3e50093a1 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseDefinition.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseDefinition.kt @@ -11,11 +11,11 @@ import com.raizlabs.dbflow5.adapter.saveable.ModelSaver import com.raizlabs.dbflow5.annotation.Database import com.raizlabs.dbflow5.annotation.QueryModel import com.raizlabs.dbflow5.annotation.Table +import com.raizlabs.dbflow5.database.AndroidSQLiteOpenHelper import com.raizlabs.dbflow5.database.DatabaseHelperListener import com.raizlabs.dbflow5.database.DatabaseStatement import com.raizlabs.dbflow5.database.DatabaseWrapper import com.raizlabs.dbflow5.database.FlowCursor -import com.raizlabs.dbflow5.database.AndroidSQLiteOpenHelper import com.raizlabs.dbflow5.database.OpenHelper import com.raizlabs.dbflow5.migration.Migration import com.raizlabs.dbflow5.runtime.DirectModelNotifier @@ -246,7 +246,7 @@ abstract class DatabaseDefinition : DatabaseWrapper { */ @Suppress("UNCHECKED_CAST") fun getModelViewAdapterForTable(table: Class): ModelViewAdapter? = - modelViewAdapterMap[table] as ModelViewAdapter? + modelViewAdapterMap[table] as ModelViewAdapter? /** * @param queryModel The [QueryModel] class @@ -254,7 +254,7 @@ abstract class DatabaseDefinition : DatabaseWrapper { */ @Suppress("UNCHECKED_CAST") fun getQueryModelAdapterForQueryClass(queryModel: Class): QueryModelAdapter? = - queryModelAdapterMap[queryModel] as QueryModelAdapter? + queryModelAdapterMap[queryModel] as QueryModelAdapter? fun getModelNotifier(): ModelNotifier { if (modelNotifier == null) { @@ -274,10 +274,10 @@ abstract class DatabaseDefinition : DatabaseWrapper { fun executeTransactionAsync(transaction: ITransaction, success: ((Transaction, R) -> Unit)? = null, error: ((Transaction, Throwable) -> Unit)? = null): Transaction - = beginTransactionAsync(transaction) - .success(success) - .error(error) - .execute() + = beginTransactionAsync(transaction) + .success(success) + .error(error) + .execute() /** * Executes and returns the executed transaction. @@ -292,12 +292,12 @@ abstract class DatabaseDefinition : DatabaseWrapper { fun beginTransactionAsync(transaction: ITransaction): Transaction.Builder = - Transaction.Builder(transaction, this) + Transaction.Builder(transaction, this) fun beginTransactionAsync(transaction: (DatabaseWrapper) -> R): Transaction.Builder = - beginTransactionAsync(object : ITransaction { - override fun execute(databaseWrapper: DatabaseWrapper) = transaction(databaseWrapper) - }) + beginTransactionAsync(object : ITransaction { + override fun execute(databaseWrapper: DatabaseWrapper) = transaction(databaseWrapper) + }) fun executeTransaction(transaction: ITransaction): R { val database = writableDatabase @@ -312,7 +312,7 @@ abstract class DatabaseDefinition : DatabaseWrapper { } inline fun executeTransaction(crossinline transaction: (DatabaseWrapper) -> R) - = executeTransaction(object : ITransaction { + = executeTransaction(object : ITransaction { override fun execute(databaseWrapper: DatabaseWrapper) = transaction(databaseWrapper) }) @@ -416,35 +416,35 @@ abstract class DatabaseDefinition : DatabaseWrapper { override fun endTransaction() = writableDatabase.endTransaction() override fun compileStatement(rawQuery: String): DatabaseStatement - = writableDatabase.compileStatement(rawQuery) + = writableDatabase.compileStatement(rawQuery) override fun rawQuery(query: String, selectionArgs: Array?): FlowCursor - = writableDatabase.rawQuery(query, selectionArgs) + = writableDatabase.rawQuery(query, selectionArgs) override fun updateWithOnConflict(tableName: String, contentValues: ContentValues, where: String?, whereArgs: Array?, conflictAlgorithm: Int): Long - = writableDatabase.updateWithOnConflict(tableName, contentValues, where, whereArgs, conflictAlgorithm) + = writableDatabase.updateWithOnConflict(tableName, contentValues, where, whereArgs, conflictAlgorithm) override fun insertWithOnConflict( - tableName: String, - nullColumnHack: String?, - values: ContentValues, - sqLiteDatabaseAlgorithmInt: Int): Long - = writableDatabase.insertWithOnConflict(tableName, nullColumnHack, values, sqLiteDatabaseAlgorithmInt) + tableName: String, + nullColumnHack: String?, + values: ContentValues, + sqLiteDatabaseAlgorithmInt: Int): Long + = writableDatabase.insertWithOnConflict(tableName, nullColumnHack, values, sqLiteDatabaseAlgorithmInt) override fun query( - tableName: String, - columns: Array?, - selection: String?, - selectionArgs: Array?, - groupBy: String?, - having: String?, - orderBy: String?): FlowCursor - = writableDatabase.query(tableName, columns, selection, selectionArgs, groupBy, having, orderBy) + tableName: String, + columns: Array?, + selection: String?, + selectionArgs: Array?, + groupBy: String?, + having: String?, + orderBy: String?): FlowCursor + = writableDatabase.query(tableName, columns, selection, selectionArgs, groupBy, having, orderBy) override fun delete(tableName: String, whereClause: String?, whereArgs: Array?): Int - = writableDatabase.delete(tableName, whereClause, whereArgs) + = writableDatabase.delete(tableName, whereClause, whereArgs) } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseHolder.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseHolder.kt index fc80ed5f6..9f9b7ea17 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseHolder.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseHolder.kt @@ -31,7 +31,7 @@ abstract class DatabaseHolder { fun getDatabaseForTable(table: Class<*>): DatabaseDefinition? = databaseDefinitionMap[table] fun getDatabase(databaseClass: Class<*>): DatabaseDefinition? = - databaseClassLookupMap[databaseClass] + databaseClassLookupMap[databaseClass] /** * @param databaseName The name of the database to retrieve diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowConfig.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowConfig.kt index ed499ac71..520770b41 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowConfig.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowConfig.kt @@ -11,10 +11,10 @@ class FlowConfig(val context: Context, val openDatabasesOnInit: Boolean = false) { internal constructor(builder: Builder) : this( - databaseHolders = builder.databaseHolders.toSet(), - databaseConfigMap = builder.databaseConfigMap, - context = builder.context, - openDatabasesOnInit = builder.openDatabasesOnInit + databaseHolders = builder.databaseHolders.toSet(), + databaseConfigMap = builder.databaseConfigMap, + context = builder.context, + openDatabasesOnInit = builder.openDatabasesOnInit ) fun getConfigForDatabase(databaseClass: Class<*>): DatabaseConfig? { diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/config/NaturalOrderComparator.java b/dbflow/src/main/java/com/raizlabs/dbflow5/config/NaturalOrderComparator.java index 94cbe7315..23a42a698 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/config/NaturalOrderComparator.java +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/config/NaturalOrderComparator.java @@ -122,8 +122,9 @@ int compareRight(String a, String b) { bias = -1; } } else if (ca > cb) { - if (bias == 0) + if (bias == 0) { bias = +1; + } } else if (ca == 0 && cb == 0) { return bias; } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/config/TableConfig.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/config/TableConfig.kt index 9ed8cc374..ac8c01553 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/config/TableConfig.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/config/TableConfig.kt @@ -16,10 +16,10 @@ class TableConfig(val tableClass: Class, val listModelLoader: ListModelLoader? = null) { internal constructor(builder: Builder) : this( - tableClass = builder.tableClass, - modelSaver = builder.modelAdapterModelSaver, - singleModelLoader = builder.singleModelLoader, - listModelLoader = builder.listModelLoader + tableClass = builder.tableClass, + modelSaver = builder.modelAdapterModelSaver, + singleModelLoader = builder.singleModelLoader, + listModelLoader = builder.listModelLoader ) /** @@ -65,9 +65,9 @@ class TableConfig(val tableClass: Class, @JvmStatic fun builder(tableClass: Class): Builder = - Builder(tableClass) + Builder(tableClass) fun builder(tableClass: KClass): Builder = - Builder(tableClass) + Builder(tableClass) } } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidSQLiteOpenHelper.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidSQLiteOpenHelper.kt index 7f52a9dde..e31e90dc9 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidSQLiteOpenHelper.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidSQLiteOpenHelper.kt @@ -11,12 +11,12 @@ import com.raizlabs.dbflow5.config.FlowManager * Description: Wraps around the [SQLiteOpenHelper] and provides extra features for use in this library. */ class AndroidSQLiteOpenHelper( - databaseDefinition: DatabaseDefinition, - listener: DatabaseHelperListener?) + databaseDefinition: DatabaseDefinition, + listener: DatabaseHelperListener?) : SQLiteOpenHelper(FlowManager.context, - if (databaseDefinition.isInMemory) null else databaseDefinition.databaseFileName, - null, - databaseDefinition.databaseVersion), OpenHelper { + if (databaseDefinition.isInMemory) null else databaseDefinition.databaseFileName, + null, + databaseDefinition.databaseVersion), OpenHelper { private val databaseHelperDelegate: DatabaseHelperDelegate private var androidDatabase: AndroidDatabase? = null @@ -26,8 +26,8 @@ class AndroidSQLiteOpenHelper( if (databaseDefinition.backupEnabled()) { // Temp database mirrors existing backupHelper = BackupHelper(FlowManager.context, - DatabaseHelperDelegate.getTempDbFileName(databaseDefinition), - databaseDefinition.databaseVersion, databaseDefinition) + DatabaseHelperDelegate.getTempDbFileName(databaseDefinition), + databaseDefinition.databaseVersion, databaseDefinition) } databaseHelperDelegate = DatabaseHelperDelegate(listener, databaseDefinition, backupHelper) diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseStatementWrapper.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseStatementWrapper.kt index b150bde94..2f4ef031b 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseStatementWrapper.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseStatementWrapper.kt @@ -1,21 +1,21 @@ package com.raizlabs.dbflow5.database -import com.raizlabs.dbflow5.runtime.NotifyDistributor import com.raizlabs.dbflow5.query.BaseQueriable +import com.raizlabs.dbflow5.runtime.NotifyDistributor /** * Description: Delegates all of its calls to the contained [DatabaseStatement], while * providing notification methods for when operations occur. */ class DatabaseStatementWrapper( - private val databaseStatement: DatabaseStatement, - private val modelQueriable: BaseQueriable) : BaseDatabaseStatement() { + private val databaseStatement: DatabaseStatement, + private val modelQueriable: BaseQueriable) : BaseDatabaseStatement() { override fun executeUpdateDelete(): Long { val affected = databaseStatement.executeUpdateDelete() if (affected > 0) { NotifyDistributor.get().notifyTableChanged(modelQueriable.table, - modelQueriable.primaryAction) + modelQueriable.primaryAction) } return affected } @@ -40,7 +40,7 @@ class DatabaseStatementWrapper( val affected = databaseStatement.executeInsert() if (affected > 0) { NotifyDistributor.get().notifyTableChanged(modelQueriable.table, - modelQueriable.primaryAction) + modelQueriable.primaryAction) } return affected } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/database/FlowCursor.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/database/FlowCursor.kt index 869d01d88..2a5b6cdee 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/database/FlowCursor.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/database/FlowCursor.kt @@ -21,7 +21,7 @@ class FlowCursor private constructor(private val cursor: Cursor) : CursorWrapper } fun getStringOrDefault(columnName: String): String? = - getStringOrDefault(cursor.getColumnIndex(columnName)) + getStringOrDefault(cursor.getColumnIndex(columnName)) fun getStringOrDefault(index: Int): String? { return if (index != -1 && !cursor.isNull(index)) { @@ -32,10 +32,10 @@ class FlowCursor private constructor(private val cursor: Cursor) : CursorWrapper } fun getStringOrDefault(columnName: String, defValue: String): String = - getStringOrDefault(cursor.getColumnIndex(columnName), defValue) + getStringOrDefault(cursor.getColumnIndex(columnName), defValue) fun getIntOrDefault(columnName: String): Int = - getIntOrDefault(cursor.getColumnIndex(columnName)) + getIntOrDefault(cursor.getColumnIndex(columnName)) fun getIntOrDefault(index: Int): Int { return if (index != -1 && !cursor.isNull(index)) { @@ -54,7 +54,7 @@ class FlowCursor private constructor(private val cursor: Cursor) : CursorWrapper } fun getIntOrDefault(columnName: String, defValue: Int): Int = - getIntOrDefault(cursor.getColumnIndex(columnName), defValue) + getIntOrDefault(cursor.getColumnIndex(columnName), defValue) fun getIntOrDefault(index: Int, defValue: Int?): Int? { return if (index != -1 && !cursor.isNull(index)) { @@ -65,7 +65,7 @@ class FlowCursor private constructor(private val cursor: Cursor) : CursorWrapper } fun getIntOrDefault(columnName: String, defValue: Int?): Int? = - getIntOrDefault(cursor.getColumnIndex(columnName), defValue) + getIntOrDefault(cursor.getColumnIndex(columnName), defValue) fun getDoubleOrDefault(index: Int, defValue: Double): Double { return if (index != -1 && !cursor.isNull(index)) { @@ -76,7 +76,7 @@ class FlowCursor private constructor(private val cursor: Cursor) : CursorWrapper } fun getDoubleOrDefault(columnName: String): Double = - getDoubleOrDefault(cursor.getColumnIndex(columnName)) + getDoubleOrDefault(cursor.getColumnIndex(columnName)) fun getDoubleOrDefault(index: Int): Double { return if (index != -1 && !cursor.isNull(index)) { @@ -87,7 +87,7 @@ class FlowCursor private constructor(private val cursor: Cursor) : CursorWrapper } fun getDoubleOrDefault(columnName: String, defValue: Double): Double = - getDoubleOrDefault(cursor.getColumnIndex(columnName), defValue) + getDoubleOrDefault(cursor.getColumnIndex(columnName), defValue) fun getDoubleOrDefault(index: Int, defValue: Double?): Double? { return if (index != -1 && !cursor.isNull(index)) { @@ -98,7 +98,7 @@ class FlowCursor private constructor(private val cursor: Cursor) : CursorWrapper } fun getDoubleOrDefault(columnName: String, defValue: Double?): Double? = - getDoubleOrDefault(cursor.getColumnIndex(columnName), defValue) + getDoubleOrDefault(cursor.getColumnIndex(columnName), defValue) fun getFloatOrDefault(index: Int, defValue: Float): Float { return if (index != -1 && !cursor.isNull(index)) { @@ -109,7 +109,7 @@ class FlowCursor private constructor(private val cursor: Cursor) : CursorWrapper } fun getFloatOrDefault(columnName: String): Float = - getFloatOrDefault(cursor.getColumnIndex(columnName)) + getFloatOrDefault(cursor.getColumnIndex(columnName)) fun getFloatOrDefault(index: Int): Float { return if (index != -1 && !cursor.isNull(index)) { @@ -120,7 +120,7 @@ class FlowCursor private constructor(private val cursor: Cursor) : CursorWrapper } fun getFloatOrDefault(columnName: String, defValue: Float): Float = - getFloatOrDefault(cursor.getColumnIndex(columnName), defValue) + getFloatOrDefault(cursor.getColumnIndex(columnName), defValue) fun getFloatOrDefault(index: Int, defValue: Float?): Float? { return if (index != -1 && !cursor.isNull(index)) { @@ -131,7 +131,7 @@ class FlowCursor private constructor(private val cursor: Cursor) : CursorWrapper } fun getFloatOrDefault(columnName: String, defValue: Float?): Float? = - getFloatOrDefault(cursor.getColumnIndex(columnName), defValue) + getFloatOrDefault(cursor.getColumnIndex(columnName), defValue) fun getLongOrDefault(index: Int, defValue: Long): Long { return if (index != -1 && !cursor.isNull(index)) { @@ -142,7 +142,7 @@ class FlowCursor private constructor(private val cursor: Cursor) : CursorWrapper } fun getLongOrDefault(columnName: String): Long = - getLongOrDefault(cursor.getColumnIndex(columnName)) + getLongOrDefault(cursor.getColumnIndex(columnName)) fun getLongOrDefault(index: Int): Long { return if (index != -1 && !cursor.isNull(index)) { @@ -153,7 +153,7 @@ class FlowCursor private constructor(private val cursor: Cursor) : CursorWrapper } fun getLongOrDefault(columnName: String, defValue: Long): Long = - getLongOrDefault(cursor.getColumnIndex(columnName), defValue) + getLongOrDefault(cursor.getColumnIndex(columnName), defValue) fun getLongOrDefault(index: Int, defValue: Long?): Long? { return if (index != -1 && !cursor.isNull(index)) { @@ -164,7 +164,7 @@ class FlowCursor private constructor(private val cursor: Cursor) : CursorWrapper } fun getLongOrDefault(columnName: String, defValue: Long?): Long? = - getLongOrDefault(cursor.getColumnIndex(columnName), defValue) + getLongOrDefault(cursor.getColumnIndex(columnName), defValue) fun getShortOrDefault(index: Int, defValue: Short): Short { return if (index != -1 && !cursor.isNull(index)) { @@ -175,7 +175,7 @@ class FlowCursor private constructor(private val cursor: Cursor) : CursorWrapper } fun getShortOrDefault(columnName: String): Short = - getShortOrDefault(cursor.getColumnIndex(columnName)) + getShortOrDefault(cursor.getColumnIndex(columnName)) fun getShortOrDefault(index: Int): Short { return if (index != -1 && !cursor.isNull(index)) { @@ -186,7 +186,7 @@ class FlowCursor private constructor(private val cursor: Cursor) : CursorWrapper } fun getShortOrDefault(columnName: String, defValue: Short): Short = - getShortOrDefault(cursor.getColumnIndex(columnName), defValue) + getShortOrDefault(cursor.getColumnIndex(columnName), defValue) fun getShortOrDefault(index: Int, defValue: Short?): Short? { return if (index != -1 && !cursor.isNull(index)) { @@ -197,10 +197,10 @@ class FlowCursor private constructor(private val cursor: Cursor) : CursorWrapper } fun getShortOrDefault(columnName: String, defValue: Short?): Short? = - getShortOrDefault(cursor.getColumnIndex(columnName), defValue) + getShortOrDefault(cursor.getColumnIndex(columnName), defValue) fun getBlobOrDefault(columnName: String): ByteArray? = - getBlobOrDefault(cursor.getColumnIndex(columnName)) + getBlobOrDefault(cursor.getColumnIndex(columnName)) fun getBlobOrDefault(index: Int): ByteArray? { return if (index != -1 && !cursor.isNull(index)) { @@ -219,7 +219,7 @@ class FlowCursor private constructor(private val cursor: Cursor) : CursorWrapper } fun getBlobOrDefault(columnName: String, defValue: ByteArray): ByteArray = - getBlobOrDefault(cursor.getColumnIndex(columnName), defValue) + getBlobOrDefault(cursor.getColumnIndex(columnName), defValue) fun getBooleanOrDefault(index: Int, defValue: Boolean): Boolean { return if (index != -1 && !cursor.isNull(index)) { @@ -230,7 +230,7 @@ class FlowCursor private constructor(private val cursor: Cursor) : CursorWrapper } fun getBooleanOrDefault(columnName: String): Boolean = - getBooleanOrDefault(cursor.getColumnIndex(columnName)) + getBooleanOrDefault(cursor.getColumnIndex(columnName)) fun getBooleanOrDefault(index: Int): Boolean { return if (index != -1 && !cursor.isNull(index)) { @@ -241,7 +241,7 @@ class FlowCursor private constructor(private val cursor: Cursor) : CursorWrapper } fun getBooleanOrDefault(columnName: String, defValue: Boolean): Boolean = - getBooleanOrDefault(cursor.getColumnIndex(columnName), defValue) + getBooleanOrDefault(cursor.getColumnIndex(columnName), defValue) fun getBoolean(index: Int): Boolean = cursor.getInt(index) == 1 diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/database/OpenHelper.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/database/OpenHelper.kt index 53434742f..9688886a9 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/database/OpenHelper.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/database/OpenHelper.kt @@ -1,9 +1,5 @@ package com.raizlabs.dbflow5.database -import com.raizlabs.dbflow5.database.DatabaseHelperDelegate -import com.raizlabs.dbflow5.database.DatabaseHelperListener -import com.raizlabs.dbflow5.database.DatabaseWrapper - /** * Description: Abstracts out the [DatabaseHelperDelegate] into the one used in this library. */ diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/migration/AlterTableMigration.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/migration/AlterTableMigration.kt index 0b3339790..3cbded752 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/migration/AlterTableMigration.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/migration/AlterTableMigration.kt @@ -13,10 +13,10 @@ import com.raizlabs.dbflow5.stripQuotes * Description: Provides a very nice way to alter a single table quickly and easily. */ class AlterTableMigration( - /** - * The table to ALTER - */ - private val table: Class) : BaseMigration() { + /** + * The table to ALTER + */ + private val table: Class) : BaseMigration() { /** * The query to rename the table with diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/migration/IndexMigration.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/migration/IndexMigration.kt index e10bbf79c..d703e89a5 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/migration/IndexMigration.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/migration/IndexMigration.kt @@ -8,10 +8,10 @@ import com.raizlabs.dbflow5.query.property.IProperty * Description: Defines and enables an Index structurally through a migration. */ abstract class IndexMigration( - /** - * The table to index on - */ - private var onTable: Class) : BaseMigration() { + /** + * The table to index on + */ + private var onTable: Class) : BaseMigration() { private var unique: Boolean = false private val columns = arrayListOf>() diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/migration/IndexPropertyMigration.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/migration/IndexPropertyMigration.kt index 5504427a4..b6f598648 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/migration/IndexPropertyMigration.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/migration/IndexPropertyMigration.kt @@ -1,17 +1,16 @@ package com.raizlabs.dbflow5.migration -import com.raizlabs.dbflow5.query.property.IndexProperty import com.raizlabs.dbflow5.database.DatabaseWrapper -import com.raizlabs.dbflow5.migration.BaseMigration +import com.raizlabs.dbflow5.query.property.IndexProperty /** * Description: Allows you to specify if and when an [IndexProperty] gets used or created. */ abstract class IndexPropertyMigration( - /** - * @return true if create the index, false to drop the index. - */ - open val shouldCreate: Boolean = true) : BaseMigration() { + /** + * @return true if create the index, false to drop the index. + */ + open val shouldCreate: Boolean = true) : BaseMigration() { abstract val indexProperty: IndexProperty<*> diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/migration/UpdateTableMigration.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/migration/UpdateTableMigration.kt index d14c72640..d0c92805a 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/migration/UpdateTableMigration.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/migration/UpdateTableMigration.kt @@ -1,10 +1,10 @@ package com.raizlabs.dbflow5.migration +import com.raizlabs.dbflow5.database.DatabaseWrapper import com.raizlabs.dbflow5.query.BaseQueriable import com.raizlabs.dbflow5.query.OperatorGroup import com.raizlabs.dbflow5.query.SQLOperator import com.raizlabs.dbflow5.query.update -import com.raizlabs.dbflow5.database.DatabaseWrapper /** * Description: Provides a simple way to update a table's field or fields quickly in a migration. @@ -18,10 +18,10 @@ open class UpdateTableMigration * @param table The table to update */ ( - /** - * The table to update - */ - private val table: Class) : BaseMigration() { + /** + * The table to update + */ + private val table: Class) : BaseMigration() { /** * Builds the conditions for the WHERE part of our query @@ -35,8 +35,8 @@ open class UpdateTableMigration val DatabaseWrapper.updateStatement: BaseQueriable get() = update(table) - .set(setOperatorGroup) - .where(whereOperatorGroup) + .set(setOperatorGroup) + .where(whereOperatorGroup) /** * This will append a condition to this migration. It will execute each of these in succession with the order diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/provider/BaseContentProvider.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/provider/BaseContentProvider.kt index 07e13ec49..807d4529d 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/provider/BaseContentProvider.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/provider/BaseContentProvider.kt @@ -27,8 +27,8 @@ protected constructor(databaseHolderClass: Class? = null) : // of the creation process. We can assume the framework has been general // framework has been initialized. moduleClass - ?.let { FlowManager.initModule(it) } - ?: context?.let { FlowManager.init(it) } + ?.let { FlowManager.initModule(it) } + ?: context?.let { FlowManager.init(it) } return true } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/provider/ModelProvider.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/provider/ModelProvider.kt index 516252331..973b6b112 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/provider/ModelProvider.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/provider/ModelProvider.kt @@ -40,9 +40,9 @@ interface ModelProvider { * @param columns The list of columns to select. Leave blank for * */ fun load(whereOperatorGroup: OperatorGroup, - orderBy: String?, - wrapper: DatabaseWrapper, - vararg columns: String?) : T? + orderBy: String?, + wrapper: DatabaseWrapper, + vararg columns: String?): T? /** * Queries the [ContentResolver] of the app based on the primary keys of the object and returns a diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseModelQueriable.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseModelQueriable.kt index c03281369..7d4ca9a07 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseModelQueriable.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseModelQueriable.kt @@ -1,15 +1,15 @@ package com.raizlabs.dbflow5.query +import com.raizlabs.dbflow5.adapter.InstanceAdapter +import com.raizlabs.dbflow5.adapter.queriable.ListModelLoader +import com.raizlabs.dbflow5.adapter.queriable.SingleModelLoader import com.raizlabs.dbflow5.config.FlowLog import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.database.DatabaseWrapper import com.raizlabs.dbflow5.query.list.FlowCursorList import com.raizlabs.dbflow5.query.list.FlowQueryList import com.raizlabs.dbflow5.runtime.NotifyDistributor import com.raizlabs.dbflow5.sql.Query -import com.raizlabs.dbflow5.adapter.queriable.ListModelLoader -import com.raizlabs.dbflow5.adapter.queriable.SingleModelLoader -import com.raizlabs.dbflow5.adapter.InstanceAdapter -import com.raizlabs.dbflow5.database.DatabaseWrapper /** * Description: Provides a base implementation of [ModelQueriable] to simplify a lot of code. It provides the @@ -50,7 +50,7 @@ protected constructor(val databaseWrapper: DatabaseWrapper, override fun cursorList(): FlowCursorList = FlowCursorList.Builder(this).build() override fun flowQueryList(): FlowQueryList = - FlowQueryList.Builder(modelQueriable = this).build() + FlowQueryList.Builder(modelQueriable = this).build() override fun executeUpdateDelete(): Long { val affected = databaseWrapper.compileStatement(query).executeUpdateDelete() diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseTransformable.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseTransformable.kt index f0ffc9d30..97672e7bc 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseTransformable.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseTransformable.kt @@ -1,8 +1,8 @@ package com.raizlabs.dbflow5.query -import com.raizlabs.dbflow5.query.property.IProperty import com.raizlabs.dbflow5.database.DatabaseWrapper import com.raizlabs.dbflow5.database.FlowCursor +import com.raizlabs.dbflow5.query.property.IProperty /** * Description: Combines basic transformations and query ops into a base class. @@ -21,21 +21,21 @@ protected constructor(databaseWrapper: DatabaseWrapper, fun where(vararg conditions: SQLOperator): Where = Where(this, *conditions) - infix fun where(condition: SQLOperator) : Where = Where(this, condition) + infix fun where(condition: SQLOperator): Where = Where(this, condition) override fun query(): FlowCursor? = where().query() override fun groupBy(vararg nameAliases: NameAlias): Where = - where().groupBy(*nameAliases) + where().groupBy(*nameAliases) override fun groupBy(vararg properties: IProperty<*>): Where = - where().groupBy(*properties) + where().groupBy(*properties) override fun orderBy(nameAlias: NameAlias, ascending: Boolean): Where = - where().orderBy(nameAlias, ascending) + where().orderBy(nameAlias, ascending) override fun orderBy(property: IProperty<*>, ascending: Boolean): Where = - where().orderBy(property, ascending) + where().orderBy(property, ascending) override fun orderByAll(orderBies: List): Where = where().orderByAll(orderBies) diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/Case.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Case.kt index 662a18105..ccc04c83d 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/Case.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Case.kt @@ -1,9 +1,9 @@ package com.raizlabs.dbflow5.query -import com.raizlabs.dbflow5.quoteIfNeeded -import com.raizlabs.dbflow5.sql.Query import com.raizlabs.dbflow5.query.property.IProperty import com.raizlabs.dbflow5.query.property.Property +import com.raizlabs.dbflow5.quoteIfNeeded +import com.raizlabs.dbflow5.sql.Query /** * Description: Represents a SQLITE CASE argument. diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/CaseCondition.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/CaseCondition.kt index 0a3ddc3bb..7896f67e0 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/CaseCondition.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/CaseCondition.kt @@ -1,7 +1,7 @@ package com.raizlabs.dbflow5.query -import com.raizlabs.dbflow5.sql.Query import com.raizlabs.dbflow5.query.property.IProperty +import com.raizlabs.dbflow5.sql.Query /** * Description: Represents an individual condition inside a CASE. @@ -26,7 +26,7 @@ class CaseCondition : Query { } append(" THEN ") append(BaseOperator.convertValueToString( - if (isThenPropertySet) thenProperty else thenValue, false)) + if (isThenPropertySet) thenProperty else thenValue, false)) } internal constructor(caze: Case, sqlOperator: SQLOperator) { diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/ContentValuesListener.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/ContentValuesListener.kt index dba6bdff0..436e19f5d 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/ContentValuesListener.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/ContentValuesListener.kt @@ -1,10 +1,9 @@ package com.raizlabs.dbflow5.query import android.content.ContentValues - +import com.raizlabs.dbflow5.adapter.ModelAdapter import com.raizlabs.dbflow5.annotation.provider.ContentProvider import com.raizlabs.dbflow5.structure.Model -import com.raizlabs.dbflow5.adapter.ModelAdapter /** * Description: Called after the declared [ContentValues] are binded. It enables diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/Delete.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Delete.kt index 43386cc92..8c8731998 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/Delete.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Delete.kt @@ -1,7 +1,7 @@ package com.raizlabs.dbflow5.query -import com.raizlabs.dbflow5.sql.Query import com.raizlabs.dbflow5.database.DatabaseWrapper +import com.raizlabs.dbflow5.sql.Query import kotlin.reflect.KClass /** diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/From.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/From.kt index 8a64d92ad..800ce7543 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/From.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/From.kt @@ -1,11 +1,11 @@ package com.raizlabs.dbflow5.query import com.raizlabs.dbflow5.config.FlowManager -import com.raizlabs.dbflow5.sql.Query +import com.raizlabs.dbflow5.database.DatabaseWrapper import com.raizlabs.dbflow5.query.Join.JoinType import com.raizlabs.dbflow5.query.property.IndexProperty +import com.raizlabs.dbflow5.sql.Query import com.raizlabs.dbflow5.structure.ChangeAction -import com.raizlabs.dbflow5.database.DatabaseWrapper import kotlin.collections.Set as KSet /** @@ -19,12 +19,12 @@ class From * @param table The table this corresponds to */ internal constructor( - databaseWrapper: DatabaseWrapper, + databaseWrapper: DatabaseWrapper, - /** - * @return The base query, usually a [Delete], [Select], or [Update] - */ - override val queryBuilderBase: Query, table: Class) + /** + * @return The base query, usually a [Delete], [Select], or [Update] + */ + override val queryBuilderBase: Query, table: Class) : BaseTransformable(databaseWrapper, table) { /** @@ -43,7 +43,7 @@ internal constructor( override val query: String get() { val queryBuilder = StringBuilder() - .append(queryBuilderBase.query) + .append(queryBuilderBase.query) if (queryBuilderBase !is Update<*>) { queryBuilder.append("FROM ") } @@ -85,9 +85,9 @@ internal constructor( */ infix fun `as`(alias: String): From { tableAlias = getTableAlias() - .newBuilder() - .`as`(alias) - .build() + .newBuilder() + .`as`(alias) + .build() return this } @@ -130,7 +130,7 @@ internal constructor( * @param The class of the join table. */ fun crossJoin(modelQueriable: ModelQueriable): Join = - join(modelQueriable, JoinType.CROSS) + join(modelQueriable, JoinType.CROSS) /** * Adds a [JoinType.INNER] join on a specific table for this query. @@ -147,7 +147,7 @@ internal constructor( * @param The class of the join table. */ fun innerJoin(modelQueriable: ModelQueriable): Join = - join(modelQueriable, JoinType.INNER) + join(modelQueriable, JoinType.INNER) /** * Adds a [JoinType.LEFT_OUTER] join on a specific table for this query. @@ -156,7 +156,7 @@ internal constructor( * @param The class of the join table. */ fun leftOuterJoin(table: Class): Join = - join(table, JoinType.LEFT_OUTER) + join(table, JoinType.LEFT_OUTER) /** * Adds a [JoinType.LEFT_OUTER] join on a specific table for this query. @@ -165,7 +165,7 @@ internal constructor( * @param The class of the join table. */ fun leftOuterJoin(modelQueriable: ModelQueriable): Join = - join(modelQueriable, JoinType.LEFT_OUTER) + join(modelQueriable, JoinType.LEFT_OUTER) /** @@ -175,7 +175,7 @@ internal constructor( * @param The class of the join table. */ fun naturalJoin(table: Class): Join = - join(table, JoinType.NATURAL) + join(table, JoinType.NATURAL) /** * Adds a [JoinType.NATURAL] join on a specific table for this query. @@ -184,7 +184,7 @@ internal constructor( * @param The class of the join table. */ fun naturalJoin(modelQueriable: ModelQueriable): Join = - join(modelQueriable, JoinType.NATURAL) + join(modelQueriable, JoinType.NATURAL) /** * Begins an INDEXED BY piece of this query with the specified name. @@ -192,6 +192,6 @@ internal constructor( * @param indexProperty The index property generated. */ fun indexedBy(indexProperty: IndexProperty): IndexedBy = - IndexedBy(indexProperty, this) + IndexedBy(indexProperty, this) } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/IndexedBy.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/IndexedBy.kt index 7452cedba..5839a1d04 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/IndexedBy.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/IndexedBy.kt @@ -1,8 +1,8 @@ package com.raizlabs.dbflow5.query +import com.raizlabs.dbflow5.query.property.IndexProperty import com.raizlabs.dbflow5.quoteIfNeeded import com.raizlabs.dbflow5.sql.Query -import com.raizlabs.dbflow5.query.property.IndexProperty import com.raizlabs.dbflow5.structure.ChangeAction /** diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/Join.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Join.kt index 371b0eac6..71a61cec9 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/Join.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Join.kt @@ -47,19 +47,19 @@ class Join : Query { queryBuilder.append(type.name.replace("_", " ")).append(" ") queryBuilder.append("JOIN") - .append(" ") - .append(alias.fullQuery) - .append(" ") + .append(" ") + .append(alias.fullQuery) + .append(" ") if (JoinType.NATURAL != type) { onGroup?.let { onGroup -> queryBuilder.append("ON") - .append(" ") - .append(onGroup.query) - .append(" ") + .append(" ") + .append(onGroup.query) + .append(" ") } ?: if (!using.isEmpty()) { queryBuilder.append("USING (") - .appendList(using) - .append(") ") + .appendList(using) + .append(") ") } } return queryBuilder.toString() @@ -127,9 +127,9 @@ class Join : Query { */ fun `as`(alias: String) = apply { this.alias = this.alias - .newBuilder() - .`as`(alias) - .build() + .newBuilder() + .`as`(alias) + .build() } /** diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/Method.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Method.kt index 050b0d176..8cab4c22d 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/Method.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Method.kt @@ -30,19 +30,19 @@ class Method(methodName: String, vararg properties: IProperty<*>) : Property): Method = - append(property, " " + Operator.Operation.PLUS) + append(property, " " + Operator.Operation.PLUS) override fun minus(property: IProperty<*>): Method = - append(property, " " + Operator.Operation.MINUS) + append(property, " " + Operator.Operation.MINUS) override fun div(property: IProperty<*>): Property = - append(property, " " + Operator.Operation.DIVISION) + append(property, " " + Operator.Operation.DIVISION) override fun times(property: IProperty<*>): Property = - append(property, " " + Operator.Operation.MULTIPLY) + append(property, " " + Operator.Operation.MULTIPLY) override fun rem(property: IProperty<*>): Property = - append(property, " " + Operator.Operation.MOD) + append(property, " " + Operator.Operation.MOD) /** * Allows adding a property to the [Method]. Will remove the [Property.ALL_PROPERTY] @@ -102,11 +102,11 @@ class Method(methodName: String, vararg properties: IProperty<*>) : Property { val newProperty = Property(property.table, - property.nameAlias - .newBuilder() - .shouldAddIdentifierToAliasName(false) - .`as`(sqLiteType.name) - .build()) + property.nameAlias + .newBuilder() + .shouldAddIdentifierToAliasName(false) + .`as`(sqLiteType.name) + .build()) return Method("CAST", newProperty) } } @@ -132,7 +132,7 @@ fun count(vararg properties: IProperty<*>): Method = Method("COUNT", *properties * @return A string which is the concatenation of all non-NULL values of the properties. */ fun group_concat(vararg properties: IProperty<*>): Method = - Method("GROUP_CONCAT", *properties) + Method("GROUP_CONCAT", *properties) /** * @param properties Set of properties that the method acts on. @@ -165,7 +165,7 @@ fun total(vararg properties: IProperty<*>): Method = Method("TOTAL", *properties fun cast(property: IProperty<*>): Method.Cast = Method.Cast(property) fun replace(property: IProperty<*>, findString: String, replacement: String): Method = - Method("REPLACE", property, PropertyFactory.from(findString), PropertyFactory.from(replacement)) + Method("REPLACE", property, PropertyFactory.from(findString), PropertyFactory.from(replacement)) /** * SQLite standard "strftime()" method. See SQLite documentation on this method. diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/ModelQueriable.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/ModelQueriable.kt index f8bcc08a5..041a252a0 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/ModelQueriable.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/ModelQueriable.kt @@ -1,9 +1,9 @@ package com.raizlabs.dbflow5.query +import com.raizlabs.dbflow5.database.FlowCursor import com.raizlabs.dbflow5.query.list.FlowCursorList import com.raizlabs.dbflow5.query.list.FlowQueryList import com.raizlabs.dbflow5.structure.BaseQueryModel -import com.raizlabs.dbflow5.database.FlowCursor /** * Description: An interface for query objects to enable you to query from the database in a structured way. diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/NameAlias.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/NameAlias.kt index cba8741b1..6e7eb30e5 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/NameAlias.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/NameAlias.kt @@ -55,26 +55,26 @@ class NameAlias(private val name: String, } private constructor(builder: Builder) : this( - name = if (builder.shouldStripIdentifier) { - builder.name.stripQuotes() ?: "" - } else { - builder.name - }, - keyword = builder.keyword, - aliasName = if (builder.shouldStripAliasName) { - builder.aliasName.stripQuotes() - } else { - builder.aliasName - }, - tableName = if (builder.tableName.isNotNullOrEmpty()) { - builder.tableName.quoteIfNeeded() - } else { - null - }, - shouldStripIdentifier = builder.shouldStripIdentifier, - shouldStripAliasName = builder.shouldStripAliasName, - shouldAddIdentifierToQuery = builder.shouldAddIdentifierToQuery, - shouldAddIdentifierToAliasName = builder.shouldAddIdentifierToAliasName) + name = if (builder.shouldStripIdentifier) { + builder.name.stripQuotes() ?: "" + } else { + builder.name + }, + keyword = builder.keyword, + aliasName = if (builder.shouldStripAliasName) { + builder.aliasName.stripQuotes() + } else { + builder.aliasName + }, + tableName = if (builder.tableName.isNotNullOrEmpty()) { + builder.tableName.quoteIfNeeded() + } else { + null + }, + shouldStripIdentifier = builder.shouldStripIdentifier, + shouldStripAliasName = builder.shouldStripAliasName, + shouldAddIdentifierToQuery = builder.shouldAddIdentifierToQuery, + shouldAddIdentifierToAliasName = builder.shouldAddIdentifierToAliasName) /** * @return The real column name. @@ -103,13 +103,13 @@ class NameAlias(private val name: String, * @return The alias name, stripped from identifier syntax completely. */ fun aliasNameRaw(): String? = - if (shouldStripAliasName) aliasName else aliasName.stripQuotes() + if (shouldStripAliasName) aliasName else aliasName.stripQuotes() /** * @return The `{tableName}`.`{name}`. If [.tableName] specified. */ fun fullName(): String = - (if (tableName.isNotNullOrEmpty()) "$tableName." else "") + name() + (if (tableName.isNotNullOrEmpty()) "$tableName." else "") + name() override fun toString(): String = fullQuery @@ -118,13 +118,13 @@ class NameAlias(private val name: String, */ fun newBuilder(): Builder { return Builder(name) - .keyword(keyword) - .`as`(aliasName) - .shouldStripAliasName(shouldStripAliasName) - .shouldStripIdentifier(shouldStripIdentifier) - .shouldAddIdentifierToName(shouldAddIdentifierToQuery) - .shouldAddIdentifierToAliasName(shouldAddIdentifierToAliasName) - .withTable(tableName) + .keyword(keyword) + .`as`(aliasName) + .shouldStripAliasName(shouldStripAliasName) + .shouldStripIdentifier(shouldStripIdentifier) + .shouldAddIdentifierToName(shouldAddIdentifierToQuery) + .shouldAddIdentifierToAliasName(shouldAddIdentifierToAliasName) + .withTable(tableName) } @@ -226,17 +226,17 @@ class NameAlias(private val name: String, */ fun rawBuilder(name: String): Builder { return Builder(name) - .shouldStripIdentifier(false) - .shouldAddIdentifierToName(false) + .shouldStripIdentifier(false) + .shouldAddIdentifierToName(false) } fun of(name: String): NameAlias = builder(name).build() fun of(name: String, aliasName: String): NameAlias = - builder(name).`as`(aliasName).build() + builder(name).`as`(aliasName).build() fun ofTable(tableName: String, name: String): NameAlias = - builder(name).withTable(tableName).build() + builder(name).withTable(tableName).build() } } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/Operator.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Operator.kt index cf1830296..aff02b74b 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/Operator.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Operator.kt @@ -213,80 +213,80 @@ class Operator : BaseOperator, IOperator { } override fun `is`(conditional: IConditional): Operator<*> = - assignValueOp(conditional, Operation.EQUALS) + assignValueOp(conditional, Operation.EQUALS) override fun eq(conditional: IConditional): Operator<*> = - assignValueOp(conditional, Operation.EQUALS) + assignValueOp(conditional, Operation.EQUALS) override fun isNot(conditional: IConditional): Operator<*> = - assignValueOp(conditional, Operation.NOT_EQUALS) + assignValueOp(conditional, Operation.NOT_EQUALS) override fun notEq(conditional: IConditional): Operator<*> = - assignValueOp(conditional, Operation.NOT_EQUALS) + assignValueOp(conditional, Operation.NOT_EQUALS) override fun like(conditional: IConditional): Operator = like(conditional.query) override fun glob(conditional: IConditional): Operator = glob(conditional.query) override fun greaterThan(conditional: IConditional): Operator = - assignValueOp(conditional, Operation.GREATER_THAN) + assignValueOp(conditional, Operation.GREATER_THAN) override fun greaterThanOrEq(conditional: IConditional): Operator = - assignValueOp(conditional, Operation.GREATER_THAN_OR_EQUALS) + assignValueOp(conditional, Operation.GREATER_THAN_OR_EQUALS) override fun lessThan(conditional: IConditional): Operator = - assignValueOp(conditional, Operation.LESS_THAN) + assignValueOp(conditional, Operation.LESS_THAN) override fun lessThanOrEq(conditional: IConditional): Operator = - assignValueOp(conditional, Operation.LESS_THAN_OR_EQUALS) + assignValueOp(conditional, Operation.LESS_THAN_OR_EQUALS) override fun between(conditional: IConditional): Between<*> = Between(this as Operator, conditional) override fun `in`(firstConditional: IConditional, vararg conditionals: IConditional): In<*> = - In(this as Operator, firstConditional, true, *conditionals) + In(this as Operator, firstConditional, true, *conditionals) override fun notIn(firstConditional: IConditional, vararg conditionals: IConditional): In<*> = - In(this as Operator, firstConditional, false, *conditionals) + In(this as Operator, firstConditional, false, *conditionals) override fun notIn(firstBaseModelQueriable: BaseModelQueriable<*>, vararg baseModelQueriables: BaseModelQueriable<*>): In<*> = - In(this as Operator, firstBaseModelQueriable, false, *baseModelQueriables) + In(this as Operator, firstBaseModelQueriable, false, *baseModelQueriables) override fun `is`(baseModelQueriable: BaseModelQueriable<*>): Operator<*> = - assignValueOp(baseModelQueriable, Operation.EQUALS) + assignValueOp(baseModelQueriable, Operation.EQUALS) override fun eq(baseModelQueriable: BaseModelQueriable<*>): Operator<*> = - assignValueOp(baseModelQueriable, Operation.EQUALS) + assignValueOp(baseModelQueriable, Operation.EQUALS) override fun isNot(baseModelQueriable: BaseModelQueriable<*>): Operator<*> = - assignValueOp(baseModelQueriable, Operation.NOT_EQUALS) + assignValueOp(baseModelQueriable, Operation.NOT_EQUALS) override fun notEq(baseModelQueriable: BaseModelQueriable<*>): Operator<*> = - assignValueOp(baseModelQueriable, Operation.NOT_EQUALS) + assignValueOp(baseModelQueriable, Operation.NOT_EQUALS) override fun like(baseModelQueriable: BaseModelQueriable<*>): Operator = - assignValueOp(baseModelQueriable, Operation.LIKE) + assignValueOp(baseModelQueriable, Operation.LIKE) override fun notLike(conditional: IConditional): Operator<*> = - assignValueOp(conditional, Operation.NOT_LIKE) + assignValueOp(conditional, Operation.NOT_LIKE) override fun notLike(baseModelQueriable: BaseModelQueriable<*>): Operator<*> = - assignValueOp(baseModelQueriable, Operation.NOT_LIKE) + assignValueOp(baseModelQueriable, Operation.NOT_LIKE) override fun glob(baseModelQueriable: BaseModelQueriable<*>): Operator = - assignValueOp(baseModelQueriable, Operation.GLOB) + assignValueOp(baseModelQueriable, Operation.GLOB) override fun greaterThan(baseModelQueriable: BaseModelQueriable<*>): Operator = - assignValueOp(baseModelQueriable, Operation.GREATER_THAN) + assignValueOp(baseModelQueriable, Operation.GREATER_THAN) override fun greaterThanOrEq(baseModelQueriable: BaseModelQueriable<*>): Operator = - assignValueOp(baseModelQueriable, Operation.GREATER_THAN_OR_EQUALS) + assignValueOp(baseModelQueriable, Operation.GREATER_THAN_OR_EQUALS) override fun lessThan(baseModelQueriable: BaseModelQueriable<*>): Operator = - assignValueOp(baseModelQueriable, Operation.LESS_THAN) + assignValueOp(baseModelQueriable, Operation.LESS_THAN) override fun lessThanOrEq(baseModelQueriable: BaseModelQueriable<*>): Operator = - assignValueOp(baseModelQueriable, Operation.LESS_THAN_OR_EQUALS) + assignValueOp(baseModelQueriable, Operation.LESS_THAN_OR_EQUALS) operator fun plus(value: IConditional): Operator<*> = assignValueOp(value, Operation.PLUS) @@ -299,25 +299,25 @@ class Operator : BaseOperator, IOperator { operator fun rem(value: IConditional): Operator<*> = assignValueOp(value, Operation.MOD) override fun plus(value: BaseModelQueriable<*>): Operator<*> = - assignValueOp(value, Operation.PLUS) + assignValueOp(value, Operation.PLUS) override fun minus(value: BaseModelQueriable<*>): Operator<*> = - assignValueOp(value, Operation.MINUS) + assignValueOp(value, Operation.MINUS) override fun div(value: BaseModelQueriable<*>): Operator<*> = - assignValueOp(value, Operation.DIVISION) + assignValueOp(value, Operation.DIVISION) override fun times(value: BaseModelQueriable<*>): Operator<*> = - assignValueOp(value, Operation.MULTIPLY) + assignValueOp(value, Operation.MULTIPLY) override fun rem(value: BaseModelQueriable<*>): Operator<*> = - assignValueOp(value, Operation.MOD) + assignValueOp(value, Operation.MOD) override fun between(baseModelQueriable: BaseModelQueriable<*>): Between<*> = - Between(this as Operator, baseModelQueriable) + Between(this as Operator, baseModelQueriable) override fun `in`(firstBaseModelQueriable: BaseModelQueriable<*>, vararg baseModelQueriables: BaseModelQueriable<*>): In<*> = - In(this as Operator, firstBaseModelQueriable, true, *baseModelQueriables) + In(this as Operator, firstBaseModelQueriable, true, *baseModelQueriables) override fun concatenate(value: Any?): Operator { var _value = value @@ -334,7 +334,7 @@ class Operator : BaseOperator, IOperator { is String, is IOperator<*>, is Char -> "$operation ${Operation.CONCATENATE} " is Number -> "$operation ${Operation.PLUS} " else -> throw IllegalArgumentException( - "Cannot concatenate the ${if (_value != null) _value.javaClass else "null"}") + "Cannot concatenate the ${if (_value != null) _value.javaClass else "null"}") } this.value = _value isValueSet = true @@ -342,7 +342,7 @@ class Operator : BaseOperator, IOperator { } override fun concatenate(conditional: IConditional): Operator = - concatenate(conditional as Any) + concatenate(conditional as Any) /** * Turns this condition into a SQL BETWEEN operation @@ -354,28 +354,28 @@ class Operator : BaseOperator, IOperator { @SafeVarargs override fun `in`(firstValue: T, vararg values: T): In = - In(this, firstValue, true, *values) + In(this, firstValue, true, *values) @SafeVarargs override fun notIn(firstValue: T, vararg values: T): In = - In(this, firstValue, false, *values) + In(this, firstValue, false, *values) override fun `in`(values: Collection): In = In(this, values, true) override fun notIn(values: Collection): In = In(this, values, false) override fun convertObjectToString(obj: Any?, appendInnerParenthesis: Boolean): String? = - (typeConverter as? TypeConverter<*, Any>?)?.let { typeConverter -> - var converted = obj - try { - converted = if (convertToDB) typeConverter.getDBValue(obj) else obj - } catch (c: ClassCastException) { - // if object type is not valid converted type, just use type as is here. - FlowLog.log(FlowLog.Level.W, throwable = c) - } - - convertValueToString(converted, appendInnerParenthesis, false) - } ?: super.convertObjectToString(obj, appendInnerParenthesis) + (typeConverter as? TypeConverter<*, Any>?)?.let { typeConverter -> + var converted = obj + try { + converted = if (convertToDB) typeConverter.getDBValue(obj) else obj + } catch (c: ClassCastException) { + // if object type is not valid converted type, just use type as is here. + FlowLog.log(FlowLog.Level.W, throwable = c) + } + + convertValueToString(converted, appendInnerParenthesis, false) + } ?: super.convertObjectToString(obj, appendInnerParenthesis) private fun assignValueOp(value: Any?, operation: String): Operator { this.operation = operation @@ -540,11 +540,11 @@ class Operator : BaseOperator, IOperator { override fun appendConditionToQuery(queryBuilder: StringBuilder) { queryBuilder.append(columnName()).append(operation()) - .append(convertObjectToString(value(), true)) - .append(" ${Operation.AND} ") - .append(convertObjectToString(secondValue(), true)) - .append(" ") - .appendOptional(postArgument()) + .append(convertObjectToString(value(), true)) + .append(" ${Operation.AND} ") + .append(convertObjectToString(secondValue(), true)) + .append(" ") + .appendOptional(postArgument()) } } @@ -593,10 +593,10 @@ class Operator : BaseOperator, IOperator { override fun appendConditionToQuery(queryBuilder: StringBuilder) { queryBuilder.append(columnName()) - .append(operation()) - .append("(") - .append(joinArguments(",", inArguments, this)) - .append(")") + .append(operation()) + .append("(") + .append(joinArguments(",", inArguments, this)) + .append(")") } } @@ -604,14 +604,14 @@ class Operator : BaseOperator, IOperator { @JvmStatic fun convertValueToString(value: Any?): String? = - convertValueToString(value, false) + convertValueToString(value, false) @JvmStatic fun op(column: NameAlias): Operator = Operator(column) @JvmStatic fun op(alias: NameAlias, typeConverter: TypeConverter<*, *>, convertToDB: Boolean): Operator = - Operator(alias, typeConverter, convertToDB) + Operator(alias, typeConverter, convertToDB) } } @@ -621,16 +621,16 @@ fun NameAlias.op() = Operator.op(this) fun String.op(): Operator = nameAlias.op() infix fun Operator.and(sqlOperator: SQLOperator): OperatorGroup - = OperatorGroup.clause(this).and(sqlOperator) + = OperatorGroup.clause(this).and(sqlOperator) infix fun Operator.or(sqlOperator: SQLOperator): OperatorGroup - = OperatorGroup.clause(this).or(sqlOperator) + = OperatorGroup.clause(this).or(sqlOperator) infix fun Operator.andAll(sqlOperator: Collection): OperatorGroup - = OperatorGroup.clause(this).andAll(sqlOperator) + = OperatorGroup.clause(this).andAll(sqlOperator) infix fun Operator.orAll(sqlOperator: Collection): OperatorGroup - = OperatorGroup.clause(this).orAll(sqlOperator) + = OperatorGroup.clause(this).orAll(sqlOperator) infix fun Operator.`in`(values: Array): Operator.In = when (values.size) { 1 -> `in`(values[0]) diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/OperatorGroup.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/OperatorGroup.kt index 1cf8e4243..bc90aefc2 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/OperatorGroup.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/OperatorGroup.kt @@ -1,7 +1,7 @@ package com.raizlabs.dbflow5.query -import com.raizlabs.dbflow5.sql.Query import com.raizlabs.dbflow5.query.Operator.Operation +import com.raizlabs.dbflow5.sql.Query /** * Allows combining of [SQLOperator] into one condition. @@ -167,7 +167,7 @@ constructor(columnName: NameAlias? = null) : BaseOperator(columnName), Query, It */ @JvmStatic fun clause(vararg condition: SQLOperator): OperatorGroup = - OperatorGroup().andAll(*condition) + OperatorGroup().andAll(*condition) /** * @return Starts an arbitrary clause of conditions to use, that when included in other [SQLOperator], @@ -181,7 +181,7 @@ constructor(columnName: NameAlias? = null) : BaseOperator(columnName), Query, It */ @JvmStatic fun nonGroupingClause(vararg condition: SQLOperator): OperatorGroup = - OperatorGroup().setUseParenthesis(false).andAll(*condition) + OperatorGroup().setUseParenthesis(false).andAll(*condition) } } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/OrderBy.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/OrderBy.kt index be1833bd1..20b75fdb8 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/OrderBy.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/OrderBy.kt @@ -1,8 +1,8 @@ package com.raizlabs.dbflow5.query import com.raizlabs.dbflow5.annotation.Collate -import com.raizlabs.dbflow5.sql.Query import com.raizlabs.dbflow5.query.property.IProperty +import com.raizlabs.dbflow5.sql.Query /** * Description: Class that represents a SQL order-by. @@ -19,8 +19,8 @@ constructor(private val column: NameAlias? = null, get() { if (orderByString == null) { val query = StringBuilder() - .append(column) - .append(" ") + .append(column) + .append(" ") if (collation != null) { query.append("COLLATE").append(" ").append(collation).append(" ") } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/Queriable.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Queriable.kt index e89e573a7..73a480ab5 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/Queriable.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Queriable.kt @@ -1,10 +1,10 @@ package com.raizlabs.dbflow5.query +import com.raizlabs.dbflow5.database.DatabaseStatement +import com.raizlabs.dbflow5.database.FlowCursor import com.raizlabs.dbflow5.sql.Query import com.raizlabs.dbflow5.structure.ChangeAction import com.raizlabs.dbflow5.structure.Model -import com.raizlabs.dbflow5.database.DatabaseStatement -import com.raizlabs.dbflow5.database.FlowCursor /** * Description: The most basic interface that some of the classes such as [Insert], [ModelQueriable], diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/SQLite.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/SQLite.kt index ca08b6cf8..a6d548c5c 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/SQLite.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/SQLite.kt @@ -3,10 +3,10 @@ package com.raizlabs.dbflow5.query +import com.raizlabs.dbflow5.database.DatabaseWrapper import com.raizlabs.dbflow5.query.property.IProperty import com.raizlabs.dbflow5.query.property.Property import com.raizlabs.dbflow5.structure.Model -import com.raizlabs.dbflow5.database.DatabaseWrapper import kotlin.reflect.KClass diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/SQLiteStatementListener.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/SQLiteStatementListener.kt index 07f1eab14..cbf568570 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/SQLiteStatementListener.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/SQLiteStatementListener.kt @@ -1,9 +1,9 @@ package com.raizlabs.dbflow5.query import com.raizlabs.dbflow5.adapter.InternalAdapter -import com.raizlabs.dbflow5.structure.Model import com.raizlabs.dbflow5.adapter.ModelAdapter import com.raizlabs.dbflow5.database.DatabaseStatement +import com.raizlabs.dbflow5.structure.Model /** * Description: Marks a [Model] as subscribing to the [DatabaseStatement] diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/Select.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Select.kt index d957dc714..f7d51d223 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/Select.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Select.kt @@ -1,9 +1,9 @@ package com.raizlabs.dbflow5.query -import com.raizlabs.dbflow5.sql.Query +import com.raizlabs.dbflow5.database.DatabaseWrapper import com.raizlabs.dbflow5.query.property.IProperty import com.raizlabs.dbflow5.query.property.Property -import com.raizlabs.dbflow5.database.DatabaseWrapper +import com.raizlabs.dbflow5.sql.Query import kotlin.reflect.KClass /** diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/Set.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Set.kt index 96f6769f6..deb24419f 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/Set.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Set.kt @@ -1,17 +1,17 @@ package com.raizlabs.dbflow5.query import android.content.ContentValues -import com.raizlabs.dbflow5.sql.Query import com.raizlabs.dbflow5.addContentValues -import com.raizlabs.dbflow5.structure.ChangeAction import com.raizlabs.dbflow5.database.DatabaseWrapper +import com.raizlabs.dbflow5.sql.Query +import com.raizlabs.dbflow5.structure.ChangeAction /** * Description: Used to specify the SET part of an [com.raizlabs.android.dbflow.sql.language.Update] query. */ class Set internal constructor( - databaseWrapper: DatabaseWrapper, - override val queryBuilderBase: Query, table: Class) + databaseWrapper: DatabaseWrapper, + override val queryBuilderBase: Query, table: Class) : BaseTransformable(databaseWrapper, table), WhereBase { private val operatorGroup: OperatorGroup = OperatorGroup.nonGroupingClause().setAllCommaSeparated(true) diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/Trigger.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Trigger.kt index a0445ebb6..ddd43850d 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/Trigger.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Trigger.kt @@ -2,8 +2,8 @@ package com.raizlabs.dbflow5.query import com.raizlabs.dbflow5.appendOptional import com.raizlabs.dbflow5.appendQuotedIfNeeded -import com.raizlabs.dbflow5.sql.Query import com.raizlabs.dbflow5.query.property.IProperty +import com.raizlabs.dbflow5.sql.Query import kotlin.reflect.KClass /** @@ -17,13 +17,13 @@ class Trigger * @param triggerName What we should call this trigger */ private constructor( - /** - * The name in the DB - */ - /** - * @return The name of this TRIGGER - */ - val name: String) : Query { + /** + * The name in the DB + */ + /** + * @return The name of this TRIGGER + */ + val name: String) : Query { /** * If it's [.BEFORE], [.AFTER], or [.INSTEAD_OF] @@ -39,8 +39,8 @@ private constructor( queryBuilder.append("TEMP ") } queryBuilder.append("TRIGGER IF NOT EXISTS ") - .appendQuotedIfNeeded(name).append(" ") - .appendOptional(beforeOrAfter + " ") + .appendQuotedIfNeeded(name).append(" ") + .appendOptional(beforeOrAfter + " ") return queryBuilder.toString() } @@ -79,7 +79,7 @@ private constructor( * @param onTable The table ON */ fun deleteOn(onTable: Class): TriggerMethod = - TriggerMethod(this, TriggerMethod.DELETE, onTable) + TriggerMethod(this, TriggerMethod.DELETE, onTable) /** * Starts a INSERT ON command @@ -87,7 +87,7 @@ private constructor( * @param onTable The table ON */ fun insertOn(onTable: Class): TriggerMethod = - TriggerMethod(this, TriggerMethod.INSERT, onTable) + TriggerMethod(this, TriggerMethod.INSERT, onTable) /** * Starts an UPDATE ON command @@ -97,7 +97,7 @@ private constructor( * the UPDATE OF column1, column2,... will be used. */ fun updateOn(onTable: Class, vararg properties: IProperty<*>): TriggerMethod = - TriggerMethod(this, TriggerMethod.UPDATE, onTable, *properties) + TriggerMethod(this, TriggerMethod.UPDATE, onTable, *properties) companion object { diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/TriggerMethod.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/TriggerMethod.kt index 255c2c113..30ac9ac03 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/TriggerMethod.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/TriggerMethod.kt @@ -2,8 +2,8 @@ package com.raizlabs.dbflow5.query import com.raizlabs.dbflow5.appendArray import com.raizlabs.dbflow5.config.FlowManager -import com.raizlabs.dbflow5.sql.Query import com.raizlabs.dbflow5.query.property.IProperty +import com.raizlabs.dbflow5.sql.Query /** * Description: Describes the method that the trigger uses. @@ -18,10 +18,10 @@ internal constructor(internal val trigger: Trigger, private val methodName: Stri override val query: String get() { val queryBuilder = StringBuilder(trigger.query) - .append(methodName) + .append(methodName) if (properties.isNotEmpty()) { queryBuilder.append(" OF ") - .appendArray(properties.toTypedArray()) + .appendArray(properties.toTypedArray()) } queryBuilder.append(" ON ").append(FlowManager.getTableName(onTable)) @@ -73,7 +73,7 @@ internal constructor(internal val trigger: Trigger, private val methodName: Stri * @return This trigger */ fun begin(triggerLogicQuery: Query): CompletedTrigger = - CompletedTrigger(this, triggerLogicQuery) + CompletedTrigger(this, triggerLogicQuery) companion object { diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/Update.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Update.kt index f96f0b1dd..ff6a1bcd7 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/Update.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Update.kt @@ -2,8 +2,8 @@ package com.raizlabs.dbflow5.query import com.raizlabs.dbflow5.annotation.ConflictAction import com.raizlabs.dbflow5.config.FlowManager -import com.raizlabs.dbflow5.sql.Query import com.raizlabs.dbflow5.database.DatabaseWrapper +import com.raizlabs.dbflow5.sql.Query /** * Description: The SQLite UPDATE query. Will update rows in the DB. @@ -77,7 +77,7 @@ internal constructor(private val databaseWrapper: DatabaseWrapper, * @return A SET query piece of this statement */ fun set(vararg conditions: SQLOperator): Set = Set(databaseWrapper, this, table) - .conditions(*conditions) + .conditions(*conditions) } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/WhereBase.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/WhereBase.kt index cd2460a66..15d171f8f 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/WhereBase.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/WhereBase.kt @@ -1,7 +1,7 @@ package com.raizlabs.dbflow5.query -import com.raizlabs.dbflow5.sql.Query import com.raizlabs.dbflow5.database.DatabaseWrapper +import com.raizlabs.dbflow5.sql.Query /** * Description: The base for a [Where] statement. diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/IndexProperty.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/IndexProperty.kt index b53600367..5b5b08869 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/IndexProperty.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/IndexProperty.kt @@ -1,9 +1,9 @@ package com.raizlabs.dbflow5.query.property import com.raizlabs.dbflow5.annotation.Table -import com.raizlabs.dbflow5.quoteIfNeeded -import com.raizlabs.dbflow5.query.Index import com.raizlabs.dbflow5.database.DatabaseWrapper +import com.raizlabs.dbflow5.query.Index +import com.raizlabs.dbflow5.quoteIfNeeded /** * Description: Defines an INDEX in Sqlite. It basically speeds up data retrieval over large datasets. diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/Property.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/Property.kt index 8c7865a17..ab2bee717 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/Property.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/Property.kt @@ -36,9 +36,9 @@ open class Property : IProperty>, IConditional, IOperator { */ private val distinctAliasName: NameAlias get() = nameAlias - .newBuilder() - .distinct() - .build() + .newBuilder() + .distinct() + .build() protected open val operator: Operator get() = Operator.op(nameAlias) @@ -56,10 +56,10 @@ open class Property : IProperty>, IConditional, IOperator { } constructor(table: Class<*>?, columnName: String, aliasName: String) - : this(table, NameAlias.builder(columnName).`as`(aliasName).build()) + : this(table, NameAlias.builder(columnName).`as`(aliasName).build()) override fun withTable(): Property = - withTable(NameAlias.Builder(FlowManager.getTableName(table!!)).build()) + withTable(NameAlias.Builder(FlowManager.getTableName(table!!)).build()) override val nameAlias: NameAlias get() = internalNameAlias @@ -91,77 +91,77 @@ open class Property : IProperty>, IConditional, IOperator { override fun glob(value: String): Operator = operator.glob(value) override fun greaterThan(conditional: IConditional): Operator<*> = - operator.greaterThan(conditional) + operator.greaterThan(conditional) override fun greaterThanOrEq(conditional: IConditional): Operator<*> = - operator.greaterThanOrEq(conditional) + operator.greaterThanOrEq(conditional) override fun lessThan(conditional: IConditional): Operator<*> = operator.lessThan(conditional) override fun lessThanOrEq(conditional: IConditional): Operator<*> = - operator.lessThanOrEq(conditional) + operator.lessThanOrEq(conditional) override fun between(conditional: IConditional): Operator.Between<*> = - operator.between(conditional) + operator.between(conditional) override fun `in`(firstConditional: IConditional, vararg conditionals: IConditional): Operator.In<*> = - operator.`in`(firstConditional, *conditionals) + operator.`in`(firstConditional, *conditionals) override fun notIn(firstConditional: IConditional, vararg conditionals: IConditional): Operator.In<*> = - operator.notIn(firstConditional, *conditionals) + operator.notIn(firstConditional, *conditionals) override fun `is`(baseModelQueriable: BaseModelQueriable<*>): Operator<*> = - operator.`is`(baseModelQueriable) + operator.`is`(baseModelQueriable) override fun isNull(): Operator<*> = operator.isNull() override fun eq(baseModelQueriable: BaseModelQueriable<*>): Operator<*> = - operator.eq(baseModelQueriable) + operator.eq(baseModelQueriable) override fun isNot(baseModelQueriable: BaseModelQueriable<*>): Operator<*> = - operator.isNot(baseModelQueriable) + operator.isNot(baseModelQueriable) override fun isNotNull(): Operator<*> = operator.isNotNull() override fun notEq(baseModelQueriable: BaseModelQueriable<*>): Operator<*> = - operator.notEq(baseModelQueriable) + operator.notEq(baseModelQueriable) override fun like(baseModelQueriable: BaseModelQueriable<*>): Operator<*> = - operator.like(baseModelQueriable) + operator.like(baseModelQueriable) override fun notLike(conditional: IConditional): Operator<*> = operator.notLike(conditional) override fun notLike(baseModelQueriable: BaseModelQueriable<*>): Operator<*> = - operator.notLike(baseModelQueriable) + operator.notLike(baseModelQueriable) override fun glob(baseModelQueriable: BaseModelQueriable<*>): Operator<*> = - operator.glob(baseModelQueriable) + operator.glob(baseModelQueriable) override fun greaterThan(baseModelQueriable: BaseModelQueriable<*>): Operator<*> = - operator.greaterThan(baseModelQueriable) + operator.greaterThan(baseModelQueriable) override fun greaterThanOrEq(baseModelQueriable: BaseModelQueriable<*>): Operator<*> = - operator.greaterThanOrEq(baseModelQueriable) + operator.greaterThanOrEq(baseModelQueriable) override fun lessThan(baseModelQueriable: BaseModelQueriable<*>): Operator<*> = - operator.lessThan(baseModelQueriable) + operator.lessThan(baseModelQueriable) override fun lessThanOrEq(baseModelQueriable: BaseModelQueriable<*>): Operator<*> = - operator.lessThanOrEq(baseModelQueriable) + operator.lessThanOrEq(baseModelQueriable) override fun between(baseModelQueriable: BaseModelQueriable<*>): Operator.Between<*> = - operator.between(baseModelQueriable) + operator.between(baseModelQueriable) override fun `in`(firstBaseModelQueriable: BaseModelQueriable<*>, vararg baseModelQueriables: BaseModelQueriable<*>): Operator.In<*> = - operator.`in`(firstBaseModelQueriable, *baseModelQueriables) + operator.`in`(firstBaseModelQueriable, *baseModelQueriables) override fun notIn(firstBaseModelQueriable: BaseModelQueriable<*>, vararg baseModelQueriables: BaseModelQueriable<*>): Operator.In<*> = - operator.notIn(firstBaseModelQueriable, *baseModelQueriables) + operator.notIn(firstBaseModelQueriable, *baseModelQueriables) override fun concatenate(conditional: IConditional): Operator<*> = - operator.concatenate(conditional) + operator.concatenate(conditional) override fun plus(value: BaseModelQueriable<*>): Operator<*> = operator.plus(value) @@ -175,48 +175,48 @@ open class Property : IProperty>, IConditional, IOperator { override fun plus(property: IProperty<*>): Property { return Property(table, NameAlias.joinNames(Operator.Operation.PLUS, - internalNameAlias.fullName(), property.toString())) + internalNameAlias.fullName(), property.toString())) } override fun minus(property: IProperty<*>): Property { return Property(table, NameAlias.joinNames(Operator.Operation.MINUS, - internalNameAlias.fullName(), property.toString())) + internalNameAlias.fullName(), property.toString())) } override fun div(property: IProperty<*>): Property { return Property(table, NameAlias.joinNames(Operator.Operation.DIVISION, - internalNameAlias.fullName(), property.toString())) + internalNameAlias.fullName(), property.toString())) } override fun times(property: IProperty<*>): Property { return Property(table, NameAlias.joinNames(Operator.Operation.MULTIPLY, - internalNameAlias.fullName(), property.toString())) + internalNameAlias.fullName(), property.toString())) } override fun rem(property: IProperty<*>): Property { return Property(table, NameAlias.joinNames(Operator.Operation.MOD, - internalNameAlias.fullName(), property.toString())) + internalNameAlias.fullName(), property.toString())) } override fun concatenate(property: IProperty<*>): Property { return Property(table, NameAlias.joinNames(Operator.Operation.CONCATENATE, - internalNameAlias.fullName(), property.toString())) + internalNameAlias.fullName(), property.toString())) } override fun `as`(aliasName: String): Property { return Property(table, nameAlias - .newBuilder() - .`as`(aliasName) - .build()) + .newBuilder() + .`as`(aliasName) + .build()) } override fun distinct(): Property = Property(table, distinctAliasName) override fun withTable(tableNameAlias: NameAlias): Property { return Property(table, nameAlias - .newBuilder() - .withTable(tableNameAlias.query) - .build()) + .newBuilder() + .withTable(tableNameAlias.query) + .build()) } override fun `is`(value: T?): Operator = operator.`is`(value) @@ -238,10 +238,10 @@ open class Property : IProperty>, IConditional, IOperator { override fun between(value: T): Operator.Between = operator.between(value) override fun `in`(firstValue: T, vararg values: T): Operator.In = - operator.`in`(firstValue, *values) + operator.`in`(firstValue, *values) override fun notIn(firstValue: T, vararg values: T): Operator.In = - operator.notIn(firstValue, *values) + operator.notIn(firstValue, *values) override fun `in`(values: Collection): Operator.In = operator.`in`(values) @@ -273,7 +273,7 @@ open class Property : IProperty>, IConditional, IOperator { @JvmStatic fun allProperty(table: Class<*>): Property = - Property(table, NameAlias.rawBuilder("*").build()).withTable() + Property(table, NameAlias.rawBuilder("*").build()).withTable() } } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/PropertyFactory.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/PropertyFactory.kt index 06579b54a..9b1ad7efc 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/PropertyFactory.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/PropertyFactory.kt @@ -1,8 +1,8 @@ package com.raizlabs.dbflow5.query.property +import com.raizlabs.dbflow5.query.ModelQueriable import com.raizlabs.dbflow5.query.NameAlias import com.raizlabs.dbflow5.query.Operator -import com.raizlabs.dbflow5.query.ModelQueriable import kotlin.reflect.KClass /** @@ -19,7 +19,7 @@ object PropertyFactory { @JvmStatic fun from(c: Char): Property { return Property(null, NameAlias.rawBuilder("'$c'") - .build()) + .build()) } /** @@ -31,7 +31,7 @@ object PropertyFactory { @JvmStatic fun from(i: Int): Property { return Property(null, NameAlias.rawBuilder(i.toString() + "") - .build()) + .build()) } /** @@ -43,7 +43,7 @@ object PropertyFactory { @JvmStatic fun from(d: Double): Property { return Property(null, NameAlias.rawBuilder(d.toString() + "") - .build()) + .build()) } /** @@ -55,7 +55,7 @@ object PropertyFactory { @JvmStatic fun from(l: Long): Property { return Property(null, NameAlias.rawBuilder(l.toString() + "") - .build()) + .build()) } /** @@ -67,7 +67,7 @@ object PropertyFactory { @JvmStatic fun from(f: Float): Property { return Property(null, NameAlias.rawBuilder(f.toString() + "") - .build()) + .build()) } /** @@ -79,7 +79,7 @@ object PropertyFactory { @JvmStatic fun from(s: Short): Property { return Property(null, NameAlias.rawBuilder(s.toString() + "") - .build()) + .build()) } /** @@ -91,7 +91,7 @@ object PropertyFactory { @JvmStatic fun from(b: Byte): Property { return Property(null, NameAlias.rawBuilder(b.toString() + "") - .build()) + .build()) } /** @@ -109,8 +109,8 @@ object PropertyFactory { @JvmStatic fun from(type: T?): Property { return Property(null, NameAlias.rawBuilder( - Operator.convertValueToString(type) ?: "") - .build()) + Operator.convertValueToString(type) ?: "") + .build()) } /** @@ -122,7 +122,7 @@ object PropertyFactory { */ @JvmStatic fun from(queriable: ModelQueriable): Property = - from(queriable.table, "(${queriable.query.trim { it <= ' ' }})") + from(queriable.table, "(${queriable.query.trim { it <= ' ' }})") /** * Creates a new type-parameterized [Property] to be used as its value represented by the string passed in. @@ -134,7 +134,7 @@ object PropertyFactory { @JvmStatic fun from(table: Class, stringRepresentation: String?): Property { return Property(null, NameAlias.rawBuilder(stringRepresentation ?: "") - .build()) + .build()) } } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/TypeConvertedProperty.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/TypeConvertedProperty.kt index a7464bf57..cf0329476 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/TypeConvertedProperty.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/TypeConvertedProperty.kt @@ -1,9 +1,9 @@ package com.raizlabs.dbflow5.query.property +import com.raizlabs.dbflow5.adapter.ModelAdapter import com.raizlabs.dbflow5.converter.TypeConverter import com.raizlabs.dbflow5.query.NameAlias import com.raizlabs.dbflow5.query.Operator -import com.raizlabs.dbflow5.adapter.ModelAdapter /** * Description: Provides convenience methods for [TypeConverter] when constructing queries. @@ -52,9 +52,9 @@ class TypeConvertedProperty : Property { fun invertProperty(): Property { if (databaseProperty == null) { databaseProperty = TypeConvertedProperty(table!!, nameAlias, - !convertToDB, object : TypeConverterGetter { + !convertToDB, object : TypeConverterGetter { override fun getTypeConverter(modelClass: Class<*>): TypeConverter<*, *> = - getter.getTypeConverter(modelClass) + getter.getTypeConverter(modelClass) }) } return databaseProperty!! @@ -62,9 +62,9 @@ class TypeConvertedProperty : Property { override fun withTable(tableNameAlias: NameAlias): Property { val nameAlias = this.nameAlias - .newBuilder() - .withTable(tableNameAlias.query) - .build() + .newBuilder() + .withTable(tableNameAlias.query) + .build() return TypeConvertedProperty(this.table!!, nameAlias, this.convertToDB, this.getter) } } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/ContentResolverNotifier.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/ContentResolverNotifier.kt index 4784c4000..901ce73e9 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/ContentResolverNotifier.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/ContentResolverNotifier.kt @@ -1,12 +1,11 @@ package com.raizlabs.dbflow5.runtime import android.content.ContentResolver - +import com.raizlabs.dbflow5.adapter.ModelAdapter import com.raizlabs.dbflow5.config.FlowManager import com.raizlabs.dbflow5.getNotificationUri import com.raizlabs.dbflow5.query.SQLOperator import com.raizlabs.dbflow5.structure.ChangeAction -import com.raizlabs.dbflow5.adapter.ModelAdapter /** * The default use case, it notifies via the [ContentResolver] system. @@ -20,18 +19,18 @@ class ContentResolverNotifier(val authority: String) : ModelNotifier { action: ChangeAction) { if (FlowContentObserver.shouldNotify()) { FlowManager.context.contentResolver - .notifyChange(getNotificationUri(authority, - adapter.table, action, - adapter.getPrimaryConditionClause(model).conditions), - null, true) + .notifyChange(getNotificationUri(authority, + adapter.table, action, + adapter.getPrimaryConditionClause(model).conditions), + null, true) } } override fun notifyTableChanged(table: Class, action: ChangeAction) { if (FlowContentObserver.shouldNotify()) { FlowManager.context.contentResolver - .notifyChange(getNotificationUri(authority, table, action, - null as Array?), null, true) + .notifyChange(getNotificationUri(authority, table, action, + null as Array?), null, true) } } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/FlowContentObserver.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/FlowContentObserver.kt index d92305f16..4b3fac538 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/FlowContentObserver.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/FlowContentObserver.kt @@ -8,9 +8,9 @@ import android.net.Uri import android.os.Build import android.os.Build.VERSION_CODES import android.os.Handler +import com.raizlabs.dbflow5.TABLE_QUERY_PARAM import com.raizlabs.dbflow5.config.DatabaseConfig import com.raizlabs.dbflow5.config.FlowManager -import com.raizlabs.dbflow5.TABLE_QUERY_PARAM import com.raizlabs.dbflow5.getNotificationUri import com.raizlabs.dbflow5.query.NameAlias import com.raizlabs.dbflow5.query.Operator @@ -107,7 +107,7 @@ open class FlowContentObserver(private val contentAuthority: String, for (uri in tableUris) { for (onTableChangedListener in onTableChangedListeners) { onTableChangedListener.onTableChanged(registeredTables[uri.authority], - ChangeAction.valueOf(uri.fragment)) + ChangeAction.valueOf(uri.fragment)) } } tableUris.clear() @@ -176,7 +176,7 @@ open class FlowContentObserver(private val contentAuthority: String, fun registerForContentChanges(contentResolver: ContentResolver, table: Class<*>) { contentResolver.registerContentObserver( - getNotificationUri(contentAuthority, table, null), true, this) + getNotificationUri(contentAuthority, table, null), true, this) REGISTERED_COUNT.incrementAndGet() if (!registeredTables.containsValue(table)) { registeredTables.put(FlowManager.getTableName(table), table) @@ -214,12 +214,12 @@ open class FlowContentObserver(private val contentAuthority: String, val queryNames = uri.queryParameterNames val columnsChanged = arrayListOf() queryNames.asSequence() - .filter { it != TABLE_QUERY_PARAM } - .forEach { key -> - param = Uri.decode(uri.getQueryParameter(key)) - columnName = Uri.decode(key) - columnsChanged += Operator.op(NameAlias.Builder(columnName).build()).eq(param) - } + .filter { it != TABLE_QUERY_PARAM } + .forEach { key -> + param = Uri.decode(uri.getQueryParameter(key)) + columnName = Uri.decode(key) + columnsChanged += Operator.op(NameAlias.Builder(columnName).build()).eq(param) + } val table = registeredTables[tableName] var action = ChangeAction.valueOf(fragment) diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/ModelNotifier.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/ModelNotifier.kt index af926d21b..c9d0b0bf8 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/ModelNotifier.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/ModelNotifier.kt @@ -1,7 +1,7 @@ package com.raizlabs.dbflow5.runtime -import com.raizlabs.dbflow5.structure.ChangeAction import com.raizlabs.dbflow5.adapter.ModelAdapter +import com.raizlabs.dbflow5.structure.ChangeAction /** * Interface for defining how we notify model changes. diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/NotifyDistributor.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/NotifyDistributor.kt index 514b42e48..4df025d2b 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/NotifyDistributor.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/NotifyDistributor.kt @@ -1,8 +1,8 @@ package com.raizlabs.dbflow5.runtime +import com.raizlabs.dbflow5.adapter.ModelAdapter import com.raizlabs.dbflow5.config.FlowManager import com.raizlabs.dbflow5.structure.ChangeAction -import com.raizlabs.dbflow5.adapter.ModelAdapter /** * Description: Distributes notifications to the [ModelNotifier]. @@ -17,7 +17,7 @@ class NotifyDistributor : ModelNotifier { adapter: ModelAdapter, action: ChangeAction) { FlowManager.getModelNotifierForTable(adapter.table) - .notifyModelChanged(model, adapter, action) + .notifyModelChanged(model, adapter, action) } /** diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/structure/BaseQueryModel.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/structure/BaseQueryModel.kt index db6ec6646..587b3ec7b 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/structure/BaseQueryModel.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/structure/BaseQueryModel.kt @@ -11,6 +11,6 @@ class BaseQueryModel : NoModificationModel() { override fun exists(wrapper: DatabaseWrapper): Boolean { throw InvalidSqlViewOperationException("Query " + wrapper.javaClass.name + - " does not exist as a table." + "It's a convenient representation of a complex SQLite query.") + " does not exist as a table." + "It's a convenient representation of a complex SQLite query.") } } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/structure/Model.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/structure/Model.kt index e906b85d2..53ff36db1 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/structure/Model.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/structure/Model.kt @@ -45,20 +45,20 @@ interface Model : ReadOnlyModel { } inline fun T.save(databaseWrapper: DatabaseWrapper = databaseForTable()): Boolean - = modelAdapter().save(this, databaseWrapper) + = modelAdapter().save(this, databaseWrapper) inline fun T.insert(databaseWrapper: DatabaseWrapper = databaseForTable()): Long - = modelAdapter().insert(this, databaseWrapper) + = modelAdapter().insert(this, databaseWrapper) inline fun T.update(databaseWrapper: DatabaseWrapper = databaseForTable()): Boolean - = modelAdapter().update(this, databaseWrapper) + = modelAdapter().update(this, databaseWrapper) inline fun T.delete(databaseWrapper: DatabaseWrapper = databaseForTable()): Boolean - = modelAdapter().delete(this, databaseWrapper) + = modelAdapter().delete(this, databaseWrapper) inline fun T.exists(databaseWrapper: DatabaseWrapper = databaseForTable()): Boolean - = modelAdapter().exists(this, databaseWrapper) + = modelAdapter().exists(this, databaseWrapper) inline fun T.load(databaseWrapper: DatabaseWrapper = databaseForTable()) - = modelAdapter().load(this, databaseWrapper) + = modelAdapter().load(this, databaseWrapper) diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/DefaultTransactionManager.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/DefaultTransactionManager.kt index d533337e2..283e8d5f1 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/DefaultTransactionManager.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/DefaultTransactionManager.kt @@ -8,10 +8,10 @@ import com.raizlabs.dbflow5.config.DatabaseDefinition class DefaultTransactionManager : BaseTransactionManager { constructor(databaseDefinition: DatabaseDefinition) - : super(DefaultTransactionQueue("DBFlow Transaction Queue"), databaseDefinition) + : super(DefaultTransactionQueue("DBFlow Transaction Queue"), databaseDefinition) constructor(transactionQueue: ITransactionQueue, databaseDefinition: DatabaseDefinition) - : super(transactionQueue, databaseDefinition) + : super(transactionQueue, databaseDefinition) } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/FastStoreModelTransaction.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/FastStoreModelTransaction.kt index c89952dfe..c7d03c905 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/FastStoreModelTransaction.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/FastStoreModelTransaction.kt @@ -75,20 +75,20 @@ class FastStoreModelTransaction internal constructor(builder: Builder saveBuilder(internalAdapter: InternalAdapter): Builder = - Builder(internalAdapter) { tModels, adapter, wrapper -> adapter.saveAll(tModels, wrapper) } + Builder(internalAdapter) { tModels, adapter, wrapper -> adapter.saveAll(tModels, wrapper) } @JvmStatic fun insertBuilder(internalAdapter: InternalAdapter): Builder = - Builder(internalAdapter) { tModels, adapter, wrapper -> adapter.insertAll(tModels, wrapper) } + Builder(internalAdapter) { tModels, adapter, wrapper -> adapter.insertAll(tModels, wrapper) } @JvmStatic fun updateBuilder(internalAdapter: InternalAdapter): Builder = - Builder(internalAdapter) { tModels, adapter, wrapper -> adapter.updateAll(tModels, wrapper) } + Builder(internalAdapter) { tModels, adapter, wrapper -> adapter.updateAll(tModels, wrapper) } @JvmStatic fun deleteBuilder(internalAdapter: InternalAdapter): Builder = - Builder(internalAdapter) { tModels, adapter, wrapper -> adapter.deleteAll(tModels, wrapper) } + Builder(internalAdapter) { tModels, adapter, wrapper -> adapter.deleteAll(tModels, wrapper) } } } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/PriorityTransactionQueue.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/PriorityTransactionQueue.kt index 056f8637e..680fe5ae8 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/PriorityTransactionQueue.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/PriorityTransactionQueue.kt @@ -107,15 +107,15 @@ class PriorityTransactionQueue internal inner class PriorityEntry>(val entry: E) : Comparable>> { private val transactionWrapper: PriorityTransactionWrapper = - if (entry.transaction() is PriorityTransactionWrapper) { - entry.transaction() as PriorityTransactionWrapper - } else { - PriorityTransactionWrapper.Builder(entry.transaction()) - .build() - } + if (entry.transaction() is PriorityTransactionWrapper) { + entry.transaction() as PriorityTransactionWrapper + } else { + PriorityTransactionWrapper.Builder(entry.transaction()) + .build() + } override fun compareTo(other: PriorityEntry>): Int = - transactionWrapper.compareTo(other.transactionWrapper) + transactionWrapper.compareTo(other.transactionWrapper) override fun equals(other: Any?): Boolean { if (this === other) { diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/PriorityTransactionWrapper.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/PriorityTransactionWrapper.kt index 3043ff168..d2262fbb5 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/PriorityTransactionWrapper.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/PriorityTransactionWrapper.kt @@ -15,12 +15,12 @@ class PriorityTransactionWrapper(private val priority: Int, private val transact annotation class Priority() internal constructor(builder: Builder) : this( - priority = if (builder.priority == 0) { - PRIORITY_NORMAL - } else { - builder.priority - }, - transaction = builder.transaction) + priority = if (builder.priority == 0) { + PRIORITY_NORMAL + } else { + builder.priority + }, + transaction = builder.transaction) override fun execute(databaseWrapper: DatabaseWrapper) { transaction.execute(databaseWrapper) diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/ProcessModelTransaction.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/ProcessModelTransaction.kt index 28eda33ae..f92460443 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/ProcessModelTransaction.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/ProcessModelTransaction.kt @@ -11,10 +11,10 @@ typealias ProcessFunction = (T, DatabaseWrapper) -> Unit * can operate on a set of [Model] to [Model.save], [Model.update], etc. */ class ProcessModelTransaction( - private val models: List = arrayListOf(), - private val processListener: OnModelProcessListener? = null, - private val processModel: ProcessModel, - private val runProcessListenerOnSameThread: Boolean) : ITransaction { + private val models: List = arrayListOf(), + private val processListener: OnModelProcessListener? = null, + private val processModel: ProcessModel, + private val runProcessListenerOnSameThread: Boolean) : ITransaction { /** @@ -49,10 +49,10 @@ class ProcessModelTransaction( } internal constructor(builder: Builder) : this( - processListener = builder.processListener, - models = builder.models, - processModel = builder.processModel, - runProcessListenerOnSameThread = builder.runProcessListenerOnSameThread + processListener = builder.processListener, + models = builder.models, + processModel = builder.processModel, + runProcessListenerOnSameThread = builder.runProcessListenerOnSameThread ) override fun execute(databaseWrapper: DatabaseWrapper) { @@ -147,18 +147,17 @@ class ProcessModelTransaction( } - /** * Enables a collection of T objects to easily operate on them within a synchronous database transaction. */ @Deprecated(message = "Use the coroutines awaitSave, awaitInsert, awaitDelete, awaitUpdate") inline fun Collection.processInTransaction( - crossinline processFunction: ProcessFunction) { + crossinline processFunction: ProcessFunction) { databaseForTable().executeTransaction { db -> forEach { processFunction(it, db) } } } inline fun processModel(crossinline function: (T, DatabaseWrapper) -> Unit) - = object : ProcessModelTransaction.ProcessModel { + = object : ProcessModelTransaction.ProcessModel { override fun processModel(model: T, wrapper: DatabaseWrapper) = function(model, wrapper) } @@ -167,19 +166,19 @@ inline fun processModel(crossinline function: (T, DatabaseWrapper) -> Unit) * an action on each individual [Model]. This happens on a non-UI thread. */ inline fun Collection.processInTransactionAsync( - crossinline processFunction: ProcessFunction, - success: Transaction.Success? = null, - error: Transaction.Error? = null, - processListener: ProcessModelTransaction.OnModelProcessListener? = null) { + crossinline processFunction: ProcessFunction, + success: Transaction.Success? = null, + error: Transaction.Error? = null, + processListener: ProcessModelTransaction.OnModelProcessListener? = null) { val builder = this.processTransaction(processFunction) processListener?.let { builder.processListener(processListener) } databaseForTable().beginTransactionAsync(builder.build()) - .success(success) - .error(error) - .execute() + .success(success) + .error(error) + .execute() } inline fun Collection.processTransaction( - crossinline processFunction: ProcessFunction): ProcessModelTransaction.Builder = - ProcessModelTransaction.Builder(processModel { model, wrapper -> processFunction(model, wrapper) }) - .addAll(this) + crossinline processFunction: ProcessFunction): ProcessModelTransaction.Builder = + ProcessModelTransaction.Builder(processModel { model, wrapper -> processFunction(model, wrapper) }) + .addAll(this) diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/Transaction.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/Transaction.kt index 4cc80547a..0cacf7868 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/Transaction.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/Transaction.kt @@ -53,13 +53,13 @@ class Transaction(private val transaction: ITransaction, internal constructor(builder: Builder) : this( - databaseDefinition = builder.databaseDefinition, - errorCallback = builder.errorCallback, - successCallback = builder.successCallback, - transaction = builder.transaction, - name = builder.name, - shouldRunInTransaction = builder.shouldRunInTransaction, - runCallbacksOnSameThread = builder.runCallbacksOnSameThread + databaseDefinition = builder.databaseDefinition, + errorCallback = builder.errorCallback, + successCallback = builder.successCallback, + transaction = builder.transaction, + name = builder.name, + shouldRunInTransaction = builder.shouldRunInTransaction, + runCallbacksOnSameThread = builder.runCallbacksOnSameThread ) fun error(): Error? = errorCallback @@ -120,11 +120,11 @@ class Transaction(private val transaction: ITransaction, fun newBuilder(): Builder { return Builder(transaction, databaseDefinition) - .error(errorCallback) - .success(successCallback) - .name(name) - .shouldRunInTransaction(shouldRunInTransaction) - .runCallbacksOnSameThread(runCallbacksOnSameThread) + .error(errorCallback) + .success(successCallback) + .name(name) + .shouldRunInTransaction(shouldRunInTransaction) + .runCallbacksOnSameThread(runCallbacksOnSameThread) } /** From b2f5ea195e24c968b7fd6aac47661754476f5437 Mon Sep 17 00:00:00 2001 From: fuzzagrosner Date: Mon, 4 Dec 2017 14:52:22 -0500 Subject: [PATCH 127/234] [dependencies] consolidate like-dependencies into project extension versions. --- build.gradle | 20 +++++++++++++++- dbflow-core/build.gradle | 2 +- dbflow-coroutines/build.gradle | 2 +- dbflow-processor/build.gradle | 10 ++++---- dbflow-rx/build.gradle | 11 ++++----- dbflow-rx2/build.gradle | 10 ++++---- dbflow-sqlcipher/build.gradle | 11 ++++----- dbflow-tests/build.gradle | 24 +++++++++---------- .../raizlabs/dbflow5/sqlcipher/CipherTest.kt | 5 ++-- dbflow/build.gradle | 10 ++++---- 10 files changed, 59 insertions(+), 46 deletions(-) diff --git a/build.gradle b/build.gradle index 1bf727a43..07b842f37 100644 --- a/build.gradle +++ b/build.gradle @@ -1,5 +1,23 @@ buildscript { - ext.kotlin_version = '1.2.0' + ext{ + kotlin_version = '1.2.0' + target_sdk = 27 + min_sdk = 4 + min_sdk_rx = 15 + sql_cipher_min = 7 + + deps = [ + kotlin: "org.jetbrains.kotlin:kotlin-stdlib:${kotlin_version}", + sql_cipher: "net.zetetic:android-database-sqlcipher:3.5.7@aar", + rx1: 'io.reactivex:rxjava:1.2.7', + rx2: 'io.reactivex.rxjava2:rxjava:2.1.3', + coroutines: "org.jetbrains.kotlinx:kotlinx-coroutines-core:0.19.2", + javapoet: 'com.squareup:javapoet:1.9.0', + kpoet: 'com.github.agrosner:KPoet:1.0.0', + javax_annotation: 'org.glassfish:javax.annotation:10.0-b28', + junit: 'junit:junit:4.12' + ] + } repositories { jcenter() google() diff --git a/dbflow-core/build.gradle b/dbflow-core/build.gradle index 476caac1e..a392ae8fa 100644 --- a/dbflow-core/build.gradle +++ b/dbflow-core/build.gradle @@ -7,7 +7,7 @@ targetCompatibility = JavaVersion.VERSION_1_8 sourceCompatibility = JavaVersion.VERSION_1_8 dependencies { - compile "org.jetbrains.kotlin:kotlin-stdlib-jre8:$kotlin_version" + compile deps.kotlin } apply from: '../java-artifacts.gradle' diff --git a/dbflow-coroutines/build.gradle b/dbflow-coroutines/build.gradle index 84d62cae7..ad727111b 100644 --- a/dbflow-coroutines/build.gradle +++ b/dbflow-coroutines/build.gradle @@ -18,7 +18,7 @@ android { dependencies { implementation project("${dbflow_project_prefix}dbflow") - api "org.jetbrains.kotlinx:kotlinx-coroutines-core:0.19.2" + api deps.coroutines } kotlin { diff --git a/dbflow-processor/build.gradle b/dbflow-processor/build.gradle index b78e31608..42394bbf6 100644 --- a/dbflow-processor/build.gradle +++ b/dbflow-processor/build.gradle @@ -8,13 +8,13 @@ sourceCompatibility = JavaVersion.VERSION_1_8 dependencies { compile project("${dbflow_project_prefix}dbflow-core") - compile 'com.squareup:javapoet:1.9.0' - compile 'com.github.agrosner:KPoet:1.0.0' - compile "org.jetbrains.kotlin:kotlin-stdlib-jre8:$kotlin_version" + compile deps.javapoet + compile deps.kpoet + compile deps.kotlin - compileOnly 'org.glassfish:javax.annotation:10.0-b28' + compileOnly deps.javax_annotation - testImplementation 'junit:junit:4.12' + testImplementation deps.junit } diff --git a/dbflow-rx/build.gradle b/dbflow-rx/build.gradle index cc6f35f92..c7ab8b11b 100644 --- a/dbflow-rx/build.gradle +++ b/dbflow-rx/build.gradle @@ -4,12 +4,11 @@ apply plugin: 'kotlin-android' project.ext.artifactId = bt_name android { - compileSdkVersion Integer.valueOf(dbflow_target_sdk) - buildToolsVersion dbflow_build_tools_version + compileSdkVersion target_sdk defaultConfig { - minSdkVersion dbflow_min_sdk_rx - targetSdkVersion Integer.valueOf(dbflow_target_sdk) + minSdkVersion min_sdk_rx + targetSdkVersion target_sdk } compileOptions { @@ -20,8 +19,8 @@ android { dependencies { api project("${dbflow_project_prefix}dbflow") - api 'io.reactivex:rxjava:1.2.7' - api "org.jetbrains.kotlin:kotlin-stdlib-jre8:$kotlin_version" + api deps.rx1 + api deps.kotlin } apply from: '../android-artifacts.gradle' diff --git a/dbflow-rx2/build.gradle b/dbflow-rx2/build.gradle index abc3cfe31..9a2d54c64 100644 --- a/dbflow-rx2/build.gradle +++ b/dbflow-rx2/build.gradle @@ -4,11 +4,11 @@ apply plugin: 'kotlin-android' project.ext.artifactId = bt_name android { - compileSdkVersion Integer.valueOf(dbflow_target_sdk) + compileSdkVersion target_sdk defaultConfig { - minSdkVersion dbflow_min_sdk_rx - targetSdkVersion Integer.valueOf(dbflow_target_sdk) + minSdkVersion min_sdk_rx + targetSdkVersion target_sdk } compileOptions { @@ -19,8 +19,8 @@ android { dependencies { api project("${dbflow_project_prefix}dbflow") - api 'io.reactivex.rxjava2:rxjava:2.1.3' - api "org.jetbrains.kotlin:kotlin-stdlib-jre8:$kotlin_version" + api deps.rx2 + api deps.kotlin } apply from: '../android-artifacts.gradle' diff --git a/dbflow-sqlcipher/build.gradle b/dbflow-sqlcipher/build.gradle index fe46d5ae1..da2007ecc 100644 --- a/dbflow-sqlcipher/build.gradle +++ b/dbflow-sqlcipher/build.gradle @@ -4,12 +4,11 @@ apply plugin: 'kotlin-android' project.ext.artifactId = bt_name android { - compileSdkVersion 26 + compileSdkVersion target_sdk defaultConfig { - minSdkVersion 7 - targetSdkVersion 26 - versionCode = version_code + minSdkVersion sql_cipher_min + targetSdkVersion target_sdk } lintOptions { @@ -23,9 +22,9 @@ android { } dependencies { - api "net.zetetic:android-database-sqlcipher:3.5.7@aar" + api deps.sql_cipher api project("${dbflow_project_prefix}dbflow") - api "org.jetbrains.kotlin:kotlin-stdlib-jre8:$kotlin_version" + api deps.kotlin } apply from: '../android-artifacts.gradle' diff --git a/dbflow-tests/build.gradle b/dbflow-tests/build.gradle index 095cd21dd..544af9597 100644 --- a/dbflow-tests/build.gradle +++ b/dbflow-tests/build.gradle @@ -7,17 +7,17 @@ android { useLibrary 'org.apache.http.legacy' - compileSdkVersion 26 + compileSdkVersion target_sdk buildToolsVersion dbflow_build_tools_version compileOptions { - sourceCompatibility JavaVersion.VERSION_1_7 - targetCompatibility JavaVersion.VERSION_1_7 + sourceCompatibility JavaVersion.VERSION_1_8 + targetCompatibility JavaVersion.VERSION_1_8 } defaultConfig { - minSdkVersion 15 - targetSdkVersion 26 + minSdkVersion min_sdk_rx + targetSdkVersion target_sdk versionCode 1 versionName "1.0" testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner" @@ -43,11 +43,11 @@ android { } dependencies { - implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version" + compile "org.jetbrains.kotlin:kotlin-stdlib" kapt project("${dbflow_project_prefix}dbflow-processor") implementation project(':dbflow') - implementation 'com.android.support:appcompat-v7:26.1.0' + implementation 'com.android.support:appcompat-v7:27.0.2' implementation project("${dbflow_project_prefix}dbflow") implementation project("${dbflow_project_prefix}dbflow-sqlcipher") implementation project("${dbflow_project_prefix}dbflow-rx") @@ -57,24 +57,22 @@ dependencies { kaptTest project("${dbflow_project_prefix}dbflow-processor") kaptAndroidTest project("${dbflow_project_prefix}dbflow-processor") - testImplementation 'org.glassfish:javax.annotation:10.0-b28' + testImplementation deps.javax_annotation - testImplementation 'junit:junit:4.12' - testImplementation "org.robolectric:robolectric:3.4.2" + testImplementation deps.junit + testImplementation "org.robolectric:robolectric:3.5.1" testImplementation("com.nhaarman:mockito-kotlin:1.5.0") { exclude group: "org.jetbrains.kotlin" } testImplementation 'org.mockito:mockito-core:2.8.9' - androidTestImplementation 'junit:junit:4.12' + androidTestImplementation deps.junit androidTestImplementation('com.android.support.test:runner:0.5') { exclude group: 'com.android.support', module: 'support-annotations' } androidTestImplementation('com.android.support.test:rules:0.5') { exclude group: 'com.android.support', module: 'support-annotations' } - androidTestImplementation 'org.awaitility:awaitility:3.0.0-rc1' - } android.applicationVariants.all { variant -> diff --git a/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/sqlcipher/CipherTest.kt b/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/sqlcipher/CipherTest.kt index f4373bdf6..42e4d160c 100644 --- a/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/sqlcipher/CipherTest.kt +++ b/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/sqlcipher/CipherTest.kt @@ -5,7 +5,6 @@ import com.raizlabs.dbflow5.config.database import com.raizlabs.dbflow5.query.delete import com.raizlabs.dbflow5.query.result import com.raizlabs.dbflow5.query.select -import com.raizlabs.dbflow5.query.where import org.junit.Assert.assertTrue import org.junit.Test @@ -22,8 +21,8 @@ class CipherTest : BaseInstrumentedUnitTest() { assertTrue(model.exists(this)) val retrieval = (select from CipherModel::class - where CipherModel_Table.name.eq("name")) - .result + where CipherModel_Table.name.eq("name")) + .result assertTrue(retrieval!!.id == model.id) (delete() from CipherModel::class).execute() } diff --git a/dbflow/build.gradle b/dbflow/build.gradle index 389fdf466..241da5406 100644 --- a/dbflow/build.gradle +++ b/dbflow/build.gradle @@ -4,11 +4,11 @@ apply plugin: 'kotlin-android' project.ext.artifactId = bt_name android { - compileSdkVersion Integer.valueOf(dbflow_target_sdk) + compileSdkVersion target_sdk defaultConfig { - minSdkVersion dbflow_min_sdk - targetSdkVersion Integer.valueOf(dbflow_target_sdk) + minSdkVersion min_sdk + targetSdkVersion target_sdk } lintOptions { @@ -24,8 +24,8 @@ android { dependencies { api project("${dbflow_project_prefix}dbflow-core") - api "com.android.support:support-annotations:27.0.1" - api "org.jetbrains.kotlin:kotlin-stdlib-jre8:$kotlin_version" + api "com.android.support:support-annotations:27.0.2" + compile "org.jetbrains.kotlin:kotlin-stdlib:${kotlin_version}" } apply from: '../android-artifacts.gradle' From 25087f86a1b1e4ef5f663d9619560573ca73de3a Mon Sep 17 00:00:00 2001 From: fuzzagrosner Date: Mon, 4 Dec 2017 14:55:09 -0500 Subject: [PATCH 128/234] [deps] update rx 1 and 2. --- build.gradle | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/build.gradle b/build.gradle index 07b842f37..11c819a20 100644 --- a/build.gradle +++ b/build.gradle @@ -9,8 +9,8 @@ buildscript { deps = [ kotlin: "org.jetbrains.kotlin:kotlin-stdlib:${kotlin_version}", sql_cipher: "net.zetetic:android-database-sqlcipher:3.5.7@aar", - rx1: 'io.reactivex:rxjava:1.2.7', - rx2: 'io.reactivex.rxjava2:rxjava:2.1.3', + rx1: 'io.reactivex:rxjava:1.3.4', + rx2: 'io.reactivex.rxjava2:rxjava:2.1.7', coroutines: "org.jetbrains.kotlinx:kotlinx-coroutines-core:0.19.2", javapoet: 'com.squareup:javapoet:1.9.0', kpoet: 'com.github.agrosner:KPoet:1.0.0', From 258881f2d59241bade0400116ec1badc4de9b968 Mon Sep 17 00:00:00 2001 From: fuzzagrosner Date: Mon, 4 Dec 2017 15:48:22 -0500 Subject: [PATCH 129/234] [db] add support android SQLite support library to provide compatibility with DBFlow. Add in maven props to generate artifacts. --- build.gradle | 21 ++++--- dbflow-android-support/.gitignore | 1 + dbflow-android-support/build.gradle | 31 +++++++++ dbflow-android-support/gradle.properties | 3 + dbflow-android-support/proguard-rules.pro | 21 +++++++ dbflow-android-support/settings.gradle | 1 + .../src/main/AndroidManifest.xml | 1 + .../android/support/SupportAndroidDatabase.kt | 63 +++++++++++++++++++ .../SupportAndroidDatabaseStatement.kt | 53 ++++++++++++++++ dbflow-coroutines/build.gradle | 2 + dbflow-coroutines/gradle.properties | 3 + dbflow-coroutines/settings.gradle | 1 + .../dbflow5/config/DatabaseDefinition.kt | 10 --- .../dbflow5/database/AndroidDatabase.kt | 10 --- .../dbflow5/database/DatabaseWrapper.kt | 4 -- settings.gradle | 2 +- 16 files changed, 192 insertions(+), 35 deletions(-) create mode 100644 dbflow-android-support/.gitignore create mode 100644 dbflow-android-support/build.gradle create mode 100644 dbflow-android-support/gradle.properties create mode 100644 dbflow-android-support/proguard-rules.pro create mode 100644 dbflow-android-support/settings.gradle create mode 100644 dbflow-android-support/src/main/AndroidManifest.xml create mode 100644 dbflow-android-support/src/main/java/com/raizlabs/dbflow5/android/support/SupportAndroidDatabase.kt create mode 100644 dbflow-android-support/src/main/java/com/raizlabs/dbflow5/android/support/SupportAndroidDatabaseStatement.kt create mode 100644 dbflow-coroutines/gradle.properties create mode 100644 dbflow-coroutines/settings.gradle diff --git a/build.gradle b/build.gradle index 11c819a20..9f7f0b433 100644 --- a/build.gradle +++ b/build.gradle @@ -1,21 +1,22 @@ buildscript { - ext{ + ext { kotlin_version = '1.2.0' target_sdk = 27 - min_sdk = 4 + min_sdk = 7 min_sdk_rx = 15 sql_cipher_min = 7 deps = [ - kotlin: "org.jetbrains.kotlin:kotlin-stdlib:${kotlin_version}", - sql_cipher: "net.zetetic:android-database-sqlcipher:3.5.7@aar", - rx1: 'io.reactivex:rxjava:1.3.4', - rx2: 'io.reactivex.rxjava2:rxjava:2.1.7', - coroutines: "org.jetbrains.kotlinx:kotlinx-coroutines-core:0.19.2", - javapoet: 'com.squareup:javapoet:1.9.0', - kpoet: 'com.github.agrosner:KPoet:1.0.0', + kotlin : "org.jetbrains.kotlin:kotlin-stdlib:${kotlin_version}", + sql_cipher : "net.zetetic:android-database-sqlcipher:3.5.7@aar", + rx1 : 'io.reactivex:rxjava:1.3.4', + rx2 : 'io.reactivex.rxjava2:rxjava:2.1.7', + coroutines : "org.jetbrains.kotlinx:kotlinx-coroutines-core:0.19.2", + javapoet : 'com.squareup:javapoet:1.9.0', + kpoet : 'com.github.agrosner:KPoet:1.0.0', javax_annotation: 'org.glassfish:javax.annotation:10.0-b28', - junit: 'junit:junit:4.12' + junit : 'junit:junit:4.12', + support_db : "android.arch.persistence:db:1.0.0" ] } repositories { diff --git a/dbflow-android-support/.gitignore b/dbflow-android-support/.gitignore new file mode 100644 index 000000000..796b96d1c --- /dev/null +++ b/dbflow-android-support/.gitignore @@ -0,0 +1 @@ +/build diff --git a/dbflow-android-support/build.gradle b/dbflow-android-support/build.gradle new file mode 100644 index 000000000..2bda61503 --- /dev/null +++ b/dbflow-android-support/build.gradle @@ -0,0 +1,31 @@ +apply plugin: 'com.android.library' +apply plugin: 'kotlin-android' + +project.ext.artifactId = bt_name + +android { + compileSdkVersion target_sdk + + defaultConfig { + minSdkVersion 14 + targetSdkVersion target_sdk + } + + compileOptions { + sourceCompatibility JavaVersion.VERSION_1_8 + targetCompatibility JavaVersion.VERSION_1_8 + } + + buildTypes { + release { + minifyEnabled false + proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro' + } + } + +} + +dependencies { + implementation project("${dbflow_project_prefix}dbflow") + api deps.support_db +} diff --git a/dbflow-android-support/gradle.properties b/dbflow-android-support/gradle.properties new file mode 100644 index 000000000..7f44795f5 --- /dev/null +++ b/dbflow-android-support/gradle.properties @@ -0,0 +1,3 @@ +bt_name=dbflow-android-support +bt_packaging=aar +bt_artifact_id=dbflow-android-support \ No newline at end of file diff --git a/dbflow-android-support/proguard-rules.pro b/dbflow-android-support/proguard-rules.pro new file mode 100644 index 000000000..f1b424510 --- /dev/null +++ b/dbflow-android-support/proguard-rules.pro @@ -0,0 +1,21 @@ +# Add project specific ProGuard rules here. +# You can control the set of applied configuration files using the +# proguardFiles setting in build.gradle. +# +# For more details, see +# http://developer.android.com/guide/developing/tools/proguard.html + +# If your project uses WebView with JS, uncomment the following +# and specify the fully qualified class name to the JavaScript interface +# class: +#-keepclassmembers class fqcn.of.javascript.interface.for.webview { +# public *; +#} + +# Uncomment this to preserve the line number information for +# debugging stack traces. +#-keepattributes SourceFile,LineNumberTable + +# If you keep the line number information, uncomment this to +# hide the original source file name. +#-renamesourcefileattribute SourceFile diff --git a/dbflow-android-support/settings.gradle b/dbflow-android-support/settings.gradle new file mode 100644 index 000000000..00126c83c --- /dev/null +++ b/dbflow-android-support/settings.gradle @@ -0,0 +1 @@ +rootProject.name = buildName \ No newline at end of file diff --git a/dbflow-android-support/src/main/AndroidManifest.xml b/dbflow-android-support/src/main/AndroidManifest.xml new file mode 100644 index 000000000..dd1028baf --- /dev/null +++ b/dbflow-android-support/src/main/AndroidManifest.xml @@ -0,0 +1 @@ + diff --git a/dbflow-android-support/src/main/java/com/raizlabs/dbflow5/android/support/SupportAndroidDatabase.kt b/dbflow-android-support/src/main/java/com/raizlabs/dbflow5/android/support/SupportAndroidDatabase.kt new file mode 100644 index 000000000..a1a51bf74 --- /dev/null +++ b/dbflow-android-support/src/main/java/com/raizlabs/dbflow5/android/support/SupportAndroidDatabase.kt @@ -0,0 +1,63 @@ +package com.raizlabs.dbflow5.android.support + +import android.arch.persistence.db.SupportSQLiteDatabase +import android.content.ContentValues +import com.raizlabs.dbflow5.database.DatabaseStatement +import com.raizlabs.dbflow5.database.DatabaseWrapper +import com.raizlabs.dbflow5.database.FlowCursor +import com.raizlabs.dbflow5.database.rethrowDBFlowException + +/** + * Description: Species the [SupportSQLiteDatabase] implementation of DBFlow. This provides compatibility + * to the support libraries. + */ +class SupportAndroidDatabase internal constructor(val database: SupportSQLiteDatabase) : DatabaseWrapper { + override val version: Int + get() = database.version + + override fun execSQL(query: String) = rethrowDBFlowException { + database.execSQL(query) + } + + override fun beginTransaction() { + database.beginTransaction() + } + + override fun setTransactionSuccessful() { + database.setTransactionSuccessful() + } + + override fun endTransaction() { + database.endTransaction() + } + + override fun compileStatement(rawQuery: String): DatabaseStatement + = rethrowDBFlowException { SupportAndroidDatabaseStatement.from(database.compileStatement(rawQuery)) } + + override fun rawQuery(query: String, selectionArgs: Array?): FlowCursor + = rethrowDBFlowException { FlowCursor.from(database.query(query, selectionArgs)) } + + override fun updateWithOnConflict(tableName: String, + contentValues: ContentValues, + where: String?, + whereArgs: Array?, + conflictAlgorithm: Int): Long = + rethrowDBFlowException { + database.update(tableName, conflictAlgorithm, contentValues, where, whereArgs) + }.toLong() + + override fun insertWithOnConflict(tableName: String, + nullColumnHack: String?, + values: ContentValues, + sqLiteDatabaseAlgorithmInt: Int): Long = + rethrowDBFlowException { database.insert(tableName, sqLiteDatabaseAlgorithmInt, values) } + + override fun delete(tableName: String, whereClause: String?, whereArgs: Array?): Int = + rethrowDBFlowException { database.delete(tableName, whereClause, whereArgs) } + + companion object { + + @JvmStatic + fun from(database: SupportSQLiteDatabase): SupportAndroidDatabase = SupportAndroidDatabase(database) + } +} \ No newline at end of file diff --git a/dbflow-android-support/src/main/java/com/raizlabs/dbflow5/android/support/SupportAndroidDatabaseStatement.kt b/dbflow-android-support/src/main/java/com/raizlabs/dbflow5/android/support/SupportAndroidDatabaseStatement.kt new file mode 100644 index 000000000..82d15d461 --- /dev/null +++ b/dbflow-android-support/src/main/java/com/raizlabs/dbflow5/android/support/SupportAndroidDatabaseStatement.kt @@ -0,0 +1,53 @@ +package com.raizlabs.dbflow5.android.support + +import android.arch.persistence.db.SupportSQLiteStatement +import com.raizlabs.dbflow5.database.BaseDatabaseStatement +import com.raizlabs.dbflow5.database.rethrowDBFlowException + +/** + * Description: Maps the [SupportSQLiteStatement] to a [SupportAndroidDatabaseStatement] + */ +class SupportAndroidDatabaseStatement(val statement: SupportSQLiteStatement) : BaseDatabaseStatement() { + override fun executeUpdateDelete(): Long = statement.executeUpdateDelete().toLong() + + override fun execute() { + statement.execute() + } + + override fun close() { + statement.close() + } + + override fun simpleQueryForLong(): Long = rethrowDBFlowException { statement.simpleQueryForLong() } + + override fun simpleQueryForString(): String? = rethrowDBFlowException { statement.simpleQueryForString() } + + override fun executeInsert(): Long = rethrowDBFlowException { statement.executeInsert() } + + override fun bindString(index: Int, s: String) { + statement.bindString(index, s) + } + + override fun bindNull(index: Int) { + statement.bindNull(index) + } + + override fun bindLong(index: Int, aLong: Long) { + statement.bindLong(index, aLong) + } + + override fun bindDouble(index: Int, aDouble: Double) { + statement.bindDouble(index, aDouble) + } + + override fun bindBlob(index: Int, bytes: ByteArray) { + statement.bindBlob(index, bytes) + } + + companion object { + + @JvmStatic + fun from(sqLiteStatement: SupportSQLiteStatement): SupportAndroidDatabaseStatement = + SupportAndroidDatabaseStatement(sqLiteStatement) + } +} \ No newline at end of file diff --git a/dbflow-coroutines/build.gradle b/dbflow-coroutines/build.gradle index ad727111b..2324a539f 100644 --- a/dbflow-coroutines/build.gradle +++ b/dbflow-coroutines/build.gradle @@ -1,6 +1,8 @@ apply plugin: 'com.android.library' apply plugin: 'kotlin-android' +project.ext.artifactId = bt_name + android { compileSdkVersion 26 defaultConfig { diff --git a/dbflow-coroutines/gradle.properties b/dbflow-coroutines/gradle.properties new file mode 100644 index 000000000..b4da7dfc7 --- /dev/null +++ b/dbflow-coroutines/gradle.properties @@ -0,0 +1,3 @@ +bt_name=dbflow-coroutines +bt_packaging=aar +bt_artifact_id=dbflow-coroutines \ No newline at end of file diff --git a/dbflow-coroutines/settings.gradle b/dbflow-coroutines/settings.gradle new file mode 100644 index 000000000..00126c83c --- /dev/null +++ b/dbflow-coroutines/settings.gradle @@ -0,0 +1 @@ +rootProject.name = buildName \ No newline at end of file diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseDefinition.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseDefinition.kt index 3e50093a1..2e6ada1c1 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseDefinition.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseDefinition.kt @@ -435,16 +435,6 @@ abstract class DatabaseDefinition : DatabaseWrapper { sqLiteDatabaseAlgorithmInt: Int): Long = writableDatabase.insertWithOnConflict(tableName, nullColumnHack, values, sqLiteDatabaseAlgorithmInt) - override fun query( - tableName: String, - columns: Array?, - selection: String?, - selectionArgs: Array?, - groupBy: String?, - having: String?, - orderBy: String?): FlowCursor - = writableDatabase.query(tableName, columns, selection, selectionArgs, groupBy, having, orderBy) - override fun delete(tableName: String, whereClause: String?, whereArgs: Array?): Int = writableDatabase.delete(tableName, whereClause, whereArgs) } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidDatabase.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidDatabase.kt index a926d3613..b6e5eb9e4 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidDatabase.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidDatabase.kt @@ -61,16 +61,6 @@ class AndroidDatabase internal constructor(val database: SQLiteDatabase) : Datab } } - override fun query(tableName: String, - columns: Array?, - selection: String?, - selectionArgs: Array?, - groupBy: String?, - having: String?, - orderBy: String?): FlowCursor = rethrowDBFlowException { - FlowCursor.from(database.query(tableName, columns, selection, selectionArgs, groupBy, having, orderBy)) - } - override fun delete(tableName: String, whereClause: String?, whereArgs: Array?): Int = rethrowDBFlowException { database.delete(tableName, whereClause, whereArgs) } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseWrapper.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseWrapper.kt index 4e8e7a7fc..d30e3d089 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseWrapper.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseWrapper.kt @@ -32,9 +32,5 @@ interface DatabaseWrapper { values: ContentValues, sqLiteDatabaseAlgorithmInt: Int): Long - fun query(tableName: String, columns: Array?, selection: String?, - selectionArgs: Array?, groupBy: String?, - having: String?, orderBy: String?): FlowCursor - fun delete(tableName: String, whereClause: String?, whereArgs: Array?): Int } diff --git a/settings.gradle b/settings.gradle index 6e1a455aa..523c79285 100644 --- a/settings.gradle +++ b/settings.gradle @@ -1,4 +1,4 @@ -include ':dbflow', ':dbflow-rx2', ':dbflow-coroutines', +include ':dbflow', ':dbflow-rx2', ':dbflow-coroutines', ':dbflow-android-support', ':dbflow-processor', ':dbflow-core', ':dbflow-sqlcipher', From 61155b88d5da91fb4c83afdfe77e82384ff3c0cb Mon Sep 17 00:00:00 2001 From: fuzzagrosner Date: Mon, 4 Dec 2017 16:29:01 -0500 Subject: [PATCH 130/234] [db] add support AndroidSQLiteOpenHelper. not fully implemented yet. --- .../support/SupportAndroidSQLiteOpenHelper.kt | 140 ++++++++++++++++++ .../dbflow5/sqlcipher/SQLCipherDatabase.kt | 10 -- .../database/AndroidSQLiteOpenHelper.kt | 6 +- 3 files changed, 141 insertions(+), 15 deletions(-) create mode 100644 dbflow-android-support/src/main/java/com/raizlabs/dbflow5/android/support/SupportAndroidSQLiteOpenHelper.kt diff --git a/dbflow-android-support/src/main/java/com/raizlabs/dbflow5/android/support/SupportAndroidSQLiteOpenHelper.kt b/dbflow-android-support/src/main/java/com/raizlabs/dbflow5/android/support/SupportAndroidSQLiteOpenHelper.kt new file mode 100644 index 000000000..2e1786f8e --- /dev/null +++ b/dbflow-android-support/src/main/java/com/raizlabs/dbflow5/android/support/SupportAndroidSQLiteOpenHelper.kt @@ -0,0 +1,140 @@ +package com.raizlabs.dbflow5.android.support + +import android.content.Context +import android.database.sqlite.SQLiteDatabase +import android.database.sqlite.SQLiteOpenHelper +import com.raizlabs.dbflow5.config.DatabaseDefinition +import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.database.AndroidDatabase +import com.raizlabs.dbflow5.database.BaseDatabaseHelper +import com.raizlabs.dbflow5.database.DatabaseHelperDelegate +import com.raizlabs.dbflow5.database.DatabaseHelperListener +import com.raizlabs.dbflow5.database.DatabaseWrapper +import com.raizlabs.dbflow5.database.OpenHelper + +/** + * Description: + */ +class SupportAndroidSQLiteOpenHelper( + databaseDefinition: DatabaseDefinition, + listener: DatabaseHelperListener?) + : OpenHelper { + + private val databaseHelperDelegate: DatabaseHelperDelegate + private var androidDatabase: SupportAndroidDatabase? = null + + init { + var backupHelper: OpenHelper? = null + if (databaseDefinition.backupEnabled()) { + // Temp database mirrors existing + backupHelper = BackupHelper(FlowManager.context, + DatabaseHelperDelegate.getTempDbFileName(databaseDefinition), + databaseDefinition.databaseVersion, databaseDefinition) + } + + databaseHelperDelegate = DatabaseHelperDelegate(listener, databaseDefinition, backupHelper) + } + + override fun performRestoreFromBackup() { + databaseHelperDelegate.performRestoreFromBackup() + } + + override val delegate: DatabaseHelperDelegate? + get() = databaseHelperDelegate + + override val isDatabaseIntegrityOk: Boolean + get() = databaseHelperDelegate.isDatabaseIntegrityOk + + override fun backupDB() { + databaseHelperDelegate.backupDB() + } + + override val database: DatabaseWrapper + get() { + if (androidDatabase == null || !androidDatabase!!.database.isOpen) { + androidDatabase = SupportAndroidDatabase.from(writableDatabase) + } + return androidDatabase!! + } + + /** + * Set a listener to listen for specific DB events and perform an action before we execute this classes + * specific methods. + * + * @param helperListener + */ + override fun setDatabaseListener(helperListener: DatabaseHelperListener?) { + databaseHelperDelegate.setDatabaseHelperListener(helperListener) + } + + override fun onCreate(db: SQLiteDatabase) { + databaseHelperDelegate.onCreate(AndroidDatabase.from(db)) + } + + override fun onUpgrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) { + databaseHelperDelegate.onUpgrade(AndroidDatabase.from(db), oldVersion, newVersion) + } + + override fun onOpen(db: SQLiteDatabase) { + databaseHelperDelegate.onOpen(AndroidDatabase.from(db)) + } + + override fun onDowngrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) { + databaseHelperDelegate.onDowngrade(AndroidDatabase.from(db), oldVersion, newVersion) + } + + override fun closeDB() { + androidDatabase?.database?.close() + } + + /** + * Simple helper to manage backup. + */ + private inner class BackupHelper(context: Context, + name: String, version: Int, + databaseDefinition: DatabaseDefinition) + : SQLiteOpenHelper(context, name, null, version), OpenHelper { + + private var androidDatabase: SupportAndroidDatabase? = null + private val baseDatabaseHelper: BaseDatabaseHelper = BaseDatabaseHelper(databaseDefinition) + + override val database: DatabaseWrapper + get() { + if (androidDatabase == null) { + androidDatabase = SupportAndroidDatabase.from(writableDatabase) + } + return androidDatabase!! + } + + override fun performRestoreFromBackup() {} + + override val delegate: DatabaseHelperDelegate? + get() = null + + override val isDatabaseIntegrityOk: Boolean + get() = false + + override fun backupDB() {} + + override fun setDatabaseListener(helperListener: DatabaseHelperListener?) {} + + override fun onCreate(db: SQLiteDatabase) { + baseDatabaseHelper.onCreate(AndroidDatabase.from(db)) + } + + override fun onUpgrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) { + baseDatabaseHelper.onUpgrade(AndroidDatabase.from(db), oldVersion, newVersion) + } + + override fun onOpen(db: SQLiteDatabase) { + baseDatabaseHelper.onOpen(AndroidDatabase.from(db)) + } + + override fun onDowngrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) { + baseDatabaseHelper.onDowngrade(AndroidDatabase.from(db), oldVersion, newVersion) + } + + override fun closeDB() {} + } + +} diff --git a/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherDatabase.kt b/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherDatabase.kt index 62a4b0600..80911f0e5 100644 --- a/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherDatabase.kt +++ b/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherDatabase.kt @@ -54,16 +54,6 @@ internal constructor(val database: SQLiteDatabase) : DatabaseWrapper { database.insertWithOnConflict(tableName, nullColumnHack, values, sqLiteDatabaseAlgorithmInt) } - override fun query(tableName: String, - columns: Array?, - selection: String?, - selectionArgs: Array?, - groupBy: String?, - having: String?, - orderBy: String?): FlowCursor = rethrowDBFlowException { - FlowCursor.from(database.query(tableName, columns, selection, selectionArgs, groupBy, having, orderBy)) - } - override fun delete(tableName: String, whereClause: String?, whereArgs: Array?): Int = rethrowDBFlowException { diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidSQLiteOpenHelper.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidSQLiteOpenHelper.kt index e31e90dc9..fa26b1b52 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidSQLiteOpenHelper.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidSQLiteOpenHelper.kt @@ -94,11 +94,7 @@ class AndroidSQLiteOpenHelper( : SQLiteOpenHelper(context, name, null, version), OpenHelper { private var androidDatabase: AndroidDatabase? = null - private val baseDatabaseHelper: BaseDatabaseHelper - - init { - this.baseDatabaseHelper = BaseDatabaseHelper(databaseDefinition) - } + private val baseDatabaseHelper: BaseDatabaseHelper = BaseDatabaseHelper(databaseDefinition) override val database: DatabaseWrapper get() { From 4dcff1bc39df6c934f7fe07a9d165c4cc568b375 Mon Sep 17 00:00:00 2001 From: fuzzagrosner Date: Tue, 5 Dec 2017 11:53:17 -0500 Subject: [PATCH 131/234] [db] remove support lib for db. dont need it. add query method back. --- build.gradle | 1 - dbflow-android-support/.gitignore | 1 - dbflow-android-support/build.gradle | 31 ---- dbflow-android-support/gradle.properties | 3 - dbflow-android-support/proguard-rules.pro | 21 --- dbflow-android-support/settings.gradle | 1 - .../src/main/AndroidManifest.xml | 1 - .../android/support/SupportAndroidDatabase.kt | 63 -------- .../SupportAndroidDatabaseStatement.kt | 53 ------- .../support/SupportAndroidSQLiteOpenHelper.kt | 140 ------------------ .../dbflow5/sqlcipher/SQLCipherDatabase.kt | 10 ++ .../dbflow5/sqlcipher/SQLCipherOpenHelper.kt | 18 ++- .../dbflow5/config/DatabaseDefinition.kt | 8 + .../dbflow5/database/AndroidDatabase.kt | 10 ++ .../database/AndroidSQLiteOpenHelper.kt | 6 +- .../dbflow5/database/DatabaseWrapper.kt | 4 + .../raizlabs/dbflow5/database/OpenHelper.kt | 6 + settings.gradle | 2 +- 18 files changed, 53 insertions(+), 326 deletions(-) delete mode 100644 dbflow-android-support/.gitignore delete mode 100644 dbflow-android-support/build.gradle delete mode 100644 dbflow-android-support/gradle.properties delete mode 100644 dbflow-android-support/proguard-rules.pro delete mode 100644 dbflow-android-support/settings.gradle delete mode 100644 dbflow-android-support/src/main/AndroidManifest.xml delete mode 100644 dbflow-android-support/src/main/java/com/raizlabs/dbflow5/android/support/SupportAndroidDatabase.kt delete mode 100644 dbflow-android-support/src/main/java/com/raizlabs/dbflow5/android/support/SupportAndroidDatabaseStatement.kt delete mode 100644 dbflow-android-support/src/main/java/com/raizlabs/dbflow5/android/support/SupportAndroidSQLiteOpenHelper.kt diff --git a/build.gradle b/build.gradle index 9f7f0b433..6aa6bebcc 100644 --- a/build.gradle +++ b/build.gradle @@ -16,7 +16,6 @@ buildscript { kpoet : 'com.github.agrosner:KPoet:1.0.0', javax_annotation: 'org.glassfish:javax.annotation:10.0-b28', junit : 'junit:junit:4.12', - support_db : "android.arch.persistence:db:1.0.0" ] } repositories { diff --git a/dbflow-android-support/.gitignore b/dbflow-android-support/.gitignore deleted file mode 100644 index 796b96d1c..000000000 --- a/dbflow-android-support/.gitignore +++ /dev/null @@ -1 +0,0 @@ -/build diff --git a/dbflow-android-support/build.gradle b/dbflow-android-support/build.gradle deleted file mode 100644 index 2bda61503..000000000 --- a/dbflow-android-support/build.gradle +++ /dev/null @@ -1,31 +0,0 @@ -apply plugin: 'com.android.library' -apply plugin: 'kotlin-android' - -project.ext.artifactId = bt_name - -android { - compileSdkVersion target_sdk - - defaultConfig { - minSdkVersion 14 - targetSdkVersion target_sdk - } - - compileOptions { - sourceCompatibility JavaVersion.VERSION_1_8 - targetCompatibility JavaVersion.VERSION_1_8 - } - - buildTypes { - release { - minifyEnabled false - proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro' - } - } - -} - -dependencies { - implementation project("${dbflow_project_prefix}dbflow") - api deps.support_db -} diff --git a/dbflow-android-support/gradle.properties b/dbflow-android-support/gradle.properties deleted file mode 100644 index 7f44795f5..000000000 --- a/dbflow-android-support/gradle.properties +++ /dev/null @@ -1,3 +0,0 @@ -bt_name=dbflow-android-support -bt_packaging=aar -bt_artifact_id=dbflow-android-support \ No newline at end of file diff --git a/dbflow-android-support/proguard-rules.pro b/dbflow-android-support/proguard-rules.pro deleted file mode 100644 index f1b424510..000000000 --- a/dbflow-android-support/proguard-rules.pro +++ /dev/null @@ -1,21 +0,0 @@ -# Add project specific ProGuard rules here. -# You can control the set of applied configuration files using the -# proguardFiles setting in build.gradle. -# -# For more details, see -# http://developer.android.com/guide/developing/tools/proguard.html - -# If your project uses WebView with JS, uncomment the following -# and specify the fully qualified class name to the JavaScript interface -# class: -#-keepclassmembers class fqcn.of.javascript.interface.for.webview { -# public *; -#} - -# Uncomment this to preserve the line number information for -# debugging stack traces. -#-keepattributes SourceFile,LineNumberTable - -# If you keep the line number information, uncomment this to -# hide the original source file name. -#-renamesourcefileattribute SourceFile diff --git a/dbflow-android-support/settings.gradle b/dbflow-android-support/settings.gradle deleted file mode 100644 index 00126c83c..000000000 --- a/dbflow-android-support/settings.gradle +++ /dev/null @@ -1 +0,0 @@ -rootProject.name = buildName \ No newline at end of file diff --git a/dbflow-android-support/src/main/AndroidManifest.xml b/dbflow-android-support/src/main/AndroidManifest.xml deleted file mode 100644 index dd1028baf..000000000 --- a/dbflow-android-support/src/main/AndroidManifest.xml +++ /dev/null @@ -1 +0,0 @@ - diff --git a/dbflow-android-support/src/main/java/com/raizlabs/dbflow5/android/support/SupportAndroidDatabase.kt b/dbflow-android-support/src/main/java/com/raizlabs/dbflow5/android/support/SupportAndroidDatabase.kt deleted file mode 100644 index a1a51bf74..000000000 --- a/dbflow-android-support/src/main/java/com/raizlabs/dbflow5/android/support/SupportAndroidDatabase.kt +++ /dev/null @@ -1,63 +0,0 @@ -package com.raizlabs.dbflow5.android.support - -import android.arch.persistence.db.SupportSQLiteDatabase -import android.content.ContentValues -import com.raizlabs.dbflow5.database.DatabaseStatement -import com.raizlabs.dbflow5.database.DatabaseWrapper -import com.raizlabs.dbflow5.database.FlowCursor -import com.raizlabs.dbflow5.database.rethrowDBFlowException - -/** - * Description: Species the [SupportSQLiteDatabase] implementation of DBFlow. This provides compatibility - * to the support libraries. - */ -class SupportAndroidDatabase internal constructor(val database: SupportSQLiteDatabase) : DatabaseWrapper { - override val version: Int - get() = database.version - - override fun execSQL(query: String) = rethrowDBFlowException { - database.execSQL(query) - } - - override fun beginTransaction() { - database.beginTransaction() - } - - override fun setTransactionSuccessful() { - database.setTransactionSuccessful() - } - - override fun endTransaction() { - database.endTransaction() - } - - override fun compileStatement(rawQuery: String): DatabaseStatement - = rethrowDBFlowException { SupportAndroidDatabaseStatement.from(database.compileStatement(rawQuery)) } - - override fun rawQuery(query: String, selectionArgs: Array?): FlowCursor - = rethrowDBFlowException { FlowCursor.from(database.query(query, selectionArgs)) } - - override fun updateWithOnConflict(tableName: String, - contentValues: ContentValues, - where: String?, - whereArgs: Array?, - conflictAlgorithm: Int): Long = - rethrowDBFlowException { - database.update(tableName, conflictAlgorithm, contentValues, where, whereArgs) - }.toLong() - - override fun insertWithOnConflict(tableName: String, - nullColumnHack: String?, - values: ContentValues, - sqLiteDatabaseAlgorithmInt: Int): Long = - rethrowDBFlowException { database.insert(tableName, sqLiteDatabaseAlgorithmInt, values) } - - override fun delete(tableName: String, whereClause: String?, whereArgs: Array?): Int = - rethrowDBFlowException { database.delete(tableName, whereClause, whereArgs) } - - companion object { - - @JvmStatic - fun from(database: SupportSQLiteDatabase): SupportAndroidDatabase = SupportAndroidDatabase(database) - } -} \ No newline at end of file diff --git a/dbflow-android-support/src/main/java/com/raizlabs/dbflow5/android/support/SupportAndroidDatabaseStatement.kt b/dbflow-android-support/src/main/java/com/raizlabs/dbflow5/android/support/SupportAndroidDatabaseStatement.kt deleted file mode 100644 index 82d15d461..000000000 --- a/dbflow-android-support/src/main/java/com/raizlabs/dbflow5/android/support/SupportAndroidDatabaseStatement.kt +++ /dev/null @@ -1,53 +0,0 @@ -package com.raizlabs.dbflow5.android.support - -import android.arch.persistence.db.SupportSQLiteStatement -import com.raizlabs.dbflow5.database.BaseDatabaseStatement -import com.raizlabs.dbflow5.database.rethrowDBFlowException - -/** - * Description: Maps the [SupportSQLiteStatement] to a [SupportAndroidDatabaseStatement] - */ -class SupportAndroidDatabaseStatement(val statement: SupportSQLiteStatement) : BaseDatabaseStatement() { - override fun executeUpdateDelete(): Long = statement.executeUpdateDelete().toLong() - - override fun execute() { - statement.execute() - } - - override fun close() { - statement.close() - } - - override fun simpleQueryForLong(): Long = rethrowDBFlowException { statement.simpleQueryForLong() } - - override fun simpleQueryForString(): String? = rethrowDBFlowException { statement.simpleQueryForString() } - - override fun executeInsert(): Long = rethrowDBFlowException { statement.executeInsert() } - - override fun bindString(index: Int, s: String) { - statement.bindString(index, s) - } - - override fun bindNull(index: Int) { - statement.bindNull(index) - } - - override fun bindLong(index: Int, aLong: Long) { - statement.bindLong(index, aLong) - } - - override fun bindDouble(index: Int, aDouble: Double) { - statement.bindDouble(index, aDouble) - } - - override fun bindBlob(index: Int, bytes: ByteArray) { - statement.bindBlob(index, bytes) - } - - companion object { - - @JvmStatic - fun from(sqLiteStatement: SupportSQLiteStatement): SupportAndroidDatabaseStatement = - SupportAndroidDatabaseStatement(sqLiteStatement) - } -} \ No newline at end of file diff --git a/dbflow-android-support/src/main/java/com/raizlabs/dbflow5/android/support/SupportAndroidSQLiteOpenHelper.kt b/dbflow-android-support/src/main/java/com/raizlabs/dbflow5/android/support/SupportAndroidSQLiteOpenHelper.kt deleted file mode 100644 index 2e1786f8e..000000000 --- a/dbflow-android-support/src/main/java/com/raizlabs/dbflow5/android/support/SupportAndroidSQLiteOpenHelper.kt +++ /dev/null @@ -1,140 +0,0 @@ -package com.raizlabs.dbflow5.android.support - -import android.content.Context -import android.database.sqlite.SQLiteDatabase -import android.database.sqlite.SQLiteOpenHelper -import com.raizlabs.dbflow5.config.DatabaseDefinition -import com.raizlabs.dbflow5.config.FlowManager -import com.raizlabs.dbflow5.database.AndroidDatabase -import com.raizlabs.dbflow5.database.BaseDatabaseHelper -import com.raizlabs.dbflow5.database.DatabaseHelperDelegate -import com.raizlabs.dbflow5.database.DatabaseHelperListener -import com.raizlabs.dbflow5.database.DatabaseWrapper -import com.raizlabs.dbflow5.database.OpenHelper - -/** - * Description: - */ -class SupportAndroidSQLiteOpenHelper( - databaseDefinition: DatabaseDefinition, - listener: DatabaseHelperListener?) - : OpenHelper { - - private val databaseHelperDelegate: DatabaseHelperDelegate - private var androidDatabase: SupportAndroidDatabase? = null - - init { - var backupHelper: OpenHelper? = null - if (databaseDefinition.backupEnabled()) { - // Temp database mirrors existing - backupHelper = BackupHelper(FlowManager.context, - DatabaseHelperDelegate.getTempDbFileName(databaseDefinition), - databaseDefinition.databaseVersion, databaseDefinition) - } - - databaseHelperDelegate = DatabaseHelperDelegate(listener, databaseDefinition, backupHelper) - } - - override fun performRestoreFromBackup() { - databaseHelperDelegate.performRestoreFromBackup() - } - - override val delegate: DatabaseHelperDelegate? - get() = databaseHelperDelegate - - override val isDatabaseIntegrityOk: Boolean - get() = databaseHelperDelegate.isDatabaseIntegrityOk - - override fun backupDB() { - databaseHelperDelegate.backupDB() - } - - override val database: DatabaseWrapper - get() { - if (androidDatabase == null || !androidDatabase!!.database.isOpen) { - androidDatabase = SupportAndroidDatabase.from(writableDatabase) - } - return androidDatabase!! - } - - /** - * Set a listener to listen for specific DB events and perform an action before we execute this classes - * specific methods. - * - * @param helperListener - */ - override fun setDatabaseListener(helperListener: DatabaseHelperListener?) { - databaseHelperDelegate.setDatabaseHelperListener(helperListener) - } - - override fun onCreate(db: SQLiteDatabase) { - databaseHelperDelegate.onCreate(AndroidDatabase.from(db)) - } - - override fun onUpgrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) { - databaseHelperDelegate.onUpgrade(AndroidDatabase.from(db), oldVersion, newVersion) - } - - override fun onOpen(db: SQLiteDatabase) { - databaseHelperDelegate.onOpen(AndroidDatabase.from(db)) - } - - override fun onDowngrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) { - databaseHelperDelegate.onDowngrade(AndroidDatabase.from(db), oldVersion, newVersion) - } - - override fun closeDB() { - androidDatabase?.database?.close() - } - - /** - * Simple helper to manage backup. - */ - private inner class BackupHelper(context: Context, - name: String, version: Int, - databaseDefinition: DatabaseDefinition) - : SQLiteOpenHelper(context, name, null, version), OpenHelper { - - private var androidDatabase: SupportAndroidDatabase? = null - private val baseDatabaseHelper: BaseDatabaseHelper = BaseDatabaseHelper(databaseDefinition) - - override val database: DatabaseWrapper - get() { - if (androidDatabase == null) { - androidDatabase = SupportAndroidDatabase.from(writableDatabase) - } - return androidDatabase!! - } - - override fun performRestoreFromBackup() {} - - override val delegate: DatabaseHelperDelegate? - get() = null - - override val isDatabaseIntegrityOk: Boolean - get() = false - - override fun backupDB() {} - - override fun setDatabaseListener(helperListener: DatabaseHelperListener?) {} - - override fun onCreate(db: SQLiteDatabase) { - baseDatabaseHelper.onCreate(AndroidDatabase.from(db)) - } - - override fun onUpgrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) { - baseDatabaseHelper.onUpgrade(AndroidDatabase.from(db), oldVersion, newVersion) - } - - override fun onOpen(db: SQLiteDatabase) { - baseDatabaseHelper.onOpen(AndroidDatabase.from(db)) - } - - override fun onDowngrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) { - baseDatabaseHelper.onDowngrade(AndroidDatabase.from(db), oldVersion, newVersion) - } - - override fun closeDB() {} - } - -} diff --git a/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherDatabase.kt b/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherDatabase.kt index 80911f0e5..62a4b0600 100644 --- a/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherDatabase.kt +++ b/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherDatabase.kt @@ -54,6 +54,16 @@ internal constructor(val database: SQLiteDatabase) : DatabaseWrapper { database.insertWithOnConflict(tableName, nullColumnHack, values, sqLiteDatabaseAlgorithmInt) } + override fun query(tableName: String, + columns: Array?, + selection: String?, + selectionArgs: Array?, + groupBy: String?, + having: String?, + orderBy: String?): FlowCursor = rethrowDBFlowException { + FlowCursor.from(database.query(tableName, columns, selection, selectionArgs, groupBy, having, orderBy)) + } + override fun delete(tableName: String, whereClause: String?, whereArgs: Array?): Int = rethrowDBFlowException { diff --git a/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherOpenHelper.kt b/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherOpenHelper.kt index ca4575c8a..92d9119c4 100644 --- a/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherOpenHelper.kt +++ b/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherOpenHelper.kt @@ -19,7 +19,9 @@ import net.sqlcipher.database.SQLiteOpenHelper * of your database to get it to work with specifying the secret you use for the databaseForTable. */ abstract class SQLCipherOpenHelper(databaseDefinition: DatabaseDefinition, listener: DatabaseHelperListener?) - : SQLiteOpenHelper(FlowManager.context, if (databaseDefinition.isInMemory) null else databaseDefinition.databaseFileName, null, databaseDefinition.databaseVersion), OpenHelper { + : SQLiteOpenHelper(FlowManager.context, + if (databaseDefinition.isInMemory) null else databaseDefinition.databaseFileName, + null, databaseDefinition.databaseVersion), OpenHelper { final override val delegate: DatabaseHelperDelegate private var cipherDatabase: SQLCipherDatabase? = null @@ -47,8 +49,8 @@ abstract class SQLCipherOpenHelper(databaseDefinition: DatabaseDefinition, liste if (databaseDefinition.backupEnabled()) { // Temp database mirrors existing backupHelper = BackupHelper(FlowManager.context, - DatabaseHelperDelegate.getTempDbFileName(databaseDefinition), - databaseDefinition.databaseVersion, databaseDefinition) + DatabaseHelperDelegate.getTempDbFileName(databaseDefinition), + databaseDefinition.databaseVersion, databaseDefinition) } delegate = DatabaseHelperDelegate(listener, databaseDefinition, backupHelper) @@ -115,13 +117,13 @@ abstract class SQLCipherOpenHelper(databaseDefinition: DatabaseDefinition, liste this.baseDatabaseHelper = BaseDatabaseHelper(databaseDefinition) } - override fun performRestoreFromBackup() {} + override fun performRestoreFromBackup() = Unit - override fun backupDB() {} + override fun backupDB() = Unit - override fun closeDB() {} + override fun closeDB() = Unit - override fun setDatabaseListener(helperListener: DatabaseHelperListener?) {} + override fun setDatabaseListener(helperListener: DatabaseHelperListener?) = Unit override fun onCreate(db: SQLiteDatabase) { baseDatabaseHelper.onCreate(SQLCipherDatabase.from(db)) @@ -134,5 +136,7 @@ abstract class SQLCipherOpenHelper(databaseDefinition: DatabaseDefinition, liste override fun onOpen(db: SQLiteDatabase) { baseDatabaseHelper.onOpen(SQLCipherDatabase.from(db)) } + + override fun setWriteAheadLoggingEnabled(enabled: Boolean) = Unit } } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseDefinition.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseDefinition.kt index 2e6ada1c1..e4b17ef41 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseDefinition.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseDefinition.kt @@ -437,4 +437,12 @@ abstract class DatabaseDefinition : DatabaseWrapper { override fun delete(tableName: String, whereClause: String?, whereArgs: Array?): Int = writableDatabase.delete(tableName, whereClause, whereArgs) + + override fun query(tableName: String, + columns: Array?, + selection: String?, + selectionArgs: Array?, + groupBy: String?, having: String?, + orderBy: String?): FlowCursor + = writableDatabase.query(tableName, columns, selection, selectionArgs, groupBy, having, orderBy) } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidDatabase.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidDatabase.kt index b6e5eb9e4..a926d3613 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidDatabase.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidDatabase.kt @@ -61,6 +61,16 @@ class AndroidDatabase internal constructor(val database: SQLiteDatabase) : Datab } } + override fun query(tableName: String, + columns: Array?, + selection: String?, + selectionArgs: Array?, + groupBy: String?, + having: String?, + orderBy: String?): FlowCursor = rethrowDBFlowException { + FlowCursor.from(database.query(tableName, columns, selection, selectionArgs, groupBy, having, orderBy)) + } + override fun delete(tableName: String, whereClause: String?, whereArgs: Array?): Int = rethrowDBFlowException { database.delete(tableName, whereClause, whereArgs) } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidSQLiteOpenHelper.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidSQLiteOpenHelper.kt index fa26b1b52..f027e38ef 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidSQLiteOpenHelper.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidSQLiteOpenHelper.kt @@ -10,7 +10,7 @@ import com.raizlabs.dbflow5.config.FlowManager /** * Description: Wraps around the [SQLiteOpenHelper] and provides extra features for use in this library. */ -class AndroidSQLiteOpenHelper( +open class AndroidSQLiteOpenHelper( databaseDefinition: DatabaseDefinition, listener: DatabaseHelperListener?) : SQLiteOpenHelper(FlowManager.context, @@ -104,7 +104,7 @@ class AndroidSQLiteOpenHelper( return androidDatabase!! } - override fun performRestoreFromBackup() {} + override fun performRestoreFromBackup() = Unit override val delegate: DatabaseHelperDelegate? get() = null @@ -132,7 +132,7 @@ class AndroidSQLiteOpenHelper( baseDatabaseHelper.onDowngrade(AndroidDatabase.from(db), oldVersion, newVersion) } - override fun closeDB() {} + override fun closeDB() = Unit } } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseWrapper.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseWrapper.kt index d30e3d089..4e8e7a7fc 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseWrapper.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseWrapper.kt @@ -32,5 +32,9 @@ interface DatabaseWrapper { values: ContentValues, sqLiteDatabaseAlgorithmInt: Int): Long + fun query(tableName: String, columns: Array?, selection: String?, + selectionArgs: Array?, groupBy: String?, + having: String?, orderBy: String?): FlowCursor + fun delete(tableName: String, whereClause: String?, whereArgs: Array?): Int } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/database/OpenHelper.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/database/OpenHelper.kt index 9688886a9..d822000d3 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/database/OpenHelper.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/database/OpenHelper.kt @@ -1,5 +1,8 @@ package com.raizlabs.dbflow5.database +import android.os.Build +import android.support.annotation.RequiresApi + /** * Description: Abstracts out the [DatabaseHelperDelegate] into the one used in this library. */ @@ -11,6 +14,9 @@ interface OpenHelper { val isDatabaseIntegrityOk: Boolean + @RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN) + fun setWriteAheadLoggingEnabled(enabled: Boolean) + fun performRestoreFromBackup() fun backupDB() diff --git a/settings.gradle b/settings.gradle index 523c79285..6e1a455aa 100644 --- a/settings.gradle +++ b/settings.gradle @@ -1,4 +1,4 @@ -include ':dbflow', ':dbflow-rx2', ':dbflow-coroutines', ':dbflow-android-support', +include ':dbflow', ':dbflow-rx2', ':dbflow-coroutines', ':dbflow-processor', ':dbflow-core', ':dbflow-sqlcipher', From 3aebf543fb52947c472fbec9cc3f1a02df438f8a Mon Sep 17 00:00:00 2001 From: fuzzagrosner Date: Tue, 5 Dec 2017 12:03:22 -0500 Subject: [PATCH 132/234] [db] fix compile. throw exception from SQLCipher that it is not supported for WriteAheadLogging. --- .../dbflow5/sqlcipher/SQLCipherOpenHelper.kt | 16 ++++++++++------ .../dbflow5/database/DatabaseHelperDelegate.kt | 7 ++----- .../com/raizlabs/dbflow5/database/OpenHelper.kt | 1 - 3 files changed, 12 insertions(+), 12 deletions(-) diff --git a/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherOpenHelper.kt b/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherOpenHelper.kt index 92d9119c4..85d47de07 100644 --- a/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherOpenHelper.kt +++ b/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherOpenHelper.kt @@ -86,6 +86,10 @@ abstract class SQLCipherOpenHelper(databaseDefinition: DatabaseDefinition, liste delegate.onOpen(SQLCipherDatabase.from(db)) } + override fun setWriteAheadLoggingEnabled(enabled: Boolean) { + throw UnsupportedOperationException("Not supported in SQLCipher") + } + override fun closeDB() { database cipherDatabase?.database?.close() @@ -94,10 +98,14 @@ abstract class SQLCipherOpenHelper(databaseDefinition: DatabaseDefinition, liste /** * Simple helper to manage backup. */ - private inner class BackupHelper(context: Context, name: String, version: Int, databaseDefinition: DatabaseDefinition) : SQLiteOpenHelper(context, name, null, version), OpenHelper { + private inner class BackupHelper(context: Context, + name: String, + version: Int, + databaseDefinition: DatabaseDefinition) + : SQLiteOpenHelper(context, name, null, version), OpenHelper { private var sqlCipherDatabase: SQLCipherDatabase? = null - private val baseDatabaseHelper: BaseDatabaseHelper + private val baseDatabaseHelper: BaseDatabaseHelper = BaseDatabaseHelper(databaseDefinition) override val database: DatabaseWrapper get() { @@ -113,10 +121,6 @@ abstract class SQLCipherOpenHelper(databaseDefinition: DatabaseDefinition, liste override val isDatabaseIntegrityOk: Boolean get() = false - init { - this.baseDatabaseHelper = BaseDatabaseHelper(databaseDefinition) - } - override fun performRestoreFromBackup() = Unit override fun backupDB() = Unit diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseHelperDelegate.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseHelperDelegate.kt index 02f9f6311..a17d3ceac 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseHelperDelegate.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseHelperDelegate.kt @@ -141,13 +141,10 @@ class DatabaseHelperDelegate( try { statement = databaseWrapper.compileStatement("PRAGMA quick_check(1)") val result = statement.simpleQueryForString() - if (!result!!.equals("ok", ignoreCase = true)) { + if (result == null || !result.equals("ok", ignoreCase = true)) { // integrity_checker failed on main or attached databases - FlowLog.log(FlowLog.Level.E, "PRAGMA integrity_check on " + - databaseDefinition.databaseName + " returned: " + result) - + FlowLog.log(FlowLog.Level.E, "PRAGMA integrity_check on ${databaseDefinition.databaseName} returned: $result") integrityOk = false - if (databaseDefinition.backupEnabled()) { integrityOk = restoreBackUp() } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/database/OpenHelper.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/database/OpenHelper.kt index d822000d3..80356a322 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/database/OpenHelper.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/database/OpenHelper.kt @@ -14,7 +14,6 @@ interface OpenHelper { val isDatabaseIntegrityOk: Boolean - @RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN) fun setWriteAheadLoggingEnabled(enabled: Boolean) fun performRestoreFromBackup() From d2b75f315063a8dd36761b021f61f2bf42183966 Mon Sep 17 00:00:00 2001 From: fuzzagrosner Date: Tue, 5 Dec 2017 13:14:50 -0500 Subject: [PATCH 133/234] [db] now db must extend DBFlowDatabase and be marked abstract. This allows direct usage of the class in our extension / db methods. --- .../raizlabs/dbflow5/coroutines/Coroutines.kt | 26 +++++----- .../raizlabs/dbflow5/processor/ClassNames.kt | 2 +- .../definition/DatabaseDefinition.kt | 37 +++++++++------ .../rx/transaction/TransactionObservable.kt | 6 +-- .../rx2/transaction/TransactionObservable.kt | 8 ++-- .../dbflow5/sqlcipher/SQLCipherOpenHelper.kt | 6 +-- .../dbflow5/DBFlowInstrumentedTestRule.kt | 10 ++-- .../dbflow5/ImmediateTransactionManager.kt | 4 +- .../java/com/raizlabs/dbflow5/AppDatabase.kt | 9 ++-- .../dbflow5/prepackaged/PrepackagedDB.kt | 7 ++- .../dbflow5/sqlcipher/CipherDatabase.kt | 8 ++-- .../dbflow5/sqlcipher/CipherTestObjects.kt | 4 +- .../raizlabs/dbflow5/test/DemoActivity.java | 3 +- .../com/raizlabs/dbflow5/DBFlowTestRule.kt | 4 +- .../dbflow5/ImmediateTransactionManager.kt | 4 +- .../java/com/raizlabs/dbflow5/TestDatabase.kt | 13 ++--- .../dbflow5/config/ConfigIntegrationTest.kt | 2 +- .../dbflow5/config/DatabaseConfigTest.kt | 10 ++-- .../provider/ContentProviderObjects.kt | 13 ++--- .../dbflow5/runtime/DirectNotifierTest.kt | 2 +- .../dbflow5/adapter/InstanceAdapter.kt | 4 +- .../raizlabs/dbflow5/adapter/ModelAdapter.kt | 4 +- .../dbflow5/adapter/ModelViewAdapter.kt | 4 +- .../dbflow5/adapter/QueryModelAdapter.kt | 4 +- .../dbflow5/adapter/RetrievalAdapter.kt | 4 +- ...atabaseDefinition.kt => DBFlowDatabase.kt} | 2 +- .../raizlabs/dbflow5/config/DatabaseConfig.kt | 18 +++---- .../raizlabs/dbflow5/config/DatabaseHolder.kt | 16 +++---- .../com/raizlabs/dbflow5/config/FlowConfig.kt | 2 +- .../raizlabs/dbflow5/config/FlowManager.kt | 47 ++++++++++--------- .../database/AndroidSQLiteOpenHelper.kt | 6 +-- .../dbflow5/database/BaseDatabaseHelper.kt | 4 +- .../database/DatabaseHelperDelegate.kt | 10 ++-- .../dbflow5/provider/BaseContentProvider.kt | 4 +- .../dbflow5/runtime/DBBatchSaveQueue.kt | 4 +- .../transaction/BaseTransactionManager.kt | 4 +- .../transaction/DefaultTransactionManager.kt | 6 +-- .../dbflow5/transaction/Transaction.kt | 10 ++-- usage2/Databases.md | 10 ++-- usage2/GettingStarted.md | 2 +- usage2/Observability.md | 2 +- usage2/SQLCipherSupport.md | 2 +- usage2/StoringData.md | 4 +- 43 files changed, 175 insertions(+), 176 deletions(-) rename dbflow/src/main/java/com/raizlabs/dbflow5/config/{DatabaseDefinition.kt => DBFlowDatabase.kt} (99%) diff --git a/dbflow-coroutines/src/main/java/com/raizlabs/dbflow5/coroutines/Coroutines.kt b/dbflow-coroutines/src/main/java/com/raizlabs/dbflow5/coroutines/Coroutines.kt index a56b49bc5..ecda57042 100644 --- a/dbflow-coroutines/src/main/java/com/raizlabs/dbflow5/coroutines/Coroutines.kt +++ b/dbflow-coroutines/src/main/java/com/raizlabs/dbflow5/coroutines/Coroutines.kt @@ -1,6 +1,6 @@ package com.raizlabs.dbflow5.coroutines -import com.raizlabs.dbflow5.config.DatabaseDefinition +import com.raizlabs.dbflow5.config.DBFlowDatabase import com.raizlabs.dbflow5.query.Queriable import com.raizlabs.dbflow5.structure.delete import com.raizlabs.dbflow5.structure.insert @@ -19,7 +19,7 @@ import kotlinx.coroutines.experimental.suspendCancellableCoroutine * Description: Puts this [Queriable] operation inside a coroutine. Inside the [queriableFunction] * execute the db operation. */ -inline suspend fun DatabaseDefinition.transact( +inline suspend fun DBFlowDatabase.transact( modelQueriable: Q, crossinline queriableFunction: Q.() -> R) = suspendCancellableCoroutine { continuation -> @@ -27,7 +27,7 @@ inline suspend fun DatabaseDefinition.transact( } inline fun constructCoroutine(continuation: CancellableContinuation, - databaseDefinition: DatabaseDefinition, + databaseDefinition: DBFlowDatabase, crossinline fn: () -> R) { val transaction = databaseDefinition.beginTransactionAsync { fn() } .success { _, result -> continuation.resume(result) } @@ -49,7 +49,7 @@ inline fun constructCoroutine(continuation: CancellableContinuation M.awaitSave(databaseDefinition: DatabaseDefinition) +inline suspend fun M.awaitSave(databaseDefinition: DBFlowDatabase) = suspendCancellableCoroutine { continuation -> constructCoroutine(continuation, databaseDefinition) { save(databaseDefinition) } } @@ -58,7 +58,7 @@ inline suspend fun M.awaitSave(databaseDefinition: DatabaseDef * Description: Puts a [Model] operation inside a coroutine. Inside the [queriableFunction] * execute the db operation. */ -inline suspend fun M.awaitInsert(databaseDefinition: DatabaseDefinition) +inline suspend fun M.awaitInsert(databaseDefinition: DBFlowDatabase) = suspendCancellableCoroutine { continuation -> constructCoroutine(continuation, databaseDefinition) { insert(databaseDefinition) } } @@ -67,7 +67,7 @@ inline suspend fun M.awaitInsert(databaseDefinition: DatabaseD * Description: Puts a [Model] operation inside a coroutine. Inside the [queriableFunction] * execute the db operation. */ -inline suspend fun M.awaitDelete(databaseDefinition: DatabaseDefinition) +inline suspend fun M.awaitDelete(databaseDefinition: DBFlowDatabase) = suspendCancellableCoroutine { continuation -> constructCoroutine(continuation, databaseDefinition) { delete(databaseDefinition) } } @@ -76,7 +76,7 @@ inline suspend fun M.awaitDelete(databaseDefinition: DatabaseD * Description: Puts a [Model] operation inside a coroutine. Inside the [queriableFunction] * execute the db operation. */ -inline suspend fun M.awaitUpdate(databaseDefinition: DatabaseDefinition) +inline suspend fun M.awaitUpdate(databaseDefinition: DBFlowDatabase) = suspendCancellableCoroutine { continuation -> constructCoroutine(continuation, databaseDefinition) { update(databaseDefinition) } } @@ -85,7 +85,7 @@ inline suspend fun M.awaitUpdate(databaseDefinition: DatabaseD * Description: Puts a [Model] operation inside a coroutine. Inside the [queriableFunction] * execute the db operation. */ -inline suspend fun M.awaitLoad(databaseDefinition: DatabaseDefinition) +inline suspend fun M.awaitLoad(databaseDefinition: DBFlowDatabase) = suspendCancellableCoroutine { continuation -> constructCoroutine(continuation, databaseDefinition) { load(databaseDefinition) } } @@ -93,7 +93,7 @@ inline suspend fun M.awaitLoad(databaseDefinition: DatabaseDef /** * Description: Puts the [Collection] inside a [FastStoreModelTransaction] coroutine. */ -inline suspend fun > M.awaitSave(databaseDefinition: DatabaseDefinition) +inline suspend fun > M.awaitSave(databaseDefinition: DBFlowDatabase) = suspendCancellableCoroutine { continuation -> constructFastCoroutine(continuation, databaseDefinition) { fastSave() } } @@ -101,7 +101,7 @@ inline suspend fun > M.awaitSave(data /** * Description: Puts the [Collection] inside a [FastStoreModelTransaction] coroutine. */ -inline suspend fun > M.awaitInsert(databaseDefinition: DatabaseDefinition) +inline suspend fun > M.awaitInsert(databaseDefinition: DBFlowDatabase) = suspendCancellableCoroutine { continuation -> constructFastCoroutine(continuation, databaseDefinition) { fastInsert() } } @@ -109,7 +109,7 @@ inline suspend fun > M.awaitInsert(da /** * Description: Puts the [Collection] inside a [FastStoreModelTransaction] coroutine. */ -inline suspend fun > M.awaitUpdate(databaseDefinition: DatabaseDefinition) +inline suspend fun > M.awaitUpdate(databaseDefinition: DBFlowDatabase) = suspendCancellableCoroutine { continuation -> constructFastCoroutine(continuation, databaseDefinition) { fastUpdate() } } @@ -117,14 +117,14 @@ inline suspend fun > M.awaitUpdate(da /** * Description: Puts the [Collection] inside a [FastStoreModelTransaction] coroutine. */ -inline suspend fun > M.awaitDelete(databaseDefinition: DatabaseDefinition) +inline suspend fun > M.awaitDelete(databaseDefinition: DBFlowDatabase) = suspendCancellableCoroutine { continuation -> constructFastCoroutine(continuation, databaseDefinition) { fastDelete() } } inline fun constructFastCoroutine(continuation: CancellableContinuation, - databaseDefinition: DatabaseDefinition, + databaseDefinition: DBFlowDatabase, crossinline fn: () -> FastStoreModelTransaction.Builder) { val transaction = databaseDefinition.beginTransactionAsync(fn().build()) .success { _, result -> continuation.resume(result) } diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/ClassNames.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/ClassNames.kt index 01771dda2..9d1e8be17 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/ClassNames.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/ClassNames.kt @@ -26,7 +26,7 @@ object ClassNames { val DATABASE_HOLDER = ClassName.get(CONFIG, "DatabaseHolder") val FLOW_MANAGER = ClassName.get(CONFIG, "FlowManager") - val BASE_DATABASE_DEFINITION_CLASSNAME = ClassName.get(CONFIG, "DatabaseDefinition") + val BASE_DATABASE_DEFINITION_CLASSNAME = ClassName.get(CONFIG, "DBFlowDatabase") val URI = ClassName.get("android.net", "Uri") val URI_MATCHER = ClassName.get("android.content", "UriMatcher") diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/DatabaseDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/DatabaseDefinition.kt index 0790b23ab..d51e64b66 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/DatabaseDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/DatabaseDefinition.kt @@ -17,6 +17,7 @@ import com.raizlabs.dbflow5.processor.ProcessorManager import com.raizlabs.dbflow5.processor.TableValidator import com.raizlabs.dbflow5.processor.utils.`override fun` import com.raizlabs.dbflow5.processor.utils.annotation +import com.raizlabs.dbflow5.processor.utils.isSubclass import com.squareup.javapoet.ClassName import com.squareup.javapoet.ParameterizedTypeName import com.squareup.javapoet.TypeName @@ -24,6 +25,7 @@ import com.squareup.javapoet.TypeSpec import com.squareup.javapoet.WildcardTypeName import java.util.regex.Pattern import javax.lang.model.element.Element +import javax.lang.model.element.Modifier /** * Description: Writes [Database] definitions, @@ -78,9 +80,16 @@ class DatabaseDefinition(manager: ProcessorManager, element: Element) : BaseDefi insertConflict = database.insertConflict updateConflict = database.updateConflict } + + if (!element.modifiers.contains(Modifier.ABSTRACT) + || element.modifiers.contains(Modifier.PRIVATE) + || !typeElement.isSubclass(manager.processingEnvironment, ClassNames.BASE_DATABASE_DEFINITION_CLASSNAME)) { + manager.logError("${elementClassName} must be a visible abstract class that " + + "extends ${ClassNames.BASE_DATABASE_DEFINITION_CLASSNAME}") + } } - override val extendsClass: TypeName? = ClassNames.BASE_DATABASE_DEFINITION_CLASSNAME + override val extendsClass: TypeName? = elementClassName override fun onWriteDefinition(typeBuilder: TypeSpec.Builder) { writeConstructor(typeBuilder) @@ -97,15 +106,15 @@ class DatabaseDefinition(manager: ProcessorManager, element: Element) : BaseDefi val map = hashMapOf() val tableValidator = TableValidator() manager.getTableDefinitions(it) - .filter { tableValidator.validate(ProcessorManager.manager, it) } - .forEach { it.elementClassName?.let { className -> map.put(className, it) } } + .filter { tableValidator.validate(ProcessorManager.manager, it) } + .forEach { it.elementClassName?.let { className -> map.put(className, it) } } manager.setTableDefinitions(map, it) val modelViewDefinitionMap = hashMapOf() val modelViewValidator = ModelViewValidator() manager.getModelViewDefinitions(it) - .filter { modelViewValidator.validate(ProcessorManager.manager, it) } - .forEach { it.elementClassName?.let { className -> modelViewDefinitionMap.put(className, it) } } + .filter { modelViewValidator.validate(ProcessorManager.manager, it) } + .forEach { it.elementClassName?.let { className -> modelViewDefinitionMap.put(className, it) } } manager.setModelViewDefinitions(modelViewDefinitionMap, it) } } @@ -149,14 +158,14 @@ class DatabaseDefinition(manager: ProcessorManager, element: Element) : BaseDefi val migrationDefinitionMap = manager.getMigrationsForDatabase(elementClassName) migrationDefinitionMap.keys - .sortedByDescending { it } - .forEach { version -> - migrationDefinitionMap[version] - ?.sortedBy { it.priority } - ?.forEach { migrationDefinition -> - statement("addMigration($version, new \$T${migrationDefinition.constructorName})", migrationDefinition.elementClassName) - } - } + .sortedByDescending { it } + .forEach { version -> + migrationDefinitionMap[version] + ?.sortedBy { it.priority } + ?.forEach { migrationDefinition -> + statement("addMigration($version, new \$T${migrationDefinition.constructorName})", migrationDefinition.elementClassName) + } + } } this } @@ -166,7 +175,7 @@ class DatabaseDefinition(manager: ProcessorManager, element: Element) : BaseDefi private fun writeGetters(typeBuilder: TypeSpec.Builder) { typeBuilder.apply { `override fun`(ParameterizedTypeName.get(ClassName.get(Class::class.java), WildcardTypeName.subtypeOf(Any::class.java)), - "getAssociatedDatabaseClassFile") { + "getAssociatedDatabaseClassFile") { modifiers(public, final) `return`("\$T.class", elementTypeName) } diff --git a/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/transaction/TransactionObservable.kt b/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/transaction/TransactionObservable.kt index 7a790aeec..02b33a7d9 100644 --- a/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/transaction/TransactionObservable.kt +++ b/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/transaction/TransactionObservable.kt @@ -2,7 +2,7 @@ package com.raizlabs.dbflow5.rx.transaction -import com.raizlabs.dbflow5.config.DatabaseDefinition +import com.raizlabs.dbflow5.config.DBFlowDatabase import com.raizlabs.dbflow5.transaction.ITransaction import rx.Observable import rx.Single @@ -10,11 +10,11 @@ import rx.Single /** * Description: Returns a [Maybe] that executes the [transaction] when called. */ -fun DatabaseDefinition.beginSingle(transaction: ITransaction) = +fun DBFlowDatabase.beginSingle(transaction: ITransaction) = Single.fromCallable { transaction.execute(this) } /** * Description: Returns a [Observable] that executes the [transaction] when called. */ -fun DatabaseDefinition.beginObservable(transaction: ITransaction) = +fun DBFlowDatabase.beginObservable(transaction: ITransaction) = Observable.fromCallable { transaction.execute(this) } diff --git a/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/transaction/TransactionObservable.kt b/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/transaction/TransactionObservable.kt index dc6c92bc7..d898cc104 100644 --- a/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/transaction/TransactionObservable.kt +++ b/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/transaction/TransactionObservable.kt @@ -2,7 +2,7 @@ package com.raizlabs.dbflow5.rx2.transaction -import com.raizlabs.dbflow5.config.DatabaseDefinition +import com.raizlabs.dbflow5.config.DBFlowDatabase import com.raizlabs.dbflow5.transaction.ITransaction import io.reactivex.Flowable import io.reactivex.Maybe @@ -11,17 +11,17 @@ import io.reactivex.Observable /** * Description: Returns a [Maybe] that executes the [transaction] when called. */ -fun DatabaseDefinition.beginMaybe(transaction: ITransaction) = +fun DBFlowDatabase.beginMaybe(transaction: ITransaction) = Maybe.fromCallable { transaction.execute(this) } /** * Description: Returns a [Observable] that executes the [transaction] when called. */ -fun DatabaseDefinition.beginObservable(transaction: ITransaction) = +fun DBFlowDatabase.beginObservable(transaction: ITransaction) = Observable.fromCallable { transaction.execute(this) } /** * Description: Returns a [Flowable] that executes the [transaction] when called. */ -fun DatabaseDefinition.beginFlowable(transaction: ITransaction) = +fun DBFlowDatabase.beginFlowable(transaction: ITransaction) = Flowable.fromCallable { transaction.execute(this) } \ No newline at end of file diff --git a/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherOpenHelper.kt b/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherOpenHelper.kt index 85d47de07..57e558931 100644 --- a/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherOpenHelper.kt +++ b/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherOpenHelper.kt @@ -3,7 +3,7 @@ package com.raizlabs.dbflow5.sqlcipher import android.content.Context import com.raizlabs.dbflow5.config.DatabaseConfig -import com.raizlabs.dbflow5.config.DatabaseDefinition +import com.raizlabs.dbflow5.config.DBFlowDatabase import com.raizlabs.dbflow5.config.FlowManager import com.raizlabs.dbflow5.database.BaseDatabaseHelper import com.raizlabs.dbflow5.database.DatabaseHelperDelegate @@ -18,7 +18,7 @@ import net.sqlcipher.database.SQLiteOpenHelper * Description: The replacement [OpenHelper] for SQLCipher. Specify a subclass of this is [DatabaseConfig.getDatabaseClass] * of your database to get it to work with specifying the secret you use for the databaseForTable. */ -abstract class SQLCipherOpenHelper(databaseDefinition: DatabaseDefinition, listener: DatabaseHelperListener?) +abstract class SQLCipherOpenHelper(databaseDefinition: DBFlowDatabase, listener: DatabaseHelperListener?) : SQLiteOpenHelper(FlowManager.context, if (databaseDefinition.isInMemory) null else databaseDefinition.databaseFileName, null, databaseDefinition.databaseVersion), OpenHelper { @@ -101,7 +101,7 @@ abstract class SQLCipherOpenHelper(databaseDefinition: DatabaseDefinition, liste private inner class BackupHelper(context: Context, name: String, version: Int, - databaseDefinition: DatabaseDefinition) + databaseDefinition: DBFlowDatabase) : SQLiteOpenHelper(context, name, null, version), OpenHelper { private var sqlCipherDatabase: SQLCipherDatabase? = null diff --git a/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/DBFlowInstrumentedTestRule.kt b/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/DBFlowInstrumentedTestRule.kt index 90306fa0a..b0db12566 100644 --- a/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/DBFlowInstrumentedTestRule.kt +++ b/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/DBFlowInstrumentedTestRule.kt @@ -1,7 +1,7 @@ package com.raizlabs.dbflow5 import com.raizlabs.dbflow5.config.DatabaseConfig -import com.raizlabs.dbflow5.config.DatabaseDefinition +import com.raizlabs.dbflow5.config.DBFlowDatabase import com.raizlabs.dbflow5.config.FlowConfig import com.raizlabs.dbflow5.config.FlowManager import com.raizlabs.dbflow5.prepackaged.PrepackagedDB @@ -19,16 +19,16 @@ class DBFlowInstrumentedTestRule : TestRule { @Throws(Throwable::class) override fun evaluate() { FlowManager.init(FlowConfig.Builder(DemoApp.context) - .addDatabaseConfig(DatabaseConfig( + .database(DatabaseConfig( databaseClass = AppDatabase::class.java, modelNotifier = ContentResolverNotifier("com.grosner.content"), - transactionManagerCreator = { databaseDefinition: DatabaseDefinition -> + transactionManagerCreator = { databaseDefinition: DBFlowDatabase -> ImmediateTransactionManager(databaseDefinition) })) - .addDatabaseConfig(DatabaseConfig( + .database(DatabaseConfig( databaseClass = PrepackagedDB::class.java, databaseName = "prepackaged")) - .addDatabaseConfig(DatabaseConfig( + .database(DatabaseConfig( databaseClass = CipherDatabase::class.java)) .build()) try { diff --git a/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/ImmediateTransactionManager.kt b/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/ImmediateTransactionManager.kt index 4b0cbcc9a..76833c12d 100644 --- a/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/ImmediateTransactionManager.kt +++ b/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/ImmediateTransactionManager.kt @@ -1,6 +1,6 @@ package com.raizlabs.dbflow5 -import com.raizlabs.dbflow5.config.DatabaseDefinition +import com.raizlabs.dbflow5.config.DBFlowDatabase import com.raizlabs.dbflow5.transaction.BaseTransactionManager import com.raizlabs.dbflow5.transaction.ITransactionQueue import com.raizlabs.dbflow5.transaction.Transaction @@ -8,7 +8,7 @@ import com.raizlabs.dbflow5.transaction.Transaction /** * Description: Executes all transactions on same thread for testing. */ -class ImmediateTransactionManager(databaseDefinition: DatabaseDefinition) +class ImmediateTransactionManager(databaseDefinition: DBFlowDatabase) : BaseTransactionManager(ImmediateTransactionQueue(), databaseDefinition) diff --git a/dbflow-tests/src/main/java/com/raizlabs/dbflow5/AppDatabase.kt b/dbflow-tests/src/main/java/com/raizlabs/dbflow5/AppDatabase.kt index 055038824..7770d693e 100644 --- a/dbflow-tests/src/main/java/com/raizlabs/dbflow5/AppDatabase.kt +++ b/dbflow-tests/src/main/java/com/raizlabs/dbflow5/AppDatabase.kt @@ -1,10 +1,7 @@ package com.raizlabs.dbflow5 import com.raizlabs.dbflow5.annotation.Database +import com.raizlabs.dbflow5.config.DBFlowDatabase -@Database(version = AppDatabase.VERSION) -object AppDatabase { - - const val VERSION = 1 - -} \ No newline at end of file +@Database(version = 1) +abstract class AppDatabase : DBFlowDatabase() \ No newline at end of file diff --git a/dbflow-tests/src/main/java/com/raizlabs/dbflow5/prepackaged/PrepackagedDB.kt b/dbflow-tests/src/main/java/com/raizlabs/dbflow5/prepackaged/PrepackagedDB.kt index fbc0b9c5f..45e7f03fa 100644 --- a/dbflow-tests/src/main/java/com/raizlabs/dbflow5/prepackaged/PrepackagedDB.kt +++ b/dbflow-tests/src/main/java/com/raizlabs/dbflow5/prepackaged/PrepackagedDB.kt @@ -4,12 +4,11 @@ import com.raizlabs.dbflow5.annotation.Column import com.raizlabs.dbflow5.annotation.Database import com.raizlabs.dbflow5.annotation.PrimaryKey import com.raizlabs.dbflow5.annotation.Table +import com.raizlabs.dbflow5.config.DBFlowDatabase import com.raizlabs.dbflow5.structure.BaseModel -@Database(version = PrepackagedDB.VERSION) -object PrepackagedDB { - const val VERSION = 1 -} +@Database(version = 1) +abstract class PrepackagedDB : DBFlowDatabase() @Table(database = PrepackagedDB::class, allFields = true) class Dog : BaseModel() { diff --git a/dbflow-tests/src/main/java/com/raizlabs/dbflow5/sqlcipher/CipherDatabase.kt b/dbflow-tests/src/main/java/com/raizlabs/dbflow5/sqlcipher/CipherDatabase.kt index 4bf3cb5a0..8bf9d547b 100644 --- a/dbflow-tests/src/main/java/com/raizlabs/dbflow5/sqlcipher/CipherDatabase.kt +++ b/dbflow-tests/src/main/java/com/raizlabs/dbflow5/sqlcipher/CipherDatabase.kt @@ -1,9 +1,7 @@ package com.raizlabs.dbflow5.sqlcipher import com.raizlabs.dbflow5.annotation.Database +import com.raizlabs.dbflow5.config.DBFlowDatabase -@Database(version = CipherDatabase.VERSION) -object CipherDatabase { - - const val VERSION = 1 -} \ No newline at end of file +@Database(version = 1) +abstract class CipherDatabase : DBFlowDatabase() \ No newline at end of file diff --git a/dbflow-tests/src/main/java/com/raizlabs/dbflow5/sqlcipher/CipherTestObjects.kt b/dbflow-tests/src/main/java/com/raizlabs/dbflow5/sqlcipher/CipherTestObjects.kt index fa3ad71ad..aa919cf83 100644 --- a/dbflow-tests/src/main/java/com/raizlabs/dbflow5/sqlcipher/CipherTestObjects.kt +++ b/dbflow-tests/src/main/java/com/raizlabs/dbflow5/sqlcipher/CipherTestObjects.kt @@ -3,11 +3,11 @@ package com.raizlabs.dbflow5.sqlcipher import com.raizlabs.dbflow5.annotation.Column import com.raizlabs.dbflow5.annotation.PrimaryKey import com.raizlabs.dbflow5.annotation.Table -import com.raizlabs.dbflow5.config.DatabaseDefinition +import com.raizlabs.dbflow5.config.DBFlowDatabase import com.raizlabs.dbflow5.database.DatabaseHelperListener import com.raizlabs.dbflow5.structure.BaseModel -class SQLCipherOpenHelperImpl(databaseDefinition: DatabaseDefinition, helperListener: DatabaseHelperListener?) +class SQLCipherOpenHelperImpl(databaseDefinition: DBFlowDatabase, helperListener: DatabaseHelperListener?) : SQLCipherOpenHelper(databaseDefinition, helperListener) { override val cipherSecret get() = "dbflow-rules" } diff --git a/dbflow-tests/src/main/java/com/raizlabs/dbflow5/test/DemoActivity.java b/dbflow-tests/src/main/java/com/raizlabs/dbflow5/test/DemoActivity.java index 4c17e0342..f2bbb30c0 100644 --- a/dbflow-tests/src/main/java/com/raizlabs/dbflow5/test/DemoActivity.java +++ b/dbflow-tests/src/main/java/com/raizlabs/dbflow5/test/DemoActivity.java @@ -8,7 +8,6 @@ import com.raizlabs.dbflow5.config.DatabaseConfig; import com.raizlabs.dbflow5.config.FlowConfig; import com.raizlabs.dbflow5.config.FlowManager; -import com.raizlabs.dbflow5.test.R; import com.raizlabs.dbflow5.prepackaged.PrepackagedDB; @@ -20,7 +19,7 @@ protected void onCreate(Bundle savedInstanceState) { setContentView(R.layout.activity_demo); FlowManager.init(new FlowConfig.Builder(getApplicationContext()) - .addDatabaseConfig( + .database( DatabaseConfig.builder(PrepackagedDB.class) .databaseName("prepackaged") .build()) diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/DBFlowTestRule.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/DBFlowTestRule.kt index 966d48615..67a9dcaf5 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/DBFlowTestRule.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/DBFlowTestRule.kt @@ -17,10 +17,10 @@ class DBFlowTestRule : TestRule { @Throws(Throwable::class) override fun evaluate() { FlowManager.init(FlowConfig.Builder(RuntimeEnvironment.application) - .addDatabaseConfig(DatabaseConfig.Builder(TestDatabase::class) + .database(DatabaseConfig.Builder(TestDatabase::class) .transactionManagerCreator(::ImmediateTransactionManager2) .build()) - .addDatabaseConfig(DatabaseConfig.builder(ContentDatabase::class) + .database(DatabaseConfig.builder(ContentDatabase::class) .databaseName("content") .build()) .build()) diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/ImmediateTransactionManager.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/ImmediateTransactionManager.kt index d0795d9b4..4c75ba653 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/ImmediateTransactionManager.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/ImmediateTransactionManager.kt @@ -1,6 +1,6 @@ package com.raizlabs.dbflow5 -import com.raizlabs.dbflow5.config.DatabaseDefinition +import com.raizlabs.dbflow5.config.DBFlowDatabase import com.raizlabs.dbflow5.transaction.BaseTransactionManager import com.raizlabs.dbflow5.transaction.ITransactionQueue import com.raizlabs.dbflow5.transaction.Transaction @@ -8,7 +8,7 @@ import com.raizlabs.dbflow5.transaction.Transaction /** * Description: Executes all transactions on same thread for testing. */ -class ImmediateTransactionManager2(databaseDefinition: DatabaseDefinition) +class ImmediateTransactionManager2(databaseDefinition: DBFlowDatabase) : BaseTransactionManager(ImmediateTransactionQueue2(), databaseDefinition) diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/TestDatabase.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/TestDatabase.kt index 573315a9c..b07cc5a55 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/TestDatabase.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/TestDatabase.kt @@ -2,22 +2,17 @@ package com.raizlabs.dbflow5 import com.raizlabs.dbflow5.annotation.Database import com.raizlabs.dbflow5.annotation.Migration +import com.raizlabs.dbflow5.config.DBFlowDatabase import com.raizlabs.dbflow5.migration.UpdateTableMigration import com.raizlabs.dbflow5.models.SimpleModel /** * Description: */ -@Database(version = TestDatabase.VERSION) -object TestDatabase { - - const val VERSION = 1 +@Database(version = 1) +abstract class TestDatabase : DBFlowDatabase() { @Migration(version = 1, database = TestDatabase::class) - class TestMigration : UpdateTableMigration(SimpleModel::class.java) { - override fun onPostMigrate() { - super.onPostMigrate() - } - } + class TestMigration : UpdateTableMigration(SimpleModel::class.java) } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/config/ConfigIntegrationTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/config/ConfigIntegrationTest.kt index afe3832aa..c6564c4b4 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/config/ConfigIntegrationTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/config/ConfigIntegrationTest.kt @@ -46,7 +46,7 @@ class ConfigIntegrationTest : BaseUnitTest() { val modelSaver = ModelSaver() FlowManager.init(builder - .addDatabaseConfig(DatabaseConfig.Builder(TestDatabase::class.java) + .database(DatabaseConfig.Builder(TestDatabase::class.java) .addTableConfig(TableConfig.Builder(SimpleModel::class.java) .singleModelLoader(singleModelLoader) .listModelLoader(customListModelLoader) diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/config/DatabaseConfigTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/config/DatabaseConfigTest.kt index c138b0fff..a119bdcd7 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/config/DatabaseConfigTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/config/DatabaseConfigTest.kt @@ -31,17 +31,17 @@ class DatabaseConfigTest : BaseUnitTest() { val helperListener = mock() val customOpenHelper = mock() - val openHelperCreator: ((DatabaseDefinition, DatabaseHelperListener?) -> OpenHelper) = { _, _ -> + val openHelperCreator: ((DBFlowDatabase, DatabaseHelperListener?) -> OpenHelper) = { _, _ -> customOpenHelper } var testTransactionManager: TestTransactionManager? = null - val managerCreator: (DatabaseDefinition) -> BaseTransactionManager = { databaseDefinition -> + val managerCreator: (DBFlowDatabase) -> BaseTransactionManager = { databaseDefinition -> testTransactionManager = TestTransactionManager(databaseDefinition) testTransactionManager!! } FlowManager.init(builder - .addDatabaseConfig(DatabaseConfig.Builder(TestDatabase::class.java) + .database(DatabaseConfig.Builder(TestDatabase::class.java) .databaseName("Test") .helperListener(helperListener) .openHelper(openHelperCreator) @@ -70,7 +70,7 @@ class DatabaseConfigTest : BaseUnitTest() { @Test fun test_EmptyName() { FlowManager.init(builder - .addDatabaseConfig(DatabaseConfig.Builder(TestDatabase::class.java) + .database(DatabaseConfig.Builder(TestDatabase::class.java) .databaseName("Test") .extensionName("") .build()) @@ -83,5 +83,5 @@ class DatabaseConfigTest : BaseUnitTest() { } -class TestTransactionManager(databaseDefinition: DatabaseDefinition) +class TestTransactionManager(databaseDefinition: DBFlowDatabase) : BaseTransactionManager(mock(), databaseDefinition) \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/provider/ContentProviderObjects.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/provider/ContentProviderObjects.kt index dfdcebcbf..f0a5916ad 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/provider/ContentProviderObjects.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/provider/ContentProviderObjects.kt @@ -10,6 +10,7 @@ import com.raizlabs.dbflow5.annotation.provider.ContentProvider import com.raizlabs.dbflow5.annotation.provider.ContentType import com.raizlabs.dbflow5.annotation.provider.ContentUri import com.raizlabs.dbflow5.annotation.provider.TableEndpoint +import com.raizlabs.dbflow5.config.DBFlowDatabase /** @@ -18,14 +19,14 @@ import com.raizlabs.dbflow5.annotation.provider.TableEndpoint @ContentProvider(authority = ContentDatabase.AUTHORITY, database = ContentDatabase::class, baseContentUri = ContentDatabase.BASE_CONTENT_URI) @Database(version = ContentDatabase.VERSION) -object ContentDatabase { - - const val BASE_CONTENT_URI = "content://" - - const val AUTHORITY = "com.raizlabs.android.content.test.ContentDatabase" +abstract class ContentDatabase : DBFlowDatabase() { + companion object { + const val BASE_CONTENT_URI = "content://" - const val VERSION = 1 + const val AUTHORITY = "com.raizlabs.android.content.test.ContentDatabase" + const val VERSION = 1 + } } @TableEndpoint(name = ContentProviderModel.NAME, contentProvider = ContentDatabase::class) diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/runtime/DirectNotifierTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/runtime/DirectNotifierTest.kt index cf141ad96..88c6d6a99 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/runtime/DirectNotifierTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/runtime/DirectNotifierTest.kt @@ -41,7 +41,7 @@ class DirectNotifierTest { @Before fun setupTest() { FlowManager.init(FlowConfig.Builder(context) - .addDatabaseConfig(DatabaseConfig.Builder(TestDatabase::class.java) + .database(DatabaseConfig.Builder(TestDatabase::class.java) .transactionManagerCreator(::ImmediateTransactionManager2) .build()).build()) } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/InstanceAdapter.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/InstanceAdapter.kt index 3a113f5d3..bc4e2226a 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/InstanceAdapter.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/InstanceAdapter.kt @@ -1,11 +1,11 @@ package com.raizlabs.dbflow5.adapter -import com.raizlabs.dbflow5.config.DatabaseDefinition +import com.raizlabs.dbflow5.config.DBFlowDatabase /** * Description: Provides a [.newInstance] method to a [RetrievalAdapter] */ -abstract class InstanceAdapter(databaseDefinition: DatabaseDefinition) +abstract class InstanceAdapter(databaseDefinition: DBFlowDatabase) : RetrievalAdapter(databaseDefinition) { /** diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/ModelAdapter.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/ModelAdapter.kt index 45eb0593f..fe26a8ef9 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/ModelAdapter.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/ModelAdapter.kt @@ -7,7 +7,7 @@ import com.raizlabs.dbflow5.annotation.ConflictAction import com.raizlabs.dbflow5.annotation.ForeignKey import com.raizlabs.dbflow5.annotation.PrimaryKey import com.raizlabs.dbflow5.annotation.Table -import com.raizlabs.dbflow5.config.DatabaseDefinition +import com.raizlabs.dbflow5.config.DBFlowDatabase import com.raizlabs.dbflow5.database.DatabaseStatement import com.raizlabs.dbflow5.database.DatabaseWrapper import com.raizlabs.dbflow5.query.property.IProperty @@ -17,7 +17,7 @@ import com.raizlabs.dbflow5.structure.InvalidDBConfiguration /** * Description: Used for generated classes from the combination of [Table] and [Model]. */ -abstract class ModelAdapter(databaseDefinition: DatabaseDefinition) +abstract class ModelAdapter(databaseDefinition: DBFlowDatabase) : InstanceAdapter(databaseDefinition), InternalAdapter { private var insertStatement: DatabaseStatement? = null diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/ModelViewAdapter.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/ModelViewAdapter.kt index 8190aed06..555c4c8f4 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/ModelViewAdapter.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/ModelViewAdapter.kt @@ -1,12 +1,12 @@ package com.raizlabs.dbflow5.adapter -import com.raizlabs.dbflow5.config.DatabaseDefinition +import com.raizlabs.dbflow5.config.DBFlowDatabase import com.raizlabs.dbflow5.database.DatabaseWrapper /** * Description: The base class for a [T] adapter that defines how it interacts with the DB. */ -abstract class ModelViewAdapter(databaseDefinition: DatabaseDefinition) +abstract class ModelViewAdapter(databaseDefinition: DBFlowDatabase) : InstanceAdapter(databaseDefinition) { /** diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/QueryModelAdapter.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/QueryModelAdapter.kt index c86988c79..e3e186139 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/QueryModelAdapter.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/QueryModelAdapter.kt @@ -1,7 +1,7 @@ package com.raizlabs.dbflow5.adapter import com.raizlabs.dbflow5.annotation.QueryModel -import com.raizlabs.dbflow5.config.DatabaseDefinition +import com.raizlabs.dbflow5.config.DBFlowDatabase import com.raizlabs.dbflow5.database.DatabaseWrapper import com.raizlabs.dbflow5.query.OperatorGroup @@ -9,7 +9,7 @@ import com.raizlabs.dbflow5.query.OperatorGroup * Description: The baseclass for adapters to [QueryModel] that defines how it interacts with the DB. The * where query is not defined here, rather its determined by the query used. */ -abstract class QueryModelAdapter(databaseDefinition: DatabaseDefinition) +abstract class QueryModelAdapter(databaseDefinition: DBFlowDatabase) : InstanceAdapter(databaseDefinition) { override fun getPrimaryConditionClause(model: T): OperatorGroup { diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/RetrievalAdapter.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/RetrievalAdapter.kt index 370eb2005..81d082717 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/RetrievalAdapter.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/RetrievalAdapter.kt @@ -2,7 +2,7 @@ package com.raizlabs.dbflow5.adapter import com.raizlabs.dbflow5.adapter.queriable.ListModelLoader import com.raizlabs.dbflow5.adapter.queriable.SingleModelLoader -import com.raizlabs.dbflow5.config.DatabaseDefinition +import com.raizlabs.dbflow5.config.DBFlowDatabase import com.raizlabs.dbflow5.config.FlowManager import com.raizlabs.dbflow5.config.TableConfig import com.raizlabs.dbflow5.database.DatabaseWrapper @@ -14,7 +14,7 @@ import com.raizlabs.dbflow5.query.select * Description: Provides a base retrieval class for all [Model] backed * adapters. */ -abstract class RetrievalAdapter(databaseDefinition: DatabaseDefinition) { +abstract class RetrievalAdapter(databaseDefinition: DBFlowDatabase) { /** * Overrides the default implementation and allows you to provide your own implementation. Defines diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseDefinition.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/config/DBFlowDatabase.kt similarity index 99% rename from dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseDefinition.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/config/DBFlowDatabase.kt index e4b17ef41..e2e309ccf 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseDefinition.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/config/DBFlowDatabase.kt @@ -31,7 +31,7 @@ import com.raizlabs.dbflow5.transaction.Transaction * Description: The main interface that all Database implementations extend from. This is for internal usage only * as it will be generated for every [Database]. */ -abstract class DatabaseDefinition : DatabaseWrapper { +abstract class DBFlowDatabase : DatabaseWrapper { private val migrationMap = hashMapOf>() diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseConfig.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseConfig.kt index e78dad64e..908f6c680 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseConfig.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseConfig.kt @@ -12,8 +12,8 @@ import kotlin.reflect.KClass */ class DatabaseConfig( val databaseClass: Class<*>, - val openHelperCreator: ((DatabaseDefinition, DatabaseHelperListener?) -> OpenHelper)? = null, - val transactionManagerCreator: ((DatabaseDefinition) -> BaseTransactionManager)? = null, + val openHelperCreator: ((DBFlowDatabase, DatabaseHelperListener?) -> OpenHelper)? = null, + val transactionManagerCreator: ((DBFlowDatabase) -> BaseTransactionManager)? = null, val helperListener: DatabaseHelperListener? = null, val tableConfigMap: Map, TableConfig<*>> = mapOf(), val modelNotifier: ModelNotifier? = null, @@ -24,12 +24,12 @@ class DatabaseConfig( interface OpenHelperCreator { - fun createHelper(databaseDefinition: DatabaseDefinition, helperListener: DatabaseHelperListener?): OpenHelper + fun createHelper(databaseDefinition: DBFlowDatabase, helperListener: DatabaseHelperListener?): OpenHelper } interface TransactionManagerCreator { - fun createManager(databaseDefinition: DatabaseDefinition): BaseTransactionManager + fun createManager(databaseDefinition: DBFlowDatabase): BaseTransactionManager } internal constructor(builder: Builder) : this( @@ -57,8 +57,8 @@ class DatabaseConfig( */ class Builder(internal val databaseClass: Class<*>) { - internal var openHelperCreator: ((DatabaseDefinition, DatabaseHelperListener?) -> OpenHelper)? = null - internal var transactionManagerCreator: ((DatabaseDefinition) -> BaseTransactionManager)? = null + internal var openHelperCreator: ((DBFlowDatabase, DatabaseHelperListener?) -> OpenHelper)? = null + internal var transactionManagerCreator: ((DBFlowDatabase) -> BaseTransactionManager)? = null internal var helperListener: DatabaseHelperListener? = null internal val tableConfigMap: MutableMap, TableConfig<*>> = hashMapOf() internal var modelNotifier: ModelNotifier? = null @@ -71,16 +71,16 @@ class DatabaseConfig( fun transactionManagerCreator(transactionManager: TransactionManagerCreator) = transactionManagerCreator { databaseDefinition -> transactionManager.createManager(databaseDefinition) } - fun transactionManagerCreator(creator: (DatabaseDefinition) -> BaseTransactionManager) = apply { + fun transactionManagerCreator(creator: (DBFlowDatabase) -> BaseTransactionManager) = apply { this.transactionManagerCreator = creator } /** - * Overrides the default [OpenHelper] for a [DatabaseDefinition]. + * Overrides the default [OpenHelper] for a [DBFlowDatabase]. * * @param openHelper The openhelper to use. */ - fun openHelper(openHelper: (DatabaseDefinition, DatabaseHelperListener?) -> OpenHelper) = apply { + fun openHelper(openHelper: (DBFlowDatabase, DatabaseHelperListener?) -> OpenHelper) = apply { openHelperCreator = openHelper } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseHolder.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseHolder.kt index 9f9b7ea17..7d9328c1b 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseHolder.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseHolder.kt @@ -8,14 +8,14 @@ import com.raizlabs.dbflow5.converter.TypeConverter */ abstract class DatabaseHolder { - val databaseDefinitionMap: MutableMap, DatabaseDefinition> = hashMapOf() - val databaseNameMap: MutableMap = hashMapOf() - val databaseClassLookupMap: MutableMap, DatabaseDefinition> = hashMapOf() + val databaseDefinitionMap: MutableMap, DBFlowDatabase> = hashMapOf() + val databaseNameMap: MutableMap = hashMapOf() + val databaseClassLookupMap: MutableMap, DBFlowDatabase> = hashMapOf() @JvmField val typeConverters: MutableMap, TypeConverter<*, *>> = hashMapOf() - val databaseDefinitions: List + val databaseDefinitions: List get() = databaseNameMap.values.toList() /** @@ -28,16 +28,16 @@ abstract class DatabaseHolder { * @param table The model class * @return The database that the table belongs in */ - fun getDatabaseForTable(table: Class<*>): DatabaseDefinition? = databaseDefinitionMap[table] + fun getDatabaseForTable(table: Class<*>): DBFlowDatabase? = databaseDefinitionMap[table] - fun getDatabase(databaseClass: Class<*>): DatabaseDefinition? = + fun getDatabase(databaseClass: Class<*>): DBFlowDatabase? = databaseClassLookupMap[databaseClass] /** * @param databaseName The name of the database to retrieve * @return The database that has the specified name */ - fun getDatabase(databaseName: String): DatabaseDefinition? = databaseNameMap[databaseName] + fun getDatabase(databaseName: String): DBFlowDatabase? = databaseNameMap[databaseName] /** * Helper method used to store a database for the specified table. @@ -45,7 +45,7 @@ abstract class DatabaseHolder { * @param table The model table * @param databaseDefinition The database definition */ - fun putDatabaseForTable(table: Class<*>, databaseDefinition: DatabaseDefinition) { + fun putDatabaseForTable(table: Class<*>, databaseDefinition: DBFlowDatabase) { databaseDefinitionMap.put(table, databaseDefinition) databaseNameMap.put(databaseDefinition.databaseName, databaseDefinition) databaseClassLookupMap.put(databaseDefinition.associatedDatabaseClassFile, databaseDefinition) diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowConfig.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowConfig.kt index 520770b41..ff23130dc 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowConfig.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowConfig.kt @@ -32,7 +32,7 @@ class FlowConfig(val context: Context, databaseHolders.add(databaseHolderClass) } - fun addDatabaseConfig(databaseConfig: DatabaseConfig) = apply { + fun database(databaseConfig: DatabaseConfig) = apply { databaseConfigMap.put(databaseConfig.databaseClass, databaseConfig) } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowManager.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowManager.kt index 6490d31e3..749a2cb55 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowManager.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowManager.kt @@ -100,7 +100,7 @@ object FlowManager { * @return The associated table class for the specified name. */ @JvmStatic - fun getTableClassForName(databaseClass: Class<*>, tableName: String): Class<*> { + fun getTableClassForName(databaseClass: Class, tableName: String): Class<*> { val databaseDefinition = getDatabase(databaseClass) return databaseDefinition.getModelClassForName(tableName) ?: databaseDefinition.getModelClassForName(tableName.quote()) @@ -110,33 +110,34 @@ object FlowManager { /** * @param table The table to lookup the database for. - * @return the corresponding [DatabaseDefinition] for the specified model + * @return the corresponding [DBFlowDatabase] for the specified model */ @JvmStatic - fun getDatabaseForTable(table: Class<*>): DatabaseDefinition { + fun getDatabaseForTable(table: Class<*>): DBFlowDatabase { checkDatabaseHolder() return globalDatabaseHolder.getDatabaseForTable(table) ?: throw InvalidDBConfiguration("Model object: ${table.name} is not registered with a Database." + " Did you forget an annotation?") } + @Suppress("UNCHECKED_CAST") @JvmStatic - fun getDatabase(databaseClass: Class<*>): DatabaseDefinition { + fun getDatabase(databaseClass: Class): T { checkDatabaseHolder() - return globalDatabaseHolder.getDatabase(databaseClass) ?: + return globalDatabaseHolder.getDatabase(databaseClass) as? T ?: throw InvalidDBConfiguration("Database: ${databaseClass.name} is not a registered Database. " + "Did you forget the @Database annotation?") } @JvmStatic - fun getDatabaseName(database: Class<*>): String = getDatabase(database).databaseName + fun getDatabaseName(database: Class): String = getDatabase(database).databaseName /** * @param databaseName The name of the database. Will throw an exception if the databaseForTable doesn't exist. - * @return the [DatabaseDefinition] for the specified database + * @return the [DBFlowDatabase] for the specified database */ @JvmStatic - fun getDatabase(databaseName: String): DatabaseDefinition { + fun getDatabase(databaseName: String): DBFlowDatabase { checkDatabaseHolder() return globalDatabaseHolder.getDatabase(databaseName) ?: throw InvalidDBConfiguration("The specified database $databaseName was not found. " + @@ -144,21 +145,21 @@ object FlowManager { } @Deprecated(replaceWith = ReplaceWith("FlowManager.getDatabaseForTable(table)"), - message = "This method is no longer needed. DatabaseDefinition now delegates to the DatabaseWrapper.") + message = "This method is no longer needed. DBFlowDatabase now delegates to the DatabaseWrapper.") @JvmStatic fun getWritableDatabaseForTable(table: Class<*>): DatabaseWrapper = getDatabaseForTable(table).writableDatabase @Deprecated(replaceWith = ReplaceWith("FlowManager.getDatabase(databaseName)"), - message = "This method is no longer needed. DatabaseDefinition now delegates to the DatabaseWrapper.") + message = "This method is no longer needed. DBFlowDatabase now delegates to the DatabaseWrapper.") @JvmStatic fun getWritableDatabase(databaseName: String): DatabaseWrapper = getDatabase(databaseName).writableDatabase @Deprecated(replaceWith = ReplaceWith("FlowManager.getDatabase(databaseClass)"), - message = "This method is no longer needed. DatabaseDefinition now delegates to the DatabaseWrapper.") + message = "This method is no longer needed. DBFlowDatabase now delegates to the DatabaseWrapper.") @JvmStatic - fun getWritableDatabase(databaseClass: Class<*>): DatabaseWrapper = + fun getWritableDatabase(databaseClass: Class): DatabaseWrapper = getDatabase(databaseClass).writableDatabase /** @@ -431,32 +432,32 @@ object FlowManager { } /** - * Easily get access to its [DatabaseDefinition] directly. + * Easily get access to its [DBFlowDatabase] directly. */ -inline fun database(): DatabaseDefinition = database(T::class) +inline fun database(): T = database(T::class) -inline fun database(kClass: KClass): DatabaseDefinition = FlowManager.getDatabase(kClass.java) +inline fun database(kClass: KClass): T = FlowManager.getDatabase(kClass.java) /** - * Easily get access to its [DatabaseDefinition] directly. + * Easily get access to its [DBFlowDatabase] directly. */ -inline fun database(kClass: KClass, f: DatabaseDefinition.() -> R): R = database(kClass).f() +inline fun database(kClass: KClass, f: T.() -> R): R = database(kClass).f() -inline fun database(f: DatabaseDefinition.() -> Unit): DatabaseDefinition +inline fun database(f: T.() -> Unit): T = database(T::class).apply(f) -inline fun databaseForTable(kClass: KClass, f: DatabaseDefinition.() -> R): R +inline fun databaseForTable(kClass: KClass, f: DBFlowDatabase.() -> R): R = databaseForTable(kClass).f() -inline fun databaseForTable(kClass: KClass): DatabaseDefinition = FlowManager.getDatabaseForTable(kClass.java) +inline fun databaseForTable(kClass: KClass): DBFlowDatabase = FlowManager.getDatabaseForTable(kClass.java) -inline fun databaseForTable(f: DatabaseDefinition.() -> Unit): DatabaseDefinition +inline fun databaseForTable(f: DBFlowDatabase.() -> Unit): DBFlowDatabase = databaseForTable(T::class).apply(f) /** - * Easily get access to its [DatabaseDefinition] directly. + * Easily get access to its [DBFlowDatabase] directly. */ -inline fun databaseForTable(): DatabaseDefinition = databaseForTable(T::class) +inline fun databaseForTable(): DBFlowDatabase = databaseForTable(T::class) /** * Easily get its table name. diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidSQLiteOpenHelper.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidSQLiteOpenHelper.kt index f027e38ef..8f6088ab5 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidSQLiteOpenHelper.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidSQLiteOpenHelper.kt @@ -4,14 +4,14 @@ import android.content.Context import android.database.sqlite.SQLiteDatabase import android.database.sqlite.SQLiteOpenHelper -import com.raizlabs.dbflow5.config.DatabaseDefinition +import com.raizlabs.dbflow5.config.DBFlowDatabase import com.raizlabs.dbflow5.config.FlowManager /** * Description: Wraps around the [SQLiteOpenHelper] and provides extra features for use in this library. */ open class AndroidSQLiteOpenHelper( - databaseDefinition: DatabaseDefinition, + databaseDefinition: DBFlowDatabase, listener: DatabaseHelperListener?) : SQLiteOpenHelper(FlowManager.context, if (databaseDefinition.isInMemory) null else databaseDefinition.databaseFileName, @@ -90,7 +90,7 @@ open class AndroidSQLiteOpenHelper( */ private inner class BackupHelper(context: Context, name: String, version: Int, - databaseDefinition: DatabaseDefinition) + databaseDefinition: DBFlowDatabase) : SQLiteOpenHelper(context, name, null, version), OpenHelper { private var androidDatabase: AndroidDatabase? = null diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/database/BaseDatabaseHelper.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/database/BaseDatabaseHelper.kt index f9a298fcb..401ec618b 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/database/BaseDatabaseHelper.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/database/BaseDatabaseHelper.kt @@ -1,6 +1,6 @@ package com.raizlabs.dbflow5.database -import com.raizlabs.dbflow5.config.DatabaseDefinition +import com.raizlabs.dbflow5.config.DBFlowDatabase import com.raizlabs.dbflow5.config.FlowLog import com.raizlabs.dbflow5.config.FlowManager import com.raizlabs.dbflow5.config.NaturalOrderComparator @@ -10,7 +10,7 @@ import java.io.InputStream /** * Description: */ -open class BaseDatabaseHelper(val databaseDefinition: DatabaseDefinition) { +open class BaseDatabaseHelper(val databaseDefinition: DBFlowDatabase) { open fun onCreate(db: DatabaseWrapper) { checkForeignKeySupport(db) diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseHelperDelegate.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseHelperDelegate.kt index a17d3ceac..f7fbadaff 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseHelperDelegate.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseHelperDelegate.kt @@ -1,6 +1,6 @@ package com.raizlabs.dbflow5.database -import com.raizlabs.dbflow5.config.DatabaseDefinition +import com.raizlabs.dbflow5.config.DBFlowDatabase import com.raizlabs.dbflow5.config.FlowLog import com.raizlabs.dbflow5.config.FlowManager import com.raizlabs.dbflow5.transaction.DefaultTransactionQueue @@ -16,13 +16,13 @@ import java.io.InputStream */ class DatabaseHelperDelegate( private var databaseHelperListener: DatabaseHelperListener?, - databaseDefinition: DatabaseDefinition, + databaseDefinition: DBFlowDatabase, private val backupHelper: OpenHelper?) : BaseDatabaseHelper(databaseDefinition) { /** * @return the temporary database file name for when we have backups enabled - * [DatabaseDefinition.backupEnabled] + * [DBFlowDatabase.backupEnabled] */ private val tempDbFileName: String get() = getTempDbFileName(databaseDefinition) @@ -204,7 +204,7 @@ class DatabaseHelperDelegate( } /** - * Will use the already existing app database if [DatabaseDefinition.backupEnabled] is true. If the existing + * Will use the already existing app database if [DBFlowDatabase.backupEnabled] is true. If the existing * is not there we will try to use the prepackaged database for that purpose. * * @param databaseName The name of the database to restore @@ -283,7 +283,7 @@ class DatabaseHelperDelegate( val TEMP_DB_NAME = "temp-" - fun getTempDbFileName(databaseDefinition: DatabaseDefinition): String { + fun getTempDbFileName(databaseDefinition: DBFlowDatabase): String { return TEMP_DB_NAME + databaseDefinition.databaseName + ".db" } } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/provider/BaseContentProvider.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/provider/BaseContentProvider.kt index 807d4529d..70dd20fc2 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/provider/BaseContentProvider.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/provider/BaseContentProvider.kt @@ -3,7 +3,7 @@ package com.raizlabs.dbflow5.provider import android.content.ContentProvider import android.content.ContentValues import android.net.Uri -import com.raizlabs.dbflow5.config.DatabaseDefinition +import com.raizlabs.dbflow5.config.DBFlowDatabase import com.raizlabs.dbflow5.config.DatabaseHolder import com.raizlabs.dbflow5.config.FlowManager import com.raizlabs.dbflow5.database.DatabaseWrapper @@ -18,7 +18,7 @@ protected constructor(databaseHolderClass: Class? = null) : protected open var moduleClass: Class? = databaseHolderClass - protected val database: DatabaseDefinition by lazy { FlowManager.getDatabase(databaseName) } + protected val database: DBFlowDatabase by lazy { FlowManager.getDatabase(databaseName) } protected abstract val databaseName: String diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/DBBatchSaveQueue.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/DBBatchSaveQueue.kt index 205bdac8b..dae7bfc6c 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/DBBatchSaveQueue.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/DBBatchSaveQueue.kt @@ -1,7 +1,7 @@ package com.raizlabs.dbflow5.runtime import android.os.Looper -import com.raizlabs.dbflow5.config.DatabaseDefinition +import com.raizlabs.dbflow5.config.DBFlowDatabase import com.raizlabs.dbflow5.config.FlowLog import com.raizlabs.dbflow5.structure.Model import com.raizlabs.dbflow5.structure.save @@ -19,7 +19,7 @@ class DBBatchSaveQueue /** * Creates a new instance of this class to batch save DB object classes. */ -internal constructor(private val databaseDefinition: DatabaseDefinition) : Thread("DBBatchSaveQueue") { +internal constructor(private val databaseDefinition: DBFlowDatabase) : Thread("DBBatchSaveQueue") { /** * Tells how many items to save at a time. This can be set using [.setModelSaveSize] diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/BaseTransactionManager.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/BaseTransactionManager.kt index b847311e2..1346e4e11 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/BaseTransactionManager.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/BaseTransactionManager.kt @@ -1,6 +1,6 @@ package com.raizlabs.dbflow5.transaction -import com.raizlabs.dbflow5.config.DatabaseDefinition +import com.raizlabs.dbflow5.config.DBFlowDatabase import com.raizlabs.dbflow5.config.FlowLog import com.raizlabs.dbflow5.runtime.DBBatchSaveQueue @@ -8,7 +8,7 @@ import com.raizlabs.dbflow5.runtime.DBBatchSaveQueue * Description: The base implementation of Transaction manager. */ abstract class BaseTransactionManager(val queue: ITransactionQueue, - databaseDefinition: DatabaseDefinition) { + databaseDefinition: DBFlowDatabase) { private val saveQueue: DBBatchSaveQueue = DBBatchSaveQueue(databaseDefinition) diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/DefaultTransactionManager.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/DefaultTransactionManager.kt index 283e8d5f1..a9bac8346 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/DefaultTransactionManager.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/DefaultTransactionManager.kt @@ -1,17 +1,17 @@ package com.raizlabs.dbflow5.transaction -import com.raizlabs.dbflow5.config.DatabaseDefinition +import com.raizlabs.dbflow5.config.DBFlowDatabase /** * Description: This class manages batch database interactions. Places DB operations onto the same Thread. */ class DefaultTransactionManager : BaseTransactionManager { - constructor(databaseDefinition: DatabaseDefinition) + constructor(databaseDefinition: DBFlowDatabase) : super(DefaultTransactionQueue("DBFlow Transaction Queue"), databaseDefinition) constructor(transactionQueue: ITransactionQueue, - databaseDefinition: DatabaseDefinition) + databaseDefinition: DBFlowDatabase) : super(transactionQueue, databaseDefinition) } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/Transaction.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/Transaction.kt index 0cacf7868..cf0006265 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/Transaction.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/Transaction.kt @@ -3,7 +3,7 @@ package com.raizlabs.dbflow5.transaction import android.os.Handler import android.os.Looper -import com.raizlabs.dbflow5.config.DatabaseDefinition +import com.raizlabs.dbflow5.config.DBFlowDatabase import com.raizlabs.dbflow5.config.FlowLog /** @@ -13,10 +13,10 @@ import com.raizlabs.dbflow5.config.FlowLog * and synchronization issues when trying to read and write from the database at the same time. * * - * To create one, the recommended method is to use the [DatabaseDefinition.beginTransactionAsync]. + * To create one, the recommended method is to use the [DBFlowDatabase.beginTransactionAsync]. */ class Transaction(private val transaction: ITransaction, - private val databaseDefinition: DatabaseDefinition, + private val databaseDefinition: DBFlowDatabase, private val errorCallback: Error? = null, private val successCallback: Success? = null, private val name: String?, @@ -86,7 +86,7 @@ class Transaction(private val transaction: ITransaction, /** * Executes the transaction immediately on the same thread from which it is called. This calls - * the [DatabaseDefinition.executeTransaction] method, which runs the + * the [DBFlowDatabase.executeTransaction] method, which runs the * [.transaction] in a database transaction. */ fun executeSync() { @@ -136,7 +136,7 @@ class Transaction(private val transaction: ITransaction, * @param databaseDefinition The database this transaction will run on. Should be the same * DB as the code that the transaction runs in. */ - (internal val transaction: ITransaction, internal val databaseDefinition: DatabaseDefinition) { + (internal val transaction: ITransaction, internal val databaseDefinition: DBFlowDatabase) { internal var errorCallback: Error? = null internal var successCallback: Success? = null internal var name: String? = null diff --git a/usage2/Databases.md b/usage2/Databases.md index 629fda39f..7f9bcef59 100644 --- a/usage2/Databases.md +++ b/usage2/Databases.md @@ -33,7 +33,7 @@ To specify a custom **name** to the database, in previous versions of DBFlow (< ```java FlowManager.init(FlowConfig.builder() - .addDatabaseConfig(DatabaseConfig.builder(AppDatabase.class) + .database(DatabaseConfig.builder(AppDatabase.class) .databaseName("AppDatabase") .build()) .build()) @@ -67,7 +67,7 @@ As with **name**, in previous versions of DBFlow (< 5.0), you specified `inMemor ```kotlin FlowManager.init(FlowConfig.builder() - .addDatabaseConfig(DatabaseConfig.inMemoryBuilder(AppDatabase::class.java) + .database(DatabaseConfig.inMemoryBuilder(AppDatabase::class.java) .databaseName("AppDatabase") .build()) .build()) @@ -77,7 +77,7 @@ FlowManager.init(FlowConfig.builder() ```java FlowManager.init(FlowConfig.builder() - .addDatabaseConfig(DatabaseConfig.inMemoryBuilder(AppDatabase.class) + .database(DatabaseConfig.inMemoryBuilder(AppDatabase.class) .databaseName("AppDatabase") .build()) .build()) @@ -211,7 +211,7 @@ Then in your `DatabaseConfig`: ```kotlin FlowManager.init(FlowConfig.builder(context) - .addDatabaseConfig(DatabaseConfig.Builder(CipherDatabase::class.java) + .database(DatabaseConfig.Builder(CipherDatabase::class.java) .openHelper(::CustomFlowSQliteOpenHelper) .build()) .build()) @@ -221,7 +221,7 @@ FlowManager.init(FlowConfig.builder(context) ```java FlowManager.init(FlowConfig.builder(context) - .addDatabaseConfig( + .database( DatabaseConfig.builder(CipherDatabase.class) .openHelper(new DatabaseConfig.OpenHelperCreator() { @Override diff --git a/usage2/GettingStarted.md b/usage2/GettingStarted.md index 27278e5ba..52c5df0d7 100644 --- a/usage2/GettingStarted.md +++ b/usage2/GettingStarted.md @@ -106,7 +106,7 @@ If you do not like the built-in `DefaultTransactionManager`, or just want to rol ```java FlowManager.init(FlowConfig.builder(this) - .addDatabaseConfig(DatabaseConfig.builder(AppDatabase.class) + .database(DatabaseConfig.builder(AppDatabase.class) .transactionManager(new CustomTransactionManager()) .build())); diff --git a/usage2/Observability.md b/usage2/Observability.md index 1e9be9659..9a4b6bbd8 100644 --- a/usage2/Observability.md +++ b/usage2/Observability.md @@ -121,7 +121,7 @@ To set up direct changes we override the default `ModelNotifier`: ```java FlowManager.init(FlowConfig.Builder(context) - .addDatabaseConfig(DatabaseConfig.Builder(TestDatabase.class) + .database(DatabaseConfig.Builder(TestDatabase.class) .modelNotifier(DirectModelNotifier.get()) .build()).build()); diff --git a/usage2/SQLCipherSupport.md b/usage2/SQLCipherSupport.md index 83bfee79e..739b3cb0f 100644 --- a/usage2/SQLCipherSupport.md +++ b/usage2/SQLCipherSupport.md @@ -41,7 +41,7 @@ Then in your application class when initializing DBFlow: ```java FlowManager.init(new FlowConfig.Builder(this) - .addDatabaseConfig( + .database( new DatabaseConfig.Builder(CipherDatabase.class) .openHelper(new DatabaseConfig.OpenHelperCreator() { @Override diff --git a/usage2/StoringData.md b/usage2/StoringData.md index baf748bd4..bf408b0e3 100644 --- a/usage2/StoringData.md +++ b/usage2/StoringData.md @@ -252,7 +252,7 @@ To register it with DBFlow, in your `FlowConfig`, you must: ```java FlowManager.init(builder - .addDatabaseConfig(new DatabaseConfig.Builder(AppDatabase.class) + .database(new DatabaseConfig.Builder(AppDatabase.class) .transactionManagerCreator(new DatabaseConfig.TransactionManagerCreator() { @Override public BaseTransactionManager createManager(DatabaseDefinition databaseDefinition) { @@ -280,7 +280,7 @@ we provide a custom instance of the `DefaultTransactionManager` with the `Prior ```java FlowManager.init(builder - .addDatabaseConfig(new DatabaseConfig.Builder(AppDatabase.class) + .database(new DatabaseConfig.Builder(AppDatabase.class) .transactionManagerCreator(new DatabaseConfig.TransactionManagerCreator() { @Override public BaseTransactionManager createManager(DatabaseDefinition databaseDefinition) { From 7cbeeb182eb63546b180f2c11be137b5a81b1f6b Mon Sep 17 00:00:00 2001 From: fuzzagrosner Date: Tue, 5 Dec 2017 17:30:01 -0500 Subject: [PATCH 134/234] [db] remove more global dbflow context usage to two base classes. remove deprecation from BaseModel, BaseModelView, and BaseQueryModel. --- .../dbflow5/sqlcipher/SQLCipherOpenHelper.kt | 30 ++++---- .../dbflow5/DBFlowInstrumentedTestRule.kt | 30 ++++---- .../dbflow5/sqlcipher/CipherTestObjects.kt | 9 ++- .../raizlabs/dbflow5/test/DemoActivity.java | 12 +-- .../com/raizlabs/dbflow5/DBFlowTestRule.kt | 18 +++-- .../dbflow5/config/ConfigIntegrationTest.kt | 29 ++++---- .../dbflow5/config/DatabaseConfigTest.kt | 17 +++-- .../dbflow5/runtime/DirectNotifierTest.kt | 8 +- .../raizlabs/dbflow5/config/DBFlowDatabase.kt | 55 ++++++++------ .../raizlabs/dbflow5/config/DatabaseConfig.kt | 73 +++++++------------ .../com/raizlabs/dbflow5/config/FlowConfig.kt | 13 ++++ .../raizlabs/dbflow5/config/FlowManager.kt | 6 +- .../database/AndroidSQLiteOpenHelper.kt | 41 ++++++++--- .../dbflow5/database/BaseDatabaseHelper.kt | 9 ++- ...eHelperListener.kt => DatabaseCallback.kt} | 2 +- .../database/DatabaseHelperDelegate.kt | 45 ++++++------ .../raizlabs/dbflow5/database/OpenHelper.kt | 7 +- .../dbflow5/provider/BaseProviderModel.kt | 8 +- .../provider/BaseSyncableProviderModel.kt | 10 +-- .../raizlabs/dbflow5/provider/ContentUtils.kt | 52 +++++++------ .../runtime/ContentResolverNotifier.kt | 26 +++---- .../dbflow5/runtime/FlowContentObserver.kt | 43 ++++++----- .../raizlabs/dbflow5/structure/BaseModel.kt | 5 +- .../dbflow5/structure/BaseModelView.kt | 1 - .../dbflow5/structure/BaseQueryModel.kt | 1 - usage2/Databases.md | 4 +- usage2/SQLCipherSupport.md | 4 +- 27 files changed, 306 insertions(+), 252 deletions(-) rename dbflow/src/main/java/com/raizlabs/dbflow5/database/{DatabaseHelperListener.kt => DatabaseCallback.kt} (96%) diff --git a/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherOpenHelper.kt b/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherOpenHelper.kt index 57e558931..c5365f9a5 100644 --- a/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherOpenHelper.kt +++ b/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherOpenHelper.kt @@ -1,16 +1,13 @@ package com.raizlabs.dbflow5.sqlcipher import android.content.Context - -import com.raizlabs.dbflow5.config.DatabaseConfig import com.raizlabs.dbflow5.config.DBFlowDatabase -import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.config.DatabaseConfig import com.raizlabs.dbflow5.database.BaseDatabaseHelper +import com.raizlabs.dbflow5.database.DatabaseCallback import com.raizlabs.dbflow5.database.DatabaseHelperDelegate -import com.raizlabs.dbflow5.database.DatabaseHelperListener import com.raizlabs.dbflow5.database.DatabaseWrapper import com.raizlabs.dbflow5.database.OpenHelper - import net.sqlcipher.database.SQLiteDatabase import net.sqlcipher.database.SQLiteOpenHelper @@ -18,8 +15,10 @@ import net.sqlcipher.database.SQLiteOpenHelper * Description: The replacement [OpenHelper] for SQLCipher. Specify a subclass of this is [DatabaseConfig.getDatabaseClass] * of your database to get it to work with specifying the secret you use for the databaseForTable. */ -abstract class SQLCipherOpenHelper(databaseDefinition: DBFlowDatabase, listener: DatabaseHelperListener?) - : SQLiteOpenHelper(FlowManager.context, +abstract class SQLCipherOpenHelper( + context: Context, + databaseDefinition: DBFlowDatabase, listener: DatabaseCallback?) + : SQLiteOpenHelper(context, if (databaseDefinition.isInMemory) null else databaseDefinition.databaseFileName, null, databaseDefinition.databaseVersion), OpenHelper { @@ -43,17 +42,17 @@ abstract class SQLCipherOpenHelper(databaseDefinition: DBFlowDatabase, listener: protected abstract val cipherSecret: String init { - SQLiteDatabase.loadLibs(FlowManager.context) + SQLiteDatabase.loadLibs(context) var backupHelper: OpenHelper? = null if (databaseDefinition.backupEnabled()) { // Temp database mirrors existing - backupHelper = BackupHelper(FlowManager.context, + backupHelper = BackupHelper(context, DatabaseHelperDelegate.getTempDbFileName(databaseDefinition), databaseDefinition.databaseVersion, databaseDefinition) } - delegate = DatabaseHelperDelegate(listener, databaseDefinition, backupHelper) + delegate = DatabaseHelperDelegate(context, listener, databaseDefinition, backupHelper) } override fun performRestoreFromBackup() { @@ -68,10 +67,10 @@ abstract class SQLCipherOpenHelper(databaseDefinition: DBFlowDatabase, listener: * Set a listener to listen for specific DB events and perform an action before we execute this classes * specific methods. * - * @param helperListener + * @param callback */ - override fun setDatabaseListener(helperListener: DatabaseHelperListener?) { - delegate.setDatabaseHelperListener(helperListener) + override fun setDatabaseListener(callback: DatabaseCallback?) { + delegate.setDatabaseHelperListener(callback) } override fun onCreate(db: SQLiteDatabase) { @@ -105,7 +104,7 @@ abstract class SQLCipherOpenHelper(databaseDefinition: DBFlowDatabase, listener: : SQLiteOpenHelper(context, name, null, version), OpenHelper { private var sqlCipherDatabase: SQLCipherDatabase? = null - private val baseDatabaseHelper: BaseDatabaseHelper = BaseDatabaseHelper(databaseDefinition) + private val baseDatabaseHelper: BaseDatabaseHelper = BaseDatabaseHelper(context, databaseDefinition) override val database: DatabaseWrapper get() { @@ -127,7 +126,7 @@ abstract class SQLCipherOpenHelper(databaseDefinition: DBFlowDatabase, listener: override fun closeDB() = Unit - override fun setDatabaseListener(helperListener: DatabaseHelperListener?) = Unit + override fun setDatabaseListener(callback: DatabaseCallback?) = Unit override fun onCreate(db: SQLiteDatabase) { baseDatabaseHelper.onCreate(SQLCipherDatabase.from(db)) @@ -143,4 +142,5 @@ abstract class SQLCipherOpenHelper(databaseDefinition: DBFlowDatabase, listener: override fun setWriteAheadLoggingEnabled(enabled: Boolean) = Unit } + } diff --git a/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/DBFlowInstrumentedTestRule.kt b/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/DBFlowInstrumentedTestRule.kt index b0db12566..331171091 100644 --- a/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/DBFlowInstrumentedTestRule.kt +++ b/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/DBFlowInstrumentedTestRule.kt @@ -1,9 +1,10 @@ package com.raizlabs.dbflow5 -import com.raizlabs.dbflow5.config.DatabaseConfig import com.raizlabs.dbflow5.config.DBFlowDatabase +import com.raizlabs.dbflow5.config.DatabaseConfig import com.raizlabs.dbflow5.config.FlowConfig import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.database.AndroidSQLiteOpenHelper import com.raizlabs.dbflow5.prepackaged.PrepackagedDB import com.raizlabs.dbflow5.runtime.ContentResolverNotifier import com.raizlabs.dbflow5.sqlcipher.CipherDatabase @@ -19,18 +20,21 @@ class DBFlowInstrumentedTestRule : TestRule { @Throws(Throwable::class) override fun evaluate() { FlowManager.init(FlowConfig.Builder(DemoApp.context) - .database(DatabaseConfig( - databaseClass = AppDatabase::class.java, - modelNotifier = ContentResolverNotifier("com.grosner.content"), - transactionManagerCreator = { databaseDefinition: DBFlowDatabase -> - ImmediateTransactionManager(databaseDefinition) - })) - .database(DatabaseConfig( - databaseClass = PrepackagedDB::class.java, - databaseName = "prepackaged")) - .database(DatabaseConfig( - databaseClass = CipherDatabase::class.java)) - .build()) + .database(DatabaseConfig( + databaseClass = AppDatabase::class.java, + openHelperCreator = AndroidSQLiteOpenHelper.createHelperCreator(DemoApp.context), + modelNotifier = ContentResolverNotifier(DemoApp.context, "com.grosner.content"), + transactionManagerCreator = { databaseDefinition: DBFlowDatabase -> + ImmediateTransactionManager(databaseDefinition) + })) + .database(DatabaseConfig( + openHelperCreator = AndroidSQLiteOpenHelper.createHelperCreator(DemoApp.context), + databaseClass = PrepackagedDB::class.java, + databaseName = "prepackaged")) + .database(DatabaseConfig( + openHelperCreator = AndroidSQLiteOpenHelper.createHelperCreator(DemoApp.context), + databaseClass = CipherDatabase::class.java)) + .build()) try { base.evaluate() } finally { diff --git a/dbflow-tests/src/main/java/com/raizlabs/dbflow5/sqlcipher/CipherTestObjects.kt b/dbflow-tests/src/main/java/com/raizlabs/dbflow5/sqlcipher/CipherTestObjects.kt index aa919cf83..17d70bd00 100644 --- a/dbflow-tests/src/main/java/com/raizlabs/dbflow5/sqlcipher/CipherTestObjects.kt +++ b/dbflow-tests/src/main/java/com/raizlabs/dbflow5/sqlcipher/CipherTestObjects.kt @@ -1,14 +1,17 @@ package com.raizlabs.dbflow5.sqlcipher +import android.content.Context import com.raizlabs.dbflow5.annotation.Column import com.raizlabs.dbflow5.annotation.PrimaryKey import com.raizlabs.dbflow5.annotation.Table import com.raizlabs.dbflow5.config.DBFlowDatabase -import com.raizlabs.dbflow5.database.DatabaseHelperListener +import com.raizlabs.dbflow5.database.DatabaseCallback import com.raizlabs.dbflow5.structure.BaseModel -class SQLCipherOpenHelperImpl(databaseDefinition: DBFlowDatabase, helperListener: DatabaseHelperListener?) - : SQLCipherOpenHelper(databaseDefinition, helperListener) { +class SQLCipherOpenHelperImpl(context: Context, + databaseDefinition: DBFlowDatabase, + callback: DatabaseCallback?) + : SQLCipherOpenHelper(context, databaseDefinition, callback) { override val cipherSecret get() = "dbflow-rules" } diff --git a/dbflow-tests/src/main/java/com/raizlabs/dbflow5/test/DemoActivity.java b/dbflow-tests/src/main/java/com/raizlabs/dbflow5/test/DemoActivity.java index f2bbb30c0..23d0e193d 100644 --- a/dbflow-tests/src/main/java/com/raizlabs/dbflow5/test/DemoActivity.java +++ b/dbflow-tests/src/main/java/com/raizlabs/dbflow5/test/DemoActivity.java @@ -8,6 +8,7 @@ import com.raizlabs.dbflow5.config.DatabaseConfig; import com.raizlabs.dbflow5.config.FlowConfig; import com.raizlabs.dbflow5.config.FlowManager; +import com.raizlabs.dbflow5.database.AndroidSQLiteOpenHelper; import com.raizlabs.dbflow5.prepackaged.PrepackagedDB; @@ -19,11 +20,12 @@ protected void onCreate(Bundle savedInstanceState) { setContentView(R.layout.activity_demo); FlowManager.init(new FlowConfig.Builder(getApplicationContext()) - .database( - DatabaseConfig.builder(PrepackagedDB.class) - .databaseName("prepackaged") - .build()) - .build()); + .database( + DatabaseConfig.builder(PrepackagedDB.class, + (dbFlowDatabase, databaseHelperListener) -> new AndroidSQLiteOpenHelper(getApplicationContext(), dbFlowDatabase, databaseHelperListener)) + .databaseName("prepackaged") + .build()) + .build()); } diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/DBFlowTestRule.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/DBFlowTestRule.kt index 67a9dcaf5..a76526b96 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/DBFlowTestRule.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/DBFlowTestRule.kt @@ -1,8 +1,10 @@ package com.raizlabs.dbflow5 +import android.content.Context import com.raizlabs.dbflow5.config.DatabaseConfig import com.raizlabs.dbflow5.config.FlowConfig import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.database.AndroidSQLiteOpenHelper import com.raizlabs.dbflow5.provider.ContentDatabase import org.junit.rules.TestRule import org.junit.runner.Description @@ -11,19 +13,23 @@ import org.robolectric.RuntimeEnvironment class DBFlowTestRule : TestRule { + val context: Context + get() = RuntimeEnvironment.application + override fun apply(base: Statement, description: Description): Statement { return object : Statement() { @Throws(Throwable::class) override fun evaluate() { FlowManager.init(FlowConfig.Builder(RuntimeEnvironment.application) - .database(DatabaseConfig.Builder(TestDatabase::class) - .transactionManagerCreator(::ImmediateTransactionManager2) - .build()) - .database(DatabaseConfig.builder(ContentDatabase::class) - .databaseName("content") - .build()) + .database(DatabaseConfig.Builder(TestDatabase::class, AndroidSQLiteOpenHelper.createHelperCreator(context)) + .transactionManagerCreator(::ImmediateTransactionManager2) + .build()) + .database(DatabaseConfig.builder(ContentDatabase::class, + AndroidSQLiteOpenHelper.createHelperCreator(context)) + .databaseName("content") .build()) + .build()) try { base.evaluate() } finally { diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/config/ConfigIntegrationTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/config/ConfigIntegrationTest.kt index c6564c4b4..f4b46977d 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/config/ConfigIntegrationTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/config/ConfigIntegrationTest.kt @@ -5,8 +5,11 @@ import com.raizlabs.dbflow5.TestDatabase import com.raizlabs.dbflow5.adapter.queriable.ListModelLoader import com.raizlabs.dbflow5.adapter.queriable.SingleModelLoader import com.raizlabs.dbflow5.adapter.saveable.ModelSaver +import com.raizlabs.dbflow5.database.AndroidSQLiteOpenHelper import com.raizlabs.dbflow5.models.SimpleModel -import org.junit.Assert.* +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNotNull +import org.junit.Assert.assertTrue import org.junit.Before import org.junit.Test @@ -27,12 +30,9 @@ class ConfigIntegrationTest : BaseUnitTest() { @Test fun test_flowConfig() { - FlowManager.init(builder - .openDatabasesOnInit(true) - .build()) - - val config = FlowManager.getConfig() - assertNotNull(config) + val config = builder + .openDatabasesOnInit(true) + .build() assertEquals(config.openDatabasesOnInit, true) assertTrue(config.databaseConfigMap.isEmpty()) assertTrue(config.databaseHolders.isEmpty()) @@ -46,14 +46,15 @@ class ConfigIntegrationTest : BaseUnitTest() { val modelSaver = ModelSaver() FlowManager.init(builder - .database(DatabaseConfig.Builder(TestDatabase::class.java) - .addTableConfig(TableConfig.Builder(SimpleModel::class.java) - .singleModelLoader(singleModelLoader) - .listModelLoader(customListModelLoader) - .modelAdapterModelSaver(modelSaver) - .build()) - .build()) + .database(DatabaseConfig.Builder(TestDatabase::class.java, + AndroidSQLiteOpenHelper.createHelperCreator(context)) + .addTableConfig(TableConfig.Builder(SimpleModel::class.java) + .singleModelLoader(singleModelLoader) + .listModelLoader(customListModelLoader) + .modelAdapterModelSaver(modelSaver) + .build()) .build()) + .build()) val flowConfig = FlowManager.getConfig() assertNotNull(flowConfig) diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/config/DatabaseConfigTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/config/DatabaseConfigTest.kt index a119bdcd7..e27f1ce01 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/config/DatabaseConfigTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/config/DatabaseConfigTest.kt @@ -3,7 +3,8 @@ package com.raizlabs.dbflow5.config import com.nhaarman.mockito_kotlin.mock import com.raizlabs.dbflow5.BaseUnitTest import com.raizlabs.dbflow5.TestDatabase -import com.raizlabs.dbflow5.database.DatabaseHelperListener +import com.raizlabs.dbflow5.database.AndroidSQLiteOpenHelper +import com.raizlabs.dbflow5.database.DatabaseCallback import com.raizlabs.dbflow5.database.OpenHelper import com.raizlabs.dbflow5.transaction.BaseTransactionManager import org.junit.Assert @@ -28,10 +29,10 @@ class DatabaseConfigTest : BaseUnitTest() { @Test fun test_databaseConfig() { - val helperListener = mock() + val helperListener = mock() val customOpenHelper = mock() - val openHelperCreator: ((DBFlowDatabase, DatabaseHelperListener?) -> OpenHelper) = { _, _ -> + val openHelperCreator: ((DBFlowDatabase, DatabaseCallback?) -> OpenHelper) = { _, _ -> customOpenHelper } var testTransactionManager: TestTransactionManager? = null @@ -41,10 +42,9 @@ class DatabaseConfigTest : BaseUnitTest() { } FlowManager.init(builder - .database(DatabaseConfig.Builder(TestDatabase::class.java) + .database(DatabaseConfig.Builder(TestDatabase::class.java, openHelperCreator) .databaseName("Test") .helperListener(helperListener) - .openHelper(openHelperCreator) .transactionManagerCreator(managerCreator) .build()) .build()) @@ -58,19 +58,20 @@ class DatabaseConfigTest : BaseUnitTest() { Assert.assertEquals(databaseConfig.transactionManagerCreator, managerCreator) Assert.assertEquals(databaseConfig.databaseClass, TestDatabase::class.java) Assert.assertEquals(databaseConfig.openHelperCreator, openHelperCreator) - Assert.assertEquals(databaseConfig.helperListener, helperListener) + Assert.assertEquals(databaseConfig.callback, helperListener) Assert.assertTrue(databaseConfig.tableConfigMap.isEmpty()) val databaseDefinition = database() Assert.assertEquals(databaseDefinition.transactionManager, testTransactionManager) - Assert.assertEquals(databaseDefinition.helper, customOpenHelper) + Assert.assertEquals(databaseDefinition.openHelper, customOpenHelper) } @Test fun test_EmptyName() { FlowManager.init(builder - .database(DatabaseConfig.Builder(TestDatabase::class.java) + .database(DatabaseConfig.Builder(TestDatabase::class.java, + AndroidSQLiteOpenHelper.createHelperCreator(context)) .databaseName("Test") .extensionName("") .build()) diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/runtime/DirectNotifierTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/runtime/DirectNotifierTest.kt index 88c6d6a99..4c04b910b 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/runtime/DirectNotifierTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/runtime/DirectNotifierTest.kt @@ -10,6 +10,7 @@ import com.raizlabs.dbflow5.config.DatabaseConfig import com.raizlabs.dbflow5.config.FlowConfig import com.raizlabs.dbflow5.config.FlowManager import com.raizlabs.dbflow5.config.databaseForTable +import com.raizlabs.dbflow5.database.AndroidSQLiteOpenHelper import com.raizlabs.dbflow5.models.SimpleModel import com.raizlabs.dbflow5.models.SimpleModel_Table import com.raizlabs.dbflow5.query.columnValues @@ -41,9 +42,10 @@ class DirectNotifierTest { @Before fun setupTest() { FlowManager.init(FlowConfig.Builder(context) - .database(DatabaseConfig.Builder(TestDatabase::class.java) - .transactionManagerCreator(::ImmediateTransactionManager2) - .build()).build()) + .database(DatabaseConfig.Builder(TestDatabase::class.java, + AndroidSQLiteOpenHelper.createHelperCreator(context)) + .transactionManagerCreator(::ImmediateTransactionManager2) + .build()).build()) } @Test diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/config/DBFlowDatabase.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/config/DBFlowDatabase.kt index e2e309ccf..5e300d328 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/config/DBFlowDatabase.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/config/DBFlowDatabase.kt @@ -12,7 +12,7 @@ import com.raizlabs.dbflow5.annotation.Database import com.raizlabs.dbflow5.annotation.QueryModel import com.raizlabs.dbflow5.annotation.Table import com.raizlabs.dbflow5.database.AndroidSQLiteOpenHelper -import com.raizlabs.dbflow5.database.DatabaseHelperListener +import com.raizlabs.dbflow5.database.DatabaseCallback import com.raizlabs.dbflow5.database.DatabaseStatement import com.raizlabs.dbflow5.database.DatabaseWrapper import com.raizlabs.dbflow5.database.FlowCursor @@ -21,6 +21,7 @@ import com.raizlabs.dbflow5.migration.Migration import com.raizlabs.dbflow5.runtime.DirectModelNotifier import com.raizlabs.dbflow5.runtime.ModelNotifier import com.raizlabs.dbflow5.structure.BaseModelView +import com.raizlabs.dbflow5.structure.InvalidDBConfiguration import com.raizlabs.dbflow5.transaction.BaseTransactionManager import com.raizlabs.dbflow5.transaction.DefaultTransactionManager import com.raizlabs.dbflow5.transaction.DefaultTransactionQueue @@ -46,12 +47,12 @@ abstract class DBFlowDatabase : DatabaseWrapper { /** * The helper that manages database changes and initialization */ - private var openHelper: OpenHelper? = null + private var _openHelper: OpenHelper? = null /** * Allows for the app to listen for database changes. */ - private var helperListener: DatabaseHelperListener? = null + private var callback: DatabaseCallback? = null /** * Used when resetting the DB @@ -96,22 +97,27 @@ abstract class DBFlowDatabase : DatabaseWrapper { val migrations: Map> get() = migrationMap - val helper: OpenHelper + /** + * Returns true if the [openHelper] has been created. + */ + var isOpened: Boolean = false + + val openHelper: OpenHelper @Synchronized get() { - if (openHelper == null) { + if (_openHelper == null) { val config = FlowManager.getConfig().databaseConfigMap[associatedDatabaseClassFile] - openHelper = if (config?.openHelperCreator != null) { - config.openHelperCreator.invoke(this, helperListener) - } else { - AndroidSQLiteOpenHelper(this, helperListener) - } - openHelper?.performRestoreFromBackup() + ?: throw InvalidDBConfiguration("" + + "Missing Database Configuration for $associatedDatabaseClassFile." + + " Please specify it in FlowManager.init()") + _openHelper = config.openHelperCreator(this, callback) + _openHelper?.performRestoreFromBackup() + isOpened = true } - return openHelper!! + return _openHelper!! } val writableDatabase: DatabaseWrapper - get() = helper.database + get() = openHelper.database /** * @return The name of this database as defined in [Database] @@ -157,7 +163,7 @@ abstract class DBFlowDatabase : DatabaseWrapper { * override the return value if it replaces the main DB. */ val isDatabaseIntegrityOk: Boolean - get() = helper.isDatabaseIntegrityOk + get() = openHelper.isDatabaseIntegrityOk init { @Suppress("LeakingThis") @@ -179,7 +185,7 @@ abstract class DBFlowDatabase : DatabaseWrapper { tableConfig.singleModelLoader?.let { modelAdapter.singleModelLoader = it as SingleModelLoader } tableConfig.modelSaver?.let { modelAdapter.modelSaver = it as ModelSaver } } - helperListener = databaseConfig.helperListener + callback = databaseConfig.callback } transactionManager = if (databaseConfig?.transactionManagerCreator == null) { DefaultTransactionManager(this) @@ -343,7 +349,7 @@ abstract class DBFlowDatabase : DatabaseWrapper { destroy() // reapply configuration before opening it. applyDatabaseConfig(databaseConfig) - helper.database + openHelper.database } } @@ -357,9 +363,10 @@ abstract class DBFlowDatabase : DatabaseWrapper { fun reopen(databaseConfig: DatabaseConfig? = this.databaseConfig) { if (!isResetting) { close() - openHelper = null + _openHelper = null + isOpened = false applyDatabaseConfig(databaseConfig) - helper.database + openHelper.database isResetting = false } } @@ -371,8 +378,9 @@ abstract class DBFlowDatabase : DatabaseWrapper { if (!isResetting) { isResetting = true close() - FlowManager.context.deleteDatabase(databaseFileName) - openHelper = null + openHelper.deleteDB() + _openHelper = null + isOpened = false isResetting = false } } @@ -390,7 +398,10 @@ abstract class DBFlowDatabase : DatabaseWrapper { closeUpdateStatement() } } - helper.closeDB() + if (isOpened) { + openHelper.closeDB() + isOpened = false + } } /** @@ -401,7 +412,7 @@ abstract class DBFlowDatabase : DatabaseWrapper { * or [Database.consistencyCheckEnabled] is not enabled. */ fun backupDatabase() { - helper.backupDB() + openHelper.backupDB() } override val version: Int diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseConfig.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseConfig.kt index 908f6c680..f8d110341 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseConfig.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseConfig.kt @@ -1,43 +1,35 @@ package com.raizlabs.dbflow5.config -import com.raizlabs.dbflow5.database.DatabaseHelperListener +import com.raizlabs.dbflow5.database.DatabaseCallback import com.raizlabs.dbflow5.database.OpenHelper import com.raizlabs.dbflow5.isNotNullOrEmpty import com.raizlabs.dbflow5.runtime.ModelNotifier import com.raizlabs.dbflow5.transaction.BaseTransactionManager import kotlin.reflect.KClass +typealias OpenHelperCreator = (DBFlowDatabase, DatabaseCallback?) -> OpenHelper +typealias TransactionManagerCreator = (DBFlowDatabase) -> BaseTransactionManager + /** * Description: */ class DatabaseConfig( val databaseClass: Class<*>, - val openHelperCreator: ((DBFlowDatabase, DatabaseHelperListener?) -> OpenHelper)? = null, - val transactionManagerCreator: ((DBFlowDatabase) -> BaseTransactionManager)? = null, - val helperListener: DatabaseHelperListener? = null, + val openHelperCreator: OpenHelperCreator, + val transactionManagerCreator: TransactionManagerCreator? = null, + val callback: DatabaseCallback? = null, val tableConfigMap: Map, TableConfig<*>> = mapOf(), val modelNotifier: ModelNotifier? = null, val isInMemory: Boolean = false, val databaseName: String? = null, val databaseExtensionName: String? = null) { - - interface OpenHelperCreator { - - fun createHelper(databaseDefinition: DBFlowDatabase, helperListener: DatabaseHelperListener?): OpenHelper - } - - interface TransactionManagerCreator { - - fun createManager(databaseDefinition: DBFlowDatabase): BaseTransactionManager - } - internal constructor(builder: Builder) : this( // convert java interface to kotlin function. openHelperCreator = builder.openHelperCreator, databaseClass = builder.databaseClass, transactionManagerCreator = builder.transactionManagerCreator, - helperListener = builder.helperListener, + callback = builder.callback, tableConfigMap = builder.tableConfigMap, modelNotifier = builder.modelNotifier, isInMemory = builder.inMemory, @@ -55,43 +47,26 @@ class DatabaseConfig( /** * Build compatibility class for Java. Use the [DatabaseConfig] class directly if Kotlin consumer. */ - class Builder(internal val databaseClass: Class<*>) { + class Builder(internal val databaseClass: Class<*>, + internal val openHelperCreator: OpenHelperCreator) { - internal var openHelperCreator: ((DBFlowDatabase, DatabaseHelperListener?) -> OpenHelper)? = null - internal var transactionManagerCreator: ((DBFlowDatabase) -> BaseTransactionManager)? = null - internal var helperListener: DatabaseHelperListener? = null + internal var transactionManagerCreator: TransactionManagerCreator? = null + internal var callback: DatabaseCallback? = null internal val tableConfigMap: MutableMap, TableConfig<*>> = hashMapOf() internal var modelNotifier: ModelNotifier? = null internal var inMemory = false internal var databaseName: String? = null internal var databaseExtensionName: String? = null - constructor(kClass: KClass<*>) : this(kClass.java) + constructor(kClass: KClass<*>, openHelperCreator: OpenHelperCreator) + : this(kClass.java, openHelperCreator) - fun transactionManagerCreator(transactionManager: TransactionManagerCreator) = - transactionManagerCreator { databaseDefinition -> transactionManager.createManager(databaseDefinition) } - - fun transactionManagerCreator(creator: (DBFlowDatabase) -> BaseTransactionManager) = apply { + fun transactionManagerCreator(creator: TransactionManagerCreator) = apply { this.transactionManagerCreator = creator } - /** - * Overrides the default [OpenHelper] for a [DBFlowDatabase]. - * - * @param openHelper The openhelper to use. - */ - fun openHelper(openHelper: (DBFlowDatabase, DatabaseHelperListener?) -> OpenHelper) = apply { - openHelperCreator = openHelper - } - - fun openHelper(openHelper: OpenHelperCreator) = apply { - openHelperCreator = { databaseDefinition, databaseHelperListener -> - openHelper.createHelper(databaseDefinition, databaseHelperListener) - } - } - - fun helperListener(helperListener: DatabaseHelperListener) = apply { - this.helperListener = helperListener + fun helperListener(callback: DatabaseCallback) = apply { + this.callback = callback } fun addTableConfig(tableConfig: TableConfig<*>) = apply { @@ -127,15 +102,17 @@ class DatabaseConfig( companion object { @JvmStatic - fun builder(database: Class<*>): Builder = Builder(database) + fun builder(database: Class<*>, openHelperCreator: OpenHelperCreator): Builder = + Builder(database, openHelperCreator) - fun builder(database: KClass<*>): Builder = Builder(database) + fun builder(database: KClass<*>, openHelperCreator: OpenHelperCreator): Builder = + Builder(database, openHelperCreator) @JvmStatic - fun inMemoryBuilder(database: Class<*>): Builder = - Builder(database).inMemory() + fun inMemoryBuilder(database: Class<*>, openHelperCreator: OpenHelperCreator): Builder = + Builder(database, openHelperCreator).inMemory() - fun inMemoryBuilder(database: KClass<*>): Builder = - Builder(database).inMemory() + fun inMemoryBuilder(database: KClass<*>, openHelperCreator: OpenHelperCreator): Builder = + Builder(database, openHelperCreator).inMemory() } } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowConfig.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowConfig.kt index ff23130dc..a08c6fba1 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowConfig.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowConfig.kt @@ -21,6 +21,19 @@ class FlowConfig(val context: Context, return databaseConfigMap[databaseClass] } + /** + * Merges two [FlowConfig] together by combining an existing config. Any new specified [DatabaseConfig] + * will override existing ones. + */ + internal fun merge(flowConfig: FlowConfig): FlowConfig = FlowConfig( + context = flowConfig.context, + databaseConfigMap = databaseConfigMap.entries + .map { (key, value) -> + key to (flowConfig.databaseConfigMap[key] ?: value) + }.toMap(), + databaseHolders = databaseHolders.plus(flowConfig.databaseHolders), + openDatabasesOnInit = flowConfig.openDatabasesOnInit) + class Builder(context: Context) { internal val context: Context = context.applicationContext diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowManager.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowManager.kt index 749a2cb55..bc221ce28 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowManager.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowManager.kt @@ -2,6 +2,7 @@ package com.raizlabs.dbflow5.config +import android.annotation.SuppressLint import android.content.Context import com.raizlabs.dbflow5.adapter.InstanceAdapter import com.raizlabs.dbflow5.adapter.ModelAdapter @@ -29,6 +30,7 @@ import kotlin.reflect.KClass */ object FlowManager { + @SuppressLint("StaticFieldLeak") internal var config: FlowConfig? = null private var globalDatabaseHolder = GlobalDatabaseHolder() @@ -248,7 +250,7 @@ object FlowManager { */ @JvmStatic fun init(flowConfig: FlowConfig) { - config = flowConfig + config = config?.merge(flowConfig) ?: flowConfig @Suppress("UNCHECKED_CAST") try { @@ -401,7 +403,7 @@ object FlowManager { * @return true if it's integrity is OK. */ @JvmStatic - fun isDatabaseIntegrityOk(databaseName: String) = getDatabase(databaseName).helper.isDatabaseIntegrityOk + fun isDatabaseIntegrityOk(databaseName: String) = getDatabase(databaseName).openHelper.isDatabaseIntegrityOk private fun throwCannotFindAdapter(type: String, clazz: Class<*>): Nothing = throw IllegalArgumentException("Cannot find $type for $clazz. Ensure the class is annotated with proper annotation.") diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidSQLiteOpenHelper.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidSQLiteOpenHelper.kt index 8f6088ab5..4abb96952 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidSQLiteOpenHelper.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidSQLiteOpenHelper.kt @@ -3,34 +3,35 @@ package com.raizlabs.dbflow5.database import android.content.Context import android.database.sqlite.SQLiteDatabase import android.database.sqlite.SQLiteOpenHelper - import com.raizlabs.dbflow5.config.DBFlowDatabase -import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.config.OpenHelperCreator /** * Description: Wraps around the [SQLiteOpenHelper] and provides extra features for use in this library. */ open class AndroidSQLiteOpenHelper( + private val context: Context, databaseDefinition: DBFlowDatabase, - listener: DatabaseHelperListener?) - : SQLiteOpenHelper(FlowManager.context, + listener: DatabaseCallback?) + : SQLiteOpenHelper(context, if (databaseDefinition.isInMemory) null else databaseDefinition.databaseFileName, null, databaseDefinition.databaseVersion), OpenHelper { private val databaseHelperDelegate: DatabaseHelperDelegate private var androidDatabase: AndroidDatabase? = null + private val _databaseName = databaseDefinition.databaseFileName init { var backupHelper: OpenHelper? = null if (databaseDefinition.backupEnabled()) { // Temp database mirrors existing - backupHelper = BackupHelper(FlowManager.context, + backupHelper = BackupHelper(context, DatabaseHelperDelegate.getTempDbFileName(databaseDefinition), databaseDefinition.databaseVersion, databaseDefinition) } - databaseHelperDelegate = DatabaseHelperDelegate(listener, databaseDefinition, backupHelper) + databaseHelperDelegate = DatabaseHelperDelegate(context, listener, databaseDefinition, backupHelper) } override fun performRestoreFromBackup() { @@ -59,10 +60,10 @@ open class AndroidSQLiteOpenHelper( * Set a listener to listen for specific DB events and perform an action before we execute this classes * specific methods. * - * @param helperListener + * @param callback */ - override fun setDatabaseListener(helperListener: DatabaseHelperListener?) { - databaseHelperDelegate.setDatabaseHelperListener(helperListener) + override fun setDatabaseListener(callback: DatabaseCallback?) { + databaseHelperDelegate.setDatabaseHelperListener(callback) } override fun onCreate(db: SQLiteDatabase) { @@ -85,6 +86,10 @@ open class AndroidSQLiteOpenHelper( androidDatabase?.database?.close() } + override fun deleteDB() { + context.deleteDatabase(_databaseName) + } + /** * Simple helper to manage backup. */ @@ -94,7 +99,8 @@ open class AndroidSQLiteOpenHelper( : SQLiteOpenHelper(context, name, null, version), OpenHelper { private var androidDatabase: AndroidDatabase? = null - private val baseDatabaseHelper: BaseDatabaseHelper = BaseDatabaseHelper(databaseDefinition) + private val baseDatabaseHelper: BaseDatabaseHelper = BaseDatabaseHelper(context, databaseDefinition) + private val _databaseName = databaseDefinition.databaseFileName override val database: DatabaseWrapper get() { @@ -114,7 +120,7 @@ open class AndroidSQLiteOpenHelper( override fun backupDB() {} - override fun setDatabaseListener(helperListener: DatabaseHelperListener?) {} + override fun setDatabaseListener(callback: DatabaseCallback?) {} override fun onCreate(db: SQLiteDatabase) { baseDatabaseHelper.onCreate(AndroidDatabase.from(db)) @@ -133,6 +139,19 @@ open class AndroidSQLiteOpenHelper( } override fun closeDB() = Unit + + override fun deleteDB() { + context.deleteDatabase(_databaseName) + } + } + + companion object { + @JvmStatic + fun createHelperCreator(context: Context): OpenHelperCreator = + { db: DBFlowDatabase, databaseCallback: DatabaseCallback? -> + AndroidSQLiteOpenHelper(context, db, databaseCallback) + } } } + diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/database/BaseDatabaseHelper.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/database/BaseDatabaseHelper.kt index 401ec618b..7065369cf 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/database/BaseDatabaseHelper.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/database/BaseDatabaseHelper.kt @@ -1,8 +1,8 @@ package com.raizlabs.dbflow5.database +import android.content.Context import com.raizlabs.dbflow5.config.DBFlowDatabase import com.raizlabs.dbflow5.config.FlowLog -import com.raizlabs.dbflow5.config.FlowManager import com.raizlabs.dbflow5.config.NaturalOrderComparator import java.io.IOException import java.io.InputStream @@ -10,7 +10,8 @@ import java.io.InputStream /** * Description: */ -open class BaseDatabaseHelper(val databaseDefinition: DBFlowDatabase) { +open class BaseDatabaseHelper(protected val context: Context, + val databaseDefinition: DBFlowDatabase) { open fun onCreate(db: DatabaseWrapper) { checkForeignKeySupport(db) @@ -92,7 +93,7 @@ open class BaseDatabaseHelper(val databaseDefinition: DBFlowDatabase) { // will try migrations file or execute migrations from code try { - val files: List = FlowManager.context.assets.list( + val files: List = context.assets.list( "$MIGRATION_PATH/${databaseDefinition.databaseName}") .sortedWith(NaturalOrderComparator()) @@ -159,7 +160,7 @@ open class BaseDatabaseHelper(val databaseDefinition: DBFlowDatabase) { private fun executeSqlScript(db: DatabaseWrapper, file: String) { try { - val input: InputStream = FlowManager.context.assets.open("$MIGRATION_PATH/${databaseDefinition.databaseName}/$file") + val input: InputStream = context.assets.open("$MIGRATION_PATH/${databaseDefinition.databaseName}/$file") // ends line with SQL val querySuffix = ";" diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseHelperListener.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseCallback.kt similarity index 96% rename from dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseHelperListener.kt rename to dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseCallback.kt index 59b0a0158..60fcf8123 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseHelperListener.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseCallback.kt @@ -3,7 +3,7 @@ package com.raizlabs.dbflow5.database /** * Description: Provides callbacks for [OpenHelper] methods */ -interface DatabaseHelperListener { +interface DatabaseCallback { /** * Called when the DB is opened diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseHelperDelegate.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseHelperDelegate.kt index f7fbadaff..1c2ff5649 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseHelperDelegate.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseHelperDelegate.kt @@ -1,5 +1,6 @@ package com.raizlabs.dbflow5.database +import android.content.Context import com.raizlabs.dbflow5.config.DBFlowDatabase import com.raizlabs.dbflow5.config.FlowLog import com.raizlabs.dbflow5.config.FlowManager @@ -15,10 +16,11 @@ import java.io.InputStream * used in other helper class definitions. */ class DatabaseHelperDelegate( - private var databaseHelperListener: DatabaseHelperListener?, + context: Context, + private var databaseCallback: DatabaseCallback?, databaseDefinition: DBFlowDatabase, private val backupHelper: OpenHelper?) - : BaseDatabaseHelper(databaseDefinition) { + : BaseDatabaseHelper(context, databaseDefinition) { /** * @return the temporary database file name for when we have backups enabled @@ -54,37 +56,37 @@ class DatabaseHelperDelegate( } /** - * @param databaseHelperListener Listens for operations the DB and allow you to provide extra + * @param databaseCallback Listens for operations the DB and allow you to provide extra * functionality. */ - fun setDatabaseHelperListener(databaseHelperListener: DatabaseHelperListener?) { - this.databaseHelperListener = databaseHelperListener + fun setDatabaseHelperListener(databaseCallback: DatabaseCallback?) { + this.databaseCallback = databaseCallback } override fun onCreate(db: DatabaseWrapper) { - if (databaseHelperListener != null) { - databaseHelperListener!!.onCreate(db) + if (databaseCallback != null) { + databaseCallback!!.onCreate(db) } super.onCreate(db) } override fun onUpgrade(db: DatabaseWrapper, oldVersion: Int, newVersion: Int) { - if (databaseHelperListener != null) { - databaseHelperListener!!.onUpgrade(db, oldVersion, newVersion) + if (databaseCallback != null) { + databaseCallback!!.onUpgrade(db, oldVersion, newVersion) } super.onUpgrade(db, oldVersion, newVersion) } override fun onOpen(db: DatabaseWrapper) { - if (databaseHelperListener != null) { - databaseHelperListener!!.onOpen(db) + if (databaseCallback != null) { + databaseCallback!!.onOpen(db) } super.onOpen(db) } override fun onDowngrade(db: DatabaseWrapper, oldVersion: Int, newVersion: Int) { - if (databaseHelperListener != null) { - databaseHelperListener!!.onDowngrade(db, oldVersion, newVersion) + if (databaseCallback != null) { + databaseCallback!!.onDowngrade(db, oldVersion, newVersion) } super.onDowngrade(db, oldVersion, newVersion) } @@ -97,7 +99,7 @@ class DatabaseHelperDelegate( * @param prepackagedName The name of the prepackaged db file */ fun movePrepackagedDB(databaseName: String, prepackagedName: String) { - val dbPath = FlowManager.context.getDatabasePath(databaseName) + val dbPath = context.getDatabasePath(databaseName) // If the database already exists, and is ok return if (dbPath.exists() && (!databaseDefinition.areConsistencyChecksEnabled() || databaseDefinition.areConsistencyChecksEnabled() && isDatabaseIntegrityOk(writableDatabase))) { @@ -110,14 +112,14 @@ class DatabaseHelperDelegate( // Try to copy database file try { // check existing and use that as backup - val existingDb = FlowManager.context.getDatabasePath(tempDbFileName) + val existingDb = context.getDatabasePath(tempDbFileName) val inputStream: InputStream // if it exists and the integrity is ok we use backup as the main DB is no longer valid if (existingDb.exists() && (!databaseDefinition.backupEnabled() || (databaseDefinition.backupEnabled() && backupHelper != null && isDatabaseIntegrityOk(backupHelper.database)))) { inputStream = FileInputStream(existingDb) } else { - inputStream = FlowManager.context.assets.open(prepackagedName) + inputStream = context.assets.open(prepackagedName) } writeDB(dbPath, inputStream) @@ -164,8 +166,8 @@ class DatabaseHelperDelegate( fun restoreBackUp(): Boolean { var success = true - val db = FlowManager.context.getDatabasePath(TEMP_DB_NAME + databaseDefinition.databaseName) - val corrupt = FlowManager.context.getDatabasePath(databaseDefinition.databaseName) + val db = context.getDatabasePath(TEMP_DB_NAME + databaseDefinition.databaseName) + val corrupt = context.getDatabasePath(databaseDefinition.databaseName) if (corrupt.delete()) { try { writeDB(corrupt, FileInputStream(db)) @@ -211,7 +213,7 @@ class DatabaseHelperDelegate( * @param prepackagedName The name of the prepackaged db file */ fun restoreDatabase(databaseName: String, prepackagedName: String) { - val dbPath = FlowManager.context.getDatabasePath(databaseName) + val dbPath = context.getDatabasePath(databaseName) // If the database already exists, return if (dbPath.exists()) { @@ -224,14 +226,14 @@ class DatabaseHelperDelegate( // Try to copy database file try { // check existing and use that as backup - val existingDb = FlowManager.context.getDatabasePath(databaseDefinition.databaseFileName) + val existingDb = context.getDatabasePath(databaseDefinition.databaseFileName) val inputStream: InputStream // if it exists and the integrity is ok if (existingDb.exists() && (databaseDefinition.backupEnabled() && backupHelper != null && isDatabaseIntegrityOk(backupHelper.database))) { inputStream = FileInputStream(existingDb) } else { - inputStream = FlowManager.context.assets.open(prepackagedName) + inputStream = context.assets.open(prepackagedName) } writeDB(dbPath, inputStream) } catch (e: IOException) { @@ -252,7 +254,6 @@ class DatabaseHelperDelegate( } databaseDefinition.executeTransactionAsync({ - val context = FlowManager.context val backup = context.getDatabasePath(tempDbFileName) val temp = context.getDatabasePath(TEMP_DB_NAME + "-2-" + databaseDefinition.databaseFileName) diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/database/OpenHelper.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/database/OpenHelper.kt index 80356a322..e233c3206 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/database/OpenHelper.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/database/OpenHelper.kt @@ -1,8 +1,5 @@ package com.raizlabs.dbflow5.database -import android.os.Build -import android.support.annotation.RequiresApi - /** * Description: Abstracts out the [DatabaseHelperDelegate] into the one used in this library. */ @@ -20,7 +17,9 @@ interface OpenHelper { fun backupDB() - fun setDatabaseListener(helperListener: DatabaseHelperListener?) + fun setDatabaseListener(callback: DatabaseCallback?) fun closeDB() + + fun deleteDB() } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/provider/BaseProviderModel.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/provider/BaseProviderModel.kt index 7445c61af..7ed49524d 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/provider/BaseProviderModel.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/provider/BaseProviderModel.kt @@ -16,10 +16,10 @@ import com.raizlabs.dbflow5.structure.Model */ abstract class BaseProviderModel : BaseModel(), ModelProvider { - override fun delete(wrapper: DatabaseWrapper): Boolean = ContentUtils.delete(deleteUri, this) > 0 + override fun delete(wrapper: DatabaseWrapper): Boolean = ContentUtils.delete(FlowManager.context, deleteUri, this) > 0 override fun save(wrapper: DatabaseWrapper): Boolean { - val count = ContentUtils.update(updateUri, this) + val count = ContentUtils.update(FlowManager.context, updateUri, this) return if (count == 0) { insert(wrapper) > 0 } else { @@ -28,10 +28,10 @@ abstract class BaseProviderModel : BaseModel(), ModelProvider { } override fun update(wrapper: DatabaseWrapper): Boolean - = ContentUtils.update(updateUri, this) > 0 + = ContentUtils.update(FlowManager.context, updateUri, this) > 0 override fun insert(wrapper: DatabaseWrapper): Long - = if (ContentUtils.insert(insertUri, wrapper) != null) 1 else 0 + = if (ContentUtils.insert(FlowManager.context, insertUri, this) != null) 1 else 0 /** * Runs a query on the [ContentProvider] to see if it returns data. diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/provider/BaseSyncableProviderModel.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/provider/BaseSyncableProviderModel.kt index f2ef03a41..5524cd18f 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/provider/BaseSyncableProviderModel.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/provider/BaseSyncableProviderModel.kt @@ -16,23 +16,23 @@ abstract class BaseSyncableProviderModel : BaseModel(), ModelProvider { override fun insert(wrapper: DatabaseWrapper): Long { val rowId = super.insert(wrapper) - ContentUtils.insert(insertUri, wrapper) + ContentUtils.insert(FlowManager.context, insertUri, this) return rowId } override fun save(wrapper: DatabaseWrapper): Boolean { return if (exists(wrapper)) { - super.save(wrapper) && ContentUtils.update(updateUri, wrapper) > 0 + super.save(wrapper) && ContentUtils.update(FlowManager.context, updateUri, this) > 0 } else { - super.save(wrapper) && ContentUtils.insert(insertUri, wrapper) != null + super.save(wrapper) && ContentUtils.insert(FlowManager.context, insertUri, this) != null } } override fun delete(wrapper: DatabaseWrapper): Boolean - = super.delete(wrapper) && ContentUtils.delete(deleteUri, wrapper) > 0 + = super.delete(wrapper) && ContentUtils.delete(FlowManager.context, deleteUri, wrapper) > 0 override fun update(wrapper: DatabaseWrapper): Boolean - = super.update(wrapper) && ContentUtils.update(updateUri, wrapper) > 0 + = super.update(wrapper) && ContentUtils.update(FlowManager.context, updateUri, wrapper) > 0 @Suppress("UNCHECKED_CAST") override fun load(whereOperatorGroup: OperatorGroup, diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/provider/ContentUtils.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/provider/ContentUtils.kt index c92ee6098..7e8cf2e10 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/provider/ContentUtils.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/provider/ContentUtils.kt @@ -2,6 +2,7 @@ package com.raizlabs.dbflow5.provider import android.content.ContentResolver import android.content.ContentValues +import android.content.Context import android.net.Uri import com.raizlabs.dbflow5.adapter.ModelAdapter import com.raizlabs.dbflow5.annotation.provider.ContentProvider @@ -59,14 +60,14 @@ object ContentUtils { * @return A Uri of the inserted data. */ @JvmStatic - fun insert(insertUri: Uri, model: TableClass): Uri? = - insert(FlowManager.context.contentResolver, insertUri, model) + fun insert(context: Context, insertUri: Uri, model: TableClass): Uri? = + insert(context.contentResolver, insertUri, model) /** * Inserts the model into the [android.content.ContentResolver]. Uses the insertUri to resolve * the reference and the model to convert its data into [android.content.ContentValues] * - * @param contentResolver The content resolver to use (if different from [FlowManager.getContext]) + * @param contentResolver The content resolver to use * @param insertUri A [android.net.Uri] from the [ContentProvider] class definition. * @param model The model to insert. * @return The Uri of the inserted data. @@ -90,7 +91,7 @@ object ContentUtils { * autoIncrementing primary keys the ROWID will not be properly updated from this method. If you care * use [.insert] instead. * - * @param contentResolver The content resolver to use (if different from [FlowManager.getContext]) + * @param contentResolver The content resolver to use * @param bulkInsertUri The URI to bulk insert with * @param table The table to insert into * @param models The models to insert. @@ -124,8 +125,11 @@ object ContentUtils { * @return The count of the rows affected by the insert. */ @JvmStatic - fun bulkInsert(bulkInsertUri: Uri, table: Class, models: List): Int = - bulkInsert(FlowManager.context.contentResolver, bulkInsertUri, table, models) + fun bulkInsert(context: Context, + bulkInsertUri: Uri, + table: Class, + models: List): Int = + bulkInsert(context.contentResolver, bulkInsertUri, table, models) /** * Updates the model through the [android.content.ContentResolver]. Uses the updateUri to @@ -136,25 +140,29 @@ object ContentUtils { * @return The number of rows updated. */ @JvmStatic - fun update(updateUri: Uri, model: TableClass): Int = - update(FlowManager.context.contentResolver, updateUri, model) + fun update(context: Context, + updateUri: Uri, + model: TableClass): Int = + update(context.contentResolver, updateUri, model) /** * Updates the model through the [android.content.ContentResolver]. Uses the updateUri to * resolve the reference and the model to convert its data in [android.content.ContentValues] * - * @param contentResolver The content resolver to use (if different from [FlowManager.getContext]) + * @param contentResolver The content resolver to use * @param updateUri A [android.net.Uri] from the [ContentProvider] * @param model The model to update * @return The number of rows updated. */ @JvmStatic - fun update(contentResolver: ContentResolver, updateUri: Uri, model: TableClass): Int { + fun update(contentResolver: ContentResolver, + updateUri: Uri, model: TableClass): Int { val adapter = FlowManager.getModelAdapter(model.javaClass) val contentValues = ContentValues() adapter.bindToContentValues(contentValues, model) - val count = contentResolver.update(updateUri, contentValues, adapter.getPrimaryConditionClause(model).query, null) + val count = contentResolver.update(updateUri, contentValues, + adapter.getPrimaryConditionClause(model).query, null) if (count == 0) { FlowLog.log(FlowLog.Level.W, "Updated failed of: " + model.javaClass) } @@ -170,14 +178,14 @@ object ContentUtils { * @return The number of rows deleted. */ @JvmStatic - fun delete(deleteUri: Uri, model: TableClass): Int = - delete(FlowManager.context.contentResolver, deleteUri, model) + fun delete(context: Context, deleteUri: Uri, model: TableClass): Int = + delete(context.contentResolver, deleteUri, model) /** * Deletes the specified model through the [android.content.ContentResolver]. Uses the deleteUri * to resolve the reference and the model to [ModelAdapter.getPrimaryConditionClause] * - * @param contentResolver The content resolver to use (if different from [FlowManager.getContext]) + * @param contentResolver The content resolver to use * @param deleteUri A [android.net.Uri] from the [ContentProvider] * @param model The model to delete * @return The number of rows deleted. @@ -201,7 +209,7 @@ object ContentUtils { * Queries the [android.content.ContentResolver] with the specified query uri. It generates * the correct query and returns a [android.database.Cursor] * - * @param contentResolver The content resolver to use (if different from [FlowManager.getContext]) + * @param contentResolver The content resolver to use * @param queryUri The URI of the query * @param whereConditions The set of [Operator] to query the content provider. * @param orderBy The order by clause without the ORDER BY @@ -226,11 +234,12 @@ object ContentUtils { * @return A list of [TableClass] */ @JvmStatic - fun queryList(queryUri: Uri, table: Class, + fun queryList(context: Context, + queryUri: Uri, table: Class, databaseWrapper: DatabaseWrapper, whereConditions: OperatorGroup, orderBy: String, vararg columns: String): List? = - queryList(FlowManager.context.contentResolver, queryUri, table, + queryList(context.contentResolver, queryUri, table, databaseWrapper, whereConditions, orderBy, *columns) @@ -238,7 +247,7 @@ object ContentUtils { * Queries the [android.content.ContentResolver] with the specified queryUri. It will generate * the correct query and return a list of [TableClass] * - * @param contentResolver The content resolver to use (if different from [FlowManager.getContext]) + * @param contentResolver The content resolver to use * @param queryUri The URI of the query * @param table The table to get from. * @param whereConditions The set of [Operator] to query the content provider. @@ -270,18 +279,19 @@ object ContentUtils { * @return The first [TableClass] of the list query from the content provider. */ @JvmStatic - fun querySingle(queryUri: Uri, table: Class, + fun querySingle(context: Context, + queryUri: Uri, table: Class, databaseWrapper: DatabaseWrapper, whereConditions: OperatorGroup, orderBy: String, vararg columns: String): TableClass? = - querySingle(FlowManager.context.contentResolver, queryUri, table, + querySingle(context.contentResolver, queryUri, table, databaseWrapper, whereConditions, orderBy, *columns) /** * Queries the [android.content.ContentResolver] with the specified queryUri. It will generate * the correct query and return a the first item from the list of [TableClass] * - * @param contentResolver The content resolver to use (if different from [FlowManager.getContext]) + * @param contentResolver The content resolver to use * @param queryUri The URI of the query * @param table The table to get from * @param whereConditions The set of [Operator] to query the content provider. diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/ContentResolverNotifier.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/ContentResolverNotifier.kt index 901ce73e9..280f4d1b4 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/ContentResolverNotifier.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/ContentResolverNotifier.kt @@ -1,8 +1,8 @@ package com.raizlabs.dbflow5.runtime import android.content.ContentResolver +import android.content.Context import com.raizlabs.dbflow5.adapter.ModelAdapter -import com.raizlabs.dbflow5.config.FlowManager import com.raizlabs.dbflow5.getNotificationUri import com.raizlabs.dbflow5.query.SQLOperator import com.raizlabs.dbflow5.structure.ChangeAction @@ -13,30 +13,28 @@ import com.raizlabs.dbflow5.structure.ChangeAction * @param [authority] Specify the content URI authority you wish to use here. This will get propagated * everywhere that changes get called from in a specific database. */ -class ContentResolverNotifier(val authority: String) : ModelNotifier { +class ContentResolverNotifier(private val context: Context, + val authority: String) : ModelNotifier { override fun notifyModelChanged(model: T, adapter: ModelAdapter, action: ChangeAction) { if (FlowContentObserver.shouldNotify()) { - FlowManager.context.contentResolver - .notifyChange(getNotificationUri(authority, - adapter.table, action, - adapter.getPrimaryConditionClause(model).conditions), - null, true) + context.contentResolver.notifyChange( + getNotificationUri(authority, adapter.table, action, + adapter.getPrimaryConditionClause(model).conditions), null, true) } } override fun notifyTableChanged(table: Class, action: ChangeAction) { if (FlowContentObserver.shouldNotify()) { - FlowManager.context.contentResolver - .notifyChange(getNotificationUri(authority, table, action, - null as Array?), null, true) + context.contentResolver.notifyChange( + getNotificationUri(authority, table, action, null as Array?), null, true) } } - override fun newRegister(): TableNotifierRegister = FlowContentTableNotifierRegister(authority) + override fun newRegister(): TableNotifierRegister = FlowContentTableNotifierRegister(context, authority) - class FlowContentTableNotifierRegister(contentAuthority: String) : TableNotifierRegister { + class FlowContentTableNotifierRegister(private val context: Context, contentAuthority: String) : TableNotifierRegister { private val flowContentObserver = FlowContentObserver(contentAuthority) @@ -53,11 +51,11 @@ class ContentResolverNotifier(val authority: String) : ModelNotifier { } override fun register(tClass: Class) { - flowContentObserver.registerForContentChanges(FlowManager.context, tClass) + flowContentObserver.registerForContentChanges(context, tClass) } override fun unregister(tClass: Class) { - flowContentObserver.unregisterForContentChanges(FlowManager.context) + flowContentObserver.unregisterForContentChanges(context) } override fun unregisterAll() { diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/FlowContentObserver.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/FlowContentObserver.kt index 4b3fac538..427b4c7e2 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/FlowContentObserver.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/FlowContentObserver.kt @@ -10,6 +10,7 @@ import android.os.Build.VERSION_CODES import android.os.Handler import com.raizlabs.dbflow5.TABLE_QUERY_PARAM import com.raizlabs.dbflow5.config.DatabaseConfig +import com.raizlabs.dbflow5.config.FlowLog import com.raizlabs.dbflow5.config.FlowManager import com.raizlabs.dbflow5.getNotificationUri import com.raizlabs.dbflow5.query.NameAlias @@ -222,27 +223,33 @@ open class FlowContentObserver(private val contentAuthority: String, } val table = registeredTables[tableName] - var action = ChangeAction.valueOf(fragment) - if (!isInTransaction) { - modelChangeListeners.forEach { it.onModelStateChanged(table, action, columnsChanged.toTypedArray()) } + if (table != null) { + var action = ChangeAction.valueOf(fragment) + if (!isInTransaction) { + modelChangeListeners.forEach { + it.onModelStateChanged(table, action, columnsChanged.toTypedArray()) + } - if (!calledInternally) { - onTableChangedListeners.forEach { it.onTableChanged(table, action) } - } - } else { - // convert this uri to a CHANGE op if we don't care about individual changes. - if (!notifyAllUris) { - action = ChangeAction.CHANGE - uri = getNotificationUri(contentAuthority, table!!, action) - } - synchronized(notificationUris) { - // add and keep track of unique notification uris for when transaction completes. - notificationUris.add(uri) - } + if (!calledInternally) { + onTableChangedListeners.forEach { it.onTableChanged(table, action) } + } + } else { + // convert this uri to a CHANGE op if we don't care about individual changes. + if (!notifyAllUris) { + action = ChangeAction.CHANGE + uri = getNotificationUri(contentAuthority, table, action) + } + synchronized(notificationUris) { + // add and keep track of unique notification uris for when transaction completes. + notificationUris.add(uri) + } - synchronized(tableUris) { - tableUris.add(getNotificationUri(contentAuthority, table!!, action)) + synchronized(tableUris) { + tableUris.add(getNotificationUri(contentAuthority, table, action)) + } } + } else { + FlowLog.log(FlowLog.Level.W, "Received URI change for unregistered table $tableName . URI ignored.") } } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/structure/BaseModel.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/structure/BaseModel.kt index 999ff3321..6316f0a40 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/structure/BaseModel.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/structure/BaseModel.kt @@ -9,7 +9,6 @@ import com.raizlabs.dbflow5.database.DatabaseWrapper * Description: The base implementation of [Model]. It is recommended to use this class as * the base for your [Model], but it is not required. */ -@Deprecated("No subclass needed. Use extension methods instead") open class BaseModel : Model { /** @@ -24,9 +23,9 @@ open class BaseModel : Model { @Suppress("UNCHECKED_CAST") override fun load(wrapper: DatabaseWrapper): T? = modelAdapter.load(this, wrapper) as T? - override fun save(wrapper: DatabaseWrapper): Boolean = modelAdapter.save(this@BaseModel, wrapper) + override fun save(wrapper: DatabaseWrapper): Boolean = modelAdapter.save(this, wrapper) - override fun delete(wrapper: DatabaseWrapper): Boolean = modelAdapter.delete(this@BaseModel, wrapper) + override fun delete(wrapper: DatabaseWrapper): Boolean = modelAdapter.delete(this, wrapper) override fun update(wrapper: DatabaseWrapper): Boolean = modelAdapter.update(this, wrapper) diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/structure/BaseModelView.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/structure/BaseModelView.kt index 3007593a0..601d7c6fb 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/structure/BaseModelView.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/structure/BaseModelView.kt @@ -8,5 +8,4 @@ import com.raizlabs.dbflow5.annotation.ModelViewQuery * annotation to register it properly. Also you need to specify a singular * field via [ModelViewQuery]. */ -@Deprecated("No subclass needed. Use extension methods and modeladapters") abstract class BaseModelView : NoModificationModel() diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/structure/BaseQueryModel.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/structure/BaseQueryModel.kt index 587b3ec7b..c810e7e7e 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/structure/BaseQueryModel.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/structure/BaseQueryModel.kt @@ -6,7 +6,6 @@ import com.raizlabs.dbflow5.database.DatabaseWrapper /** * Description: Provides a base class for objects that represent [QueryModel]. */ -@Deprecated("No subclass needed. Use extension methods instead.") class BaseQueryModel : NoModificationModel() { override fun exists(wrapper: DatabaseWrapper): Boolean { diff --git a/usage2/Databases.md b/usage2/Databases.md index 7f9bcef59..a3d507415 100644 --- a/usage2/Databases.md +++ b/usage2/Databases.md @@ -225,8 +225,8 @@ FlowManager.init(FlowConfig.builder(context) DatabaseConfig.builder(CipherDatabase.class) .openHelper(new DatabaseConfig.OpenHelperCreator() { @Override - public OpenHelper createHelper(DatabaseDefinition databaseDefinition, DatabaseHelperListener helperListener) { - return new CustomFlowSQliteOpenHelper(databaseDefinition, helperListener); + public OpenHelper createHelper(DatabaseDefinition databaseDefinition, DatabaseHelperListener callback) { + return new CustomFlowSQliteOpenHelper(databaseDefinition, callback); } }) .build()) diff --git a/usage2/SQLCipherSupport.md b/usage2/SQLCipherSupport.md index 739b3cb0f..a2a3fe873 100644 --- a/usage2/SQLCipherSupport.md +++ b/usage2/SQLCipherSupport.md @@ -45,8 +45,8 @@ FlowManager.init(new FlowConfig.Builder(this) new DatabaseConfig.Builder(CipherDatabase.class) .openHelper(new DatabaseConfig.OpenHelperCreator() { @Override - public OpenHelper createHelper(DatabaseDefinition databaseDefinition, DatabaseHelperListener helperListener) { - return new SQLCipherHelperImpl(databaseDefinition, helperListener); + public OpenHelper createHelper(DatabaseDefinition databaseDefinition, DatabaseHelperListener callback) { + return new SQLCipherHelperImpl(databaseDefinition, callback); } }) .build()) From c3edb6b1a68494d0aba42be85d5a9d72aae43a05 Mon Sep 17 00:00:00 2001 From: fuzzagrosner Date: Tue, 5 Dec 2017 17:45:14 -0500 Subject: [PATCH 135/234] [db] fix compile. --- .../dbflow5/sqlcipher/SQLCipherOpenHelper.kt | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherOpenHelper.kt b/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherOpenHelper.kt index c5365f9a5..bc7b524e8 100644 --- a/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherOpenHelper.kt +++ b/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherOpenHelper.kt @@ -16,7 +16,7 @@ import net.sqlcipher.database.SQLiteOpenHelper * of your database to get it to work with specifying the secret you use for the databaseForTable. */ abstract class SQLCipherOpenHelper( - context: Context, + private val context: Context, databaseDefinition: DBFlowDatabase, listener: DatabaseCallback?) : SQLiteOpenHelper(context, if (databaseDefinition.isInMemory) null else databaseDefinition.databaseFileName, @@ -24,6 +24,7 @@ abstract class SQLCipherOpenHelper( final override val delegate: DatabaseHelperDelegate private var cipherDatabase: SQLCipherDatabase? = null + private val _databaseName = databaseDefinition.databaseFileName override val isDatabaseIntegrityOk: Boolean get() = delegate.isDatabaseIntegrityOk @@ -94,10 +95,14 @@ abstract class SQLCipherOpenHelper( cipherDatabase?.database?.close() } + override fun deleteDB() { + context.deleteDatabase(_databaseName) + } + /** * Simple helper to manage backup. */ - private inner class BackupHelper(context: Context, + private inner class BackupHelper(private val context: Context, name: String, version: Int, databaseDefinition: DBFlowDatabase) @@ -105,6 +110,7 @@ abstract class SQLCipherOpenHelper( private var sqlCipherDatabase: SQLCipherDatabase? = null private val baseDatabaseHelper: BaseDatabaseHelper = BaseDatabaseHelper(context, databaseDefinition) + private val _databaseName = databaseDefinition.databaseFileName override val database: DatabaseWrapper get() { @@ -141,6 +147,10 @@ abstract class SQLCipherOpenHelper( } override fun setWriteAheadLoggingEnabled(enabled: Boolean) = Unit + + override fun deleteDB() { + context.deleteDatabase(_databaseName) + } } } From c1a81fabd35c257fc5ba11d0d54630b9adac9b0f Mon Sep 17 00:00:00 2001 From: fuzzagrosner Date: Tue, 5 Dec 2017 17:56:33 -0500 Subject: [PATCH 136/234] [db] replace FlowManager with extensions in internal lib. --- .../dbflow5/rx/structure/RXModelAdapter.kt | 38 +++++++++---------- .../dbflow5/rx2/structure/RXModelAdapter.kt | 38 +++++++++---------- .../contentobserver/ContentObserverTest.kt | 10 ++--- .../dbflow5/config/ConfigIntegrationTest.kt | 2 +- .../raizlabs/dbflow5/config/DBFlowDatabase.kt | 4 +- .../raizlabs/dbflow5/config/FlowManager.kt | 21 +++++++++- .../raizlabs/dbflow5/provider/ContentUtils.kt | 12 +++--- .../dbflow5/query/BaseModelQueriable.kt | 7 ++-- .../raizlabs/dbflow5/query/CursorResult.kt | 14 +++---- .../java/com/raizlabs/dbflow5/query/Insert.kt | 5 ++- .../raizlabs/dbflow5/structure/BaseModel.kt | 3 +- 11 files changed, 88 insertions(+), 66 deletions(-) diff --git a/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/structure/RXModelAdapter.kt b/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/structure/RXModelAdapter.kt index ed8414c8d..f12bcff32 100644 --- a/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/structure/RXModelAdapter.kt +++ b/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/structure/RXModelAdapter.kt @@ -1,7 +1,7 @@ package com.raizlabs.dbflow5.rx.structure -import com.raizlabs.dbflow5.config.FlowManager import com.raizlabs.dbflow5.adapter.ModelAdapter +import com.raizlabs.dbflow5.config.modelAdapter import com.raizlabs.dbflow5.database.DatabaseWrapper import rx.Completable import rx.Single @@ -12,19 +12,19 @@ import rx.Single class RXModelAdapter internal constructor(private val modelAdapter: ModelAdapter) : RXRetrievalAdapter(modelAdapter) { - constructor(table: Class) : this(FlowManager.getModelAdapter(table)) + constructor(table: Class) : this(table.modelAdapter) fun save(model: T, databaseWrapper: DatabaseWrapper): Single = - Single.fromCallable { modelAdapter.save(model, databaseWrapper) } + Single.fromCallable { modelAdapter.save(model, databaseWrapper) } fun saveAll(models: Collection, databaseWrapper: DatabaseWrapper): Completable = - Completable.fromCallable { - modelAdapter.saveAll(models, databaseWrapper) - null - } + Completable.fromCallable { + modelAdapter.saveAll(models, databaseWrapper) + null + } fun insert(model: T, databaseWrapper: DatabaseWrapper): Single = - Single.fromCallable { modelAdapter.insert(model, databaseWrapper) } + Single.fromCallable { modelAdapter.insert(model, databaseWrapper) } fun insertAll(models: Collection, databaseWrapper: DatabaseWrapper): Completable = Completable.fromCallable { @@ -33,28 +33,28 @@ class RXModelAdapter internal constructor(private val modelAdapter: Mod } fun update(model: T, databaseWrapper: DatabaseWrapper): Single = - Single.fromCallable { modelAdapter.update(model, databaseWrapper) } + Single.fromCallable { modelAdapter.update(model, databaseWrapper) } fun updateAll(models: Collection, databaseWrapper: DatabaseWrapper): Completable = - Completable.fromCallable { - modelAdapter.updateAll(models, databaseWrapper) - null - } + Completable.fromCallable { + modelAdapter.updateAll(models, databaseWrapper) + null + } fun delete(model: T, databaseWrapper: DatabaseWrapper): Single = - Single.fromCallable { modelAdapter.delete(model, databaseWrapper) } + Single.fromCallable { modelAdapter.delete(model, databaseWrapper) } fun deleteAll(models: Collection, databaseWrapper: DatabaseWrapper): Completable = - Completable.fromCallable { - modelAdapter.deleteAll(models, databaseWrapper) - null - } + Completable.fromCallable { + modelAdapter.deleteAll(models, databaseWrapper) + null + } companion object { @JvmStatic fun from(modelAdapter: ModelAdapter): RXModelAdapter = - RXModelAdapter(modelAdapter) + RXModelAdapter(modelAdapter) @JvmStatic fun from(table: Class): RXModelAdapter = RXModelAdapter(table) diff --git a/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/structure/RXModelAdapter.kt b/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/structure/RXModelAdapter.kt index 65cc8b733..df9f65b55 100644 --- a/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/structure/RXModelAdapter.kt +++ b/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/structure/RXModelAdapter.kt @@ -1,7 +1,7 @@ package com.raizlabs.dbflow5.rx2.structure -import com.raizlabs.dbflow5.config.FlowManager import com.raizlabs.dbflow5.adapter.ModelAdapter +import com.raizlabs.dbflow5.config.modelAdapter import com.raizlabs.dbflow5.database.DatabaseWrapper import io.reactivex.Completable import io.reactivex.Completable.fromCallable @@ -13,19 +13,19 @@ import io.reactivex.Single class RXModelAdapter internal constructor(private val modelAdapter: ModelAdapter) : RXRetrievalAdapter(modelAdapter) { - constructor(table: Class) : this(FlowManager.getModelAdapter(table)) + constructor(table: Class) : this(table.modelAdapter) fun save(model: T, databaseWrapper: DatabaseWrapper): Single = - Single.fromCallable { modelAdapter.save(model, databaseWrapper) } + Single.fromCallable { modelAdapter.save(model, databaseWrapper) } fun saveAll(models: Collection, databaseWrapper: DatabaseWrapper): Completable = - fromCallable { - modelAdapter.saveAll(models, databaseWrapper) - null - } + fromCallable { + modelAdapter.saveAll(models, databaseWrapper) + null + } fun insert(model: T, databaseWrapper: DatabaseWrapper): Single = - Single.fromCallable { modelAdapter.insert(model, databaseWrapper) } + Single.fromCallable { modelAdapter.insert(model, databaseWrapper) } fun insertAll(models: Collection, databaseWrapper: DatabaseWrapper): Completable = fromCallable { @@ -34,28 +34,28 @@ class RXModelAdapter internal constructor(private val modelAdapter: Mod } fun update(model: T, databaseWrapper: DatabaseWrapper): Single = - Single.fromCallable { modelAdapter.update(model, databaseWrapper) } + Single.fromCallable { modelAdapter.update(model, databaseWrapper) } fun updateAll(models: Collection, databaseWrapper: DatabaseWrapper): Completable = - fromCallable { - modelAdapter.updateAll(models, databaseWrapper) - null - } + fromCallable { + modelAdapter.updateAll(models, databaseWrapper) + null + } fun delete(model: T, databaseWrapper: DatabaseWrapper): Single = - Single.fromCallable { modelAdapter.delete(model, databaseWrapper) } + Single.fromCallable { modelAdapter.delete(model, databaseWrapper) } fun deleteAll(models: Collection, databaseWrapper: DatabaseWrapper): Completable = - fromCallable { - modelAdapter.deleteAll(models, databaseWrapper) - null - } + fromCallable { + modelAdapter.deleteAll(models, databaseWrapper) + null + } companion object { @JvmStatic fun from(modelAdapter: ModelAdapter): RXModelAdapter = - RXModelAdapter(modelAdapter) + RXModelAdapter(modelAdapter) @JvmStatic fun from(table: Class): RXModelAdapter = RXModelAdapter(table) diff --git a/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/contentobserver/ContentObserverTest.kt b/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/contentobserver/ContentObserverTest.kt index 3f48d7a40..27949e623 100644 --- a/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/contentobserver/ContentObserverTest.kt +++ b/dbflow-tests/src/androidTest/java/com/raizlabs/dbflow5/contentobserver/ContentObserverTest.kt @@ -4,8 +4,8 @@ import android.net.Uri import com.raizlabs.dbflow5.BaseInstrumentedUnitTest import com.raizlabs.dbflow5.DemoApp import com.raizlabs.dbflow5.TABLE_QUERY_PARAM -import com.raizlabs.dbflow5.config.FlowManager import com.raizlabs.dbflow5.config.databaseForTable +import com.raizlabs.dbflow5.config.modelAdapter import com.raizlabs.dbflow5.config.tableName import com.raizlabs.dbflow5.contentobserver.User_Table.id import com.raizlabs.dbflow5.contentobserver.User_Table.name @@ -39,11 +39,11 @@ class ContentObserverTest : BaseInstrumentedUnitTest() { @Test fun testSpecificUris() { - val conditionGroup = FlowManager.getModelAdapter(User::class.java) - .getPrimaryConditionClause(user) + val conditionGroup = User::class.modelAdapter + .getPrimaryConditionClause(user) val uri = getNotificationUri(contentUri, - User::class.java, ChangeAction.DELETE, - conditionGroup.conditions.toTypedArray()) + User::class.java, ChangeAction.DELETE, + conditionGroup.conditions.toTypedArray()) assertEquals(uri.authority, contentUri) assertEquals(tableName(), uri.getQueryParameter(TABLE_QUERY_PARAM)) diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/config/ConfigIntegrationTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/config/ConfigIntegrationTest.kt index f4b46977d..e1c3f6d52 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/config/ConfigIntegrationTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/config/ConfigIntegrationTest.kt @@ -69,7 +69,7 @@ class ConfigIntegrationTest : BaseUnitTest() { assertEquals(config.listModelLoader, customListModelLoader) assertEquals(config.singleModelLoader, singleModelLoader) - val modelAdapter = FlowManager.getModelAdapter(SimpleModel::class.java) + val modelAdapter = SimpleModel::class.modelAdapter assertEquals(modelAdapter.listModelLoader, customListModelLoader) assertEquals(modelAdapter.singleModelLoader, singleModelLoader) assertEquals(modelAdapter.modelSaver, modelSaver) diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/config/DBFlowDatabase.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/config/DBFlowDatabase.kt index 5e300d328..a5693dddb 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/config/DBFlowDatabase.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/config/DBFlowDatabase.kt @@ -378,7 +378,9 @@ abstract class DBFlowDatabase : DatabaseWrapper { if (!isResetting) { isResetting = true close() - openHelper.deleteDB() + if (isOpened) { + openHelper.deleteDB() + } _openHelper = null isOpened = false isResetting = false diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowManager.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowManager.kt index bc221ce28..9d9f610aa 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowManager.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowManager.kt @@ -472,12 +472,31 @@ inline fun tableName(): String */ inline fun modelAdapter() = FlowManager.getModelAdapter(T::class.java) +inline val KClass.modelAdapter + get() = FlowManager.getModelAdapter(this.java) + + +inline val Class.modelAdapter + get() = FlowManager.getModelAdapter(this) + /** * Easily get its [QueryModelAdapter]. */ inline fun queryModelAdapter() = FlowManager.getQueryModelAdapter(T::class.java) +inline val KClass.queryModelAdapter + get() = FlowManager.getQueryModelAdapter(this.java) + +inline val Class.queryModelAdapter + get() = FlowManager.getQueryModelAdapter(this) + /** * Easily get its [ModelViewAdapter] */ -inline fun modelViewAdapter() = FlowManager.getModelViewAdapter(T::class.java) \ No newline at end of file +inline fun modelViewAdapter() = FlowManager.getModelViewAdapter(T::class.java) + +inline val KClass.modelViewAdapter + get() = FlowManager.getModelViewAdapter(this.java) + +inline val Class.modelViewAdapter + get() = FlowManager.getModelViewAdapter(this) \ No newline at end of file diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/provider/ContentUtils.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/provider/ContentUtils.kt index 7e8cf2e10..b4b537416 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/provider/ContentUtils.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/provider/ContentUtils.kt @@ -7,7 +7,7 @@ import android.net.Uri import com.raizlabs.dbflow5.adapter.ModelAdapter import com.raizlabs.dbflow5.annotation.provider.ContentProvider import com.raizlabs.dbflow5.config.FlowLog -import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.config.modelAdapter import com.raizlabs.dbflow5.database.DatabaseWrapper import com.raizlabs.dbflow5.database.FlowCursor import com.raizlabs.dbflow5.query.Operator @@ -74,7 +74,7 @@ object ContentUtils { */ @JvmStatic fun insert(contentResolver: ContentResolver, insertUri: Uri, model: TableClass): Uri? { - val adapter = FlowManager.getModelAdapter(model.javaClass) + val adapter = model.javaClass.modelAdapter val contentValues = ContentValues() adapter.bindToInsertValues(contentValues, model) @@ -101,7 +101,7 @@ object ContentUtils { fun bulkInsert(contentResolver: ContentResolver, bulkInsertUri: Uri, table: Class, models: List?): Int { val contentValues = arrayListOf() - val adapter = FlowManager.getModelAdapter(table) + val adapter = table.modelAdapter if (models != null) { for (i in contentValues.indices) { @@ -157,7 +157,7 @@ object ContentUtils { @JvmStatic fun update(contentResolver: ContentResolver, updateUri: Uri, model: TableClass): Int { - val adapter = FlowManager.getModelAdapter(model.javaClass) + val adapter = model.javaClass.modelAdapter val contentValues = ContentValues() adapter.bindToContentValues(contentValues, model) @@ -192,7 +192,7 @@ object ContentUtils { */ @JvmStatic fun delete(contentResolver: ContentResolver, deleteUri: Uri, model: TableClass): Int { - val adapter = FlowManager.getModelAdapter(model.javaClass) + val adapter = model.javaClass.modelAdapter val count = contentResolver.delete(deleteUri, adapter.getPrimaryConditionClause(model).query, null) @@ -262,7 +262,7 @@ object ContentUtils { whereConditions: OperatorGroup, orderBy: String, vararg columns: String): List? { val cursor = FlowCursor.from(contentResolver.query(queryUri, columns, whereConditions.query, null, orderBy)!!) - return FlowManager.getModelAdapter(table) + return table.modelAdapter .listModelLoader .load(cursor, databaseWrapper) } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseModelQueriable.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseModelQueriable.kt index 7d4ca9a07..e2975b647 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseModelQueriable.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseModelQueriable.kt @@ -5,6 +5,7 @@ import com.raizlabs.dbflow5.adapter.queriable.ListModelLoader import com.raizlabs.dbflow5.adapter.queriable.SingleModelLoader import com.raizlabs.dbflow5.config.FlowLog import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.config.queryModelAdapter import com.raizlabs.dbflow5.database.DatabaseWrapper import com.raizlabs.dbflow5.query.list.FlowCursorList import com.raizlabs.dbflow5.query.list.FlowQueryList @@ -65,15 +66,13 @@ protected constructor(val databaseWrapper: DatabaseWrapper, override fun queryCustomList(queryModelClass: Class): MutableList { val query = query FlowLog.log(FlowLog.Level.V, "Executing query: " + query) - val adapter = FlowManager.getQueryModelAdapter(queryModelClass) - return adapter.listModelLoader.load(databaseWrapper, query)!! + return queryModelClass.queryModelAdapter.listModelLoader.load(databaseWrapper, query)!! } override fun queryCustomSingle(queryModelClass: Class): QueryClass? { val query = query FlowLog.log(FlowLog.Level.V, "Executing query: " + query) - val adapter = FlowManager.getQueryModelAdapter(queryModelClass) - return adapter.singleModelLoader.load(databaseWrapper, query) + return queryModelClass.queryModelAdapter.singleModelLoader.load(databaseWrapper, query) } } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/CursorResult.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/CursorResult.kt index aeef3f8ef..93808da59 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/CursorResult.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/CursorResult.kt @@ -2,6 +2,7 @@ package com.raizlabs.dbflow5.query import com.raizlabs.dbflow5.adapter.InstanceAdapter import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.config.queryModelAdapter import com.raizlabs.dbflow5.database.DatabaseWrapper import com.raizlabs.dbflow5.database.FlowCursor import com.raizlabs.dbflow5.query.list.FlowCursorIterator @@ -62,7 +63,7 @@ class CursorResult internal constructor(modelClass: Class, cursor: F */ fun toCustomList(customClass: Class): List { return _cursor?.let { cursor -> - return@let FlowManager.getQueryModelAdapter(customClass) + return@let customClass.queryModelAdapter .listModelLoader.convertToData(cursor, databaseWrapper) } ?: arrayListOf() } @@ -71,7 +72,7 @@ class CursorResult internal constructor(modelClass: Class, cursor: F * @return Converts the [FlowCursor] to a [List] of [T] and then closes it. */ fun toCustomListClose(customClass: Class): List { - val customList = FlowManager.getQueryModelAdapter(customClass).listModelLoader + val customList = customClass.queryModelAdapter.listModelLoader .load(_cursor, databaseWrapper) ?: arrayListOf() close() return customList @@ -97,17 +98,16 @@ class CursorResult internal constructor(modelClass: Class, cursor: F * @return The first [T] of items from the contained [FlowCursor]. You must call [.close] when finished. */ fun toCustomModel(customClass: Class): TCustom? { - return if (_cursor != null) - FlowManager.getQueryModelAdapter(customClass) - .singleModelLoader.convertToData(_cursor!!, databaseWrapper) - else null + return _cursor?.let { _cursor -> + customClass.queryModelAdapter.singleModelLoader.convertToData(_cursor, databaseWrapper) + } } /** * @return Converts the [FlowCursor] to a [T] and then closes it. */ fun toCustomModelClose(customClass: Class): TCustom? { - val customList = FlowManager.getQueryModelAdapter(customClass).singleModelLoader.load(_cursor, databaseWrapper) + val customList = customClass.queryModelAdapter.singleModelLoader.load(_cursor, databaseWrapper) close() return customList } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/Insert.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Insert.kt index 27482b503..b96c9cfd8 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/Insert.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/Insert.kt @@ -4,6 +4,7 @@ import android.content.ContentValues import com.raizlabs.dbflow5.annotation.ConflictAction import com.raizlabs.dbflow5.appendArray import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.config.modelAdapter import com.raizlabs.dbflow5.database.DatabaseWrapper import com.raizlabs.dbflow5.query.property.IProperty import com.raizlabs.dbflow5.sql.Query @@ -94,7 +95,7 @@ internal constructor(databaseWrapper: DatabaseWrapper, * @param columns The columns to use */ fun columns(vararg columns: String) = apply { - val modelClassModelAdapter = FlowManager.getModelAdapter(table) + val modelClassModelAdapter = table.modelAdapter this.columns = columns.map { modelClassModelAdapter.getProperty(it) } } @@ -110,7 +111,7 @@ internal constructor(databaseWrapper: DatabaseWrapper, * @return Appends a list of columns to this INSERT statement from the associated [TModel]. */ fun asColumns() = apply { - columns(*FlowManager.getModelAdapter(table).allColumnProperties) + columns(*table.modelAdapter.allColumnProperties) } /** diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/structure/BaseModel.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/structure/BaseModel.kt index 6316f0a40..67f5a8a52 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/structure/BaseModel.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/structure/BaseModel.kt @@ -3,6 +3,7 @@ package com.raizlabs.dbflow5.structure import com.raizlabs.dbflow5.adapter.ModelAdapter import com.raizlabs.dbflow5.annotation.ColumnIgnore import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.config.modelAdapter import com.raizlabs.dbflow5.database.DatabaseWrapper /** @@ -18,7 +19,7 @@ open class BaseModel : Model { */ @delegate:ColumnIgnore @delegate:Transient - val modelAdapter: ModelAdapter by lazy { FlowManager.getModelAdapter(javaClass) } + val modelAdapter: ModelAdapter by lazy { javaClass.modelAdapter } @Suppress("UNCHECKED_CAST") override fun load(wrapper: DatabaseWrapper): T? = modelAdapter.load(this, wrapper) as T? From 540601fc0eca0ff2b9a63daee28022a3b7969224 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Fri, 8 Dec 2017 11:39:29 -0500 Subject: [PATCH 137/234] [db] dont require database config specified just yet. --- .../raizlabs/dbflow5/config/DBFlowDatabase.kt | 60 +++++++++---------- .../raizlabs/dbflow5/config/DatabaseConfig.kt | 4 +- 2 files changed, 32 insertions(+), 32 deletions(-) diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/config/DBFlowDatabase.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/config/DBFlowDatabase.kt index a5693dddb..473e0c2ae 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/config/DBFlowDatabase.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/config/DBFlowDatabase.kt @@ -21,7 +21,6 @@ import com.raizlabs.dbflow5.migration.Migration import com.raizlabs.dbflow5.runtime.DirectModelNotifier import com.raizlabs.dbflow5.runtime.ModelNotifier import com.raizlabs.dbflow5.structure.BaseModelView -import com.raizlabs.dbflow5.structure.InvalidDBConfiguration import com.raizlabs.dbflow5.transaction.BaseTransactionManager import com.raizlabs.dbflow5.transaction.DefaultTransactionManager import com.raizlabs.dbflow5.transaction.DefaultTransactionQueue @@ -106,10 +105,11 @@ abstract class DBFlowDatabase : DatabaseWrapper { @Synchronized get() { if (_openHelper == null) { val config = FlowManager.getConfig().databaseConfigMap[associatedDatabaseClassFile] - ?: throw InvalidDBConfiguration("" + - "Missing Database Configuration for $associatedDatabaseClassFile." + - " Please specify it in FlowManager.init()") - _openHelper = config.openHelperCreator(this, callback) + _openHelper = if (config?.openHelperCreator != null) { + config.openHelperCreator.invoke(this, callback) + } else { + AndroidSQLiteOpenHelper(FlowManager.context, this, callback) + } _openHelper?.performRestoreFromBackup() isOpened = true } @@ -252,7 +252,7 @@ abstract class DBFlowDatabase : DatabaseWrapper { */ @Suppress("UNCHECKED_CAST") fun getModelViewAdapterForTable(table: Class): ModelViewAdapter? = - modelViewAdapterMap[table] as ModelViewAdapter? + modelViewAdapterMap[table] as ModelViewAdapter? /** * @param queryModel The [QueryModel] class @@ -260,7 +260,7 @@ abstract class DBFlowDatabase : DatabaseWrapper { */ @Suppress("UNCHECKED_CAST") fun getQueryModelAdapterForQueryClass(queryModel: Class): QueryModelAdapter? = - queryModelAdapterMap[queryModel] as QueryModelAdapter? + queryModelAdapterMap[queryModel] as QueryModelAdapter? fun getModelNotifier(): ModelNotifier { if (modelNotifier == null) { @@ -280,10 +280,10 @@ abstract class DBFlowDatabase : DatabaseWrapper { fun executeTransactionAsync(transaction: ITransaction, success: ((Transaction, R) -> Unit)? = null, error: ((Transaction, Throwable) -> Unit)? = null): Transaction - = beginTransactionAsync(transaction) - .success(success) - .error(error) - .execute() + = beginTransactionAsync(transaction) + .success(success) + .error(error) + .execute() /** * Executes and returns the executed transaction. @@ -291,19 +291,19 @@ abstract class DBFlowDatabase : DatabaseWrapper { fun executeTransactionAsync(transaction: (DatabaseWrapper) -> R, success: ((Transaction, R) -> Unit)? = null, error: ((Transaction, Throwable) -> Unit)? = null): Transaction - = beginTransactionAsync(transaction) - .success(success) - .error(error) - .execute() + = beginTransactionAsync(transaction) + .success(success) + .error(error) + .execute() fun beginTransactionAsync(transaction: ITransaction): Transaction.Builder = - Transaction.Builder(transaction, this) + Transaction.Builder(transaction, this) fun beginTransactionAsync(transaction: (DatabaseWrapper) -> R): Transaction.Builder = - beginTransactionAsync(object : ITransaction { - override fun execute(databaseWrapper: DatabaseWrapper) = transaction(databaseWrapper) - }) + beginTransactionAsync(object : ITransaction { + override fun execute(databaseWrapper: DatabaseWrapper) = transaction(databaseWrapper) + }) fun executeTransaction(transaction: ITransaction): R { val database = writableDatabase @@ -318,7 +318,7 @@ abstract class DBFlowDatabase : DatabaseWrapper { } inline fun executeTransaction(crossinline transaction: (DatabaseWrapper) -> R) - = executeTransaction(object : ITransaction { + = executeTransaction(object : ITransaction { override fun execute(databaseWrapper: DatabaseWrapper) = transaction(databaseWrapper) }) @@ -429,27 +429,27 @@ abstract class DBFlowDatabase : DatabaseWrapper { override fun endTransaction() = writableDatabase.endTransaction() override fun compileStatement(rawQuery: String): DatabaseStatement - = writableDatabase.compileStatement(rawQuery) + = writableDatabase.compileStatement(rawQuery) override fun rawQuery(query: String, selectionArgs: Array?): FlowCursor - = writableDatabase.rawQuery(query, selectionArgs) + = writableDatabase.rawQuery(query, selectionArgs) override fun updateWithOnConflict(tableName: String, contentValues: ContentValues, where: String?, whereArgs: Array?, conflictAlgorithm: Int): Long - = writableDatabase.updateWithOnConflict(tableName, contentValues, where, whereArgs, conflictAlgorithm) + = writableDatabase.updateWithOnConflict(tableName, contentValues, where, whereArgs, conflictAlgorithm) override fun insertWithOnConflict( - tableName: String, - nullColumnHack: String?, - values: ContentValues, - sqLiteDatabaseAlgorithmInt: Int): Long - = writableDatabase.insertWithOnConflict(tableName, nullColumnHack, values, sqLiteDatabaseAlgorithmInt) + tableName: String, + nullColumnHack: String?, + values: ContentValues, + sqLiteDatabaseAlgorithmInt: Int): Long + = writableDatabase.insertWithOnConflict(tableName, nullColumnHack, values, sqLiteDatabaseAlgorithmInt) override fun delete(tableName: String, whereClause: String?, whereArgs: Array?): Int - = writableDatabase.delete(tableName, whereClause, whereArgs) + = writableDatabase.delete(tableName, whereClause, whereArgs) override fun query(tableName: String, columns: Array?, @@ -457,5 +457,5 @@ abstract class DBFlowDatabase : DatabaseWrapper { selectionArgs: Array?, groupBy: String?, having: String?, orderBy: String?): FlowCursor - = writableDatabase.query(tableName, columns, selection, selectionArgs, groupBy, having, orderBy) + = writableDatabase.query(tableName, columns, selection, selectionArgs, groupBy, having, orderBy) } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseConfig.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseConfig.kt index f8d110341..ffcb539ba 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseConfig.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseConfig.kt @@ -15,7 +15,7 @@ typealias TransactionManagerCreator = (DBFlowDatabase) -> BaseTransactionManager */ class DatabaseConfig( val databaseClass: Class<*>, - val openHelperCreator: OpenHelperCreator, + val openHelperCreator: OpenHelperCreator? = null, val transactionManagerCreator: TransactionManagerCreator? = null, val callback: DatabaseCallback? = null, val tableConfigMap: Map, TableConfig<*>> = mapOf(), @@ -48,7 +48,7 @@ class DatabaseConfig( * Build compatibility class for Java. Use the [DatabaseConfig] class directly if Kotlin consumer. */ class Builder(internal val databaseClass: Class<*>, - internal val openHelperCreator: OpenHelperCreator) { + internal val openHelperCreator: OpenHelperCreator? = null) { internal var transactionManagerCreator: TransactionManagerCreator? = null internal var callback: DatabaseCallback? = null From 0f74c4d52ac292bf3daf5f6479cdd4c1a31410d9 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Fri, 8 Dec 2017 12:11:09 -0500 Subject: [PATCH 138/234] [models] remove instanceadapter since now we construct object within load method. replace with retrieval adapter. for processor reorganized definitions for content provider into own package. --- .../raizlabs/dbflow5/processor/Handlers.kt | 4 +- .../dbflow5/processor/ProcessorManager.kt | 4 +- .../raizlabs/dbflow5/processor/Validators.kt | 2 + .../processor/definition/BaseDefinition.kt | 7 +- .../definition/DatabaseHolderDefinition.kt | 9 +- .../definition/DatabaseObjectHolder.kt | 1 + .../definition/ModelViewDefinition.kt | 16 +- .../definition/QueryModelDefinition.kt | 34 +-- .../processor/definition/TableDefinition.kt | 283 +++++++++--------- .../definition/UniqueGroupsDefinition.kt | 12 +- .../definition/column/ColumnDefinition.kt | 2 +- .../{ => content}/ContentProvider.kt | 19 +- .../{ => content}/NotifyDefinition.kt | 7 +- .../{ => content}/TableEndpointDefinition.kt | 3 +- .../rx/structure/RXRetrievalAdapter.kt | 2 +- .../rx2/structure/RXRetrievalAdapter.kt | 4 +- .../dbflow5/adapter/InstanceAdapter.kt | 16 - .../raizlabs/dbflow5/adapter/ModelAdapter.kt | 32 +- .../dbflow5/adapter/ModelViewAdapter.kt | 2 +- .../dbflow5/adapter/QueryModelAdapter.kt | 2 +- .../dbflow5/adapter/queriable/ModelLoader.kt | 6 +- .../raizlabs/dbflow5/config/FlowManager.kt | 19 -- .../dbflow5/query/BaseModelQueriable.kt | 4 +- .../raizlabs/dbflow5/query/CursorResult.kt | 12 +- .../dbflow5/query/list/FlowCursorList.kt | 14 +- .../dbflow5/query/list/FlowQueryList.kt | 22 +- .../dbflow5/structure/NoModificationModel.kt | 2 +- 27 files changed, 248 insertions(+), 292 deletions(-) rename dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/{ => content}/ContentProvider.kt (97%) rename dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/{ => content}/NotifyDefinition.kt (94%) rename dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/{ => content}/TableEndpointDefinition.kt (95%) delete mode 100644 dbflow/src/main/java/com/raizlabs/dbflow5/adapter/InstanceAdapter.kt diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/Handlers.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/Handlers.kt index 977c36e19..933e11dbd 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/Handlers.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/Handlers.kt @@ -18,14 +18,14 @@ import com.raizlabs.dbflow5.converter.CharConverter import com.raizlabs.dbflow5.converter.DateConverter import com.raizlabs.dbflow5.converter.SqlDateConverter import com.raizlabs.dbflow5.converter.UUIDConverter -import com.raizlabs.dbflow5.processor.definition.ContentProviderDefinition +import com.raizlabs.dbflow5.processor.definition.content.ContentProviderDefinition import com.raizlabs.dbflow5.processor.definition.DatabaseDefinition import com.raizlabs.dbflow5.processor.definition.ManyToManyDefinition import com.raizlabs.dbflow5.processor.definition.MigrationDefinition import com.raizlabs.dbflow5.processor.definition.ModelViewDefinition import com.raizlabs.dbflow5.processor.definition.QueryModelDefinition import com.raizlabs.dbflow5.processor.definition.TableDefinition -import com.raizlabs.dbflow5.processor.definition.TableEndpointDefinition +import com.raizlabs.dbflow5.processor.definition.content.TableEndpointDefinition import com.raizlabs.dbflow5.processor.definition.TypeConverterDefinition import com.raizlabs.dbflow5.processor.utils.annotation import javax.annotation.processing.RoundEnvironment diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/ProcessorManager.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/ProcessorManager.kt index ba1c3b7ed..705a4bedd 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/ProcessorManager.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/ProcessorManager.kt @@ -1,7 +1,7 @@ package com.raizlabs.dbflow5.processor import com.raizlabs.dbflow5.processor.definition.BaseTableDefinition -import com.raizlabs.dbflow5.processor.definition.ContentProviderDefinition +import com.raizlabs.dbflow5.processor.definition.content.ContentProviderDefinition import com.raizlabs.dbflow5.processor.definition.DatabaseDefinition import com.raizlabs.dbflow5.processor.definition.DatabaseHolderDefinition import com.raizlabs.dbflow5.processor.definition.DatabaseObjectHolder @@ -10,7 +10,7 @@ import com.raizlabs.dbflow5.processor.definition.MigrationDefinition import com.raizlabs.dbflow5.processor.definition.ModelViewDefinition import com.raizlabs.dbflow5.processor.definition.QueryModelDefinition import com.raizlabs.dbflow5.processor.definition.TableDefinition -import com.raizlabs.dbflow5.processor.definition.TableEndpointDefinition +import com.raizlabs.dbflow5.processor.definition.content.TableEndpointDefinition import com.raizlabs.dbflow5.processor.definition.TypeConverterDefinition import com.raizlabs.dbflow5.processor.utils.WriterUtils import com.squareup.javapoet.ClassName diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/Validators.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/Validators.kt index d81d8e4d0..f4dd67ca6 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/Validators.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/Validators.kt @@ -5,6 +5,8 @@ import com.raizlabs.dbflow5.processor.definition.column.ColumnDefinition import com.raizlabs.dbflow5.processor.definition.column.EnumColumnAccessor import com.raizlabs.dbflow5.processor.definition.column.ReferenceColumnDefinition import com.raizlabs.dbflow5.processor.definition.column.PrivateScopeColumnAccessor +import com.raizlabs.dbflow5.processor.definition.content.ContentProviderDefinition +import com.raizlabs.dbflow5.processor.definition.content.TableEndpointDefinition import com.raizlabs.dbflow5.processor.utils.isNullOrEmpty diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/BaseDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/BaseDefinition.kt index 2f12591a1..73adfa46e 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/BaseDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/BaseDefinition.kt @@ -104,12 +104,11 @@ abstract class BaseDefinition : TypeDefinition { } protected open fun getElementClassName(element: Element?): ClassName? { - try { - return ElementUtility.getClassName(element?.asType().toString(), manager) + return try { + ElementUtility.getClassName(element?.asType().toString(), manager) } catch (e: Exception) { - return null + null } - } protected fun setOutputClassName(postfix: String) { diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/DatabaseHolderDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/DatabaseHolderDefinition.kt index ec6cd8f95..e842b28e1 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/DatabaseHolderDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/DatabaseHolderDefinition.kt @@ -1,6 +1,11 @@ package com.raizlabs.dbflow5.processor.definition -import com.grosner.kpoet.* +import com.grosner.kpoet.`public final class` +import com.grosner.kpoet.constructor +import com.grosner.kpoet.extends +import com.grosner.kpoet.modifiers +import com.grosner.kpoet.public +import com.grosner.kpoet.statement import com.raizlabs.dbflow5.processor.ClassNames import com.raizlabs.dbflow5.processor.DatabaseHandler import com.raizlabs.dbflow5.processor.ProcessorManager @@ -52,7 +57,7 @@ class DatabaseHolderDefinition(private val processorManager: ProcessorManager) : * If none of the database holder databases exist, don't generate a holder. */ fun isGarbage() = processorManager.getDatabaseHolderDefinitionList() - .filter { it.databaseDefinition?.outputClassName != null }.isEmpty() + .none { it.databaseDefinition?.outputClassName != null } companion object { diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/DatabaseObjectHolder.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/DatabaseObjectHolder.kt index 1afc46275..c2d8b1f92 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/DatabaseObjectHolder.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/DatabaseObjectHolder.kt @@ -1,5 +1,6 @@ package com.raizlabs.dbflow5.processor.definition +import com.raizlabs.dbflow5.processor.definition.content.ContentProviderDefinition import com.squareup.javapoet.TypeName /** diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/ModelViewDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/ModelViewDefinition.kt index fd6f66a5a..c8be5e17b 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/ModelViewDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/ModelViewDefinition.kt @@ -38,16 +38,19 @@ import javax.lang.model.type.MirroredTypeException /** * Description: Used in writing ModelViewAdapters */ -class ModelViewDefinition(manager: ProcessorManager, element: Element) : BaseTableDefinition(element, manager) { +class ModelViewDefinition(manager: ProcessorManager, element: Element) + : BaseTableDefinition(element, manager) { - internal val implementsLoadFromCursorListener: Boolean + private val implementsLoadFromCursorListener: Boolean private var queryFieldName: String? = null private var name: String? = null - private val methods: Array = - arrayOf(LoadFromCursorMethod(this), ExistenceMethod(this), PrimaryConditionMethod(this)) + private val methods: Array = arrayOf( + LoadFromCursorMethod(this), + ExistenceMethod(this), + PrimaryConditionMethod(this)) var allFields: Boolean = false @@ -182,11 +185,6 @@ class ModelViewDefinition(manager: ProcessorManager, element: Element) : BaseTab modifiers(public, final) `return`(name.S) } - `override fun`(elementClassName!!, "newInstance") { - modifiers(public, final) - `return`("new \$T()", elementClassName) - } - } methods.mapNotNull { it.methodSpec } diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/QueryModelDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/QueryModelDefinition.kt index 9d8593f75..4d42f49ee 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/QueryModelDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/QueryModelDefinition.kt @@ -1,9 +1,5 @@ package com.raizlabs.dbflow5.processor.definition -import com.grosner.kpoet.`return` -import com.grosner.kpoet.final -import com.grosner.kpoet.modifiers -import com.grosner.kpoet.public import com.raizlabs.dbflow5.annotation.Column import com.raizlabs.dbflow5.annotation.ColumnMap import com.raizlabs.dbflow5.annotation.QueryModel @@ -13,7 +9,6 @@ import com.raizlabs.dbflow5.processor.ProcessorManager import com.raizlabs.dbflow5.processor.definition.column.ColumnDefinition import com.raizlabs.dbflow5.processor.definition.column.ReferenceColumnDefinition import com.raizlabs.dbflow5.processor.utils.ElementUtility -import com.raizlabs.dbflow5.processor.utils.`override fun` import com.raizlabs.dbflow5.processor.utils.annotation import com.raizlabs.dbflow5.processor.utils.extractTypeNameFromAnnotation import com.raizlabs.dbflow5.processor.utils.implementsClass @@ -38,7 +33,9 @@ class QueryModelDefinition(typeElement: Element, processorManager: ProcessorMana init { databaseTypeName = typeElement.extractTypeNameFromAnnotation { it.database } - elementClassName?.let { elementClassName -> databaseTypeName?.let { processorManager.addModelToDatabase(elementClassName, it) } } + elementClassName?.let { elementClassName -> + databaseTypeName?.let { processorManager.addModelToDatabase(elementClassName, it) } + } implementsLoadFromCursorListener = (element as? TypeElement) ?.implementsClass(manager.processingEnvironment, ClassNames.LOAD_FROM_CURSOR_LISTENER) == true @@ -53,11 +50,7 @@ class QueryModelDefinition(typeElement: Element, processorManager: ProcessorMana packagePrivateList.clear() val queryModel = typeElement.annotation() - if (queryModel != null) { - allFields = queryModel.allFields - } else { - allFields = true - } + allFields = queryModel?.allFields ?: true databaseDefinition = manager.getDatabaseHolderDefinition(databaseTypeName)?.databaseDefinition setOutputClassName("${databaseDefinition?.classSeparator}QueryTable") @@ -70,16 +63,12 @@ class QueryModelDefinition(typeElement: Element, processorManager: ProcessorMana override fun onWriteDefinition(typeBuilder: TypeSpec.Builder) { typeBuilder.apply { - elementClassName?.let { className -> columnDefinitions.forEach { it.addPropertyDefinition(this, className) } } + elementClassName?.let { elementClassName -> + columnDefinitions.forEach { it.addPropertyDefinition(this, elementClassName) } + } writeGetModelClass(typeBuilder, elementClassName) - writeConstructor(this) - - `override fun`(elementClassName!!, "newInstance") { - modifiers(public, final) - `return`("new \$T()", elementClassName) - } } methods.mapNotNull { it.methodSpec } @@ -88,10 +77,7 @@ class QueryModelDefinition(typeElement: Element, processorManager: ProcessorMana override fun createColumnDefinitions(typeElement: TypeElement) { val variableElements = ElementUtility.getAllElements(typeElement, manager) - - for (element in variableElements) { - classElementLookUpMap.put(element.simpleName.toString(), element) - } + variableElements.forEach { classElementLookUpMap.put(it.simpleName.toString(), it) } val columnValidator = ColumnValidator() for (variableElement in variableElements) { @@ -120,7 +106,9 @@ class QueryModelDefinition(typeElement: Element, processorManager: ProcessorMana } } - if (columnDefinition.isPrimaryKey || columnDefinition.isPrimaryKeyAutoIncrement || columnDefinition.isRowId) { + if (columnDefinition.isPrimaryKey + || columnDefinition.isPrimaryKeyAutoIncrement + || columnDefinition.isRowId) { manager.logError("QueryModel $elementName cannot have primary keys") } } diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/TableDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/TableDefinition.kt index 389ad4bb3..d91d5436a 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/TableDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/TableDefinition.kt @@ -146,7 +146,7 @@ class TableDefinition(manager: ProcessorManager, element: TypeElement) : BaseTab inheritedColumns.forEach { if (inheritedFieldNameList.contains(it.fieldName)) { manager.logError("A duplicate inherited column with name %1s was found for %1s", - it.fieldName, tableName) + it.fieldName, tableName) } inheritedFieldNameList.add(it.fieldName) inheritedColumnMap.put(it.fieldName, it) @@ -156,38 +156,38 @@ class TableDefinition(manager: ProcessorManager, element: TypeElement) : BaseTab inheritedPrimaryKeys.forEach { if (inheritedFieldNameList.contains(it.fieldName)) { manager.logError("A duplicate inherited column with name %1s was found for %1s", - it.fieldName, tableName) + it.fieldName, tableName) } inheritedFieldNameList.add(it.fieldName) inheritedPrimaryKeyMap.put(it.fieldName, it) } implementsLoadFromCursorListener = element.implementsClass(manager.processingEnvironment, - ClassNames.LOAD_FROM_CURSOR_LISTENER) + ClassNames.LOAD_FROM_CURSOR_LISTENER) implementsContentValuesListener = element.implementsClass(manager.processingEnvironment, - ClassNames.CONTENT_VALUES_LISTENER) + ClassNames.CONTENT_VALUES_LISTENER) implementsSqlStatementListener = element.implementsClass(manager.processingEnvironment, - ClassNames.SQLITE_STATEMENT_LISTENER) + ClassNames.SQLITE_STATEMENT_LISTENER) } contentValueMethods = arrayOf(BindToContentValuesMethod(this, true, implementsContentValuesListener), - BindToContentValuesMethod(this, false, implementsContentValuesListener)) + BindToContentValuesMethod(this, false, implementsContentValuesListener)) methods = arrayOf( - BindToStatementMethod(this, INSERT), BindToStatementMethod(this, NON_INSERT), - BindToStatementMethod(this, UPDATE), BindToStatementMethod(this, DELETE), - InsertStatementQueryMethod(this, true), InsertStatementQueryMethod(this, false), - UpdateStatementQueryMethod(this), DeleteStatementQueryMethod(this), - CreationQueryMethod(this), - LoadFromCursorMethod(this), - ExistenceMethod(this), - PrimaryConditionMethod(this), - OneToManyDeleteMethod(this), - OneToManySaveMethod(this, OneToManySaveMethod.METHOD_SAVE), - OneToManySaveMethod(this, OneToManySaveMethod.METHOD_INSERT), - OneToManySaveMethod(this, OneToManySaveMethod.METHOD_UPDATE)) + BindToStatementMethod(this, INSERT), BindToStatementMethod(this, NON_INSERT), + BindToStatementMethod(this, UPDATE), BindToStatementMethod(this, DELETE), + InsertStatementQueryMethod(this, true), InsertStatementQueryMethod(this, false), + UpdateStatementQueryMethod(this), DeleteStatementQueryMethod(this), + CreationQueryMethod(this), + LoadFromCursorMethod(this), + ExistenceMethod(this), + PrimaryConditionMethod(this), + OneToManyDeleteMethod(this), + OneToManySaveMethod(this, OneToManySaveMethod.METHOD_SAVE), + OneToManySaveMethod(this, OneToManySaveMethod.METHOD_INSERT), + OneToManySaveMethod(this, OneToManySaveMethod.METHOD_UPDATE)) } override fun prepareForWrite() { @@ -237,11 +237,12 @@ class TableDefinition(manager: ProcessorManager, element: TypeElement) : BaseTab var uniqueNumbersSet: MutableSet = hashSetOf() for (uniqueGroup in groups) { if (uniqueNumbersSet.contains(uniqueGroup.groupNumber)) { - manager.logError("A duplicate unique group with number %1s was found for %1s", uniqueGroup.groupNumber, tableName) + manager.logError("A duplicate unique group with number" + + " ${uniqueGroup.groupNumber} was found for ${tableName}") } val definition = UniqueGroupsDefinition(uniqueGroup) columnDefinitions.filter { it.uniqueGroups.contains(definition.number) } - .forEach { definition.addColumnDefinition(it) } + .forEach { definition.addColumnDefinition(it) } uniqueGroupsDefinitions.add(definition) uniqueNumbersSet.add(uniqueGroup.groupNumber) } @@ -250,11 +251,12 @@ class TableDefinition(manager: ProcessorManager, element: TypeElement) : BaseTab uniqueNumbersSet = hashSetOf() for (indexGroup in indexGroups) { if (uniqueNumbersSet.contains(indexGroup.number)) { - manager.logError(TableDefinition::class, "A duplicate unique index number %1s was found for %1s", indexGroup.number, elementName) + manager.logError(TableDefinition::class, "A duplicate unique index number" + + " ${indexGroup.number} was found for ${elementName}") } val definition = IndexGroupsDefinition(this, indexGroup) columnDefinitions.filter { it.indexGroups.contains(definition.indexNumber) } - .forEach { definition.columnDefinitionList.add(it) } + .forEach { definition.columnDefinitionList.add(it) } indexGroupsDefinitions.add(definition) uniqueNumbersSet.add(indexGroup.number) } @@ -268,9 +270,9 @@ class TableDefinition(manager: ProcessorManager, element: TypeElement) : BaseTab for (element in elements) { classElementLookUpMap.put(element.simpleName.toString(), element) if (element is ExecutableElement && element.parameters.isEmpty() - && element.simpleName.toString() == "" - && element.enclosingElement == typeElement - && !element.modifiers.contains(Modifier.PRIVATE)) { + && element.simpleName.toString() == "" + && element.enclosingElement == typeElement + && !element.modifiers.contains(Modifier.PRIVATE)) { hasPrimaryConstructor = true } } @@ -291,24 +293,24 @@ class TableDefinition(manager: ProcessorManager, element: TypeElement) : BaseTab val isInheritedPrimaryKey = inheritedPrimaryKeyMap.containsKey(element.simpleName.toString()) val isColumnMap = element.annotation() != null if (element.annotation() != null || isForeign || isPrimary - || isAllFields || isInherited || isInheritedPrimaryKey || isColumnMap) { + || isAllFields || isInherited || isInheritedPrimaryKey || isColumnMap) { if (checkInheritancePackagePrivate(isPackagePrivateNotInSamePackage, element)) return val columnDefinition = if (isInheritedPrimaryKey) { val inherited = inheritedPrimaryKeyMap[element.simpleName.toString()] ColumnDefinition(manager, element, this, isPackagePrivateNotInSamePackage, - inherited?.column, inherited?.primaryKey) + inherited?.column, inherited?.primaryKey) } else if (isInherited) { val inherited = inheritedColumnMap[element.simpleName.toString()] ColumnDefinition(manager, element, this, isPackagePrivateNotInSamePackage, - inherited?.column, null, inherited?.nonNullConflict ?: ConflictAction.NONE) + inherited?.column, null, inherited?.nonNullConflict ?: ConflictAction.NONE) } else if (isForeign || isColumnMap) { ReferenceColumnDefinition(manager, this, - element, isPackagePrivateNotInSamePackage) + element, isPackagePrivateNotInSamePackage) } else { ColumnDefinition(manager, element, - this, isPackagePrivateNotInSamePackage) + this, isPackagePrivateNotInSamePackage) } if (columnValidator.validate(manager, columnDefinition)) { @@ -328,10 +330,10 @@ class TableDefinition(manager: ProcessorManager, element: TypeElement) : BaseTab // check to ensure not null. if (it.isNullableType) { manager.logWarning("Attempting to use nullable field type on an autoincrementing column. " + - "To suppress or remove this warning " + - "switch to java primitive, add @android.support.annotation.NonNull," + - "@org.jetbrains.annotation.NotNull, or in Kotlin don't make it nullable. Check the column ${it.columnName} " + - "on $tableName") + "To suppress or remove this warning " + + "switch to java primitive, add @android.support.annotation.NonNull," + + "@org.jetbrains.annotation.NotNull, or in Kotlin don't make it nullable. Check the column ${it.columnName} " + + "on $tableName") } } @@ -397,11 +399,6 @@ class TableDefinition(manager: ProcessorManager, element: TypeElement) : BaseTab `return`(tableName.quote().S) } - `override fun`(elementClassName!!, "newInstance") { - modifiers(public, final) - `return`("new \$T()", elementClassName) - } - if (updateConflictActionName.isNotEmpty()) { `override fun`(ClassNames.CONFLICT_ACTION, "getUpdateOnConflictAction") { modifiers(public, final) @@ -420,7 +417,7 @@ class TableDefinition(manager: ProcessorManager, element: TypeElement) : BaseTab val getPropertiesBuilder = CodeBlock.builder() `override fun`(ClassNames.PROPERTY, "getProperty", - param(String::class, paramColumnName)) { + param(String::class, paramColumnName)) { modifiers(public, final) statement("$paramColumnName = \$T.quoteIfNeeded($paramColumnName)", ClassNames.STRING_UTILS) @@ -454,7 +451,7 @@ class TableDefinition(manager: ProcessorManager, element: TypeElement) : BaseTab val autoIncrement = autoIncrementColumn autoIncrement?.let { `override fun`(TypeName.VOID, "updateAutoIncrement", param(elementClassName!!, ModelUtils.variable), - param(Number::class, "id")) { + param(Number::class, "id")) { modifiers(public, final) addCode(autoIncrement.updateAutoIncrementMethod) } @@ -476,28 +473,28 @@ class TableDefinition(manager: ProcessorManager, element: TypeElement) : BaseTab } val saveForeignKeyFields = columnDefinitions - .filter { (it is ReferenceColumnDefinition) && it.saveForeignKeyModel } - .map { it as ReferenceColumnDefinition } + .filter { (it is ReferenceColumnDefinition) && it.saveForeignKeyModel } + .map { it as ReferenceColumnDefinition } if (saveForeignKeyFields.isNotEmpty()) { val code = CodeBlock.builder() saveForeignKeyFields.forEach { it.appendSaveMethod(code) } `override fun`(TypeName.VOID, "saveForeignKeys", param(elementClassName!!, ModelUtils.variable), - param(ClassNames.DATABASE_WRAPPER, ModelUtils.wrapper)) { + param(ClassNames.DATABASE_WRAPPER, ModelUtils.wrapper)) { modifiers(public, final) addCode(code.build()) } } val deleteForeignKeyFields = columnDefinitions - .filter { (it is ReferenceColumnDefinition) && it.deleteForeignKeyModel } - .map { it as ReferenceColumnDefinition } + .filter { (it is ReferenceColumnDefinition) && it.deleteForeignKeyModel } + .map { it as ReferenceColumnDefinition } if (deleteForeignKeyFields.isNotEmpty()) { val code = CodeBlock.builder() deleteForeignKeyFields.forEach { it.appendDeleteMethod(code) } `override fun`(TypeName.VOID, "deleteForeignKeys", param(elementClassName!!, ModelUtils.variable), - param(ClassNames.DATABASE_WRAPPER, ModelUtils.wrapper)) { + param(ClassNames.DATABASE_WRAPPER, ModelUtils.wrapper)) { modifiers(public, final) addCode(code.build()) } @@ -519,99 +516,99 @@ class TableDefinition(manager: ProcessorManager, element: TypeElement) : BaseTab `private final field`(ClassNames.CACHE_ADAPTER, "cacheAdapter") { `=` { add("\$L", - TypeSpec.anonymousClassBuilder("") - .addSuperinterface(ParameterizedTypeName.get(ClassNames.CACHE_ADAPTER, elementTypeName)) - .apply { - val primaryColumns = primaryColumnDefinitions - if (primaryColumns.size > 1) { - `override fun`(ArrayTypeName.of(Any::class.java), "getCachingColumnValuesFromModel", - param(ArrayTypeName.of(Any::class.java), "inValues"), - param(elementClassName!!, ModelUtils.variable)) { - modifiers(public, final) - for (i in primaryColumns.indices) { - val column = primaryColumns[i] - addCode(column.getColumnAccessString(i)) + TypeSpec.anonymousClassBuilder("") + .addSuperinterface(ParameterizedTypeName.get(ClassNames.CACHE_ADAPTER, elementTypeName)) + .apply { + val primaryColumns = primaryColumnDefinitions + if (primaryColumns.size > 1) { + `override fun`(ArrayTypeName.of(Any::class.java), "getCachingColumnValuesFromModel", + param(ArrayTypeName.of(Any::class.java), "inValues"), + param(elementClassName!!, ModelUtils.variable)) { + modifiers(public, final) + for (i in primaryColumns.indices) { + val column = primaryColumns[i] + addCode(column.getColumnAccessString(i)) + } + + `return`("inValues") + } + + `override fun`(ArrayTypeName.of(Any::class.java), "getCachingColumnValuesFromCursor", + param(ArrayTypeName.of(Any::class.java), "inValues"), + param(ClassNames.FLOW_CURSOR, "cursor")) { + modifiers(public, final) + for (i in primaryColumns.indices) { + val column = primaryColumns[i] + val method = DefinitionUtils.getLoadFromCursorMethodString(column.elementTypeName, column.wrapperTypeName) + statement("inValues[$i] = ${LoadFromCursorMethod.PARAM_CURSOR}" + + ".$method(${LoadFromCursorMethod.PARAM_CURSOR}.getColumnIndex(${column.columnName.S}))") + } + `return`("inValues") + } + } else { + // single primary key + `override fun`(Any::class, "getCachingColumnValueFromModel", + param(elementClassName!!, ModelUtils.variable)) { + modifiers(public, final) + addCode(primaryColumns[0].getSimpleAccessString()) + } + + `override fun`(Any::class, "getCachingColumnValueFromCursor", param(ClassNames.FLOW_CURSOR, "cursor")) { + modifiers(public, final) + val column = primaryColumns[0] + val method = DefinitionUtils.getLoadFromCursorMethodString(column.elementTypeName, column.wrapperTypeName) + `return`("${LoadFromCursorMethod.PARAM_CURSOR}.$method(${LoadFromCursorMethod.PARAM_CURSOR}.getColumnIndex(${column.columnName.S}))") + } + `override fun`(Any::class, "getCachingId", param(elementClassName!!, ModelUtils.variable)) { + modifiers(public, final) + `return`("getCachingColumnValueFromModel(${ModelUtils.variable})") + } } - `return`("inValues") - } - `override fun`(ArrayTypeName.of(Any::class.java), "getCachingColumnValuesFromCursor", - param(ArrayTypeName.of(Any::class.java), "inValues"), - param(ClassNames.FLOW_CURSOR, "cursor")) { - modifiers(public, final) - for (i in primaryColumns.indices) { - val column = primaryColumns[i] - val method = DefinitionUtils.getLoadFromCursorMethodString(column.elementTypeName, column.wrapperTypeName) - statement("inValues[$i] = ${LoadFromCursorMethod.PARAM_CURSOR}" + - ".$method(${LoadFromCursorMethod.PARAM_CURSOR}.getColumnIndex(${column.columnName.S}))") + `override fun`(TypeName.INT, "getCachingColumnSize") { + modifiers(public, final) + `return`(primaryColumns.size.L) } - `return`("inValues") - } - } else { - // single primary key - `override fun`(Any::class, "getCachingColumnValueFromModel", - param(elementClassName!!, ModelUtils.variable)) { - modifiers(public, final) - addCode(primaryColumns[0].getSimpleAccessString()) - } - - `override fun`(Any::class, "getCachingColumnValueFromCursor", param(ClassNames.FLOW_CURSOR, "cursor")) { - modifiers(public, final) - val column = primaryColumns[0] - val method = DefinitionUtils.getLoadFromCursorMethodString(column.elementTypeName, column.wrapperTypeName) - `return`("${LoadFromCursorMethod.PARAM_CURSOR}.$method(${LoadFromCursorMethod.PARAM_CURSOR}.getColumnIndex(${column.columnName.S}))") - } - `override fun`(Any::class, "getCachingId", param(elementClassName!!, ModelUtils.variable)) { - modifiers(public, final) - `return`("getCachingColumnValueFromModel(${ModelUtils.variable})") - } - } - - `override fun`(TypeName.INT, "getCachingColumnSize") { - modifiers(public, final) - `return`(primaryColumns.size.L) - } - - if (cacheSize != DEFAULT_CACHE_SIZE) { - `override fun`(TypeName.INT, "getCacheSize") { - modifiers(public, final) - `return`(cacheSize.L) - } - } + if (cacheSize != DEFAULT_CACHE_SIZE) { + `override fun`(TypeName.INT, "getCacheSize") { + modifiers(public, final) + `return`(cacheSize.L) + } + } - if (!customCacheFieldName.isNullOrEmpty()) { - `override fun`(ParameterizedTypeName.get(ClassNames.MODEL_CACHE, elementClassName, - WildcardTypeName.subtypeOf(Any::class.java)), "createModelCache") { - modifiers(public, final) - `return`("\$T.$customCacheFieldName", elementClassName) - } - } + if (!customCacheFieldName.isNullOrEmpty()) { + `override fun`(ParameterizedTypeName.get(ClassNames.MODEL_CACHE, elementClassName, + WildcardTypeName.subtypeOf(Any::class.java)), "createModelCache") { + modifiers(public, final) + `return`("\$T.$customCacheFieldName", elementClassName) + } + } - if (!customMultiCacheFieldName.isNullOrEmpty()) { - `override fun`(ParameterizedTypeName.get(ClassNames.MULTI_KEY_CACHE_CONVERTER, - WildcardTypeName.subtypeOf(Any::class.java)), "getCacheConverter") { - modifiers(public, final) - `return`("\$T.$customMultiCacheFieldName", elementClassName) - } - } - if (foreignKeyDefinitions.isNotEmpty()) { - `override fun`(TypeName.VOID, "reloadRelationships", - param(elementClassName!!, ModelUtils.variable), - param(ClassNames.FLOW_CURSOR, LoadFromCursorMethod.PARAM_CURSOR), - param(ClassNames.DATABASE_WRAPPER, ModelUtils.wrapper)) { - modifiers(public, final) - code { - val noIndex = AtomicInteger(-1) - val nameAllocator = NameAllocator() - foreignKeyDefinitions.forEach { add(it.getLoadFromCursorMethod(false, noIndex, nameAllocator)) } - this + if (!customMultiCacheFieldName.isNullOrEmpty()) { + `override fun`(ParameterizedTypeName.get(ClassNames.MULTI_KEY_CACHE_CONVERTER, + WildcardTypeName.subtypeOf(Any::class.java)), "getCacheConverter") { + modifiers(public, final) + `return`("\$T.$customMultiCacheFieldName", elementClassName) + } + } + if (foreignKeyDefinitions.isNotEmpty()) { + `override fun`(TypeName.VOID, "reloadRelationships", + param(elementClassName!!, ModelUtils.variable), + param(ClassNames.FLOW_CURSOR, LoadFromCursorMethod.PARAM_CURSOR), + param(ClassNames.DATABASE_WRAPPER, ModelUtils.wrapper)) { + modifiers(public, final) + code { + val noIndex = AtomicInteger(-1) + val nameAllocator = NameAllocator() + foreignKeyDefinitions.forEach { add(it.getLoadFromCursorMethod(false, noIndex, nameAllocator)) } + this + } + } } } - } - } - .build()) + .build()) } } @@ -620,21 +617,21 @@ class TableDefinition(manager: ProcessorManager, element: TypeElement) : BaseTab `override fun`(ClassNames.SINGLE_MODEL_LOADER, "createSingleModelLoader") { modifiers(public, final) addStatement("return new \$T<>(getTable(), cacheAdapter)", - if (singlePrimaryKey) - ClassNames.SINGLE_KEY_CACHEABLE_MODEL_LOADER - else - ClassNames.CACHEABLE_MODEL_LOADER) + if (singlePrimaryKey) + ClassNames.SINGLE_KEY_CACHEABLE_MODEL_LOADER + else + ClassNames.CACHEABLE_MODEL_LOADER) } `override fun`(ClassNames.LIST_MODEL_LOADER, "createListModelLoader") { modifiers(public, final) `return`("new \$T<>(getTable(), cacheAdapter)", - if (singlePrimaryKey) - ClassNames.SINGLE_KEY_CACHEABLE_LIST_MODEL_LOADER - else - ClassNames.CACHEABLE_LIST_MODEL_LOADER) + if (singlePrimaryKey) + ClassNames.SINGLE_KEY_CACHEABLE_LIST_MODEL_LOADER + else + ClassNames.CACHEABLE_LIST_MODEL_LOADER) } `override fun`(ParameterizedTypeName.get(ClassNames.CACHEABLE_LIST_MODEL_SAVER, elementClassName), - "createListModelSaver") { + "createListModelSaver") { modifiers(protected) `return`("new \$T<>(getModelSaver(), cacheAdapter)", ClassNames.CACHEABLE_LIST_MODEL_SAVER) } @@ -644,7 +641,7 @@ class TableDefinition(manager: ProcessorManager, element: TypeElement) : BaseTab } `override fun`(elementClassName!!, "load", param(elementClassName!!, "model"), - param(ClassNames.DATABASE_WRAPPER, wrapper)) { + param(ClassNames.DATABASE_WRAPPER, wrapper)) { modifiers(public, final) statement("\$T loaded = super.load(model, $wrapper)", elementClassName!!) statement("cacheAdapter.storeModelInCache(model)") @@ -655,10 +652,10 @@ class TableDefinition(manager: ProcessorManager, element: TypeElement) : BaseTab } methods.mapNotNull { it.methodSpec } - .forEach { typeBuilder.addMethod(it) } + .forEach { typeBuilder.addMethod(it) } if (generateContentValues) { contentValueMethods.mapNotNull { it.methodSpec } - .forEach { typeBuilder.addMethod(it) } + .forEach { typeBuilder.addMethod(it) } } } } diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/UniqueGroupsDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/UniqueGroupsDefinition.kt index 158670145..42e0fcb21 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/UniqueGroupsDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/UniqueGroupsDefinition.kt @@ -25,19 +25,17 @@ class UniqueGroupsDefinition(uniqueGroup: UniqueGroup) { val creationName: CodeBlock get() { val codeBuilder = CodeBlock.builder().add(", UNIQUE(") - var count = 0 - columnDefinitionList.forEach { - if (count > 0) { + columnDefinitionList.forEachIndexed { index, columnDefinition -> + if (index > 0) { codeBuilder.add(",") } - if (it is ReferenceColumnDefinition) { - for (reference in it._referenceDefinitionList) { + if (columnDefinition is ReferenceColumnDefinition) { + for (reference in columnDefinition._referenceDefinitionList) { codeBuilder.add(reference.columnName.quote()) } } else { - codeBuilder.add(it.columnName.quote()) + codeBuilder.add(columnDefinition.columnName.quote()) } - count++ } codeBuilder.add(") ON CONFLICT \$L", uniqueConflict) return codeBuilder.build() diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/column/ColumnDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/column/ColumnDefinition.kt index 4723f7446..4f40ce7e6 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/column/ColumnDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/column/ColumnDefinition.kt @@ -330,7 +330,7 @@ constructor(processorManager: ProcessorManager, element: Element, new ${"$"}T() { @Override public ${"$"}T getTypeConverter(Class modelClass) { - ${"$"}T adapter = (${"$"}T) ${"$"}T.getInstanceAdapter(modelClass); + ${"$"}T adapter = (${"$"}T) ${"$"}T.getRetrievalAdapter(modelClass); return adapter.${"$"}L; } })""", diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/ContentProvider.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/content/ContentProvider.kt similarity index 97% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/ContentProvider.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/content/ContentProvider.kt index 575bdc884..985088cdc 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/ContentProvider.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/content/ContentProvider.kt @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5.processor.definition +package com.raizlabs.dbflow5.processor.definition.content import com.grosner.kpoet.L import com.grosner.kpoet.`=` @@ -22,6 +22,9 @@ import com.raizlabs.dbflow5.annotation.provider.TableEndpoint import com.raizlabs.dbflow5.processor.ClassNames import com.raizlabs.dbflow5.processor.ProcessorManager import com.raizlabs.dbflow5.processor.TableEndpointValidator +import com.raizlabs.dbflow5.processor.definition.BaseDefinition +import com.raizlabs.dbflow5.processor.definition.CodeAdder +import com.raizlabs.dbflow5.processor.definition.MethodDefinition import com.raizlabs.dbflow5.processor.utils.`override fun` import com.raizlabs.dbflow5.processor.utils.annotation import com.raizlabs.dbflow5.processor.utils.controlFlow @@ -327,7 +330,7 @@ class UpdateMethod(private val contentProviderDefinition: ContentProviderDefinit "long count = \$T.getDatabase(\$T.class).updateWithOnConflict(\$S, \$L, ", ClassNames.FLOW_MANAGER, contentProviderDefinition.databaseTypeName, tableEndpointDefinition.tableName, - Constants.PARAM_CONTENT_VALUES) + Constants.PARAM_CONTENT_VALUES) addCode(uriDefinition.getSelectionAndSelectionArgs()) addCode( ", \$T.getSQLiteDatabaseAlgorithmInt(adapter.getUpdateOnConflictAction()));\n", @@ -335,7 +338,7 @@ class UpdateMethod(private val contentProviderDefinition: ContentProviderDefinit val code = CodeBlock.builder() NotifyMethod(tableEndpointDefinition, uriDefinition, - NotifyMethod.UPDATE).addCode(code) + NotifyMethod.UPDATE).addCode(code) addCode(code.build()) addStatement("return (int) count") @@ -369,10 +372,10 @@ class ContentProviderDefinition(typeElement: Element, processorManager: Processo var endpointDefinitions = arrayListOf() private val methods: Array = arrayOf(QueryMethod(this, manager), - InsertMethod(this, false), - InsertMethod(this, true), - DeleteMethod(this, manager), - UpdateMethod(this, manager)) + InsertMethod(this, false), + InsertMethod(this, true), + DeleteMethod(this, manager), + UpdateMethod(this, manager)) init { element.annotation()?.let { provider -> @@ -422,7 +425,7 @@ class ContentProviderDefinition(typeElement: Element, processorManager: Processo `override fun`(TypeName.BOOLEAN, "onCreate") { modifiers(public, final) - addStatement("final \$T $AUTHORITY = \$L", String::class.java, + addStatement("final \$T ${AUTHORITY} = \$L", String::class.java, if (authority.contains("R.string.")) "getContext().getString($authority)" else diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/NotifyDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/content/NotifyDefinition.kt similarity index 94% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/NotifyDefinition.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/content/NotifyDefinition.kt index 048370a78..a0874815f 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/NotifyDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/content/NotifyDefinition.kt @@ -1,9 +1,10 @@ -package com.raizlabs.dbflow5.processor.definition +package com.raizlabs.dbflow5.processor.definition.content import com.raizlabs.dbflow5.annotation.provider.Notify import com.raizlabs.dbflow5.annotation.provider.NotifyMethod import com.raizlabs.dbflow5.processor.ClassNames import com.raizlabs.dbflow5.processor.ProcessorManager +import com.raizlabs.dbflow5.processor.definition.BaseDefinition import com.raizlabs.dbflow5.processor.utils.annotation import com.squareup.javapoet.ClassName import javax.lang.model.element.Element @@ -66,7 +67,5 @@ class NotifyDefinition(typeElement: Element, processorManager: ProcessorManager) } } - override fun getElementClassName(element: Element?): ClassName? { - return null - } + override fun getElementClassName(element: Element?): ClassName? = null } diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/TableEndpointDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/content/TableEndpointDefinition.kt similarity index 95% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/TableEndpointDefinition.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/content/TableEndpointDefinition.kt index 519be77ff..fecc89af3 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/TableEndpointDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/content/TableEndpointDefinition.kt @@ -1,10 +1,11 @@ -package com.raizlabs.dbflow5.processor.definition +package com.raizlabs.dbflow5.processor.definition.content import com.raizlabs.dbflow5.annotation.provider.ContentUri import com.raizlabs.dbflow5.annotation.provider.Notify import com.raizlabs.dbflow5.annotation.provider.NotifyMethod import com.raizlabs.dbflow5.annotation.provider.TableEndpoint import com.raizlabs.dbflow5.processor.ProcessorManager +import com.raizlabs.dbflow5.processor.definition.BaseDefinition import com.raizlabs.dbflow5.processor.utils.annotation import com.raizlabs.dbflow5.processor.utils.extractTypeNameFromAnnotation import com.squareup.javapoet.TypeName diff --git a/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/structure/RXRetrievalAdapter.kt b/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/structure/RXRetrievalAdapter.kt index b12d8e8f1..c76e1f5ec 100644 --- a/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/structure/RXRetrievalAdapter.kt +++ b/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/structure/RXRetrievalAdapter.kt @@ -13,7 +13,7 @@ import rx.Single open class RXRetrievalAdapter internal constructor(private val retrievalAdapter: RetrievalAdapter) { - internal constructor(table: Class) : this(FlowManager.getInstanceAdapter(table)) + internal constructor(table: Class) : this(FlowManager.getRetrievalAdapter(table)) fun load(model: T, databaseWrapper: DatabaseWrapper): Completable = Completable.fromCallable { retrievalAdapter.load(model, databaseWrapper) diff --git a/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/structure/RXRetrievalAdapter.kt b/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/structure/RXRetrievalAdapter.kt index f7fec3401..32cf6711f 100644 --- a/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/structure/RXRetrievalAdapter.kt +++ b/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/structure/RXRetrievalAdapter.kt @@ -1,7 +1,7 @@ package com.raizlabs.dbflow5.rx2.structure -import com.raizlabs.dbflow5.config.FlowManager import com.raizlabs.dbflow5.adapter.RetrievalAdapter +import com.raizlabs.dbflow5.config.FlowManager import com.raizlabs.dbflow5.database.DatabaseWrapper import io.reactivex.Completable import io.reactivex.Single @@ -13,7 +13,7 @@ import io.reactivex.Single open class RXRetrievalAdapter internal constructor(private val retrievalAdapter: RetrievalAdapter) { - internal constructor(table: Class) : this(FlowManager.getInstanceAdapter(table)) + internal constructor(table: Class) : this(FlowManager.getRetrievalAdapter(table)) fun load(model: T, databaseWrapper: DatabaseWrapper): Completable = Completable.fromCallable { retrievalAdapter.load(model, databaseWrapper) diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/InstanceAdapter.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/InstanceAdapter.kt deleted file mode 100644 index bc4e2226a..000000000 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/InstanceAdapter.kt +++ /dev/null @@ -1,16 +0,0 @@ -package com.raizlabs.dbflow5.adapter - -import com.raizlabs.dbflow5.config.DBFlowDatabase - -/** - * Description: Provides a [.newInstance] method to a [RetrievalAdapter] - */ -abstract class InstanceAdapter(databaseDefinition: DBFlowDatabase) - : RetrievalAdapter(databaseDefinition) { - - /** - * @return A new model using its default constructor. This is why default is required so that - * we don't use reflection to create objects = faster. - */ - abstract fun newInstance(): T -} diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/ModelAdapter.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/ModelAdapter.kt index fe26a8ef9..920fec709 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/ModelAdapter.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/ModelAdapter.kt @@ -18,7 +18,7 @@ import com.raizlabs.dbflow5.structure.InvalidDBConfiguration * Description: Used for generated classes from the combination of [Table] and [Model]. */ abstract class ModelAdapter(databaseDefinition: DBFlowDatabase) - : InstanceAdapter(databaseDefinition), InternalAdapter { + : RetrievalAdapter(databaseDefinition), InternalAdapter { private var insertStatement: DatabaseStatement? = null private var compiledStatement: DatabaseStatement? = null @@ -35,8 +35,8 @@ abstract class ModelAdapter(databaseDefinition: DBFlowDatabase) */ open val autoIncrementingColumnName: String get() = throw InvalidDBConfiguration("This method may have been called in error." + - " The model class $table must contain an autoincrementing" + - " or single int/long primary key (if used in a ModelCache, this method may be called)") + " The model class $table must contain an autoincrementing" + + " or single int/long primary key (if used in a ModelCache, this method may be called)") /** * @return The query used to create this table. @@ -103,7 +103,7 @@ abstract class ModelAdapter(databaseDefinition: DBFlowDatabase) * To bind values use [.bindToInsertStatement]. */ fun getInsertStatement(databaseWrapper: DatabaseWrapper): DatabaseStatement = - databaseWrapper.compileStatement(insertStatementQuery) + databaseWrapper.compileStatement(insertStatementQuery) /** * @param databaseWrapper The database used to do an update statement. @@ -111,7 +111,7 @@ abstract class ModelAdapter(databaseDefinition: DBFlowDatabase) * To bind values use [.bindToUpdateStatement]. */ fun getUpdateStatement(databaseWrapper: DatabaseWrapper): DatabaseStatement = - databaseWrapper.compileStatement(updateStatementQuery) + databaseWrapper.compileStatement(updateStatementQuery) /** * @param databaseWrapper The database used to do a delete statement. @@ -119,7 +119,7 @@ abstract class ModelAdapter(databaseDefinition: DBFlowDatabase) * To bind values use [.bindToDeleteStatement]. */ fun getDeleteStatement(databaseWrapper: DatabaseWrapper): DatabaseStatement = - databaseWrapper.compileStatement(deleteStatementQuery) + databaseWrapper.compileStatement(deleteStatementQuery) fun closeCompiledStatement() { compiledStatement?.close() @@ -132,31 +132,31 @@ abstract class ModelAdapter(databaseDefinition: DBFlowDatabase) * To bind values use [.bindToInsertStatement]. */ fun getCompiledStatement(databaseWrapper: DatabaseWrapper): DatabaseStatement = - databaseWrapper.compileStatement(compiledStatementQuery) + databaseWrapper.compileStatement(compiledStatementQuery) override fun save(model: T, databaseWrapper: DatabaseWrapper): Boolean = - modelSaver.save(model, databaseWrapper) + modelSaver.save(model, databaseWrapper) override fun saveAll(models: Collection, databaseWrapper: DatabaseWrapper): Long - = listModelSaver.saveAll(models, databaseWrapper) + = listModelSaver.saveAll(models, databaseWrapper) override fun insert(model: T, databaseWrapper: DatabaseWrapper): Long = - modelSaver.insert(model, databaseWrapper) + modelSaver.insert(model, databaseWrapper) override fun insertAll(models: Collection, databaseWrapper: DatabaseWrapper): Long - = listModelSaver.insertAll(models, databaseWrapper) + = listModelSaver.insertAll(models, databaseWrapper) override fun update(model: T, databaseWrapper: DatabaseWrapper): Boolean = - modelSaver.update(model, databaseWrapper) + modelSaver.update(model, databaseWrapper) override fun updateAll(models: Collection, databaseWrapper: DatabaseWrapper): Long - = listModelSaver.updateAll(models, databaseWrapper) + = listModelSaver.updateAll(models, databaseWrapper) override fun delete(model: T, databaseWrapper: DatabaseWrapper): Boolean = - modelSaver.delete(model, databaseWrapper) + modelSaver.delete(model, databaseWrapper) override fun deleteAll(models: Collection, databaseWrapper: DatabaseWrapper): Long - = listModelSaver.deleteAll(models, databaseWrapper) + = listModelSaver.deleteAll(models, databaseWrapper) override fun bindToInsertStatement(sqLiteStatement: DatabaseStatement, model: T) { bindToInsertStatement(sqLiteStatement, model, 0) @@ -168,7 +168,7 @@ abstract class ModelAdapter(databaseDefinition: DBFlowDatabase) override fun bindToInsertValues(contentValues: ContentValues, model: T) { throw RuntimeException("ContentValues are no longer generated automatically. To enable it," + - " set generateContentValues = true in @Table for $table.") + " set generateContentValues = true in @Table for $table.") } override fun bindToStatement(sqLiteStatement: DatabaseStatement, model: T) { diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/ModelViewAdapter.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/ModelViewAdapter.kt index 555c4c8f4..24775ce24 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/ModelViewAdapter.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/ModelViewAdapter.kt @@ -7,7 +7,7 @@ import com.raizlabs.dbflow5.database.DatabaseWrapper * Description: The base class for a [T] adapter that defines how it interacts with the DB. */ abstract class ModelViewAdapter(databaseDefinition: DBFlowDatabase) - : InstanceAdapter(databaseDefinition) { + : RetrievalAdapter(databaseDefinition) { /** * @return a string of the query that is used to create this model view. diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/QueryModelAdapter.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/QueryModelAdapter.kt index e3e186139..f24328939 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/QueryModelAdapter.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/QueryModelAdapter.kt @@ -10,7 +10,7 @@ import com.raizlabs.dbflow5.query.OperatorGroup * where query is not defined here, rather its determined by the query used. */ abstract class QueryModelAdapter(databaseDefinition: DBFlowDatabase) - : InstanceAdapter(databaseDefinition) { + : RetrievalAdapter(databaseDefinition) { override fun getPrimaryConditionClause(model: T): OperatorGroup { throw UnsupportedOperationException("QueryModels cannot check for existence") diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/ModelLoader.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/ModelLoader.kt index 7eeca1092..713859ff6 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/ModelLoader.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/ModelLoader.kt @@ -1,6 +1,6 @@ package com.raizlabs.dbflow5.adapter.queriable -import com.raizlabs.dbflow5.adapter.InstanceAdapter +import com.raizlabs.dbflow5.adapter.RetrievalAdapter import com.raizlabs.dbflow5.config.FlowManager import com.raizlabs.dbflow5.database.DatabaseWrapper import com.raizlabs.dbflow5.database.FlowCursor @@ -11,7 +11,7 @@ import com.raizlabs.dbflow5.database.FlowCursor */ abstract class ModelLoader(val modelClass: Class) { - val instanceAdapter: InstanceAdapter by lazy { FlowManager.getInstanceAdapter(modelClass) } + val instanceAdapter: RetrievalAdapter by lazy { FlowManager.getRetrievalAdapter(modelClass) } /** * Loads the data from a query and returns it as a [TReturn]. @@ -21,7 +21,7 @@ abstract class ModelLoader(val modelClass: Clas * @return The data loaded from the database. */ open fun load(databaseWrapper: DatabaseWrapper, query: String): TReturn? - = load(databaseWrapper.rawQuery(query, null), databaseWrapper) + = load(databaseWrapper.rawQuery(query, null), databaseWrapper) open fun load(cursor: FlowCursor?, databaseWrapper: DatabaseWrapper): TReturn? { var _data: TReturn? = null diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowManager.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowManager.kt index 9d9f610aa..2261c0f46 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowManager.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowManager.kt @@ -4,7 +4,6 @@ package com.raizlabs.dbflow5.config import android.annotation.SuppressLint import android.content.Context -import com.raizlabs.dbflow5.adapter.InstanceAdapter import com.raizlabs.dbflow5.adapter.ModelAdapter import com.raizlabs.dbflow5.adapter.ModelViewAdapter import com.raizlabs.dbflow5.adapter.QueryModelAdapter @@ -302,24 +301,6 @@ object FlowManager { loadedModules.clear() } - /** - * @param modelClass The class that implements [Model] to find an adapter for. - * @return The adapter associated with the class. If its not a [ModelAdapter], - * it checks both the [ModelViewAdapter] and [QueryModelAdapter]. - */ - @Suppress("UNCHECKED_CAST") - @JvmStatic - fun getInstanceAdapter(modelClass: Class): InstanceAdapter { - var internalAdapter: InstanceAdapter<*>? = getModelAdapterOrNull(modelClass) - if (internalAdapter == null) { - internalAdapter = getModelViewAdapterOrNull(modelClass) - if (internalAdapter == null) { - internalAdapter = getQueryModelAdapterOrNull(modelClass) - } - } - return internalAdapter as InstanceAdapter? ?: throwCannotFindAdapter("InstanceAdapter", modelClass) - } - /** * @param modelClass The class that implements [Model] to find an adapter for. * @return The adapter associated with the class. If its not a [ModelAdapter], diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseModelQueriable.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseModelQueriable.kt index e2975b647..90a5a7010 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseModelQueriable.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseModelQueriable.kt @@ -1,6 +1,6 @@ package com.raizlabs.dbflow5.query -import com.raizlabs.dbflow5.adapter.InstanceAdapter +import com.raizlabs.dbflow5.adapter.RetrievalAdapter import com.raizlabs.dbflow5.adapter.queriable.ListModelLoader import com.raizlabs.dbflow5.adapter.queriable.SingleModelLoader import com.raizlabs.dbflow5.config.FlowLog @@ -26,7 +26,7 @@ protected constructor(val databaseWrapper: DatabaseWrapper, table: Class) : BaseQueriable(databaseWrapper, table), ModelQueriable, Query { - private val retrievalAdapter: InstanceAdapter by lazy { FlowManager.getInstanceAdapter(table) } + private val retrievalAdapter: RetrievalAdapter by lazy { FlowManager.getRetrievalAdapter(table) } private val listModelLoader: ListModelLoader get() = retrievalAdapter.listModelLoader diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/CursorResult.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/CursorResult.kt index 93808da59..7ca5a418d 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/CursorResult.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/CursorResult.kt @@ -1,6 +1,6 @@ package com.raizlabs.dbflow5.query -import com.raizlabs.dbflow5.adapter.InstanceAdapter +import com.raizlabs.dbflow5.adapter.RetrievalAdapter import com.raizlabs.dbflow5.config.FlowManager import com.raizlabs.dbflow5.config.queryModelAdapter import com.raizlabs.dbflow5.database.DatabaseWrapper @@ -16,7 +16,7 @@ class CursorResult internal constructor(modelClass: Class, cursor: F private val databaseWrapper: DatabaseWrapper) : IFlowCursorIterator { - private val retrievalAdapter: InstanceAdapter + private val retrievalAdapter: RetrievalAdapter private var _cursor: FlowCursor? = null @@ -27,7 +27,7 @@ class CursorResult internal constructor(modelClass: Class, cursor: F if (cursor != null) { this._cursor = FlowCursor.from(cursor) } - retrievalAdapter = FlowManager.getInstanceAdapter(modelClass) + retrievalAdapter = FlowManager.getRetrievalAdapter(modelClass) } /** @@ -64,7 +64,7 @@ class CursorResult internal constructor(modelClass: Class, cursor: F fun toCustomList(customClass: Class): List { return _cursor?.let { cursor -> return@let customClass.queryModelAdapter - .listModelLoader.convertToData(cursor, databaseWrapper) + .listModelLoader.convertToData(cursor, databaseWrapper) } ?: arrayListOf() } @@ -73,7 +73,7 @@ class CursorResult internal constructor(modelClass: Class, cursor: F */ fun toCustomListClose(customClass: Class): List { val customList = customClass.queryModelAdapter.listModelLoader - .load(_cursor, databaseWrapper) ?: arrayListOf() + .load(_cursor, databaseWrapper) ?: arrayListOf() close() return customList } @@ -125,7 +125,7 @@ class CursorResult internal constructor(modelClass: Class, cursor: F override fun iterator(): FlowCursorIterator = FlowCursorIterator(this) override fun iterator(startingLocation: Int, limit: Long): FlowCursorIterator = - FlowCursorIterator(this, startingLocation, limit) + FlowCursorIterator(this, startingLocation, limit) override val cursor: FlowCursor? get() = _cursor diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowCursorList.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowCursorList.kt index 542f119ed..829685061 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowCursorList.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowCursorList.kt @@ -1,7 +1,7 @@ package com.raizlabs.dbflow5.query.list import android.widget.ListView -import com.raizlabs.dbflow5.adapter.InstanceAdapter +import com.raizlabs.dbflow5.adapter.RetrievalAdapter import com.raizlabs.dbflow5.config.FlowLog import com.raizlabs.dbflow5.config.FlowManager import com.raizlabs.dbflow5.database.FlowCursor @@ -30,7 +30,7 @@ class FlowCursorList private constructor(builder: Builder) : IFlowCu private var _cursor: FlowCursor? = null private val cursorFunc: () -> FlowCursor - internal val instanceAdapter: InstanceAdapter + internal val instanceAdapter: RetrievalAdapter private val cursorRefreshListenerSet = hashSetOf>() @@ -62,13 +62,13 @@ class FlowCursorList private constructor(builder: Builder) : IFlowCu table = builder.modelClass this.modelQueriable = builder.modelQueriable cursorFunc = { builder.cursor ?: modelQueriable.query() ?: throw IllegalStateException("The query must evaluate to a cursor") } - instanceAdapter = FlowManager.getInstanceAdapter(builder.modelClass) + instanceAdapter = FlowManager.getRetrievalAdapter(builder.modelClass) } override operator fun iterator(): FlowCursorIterator = FlowCursorIterator(this) override fun iterator(startingLocation: Int, limit: Long): FlowCursorIterator = - FlowCursorIterator(this, startingLocation, limit) + FlowCursorIterator(this, startingLocation, limit) /** * Register listener for when cursor refreshes. @@ -111,9 +111,9 @@ class FlowCursorList private constructor(builder: Builder) : IFlowCu val cursor = unpackCursor() return if (cursor.moveToPosition(position.toInt())) { instanceAdapter.singleModelLoader.convertToData( - FlowCursor.from(cursor), false, - FlowManager.getDatabaseForTable(table)) - ?: throw IndexOutOfBoundsException("Invalid item at position $position. Check your cursor data.") + FlowCursor.from(cursor), false, + FlowManager.getDatabaseForTable(table)) + ?: throw IndexOutOfBoundsException("Invalid item at position $position. Check your cursor data.") } else { throw IndexOutOfBoundsException("Invalid item at position $position. Check your cursor data.") } diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowQueryList.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowQueryList.kt index 408cd231b..c21902dc5 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowQueryList.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowQueryList.kt @@ -2,7 +2,7 @@ package com.raizlabs.dbflow5.query.list import android.os.Handler import android.os.Looper -import com.raizlabs.dbflow5.adapter.InstanceAdapter +import com.raizlabs.dbflow5.adapter.RetrievalAdapter import com.raizlabs.dbflow5.database.FlowCursor import com.raizlabs.dbflow5.query.ModelQueriable import com.raizlabs.dbflow5.query.list.FlowCursorList.OnCursorRefreshListener @@ -13,10 +13,10 @@ import com.raizlabs.dbflow5.query.list.FlowCursorList.OnCursorRefreshListener * it leaves a [FlowCursor] object active. */ class FlowQueryList( - /** - * Holds the table cursor - */ - val internalCursorList: FlowCursorList) + /** + * Holds the table cursor + */ + val internalCursorList: FlowCursorList) : List, IFlowCursorIterator { private var pendingRefresh = false @@ -27,7 +27,7 @@ class FlowQueryList( val copy: List get() = internalCursorList.all - internal val instanceAdapter: InstanceAdapter + internal val retrievalAdapter: RetrievalAdapter get() = internalCursorList.instanceAdapter override val count: Long @@ -49,9 +49,9 @@ class FlowQueryList( } internal constructor(builder: Builder) : this( - internalCursorList = FlowCursorList.Builder(builder.modelQueriable) - .cursor(builder.cursor) - .build() + internalCursorList = FlowCursorList.Builder(builder.modelQueriable) + .cursor(builder.cursor) + .build() ) fun addOnCursorRefreshListener(onCursorRefreshListener: OnCursorRefreshListener) { @@ -132,7 +132,7 @@ class FlowQueryList( override fun indexOf(element: T): Int { throw UnsupportedOperationException( - "We cannot determine which index in the table this item exists at efficiently") + "We cannot determine which index in the table this item exists at efficiently") } override fun isEmpty(): Boolean { @@ -153,7 +153,7 @@ class FlowQueryList( override fun lastIndexOf(element: T): Int { throw UnsupportedOperationException( - "We cannot determine which index in the table this item exists at efficiently") + "We cannot determine which index in the table this item exists at efficiently") } /** diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/structure/NoModificationModel.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/structure/NoModificationModel.kt index e1b84ca8c..21cbeb13f 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/structure/NoModificationModel.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/structure/NoModificationModel.kt @@ -10,7 +10,7 @@ import com.raizlabs.dbflow5.database.DatabaseWrapper abstract class NoModificationModel : ReadOnlyModel { @delegate:Transient - private val retrievalAdapter: RetrievalAdapter by lazy { FlowManager.getInstanceAdapter(javaClass) } + private val retrievalAdapter: RetrievalAdapter by lazy { FlowManager.getRetrievalAdapter(javaClass) } override fun exists(wrapper: DatabaseWrapper): Boolean = retrievalAdapter.exists(this, wrapper) From 67a0e5c9dbf8e80c72d400939b581170766c928e Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Fri, 8 Dec 2017 12:13:20 -0500 Subject: [PATCH 139/234] [processor] rename package to provider to match other uses. --- .../src/main/java/com/raizlabs/dbflow5/processor/Handlers.kt | 4 ++-- .../java/com/raizlabs/dbflow5/processor/ProcessorManager.kt | 4 ++-- .../main/java/com/raizlabs/dbflow5/processor/Validators.kt | 4 ++-- .../dbflow5/processor/definition/DatabaseObjectHolder.kt | 2 +- .../definition/{content => provider}/ContentProvider.kt | 2 +- .../definition/{content => provider}/NotifyDefinition.kt | 2 +- .../{content => provider}/TableEndpointDefinition.kt | 2 +- .../src/main/java/com/raizlabs/dbflow5/config/FlowManager.kt | 2 +- 8 files changed, 11 insertions(+), 11 deletions(-) rename dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/{content => provider}/ContentProvider.kt (99%) rename dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/{content => provider}/NotifyDefinition.kt (97%) rename dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/{content => provider}/TableEndpointDefinition.kt (97%) diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/Handlers.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/Handlers.kt index 933e11dbd..a29b65bcf 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/Handlers.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/Handlers.kt @@ -18,14 +18,14 @@ import com.raizlabs.dbflow5.converter.CharConverter import com.raizlabs.dbflow5.converter.DateConverter import com.raizlabs.dbflow5.converter.SqlDateConverter import com.raizlabs.dbflow5.converter.UUIDConverter -import com.raizlabs.dbflow5.processor.definition.content.ContentProviderDefinition +import com.raizlabs.dbflow5.processor.definition.provider.ContentProviderDefinition import com.raizlabs.dbflow5.processor.definition.DatabaseDefinition import com.raizlabs.dbflow5.processor.definition.ManyToManyDefinition import com.raizlabs.dbflow5.processor.definition.MigrationDefinition import com.raizlabs.dbflow5.processor.definition.ModelViewDefinition import com.raizlabs.dbflow5.processor.definition.QueryModelDefinition import com.raizlabs.dbflow5.processor.definition.TableDefinition -import com.raizlabs.dbflow5.processor.definition.content.TableEndpointDefinition +import com.raizlabs.dbflow5.processor.definition.provider.TableEndpointDefinition import com.raizlabs.dbflow5.processor.definition.TypeConverterDefinition import com.raizlabs.dbflow5.processor.utils.annotation import javax.annotation.processing.RoundEnvironment diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/ProcessorManager.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/ProcessorManager.kt index 705a4bedd..8adc4fa8d 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/ProcessorManager.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/ProcessorManager.kt @@ -1,7 +1,7 @@ package com.raizlabs.dbflow5.processor import com.raizlabs.dbflow5.processor.definition.BaseTableDefinition -import com.raizlabs.dbflow5.processor.definition.content.ContentProviderDefinition +import com.raizlabs.dbflow5.processor.definition.provider.ContentProviderDefinition import com.raizlabs.dbflow5.processor.definition.DatabaseDefinition import com.raizlabs.dbflow5.processor.definition.DatabaseHolderDefinition import com.raizlabs.dbflow5.processor.definition.DatabaseObjectHolder @@ -10,7 +10,7 @@ import com.raizlabs.dbflow5.processor.definition.MigrationDefinition import com.raizlabs.dbflow5.processor.definition.ModelViewDefinition import com.raizlabs.dbflow5.processor.definition.QueryModelDefinition import com.raizlabs.dbflow5.processor.definition.TableDefinition -import com.raizlabs.dbflow5.processor.definition.content.TableEndpointDefinition +import com.raizlabs.dbflow5.processor.definition.provider.TableEndpointDefinition import com.raizlabs.dbflow5.processor.definition.TypeConverterDefinition import com.raizlabs.dbflow5.processor.utils.WriterUtils import com.squareup.javapoet.ClassName diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/Validators.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/Validators.kt index f4dd67ca6..2aadc40f0 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/Validators.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/Validators.kt @@ -5,8 +5,8 @@ import com.raizlabs.dbflow5.processor.definition.column.ColumnDefinition import com.raizlabs.dbflow5.processor.definition.column.EnumColumnAccessor import com.raizlabs.dbflow5.processor.definition.column.ReferenceColumnDefinition import com.raizlabs.dbflow5.processor.definition.column.PrivateScopeColumnAccessor -import com.raizlabs.dbflow5.processor.definition.content.ContentProviderDefinition -import com.raizlabs.dbflow5.processor.definition.content.TableEndpointDefinition +import com.raizlabs.dbflow5.processor.definition.provider.ContentProviderDefinition +import com.raizlabs.dbflow5.processor.definition.provider.TableEndpointDefinition import com.raizlabs.dbflow5.processor.utils.isNullOrEmpty diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/DatabaseObjectHolder.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/DatabaseObjectHolder.kt index c2d8b1f92..cbce9e3e6 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/DatabaseObjectHolder.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/DatabaseObjectHolder.kt @@ -1,6 +1,6 @@ package com.raizlabs.dbflow5.processor.definition -import com.raizlabs.dbflow5.processor.definition.content.ContentProviderDefinition +import com.raizlabs.dbflow5.processor.definition.provider.ContentProviderDefinition import com.squareup.javapoet.TypeName /** diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/content/ContentProvider.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/provider/ContentProvider.kt similarity index 99% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/content/ContentProvider.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/provider/ContentProvider.kt index 985088cdc..50131d55e 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/content/ContentProvider.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/provider/ContentProvider.kt @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5.processor.definition.content +package com.raizlabs.dbflow5.processor.definition.provider import com.grosner.kpoet.L import com.grosner.kpoet.`=` diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/content/NotifyDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/provider/NotifyDefinition.kt similarity index 97% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/content/NotifyDefinition.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/provider/NotifyDefinition.kt index a0874815f..9204f9bc6 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/content/NotifyDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/provider/NotifyDefinition.kt @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5.processor.definition.content +package com.raizlabs.dbflow5.processor.definition.provider import com.raizlabs.dbflow5.annotation.provider.Notify import com.raizlabs.dbflow5.annotation.provider.NotifyMethod diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/content/TableEndpointDefinition.kt b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/provider/TableEndpointDefinition.kt similarity index 97% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/content/TableEndpointDefinition.kt rename to dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/provider/TableEndpointDefinition.kt index fecc89af3..726841507 100644 --- a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/content/TableEndpointDefinition.kt +++ b/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/provider/TableEndpointDefinition.kt @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5.processor.definition.content +package com.raizlabs.dbflow5.processor.definition.provider import com.raizlabs.dbflow5.annotation.provider.ContentUri import com.raizlabs.dbflow5.annotation.provider.Notify diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowManager.kt b/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowManager.kt index 2261c0f46..1e242f2af 100644 --- a/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowManager.kt +++ b/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowManager.kt @@ -41,7 +41,7 @@ object FlowManager { private val DEFAULT_DATABASE_HOLDER_PACKAGE_NAME = FlowManager::class.java.`package`.name private val DEFAULT_DATABASE_HOLDER_CLASSNAME = - DEFAULT_DATABASE_HOLDER_PACKAGE_NAME + "." + DEFAULT_DATABASE_HOLDER_NAME + "$DEFAULT_DATABASE_HOLDER_PACKAGE_NAME.$DEFAULT_DATABASE_HOLDER_NAME" /** * Will throw an exception if this class is not initialized yet in [.init] From 9c819fb7e497c66c09c5fda10ccb8409d20295e6 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Fri, 8 Dec 2017 12:21:46 -0500 Subject: [PATCH 140/234] [lib] move java to kotlin dirs. remove explicit apply of java plugin for kotlin only artifacts. --- dbflow-core/build.gradle | 3 +-- .../{java => kotlin}/com/raizlabs/dbflow5/StringUtils.kt | 0 .../com/raizlabs/dbflow5/annotation/Collate.kt | 0 .../com/raizlabs/dbflow5/annotation/Column.kt | 0 .../com/raizlabs/dbflow5/annotation/ColumnIgnore.kt | 0 .../com/raizlabs/dbflow5/annotation/ColumnMap.kt | 0 .../com/raizlabs/dbflow5/annotation/ColumnMapReference.kt | 0 .../com/raizlabs/dbflow5/annotation/ConflictAction.kt | 0 .../com/raizlabs/dbflow5/annotation/Database.kt | 0 .../com/raizlabs/dbflow5/annotation/ForeignKey.kt | 0 .../com/raizlabs/dbflow5/annotation/ForeignKeyAction.kt | 0 .../com/raizlabs/dbflow5/annotation/ForeignKeyReference.kt | 0 .../com/raizlabs/dbflow5/annotation/Index.kt | 0 .../com/raizlabs/dbflow5/annotation/IndexGroup.kt | 0 .../com/raizlabs/dbflow5/annotation/InheritedColumn.kt | 0 .../com/raizlabs/dbflow5/annotation/InheritedPrimaryKey.kt | 0 .../com/raizlabs/dbflow5/annotation/ManyToMany.kt | 0 .../com/raizlabs/dbflow5/annotation/Migration.kt | 0 .../com/raizlabs/dbflow5/annotation/ModelCacheField.kt | 0 .../com/raizlabs/dbflow5/annotation/ModelView.kt | 0 .../com/raizlabs/dbflow5/annotation/ModelViewQuery.kt | 0 .../com/raizlabs/dbflow5/annotation/MultiCacheField.kt | 0 .../com/raizlabs/dbflow5/annotation/MultipleManyToMany.kt | 0 .../com/raizlabs/dbflow5/annotation/NotNull.kt | 0 .../com/raizlabs/dbflow5/annotation/OneToMany.kt | 0 .../com/raizlabs/dbflow5/annotation/PrimaryKey.kt | 0 .../com/raizlabs/dbflow5/annotation/QueryModel.kt | 0 .../com/raizlabs/dbflow5/annotation/Table.kt | 0 .../com/raizlabs/dbflow5/annotation/TypeConverter.kt | 0 .../com/raizlabs/dbflow5/annotation/Unique.kt | 0 .../com/raizlabs/dbflow5/annotation/UniqueGroup.kt | 0 .../raizlabs/dbflow5/annotation/provider/ContentProvider.kt | 0 .../com/raizlabs/dbflow5/annotation/provider/ContentUri.kt | 0 .../com/raizlabs/dbflow5/annotation/provider/Notify.kt | 0 .../raizlabs/dbflow5/annotation/provider/TableEndpoint.kt | 0 .../com/raizlabs/dbflow5/converter/TypeConverters.kt | 0 .../main/{java => kotlin}/com/raizlabs/dbflow5/data/Blob.kt | 0 .../main/{java => kotlin}/com/raizlabs/dbflow5/sql/Query.kt | 0 .../{java => kotlin}/com/raizlabs/dbflow5/sql/SQLiteType.kt | 0 .../com/raizlabs/dbflow5/coroutines/Coroutines.kt | 0 dbflow-processor/build.gradle | 5 +---- .../com/raizlabs/dbflow5/processor/ClassNames.kt | 0 .../com/raizlabs/dbflow5/processor/DBFlowProcessor.kt | 0 .../com/raizlabs/dbflow5/processor/Handlers.kt | 0 .../com/raizlabs/dbflow5/processor/ProcessorManager.kt | 0 .../com/raizlabs/dbflow5/processor/ProcessorUtils.kt | 0 .../com/raizlabs/dbflow5/processor/SQLiteHelper.kt | 0 .../com/raizlabs/dbflow5/processor/Validators.kt | 0 .../com/raizlabs/dbflow5/processor/definition/Adders.kt | 0 .../raizlabs/dbflow5/processor/definition/BaseDefinition.kt | 0 .../dbflow5/processor/definition/BaseTableDefinition.kt | 0 .../dbflow5/processor/definition/DatabaseDefinition.kt | 0 .../dbflow5/processor/definition/DatabaseHolderDefinition.kt | 0 .../dbflow5/processor/definition/DatabaseObjectHolder.kt | 0 .../dbflow5/processor/definition/IndexGroupsDefinition.kt | 0 .../dbflow5/processor/definition/ManyToManyDefinition.kt | 0 .../com/raizlabs/dbflow5/processor/definition/Methods.kt | 0 .../dbflow5/processor/definition/MigrationDefinition.kt | 0 .../dbflow5/processor/definition/ModelViewDefinition.kt | 0 .../dbflow5/processor/definition/OneToManyDefinition.kt | 0 .../dbflow5/processor/definition/QueryModelDefinition.kt | 0 .../raizlabs/dbflow5/processor/definition/TableDefinition.kt | 0 .../dbflow5/processor/definition/TypeConverterDefinition.kt | 0 .../raizlabs/dbflow5/processor/definition/TypeDefinition.kt | 0 .../dbflow5/processor/definition/UniqueGroupsDefinition.kt | 0 .../processor/definition/column/ColumnAccessCombiner.kt | 0 .../dbflow5/processor/definition/column/ColumnAccessor.kt | 0 .../dbflow5/processor/definition/column/ColumnDefinition.kt | 0 .../dbflow5/processor/definition/column/DefinitionUtils.kt | 0 .../processor/definition/column/ForeignKeyAccessCombiner.kt | 0 .../processor/definition/column/ReferenceColumnDefinition.kt | 0 .../processor/definition/column/ReferenceDefinition.kt | 0 .../dbflow5/processor/definition/provider/ContentProvider.kt | 0 .../processor/definition/provider/NotifyDefinition.kt | 0 .../processor/definition/provider/TableEndpointDefinition.kt | 0 .../com/raizlabs/dbflow5/processor/utils/CodeExtensions.kt | 0 .../com/raizlabs/dbflow5/processor/utils/DependencyUtils.kt | 0 .../raizlabs/dbflow5/processor/utils/ElementExtensions.kt | 0 .../com/raizlabs/dbflow5/processor/utils/ElementUtility.kt | 0 .../raizlabs/dbflow5/processor/utils/JavaPoetExtensions.kt | 0 .../com/raizlabs/dbflow5/processor/utils/ModelUtils.kt | 0 .../com/raizlabs/dbflow5/processor/utils/ProcessorUtils.kt | 0 .../com/raizlabs/dbflow5/processor/utils/StringUtils.kt | 0 .../com/raizlabs/dbflow5/processor/utils/WriterUtils.kt | 0 dbflow-rx/build.gradle | 4 ++++ .../com/raizlabs/dbflow5/rx/query/CursorResultSubscriber.kt | 0 .../com/raizlabs/dbflow5/rx/query/RXModelQueriable.kt | 0 .../com/raizlabs/dbflow5/rx/query/RXModelQueriableImpl.kt | 0 .../com/raizlabs/dbflow5/rx/query/RXQueriable.kt | 0 .../com/raizlabs/dbflow5/rx/query/RXQueriableImpl.kt | 0 .../com/raizlabs/dbflow5/rx/query/RXSQLite.kt | 0 .../dbflow5/rx/query/TableChangeListenerEmitter.java | 0 .../com/raizlabs/dbflow5/rx/structure/BaseRXModel.kt | 0 .../com/raizlabs/dbflow5/rx/structure/RXModelAdapter.kt | 0 .../com/raizlabs/dbflow5/rx/structure/RXRetrievalAdapter.kt | 0 .../raizlabs/dbflow5/rx/transaction/TransactionObservable.kt | 0 dbflow-rx2/build.gradle | 4 ++++ .../com/raizlabs/dbflow5/rx2/query/CursorResultFlowable.kt | 0 .../com/raizlabs/dbflow5/rx2/query/RXModelQueriable.kt | 0 .../com/raizlabs/dbflow5/rx2/query/RXModelQueriableImpl.kt | 0 .../com/raizlabs/dbflow5/rx2/query/RXQueriable.kt | 0 .../com/raizlabs/dbflow5/rx2/query/RXQueriableImpl.kt | 0 .../com/raizlabs/dbflow5/rx2/query/RXSQLite.kt | 0 .../com/raizlabs/dbflow5/rx2/query/TableChangeOnSubscribe.kt | 0 .../com/raizlabs/dbflow5/rx2/structure/BaseRXModel.kt | 0 .../com/raizlabs/dbflow5/rx2/structure/RXModelAdapter.kt | 0 .../com/raizlabs/dbflow5/rx2/structure/RXRetrievalAdapter.kt | 0 .../dbflow5/rx2/transaction/TransactionObservable.kt | 0 dbflow-sqlcipher/build.gradle | 4 ++++ .../com/raizlabs/dbflow5/sqlcipher/SQLCipherDatabase.kt | 0 .../com/raizlabs/dbflow5/sqlcipher/SQLCipherOpenHelper.kt | 0 .../com/raizlabs/dbflow5/sqlcipher/SQLCipherStatement.kt | 0 dbflow/build.gradle | 3 +++ .../main/{java => kotlin}/com/raizlabs/dbflow5/SqlUtils.kt | 0 .../com/raizlabs/dbflow5/adapter/CacheAdapter.kt | 0 .../com/raizlabs/dbflow5/adapter/InternalAdapter.kt | 0 .../com/raizlabs/dbflow5/adapter/ModelAdapter.kt | 0 .../com/raizlabs/dbflow5/adapter/ModelViewAdapter.kt | 0 .../com/raizlabs/dbflow5/adapter/QueryModelAdapter.kt | 0 .../com/raizlabs/dbflow5/adapter/RetrievalAdapter.kt | 0 .../dbflow5/adapter/queriable/CacheableListModelLoader.kt | 0 .../dbflow5/adapter/queriable/CacheableModelLoader.kt | 0 .../raizlabs/dbflow5/adapter/queriable/ListModelLoader.kt | 0 .../com/raizlabs/dbflow5/adapter/queriable/ModelLoader.kt | 0 .../adapter/queriable/SingleKeyCacheableListModelLoader.kt | 0 .../adapter/queriable/SingleKeyCacheableModelLoader.kt | 0 .../raizlabs/dbflow5/adapter/queriable/SingleModelLoader.kt | 0 .../dbflow5/adapter/saveable/AutoIncrementModelSaver.kt | 0 .../dbflow5/adapter/saveable/CacheableListModelSaver.kt | 0 .../com/raizlabs/dbflow5/adapter/saveable/ListModelSaver.kt | 0 .../com/raizlabs/dbflow5/adapter/saveable/ModelSaver.kt | 0 .../com/raizlabs/dbflow5/config/DBFlowDatabase.kt | 0 .../com/raizlabs/dbflow5/config/DatabaseConfig.kt | 0 .../com/raizlabs/dbflow5/config/DatabaseHolder.kt | 0 .../com/raizlabs/dbflow5/config/FlowConfig.kt | 0 .../{java => kotlin}/com/raizlabs/dbflow5/config/FlowLog.kt | 0 .../com/raizlabs/dbflow5/config/FlowManager.kt | 0 .../com/raizlabs/dbflow5/config/NaturalOrderComparator.java | 0 .../com/raizlabs/dbflow5/config/TableConfig.kt | 0 .../com/raizlabs/dbflow5/database/AndroidDatabase.kt | 0 .../raizlabs/dbflow5/database/AndroidDatabaseStatement.kt | 0 .../com/raizlabs/dbflow5/database/AndroidSQLiteOpenHelper.kt | 0 .../com/raizlabs/dbflow5/database/BaseDatabaseHelper.kt | 0 .../com/raizlabs/dbflow5/database/BaseDatabaseStatement.kt | 0 .../com/raizlabs/dbflow5/database/ContentValueExtensions.kt | 0 .../com/raizlabs/dbflow5/database/DatabaseCallback.kt | 0 .../com/raizlabs/dbflow5/database/DatabaseHelperDelegate.kt | 0 .../com/raizlabs/dbflow5/database/DatabaseStatement.kt | 0 .../raizlabs/dbflow5/database/DatabaseStatementWrapper.kt | 0 .../com/raizlabs/dbflow5/database/DatabaseWrapper.kt | 0 .../com/raizlabs/dbflow5/database/FlowCursor.kt | 0 .../com/raizlabs/dbflow5/database/OpenHelper.kt | 0 .../com/raizlabs/dbflow5/database/SQLiteException.kt | 0 .../com/raizlabs/dbflow5/migration/AlterTableMigration.kt | 0 .../com/raizlabs/dbflow5/migration/BaseMigration.kt | 0 .../com/raizlabs/dbflow5/migration/IndexMigration.kt | 0 .../com/raizlabs/dbflow5/migration/IndexPropertyMigration.kt | 0 .../com/raizlabs/dbflow5/migration/Migration.kt | 0 .../com/raizlabs/dbflow5/migration/UpdateTableMigration.kt | 0 .../com/raizlabs/dbflow5/provider/BaseContentProvider.kt | 0 .../com/raizlabs/dbflow5/provider/BaseProviderModel.kt | 0 .../raizlabs/dbflow5/provider/BaseSyncableProviderModel.kt | 0 .../com/raizlabs/dbflow5/provider/ContentUtils.kt | 0 .../com/raizlabs/dbflow5/provider/ModelProvider.kt | 0 .../com/raizlabs/dbflow5/query/Actionable.kt | 0 .../com/raizlabs/dbflow5/query/BaseModelQueriable.kt | 0 .../com/raizlabs/dbflow5/query/BaseOperator.kt | 0 .../com/raizlabs/dbflow5/query/BaseQueriable.kt | 0 .../com/raizlabs/dbflow5/query/BaseTransformable.kt | 0 .../main/{java => kotlin}/com/raizlabs/dbflow5/query/Case.kt | 0 .../com/raizlabs/dbflow5/query/CaseCondition.kt | 0 .../com/raizlabs/dbflow5/query/CompletedTrigger.kt | 0 .../com/raizlabs/dbflow5/query/ContentValuesListener.kt | 0 .../com/raizlabs/dbflow5/query/CursorResult.kt | 0 .../{java => kotlin}/com/raizlabs/dbflow5/query/Delete.kt | 0 .../com/raizlabs/dbflow5/query/ExistenceOperator.kt | 0 .../main/{java => kotlin}/com/raizlabs/dbflow5/query/From.kt | 0 .../com/raizlabs/dbflow5/query/IConditional.kt | 0 .../{java => kotlin}/com/raizlabs/dbflow5/query/IOperator.kt | 0 .../{java => kotlin}/com/raizlabs/dbflow5/query/Index.kt | 0 .../{java => kotlin}/com/raizlabs/dbflow5/query/IndexedBy.kt | 0 .../{java => kotlin}/com/raizlabs/dbflow5/query/Insert.kt | 0 .../main/{java => kotlin}/com/raizlabs/dbflow5/query/Join.kt | 0 .../com/raizlabs/dbflow5/query/LoadFromCursorListener.kt | 0 .../{java => kotlin}/com/raizlabs/dbflow5/query/Method.kt | 0 .../com/raizlabs/dbflow5/query/ModelQueriable.kt | 0 .../{java => kotlin}/com/raizlabs/dbflow5/query/NameAlias.kt | 0 .../{java => kotlin}/com/raizlabs/dbflow5/query/Operator.kt | 0 .../com/raizlabs/dbflow5/query/OperatorGroup.kt | 0 .../{java => kotlin}/com/raizlabs/dbflow5/query/OrderBy.kt | 0 .../{java => kotlin}/com/raizlabs/dbflow5/query/Queriable.kt | 0 .../com/raizlabs/dbflow5/query/SQLOperator.kt | 0 .../{java => kotlin}/com/raizlabs/dbflow5/query/SQLite.kt | 0 .../com/raizlabs/dbflow5/query/SQLiteStatementListener.kt | 0 .../{java => kotlin}/com/raizlabs/dbflow5/query/Select.kt | 0 .../main/{java => kotlin}/com/raizlabs/dbflow5/query/Set.kt | 0 .../com/raizlabs/dbflow5/query/StringQuery.kt | 0 .../com/raizlabs/dbflow5/query/Transformable.kt | 0 .../{java => kotlin}/com/raizlabs/dbflow5/query/Trigger.kt | 0 .../com/raizlabs/dbflow5/query/TriggerMethod.kt | 0 .../com/raizlabs/dbflow5/query/UnSafeStringOperator.kt | 0 .../{java => kotlin}/com/raizlabs/dbflow5/query/Update.kt | 0 .../{java => kotlin}/com/raizlabs/dbflow5/query/Where.kt | 0 .../{java => kotlin}/com/raizlabs/dbflow5/query/WhereBase.kt | 0 .../raizlabs/dbflow5/query/cache/IMultiKeyCacheConverter.kt | 0 .../com/raizlabs/dbflow5/query/cache/ModelCache.kt | 0 .../com/raizlabs/dbflow5/query/cache/ModelLruCache.kt | 0 .../com/raizlabs/dbflow5/query/cache/SimpleMapCache.kt | 0 .../raizlabs/dbflow5/query/cache/SparseArrayBasedCache.kt | 0 .../com/raizlabs/dbflow5/query/list/FlowCursorIterator.kt | 0 .../com/raizlabs/dbflow5/query/list/FlowCursorList.kt | 0 .../com/raizlabs/dbflow5/query/list/FlowQueryList.kt | 0 .../com/raizlabs/dbflow5/query/list/IFlowCursorIterator.kt | 0 .../com/raizlabs/dbflow5/query/property/IProperty.kt | 0 .../com/raizlabs/dbflow5/query/property/IndexProperty.kt | 0 .../com/raizlabs/dbflow5/query/property/Property.kt | 0 .../com/raizlabs/dbflow5/query/property/PropertyFactory.kt | 0 .../raizlabs/dbflow5/query/property/TypeConvertedProperty.kt | 0 .../com/raizlabs/dbflow5/query/property/WrapperProperty.kt | 0 .../com/raizlabs/dbflow5/runtime/ContentResolverNotifier.kt | 0 .../com/raizlabs/dbflow5/runtime/DBBatchSaveQueue.kt | 0 .../com/raizlabs/dbflow5/runtime/DirectModelNotifier.kt | 0 .../com/raizlabs/dbflow5/runtime/FlowContentObserver.kt | 0 .../com/raizlabs/dbflow5/runtime/ModelNotifier.kt | 0 .../com/raizlabs/dbflow5/runtime/NotifyDistributor.kt | 0 .../com/raizlabs/dbflow5/runtime/OnTableChangedListener.kt | 0 .../com/raizlabs/dbflow5/runtime/TableNotifierRegister.kt | 0 .../com/raizlabs/dbflow5/structure/Action.kt | 0 .../com/raizlabs/dbflow5/structure/BaseModel.kt | 0 .../com/raizlabs/dbflow5/structure/BaseModelView.kt | 0 .../com/raizlabs/dbflow5/structure/BaseQueryModel.kt | 0 .../com/raizlabs/dbflow5/structure/InvalidDBConfiguration.kt | 0 .../{java => kotlin}/com/raizlabs/dbflow5/structure/Model.kt | 0 .../com/raizlabs/dbflow5/structure/NoModificationModel.kt | 0 .../com/raizlabs/dbflow5/structure/OneToMany.kt | 0 .../com/raizlabs/dbflow5/structure/ReadOnlyModel.kt | 0 .../raizlabs/dbflow5/transaction/BaseTransactionManager.kt | 0 .../dbflow5/transaction/DefaultTransactionManager.kt | 0 .../raizlabs/dbflow5/transaction/DefaultTransactionQueue.kt | 0 .../dbflow5/transaction/FastStoreModelTransaction.kt | 0 .../com/raizlabs/dbflow5/transaction/ITransaction.kt | 0 .../com/raizlabs/dbflow5/transaction/ITransactionQueue.kt | 0 .../raizlabs/dbflow5/transaction/PriorityTransactionQueue.kt | 0 .../dbflow5/transaction/PriorityTransactionWrapper.kt | 0 .../raizlabs/dbflow5/transaction/ProcessModelTransaction.kt | 0 .../com/raizlabs/dbflow5/transaction/Transaction.kt | 0 .../com/raizlabs/dbflow5/transaction/TransactionWrapper.kt | 0 247 files changed, 17 insertions(+), 6 deletions(-) rename dbflow-core/src/main/{java => kotlin}/com/raizlabs/dbflow5/StringUtils.kt (100%) rename dbflow-core/src/main/{java => kotlin}/com/raizlabs/dbflow5/annotation/Collate.kt (100%) rename dbflow-core/src/main/{java => kotlin}/com/raizlabs/dbflow5/annotation/Column.kt (100%) rename dbflow-core/src/main/{java => kotlin}/com/raizlabs/dbflow5/annotation/ColumnIgnore.kt (100%) rename dbflow-core/src/main/{java => kotlin}/com/raizlabs/dbflow5/annotation/ColumnMap.kt (100%) rename dbflow-core/src/main/{java => kotlin}/com/raizlabs/dbflow5/annotation/ColumnMapReference.kt (100%) rename dbflow-core/src/main/{java => kotlin}/com/raizlabs/dbflow5/annotation/ConflictAction.kt (100%) rename dbflow-core/src/main/{java => kotlin}/com/raizlabs/dbflow5/annotation/Database.kt (100%) rename dbflow-core/src/main/{java => kotlin}/com/raizlabs/dbflow5/annotation/ForeignKey.kt (100%) rename dbflow-core/src/main/{java => kotlin}/com/raizlabs/dbflow5/annotation/ForeignKeyAction.kt (100%) rename dbflow-core/src/main/{java => kotlin}/com/raizlabs/dbflow5/annotation/ForeignKeyReference.kt (100%) rename dbflow-core/src/main/{java => kotlin}/com/raizlabs/dbflow5/annotation/Index.kt (100%) rename dbflow-core/src/main/{java => kotlin}/com/raizlabs/dbflow5/annotation/IndexGroup.kt (100%) rename dbflow-core/src/main/{java => kotlin}/com/raizlabs/dbflow5/annotation/InheritedColumn.kt (100%) rename dbflow-core/src/main/{java => kotlin}/com/raizlabs/dbflow5/annotation/InheritedPrimaryKey.kt (100%) rename dbflow-core/src/main/{java => kotlin}/com/raizlabs/dbflow5/annotation/ManyToMany.kt (100%) rename dbflow-core/src/main/{java => kotlin}/com/raizlabs/dbflow5/annotation/Migration.kt (100%) rename dbflow-core/src/main/{java => kotlin}/com/raizlabs/dbflow5/annotation/ModelCacheField.kt (100%) rename dbflow-core/src/main/{java => kotlin}/com/raizlabs/dbflow5/annotation/ModelView.kt (100%) rename dbflow-core/src/main/{java => kotlin}/com/raizlabs/dbflow5/annotation/ModelViewQuery.kt (100%) rename dbflow-core/src/main/{java => kotlin}/com/raizlabs/dbflow5/annotation/MultiCacheField.kt (100%) rename dbflow-core/src/main/{java => kotlin}/com/raizlabs/dbflow5/annotation/MultipleManyToMany.kt (100%) rename dbflow-core/src/main/{java => kotlin}/com/raizlabs/dbflow5/annotation/NotNull.kt (100%) rename dbflow-core/src/main/{java => kotlin}/com/raizlabs/dbflow5/annotation/OneToMany.kt (100%) rename dbflow-core/src/main/{java => kotlin}/com/raizlabs/dbflow5/annotation/PrimaryKey.kt (100%) rename dbflow-core/src/main/{java => kotlin}/com/raizlabs/dbflow5/annotation/QueryModel.kt (100%) rename dbflow-core/src/main/{java => kotlin}/com/raizlabs/dbflow5/annotation/Table.kt (100%) rename dbflow-core/src/main/{java => kotlin}/com/raizlabs/dbflow5/annotation/TypeConverter.kt (100%) rename dbflow-core/src/main/{java => kotlin}/com/raizlabs/dbflow5/annotation/Unique.kt (100%) rename dbflow-core/src/main/{java => kotlin}/com/raizlabs/dbflow5/annotation/UniqueGroup.kt (100%) rename dbflow-core/src/main/{java => kotlin}/com/raizlabs/dbflow5/annotation/provider/ContentProvider.kt (100%) rename dbflow-core/src/main/{java => kotlin}/com/raizlabs/dbflow5/annotation/provider/ContentUri.kt (100%) rename dbflow-core/src/main/{java => kotlin}/com/raizlabs/dbflow5/annotation/provider/Notify.kt (100%) rename dbflow-core/src/main/{java => kotlin}/com/raizlabs/dbflow5/annotation/provider/TableEndpoint.kt (100%) rename dbflow-core/src/main/{java => kotlin}/com/raizlabs/dbflow5/converter/TypeConverters.kt (100%) rename dbflow-core/src/main/{java => kotlin}/com/raizlabs/dbflow5/data/Blob.kt (100%) rename dbflow-core/src/main/{java => kotlin}/com/raizlabs/dbflow5/sql/Query.kt (100%) rename dbflow-core/src/main/{java => kotlin}/com/raizlabs/dbflow5/sql/SQLiteType.kt (100%) rename dbflow-coroutines/src/main/{java => kotlin}/com/raizlabs/dbflow5/coroutines/Coroutines.kt (100%) rename dbflow-processor/src/main/{java => kotlin}/com/raizlabs/dbflow5/processor/ClassNames.kt (100%) rename dbflow-processor/src/main/{java => kotlin}/com/raizlabs/dbflow5/processor/DBFlowProcessor.kt (100%) rename dbflow-processor/src/main/{java => kotlin}/com/raizlabs/dbflow5/processor/Handlers.kt (100%) rename dbflow-processor/src/main/{java => kotlin}/com/raizlabs/dbflow5/processor/ProcessorManager.kt (100%) rename dbflow-processor/src/main/{java => kotlin}/com/raizlabs/dbflow5/processor/ProcessorUtils.kt (100%) rename dbflow-processor/src/main/{java => kotlin}/com/raizlabs/dbflow5/processor/SQLiteHelper.kt (100%) rename dbflow-processor/src/main/{java => kotlin}/com/raizlabs/dbflow5/processor/Validators.kt (100%) rename dbflow-processor/src/main/{java => kotlin}/com/raizlabs/dbflow5/processor/definition/Adders.kt (100%) rename dbflow-processor/src/main/{java => kotlin}/com/raizlabs/dbflow5/processor/definition/BaseDefinition.kt (100%) rename dbflow-processor/src/main/{java => kotlin}/com/raizlabs/dbflow5/processor/definition/BaseTableDefinition.kt (100%) rename dbflow-processor/src/main/{java => kotlin}/com/raizlabs/dbflow5/processor/definition/DatabaseDefinition.kt (100%) rename dbflow-processor/src/main/{java => kotlin}/com/raizlabs/dbflow5/processor/definition/DatabaseHolderDefinition.kt (100%) rename dbflow-processor/src/main/{java => kotlin}/com/raizlabs/dbflow5/processor/definition/DatabaseObjectHolder.kt (100%) rename dbflow-processor/src/main/{java => kotlin}/com/raizlabs/dbflow5/processor/definition/IndexGroupsDefinition.kt (100%) rename dbflow-processor/src/main/{java => kotlin}/com/raizlabs/dbflow5/processor/definition/ManyToManyDefinition.kt (100%) rename dbflow-processor/src/main/{java => kotlin}/com/raizlabs/dbflow5/processor/definition/Methods.kt (100%) rename dbflow-processor/src/main/{java => kotlin}/com/raizlabs/dbflow5/processor/definition/MigrationDefinition.kt (100%) rename dbflow-processor/src/main/{java => kotlin}/com/raizlabs/dbflow5/processor/definition/ModelViewDefinition.kt (100%) rename dbflow-processor/src/main/{java => kotlin}/com/raizlabs/dbflow5/processor/definition/OneToManyDefinition.kt (100%) rename dbflow-processor/src/main/{java => kotlin}/com/raizlabs/dbflow5/processor/definition/QueryModelDefinition.kt (100%) rename dbflow-processor/src/main/{java => kotlin}/com/raizlabs/dbflow5/processor/definition/TableDefinition.kt (100%) rename dbflow-processor/src/main/{java => kotlin}/com/raizlabs/dbflow5/processor/definition/TypeConverterDefinition.kt (100%) rename dbflow-processor/src/main/{java => kotlin}/com/raizlabs/dbflow5/processor/definition/TypeDefinition.kt (100%) rename dbflow-processor/src/main/{java => kotlin}/com/raizlabs/dbflow5/processor/definition/UniqueGroupsDefinition.kt (100%) rename dbflow-processor/src/main/{java => kotlin}/com/raizlabs/dbflow5/processor/definition/column/ColumnAccessCombiner.kt (100%) rename dbflow-processor/src/main/{java => kotlin}/com/raizlabs/dbflow5/processor/definition/column/ColumnAccessor.kt (100%) rename dbflow-processor/src/main/{java => kotlin}/com/raizlabs/dbflow5/processor/definition/column/ColumnDefinition.kt (100%) rename dbflow-processor/src/main/{java => kotlin}/com/raizlabs/dbflow5/processor/definition/column/DefinitionUtils.kt (100%) rename dbflow-processor/src/main/{java => kotlin}/com/raizlabs/dbflow5/processor/definition/column/ForeignKeyAccessCombiner.kt (100%) rename dbflow-processor/src/main/{java => kotlin}/com/raizlabs/dbflow5/processor/definition/column/ReferenceColumnDefinition.kt (100%) rename dbflow-processor/src/main/{java => kotlin}/com/raizlabs/dbflow5/processor/definition/column/ReferenceDefinition.kt (100%) rename dbflow-processor/src/main/{java => kotlin}/com/raizlabs/dbflow5/processor/definition/provider/ContentProvider.kt (100%) rename dbflow-processor/src/main/{java => kotlin}/com/raizlabs/dbflow5/processor/definition/provider/NotifyDefinition.kt (100%) rename dbflow-processor/src/main/{java => kotlin}/com/raizlabs/dbflow5/processor/definition/provider/TableEndpointDefinition.kt (100%) rename dbflow-processor/src/main/{java => kotlin}/com/raizlabs/dbflow5/processor/utils/CodeExtensions.kt (100%) rename dbflow-processor/src/main/{java => kotlin}/com/raizlabs/dbflow5/processor/utils/DependencyUtils.kt (100%) rename dbflow-processor/src/main/{java => kotlin}/com/raizlabs/dbflow5/processor/utils/ElementExtensions.kt (100%) rename dbflow-processor/src/main/{java => kotlin}/com/raizlabs/dbflow5/processor/utils/ElementUtility.kt (100%) rename dbflow-processor/src/main/{java => kotlin}/com/raizlabs/dbflow5/processor/utils/JavaPoetExtensions.kt (100%) rename dbflow-processor/src/main/{java => kotlin}/com/raizlabs/dbflow5/processor/utils/ModelUtils.kt (100%) rename dbflow-processor/src/main/{java => kotlin}/com/raizlabs/dbflow5/processor/utils/ProcessorUtils.kt (100%) rename dbflow-processor/src/main/{java => kotlin}/com/raizlabs/dbflow5/processor/utils/StringUtils.kt (100%) rename dbflow-processor/src/main/{java => kotlin}/com/raizlabs/dbflow5/processor/utils/WriterUtils.kt (100%) rename dbflow-rx/src/main/{java => kotlin}/com/raizlabs/dbflow5/rx/query/CursorResultSubscriber.kt (100%) rename dbflow-rx/src/main/{java => kotlin}/com/raizlabs/dbflow5/rx/query/RXModelQueriable.kt (100%) rename dbflow-rx/src/main/{java => kotlin}/com/raizlabs/dbflow5/rx/query/RXModelQueriableImpl.kt (100%) rename dbflow-rx/src/main/{java => kotlin}/com/raizlabs/dbflow5/rx/query/RXQueriable.kt (100%) rename dbflow-rx/src/main/{java => kotlin}/com/raizlabs/dbflow5/rx/query/RXQueriableImpl.kt (100%) rename dbflow-rx/src/main/{java => kotlin}/com/raizlabs/dbflow5/rx/query/RXSQLite.kt (100%) rename dbflow-rx/src/main/{java => kotlin}/com/raizlabs/dbflow5/rx/query/TableChangeListenerEmitter.java (100%) rename dbflow-rx/src/main/{java => kotlin}/com/raizlabs/dbflow5/rx/structure/BaseRXModel.kt (100%) rename dbflow-rx/src/main/{java => kotlin}/com/raizlabs/dbflow5/rx/structure/RXModelAdapter.kt (100%) rename dbflow-rx/src/main/{java => kotlin}/com/raizlabs/dbflow5/rx/structure/RXRetrievalAdapter.kt (100%) rename dbflow-rx/src/main/{java => kotlin}/com/raizlabs/dbflow5/rx/transaction/TransactionObservable.kt (100%) rename dbflow-rx2/src/main/{java => kotlin}/com/raizlabs/dbflow5/rx2/query/CursorResultFlowable.kt (100%) rename dbflow-rx2/src/main/{java => kotlin}/com/raizlabs/dbflow5/rx2/query/RXModelQueriable.kt (100%) rename dbflow-rx2/src/main/{java => kotlin}/com/raizlabs/dbflow5/rx2/query/RXModelQueriableImpl.kt (100%) rename dbflow-rx2/src/main/{java => kotlin}/com/raizlabs/dbflow5/rx2/query/RXQueriable.kt (100%) rename dbflow-rx2/src/main/{java => kotlin}/com/raizlabs/dbflow5/rx2/query/RXQueriableImpl.kt (100%) rename dbflow-rx2/src/main/{java => kotlin}/com/raizlabs/dbflow5/rx2/query/RXSQLite.kt (100%) rename dbflow-rx2/src/main/{java => kotlin}/com/raizlabs/dbflow5/rx2/query/TableChangeOnSubscribe.kt (100%) rename dbflow-rx2/src/main/{java => kotlin}/com/raizlabs/dbflow5/rx2/structure/BaseRXModel.kt (100%) rename dbflow-rx2/src/main/{java => kotlin}/com/raizlabs/dbflow5/rx2/structure/RXModelAdapter.kt (100%) rename dbflow-rx2/src/main/{java => kotlin}/com/raizlabs/dbflow5/rx2/structure/RXRetrievalAdapter.kt (100%) rename dbflow-rx2/src/main/{java => kotlin}/com/raizlabs/dbflow5/rx2/transaction/TransactionObservable.kt (100%) rename dbflow-sqlcipher/src/main/{java => kotlin}/com/raizlabs/dbflow5/sqlcipher/SQLCipherDatabase.kt (100%) rename dbflow-sqlcipher/src/main/{java => kotlin}/com/raizlabs/dbflow5/sqlcipher/SQLCipherOpenHelper.kt (100%) rename dbflow-sqlcipher/src/main/{java => kotlin}/com/raizlabs/dbflow5/sqlcipher/SQLCipherStatement.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/SqlUtils.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/adapter/CacheAdapter.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/adapter/InternalAdapter.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/adapter/ModelAdapter.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/adapter/ModelViewAdapter.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/adapter/QueryModelAdapter.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/adapter/RetrievalAdapter.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/adapter/queriable/CacheableListModelLoader.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/adapter/queriable/CacheableModelLoader.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/adapter/queriable/ListModelLoader.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/adapter/queriable/ModelLoader.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/adapter/queriable/SingleKeyCacheableListModelLoader.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/adapter/queriable/SingleKeyCacheableModelLoader.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/adapter/queriable/SingleModelLoader.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/adapter/saveable/AutoIncrementModelSaver.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/adapter/saveable/CacheableListModelSaver.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/adapter/saveable/ListModelSaver.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/adapter/saveable/ModelSaver.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/config/DBFlowDatabase.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/config/DatabaseConfig.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/config/DatabaseHolder.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/config/FlowConfig.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/config/FlowLog.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/config/FlowManager.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/config/NaturalOrderComparator.java (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/config/TableConfig.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/database/AndroidDatabase.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/database/AndroidDatabaseStatement.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/database/AndroidSQLiteOpenHelper.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/database/BaseDatabaseHelper.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/database/BaseDatabaseStatement.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/database/ContentValueExtensions.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/database/DatabaseCallback.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/database/DatabaseHelperDelegate.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/database/DatabaseStatement.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/database/DatabaseStatementWrapper.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/database/DatabaseWrapper.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/database/FlowCursor.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/database/OpenHelper.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/database/SQLiteException.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/migration/AlterTableMigration.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/migration/BaseMigration.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/migration/IndexMigration.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/migration/IndexPropertyMigration.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/migration/Migration.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/migration/UpdateTableMigration.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/provider/BaseContentProvider.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/provider/BaseProviderModel.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/provider/BaseSyncableProviderModel.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/provider/ContentUtils.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/provider/ModelProvider.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/Actionable.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/BaseModelQueriable.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/BaseOperator.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/BaseQueriable.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/BaseTransformable.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/Case.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/CaseCondition.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/CompletedTrigger.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/ContentValuesListener.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/CursorResult.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/Delete.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/ExistenceOperator.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/From.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/IConditional.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/IOperator.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/Index.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/IndexedBy.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/Insert.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/Join.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/LoadFromCursorListener.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/Method.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/ModelQueriable.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/NameAlias.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/Operator.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/OperatorGroup.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/OrderBy.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/Queriable.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/SQLOperator.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/SQLite.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/SQLiteStatementListener.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/Select.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/Set.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/StringQuery.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/Transformable.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/Trigger.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/TriggerMethod.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/UnSafeStringOperator.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/Update.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/Where.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/WhereBase.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/cache/IMultiKeyCacheConverter.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/cache/ModelCache.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/cache/ModelLruCache.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/cache/SimpleMapCache.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/cache/SparseArrayBasedCache.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/list/FlowCursorIterator.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/list/FlowCursorList.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/list/FlowQueryList.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/list/IFlowCursorIterator.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/property/IProperty.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/property/IndexProperty.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/property/Property.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/property/PropertyFactory.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/property/TypeConvertedProperty.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/query/property/WrapperProperty.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/runtime/ContentResolverNotifier.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/runtime/DBBatchSaveQueue.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/runtime/DirectModelNotifier.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/runtime/FlowContentObserver.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/runtime/ModelNotifier.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/runtime/NotifyDistributor.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/runtime/OnTableChangedListener.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/runtime/TableNotifierRegister.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/structure/Action.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/structure/BaseModel.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/structure/BaseModelView.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/structure/BaseQueryModel.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/structure/InvalidDBConfiguration.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/structure/Model.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/structure/NoModificationModel.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/structure/OneToMany.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/structure/ReadOnlyModel.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/transaction/BaseTransactionManager.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/transaction/DefaultTransactionManager.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/transaction/DefaultTransactionQueue.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/transaction/FastStoreModelTransaction.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/transaction/ITransaction.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/transaction/ITransactionQueue.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/transaction/PriorityTransactionQueue.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/transaction/PriorityTransactionWrapper.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/transaction/ProcessModelTransaction.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/transaction/Transaction.kt (100%) rename dbflow/src/main/{java => kotlin}/com/raizlabs/dbflow5/transaction/TransactionWrapper.kt (100%) diff --git a/dbflow-core/build.gradle b/dbflow-core/build.gradle index a392ae8fa..b244434f6 100644 --- a/dbflow-core/build.gradle +++ b/dbflow-core/build.gradle @@ -1,4 +1,3 @@ -apply plugin: 'java' apply plugin: 'kotlin' project.ext.artifactId = bt_name @@ -10,7 +9,7 @@ dependencies { compile deps.kotlin } -apply from: '../java-artifacts.gradle' +apply from: '../kotlin-artifacts.gradle' compileKotlin { kotlinOptions { diff --git a/dbflow-core/src/main/java/com/raizlabs/dbflow5/StringUtils.kt b/dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/StringUtils.kt similarity index 100% rename from dbflow-core/src/main/java/com/raizlabs/dbflow5/StringUtils.kt rename to dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/StringUtils.kt diff --git a/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/Collate.kt b/dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/Collate.kt similarity index 100% rename from dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/Collate.kt rename to dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/Collate.kt diff --git a/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/Column.kt b/dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/Column.kt similarity index 100% rename from dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/Column.kt rename to dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/Column.kt diff --git a/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ColumnIgnore.kt b/dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/ColumnIgnore.kt similarity index 100% rename from dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ColumnIgnore.kt rename to dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/ColumnIgnore.kt diff --git a/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ColumnMap.kt b/dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/ColumnMap.kt similarity index 100% rename from dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ColumnMap.kt rename to dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/ColumnMap.kt diff --git a/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ColumnMapReference.kt b/dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/ColumnMapReference.kt similarity index 100% rename from dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ColumnMapReference.kt rename to dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/ColumnMapReference.kt diff --git a/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ConflictAction.kt b/dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/ConflictAction.kt similarity index 100% rename from dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ConflictAction.kt rename to dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/ConflictAction.kt diff --git a/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/Database.kt b/dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/Database.kt similarity index 100% rename from dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/Database.kt rename to dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/Database.kt diff --git a/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ForeignKey.kt b/dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/ForeignKey.kt similarity index 100% rename from dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ForeignKey.kt rename to dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/ForeignKey.kt diff --git a/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ForeignKeyAction.kt b/dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/ForeignKeyAction.kt similarity index 100% rename from dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ForeignKeyAction.kt rename to dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/ForeignKeyAction.kt diff --git a/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ForeignKeyReference.kt b/dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/ForeignKeyReference.kt similarity index 100% rename from dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ForeignKeyReference.kt rename to dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/ForeignKeyReference.kt diff --git a/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/Index.kt b/dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/Index.kt similarity index 100% rename from dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/Index.kt rename to dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/Index.kt diff --git a/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/IndexGroup.kt b/dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/IndexGroup.kt similarity index 100% rename from dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/IndexGroup.kt rename to dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/IndexGroup.kt diff --git a/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/InheritedColumn.kt b/dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/InheritedColumn.kt similarity index 100% rename from dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/InheritedColumn.kt rename to dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/InheritedColumn.kt diff --git a/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/InheritedPrimaryKey.kt b/dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/InheritedPrimaryKey.kt similarity index 100% rename from dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/InheritedPrimaryKey.kt rename to dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/InheritedPrimaryKey.kt diff --git a/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ManyToMany.kt b/dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/ManyToMany.kt similarity index 100% rename from dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ManyToMany.kt rename to dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/ManyToMany.kt diff --git a/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/Migration.kt b/dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/Migration.kt similarity index 100% rename from dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/Migration.kt rename to dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/Migration.kt diff --git a/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ModelCacheField.kt b/dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/ModelCacheField.kt similarity index 100% rename from dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ModelCacheField.kt rename to dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/ModelCacheField.kt diff --git a/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ModelView.kt b/dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/ModelView.kt similarity index 100% rename from dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ModelView.kt rename to dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/ModelView.kt diff --git a/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ModelViewQuery.kt b/dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/ModelViewQuery.kt similarity index 100% rename from dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/ModelViewQuery.kt rename to dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/ModelViewQuery.kt diff --git a/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/MultiCacheField.kt b/dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/MultiCacheField.kt similarity index 100% rename from dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/MultiCacheField.kt rename to dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/MultiCacheField.kt diff --git a/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/MultipleManyToMany.kt b/dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/MultipleManyToMany.kt similarity index 100% rename from dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/MultipleManyToMany.kt rename to dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/MultipleManyToMany.kt diff --git a/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/NotNull.kt b/dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/NotNull.kt similarity index 100% rename from dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/NotNull.kt rename to dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/NotNull.kt diff --git a/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/OneToMany.kt b/dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/OneToMany.kt similarity index 100% rename from dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/OneToMany.kt rename to dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/OneToMany.kt diff --git a/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/PrimaryKey.kt b/dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/PrimaryKey.kt similarity index 100% rename from dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/PrimaryKey.kt rename to dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/PrimaryKey.kt diff --git a/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/QueryModel.kt b/dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/QueryModel.kt similarity index 100% rename from dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/QueryModel.kt rename to dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/QueryModel.kt diff --git a/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/Table.kt b/dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/Table.kt similarity index 100% rename from dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/Table.kt rename to dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/Table.kt diff --git a/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/TypeConverter.kt b/dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/TypeConverter.kt similarity index 100% rename from dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/TypeConverter.kt rename to dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/TypeConverter.kt diff --git a/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/Unique.kt b/dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/Unique.kt similarity index 100% rename from dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/Unique.kt rename to dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/Unique.kt diff --git a/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/UniqueGroup.kt b/dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/UniqueGroup.kt similarity index 100% rename from dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/UniqueGroup.kt rename to dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/UniqueGroup.kt diff --git a/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/provider/ContentProvider.kt b/dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/provider/ContentProvider.kt similarity index 100% rename from dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/provider/ContentProvider.kt rename to dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/provider/ContentProvider.kt diff --git a/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/provider/ContentUri.kt b/dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/provider/ContentUri.kt similarity index 100% rename from dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/provider/ContentUri.kt rename to dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/provider/ContentUri.kt diff --git a/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/provider/Notify.kt b/dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/provider/Notify.kt similarity index 100% rename from dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/provider/Notify.kt rename to dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/provider/Notify.kt diff --git a/dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/provider/TableEndpoint.kt b/dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/provider/TableEndpoint.kt similarity index 100% rename from dbflow-core/src/main/java/com/raizlabs/dbflow5/annotation/provider/TableEndpoint.kt rename to dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/annotation/provider/TableEndpoint.kt diff --git a/dbflow-core/src/main/java/com/raizlabs/dbflow5/converter/TypeConverters.kt b/dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/converter/TypeConverters.kt similarity index 100% rename from dbflow-core/src/main/java/com/raizlabs/dbflow5/converter/TypeConverters.kt rename to dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/converter/TypeConverters.kt diff --git a/dbflow-core/src/main/java/com/raizlabs/dbflow5/data/Blob.kt b/dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/data/Blob.kt similarity index 100% rename from dbflow-core/src/main/java/com/raizlabs/dbflow5/data/Blob.kt rename to dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/data/Blob.kt diff --git a/dbflow-core/src/main/java/com/raizlabs/dbflow5/sql/Query.kt b/dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/sql/Query.kt similarity index 100% rename from dbflow-core/src/main/java/com/raizlabs/dbflow5/sql/Query.kt rename to dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/sql/Query.kt diff --git a/dbflow-core/src/main/java/com/raizlabs/dbflow5/sql/SQLiteType.kt b/dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/sql/SQLiteType.kt similarity index 100% rename from dbflow-core/src/main/java/com/raizlabs/dbflow5/sql/SQLiteType.kt rename to dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/sql/SQLiteType.kt diff --git a/dbflow-coroutines/src/main/java/com/raizlabs/dbflow5/coroutines/Coroutines.kt b/dbflow-coroutines/src/main/kotlin/com/raizlabs/dbflow5/coroutines/Coroutines.kt similarity index 100% rename from dbflow-coroutines/src/main/java/com/raizlabs/dbflow5/coroutines/Coroutines.kt rename to dbflow-coroutines/src/main/kotlin/com/raizlabs/dbflow5/coroutines/Coroutines.kt diff --git a/dbflow-processor/build.gradle b/dbflow-processor/build.gradle index 42394bbf6..6b47b06cf 100644 --- a/dbflow-processor/build.gradle +++ b/dbflow-processor/build.gradle @@ -1,4 +1,3 @@ -apply plugin: 'java' apply plugin: 'kotlin' project.ext.artifactId = bt_name @@ -13,9 +12,7 @@ dependencies { compile deps.kotlin compileOnly deps.javax_annotation - testImplementation deps.junit - } -apply from: '../java-artifacts.gradle' +apply from: '../kotlin-artifacts.gradle' diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/ClassNames.kt b/dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/ClassNames.kt similarity index 100% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/ClassNames.kt rename to dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/ClassNames.kt diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/DBFlowProcessor.kt b/dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/DBFlowProcessor.kt similarity index 100% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/DBFlowProcessor.kt rename to dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/DBFlowProcessor.kt diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/Handlers.kt b/dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/Handlers.kt similarity index 100% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/Handlers.kt rename to dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/Handlers.kt diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/ProcessorManager.kt b/dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/ProcessorManager.kt similarity index 100% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/ProcessorManager.kt rename to dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/ProcessorManager.kt diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/ProcessorUtils.kt b/dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/ProcessorUtils.kt similarity index 100% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/ProcessorUtils.kt rename to dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/ProcessorUtils.kt diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/SQLiteHelper.kt b/dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/SQLiteHelper.kt similarity index 100% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/SQLiteHelper.kt rename to dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/SQLiteHelper.kt diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/Validators.kt b/dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/Validators.kt similarity index 100% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/Validators.kt rename to dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/Validators.kt diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/Adders.kt b/dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/Adders.kt similarity index 100% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/Adders.kt rename to dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/Adders.kt diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/BaseDefinition.kt b/dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/BaseDefinition.kt similarity index 100% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/BaseDefinition.kt rename to dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/BaseDefinition.kt diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/BaseTableDefinition.kt b/dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/BaseTableDefinition.kt similarity index 100% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/BaseTableDefinition.kt rename to dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/BaseTableDefinition.kt diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/DatabaseDefinition.kt b/dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/DatabaseDefinition.kt similarity index 100% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/DatabaseDefinition.kt rename to dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/DatabaseDefinition.kt diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/DatabaseHolderDefinition.kt b/dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/DatabaseHolderDefinition.kt similarity index 100% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/DatabaseHolderDefinition.kt rename to dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/DatabaseHolderDefinition.kt diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/DatabaseObjectHolder.kt b/dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/DatabaseObjectHolder.kt similarity index 100% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/DatabaseObjectHolder.kt rename to dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/DatabaseObjectHolder.kt diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/IndexGroupsDefinition.kt b/dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/IndexGroupsDefinition.kt similarity index 100% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/IndexGroupsDefinition.kt rename to dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/IndexGroupsDefinition.kt diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/ManyToManyDefinition.kt b/dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/ManyToManyDefinition.kt similarity index 100% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/ManyToManyDefinition.kt rename to dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/ManyToManyDefinition.kt diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/Methods.kt b/dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/Methods.kt similarity index 100% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/Methods.kt rename to dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/Methods.kt diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/MigrationDefinition.kt b/dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/MigrationDefinition.kt similarity index 100% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/MigrationDefinition.kt rename to dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/MigrationDefinition.kt diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/ModelViewDefinition.kt b/dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/ModelViewDefinition.kt similarity index 100% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/ModelViewDefinition.kt rename to dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/ModelViewDefinition.kt diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/OneToManyDefinition.kt b/dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/OneToManyDefinition.kt similarity index 100% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/OneToManyDefinition.kt rename to dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/OneToManyDefinition.kt diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/QueryModelDefinition.kt b/dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/QueryModelDefinition.kt similarity index 100% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/QueryModelDefinition.kt rename to dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/QueryModelDefinition.kt diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/TableDefinition.kt b/dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/TableDefinition.kt similarity index 100% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/TableDefinition.kt rename to dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/TableDefinition.kt diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/TypeConverterDefinition.kt b/dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/TypeConverterDefinition.kt similarity index 100% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/TypeConverterDefinition.kt rename to dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/TypeConverterDefinition.kt diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/TypeDefinition.kt b/dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/TypeDefinition.kt similarity index 100% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/TypeDefinition.kt rename to dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/TypeDefinition.kt diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/UniqueGroupsDefinition.kt b/dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/UniqueGroupsDefinition.kt similarity index 100% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/UniqueGroupsDefinition.kt rename to dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/UniqueGroupsDefinition.kt diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/column/ColumnAccessCombiner.kt b/dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/column/ColumnAccessCombiner.kt similarity index 100% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/column/ColumnAccessCombiner.kt rename to dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/column/ColumnAccessCombiner.kt diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/column/ColumnAccessor.kt b/dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/column/ColumnAccessor.kt similarity index 100% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/column/ColumnAccessor.kt rename to dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/column/ColumnAccessor.kt diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/column/ColumnDefinition.kt b/dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/column/ColumnDefinition.kt similarity index 100% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/column/ColumnDefinition.kt rename to dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/column/ColumnDefinition.kt diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/column/DefinitionUtils.kt b/dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/column/DefinitionUtils.kt similarity index 100% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/column/DefinitionUtils.kt rename to dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/column/DefinitionUtils.kt diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/column/ForeignKeyAccessCombiner.kt b/dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/column/ForeignKeyAccessCombiner.kt similarity index 100% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/column/ForeignKeyAccessCombiner.kt rename to dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/column/ForeignKeyAccessCombiner.kt diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/column/ReferenceColumnDefinition.kt b/dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/column/ReferenceColumnDefinition.kt similarity index 100% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/column/ReferenceColumnDefinition.kt rename to dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/column/ReferenceColumnDefinition.kt diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/column/ReferenceDefinition.kt b/dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/column/ReferenceDefinition.kt similarity index 100% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/column/ReferenceDefinition.kt rename to dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/column/ReferenceDefinition.kt diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/provider/ContentProvider.kt b/dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/provider/ContentProvider.kt similarity index 100% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/provider/ContentProvider.kt rename to dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/provider/ContentProvider.kt diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/provider/NotifyDefinition.kt b/dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/provider/NotifyDefinition.kt similarity index 100% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/provider/NotifyDefinition.kt rename to dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/provider/NotifyDefinition.kt diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/provider/TableEndpointDefinition.kt b/dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/provider/TableEndpointDefinition.kt similarity index 100% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/definition/provider/TableEndpointDefinition.kt rename to dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/provider/TableEndpointDefinition.kt diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/utils/CodeExtensions.kt b/dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/utils/CodeExtensions.kt similarity index 100% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/utils/CodeExtensions.kt rename to dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/utils/CodeExtensions.kt diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/utils/DependencyUtils.kt b/dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/utils/DependencyUtils.kt similarity index 100% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/utils/DependencyUtils.kt rename to dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/utils/DependencyUtils.kt diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/utils/ElementExtensions.kt b/dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/utils/ElementExtensions.kt similarity index 100% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/utils/ElementExtensions.kt rename to dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/utils/ElementExtensions.kt diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/utils/ElementUtility.kt b/dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/utils/ElementUtility.kt similarity index 100% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/utils/ElementUtility.kt rename to dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/utils/ElementUtility.kt diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/utils/JavaPoetExtensions.kt b/dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/utils/JavaPoetExtensions.kt similarity index 100% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/utils/JavaPoetExtensions.kt rename to dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/utils/JavaPoetExtensions.kt diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/utils/ModelUtils.kt b/dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/utils/ModelUtils.kt similarity index 100% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/utils/ModelUtils.kt rename to dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/utils/ModelUtils.kt diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/utils/ProcessorUtils.kt b/dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/utils/ProcessorUtils.kt similarity index 100% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/utils/ProcessorUtils.kt rename to dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/utils/ProcessorUtils.kt diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/utils/StringUtils.kt b/dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/utils/StringUtils.kt similarity index 100% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/utils/StringUtils.kt rename to dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/utils/StringUtils.kt diff --git a/dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/utils/WriterUtils.kt b/dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/utils/WriterUtils.kt similarity index 100% rename from dbflow-processor/src/main/java/com/raizlabs/dbflow5/processor/utils/WriterUtils.kt rename to dbflow-processor/src/main/kotlin/com/raizlabs/dbflow5/processor/utils/WriterUtils.kt diff --git a/dbflow-rx/build.gradle b/dbflow-rx/build.gradle index c7ab8b11b..043ad152f 100644 --- a/dbflow-rx/build.gradle +++ b/dbflow-rx/build.gradle @@ -15,6 +15,10 @@ android { sourceCompatibility JavaVersion.VERSION_1_8 targetCompatibility JavaVersion.VERSION_1_8 } + + sourceSets { + main.java.srcDirs += 'src/main/kotlin' + } } dependencies { diff --git a/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/query/CursorResultSubscriber.kt b/dbflow-rx/src/main/kotlin/com/raizlabs/dbflow5/rx/query/CursorResultSubscriber.kt similarity index 100% rename from dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/query/CursorResultSubscriber.kt rename to dbflow-rx/src/main/kotlin/com/raizlabs/dbflow5/rx/query/CursorResultSubscriber.kt diff --git a/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/query/RXModelQueriable.kt b/dbflow-rx/src/main/kotlin/com/raizlabs/dbflow5/rx/query/RXModelQueriable.kt similarity index 100% rename from dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/query/RXModelQueriable.kt rename to dbflow-rx/src/main/kotlin/com/raizlabs/dbflow5/rx/query/RXModelQueriable.kt diff --git a/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/query/RXModelQueriableImpl.kt b/dbflow-rx/src/main/kotlin/com/raizlabs/dbflow5/rx/query/RXModelQueriableImpl.kt similarity index 100% rename from dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/query/RXModelQueriableImpl.kt rename to dbflow-rx/src/main/kotlin/com/raizlabs/dbflow5/rx/query/RXModelQueriableImpl.kt diff --git a/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/query/RXQueriable.kt b/dbflow-rx/src/main/kotlin/com/raizlabs/dbflow5/rx/query/RXQueriable.kt similarity index 100% rename from dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/query/RXQueriable.kt rename to dbflow-rx/src/main/kotlin/com/raizlabs/dbflow5/rx/query/RXQueriable.kt diff --git a/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/query/RXQueriableImpl.kt b/dbflow-rx/src/main/kotlin/com/raizlabs/dbflow5/rx/query/RXQueriableImpl.kt similarity index 100% rename from dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/query/RXQueriableImpl.kt rename to dbflow-rx/src/main/kotlin/com/raizlabs/dbflow5/rx/query/RXQueriableImpl.kt diff --git a/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/query/RXSQLite.kt b/dbflow-rx/src/main/kotlin/com/raizlabs/dbflow5/rx/query/RXSQLite.kt similarity index 100% rename from dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/query/RXSQLite.kt rename to dbflow-rx/src/main/kotlin/com/raizlabs/dbflow5/rx/query/RXSQLite.kt diff --git a/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/query/TableChangeListenerEmitter.java b/dbflow-rx/src/main/kotlin/com/raizlabs/dbflow5/rx/query/TableChangeListenerEmitter.java similarity index 100% rename from dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/query/TableChangeListenerEmitter.java rename to dbflow-rx/src/main/kotlin/com/raizlabs/dbflow5/rx/query/TableChangeListenerEmitter.java diff --git a/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/structure/BaseRXModel.kt b/dbflow-rx/src/main/kotlin/com/raizlabs/dbflow5/rx/structure/BaseRXModel.kt similarity index 100% rename from dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/structure/BaseRXModel.kt rename to dbflow-rx/src/main/kotlin/com/raizlabs/dbflow5/rx/structure/BaseRXModel.kt diff --git a/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/structure/RXModelAdapter.kt b/dbflow-rx/src/main/kotlin/com/raizlabs/dbflow5/rx/structure/RXModelAdapter.kt similarity index 100% rename from dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/structure/RXModelAdapter.kt rename to dbflow-rx/src/main/kotlin/com/raizlabs/dbflow5/rx/structure/RXModelAdapter.kt diff --git a/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/structure/RXRetrievalAdapter.kt b/dbflow-rx/src/main/kotlin/com/raizlabs/dbflow5/rx/structure/RXRetrievalAdapter.kt similarity index 100% rename from dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/structure/RXRetrievalAdapter.kt rename to dbflow-rx/src/main/kotlin/com/raizlabs/dbflow5/rx/structure/RXRetrievalAdapter.kt diff --git a/dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/transaction/TransactionObservable.kt b/dbflow-rx/src/main/kotlin/com/raizlabs/dbflow5/rx/transaction/TransactionObservable.kt similarity index 100% rename from dbflow-rx/src/main/java/com/raizlabs/dbflow5/rx/transaction/TransactionObservable.kt rename to dbflow-rx/src/main/kotlin/com/raizlabs/dbflow5/rx/transaction/TransactionObservable.kt diff --git a/dbflow-rx2/build.gradle b/dbflow-rx2/build.gradle index 9a2d54c64..3c3db907f 100644 --- a/dbflow-rx2/build.gradle +++ b/dbflow-rx2/build.gradle @@ -15,6 +15,10 @@ android { sourceCompatibility JavaVersion.VERSION_1_8 targetCompatibility JavaVersion.VERSION_1_8 } + + sourceSets { + main.java.srcDirs += 'src/main/kotlin' + } } dependencies { diff --git a/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/query/CursorResultFlowable.kt b/dbflow-rx2/src/main/kotlin/com/raizlabs/dbflow5/rx2/query/CursorResultFlowable.kt similarity index 100% rename from dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/query/CursorResultFlowable.kt rename to dbflow-rx2/src/main/kotlin/com/raizlabs/dbflow5/rx2/query/CursorResultFlowable.kt diff --git a/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/query/RXModelQueriable.kt b/dbflow-rx2/src/main/kotlin/com/raizlabs/dbflow5/rx2/query/RXModelQueriable.kt similarity index 100% rename from dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/query/RXModelQueriable.kt rename to dbflow-rx2/src/main/kotlin/com/raizlabs/dbflow5/rx2/query/RXModelQueriable.kt diff --git a/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/query/RXModelQueriableImpl.kt b/dbflow-rx2/src/main/kotlin/com/raizlabs/dbflow5/rx2/query/RXModelQueriableImpl.kt similarity index 100% rename from dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/query/RXModelQueriableImpl.kt rename to dbflow-rx2/src/main/kotlin/com/raizlabs/dbflow5/rx2/query/RXModelQueriableImpl.kt diff --git a/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/query/RXQueriable.kt b/dbflow-rx2/src/main/kotlin/com/raizlabs/dbflow5/rx2/query/RXQueriable.kt similarity index 100% rename from dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/query/RXQueriable.kt rename to dbflow-rx2/src/main/kotlin/com/raizlabs/dbflow5/rx2/query/RXQueriable.kt diff --git a/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/query/RXQueriableImpl.kt b/dbflow-rx2/src/main/kotlin/com/raizlabs/dbflow5/rx2/query/RXQueriableImpl.kt similarity index 100% rename from dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/query/RXQueriableImpl.kt rename to dbflow-rx2/src/main/kotlin/com/raizlabs/dbflow5/rx2/query/RXQueriableImpl.kt diff --git a/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/query/RXSQLite.kt b/dbflow-rx2/src/main/kotlin/com/raizlabs/dbflow5/rx2/query/RXSQLite.kt similarity index 100% rename from dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/query/RXSQLite.kt rename to dbflow-rx2/src/main/kotlin/com/raizlabs/dbflow5/rx2/query/RXSQLite.kt diff --git a/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/query/TableChangeOnSubscribe.kt b/dbflow-rx2/src/main/kotlin/com/raizlabs/dbflow5/rx2/query/TableChangeOnSubscribe.kt similarity index 100% rename from dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/query/TableChangeOnSubscribe.kt rename to dbflow-rx2/src/main/kotlin/com/raizlabs/dbflow5/rx2/query/TableChangeOnSubscribe.kt diff --git a/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/structure/BaseRXModel.kt b/dbflow-rx2/src/main/kotlin/com/raizlabs/dbflow5/rx2/structure/BaseRXModel.kt similarity index 100% rename from dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/structure/BaseRXModel.kt rename to dbflow-rx2/src/main/kotlin/com/raizlabs/dbflow5/rx2/structure/BaseRXModel.kt diff --git a/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/structure/RXModelAdapter.kt b/dbflow-rx2/src/main/kotlin/com/raizlabs/dbflow5/rx2/structure/RXModelAdapter.kt similarity index 100% rename from dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/structure/RXModelAdapter.kt rename to dbflow-rx2/src/main/kotlin/com/raizlabs/dbflow5/rx2/structure/RXModelAdapter.kt diff --git a/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/structure/RXRetrievalAdapter.kt b/dbflow-rx2/src/main/kotlin/com/raizlabs/dbflow5/rx2/structure/RXRetrievalAdapter.kt similarity index 100% rename from dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/structure/RXRetrievalAdapter.kt rename to dbflow-rx2/src/main/kotlin/com/raizlabs/dbflow5/rx2/structure/RXRetrievalAdapter.kt diff --git a/dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/transaction/TransactionObservable.kt b/dbflow-rx2/src/main/kotlin/com/raizlabs/dbflow5/rx2/transaction/TransactionObservable.kt similarity index 100% rename from dbflow-rx2/src/main/java/com/raizlabs/dbflow5/rx2/transaction/TransactionObservable.kt rename to dbflow-rx2/src/main/kotlin/com/raizlabs/dbflow5/rx2/transaction/TransactionObservable.kt diff --git a/dbflow-sqlcipher/build.gradle b/dbflow-sqlcipher/build.gradle index da2007ecc..1669f6ea4 100644 --- a/dbflow-sqlcipher/build.gradle +++ b/dbflow-sqlcipher/build.gradle @@ -19,6 +19,10 @@ android { sourceCompatibility JavaVersion.VERSION_1_8 targetCompatibility JavaVersion.VERSION_1_8 } + + sourceSets { + main.java.srcDirs += 'src/main/kotlin' + } } dependencies { diff --git a/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherDatabase.kt b/dbflow-sqlcipher/src/main/kotlin/com/raizlabs/dbflow5/sqlcipher/SQLCipherDatabase.kt similarity index 100% rename from dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherDatabase.kt rename to dbflow-sqlcipher/src/main/kotlin/com/raizlabs/dbflow5/sqlcipher/SQLCipherDatabase.kt diff --git a/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherOpenHelper.kt b/dbflow-sqlcipher/src/main/kotlin/com/raizlabs/dbflow5/sqlcipher/SQLCipherOpenHelper.kt similarity index 100% rename from dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherOpenHelper.kt rename to dbflow-sqlcipher/src/main/kotlin/com/raizlabs/dbflow5/sqlcipher/SQLCipherOpenHelper.kt diff --git a/dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherStatement.kt b/dbflow-sqlcipher/src/main/kotlin/com/raizlabs/dbflow5/sqlcipher/SQLCipherStatement.kt similarity index 100% rename from dbflow-sqlcipher/src/main/java/com/raizlabs/dbflow5/sqlcipher/SQLCipherStatement.kt rename to dbflow-sqlcipher/src/main/kotlin/com/raizlabs/dbflow5/sqlcipher/SQLCipherStatement.kt diff --git a/dbflow/build.gradle b/dbflow/build.gradle index 241da5406..10038b664 100644 --- a/dbflow/build.gradle +++ b/dbflow/build.gradle @@ -20,6 +20,9 @@ android { targetCompatibility JavaVersion.VERSION_1_8 } + sourceSets { + main.java.srcDirs += 'src/main/kotlin' + } } dependencies { diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/SqlUtils.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/SqlUtils.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/SqlUtils.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/SqlUtils.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/CacheAdapter.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/adapter/CacheAdapter.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/adapter/CacheAdapter.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/adapter/CacheAdapter.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/InternalAdapter.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/adapter/InternalAdapter.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/adapter/InternalAdapter.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/adapter/InternalAdapter.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/ModelAdapter.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/adapter/ModelAdapter.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/adapter/ModelAdapter.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/adapter/ModelAdapter.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/ModelViewAdapter.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/adapter/ModelViewAdapter.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/adapter/ModelViewAdapter.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/adapter/ModelViewAdapter.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/QueryModelAdapter.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/adapter/QueryModelAdapter.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/adapter/QueryModelAdapter.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/adapter/QueryModelAdapter.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/RetrievalAdapter.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/adapter/RetrievalAdapter.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/adapter/RetrievalAdapter.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/adapter/RetrievalAdapter.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/CacheableListModelLoader.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/adapter/queriable/CacheableListModelLoader.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/CacheableListModelLoader.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/adapter/queriable/CacheableListModelLoader.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/CacheableModelLoader.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/adapter/queriable/CacheableModelLoader.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/CacheableModelLoader.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/adapter/queriable/CacheableModelLoader.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/ListModelLoader.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/adapter/queriable/ListModelLoader.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/ListModelLoader.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/adapter/queriable/ListModelLoader.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/ModelLoader.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/adapter/queriable/ModelLoader.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/ModelLoader.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/adapter/queriable/ModelLoader.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/SingleKeyCacheableListModelLoader.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/adapter/queriable/SingleKeyCacheableListModelLoader.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/SingleKeyCacheableListModelLoader.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/adapter/queriable/SingleKeyCacheableListModelLoader.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/SingleKeyCacheableModelLoader.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/adapter/queriable/SingleKeyCacheableModelLoader.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/SingleKeyCacheableModelLoader.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/adapter/queriable/SingleKeyCacheableModelLoader.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/SingleModelLoader.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/adapter/queriable/SingleModelLoader.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/adapter/queriable/SingleModelLoader.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/adapter/queriable/SingleModelLoader.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/saveable/AutoIncrementModelSaver.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/adapter/saveable/AutoIncrementModelSaver.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/adapter/saveable/AutoIncrementModelSaver.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/adapter/saveable/AutoIncrementModelSaver.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/saveable/CacheableListModelSaver.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/adapter/saveable/CacheableListModelSaver.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/adapter/saveable/CacheableListModelSaver.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/adapter/saveable/CacheableListModelSaver.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/saveable/ListModelSaver.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/adapter/saveable/ListModelSaver.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/adapter/saveable/ListModelSaver.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/adapter/saveable/ListModelSaver.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/adapter/saveable/ModelSaver.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/adapter/saveable/ModelSaver.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/adapter/saveable/ModelSaver.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/adapter/saveable/ModelSaver.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/config/DBFlowDatabase.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/config/DBFlowDatabase.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/config/DBFlowDatabase.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/config/DBFlowDatabase.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseConfig.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/config/DatabaseConfig.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseConfig.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/config/DatabaseConfig.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseHolder.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/config/DatabaseHolder.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/config/DatabaseHolder.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/config/DatabaseHolder.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowConfig.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/config/FlowConfig.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowConfig.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/config/FlowConfig.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowLog.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/config/FlowLog.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowLog.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/config/FlowLog.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowManager.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/config/FlowManager.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/config/FlowManager.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/config/FlowManager.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/config/NaturalOrderComparator.java b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/config/NaturalOrderComparator.java similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/config/NaturalOrderComparator.java rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/config/NaturalOrderComparator.java diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/config/TableConfig.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/config/TableConfig.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/config/TableConfig.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/config/TableConfig.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidDatabase.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/database/AndroidDatabase.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidDatabase.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/database/AndroidDatabase.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidDatabaseStatement.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/database/AndroidDatabaseStatement.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidDatabaseStatement.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/database/AndroidDatabaseStatement.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidSQLiteOpenHelper.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/database/AndroidSQLiteOpenHelper.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/database/AndroidSQLiteOpenHelper.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/database/AndroidSQLiteOpenHelper.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/database/BaseDatabaseHelper.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/database/BaseDatabaseHelper.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/database/BaseDatabaseHelper.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/database/BaseDatabaseHelper.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/database/BaseDatabaseStatement.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/database/BaseDatabaseStatement.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/database/BaseDatabaseStatement.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/database/BaseDatabaseStatement.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/database/ContentValueExtensions.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/database/ContentValueExtensions.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/database/ContentValueExtensions.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/database/ContentValueExtensions.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseCallback.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/database/DatabaseCallback.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseCallback.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/database/DatabaseCallback.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseHelperDelegate.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/database/DatabaseHelperDelegate.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseHelperDelegate.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/database/DatabaseHelperDelegate.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseStatement.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/database/DatabaseStatement.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseStatement.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/database/DatabaseStatement.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseStatementWrapper.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/database/DatabaseStatementWrapper.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseStatementWrapper.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/database/DatabaseStatementWrapper.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseWrapper.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/database/DatabaseWrapper.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/database/DatabaseWrapper.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/database/DatabaseWrapper.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/database/FlowCursor.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/database/FlowCursor.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/database/FlowCursor.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/database/FlowCursor.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/database/OpenHelper.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/database/OpenHelper.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/database/OpenHelper.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/database/OpenHelper.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/database/SQLiteException.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/database/SQLiteException.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/database/SQLiteException.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/database/SQLiteException.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/migration/AlterTableMigration.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/migration/AlterTableMigration.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/migration/AlterTableMigration.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/migration/AlterTableMigration.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/migration/BaseMigration.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/migration/BaseMigration.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/migration/BaseMigration.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/migration/BaseMigration.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/migration/IndexMigration.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/migration/IndexMigration.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/migration/IndexMigration.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/migration/IndexMigration.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/migration/IndexPropertyMigration.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/migration/IndexPropertyMigration.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/migration/IndexPropertyMigration.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/migration/IndexPropertyMigration.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/migration/Migration.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/migration/Migration.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/migration/Migration.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/migration/Migration.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/migration/UpdateTableMigration.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/migration/UpdateTableMigration.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/migration/UpdateTableMigration.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/migration/UpdateTableMigration.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/provider/BaseContentProvider.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/provider/BaseContentProvider.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/provider/BaseContentProvider.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/provider/BaseContentProvider.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/provider/BaseProviderModel.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/provider/BaseProviderModel.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/provider/BaseProviderModel.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/provider/BaseProviderModel.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/provider/BaseSyncableProviderModel.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/provider/BaseSyncableProviderModel.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/provider/BaseSyncableProviderModel.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/provider/BaseSyncableProviderModel.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/provider/ContentUtils.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/provider/ContentUtils.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/provider/ContentUtils.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/provider/ContentUtils.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/provider/ModelProvider.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/provider/ModelProvider.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/provider/ModelProvider.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/provider/ModelProvider.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/Actionable.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/Actionable.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/Actionable.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/Actionable.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseModelQueriable.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/BaseModelQueriable.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseModelQueriable.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/BaseModelQueriable.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseOperator.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/BaseOperator.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseOperator.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/BaseOperator.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseQueriable.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/BaseQueriable.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseQueriable.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/BaseQueriable.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseTransformable.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/BaseTransformable.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/BaseTransformable.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/BaseTransformable.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/Case.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/Case.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/Case.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/Case.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/CaseCondition.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/CaseCondition.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/CaseCondition.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/CaseCondition.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/CompletedTrigger.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/CompletedTrigger.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/CompletedTrigger.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/CompletedTrigger.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/ContentValuesListener.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/ContentValuesListener.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/ContentValuesListener.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/ContentValuesListener.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/CursorResult.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/CursorResult.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/CursorResult.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/CursorResult.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/Delete.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/Delete.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/Delete.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/Delete.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/ExistenceOperator.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/ExistenceOperator.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/ExistenceOperator.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/ExistenceOperator.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/From.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/From.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/From.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/From.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/IConditional.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/IConditional.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/IConditional.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/IConditional.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/IOperator.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/IOperator.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/IOperator.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/IOperator.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/Index.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/Index.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/Index.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/Index.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/IndexedBy.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/IndexedBy.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/IndexedBy.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/IndexedBy.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/Insert.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/Insert.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/Insert.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/Insert.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/Join.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/Join.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/Join.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/Join.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/LoadFromCursorListener.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/LoadFromCursorListener.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/LoadFromCursorListener.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/LoadFromCursorListener.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/Method.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/Method.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/Method.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/Method.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/ModelQueriable.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/ModelQueriable.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/ModelQueriable.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/ModelQueriable.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/NameAlias.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/NameAlias.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/NameAlias.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/NameAlias.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/Operator.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/Operator.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/Operator.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/Operator.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/OperatorGroup.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/OperatorGroup.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/OperatorGroup.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/OperatorGroup.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/OrderBy.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/OrderBy.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/OrderBy.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/OrderBy.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/Queriable.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/Queriable.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/Queriable.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/Queriable.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/SQLOperator.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/SQLOperator.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/SQLOperator.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/SQLOperator.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/SQLite.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/SQLite.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/SQLite.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/SQLite.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/SQLiteStatementListener.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/SQLiteStatementListener.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/SQLiteStatementListener.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/SQLiteStatementListener.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/Select.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/Select.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/Select.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/Select.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/Set.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/Set.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/Set.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/Set.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/StringQuery.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/StringQuery.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/StringQuery.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/StringQuery.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/Transformable.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/Transformable.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/Transformable.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/Transformable.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/Trigger.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/Trigger.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/Trigger.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/Trigger.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/TriggerMethod.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/TriggerMethod.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/TriggerMethod.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/TriggerMethod.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/UnSafeStringOperator.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/UnSafeStringOperator.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/UnSafeStringOperator.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/UnSafeStringOperator.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/Update.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/Update.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/Update.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/Update.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/Where.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/Where.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/Where.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/Where.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/WhereBase.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/WhereBase.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/WhereBase.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/WhereBase.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/cache/IMultiKeyCacheConverter.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/cache/IMultiKeyCacheConverter.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/cache/IMultiKeyCacheConverter.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/cache/IMultiKeyCacheConverter.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/cache/ModelCache.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/cache/ModelCache.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/cache/ModelCache.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/cache/ModelCache.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/cache/ModelLruCache.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/cache/ModelLruCache.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/cache/ModelLruCache.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/cache/ModelLruCache.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/cache/SimpleMapCache.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/cache/SimpleMapCache.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/cache/SimpleMapCache.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/cache/SimpleMapCache.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/cache/SparseArrayBasedCache.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/cache/SparseArrayBasedCache.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/cache/SparseArrayBasedCache.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/cache/SparseArrayBasedCache.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowCursorIterator.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/list/FlowCursorIterator.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowCursorIterator.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/list/FlowCursorIterator.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowCursorList.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/list/FlowCursorList.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowCursorList.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/list/FlowCursorList.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowQueryList.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/list/FlowQueryList.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/list/FlowQueryList.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/list/FlowQueryList.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/list/IFlowCursorIterator.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/list/IFlowCursorIterator.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/list/IFlowCursorIterator.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/list/IFlowCursorIterator.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/IProperty.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/property/IProperty.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/property/IProperty.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/property/IProperty.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/IndexProperty.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/property/IndexProperty.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/property/IndexProperty.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/property/IndexProperty.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/Property.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/property/Property.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/property/Property.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/property/Property.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/PropertyFactory.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/property/PropertyFactory.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/property/PropertyFactory.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/property/PropertyFactory.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/TypeConvertedProperty.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/property/TypeConvertedProperty.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/property/TypeConvertedProperty.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/property/TypeConvertedProperty.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/query/property/WrapperProperty.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/property/WrapperProperty.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/query/property/WrapperProperty.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/property/WrapperProperty.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/ContentResolverNotifier.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/runtime/ContentResolverNotifier.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/runtime/ContentResolverNotifier.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/runtime/ContentResolverNotifier.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/DBBatchSaveQueue.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/runtime/DBBatchSaveQueue.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/runtime/DBBatchSaveQueue.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/runtime/DBBatchSaveQueue.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/DirectModelNotifier.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/runtime/DirectModelNotifier.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/runtime/DirectModelNotifier.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/runtime/DirectModelNotifier.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/FlowContentObserver.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/runtime/FlowContentObserver.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/runtime/FlowContentObserver.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/runtime/FlowContentObserver.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/ModelNotifier.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/runtime/ModelNotifier.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/runtime/ModelNotifier.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/runtime/ModelNotifier.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/NotifyDistributor.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/runtime/NotifyDistributor.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/runtime/NotifyDistributor.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/runtime/NotifyDistributor.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/OnTableChangedListener.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/runtime/OnTableChangedListener.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/runtime/OnTableChangedListener.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/runtime/OnTableChangedListener.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/runtime/TableNotifierRegister.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/runtime/TableNotifierRegister.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/runtime/TableNotifierRegister.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/runtime/TableNotifierRegister.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/structure/Action.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/structure/Action.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/structure/Action.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/structure/Action.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/structure/BaseModel.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/structure/BaseModel.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/structure/BaseModel.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/structure/BaseModel.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/structure/BaseModelView.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/structure/BaseModelView.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/structure/BaseModelView.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/structure/BaseModelView.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/structure/BaseQueryModel.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/structure/BaseQueryModel.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/structure/BaseQueryModel.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/structure/BaseQueryModel.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/structure/InvalidDBConfiguration.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/structure/InvalidDBConfiguration.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/structure/InvalidDBConfiguration.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/structure/InvalidDBConfiguration.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/structure/Model.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/structure/Model.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/structure/Model.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/structure/Model.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/structure/NoModificationModel.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/structure/NoModificationModel.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/structure/NoModificationModel.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/structure/NoModificationModel.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/structure/OneToMany.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/structure/OneToMany.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/structure/OneToMany.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/structure/OneToMany.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/structure/ReadOnlyModel.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/structure/ReadOnlyModel.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/structure/ReadOnlyModel.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/structure/ReadOnlyModel.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/BaseTransactionManager.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/transaction/BaseTransactionManager.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/transaction/BaseTransactionManager.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/transaction/BaseTransactionManager.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/DefaultTransactionManager.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/transaction/DefaultTransactionManager.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/transaction/DefaultTransactionManager.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/transaction/DefaultTransactionManager.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/DefaultTransactionQueue.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/transaction/DefaultTransactionQueue.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/transaction/DefaultTransactionQueue.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/transaction/DefaultTransactionQueue.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/FastStoreModelTransaction.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/transaction/FastStoreModelTransaction.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/transaction/FastStoreModelTransaction.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/transaction/FastStoreModelTransaction.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/ITransaction.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/transaction/ITransaction.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/transaction/ITransaction.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/transaction/ITransaction.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/ITransactionQueue.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/transaction/ITransactionQueue.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/transaction/ITransactionQueue.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/transaction/ITransactionQueue.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/PriorityTransactionQueue.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/transaction/PriorityTransactionQueue.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/transaction/PriorityTransactionQueue.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/transaction/PriorityTransactionQueue.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/PriorityTransactionWrapper.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/transaction/PriorityTransactionWrapper.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/transaction/PriorityTransactionWrapper.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/transaction/PriorityTransactionWrapper.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/ProcessModelTransaction.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/transaction/ProcessModelTransaction.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/transaction/ProcessModelTransaction.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/transaction/ProcessModelTransaction.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/Transaction.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/transaction/Transaction.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/transaction/Transaction.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/transaction/Transaction.kt diff --git a/dbflow/src/main/java/com/raizlabs/dbflow5/transaction/TransactionWrapper.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/transaction/TransactionWrapper.kt similarity index 100% rename from dbflow/src/main/java/com/raizlabs/dbflow5/transaction/TransactionWrapper.kt rename to dbflow/src/main/kotlin/com/raizlabs/dbflow5/transaction/TransactionWrapper.kt From 85abc4911089a5b59f31cd8da73616d125ee35ec Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Fri, 8 Dec 2017 13:06:06 -0500 Subject: [PATCH 141/234] [lib] make sources working again. remove and fix most warnings in lib. remove deprecated method from FlowManager.reset(context) --- android-artifacts.gradle | 43 --------- bintray_upload.gradle | 30 ------- dbflow-rx/build.gradle | 2 +- .../dbflow5/rx/query/RXModelQueriableImpl.kt | 6 +- .../rx/query/TableChangeListenerEmitter.java | 90 ------------------- .../rx/query/TableChangeListenerEmitter.kt | 68 ++++++++++++++ dbflow-rx2/build.gradle | 2 +- dbflow-sqlcipher/build.gradle | 2 +- .../dbflow5/sql/language/TriggerTest.kt | 1 - dbflow/build.gradle | 4 +- .../raizlabs/dbflow5/config/DBFlowDatabase.kt | 6 -- .../com/raizlabs/dbflow5/query/Trigger.kt | 34 ++++--- .../raizlabs/dbflow5/query/TriggerMethod.kt | 2 +- .../dbflow5/query/list/FlowQueryList.kt | 6 +- .../dbflow5/query/property/PropertyFactory.kt | 23 ++--- .../dbflow5/runtime/FlowContentObserver.kt | 34 +++---- gradle.properties | 2 +- kotlin-artifacts.gradle | 10 +-- 18 files changed, 130 insertions(+), 235 deletions(-) delete mode 100644 android-artifacts.gradle delete mode 100644 bintray_upload.gradle delete mode 100644 dbflow-rx/src/main/kotlin/com/raizlabs/dbflow5/rx/query/TableChangeListenerEmitter.java create mode 100644 dbflow-rx/src/main/kotlin/com/raizlabs/dbflow5/rx/query/TableChangeListenerEmitter.kt diff --git a/android-artifacts.gradle b/android-artifacts.gradle deleted file mode 100644 index 9c8dae956..000000000 --- a/android-artifacts.gradle +++ /dev/null @@ -1,43 +0,0 @@ -apply plugin: 'com.github.dcendents.android-maven' -install { - repositories.mavenInstaller { - pom { - project { - packaging bt_packaging - name bt_name - url bt_siteUrl - licenses { - license { - name bt_licenseName - url bt_licenseUrl - } - } - scm { - connection bt_gitUrl - developerConnection bt_gitUrl - url bt_siteUrl - } - } - } - } -} - -task sourcesJar(type: Jar) { - from android.sourceSets.main.java.srcDirs - classifier = 'sources' -} - -task javadoc(type: Javadoc) { - source = android.sourceSets.main.java.srcDirs - classpath += project.files(android.getBootClasspath().join(File.pathSeparator)) -} - -task javadocJar(type: Jar, dependsOn: javadoc) { - classifier = 'javadoc' - from javadoc.destinationDir -} - -artifacts { - //archives javadocJar - archives sourcesJar -} \ No newline at end of file diff --git a/bintray_upload.gradle b/bintray_upload.gradle deleted file mode 100644 index d65988aad..000000000 --- a/bintray_upload.gradle +++ /dev/null @@ -1,30 +0,0 @@ -/** - * This task will generate the pom.xml file and install the AAR to the local M2 repo - */ -install { - repositories { - mavenInstaller { - pom.artifactId = bt_artifact_id - pom { - project { - packaging bt_packaging - name bt_name - url bt_siteUrl - - licenses { - license { - name bt_licenseName - url bt_licenseUrl - } - } - - scm { - connection bt_gitUrl - developerConnection bt_gitUrl - url bt_siteUrl - } - } - } - } - } -} diff --git a/dbflow-rx/build.gradle b/dbflow-rx/build.gradle index 043ad152f..ab7cc99de 100644 --- a/dbflow-rx/build.gradle +++ b/dbflow-rx/build.gradle @@ -27,4 +27,4 @@ dependencies { api deps.kotlin } -apply from: '../android-artifacts.gradle' +apply from: '../kotlin-artifacts.gradle' diff --git a/dbflow-rx/src/main/kotlin/com/raizlabs/dbflow5/rx/query/RXModelQueriableImpl.kt b/dbflow-rx/src/main/kotlin/com/raizlabs/dbflow5/rx/query/RXModelQueriableImpl.kt index a43ab65dc..692587132 100644 --- a/dbflow-rx/src/main/kotlin/com/raizlabs/dbflow5/rx/query/RXModelQueriableImpl.kt +++ b/dbflow-rx/src/main/kotlin/com/raizlabs/dbflow5/rx/query/RXModelQueriableImpl.kt @@ -1,10 +1,10 @@ package com.raizlabs.dbflow5.rx.query -import com.raizlabs.dbflow5.query.list.FlowCursorList -import com.raizlabs.dbflow5.query.list.FlowQueryList import com.raizlabs.dbflow5.query.BaseModelQueriable import com.raizlabs.dbflow5.query.CursorResult import com.raizlabs.dbflow5.query.ModelQueriable +import com.raizlabs.dbflow5.query.list.FlowCursorList +import com.raizlabs.dbflow5.query.list.FlowQueryList import rx.Emitter import rx.Observable import rx.Single @@ -18,7 +18,7 @@ constructor(private val innerModelQueriable: ModelQueriable) : RXQueriableImpl(innerModelQueriable), RXModelQueriable { override fun queryStreamResults(): Observable = - Observable.create(CursorResultSubscriber(this)) + Observable.unsafeCreate(CursorResultSubscriber(this)) override fun queryResults(): Single> = fromCallable { innerModelQueriable.queryResults() } diff --git a/dbflow-rx/src/main/kotlin/com/raizlabs/dbflow5/rx/query/TableChangeListenerEmitter.java b/dbflow-rx/src/main/kotlin/com/raizlabs/dbflow5/rx/query/TableChangeListenerEmitter.java deleted file mode 100644 index 69bf0ecfd..000000000 --- a/dbflow-rx/src/main/kotlin/com/raizlabs/dbflow5/rx/query/TableChangeListenerEmitter.java +++ /dev/null @@ -1,90 +0,0 @@ -package com.raizlabs.dbflow5.rx.query; - -import android.support.annotation.NonNull; -import android.support.annotation.Nullable; - -import com.raizlabs.dbflow5.config.FlowManager; -import com.raizlabs.dbflow5.runtime.OnTableChangedListener; -import com.raizlabs.dbflow5.runtime.TableNotifierRegister; -import com.raizlabs.dbflow5.query.From; -import com.raizlabs.dbflow5.query.Join; -import com.raizlabs.dbflow5.query.Where; -import com.raizlabs.dbflow5.query.ModelQueriable; -import com.raizlabs.dbflow5.structure.ChangeAction; - -import rx.Emitter; -import rx.Subscription; -import rx.functions.Action1; - -/** - * Description: Emits when table changes occur for the related table on the {@link ModelQueriable}. - * If the {@link ModelQueriable} relates to a {@link Join}, this can be multiple tables. - */ -public class TableChangeListenerEmitter implements Action1>> { - - private final ModelQueriable modelQueriable; - - public TableChangeListenerEmitter(ModelQueriable modelQueriable) { - this.modelQueriable = modelQueriable; - } - - @Override - public void call(Emitter> modelQueriableEmitter) { - modelQueriableEmitter.setSubscription( - new FlowContentObserverSubscription(modelQueriableEmitter, modelQueriable.getTable())); - } - - private class FlowContentObserverSubscription implements Subscription { - - private final Emitter> modelQueriableEmitter; - - private final TableNotifierRegister register; - - private FlowContentObserverSubscription( - Emitter> modelQueriableEmitter, Class table) { - this.modelQueriableEmitter = modelQueriableEmitter; - register = FlowManager.newRegisterForTable(table); - - From from = null; - if (modelQueriable instanceof From) { - from = (From) modelQueriable; - } else if (modelQueriable instanceof Where - && ((Where) modelQueriable).getWhereBase() instanceof From) { - //noinspection unchecked - from = (From) ((Where) modelQueriable).getWhereBase(); - } - - // From could be part of many joins, so we register for all affected tables here. - if (from != null) { - java.util.Set> associatedTables = from.getAssociatedTables(); - for (Class associated : associatedTables) { - register.register(associated); - } - } else { - register.register(table); - } - - register.setListener(onTableChangedListener); - } - - @Override - public void unsubscribe() { - register.unregisterAll(); - } - - @Override - public boolean isUnsubscribed() { - return !register.isSubscribed(); - } - - private final OnTableChangedListener onTableChangedListener - = new OnTableChangedListener() { - @Override - public void onTableChanged(@Nullable Class table, @NonNull ChangeAction action) { - if (modelQueriable.getTable().equals(table)) { - modelQueriableEmitter.onNext(modelQueriable); - } - } - }; - } -} diff --git a/dbflow-rx/src/main/kotlin/com/raizlabs/dbflow5/rx/query/TableChangeListenerEmitter.kt b/dbflow-rx/src/main/kotlin/com/raizlabs/dbflow5/rx/query/TableChangeListenerEmitter.kt new file mode 100644 index 000000000..1c1b58458 --- /dev/null +++ b/dbflow-rx/src/main/kotlin/com/raizlabs/dbflow5/rx/query/TableChangeListenerEmitter.kt @@ -0,0 +1,68 @@ +package com.raizlabs.dbflow5.rx.query + +import com.raizlabs.dbflow5.config.FlowManager +import com.raizlabs.dbflow5.query.From +import com.raizlabs.dbflow5.query.Join +import com.raizlabs.dbflow5.query.ModelQueriable +import com.raizlabs.dbflow5.query.Where +import com.raizlabs.dbflow5.runtime.OnTableChangedListener +import com.raizlabs.dbflow5.runtime.TableNotifierRegister +import com.raizlabs.dbflow5.structure.ChangeAction +import rx.Emitter +import rx.Subscription +import rx.functions.Action1 + +/** + * Description: Emits when table changes occur for the related table on the [ModelQueriable]. + * If the [ModelQueriable] relates to a [Join], this can be multiple tables. + */ +class TableChangeListenerEmitter(private val modelQueriable: ModelQueriable) + : Action1>> { + + override fun call(modelQueriableEmitter: Emitter>) { + modelQueriableEmitter.setSubscription( + FlowContentObserverSubscription(modelQueriableEmitter, modelQueriable.table)) + } + + private inner class FlowContentObserverSubscription internal constructor( + private val modelQueriableEmitter: Emitter>, table: Class) + : Subscription { + + private val register: TableNotifierRegister = FlowManager.newRegisterForTable(table) + + private val onTableChangedListener = object : OnTableChangedListener { + override fun onTableChanged(table: Class<*>?, action: ChangeAction) { + if (modelQueriable.table == table) { + modelQueriableEmitter.onNext(modelQueriable) + } + } + } + + init { + val from: From? = when { + modelQueriable is From<*> -> modelQueriable as From + modelQueriable is Where<*> && modelQueriable.whereBase is From<*> -> + @Suppress("UNCHECKED_CAST") + modelQueriable.whereBase as From + else -> null + } + + // From could be part of many joins, so we register for all affected tables here. + if (from != null) { + from.associatedTables.forEach { register.register(it) } + } else { + register.register(table) + } + + register.setListener(onTableChangedListener) + } + + override fun unsubscribe() { + register.unregisterAll() + } + + override fun isUnsubscribed(): Boolean { + return !register.isSubscribed + } + } +} diff --git a/dbflow-rx2/build.gradle b/dbflow-rx2/build.gradle index 3c3db907f..0378140b6 100644 --- a/dbflow-rx2/build.gradle +++ b/dbflow-rx2/build.gradle @@ -27,4 +27,4 @@ dependencies { api deps.kotlin } -apply from: '../android-artifacts.gradle' +apply from: '../kotlin-artifacts.gradle' diff --git a/dbflow-sqlcipher/build.gradle b/dbflow-sqlcipher/build.gradle index 1669f6ea4..4cad5dbab 100644 --- a/dbflow-sqlcipher/build.gradle +++ b/dbflow-sqlcipher/build.gradle @@ -31,4 +31,4 @@ dependencies { api deps.kotlin } -apply from: '../android-artifacts.gradle' +apply from: '../kotlin-artifacts.gradle' diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/TriggerTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/TriggerTest.kt index c68335b0f..4e90820ad 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/TriggerTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/TriggerTest.kt @@ -8,7 +8,6 @@ import com.raizlabs.dbflow5.models.SimpleModel_Table.name import com.raizlabs.dbflow5.models.TwoColumnModel import com.raizlabs.dbflow5.models.TwoColumnModel_Table.id import com.raizlabs.dbflow5.query.NameAlias -import com.raizlabs.dbflow5.query.begin import com.raizlabs.dbflow5.query.cast import com.raizlabs.dbflow5.query.columnValues import com.raizlabs.dbflow5.query.createTrigger diff --git a/dbflow/build.gradle b/dbflow/build.gradle index 10038b664..c0f68aaec 100644 --- a/dbflow/build.gradle +++ b/dbflow/build.gradle @@ -28,8 +28,8 @@ android { dependencies { api project("${dbflow_project_prefix}dbflow-core") api "com.android.support:support-annotations:27.0.2" - compile "org.jetbrains.kotlin:kotlin-stdlib:${kotlin_version}" + api "org.jetbrains.kotlin:kotlin-stdlib:${kotlin_version}" } -apply from: '../android-artifacts.gradle' +apply from: '../kotlin-artifacts.gradle' diff --git a/dbflow/src/main/kotlin/com/raizlabs/dbflow5/config/DBFlowDatabase.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/config/DBFlowDatabase.kt index 473e0c2ae..1a477aafa 100644 --- a/dbflow/src/main/kotlin/com/raizlabs/dbflow5/config/DBFlowDatabase.kt +++ b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/config/DBFlowDatabase.kt @@ -1,7 +1,6 @@ package com.raizlabs.dbflow5.config import android.content.ContentValues -import android.content.Context import com.raizlabs.dbflow5.adapter.ModelAdapter import com.raizlabs.dbflow5.adapter.ModelViewAdapter import com.raizlabs.dbflow5.adapter.QueryModelAdapter @@ -332,11 +331,6 @@ abstract class DBFlowDatabase : DatabaseWrapper { */ abstract fun backupEnabled(): Boolean - @Deprecated(message = "use {@link #reset()}", replaceWith = ReplaceWith("reset()")) - fun reset(context: Context) { - reset(databaseConfig) - } - /** * Performs a full deletion of this database. Reopens the [AndroidSQLiteOpenHelper] as well. * diff --git a/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/Trigger.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/Trigger.kt index ddd43850d..323c78448 100644 --- a/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/Trigger.kt +++ b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/Trigger.kt @@ -17,13 +17,13 @@ class Trigger * @param triggerName What we should call this trigger */ private constructor( - /** - * The name in the DB - */ - /** - * @return The name of this TRIGGER - */ - val name: String) : Query { + /** + * The name in the DB + */ + /** + * @return The name of this TRIGGER + */ + val name: String) : Query { /** * If it's [.BEFORE], [.AFTER], or [.INSTEAD_OF] @@ -39,8 +39,8 @@ private constructor( queryBuilder.append("TEMP ") } queryBuilder.append("TRIGGER IF NOT EXISTS ") - .appendQuotedIfNeeded(name).append(" ") - .appendOptional(beforeOrAfter + " ") + .appendQuotedIfNeeded(name).append(" ") + .appendOptional(beforeOrAfter + " ") return queryBuilder.toString() } @@ -78,16 +78,16 @@ private constructor( * * @param onTable The table ON */ - fun deleteOn(onTable: Class): TriggerMethod = - TriggerMethod(this, TriggerMethod.DELETE, onTable) + infix fun deleteOn(onTable: Class): TriggerMethod = + TriggerMethod(this, TriggerMethod.DELETE, onTable) /** * Starts a INSERT ON command * * @param onTable The table ON */ - fun insertOn(onTable: Class): TriggerMethod = - TriggerMethod(this, TriggerMethod.INSERT, onTable) + infix fun insertOn(onTable: Class): TriggerMethod = + TriggerMethod(this, TriggerMethod.INSERT, onTable) /** * Starts an UPDATE ON command @@ -97,7 +97,7 @@ private constructor( * the UPDATE OF column1, column2,... will be used. */ fun updateOn(onTable: Class, vararg properties: IProperty<*>): TriggerMethod = - TriggerMethod(this, TriggerMethod.UPDATE, onTable, *properties) + TriggerMethod(this, TriggerMethod.UPDATE, onTable, *properties) companion object { @@ -132,8 +132,4 @@ infix fun Trigger.deleteOn(kClass: KClass) = deleteOn(kClass.java) infix fun Trigger.insertOn(kClass: KClass) = insertOn(kClass.java) -infix fun Trigger.updateOn(kClass: KClass) = updateOn(kClass.java) - -infix fun TriggerMethod.begin(triggerStatement: Query) = begin(triggerStatement) - -infix fun CompletedTrigger.and(nextStatement: Query) = and(nextStatement) \ No newline at end of file +infix fun Trigger.updateOn(kClass: KClass) = updateOn(kClass.java) \ No newline at end of file diff --git a/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/TriggerMethod.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/TriggerMethod.kt index 30ac9ac03..9c4c36efa 100644 --- a/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/TriggerMethod.kt +++ b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/TriggerMethod.kt @@ -72,7 +72,7 @@ internal constructor(internal val trigger: Trigger, private val methodName: Stri * @param triggerLogicQuery The query to run for the BEGIN..END of the trigger * @return This trigger */ - fun begin(triggerLogicQuery: Query): CompletedTrigger = + infix fun begin(triggerLogicQuery: Query): CompletedTrigger = CompletedTrigger(this, triggerLogicQuery) companion object { diff --git a/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/list/FlowQueryList.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/list/FlowQueryList.kt index c21902dc5..1a66fd9dd 100644 --- a/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/list/FlowQueryList.kt +++ b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/list/FlowQueryList.kt @@ -165,12 +165,12 @@ class FlowQueryList( } /** - * @param location The index to start the iterator. + * @param index The index to start the iterator. * @return A list iterator from the [FlowCursorList.getAll]. * Be careful as this method will convert all data under this table into a list of [T] in the UI thread. */ - override fun listIterator(location: Int): ListIterator { - return FlowCursorIterator(this, location) + override fun listIterator(index: Int): ListIterator { + return FlowCursorIterator(this, index) } override fun subList(fromIndex: Int, toIndex: Int): List { diff --git a/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/property/PropertyFactory.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/property/PropertyFactory.kt index 9b1ad7efc..3785700e5 100644 --- a/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/property/PropertyFactory.kt +++ b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/property/PropertyFactory.kt @@ -19,7 +19,7 @@ object PropertyFactory { @JvmStatic fun from(c: Char): Property { return Property(null, NameAlias.rawBuilder("'$c'") - .build()) + .build()) } /** @@ -31,7 +31,7 @@ object PropertyFactory { @JvmStatic fun from(i: Int): Property { return Property(null, NameAlias.rawBuilder(i.toString() + "") - .build()) + .build()) } /** @@ -43,7 +43,7 @@ object PropertyFactory { @JvmStatic fun from(d: Double): Property { return Property(null, NameAlias.rawBuilder(d.toString() + "") - .build()) + .build()) } /** @@ -55,7 +55,7 @@ object PropertyFactory { @JvmStatic fun from(l: Long): Property { return Property(null, NameAlias.rawBuilder(l.toString() + "") - .build()) + .build()) } /** @@ -67,7 +67,7 @@ object PropertyFactory { @JvmStatic fun from(f: Float): Property { return Property(null, NameAlias.rawBuilder(f.toString() + "") - .build()) + .build()) } /** @@ -79,7 +79,7 @@ object PropertyFactory { @JvmStatic fun from(s: Short): Property { return Property(null, NameAlias.rawBuilder(s.toString() + "") - .build()) + .build()) } /** @@ -91,7 +91,7 @@ object PropertyFactory { @JvmStatic fun from(b: Byte): Property { return Property(null, NameAlias.rawBuilder(b.toString() + "") - .build()) + .build()) } /** @@ -109,8 +109,8 @@ object PropertyFactory { @JvmStatic fun from(type: T?): Property { return Property(null, NameAlias.rawBuilder( - Operator.convertValueToString(type) ?: "") - .build()) + Operator.convertValueToString(type) ?: "") + .build()) } /** @@ -122,7 +122,7 @@ object PropertyFactory { */ @JvmStatic fun from(queriable: ModelQueriable): Property = - from(queriable.table, "(${queriable.query.trim { it <= ' ' }})") + from(queriable.table, "(${queriable.query.trim { it <= ' ' }})") /** * Creates a new type-parameterized [Property] to be used as its value represented by the string passed in. @@ -131,10 +131,11 @@ object PropertyFactory { * @param [T] The parameter of its type. * @return A new property with its type. */ + @Suppress("UNUSED_PARAMETER") @JvmStatic fun from(table: Class, stringRepresentation: String?): Property { return Property(null, NameAlias.rawBuilder(stringRepresentation ?: "") - .build()) + .build()) } } diff --git a/dbflow/src/main/kotlin/com/raizlabs/dbflow5/runtime/FlowContentObserver.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/runtime/FlowContentObserver.kt index 427b4c7e2..5666d33c5 100644 --- a/dbflow/src/main/kotlin/com/raizlabs/dbflow5/runtime/FlowContentObserver.kt +++ b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/runtime/FlowContentObserver.kt @@ -100,7 +100,7 @@ open class FlowContentObserver(private val contentAuthority: String, } else { synchronized(notificationUris) { for (uri in notificationUris) { - onChange(true, uri, true) + onChange(uri, true) } notificationUris.clear() } @@ -108,7 +108,7 @@ open class FlowContentObserver(private val contentAuthority: String, for (uri in tableUris) { for (onTableChangedListener in onTableChangedListeners) { onTableChangedListener.onTableChanged(registeredTables[uri.authority], - ChangeAction.valueOf(uri.fragment)) + ChangeAction.valueOf(uri.fragment)) } } tableUris.clear() @@ -177,7 +177,7 @@ open class FlowContentObserver(private val contentAuthority: String, fun registerForContentChanges(contentResolver: ContentResolver, table: Class<*>) { contentResolver.registerContentObserver( - getNotificationUri(contentAuthority, table, null), true, this) + getNotificationUri(contentAuthority, table, null), true, this) REGISTERED_COUNT.incrementAndGet() if (!registeredTables.containsValue(table)) { registeredTables.put(FlowManager.getTableName(table), table) @@ -200,27 +200,27 @@ open class FlowContentObserver(private val contentAuthority: String, @TargetApi(VERSION_CODES.JELLY_BEAN) override fun onChange(selfChange: Boolean, uri: Uri) { - onChange(selfChange, uri, false) + onChange(uri, false) } @TargetApi(VERSION_CODES.JELLY_BEAN) - private fun onChange(selfChanges: Boolean, uri: Uri, calledInternally: Boolean) { - var uri = uri - val fragment = uri.fragment - val tableName = uri.getQueryParameter(TABLE_QUERY_PARAM) + private fun onChange(uri: Uri, calledInternally: Boolean) { + var _uri = uri + val fragment = _uri.fragment + val tableName = _uri.getQueryParameter(TABLE_QUERY_PARAM) var columnName: String var param: String - val queryNames = uri.queryParameterNames + val queryNames = _uri.queryParameterNames val columnsChanged = arrayListOf() queryNames.asSequence() - .filter { it != TABLE_QUERY_PARAM } - .forEach { key -> - param = Uri.decode(uri.getQueryParameter(key)) - columnName = Uri.decode(key) - columnsChanged += Operator.op(NameAlias.Builder(columnName).build()).eq(param) - } + .filter { it != TABLE_QUERY_PARAM } + .forEach { key -> + param = Uri.decode(_uri.getQueryParameter(key)) + columnName = Uri.decode(key) + columnsChanged += Operator.op(NameAlias.Builder(columnName).build()).eq(param) + } val table = registeredTables[tableName] if (table != null) { @@ -237,11 +237,11 @@ open class FlowContentObserver(private val contentAuthority: String, // convert this uri to a CHANGE op if we don't care about individual changes. if (!notifyAllUris) { action = ChangeAction.CHANGE - uri = getNotificationUri(contentAuthority, table, action) + _uri = getNotificationUri(contentAuthority, table, action) } synchronized(notificationUris) { // add and keep track of unique notification uris for when transaction completes. - notificationUris.add(uri) + notificationUris.add(_uri) } synchronized(tableUris) { diff --git a/gradle.properties b/gradle.properties index 2d2b9ba60..9d97ed823 100644 --- a/gradle.properties +++ b/gradle.properties @@ -1,4 +1,4 @@ -version=4.1.1 +version=5.0.0-alpha1 version_code=1 group=com.raizlabs.android bt_siteUrl=https://github.com/Raizlabs/DBFlow diff --git a/kotlin-artifacts.gradle b/kotlin-artifacts.gradle index b4f2d1740..b2c25e61b 100644 --- a/kotlin-artifacts.gradle +++ b/kotlin-artifacts.gradle @@ -24,10 +24,10 @@ install { } // restore when found. -/*task sourcesJar(type: Jar, dependsOn: classes) { - classifier = 'sources' - from sourceSets.main.allSource -}*/ +task sourcesJar(type: Jar) { + from "src" + classifier = "sources" +} /*task javadocJar(type: Jar, dependsOn: javadoc) { classifier = 'javadoc' @@ -35,6 +35,6 @@ install { }*/ artifacts { - //archives sourcesJar + archives sourcesJar //archives javadocJar } \ No newline at end of file From 19e317dd18499fa3ae07a88a9268d1540e597790 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Fri, 8 Dec 2017 13:09:20 -0500 Subject: [PATCH 142/234] [lib] remove javadoc commented out task.keep sources as full. --- kotlin-artifacts.gradle | 7 ------- 1 file changed, 7 deletions(-) diff --git a/kotlin-artifacts.gradle b/kotlin-artifacts.gradle index b2c25e61b..38f9f6cb5 100644 --- a/kotlin-artifacts.gradle +++ b/kotlin-artifacts.gradle @@ -23,18 +23,11 @@ install { } } -// restore when found. task sourcesJar(type: Jar) { from "src" classifier = "sources" } -/*task javadocJar(type: Jar, dependsOn: javadoc) { - classifier = 'javadoc' - from javadoc.destinationDir -}*/ - artifacts { archives sourcesJar - //archives javadocJar } \ No newline at end of file From 7feb7288d894a6f1f7a7ccbf835dd6e4085fdca9 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Mon, 11 Dec 2017 09:11:50 -0500 Subject: [PATCH 143/234] [paging] add paging lib as separate artifact. --- build.gradle | 1 + dbflow-paging/build.gradle | 35 ++++++++++++ dbflow-paging/gradle.properties | 3 + dbflow-paging/settings.gradle | 1 + dbflow-paging/src/main/AndroidManifest.xml | 2 + .../com/raizlabs/dbflow5/paging/Factory.kt | 55 +++++++++++++++++++ dbflow-tests/build.gradle | 1 + .../paging/ModelQueriableDataSourceTest.kt | 15 +++++ .../raizlabs/dbflow5/query/CursorResult.kt | 4 +- .../dbflow5/query/list/FlowCursorList.kt | 14 ++--- .../dbflow5/query/list/FlowQueryList.kt | 5 +- .../dbflow5/query/list/IFlowCursorIterator.kt | 9 ++- settings.gradle | 11 ++-- 13 files changed, 137 insertions(+), 19 deletions(-) create mode 100644 dbflow-paging/build.gradle create mode 100644 dbflow-paging/gradle.properties create mode 100644 dbflow-paging/settings.gradle create mode 100644 dbflow-paging/src/main/AndroidManifest.xml create mode 100644 dbflow-paging/src/main/kotlin/com/raizlabs/dbflow5/paging/Factory.kt create mode 100644 dbflow-tests/src/test/java/com/raizlabs/dbflow5/paging/ModelQueriableDataSourceTest.kt diff --git a/build.gradle b/build.gradle index 6aa6bebcc..6079cf728 100644 --- a/build.gradle +++ b/build.gradle @@ -5,6 +5,7 @@ buildscript { min_sdk = 7 min_sdk_rx = 15 sql_cipher_min = 7 + arch_min = 14 deps = [ kotlin : "org.jetbrains.kotlin:kotlin-stdlib:${kotlin_version}", diff --git a/dbflow-paging/build.gradle b/dbflow-paging/build.gradle new file mode 100644 index 000000000..ca5bc7b5a --- /dev/null +++ b/dbflow-paging/build.gradle @@ -0,0 +1,35 @@ +apply plugin: 'com.android.library' +apply plugin: 'kotlin-android' + +project.ext.artifactId = bt_name + +android { + compileSdkVersion target_sdk + + defaultConfig { + minSdkVersion arch_min + targetSdkVersion target_sdk + } + + lintOptions { + abortOnError false + } + + compileOptions { + sourceCompatibility JavaVersion.VERSION_1_8 + targetCompatibility JavaVersion.VERSION_1_8 + } + + sourceSets { + main.java.srcDirs += 'src/main/kotlin' + } +} + +dependencies { + implementation project("${dbflow_project_prefix}dbflow") + api "android.arch.paging:runtime:1.0.0-alpha4" + api "org.jetbrains.kotlin:kotlin-stdlib:${kotlin_version}" +} + +apply from: '../kotlin-artifacts.gradle' + diff --git a/dbflow-paging/gradle.properties b/dbflow-paging/gradle.properties new file mode 100644 index 000000000..f02d9329c --- /dev/null +++ b/dbflow-paging/gradle.properties @@ -0,0 +1,3 @@ +bt_name=dbflow +bt_packaging=aar +bt_artifact_id=dbflow \ No newline at end of file diff --git a/dbflow-paging/settings.gradle b/dbflow-paging/settings.gradle new file mode 100644 index 000000000..00126c83c --- /dev/null +++ b/dbflow-paging/settings.gradle @@ -0,0 +1 @@ +rootProject.name = buildName \ No newline at end of file diff --git a/dbflow-paging/src/main/AndroidManifest.xml b/dbflow-paging/src/main/AndroidManifest.xml new file mode 100644 index 000000000..6d377d33b --- /dev/null +++ b/dbflow-paging/src/main/AndroidManifest.xml @@ -0,0 +1,2 @@ + + diff --git a/dbflow-paging/src/main/kotlin/com/raizlabs/dbflow5/paging/Factory.kt b/dbflow-paging/src/main/kotlin/com/raizlabs/dbflow5/paging/Factory.kt new file mode 100644 index 000000000..067140c3d --- /dev/null +++ b/dbflow-paging/src/main/kotlin/com/raizlabs/dbflow5/paging/Factory.kt @@ -0,0 +1,55 @@ +package com.raizlabs.dbflow5.paging + +import android.arch.paging.DataSource +import android.arch.paging.PositionalDataSource +import com.raizlabs.dbflow5.config.DBFlowDatabase +import com.raizlabs.dbflow5.query.ModelQueriable + +/** + * Bridges the [ModelQueriable] into a [PositionalDataSource] that loads a [ModelQueriable]. + */ +class ModelQueriableDataSource(private val modelQueriable: ModelQueriable, + private val database: DBFlowDatabase) + : PositionalDataSource() { + override fun loadRange(params: LoadRangeParams, callback: LoadRangeCallback) { + database.executeTransactionAsync({ modelQueriable.cursorList() }, + success = { _, cursorList -> + val list = mutableListOf() + val max = when { + params.loadSize >= cursorList.count - 1 -> cursorList.count.toInt() + else -> params.loadSize + } + (params.startPosition until max).mapTo(list) { cursorList[it] } + callback.onResult(list) + }) + } + + override fun loadInitial(params: LoadInitialParams, callback: LoadInitialCallback) { + database.executeTransactionAsync({ modelQueriable.cursorList() }, + success = { _, cursorList -> + val max = when { + params.requestedLoadSize >= cursorList.count - 1 -> cursorList.count.toInt() + else -> params.requestedLoadSize + } + val list = mutableListOf() + (params.requestedStartPosition until max).mapTo(list) { cursorList[it] } + callback.onResult(list, params.requestedStartPosition, cursorList.count.toInt()) + }) + } + + class Factory + internal constructor(private val modelQueriable: ModelQueriable, + private val database: DBFlowDatabase) : DataSource.Factory { + override fun create(): DataSource = ModelQueriableDataSource(modelQueriable, database) + } + + companion object { + @JvmStatic + fun newFactory(modelQueriable: ModelQueriable, + database: DBFlowDatabase) = + Factory(modelQueriable, database) + } +} + +fun ModelQueriable.toDataSourceFactory(database: DBFlowDatabase) = + ModelQueriableDataSource.newFactory(this, database) \ No newline at end of file diff --git a/dbflow-tests/build.gradle b/dbflow-tests/build.gradle index 544af9597..8ed301277 100644 --- a/dbflow-tests/build.gradle +++ b/dbflow-tests/build.gradle @@ -53,6 +53,7 @@ dependencies { implementation project("${dbflow_project_prefix}dbflow-rx") implementation project("${dbflow_project_prefix}dbflow-rx2") implementation project("${dbflow_project_prefix}dbflow-coroutines") + implementation project("${dbflow_project_prefix}dbflow-paging") kaptTest project("${dbflow_project_prefix}dbflow-processor") kaptAndroidTest project("${dbflow_project_prefix}dbflow-processor") diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/paging/ModelQueriableDataSourceTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/paging/ModelQueriableDataSourceTest.kt new file mode 100644 index 000000000..fd8707a46 --- /dev/null +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/paging/ModelQueriableDataSourceTest.kt @@ -0,0 +1,15 @@ +package com.raizlabs.dbflow5.paging + +import com.raizlabs.dbflow5.BaseUnitTest +import org.junit.Test + +/** + * Description: + */ +class ModelQueriableDataSourceTest : BaseUnitTest() { + + @Test + fun testLoadInitialParams() { + //val list = PagedList.Builder() + } +} \ No newline at end of file diff --git a/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/CursorResult.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/CursorResult.kt index 7ca5a418d..dfb9eb96b 100644 --- a/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/CursorResult.kt +++ b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/CursorResult.kt @@ -112,10 +112,10 @@ class CursorResult internal constructor(modelClass: Class, cursor: F return customList } - override fun get(position: Long): T { + override fun get(index: Long): T { var model: T? = null _cursor?.let { cursor -> - if (cursor.moveToPosition(position.toInt())) { + if (cursor.moveToPosition(index.toInt())) { model = retrievalAdapter.singleModelLoader.convertToData(cursor, false, databaseWrapper) } } diff --git a/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/list/FlowCursorList.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/list/FlowCursorList.kt index 829685061..653e643a2 100644 --- a/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/list/FlowCursorList.kt +++ b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/list/FlowCursorList.kt @@ -99,23 +99,23 @@ class FlowCursorList private constructor(builder: Builder) : IFlowCu } /** - * Returns a model at the specified position. If we are using the cache and it does not contain a model - * at that position, we move the cursor to the specified position and construct the [T]. + * Returns a model at the specified index. If we are using the cache and it does not contain a model + * at that index, we move the cursor to the specified index and construct the [T]. * - * @param position The row number in the [FlowCursor] to look at + * @param index The row number in the [FlowCursor] to look at * @return The [T] converted from the cursor */ - override fun get(position: Long): T { + override fun get(index: Long): T { throwIfCursorClosed() val cursor = unpackCursor() - return if (cursor.moveToPosition(position.toInt())) { + return if (cursor.moveToPosition(index.toInt())) { instanceAdapter.singleModelLoader.convertToData( FlowCursor.from(cursor), false, FlowManager.getDatabaseForTable(table)) - ?: throw IndexOutOfBoundsException("Invalid item at position $position. Check your cursor data.") + ?: throw IndexOutOfBoundsException("Invalid item at index $index. Check your cursor data.") } else { - throw IndexOutOfBoundsException("Invalid item at position $position. Check your cursor data.") + throw IndexOutOfBoundsException("Invalid item at index $index. Check your cursor data.") } } diff --git a/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/list/FlowQueryList.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/list/FlowQueryList.kt index 1a66fd9dd..47e05eba6 100644 --- a/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/list/FlowQueryList.kt +++ b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/list/FlowQueryList.kt @@ -117,9 +117,6 @@ class FlowQueryList( return contains } - override fun get(position: Long): T = internalCursorList[position] - - /** * Returns the item from the backing [FlowCursorList]. First call * will load the model from the cursor, while subsequent calls will use the cache. @@ -128,6 +125,8 @@ class FlowQueryList( * @return A model converted from the internal [FlowCursorList]. For * performance improvements, ensure caching is turned on. */ + override fun get(index: Long): T = internalCursorList[index] + override operator fun get(index: Int): T = internalCursorList[index.toLong()] override fun indexOf(element: T): Int { diff --git a/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/list/IFlowCursorIterator.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/list/IFlowCursorIterator.kt index 5cab4a827..9db3ada54 100644 --- a/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/list/IFlowCursorIterator.kt +++ b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/list/IFlowCursorIterator.kt @@ -15,9 +15,14 @@ interface IFlowCursorIterator : Closeable, Iterable { val count: Long /** - * @param position The position within the [FlowCursor] to retrieve and convert into a [TModel] + * @param index The index within the [FlowCursor] to retrieve and convert into a [TModel] */ - operator fun get(position: Long): TModel + operator fun get(index: Long): TModel + + /** + * @param index The index within the [FlowCursor] to retrieve and convert into a [TModel] + */ + operator fun get(index: Int): TModel = get(index.toLong()) /** * @return The cursor. diff --git a/settings.gradle b/settings.gradle index 6e1a455aa..4d1279f4c 100644 --- a/settings.gradle +++ b/settings.gradle @@ -1,7 +1,8 @@ include ':dbflow', ':dbflow-rx2', ':dbflow-coroutines', - ':dbflow-processor', - ':dbflow-core', - ':dbflow-sqlcipher', - ':dbflow-rx', - ':dbflow-tests' + ':dbflow-processor', + ':dbflow-core', + ':dbflow-sqlcipher', + ':dbflow-rx', + ':dbflow-tests', + ':dbflow-paging' From 8138586439f16660a6df1154ff4ffa272dff4896 Mon Sep 17 00:00:00 2001 From: fuzzagrosner Date: Mon, 11 Dec 2017 09:49:08 -0500 Subject: [PATCH 144/234] [paging] properly propagate the indexes into lists for paging. add test to ensure we load items correctly. --- dbflow-coroutines/build.gradle | 4 ++ .../com/raizlabs/dbflow5/paging/Factory.kt | 45 ++++++++++--------- .../paging/ModelQueriableDataSourceTest.kt | 29 +++++++++++- 3 files changed, 55 insertions(+), 23 deletions(-) diff --git a/dbflow-coroutines/build.gradle b/dbflow-coroutines/build.gradle index 2324a539f..690349455 100644 --- a/dbflow-coroutines/build.gradle +++ b/dbflow-coroutines/build.gradle @@ -16,6 +16,10 @@ android { proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro' } } + + sourceSets { + main.java.srcDirs += 'src/main/kotlin' + } } dependencies { diff --git a/dbflow-paging/src/main/kotlin/com/raizlabs/dbflow5/paging/Factory.kt b/dbflow-paging/src/main/kotlin/com/raizlabs/dbflow5/paging/Factory.kt index 067140c3d..574874ab7 100644 --- a/dbflow-paging/src/main/kotlin/com/raizlabs/dbflow5/paging/Factory.kt +++ b/dbflow-paging/src/main/kotlin/com/raizlabs/dbflow5/paging/Factory.kt @@ -8,33 +8,34 @@ import com.raizlabs.dbflow5.query.ModelQueriable /** * Bridges the [ModelQueriable] into a [PositionalDataSource] that loads a [ModelQueriable]. */ -class ModelQueriableDataSource(private val modelQueriable: ModelQueriable, - private val database: DBFlowDatabase) +class ModelQueriableDataSource +internal constructor(private val modelQueriable: ModelQueriable, + private val database: DBFlowDatabase) : PositionalDataSource() { override fun loadRange(params: LoadRangeParams, callback: LoadRangeCallback) { database.executeTransactionAsync({ modelQueriable.cursorList() }, - success = { _, cursorList -> - val list = mutableListOf() - val max = when { - params.loadSize >= cursorList.count - 1 -> cursorList.count.toInt() - else -> params.loadSize - } - (params.startPosition until max).mapTo(list) { cursorList[it] } - callback.onResult(list) - }) + success = { _, cursorList -> + val list = mutableListOf() + val max = when { + params.loadSize >= cursorList.count - 1 -> cursorList.count.toInt() + else -> params.loadSize + } + (params.startPosition until params.startPosition + max).mapTo(list) { cursorList[it] } + callback.onResult(list) + }) } override fun loadInitial(params: LoadInitialParams, callback: LoadInitialCallback) { database.executeTransactionAsync({ modelQueriable.cursorList() }, - success = { _, cursorList -> - val max = when { - params.requestedLoadSize >= cursorList.count - 1 -> cursorList.count.toInt() - else -> params.requestedLoadSize - } - val list = mutableListOf() - (params.requestedStartPosition until max).mapTo(list) { cursorList[it] } - callback.onResult(list, params.requestedStartPosition, cursorList.count.toInt()) - }) + success = { _, cursorList -> + val max = when { + params.requestedLoadSize >= cursorList.count - 1 -> cursorList.count.toInt() + else -> params.requestedLoadSize + } + val list = mutableListOf() + (params.requestedStartPosition until params.requestedStartPosition + max).mapTo(list) { cursorList[it] } + callback.onResult(list, params.requestedStartPosition, cursorList.count.toInt()) + }) } class Factory @@ -47,9 +48,9 @@ class ModelQueriableDataSource(private val modelQueriable: ModelQueriab @JvmStatic fun newFactory(modelQueriable: ModelQueriable, database: DBFlowDatabase) = - Factory(modelQueriable, database) + Factory(modelQueriable, database) } } fun ModelQueriable.toDataSourceFactory(database: DBFlowDatabase) = - ModelQueriableDataSource.newFactory(this, database) \ No newline at end of file + ModelQueriableDataSource.newFactory(this, database) \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/paging/ModelQueriableDataSourceTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/paging/ModelQueriableDataSourceTest.kt index fd8707a46..66d9bd340 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/paging/ModelQueriableDataSourceTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/paging/ModelQueriableDataSourceTest.kt @@ -1,6 +1,13 @@ package com.raizlabs.dbflow5.paging +import android.arch.paging.PagedList import com.raizlabs.dbflow5.BaseUnitTest +import com.raizlabs.dbflow5.TestDatabase +import com.raizlabs.dbflow5.config.database +import com.raizlabs.dbflow5.models.SimpleModel +import com.raizlabs.dbflow5.query.select +import com.raizlabs.dbflow5.structure.save +import org.junit.Assert.assertEquals import org.junit.Test /** @@ -10,6 +17,26 @@ class ModelQueriableDataSourceTest : BaseUnitTest() { @Test fun testLoadInitialParams() { - //val list = PagedList.Builder() + database { + (0 until 100).forEach { SimpleModel("$it").save(this) } + + + val factory = (select from SimpleModel::class).toDataSourceFactory(this) + val list = PagedList.Builder(factory.create(), + PagedList.Config.Builder() + .setPageSize(5) + .setPrefetchDistance(10) + .setEnablePlaceholders(true).build()) + .setBackgroundThreadExecutor { it.run() } // run on main + .setMainThreadExecutor { it.run() } + .build() + + assertEquals(100, list.size) + + list.forEachIndexed { index, simpleModel -> + list.loadAround(index) + assertEquals(index, simpleModel.name?.toInt()) + } + } } } \ No newline at end of file From c832a0e6f8d29fb366c418d60f572cb4ef835970 Mon Sep 17 00:00:00 2001 From: fuzzagrosner Date: Mon, 11 Dec 2017 09:50:41 -0500 Subject: [PATCH 145/234] [paging] close cursor list when done. --- .../com/raizlabs/dbflow5/paging/Factory.kt | 33 +++++++++++-------- 1 file changed, 19 insertions(+), 14 deletions(-) diff --git a/dbflow-paging/src/main/kotlin/com/raizlabs/dbflow5/paging/Factory.kt b/dbflow-paging/src/main/kotlin/com/raizlabs/dbflow5/paging/Factory.kt index 574874ab7..e8c1d690c 100644 --- a/dbflow-paging/src/main/kotlin/com/raizlabs/dbflow5/paging/Factory.kt +++ b/dbflow-paging/src/main/kotlin/com/raizlabs/dbflow5/paging/Factory.kt @@ -14,27 +14,32 @@ internal constructor(private val modelQueriable: ModelQueriable, : PositionalDataSource() { override fun loadRange(params: LoadRangeParams, callback: LoadRangeCallback) { database.executeTransactionAsync({ modelQueriable.cursorList() }, - success = { _, cursorList -> - val list = mutableListOf() - val max = when { - params.loadSize >= cursorList.count - 1 -> cursorList.count.toInt() - else -> params.loadSize + success = { _, paramCursorList -> + paramCursorList.use { cursorList -> + val list = mutableListOf() + val max = when { + params.loadSize >= cursorList.count - 1 -> cursorList.count.toInt() + else -> params.loadSize + } + (params.startPosition until params.startPosition + max).mapTo(list) { cursorList[it] } + callback.onResult(list) + cursorList.close() } - (params.startPosition until params.startPosition + max).mapTo(list) { cursorList[it] } - callback.onResult(list) }) } override fun loadInitial(params: LoadInitialParams, callback: LoadInitialCallback) { database.executeTransactionAsync({ modelQueriable.cursorList() }, - success = { _, cursorList -> - val max = when { - params.requestedLoadSize >= cursorList.count - 1 -> cursorList.count.toInt() - else -> params.requestedLoadSize + success = { _, paramCursorList -> + paramCursorList.use { cursorList -> + val max = when { + params.requestedLoadSize >= cursorList.count - 1 -> cursorList.count.toInt() + else -> params.requestedLoadSize + } + val list = mutableListOf() + (params.requestedStartPosition until params.requestedStartPosition + max).mapTo(list) { cursorList[it] } + callback.onResult(list, params.requestedStartPosition, cursorList.count.toInt()) } - val list = mutableListOf() - (params.requestedStartPosition until params.requestedStartPosition + max).mapTo(list) { cursorList[it] } - callback.onResult(list, params.requestedStartPosition, cursorList.count.toInt()) }) } From 11d4175f3882ef72ef2097b4c99ee7562a5d0a37 Mon Sep 17 00:00:00 2001 From: fuzzagrosner Date: Mon, 11 Dec 2017 09:57:45 -0500 Subject: [PATCH 146/234] [paging] code cleanup. make test use uneven numbers to test proper paging. --- .../main/kotlin/com/raizlabs/dbflow5/paging/Factory.kt | 2 +- .../dbflow5/paging/ModelQueriableDataSourceTest.kt | 9 ++++++--- 2 files changed, 7 insertions(+), 4 deletions(-) diff --git a/dbflow-paging/src/main/kotlin/com/raizlabs/dbflow5/paging/Factory.kt b/dbflow-paging/src/main/kotlin/com/raizlabs/dbflow5/paging/Factory.kt index e8c1d690c..1d60f0e6d 100644 --- a/dbflow-paging/src/main/kotlin/com/raizlabs/dbflow5/paging/Factory.kt +++ b/dbflow-paging/src/main/kotlin/com/raizlabs/dbflow5/paging/Factory.kt @@ -16,11 +16,11 @@ internal constructor(private val modelQueriable: ModelQueriable, database.executeTransactionAsync({ modelQueriable.cursorList() }, success = { _, paramCursorList -> paramCursorList.use { cursorList -> - val list = mutableListOf() val max = when { params.loadSize >= cursorList.count - 1 -> cursorList.count.toInt() else -> params.loadSize } + val list = mutableListOf() (params.startPosition until params.startPosition + max).mapTo(list) { cursorList[it] } callback.onResult(list) cursorList.close() diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/paging/ModelQueriableDataSourceTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/paging/ModelQueriableDataSourceTest.kt index 66d9bd340..50248443f 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/paging/ModelQueriableDataSourceTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/paging/ModelQueriableDataSourceTest.kt @@ -8,6 +8,7 @@ import com.raizlabs.dbflow5.models.SimpleModel import com.raizlabs.dbflow5.query.select import com.raizlabs.dbflow5.structure.save import org.junit.Assert.assertEquals +import org.junit.Assert.assertTrue import org.junit.Test /** @@ -20,12 +21,11 @@ class ModelQueriableDataSourceTest : BaseUnitTest() { database { (0 until 100).forEach { SimpleModel("$it").save(this) } - val factory = (select from SimpleModel::class).toDataSourceFactory(this) val list = PagedList.Builder(factory.create(), PagedList.Config.Builder() - .setPageSize(5) - .setPrefetchDistance(10) + .setPageSize(3) + .setPrefetchDistance(6) .setEnablePlaceholders(true).build()) .setBackgroundThreadExecutor { it.run() } // run on main .setMainThreadExecutor { it.run() } @@ -36,6 +36,9 @@ class ModelQueriableDataSourceTest : BaseUnitTest() { list.forEachIndexed { index, simpleModel -> list.loadAround(index) assertEquals(index, simpleModel.name?.toInt()) + + // assert we don't run over somehow. + assertTrue(index < 100) } } } From a97de3241a3010ec6169e035f3367b59fa44df5f Mon Sep 17 00:00:00 2001 From: fuzzagrosner Date: Mon, 11 Dec 2017 12:40:56 -0500 Subject: [PATCH 147/234] [paging] add cloneability to sqlite queries so we can copy instance without modifying existing instance. make query datasource do proper count query of results. add from with ModelQueriableSupport. --- .../raizlabs/dbflow5/sql/QueryCloneable.kt | 9 ++ .../com/raizlabs/dbflow5/paging/Factory.kt | 61 ------------ .../dbflow5/paging/QueryDataSource.kt | 73 ++++++++++++++ .../com/raizlabs/dbflow5/DBFlowTestRule.kt | 2 + .../com/raizlabs/dbflow5/TestExtensions.kt | 4 +- .../raizlabs/dbflow5/models/ModelViewTest.kt | 5 +- ...taSourceTest.kt => QueryDataSourceTest.kt} | 17 +++- .../dbflow5/sql/language/OperatorGroupTest.kt | 17 ++-- .../dbflow5/sql/language/OperatorTest.kt | 43 ++++---- .../dbflow5/sql/language/OrderByTest.kt | 8 +- .../dbflow5/sql/language/SelectTest.kt | 6 +- .../raizlabs/dbflow5/sql/language/SetTest.kt | 6 +- .../dbflow5/sql/language/TriggerTest.kt | 30 +++--- .../sql/language/UnsafeStringOperatorTest.kt | 5 +- .../dbflow5/sql/language/UpdateTest.kt | 19 ++-- .../dbflow5/sql/language/WhereTest.kt | 99 +++++++++++-------- .../database/AndroidDatabaseStatement.kt | 5 +- .../raizlabs/dbflow5/query/BaseOperator.kt | 2 +- .../dbflow5/query/BaseTransformable.kt | 2 + .../dbflow5/query/ExistenceOperator.kt | 2 +- .../kotlin/com/raizlabs/dbflow5/query/From.kt | 23 ++++- .../com/raizlabs/dbflow5/query/IndexedBy.kt | 2 + .../raizlabs/dbflow5/query/ModelQueriable.kt | 3 + .../com/raizlabs/dbflow5/query/Select.kt | 9 +- .../kotlin/com/raizlabs/dbflow5/query/Set.kt | 10 ++ .../com/raizlabs/dbflow5/query/Update.kt | 14 +-- .../com/raizlabs/dbflow5/query/Where.kt | 13 ++- .../com/raizlabs/dbflow5/query/WhereBase.kt | 3 +- 28 files changed, 299 insertions(+), 193 deletions(-) create mode 100644 dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/sql/QueryCloneable.kt delete mode 100644 dbflow-paging/src/main/kotlin/com/raizlabs/dbflow5/paging/Factory.kt create mode 100644 dbflow-paging/src/main/kotlin/com/raizlabs/dbflow5/paging/QueryDataSource.kt rename dbflow-tests/src/test/java/com/raizlabs/dbflow5/paging/{ModelQueriableDataSourceTest.kt => QueryDataSourceTest.kt} (71%) diff --git a/dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/sql/QueryCloneable.kt b/dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/sql/QueryCloneable.kt new file mode 100644 index 000000000..6c53d9df9 --- /dev/null +++ b/dbflow-core/src/main/kotlin/com/raizlabs/dbflow5/sql/QueryCloneable.kt @@ -0,0 +1,9 @@ +package com.raizlabs.dbflow5.sql + +/** + * Description: + */ +interface QueryCloneable { + + fun cloneSelf(): T +} \ No newline at end of file diff --git a/dbflow-paging/src/main/kotlin/com/raizlabs/dbflow5/paging/Factory.kt b/dbflow-paging/src/main/kotlin/com/raizlabs/dbflow5/paging/Factory.kt deleted file mode 100644 index 1d60f0e6d..000000000 --- a/dbflow-paging/src/main/kotlin/com/raizlabs/dbflow5/paging/Factory.kt +++ /dev/null @@ -1,61 +0,0 @@ -package com.raizlabs.dbflow5.paging - -import android.arch.paging.DataSource -import android.arch.paging.PositionalDataSource -import com.raizlabs.dbflow5.config.DBFlowDatabase -import com.raizlabs.dbflow5.query.ModelQueriable - -/** - * Bridges the [ModelQueriable] into a [PositionalDataSource] that loads a [ModelQueriable]. - */ -class ModelQueriableDataSource -internal constructor(private val modelQueriable: ModelQueriable, - private val database: DBFlowDatabase) - : PositionalDataSource() { - override fun loadRange(params: LoadRangeParams, callback: LoadRangeCallback) { - database.executeTransactionAsync({ modelQueriable.cursorList() }, - success = { _, paramCursorList -> - paramCursorList.use { cursorList -> - val max = when { - params.loadSize >= cursorList.count - 1 -> cursorList.count.toInt() - else -> params.loadSize - } - val list = mutableListOf() - (params.startPosition until params.startPosition + max).mapTo(list) { cursorList[it] } - callback.onResult(list) - cursorList.close() - } - }) - } - - override fun loadInitial(params: LoadInitialParams, callback: LoadInitialCallback) { - database.executeTransactionAsync({ modelQueriable.cursorList() }, - success = { _, paramCursorList -> - paramCursorList.use { cursorList -> - val max = when { - params.requestedLoadSize >= cursorList.count - 1 -> cursorList.count.toInt() - else -> params.requestedLoadSize - } - val list = mutableListOf() - (params.requestedStartPosition until params.requestedStartPosition + max).mapTo(list) { cursorList[it] } - callback.onResult(list, params.requestedStartPosition, cursorList.count.toInt()) - } - }) - } - - class Factory - internal constructor(private val modelQueriable: ModelQueriable, - private val database: DBFlowDatabase) : DataSource.Factory { - override fun create(): DataSource = ModelQueriableDataSource(modelQueriable, database) - } - - companion object { - @JvmStatic - fun newFactory(modelQueriable: ModelQueriable, - database: DBFlowDatabase) = - Factory(modelQueriable, database) - } -} - -fun ModelQueriable.toDataSourceFactory(database: DBFlowDatabase) = - ModelQueriableDataSource.newFactory(this, database) \ No newline at end of file diff --git a/dbflow-paging/src/main/kotlin/com/raizlabs/dbflow5/paging/QueryDataSource.kt b/dbflow-paging/src/main/kotlin/com/raizlabs/dbflow5/paging/QueryDataSource.kt new file mode 100644 index 000000000..0b85c461b --- /dev/null +++ b/dbflow-paging/src/main/kotlin/com/raizlabs/dbflow5/paging/QueryDataSource.kt @@ -0,0 +1,73 @@ +package com.raizlabs.dbflow5.paging + +import android.arch.paging.DataSource +import android.arch.paging.PositionalDataSource +import com.raizlabs.dbflow5.config.DBFlowDatabase +import com.raizlabs.dbflow5.query.ModelQueriable +import com.raizlabs.dbflow5.query.Select +import com.raizlabs.dbflow5.query.Transformable +import com.raizlabs.dbflow5.query.WhereBase +import com.raizlabs.dbflow5.query.list +import com.raizlabs.dbflow5.query.selectCountOf +import com.raizlabs.dbflow5.sql.QueryCloneable + +/** + * Bridges the [ModelQueriable] into a [PositionalDataSource] that loads a [ModelQueriable]. + */ +class QueryDataSource +internal constructor(private val transformable: TQuery, + private val database: DBFlowDatabase) + : PositionalDataSource() where TQuery : Transformable, TQuery : ModelQueriable { + + init { + if (transformable is WhereBase<*> && transformable.queryBuilderBase !is Select) { + throw IllegalArgumentException("Cannot pass a non-SELECT query into this data source.") + } + } + + override fun loadRange(params: LoadRangeParams, callback: LoadRangeCallback) { + database.executeTransactionAsync({ getQueriableFromParams(params.startPosition, params.loadSize).list }, + success = { _, list -> callback.onResult(list) }) + } + + override fun loadInitial(params: LoadInitialParams, callback: LoadInitialCallback) { + database.executeTransactionAsync({ db -> db.selectCountOf().from(transformable).longValue() }, + success = { _, count -> + val max = when { + params.requestedLoadSize >= count - 1 -> count.toInt() + else -> params.requestedLoadSize + } + database.executeTransactionAsync({ getQueriableFromParams(params.requestedStartPosition, max).list }, + success = { _, list -> + callback.onResult(list, params.requestedStartPosition, count.toInt()) + }) + }) + } + + private fun getQueriableFromParams(startPosition: Int, max: Int): ModelQueriable { + var tr: Transformable = transformable + @Suppress("UNCHECKED_CAST") + if (tr is QueryCloneable<*>) { + tr = tr.cloneSelf() as Transformable + } + return tr.offset(startPosition).limit(max) + } + + class Factory + internal constructor(private val transformable: TQuery, + private val database: DBFlowDatabase) + : DataSource.Factory where TQuery : Transformable, TQuery : ModelQueriable { + override fun create(): DataSource = QueryDataSource(transformable, database) + } + + companion object { + @JvmStatic + fun newFactory(transformable: TQuery, database: DBFlowDatabase) + where TQuery : Transformable, TQuery : ModelQueriable = + Factory(transformable, database) + } +} + +fun TQuery.toDataSourceFactory(database: DBFlowDatabase) + where TQuery : Transformable, TQuery : ModelQueriable = + QueryDataSource.newFactory(this, database) \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/DBFlowTestRule.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/DBFlowTestRule.kt index a76526b96..78181d356 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/DBFlowTestRule.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/DBFlowTestRule.kt @@ -3,6 +3,7 @@ package com.raizlabs.dbflow5 import android.content.Context import com.raizlabs.dbflow5.config.DatabaseConfig import com.raizlabs.dbflow5.config.FlowConfig +import com.raizlabs.dbflow5.config.FlowLog import com.raizlabs.dbflow5.config.FlowManager import com.raizlabs.dbflow5.database.AndroidSQLiteOpenHelper import com.raizlabs.dbflow5.provider.ContentDatabase @@ -21,6 +22,7 @@ class DBFlowTestRule : TestRule { @Throws(Throwable::class) override fun evaluate() { + FlowLog.setMinimumLoggingLevel(FlowLog.Level.V) FlowManager.init(FlowConfig.Builder(RuntimeEnvironment.application) .database(DatabaseConfig.Builder(TestDatabase::class, AndroidSQLiteOpenHelper.createHelperCreator(context)) .transactionManagerCreator(::ImmediateTransactionManager2) diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/TestExtensions.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/TestExtensions.kt index d81f1b657..4171499de 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/TestExtensions.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/TestExtensions.kt @@ -6,7 +6,9 @@ import org.junit.Assert.fail import kotlin.reflect.KClass -fun assertEquals(string: String, query: Query) = assertEquals(string, query.query.trim()) +fun String.assertEquals(query: Query) = assertEquals(this, query.query.trim()) + +fun Query.assertEquals(actual: Query) = assertEquals(query.trim(), actual.query.trim()) fun assertThrowsException(expectedException: KClass, function: () -> Unit) { try { diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/ModelViewTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/ModelViewTest.kt index 81be0d3f7..c5150c225 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/ModelViewTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/models/ModelViewTest.kt @@ -11,12 +11,11 @@ class ModelViewTest : BaseUnitTest() { @Test fun validateModelViewQuery() = database(TestDatabase::class) { - assertEquals("SELECT `id` AS `authorId`,`first_name` || ' ' || `last_name` AS `authorName` FROM `Author`", - AuthorView.getQuery(this)) + "SELECT `id` AS `authorId`,`first_name` || ' ' || `last_name` AS `authorName` FROM `Author`".assertEquals(AuthorView.getQuery(this)) } @Test fun validateJavaModelViewQuery() = database(TestDatabase::class) { - assertEquals("SELECT `first_name` AS `firstName`,`id` AS `id`", JavaModelView.getQuery(this)) + "SELECT `first_name` AS `firstName`,`id` AS `id`".assertEquals(JavaModelView.getQuery(this)) } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/paging/ModelQueriableDataSourceTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/paging/QueryDataSourceTest.kt similarity index 71% rename from dbflow-tests/src/test/java/com/raizlabs/dbflow5/paging/ModelQueriableDataSourceTest.kt rename to dbflow-tests/src/test/java/com/raizlabs/dbflow5/paging/QueryDataSourceTest.kt index 50248443f..f9cdb93d8 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/paging/ModelQueriableDataSourceTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/paging/QueryDataSourceTest.kt @@ -3,9 +3,13 @@ package com.raizlabs.dbflow5.paging import android.arch.paging.PagedList import com.raizlabs.dbflow5.BaseUnitTest import com.raizlabs.dbflow5.TestDatabase +import com.raizlabs.dbflow5.assertThrowsException import com.raizlabs.dbflow5.config.database import com.raizlabs.dbflow5.models.SimpleModel +import com.raizlabs.dbflow5.models.SimpleModel_Table import com.raizlabs.dbflow5.query.select +import com.raizlabs.dbflow5.query.set +import com.raizlabs.dbflow5.query.update import com.raizlabs.dbflow5.structure.save import org.junit.Assert.assertEquals import org.junit.Assert.assertTrue @@ -14,7 +18,7 @@ import org.junit.Test /** * Description: */ -class ModelQueriableDataSourceTest : BaseUnitTest() { +class QueryDataSourceTest : BaseUnitTest() { @Test fun testLoadInitialParams() { @@ -42,4 +46,15 @@ class ModelQueriableDataSourceTest : BaseUnitTest() { } } } + + @Test + fun testThrowsErrorOnInvalidType() { + database { + assertThrowsException(IllegalArgumentException::class) { + (update() set (SimpleModel_Table.name.eq("name"))) + .toDataSourceFactory(this) + .create() + } + } + } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/OperatorGroupTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/OperatorGroupTest.kt index da2eeb133..43cfed123 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/OperatorGroupTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/OperatorGroupTest.kt @@ -16,38 +16,33 @@ class OperatorGroupTest : BaseUnitTest() { @Test fun validateCommaSeparated() { - assertEquals("(`name`='name', `id`=0)", - OperatorGroup.clause().setAllCommaSeparated(true).andAll(name.eq("name"), id.eq(0))) + "(`name`='name', `id`=0)".assertEquals(OperatorGroup.clause().setAllCommaSeparated(true).andAll(name.eq("name"), id.eq(0))) } @Test fun validateParanthesis() { - assertEquals("`name`='name'", - OperatorGroup.nonGroupingClause(name.eq("name")).setUseParenthesis(false)) + "`name`='name'".assertEquals(OperatorGroup.nonGroupingClause(name.eq("name")).setUseParenthesis(false)) } @Test fun validateOr() { - assertEquals("(`name`='name' OR `id`=0)", - name.eq("name") or id.eq(0)) + "(`name`='name' OR `id`=0)".assertEquals(name.eq("name") or id.eq(0)) } @Test fun validateOrAll() { - assertEquals("(`name`='name' OR `id`=0 OR `name`='test')", - name.eq("name") orAll arrayListOf(id.eq(0), name.eq("test"))) + "(`name`='name' OR `id`=0 OR `name`='test')".assertEquals(name.eq("name") orAll arrayListOf(id.eq(0), name.eq("test"))) } @Test fun validateAnd() { - assertEquals("(`name`='name' AND `id`=0)", name.eq("name") and id.eq(0)) + "(`name`='name' AND `id`=0)".assertEquals(name.eq("name") and id.eq(0)) } @Test fun validateAndAll() { - assertEquals("(`name`='name' AND `id`=0 AND `name`='test')", - name.eq("name") andAll arrayListOf(id.eq(0), name.eq("test"))) + "(`name`='name' AND `id`=0 AND `name`='test')".assertEquals(name.eq("name") andAll arrayListOf(id.eq(0), name.eq("test"))) } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/OperatorTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/OperatorTest.kt index 9f7ec6203..c3248a397 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/OperatorTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/OperatorTest.kt @@ -14,53 +14,52 @@ class OperatorTest : BaseUnitTest() { @Test fun testEquals() { - assertEquals("`name`='name'", "name".op().eq("name")) - assertEquals("`name`='name'", "name".op().`is`("name")) + "`name`='name'".assertEquals("name".op().eq("name")) + "`name`='name'".assertEquals("name".op().`is`("name")) } @Test fun testNotEquals() { - assertEquals("`name`!='name'", "name".op().notEq("name")) - assertEquals("`name`!='name'", "name".op().isNot("name")) + "`name`!='name'".assertEquals("name".op().notEq("name")) + "`name`!='name'".assertEquals("name".op().isNot("name")) } @Test fun testLike() { - assertEquals("`name` LIKE 'name'", "name".op().like("name")) - assertEquals("`name` NOT LIKE 'name'", "name".op().notLike("name")) - assertEquals("`name` GLOB 'name'", "name".op().glob("name")) + "`name` LIKE 'name'".assertEquals("name".op().like("name")) + "`name` NOT LIKE 'name'".assertEquals("name".op().notLike("name")) + "`name` GLOB 'name'".assertEquals("name".op().glob("name")) } @Test fun testMath() { - assertEquals("`name`>'name'", "name".op().greaterThan("name")) - assertEquals("`name`>='name'", "name".op().greaterThanOrEq("name")) - assertEquals("`name`<'name'", "name".op().lessThan("name")) - assertEquals("`name`<='name'", "name".op().lessThanOrEq("name")) - assertEquals("`name`+'name'", "name".op() + "name") - assertEquals("`name`-'name'", "name".op() - "name") - assertEquals("`name`/'name'", "name".op() / "name") - assertEquals("`name`*'name'", "name".op() * "name") - assertEquals("`name`%'name'", "name".op() % "name") + "`name`>'name'".assertEquals("name".op().greaterThan("name")) + "`name`>='name'".assertEquals("name".op().greaterThanOrEq("name")) + "`name`<'name'".assertEquals("name".op().lessThan("name")) + "`name`<='name'".assertEquals("name".op().lessThanOrEq("name")) + "`name`+'name'".assertEquals("name".op() + "name") + "`name`-'name'".assertEquals("name".op() - "name") + "`name`/'name'".assertEquals("name".op() / "name") + "`name`*'name'".assertEquals("name".op() * "name") + "`name`%'name'".assertEquals("name".op() % "name") } @Test fun testCollate() { - assertEquals("`name` COLLATE NOCASE", "name".op() collate Collate.NOCASE) - assertEquals("`name` COLLATE NOCASE", "name".op() collate "NOCASE") + "`name` COLLATE NOCASE".assertEquals("name".op() collate Collate.NOCASE) + "`name` COLLATE NOCASE".assertEquals("name".op() collate "NOCASE") } @Test fun testBetween() { - assertEquals("`id` BETWEEN 6 AND 7", id.between(6) and 7) + "`id` BETWEEN 6 AND 7".assertEquals(id.between(6) and 7) } @Test fun testIn() { databaseForTable { - assertEquals("`id` IN (5,6,7,8,9)", id.`in`(5, 6, 7, 8) and 9) - assertEquals("`id` NOT IN (SELECT * FROM `SimpleModel`)", - id.notIn(select from SimpleModel::class)) + "`id` IN (5,6,7,8,9)".assertEquals(id.`in`(5, 6, 7, 8) and 9) + "`id` NOT IN (SELECT * FROM `SimpleModel`)".assertEquals(id.notIn(select from SimpleModel::class)) } } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/OrderByTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/OrderByTest.kt index b4fb4910c..8fb7eef24 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/OrderByTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/OrderByTest.kt @@ -14,21 +14,21 @@ class OrderByTest : BaseUnitTest() { @Test fun validateBasicOrderBy() { - assertEquals("`name` ASC", OrderBy.fromProperty(name).ascending()) + "`name` ASC".assertEquals(OrderBy.fromProperty(name).ascending()) } @Test fun validateDescendingOrderBy() { - assertEquals("`name` DESC", OrderBy.fromNameAlias("name".nameAlias).descending()) + "`name` DESC".assertEquals(OrderBy.fromNameAlias("name".nameAlias).descending()) } @Test fun validateCollate() { - assertEquals("`name` COLLATE RTRIM ASC", OrderBy.fromProperty(name).ascending() collate Collate.RTRIM) + "`name` COLLATE RTRIM ASC".assertEquals(OrderBy.fromProperty(name).ascending() collate Collate.RTRIM) } @Test fun validateCustomOrdrBy() { - assertEquals("`name` ASC This is custom", OrderBy.fromString("`name` ASC This is custom")) + "`name` ASC This is custom".assertEquals(OrderBy.fromString("`name` ASC This is custom")) } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/SelectTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/SelectTest.kt index 03e239e34..c748fc61f 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/SelectTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/SelectTest.kt @@ -15,16 +15,14 @@ class SelectTest : BaseUnitTest() { @Test fun validateSelect() { databaseForTable { - assertEquals("SELECT `name`,`id` FROM `TwoColumnModel`", - select(name, id) from TwoColumnModel::class) + "SELECT `name`,`id` FROM `TwoColumnModel`".assertEquals(select(name, id) from TwoColumnModel::class) } } @Test fun validateSelectDistinct() { databaseForTable { - assertEquals("SELECT DISTINCT `name` FROM `SimpleModel`", - select(name).distinct() from SimpleModel::class) + "SELECT DISTINCT `name` FROM `SimpleModel`".assertEquals(select(name).distinct() from SimpleModel::class) } } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/SetTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/SetTest.kt index ab7ac1473..182a6a105 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/SetTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/SetTest.kt @@ -15,16 +15,14 @@ class SetTest : BaseUnitTest() { @Test fun validateSetWithConditions() { databaseForTable { - assertEquals("UPDATE `SimpleModel` SET `name`='name'", - update() set name.`is`("name")) + "UPDATE `SimpleModel` SET `name`='name'".assertEquals(update() set name.`is`("name")) } } @Test fun validateMultipleConditions() { databaseForTable { - assertEquals("UPDATE `SimpleModel` SET `name`='name', `id`=0", - update() set name.eq("name") and id.eq(0)) + "UPDATE `SimpleModel` SET `name`='name', `id`=0".assertEquals(update() set name.eq("name") and id.eq(0)) } } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/TriggerTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/TriggerTest.kt index 4e90820ad..f671115b8 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/TriggerTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/TriggerTest.kt @@ -26,28 +26,26 @@ class TriggerTest : BaseUnitTest() { @Test fun validateBasicTrigger() { databaseForTable { - assertEquals("CREATE TRIGGER IF NOT EXISTS `MyTrigger` AFTER INSERT ON `SimpleModel` " + - "\nBEGIN" + - "\nINSERT INTO `TwoColumnModel`(`name`) VALUES(`new`.`name`);" + - "\nEND", - createTrigger("MyTrigger").after() insertOn SimpleModel::class begin - insert(TwoColumnModel::class).columnValues(name to NameAlias.ofTable("new", "name"))) + ("CREATE TRIGGER IF NOT EXISTS `MyTrigger` AFTER INSERT ON `SimpleModel` " + + "\nBEGIN" + + "\nINSERT INTO `TwoColumnModel`(`name`) VALUES(`new`.`name`);" + + "\nEND").assertEquals(createTrigger("MyTrigger").after() insertOn SimpleModel::class begin + insert(TwoColumnModel::class).columnValues(name to NameAlias.ofTable("new", "name"))) } } @Test fun validateUpdateTriggerMultiline() { databaseForTable { - assertEquals("CREATE TEMP TRIGGER IF NOT EXISTS `MyTrigger` BEFORE UPDATE ON `SimpleModel` " + - "\nBEGIN" + - "\nINSERT INTO `TwoColumnModel`(`name`) VALUES(`new`.`name`);" + - "\nINSERT INTO `TwoColumnModel`(`id`) VALUES(CAST(`new`.`name` AS INTEGER));" + - "\nEND", - createTrigger("MyTrigger").temporary().before() updateOn SimpleModel::class begin - insert(TwoColumnModel::class).columnValues(name to NameAlias.ofTable("new", "name")) and - insert(TwoColumnModel::class) - .columnValues(id to cast(NameAlias.ofTable("new", "name").property) - .`as`(SQLiteType.INTEGER))) + ("CREATE TEMP TRIGGER IF NOT EXISTS `MyTrigger` BEFORE UPDATE ON `SimpleModel` " + + "\nBEGIN" + + "\nINSERT INTO `TwoColumnModel`(`name`) VALUES(`new`.`name`);" + + "\nINSERT INTO `TwoColumnModel`(`id`) VALUES(CAST(`new`.`name` AS INTEGER));" + + "\nEND").assertEquals(createTrigger("MyTrigger").temporary().before() updateOn SimpleModel::class begin + insert(TwoColumnModel::class).columnValues(name to NameAlias.ofTable("new", "name")) and + insert(TwoColumnModel::class) + .columnValues(id to cast(NameAlias.ofTable("new", "name").property) + .`as`(SQLiteType.INTEGER))) } } diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/UnsafeStringOperatorTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/UnsafeStringOperatorTest.kt index e37b0b22e..c7d233120 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/UnsafeStringOperatorTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/UnsafeStringOperatorTest.kt @@ -14,9 +14,8 @@ class UnsafeStringOperatorTest : BaseUnitTest() { fun testCanIncludeInQuery() { databaseForTable { val op = UnSafeStringOperator("name = ?, id = ?, test = ?", arrayOf("'name'", "0", "'test'")) - assertEquals("name = 'name', id = 0, test = 'test'", op) - assertEquals("SELECT * FROM `SimpleModel` WHERE name = 'name', id = 0, test = 'test'", - select from SimpleModel::class where op) + "name = 'name', id = 0, test = 'test'".assertEquals(op) + "SELECT * FROM `SimpleModel` WHERE name = 'name', id = 0, test = 'test'".assertEquals(select from SimpleModel::class where op) } } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/UpdateTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/UpdateTest.kt index 03a12eedd..2724e0e3b 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/UpdateTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/UpdateTest.kt @@ -18,52 +18,51 @@ class UpdateTest : BaseUnitTest() { @Test fun validateUpdateRollback() { databaseForTable { - assertEquals("UPDATE OR ROLLBACK `SimpleModel`", update().orRollback()) + "UPDATE OR ROLLBACK `SimpleModel`".assertEquals(update().orRollback()) } } @Test fun validateUpdateFail() { databaseForTable { - assertEquals("UPDATE OR FAIL `SimpleModel`", update().orFail()) + "UPDATE OR FAIL `SimpleModel`".assertEquals(update().orFail()) } } @Test fun validateUpdateIgnore() { databaseForTable { - assertEquals("UPDATE OR IGNORE `SimpleModel`", update().orIgnore()) + "UPDATE OR IGNORE `SimpleModel`".assertEquals(update().orIgnore()) } } @Test fun validateUpdateReplace() { databaseForTable { - assertEquals("UPDATE OR REPLACE `SimpleModel`", update().orReplace()) + "UPDATE OR REPLACE `SimpleModel`".assertEquals(update().orReplace()) } } @Test fun validateUpdateAbort() { databaseForTable { - assertEquals("UPDATE OR ABORT `SimpleModel`", update().orAbort()) + "UPDATE OR ABORT `SimpleModel`".assertEquals(update().orAbort()) } } @Test fun validateSetQuery() { databaseForTable { - assertEquals("UPDATE `SimpleModel` SET `name`='name'", update() set (name eq "name")) + "UPDATE `SimpleModel` SET `name`='name'".assertEquals(update() set (name eq "name")) } } @Test fun validateWildcardQuery() { databaseForTable { - assertEquals("UPDATE OR FAIL `NumberModel` SET `id`=? WHERE `id`=?", - update().or(ConflictAction.FAIL) - .set(id.eq(Property.WILDCARD)) - .where(id.eq(Property.WILDCARD))) + "UPDATE OR FAIL `NumberModel` SET `id`=? WHERE `id`=?".assertEquals(update().or(ConflictAction.FAIL) + .set(id.eq(Property.WILDCARD)) + .where(id.eq(Property.WILDCARD))) } } } \ No newline at end of file diff --git a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/WhereTest.kt b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/WhereTest.kt index 829753466..f987c406f 100644 --- a/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/WhereTest.kt +++ b/dbflow-tests/src/test/java/com/raizlabs/dbflow5/sql/language/WhereTest.kt @@ -8,6 +8,7 @@ import com.raizlabs.dbflow5.models.SimpleModel_Table.name import com.raizlabs.dbflow5.models.TwoColumnModel import com.raizlabs.dbflow5.models.TwoColumnModel_Table.id import com.raizlabs.dbflow5.query.OrderBy.Companion.fromNameAlias +import com.raizlabs.dbflow5.query.Where import com.raizlabs.dbflow5.query.groupBy import com.raizlabs.dbflow5.query.having import com.raizlabs.dbflow5.query.list @@ -16,6 +17,7 @@ import com.raizlabs.dbflow5.query.or import com.raizlabs.dbflow5.query.result import com.raizlabs.dbflow5.query.select import com.raizlabs.dbflow5.query.update +import org.junit.Assert.assertTrue import org.junit.Assert.fail import org.junit.Test @@ -24,117 +26,136 @@ class WhereTest : BaseUnitTest() { @Test fun validateBasicWhere() { databaseForTable { - assertEquals("SELECT * FROM `SimpleModel` WHERE `name`='name'", - select from SimpleModel::class where name.`is`("name")) + val query = select from SimpleModel::class where name.`is`("name") + "SELECT * FROM `SimpleModel` WHERE `name`='name'".assertEquals(query) + assertCanCopyQuery(query) } } @Test fun validateComplexQueryWhere() { databaseForTable { - assertEquals("SELECT * FROM `SimpleModel` WHERE `name`='name' OR `id`=1 AND (`id`=0 OR `name`='hi')", - select from SimpleModel::class where name.`is`("name") or id.eq(1) and (id.`is`(0) or name.eq("hi"))) + val query = select from SimpleModel::class where name.`is`("name") or id.eq(1) and (id.`is`(0) or name.eq("hi")) + "SELECT * FROM `SimpleModel` WHERE `name`='name' OR `id`=1 AND (`id`=0 OR `name`='hi')".assertEquals(query) + assertCanCopyQuery(query) } } @Test fun validateGroupBy() { databaseForTable { - assertEquals("SELECT * FROM `SimpleModel` WHERE `name`='name' GROUP BY `name`", - select from SimpleModel::class where name.`is`("name") groupBy name) + val query = select from SimpleModel::class where name.`is`("name") groupBy name + "SELECT * FROM `SimpleModel` WHERE `name`='name' GROUP BY `name`".assertEquals(query) + assertCanCopyQuery(query) + } } @Test fun validateGroupByNameAlias() { databaseForTable { - assertEquals("SELECT * FROM `SimpleModel` WHERE `name`='name' GROUP BY `name`,`id`", - (select from SimpleModel::class where name.`is`("name")).groupBy("name".nameAlias, "id".nameAlias)) + val query = (select from SimpleModel::class where name.`is`("name")).groupBy("name".nameAlias, "id".nameAlias) + "SELECT * FROM `SimpleModel` WHERE `name`='name' GROUP BY `name`,`id`".assertEquals(query) + assertCanCopyQuery(query) } } @Test fun validateGroupByNameProps() { databaseForTable { - assertEquals("SELECT * FROM `SimpleModel` WHERE `name`='name' GROUP BY `name`,`id`", - (select from SimpleModel::class where name.`is`("name")).groupBy(name, id)) + val query = (select from SimpleModel::class where name.`is`("name")).groupBy(name, id) + "SELECT * FROM `SimpleModel` WHERE `name`='name' GROUP BY `name`,`id`".assertEquals(query) + assertCanCopyQuery(query) } } @Test fun validateHaving() { databaseForTable { - assertEquals("SELECT * FROM `SimpleModel` WHERE `name`='name' HAVING `name` LIKE 'That'", - select from SimpleModel::class where name.`is`("name") having name.like("That")) + val query = select from SimpleModel::class where name.`is`("name") having name.like("That") + "SELECT * FROM `SimpleModel` WHERE `name`='name' HAVING `name` LIKE 'That'".assertEquals(query) + assertCanCopyQuery(query) } } @Test fun validateLimit() { databaseForTable { - assertEquals("SELECT * FROM `SimpleModel` WHERE `name`='name' LIMIT 10", - select from SimpleModel::class where name.`is`("name") limit 10) + val query = select from SimpleModel::class where name.`is`("name") limit 10 + "SELECT * FROM `SimpleModel` WHERE `name`='name' LIMIT 10".assertEquals(query) + assertCanCopyQuery(query) } } @Test fun validateOffset() { databaseForTable { - assertEquals("SELECT * FROM `SimpleModel` WHERE `name`='name' OFFSET 10", - select from SimpleModel::class where name.`is`("name") offset 10) + val query = select from SimpleModel::class where name.`is`("name") offset 10 + "SELECT * FROM `SimpleModel` WHERE `name`='name' OFFSET 10".assertEquals(query) + assertCanCopyQuery(query) } } @Test fun validateWhereExists() { databaseForTable { - assertEquals("SELECT * FROM `SimpleModel` " + - "WHERE EXISTS (SELECT `name` FROM `SimpleModel` WHERE `name` LIKE 'Andrew')", - select from SimpleModel::class - whereExists (select(name) from SimpleModel::class where name.like("Andrew"))) + val query = (select from SimpleModel::class + whereExists (select(name) from SimpleModel::class where name.like("Andrew"))) + ("SELECT * FROM `SimpleModel` " + + "WHERE EXISTS (SELECT `name` FROM `SimpleModel` WHERE `name` LIKE 'Andrew')").assertEquals(query) + assertCanCopyQuery(query) } } @Test fun validateOrderByWhere() { databaseForTable { - assertEquals("SELECT * FROM `SimpleModel` " + - "WHERE `name`='name' ORDER BY `name` ASC", - (select from SimpleModel::class - where name.eq("name")).orderBy(name, true)) + val query = (select from SimpleModel::class + where name.eq("name")).orderBy(name, true) + ("SELECT * FROM `SimpleModel` WHERE `name`='name' ORDER BY `name` ASC").assertEquals(query) + assertCanCopyQuery(query) } } @Test fun validateOrderByWhereAlias() { databaseForTable { - assertEquals("SELECT * FROM `SimpleModel` " + - "WHERE `name`='name' ORDER BY `name` ASC", - (select from SimpleModel::class - where name.eq("name")).orderBy("name".nameAlias, true)) + val query = (select from SimpleModel::class + where name.eq("name")).orderBy("name".nameAlias, true) + ("SELECT * FROM `SimpleModel` " + + "WHERE `name`='name' ORDER BY `name` ASC").assertEquals(query) + assertCanCopyQuery(query) } } @Test fun validateOrderBy() { databaseForTable { - assertEquals("SELECT * FROM `SimpleModel` " + - "WHERE `name`='name' ORDER BY `name` ASC", - select from SimpleModel::class - where name.eq("name") orderBy fromNameAlias("name".nameAlias).ascending()) + val query = (select from SimpleModel::class + where name.eq("name") orderBy fromNameAlias("name".nameAlias).ascending()) + ("SELECT * FROM `SimpleModel` " + + "WHERE `name`='name' ORDER BY `name` ASC").assertEquals(query) + assertCanCopyQuery(query) } } + private fun assertCanCopyQuery(query: Where) { + val actual = query.cloneSelf() + query.assertEquals(actual) + assertTrue(actual !== query) + } + @Test fun validateOrderByAll() { databaseForTable { - assertEquals("SELECT * FROM `TwoColumnModel` " + - "WHERE `name`='name' ORDER BY `name` ASC,`id` DESC", - (select from TwoColumnModel::class - where name.eq("name")) - .orderByAll(listOf( - fromNameAlias("name".nameAlias).ascending(), - fromNameAlias("id".nameAlias).descending()))) + val query = (select from TwoColumnModel::class + where name.eq("name")) + .orderByAll(listOf( + fromNameAlias("name".nameAlias).ascending(), + fromNameAlias("id".nameAlias).descending())) + ("SELECT * FROM `TwoColumnModel` " + + "WHERE `name`='name' ORDER BY `name` ASC,`id` DESC").assertEquals(query) + assertCanCopyQuery(query) } } diff --git a/dbflow/src/main/kotlin/com/raizlabs/dbflow5/database/AndroidDatabaseStatement.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/database/AndroidDatabaseStatement.kt index 5bd8e647c..f5f1d0e4b 100644 --- a/dbflow/src/main/kotlin/com/raizlabs/dbflow5/database/AndroidDatabaseStatement.kt +++ b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/database/AndroidDatabaseStatement.kt @@ -45,7 +45,10 @@ internal constructor(val statement: SQLiteStatement, statement.close() } - override fun simpleQueryForLong(): Long = rethrowDBFlowException { statement.simpleQueryForLong() } + override fun simpleQueryForLong(): Long = rethrowDBFlowException { + val simpleQueryForLong = statement.simpleQueryForLong() + simpleQueryForLong + } override fun simpleQueryForString(): String? = rethrowDBFlowException { statement.simpleQueryForString() } diff --git a/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/BaseOperator.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/BaseOperator.kt index 63ba361be..5224e3257 100644 --- a/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/BaseOperator.kt +++ b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/BaseOperator.kt @@ -141,7 +141,7 @@ abstract class BaseOperator internal constructor( stringVal = sqlEscapeString(_value.name) } else { if (appendInnerQueryParenthesis && _value is BaseModelQueriable<*>) { - stringVal = String.format("(%1s)", _value.query.trim { it <= ' ' }) + stringVal = _value.enclosedQuery } else if (_value is NameAlias) { stringVal = _value.query } else if (_value is SQLOperator) { diff --git a/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/BaseTransformable.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/BaseTransformable.kt index 97672e7bc..de16311d4 100644 --- a/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/BaseTransformable.kt +++ b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/BaseTransformable.kt @@ -47,6 +47,8 @@ protected constructor(databaseWrapper: DatabaseWrapper, override fun having(vararg conditions: SQLOperator): Where = where().having(*conditions) + abstract override fun cloneSelf(): BaseTransformable + override fun queryList(): MutableList { checkSelect("query") return super.queryList() diff --git a/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/ExistenceOperator.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/ExistenceOperator.kt index ecf6f39b3..8bf229a4a 100644 --- a/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/ExistenceOperator.kt +++ b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/ExistenceOperator.kt @@ -12,7 +12,7 @@ class ExistenceOperator(private val innerWhere: Where<*>) : SQLOperator, Query { get() = appendToQuery() override fun appendConditionToQuery(queryBuilder: StringBuilder) { - queryBuilder.appendQualifier("EXISTS", "(" + innerWhere.query.trim({ it <= ' ' }) + ")") + queryBuilder.appendQualifier("EXISTS", innerWhere.enclosedQuery) } override fun columnName(): String { diff --git a/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/From.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/From.kt index 800ce7543..a0b1ee044 100644 --- a/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/From.kt +++ b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/From.kt @@ -24,7 +24,13 @@ internal constructor( /** * @return The base query, usually a [Delete], [Select], or [Update] */ - override val queryBuilderBase: Query, table: Class) + override val queryBuilderBase: Query, + table: Class, + + /** + * If specified, we use this as the subquery for the FROM statement. + */ + private val modelQueriable: ModelQueriable? = null) : BaseTransformable(databaseWrapper, table) { /** @@ -48,7 +54,8 @@ internal constructor( queryBuilder.append("FROM ") } - queryBuilder.append(getTableAlias()) + modelQueriable?.let { queryBuilder.append(it.enclosedQuery) } + ?: queryBuilder.append(getTableAlias()) if (queryBuilderBase is Select) { if (!joins.isEmpty()) { @@ -62,6 +69,18 @@ internal constructor( return queryBuilder.toString() } + override fun cloneSelf(): From { + val from = From(databaseWrapper, + when (queryBuilderBase) { + is Select -> queryBuilderBase.cloneSelf() + else -> queryBuilderBase + }, + table) + from.joins.addAll(joins) + from.tableAlias = tableAlias + return from + } + /** * @return A list of [Class] that represents tables represented in this query. For every * [Join] on another table, this adds another [Class]. diff --git a/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/IndexedBy.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/IndexedBy.kt index 5839a1d04..d19886ab2 100644 --- a/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/IndexedBy.kt +++ b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/IndexedBy.kt @@ -32,4 +32,6 @@ class IndexedBy override val primaryAction: ChangeAction get() = whereBase.primaryAction + + override fun cloneSelf(): IndexedBy = IndexedBy(indexProperty, whereBase.cloneSelf()) } diff --git a/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/ModelQueriable.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/ModelQueriable.kt index 041a252a0..82cb396e8 100644 --- a/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/ModelQueriable.kt +++ b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/ModelQueriable.kt @@ -63,6 +63,9 @@ interface ModelQueriable : Queriable { } +internal inline val ModelQueriable.enclosedQuery + get() = "(${query.trim({ it <= ' ' })})" + inline val ModelQueriable.list get() = queryList() diff --git a/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/Select.kt b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/Select.kt index f7d51d223..bff3961f9 100644 --- a/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/Select.kt +++ b/dbflow/src/main/kotlin/com/raizlabs/dbflow5/query/Select.kt @@ -4,6 +4,7 @@ import com.raizlabs.dbflow5.database.DatabaseWrapper import com.raizlabs.dbflow5.query.property.IProperty import com.raizlabs.dbflow5.query.property.Property import com.raizlabs.dbflow5.sql.Query +import com.raizlabs.dbflow5.sql.QueryCloneable import kotlin.reflect.KClass /** @@ -16,7 +17,7 @@ class Select * @param properties The properties to select from. */ internal constructor(private val databaseWrapper: DatabaseWrapper, - vararg properties: IProperty<*>) : Query { + vararg properties: IProperty<*>) : Query, QueryCloneable { +internal constructor(vararg properties: IProperty<*>) : Query, QueryCloneable

() != null nonModelColumn = !isReferencingTableObject @@ -187,7 +186,7 @@ class ReferenceColumnDefinition(manager: ProcessorManager, tableDefinition: Base var propParam: TypeName? = null val colClassName = it.columnClassName colClassName?.let { - propParam = ParameterizedTypeName.get(ClassNames.PROPERTY, it.box()) + propParam = ParameterizedTypeName.get(com.dbflow5.processor.ClassNames.PROPERTY, it.box()) } if (it.columnName.isNullOrEmpty()) { manager.logError("Found empty reference name at ${it.foreignColumnName}" + diff --git a/processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/column/ReferenceDefinition.kt b/processor/src/main/kotlin/com/dbflow5/processor/definition/column/ReferenceDefinition.kt similarity index 93% rename from processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/column/ReferenceDefinition.kt rename to processor/src/main/kotlin/com/dbflow5/processor/definition/column/ReferenceDefinition.kt index 316a6ffa6..49bc74e42 100644 --- a/processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/column/ReferenceDefinition.kt +++ b/processor/src/main/kotlin/com/dbflow5/processor/definition/column/ReferenceDefinition.kt @@ -1,13 +1,12 @@ -package com.raizlabs.dbflow5.processor.definition.column - -import com.raizlabs.dbflow5.annotation.ConflictAction -import com.raizlabs.dbflow5.data.Blob -import com.raizlabs.dbflow5.processor.ClassNames -import com.raizlabs.dbflow5.processor.ProcessorManager -import com.raizlabs.dbflow5.processor.definition.TypeConverterDefinition -import com.raizlabs.dbflow5.processor.utils.ElementUtility -import com.raizlabs.dbflow5.processor.utils.isNullOrEmpty -import com.raizlabs.dbflow5.quote +package com.dbflow5.processor.definition.column + +import com.dbflow5.annotation.ConflictAction +import com.dbflow5.data.Blob +import com.dbflow5.processor.ProcessorManager +import com.dbflow5.processor.definition.TypeConverterDefinition +import com.dbflow5.processor.utils.ElementUtility +import com.dbflow5.processor.utils.isNullOrEmpty +import com.dbflow5.quote import com.squareup.javapoet.ClassName import com.squareup.javapoet.CodeBlock import com.squareup.javapoet.TypeName @@ -108,7 +107,7 @@ class ReferenceDefinition(private val manager: ProcessorManager, private fun handleSpecifiedTypeConverter(typeConverterClassName: ClassName?, typeMirror: TypeMirror?) { if (typeConverterClassName != null && typeMirror != null && - typeConverterClassName != ClassNames.TYPE_CONVERTER) { + typeConverterClassName != com.dbflow5.processor.ClassNames.TYPE_CONVERTER) { evaluateTypeConverter(TypeConverterDefinition(typeConverterClassName, typeMirror, manager), true) } } diff --git a/processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/provider/ContentProvider.kt b/processor/src/main/kotlin/com/dbflow5/processor/definition/provider/ContentProvider.kt similarity index 84% rename from processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/provider/ContentProvider.kt rename to processor/src/main/kotlin/com/dbflow5/processor/definition/provider/ContentProvider.kt index 17f910b10..e8bfaed69 100644 --- a/processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/provider/ContentProvider.kt +++ b/processor/src/main/kotlin/com/dbflow5/processor/definition/provider/ContentProvider.kt @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5.processor.definition.provider +package com.dbflow5.processor.definition.provider import com.grosner.kpoet.L import com.grosner.kpoet.`=` @@ -14,21 +14,20 @@ import com.grosner.kpoet.param import com.grosner.kpoet.parameterized import com.grosner.kpoet.public import com.grosner.kpoet.statement -import com.raizlabs.dbflow5.annotation.provider.ContentProvider -import com.raizlabs.dbflow5.annotation.provider.ContentUri -import com.raizlabs.dbflow5.annotation.provider.NotifyMethod -import com.raizlabs.dbflow5.annotation.provider.PathSegment -import com.raizlabs.dbflow5.annotation.provider.TableEndpoint -import com.raizlabs.dbflow5.processor.ClassNames -import com.raizlabs.dbflow5.processor.ProcessorManager -import com.raizlabs.dbflow5.processor.TableEndpointValidator -import com.raizlabs.dbflow5.processor.definition.BaseDefinition -import com.raizlabs.dbflow5.processor.definition.CodeAdder -import com.raizlabs.dbflow5.processor.definition.MethodDefinition -import com.raizlabs.dbflow5.processor.utils.`override fun` -import com.raizlabs.dbflow5.processor.utils.annotation -import com.raizlabs.dbflow5.processor.utils.controlFlow -import com.raizlabs.dbflow5.processor.utils.isNullOrEmpty +import com.dbflow5.annotation.provider.ContentProvider +import com.dbflow5.annotation.provider.ContentUri +import com.dbflow5.annotation.provider.NotifyMethod +import com.dbflow5.annotation.provider.PathSegment +import com.dbflow5.annotation.provider.TableEndpoint +import com.dbflow5.processor.ProcessorManager +import com.dbflow5.processor.TableEndpointValidator +import com.dbflow5.processor.definition.BaseDefinition +import com.dbflow5.processor.definition.CodeAdder +import com.dbflow5.processor.definition.MethodDefinition +import com.dbflow5.processor.utils.`override fun` +import com.dbflow5.processor.utils.annotation +import com.dbflow5.processor.utils.controlFlow +import com.dbflow5.processor.utils.isNullOrEmpty import com.squareup.javapoet.ArrayTypeName import com.squareup.javapoet.ClassName import com.squareup.javapoet.CodeBlock @@ -74,9 +73,9 @@ internal fun ContentUriDefinition.getSelectionAndSelectionArgs(): CodeBlock { if (segments.isEmpty()) { return CodeBlock.builder().add("selection, selectionArgs").build() } else { - val selectionBuilder = CodeBlock.builder().add("\$T.concatenateWhere(selection, \"", ClassNames.DATABASE_UTILS) + val selectionBuilder = CodeBlock.builder().add("\$T.concatenateWhere(selection, \"", com.dbflow5.processor.ClassNames.DATABASE_UTILS) val selectionArgsBuilder = CodeBlock.builder().add("\$T.appendSelectionArgs(selectionArgs, new \$T[] {", - ClassNames.DATABASE_UTILS, String::class.java) + com.dbflow5.processor.ClassNames.DATABASE_UTILS, String::class.java) var isFirst = true for (segment in segments) { if (!isFirst) { @@ -113,7 +112,7 @@ class DeleteMethod(private val contentProviderDefinition: ContentProviderDefinit case(uriDefinition.name.L) { add(uriDefinition.getSegmentsPreparation()) add("long count = \$T.getDatabase(\$T.class).delete(\$S, ", - ClassNames.FLOW_MANAGER, contentProviderDefinition.databaseTypeName, + com.dbflow5.processor.ClassNames.FLOW_MANAGER, contentProviderDefinition.databaseTypeName, it.tableName) add(uriDefinition.getSelectionAndSelectionArgs()) add(");\n") @@ -133,7 +132,7 @@ class DeleteMethod(private val contentProviderDefinition: ContentProviderDefinit return MethodSpec.methodBuilder("delete") .addAnnotation(Override::class.java) .addModifiers(Modifier.PUBLIC, Modifier.FINAL) - .addParameter(ClassNames.URI, PARAM_URI) + .addParameter(com.dbflow5.processor.ClassNames.URI, PARAM_URI) .addParameter(ClassName.get(String::class.java), PARAM_SELECTION) .addParameter(ArrayTypeName.of(String::class.java), PARAM_SELECTION_ARGS) .addCode(code.build()).returns(TypeName.INT).build() @@ -165,19 +164,19 @@ class InsertMethod(private val contentProviderDefinition: ContentProviderDefinit code.apply { beginControlFlow("case \$L:", uriDefinition.name) addStatement("\$T adapter = \$T.getModelAdapter(\$T.getTableClassForName(\$T.class, \$S))", - ClassNames.MODEL_ADAPTER, ClassNames.FLOW_MANAGER, ClassNames.FLOW_MANAGER, + com.dbflow5.processor.ClassNames.MODEL_ADAPTER, com.dbflow5.processor.ClassNames.FLOW_MANAGER, com.dbflow5.processor.ClassNames.FLOW_MANAGER, contentProviderDefinition.databaseTypeName, it.tableName) add("final long id = FlowManager.getDatabase(\$T.class)", contentProviderDefinition.databaseTypeName).add( ".insertWithOnConflict(\$S, null, values, " + "\$T.getSQLiteDatabaseAlgorithmInt(adapter.getInsertOnConflictAction()));\n", it.tableName, - ClassNames.CONFLICT_ACTION) + com.dbflow5.processor.ClassNames.CONFLICT_ACTION) NotifyMethod(it, uriDefinition, NotifyMethod.INSERT).addCode(this) if (!isBulk) { - addStatement("return \$T.withAppendedId(\$L, id)", ClassNames.CONTENT_URIS, Constants.PARAM_URI) + addStatement("return \$T.withAppendedId(\$L, id)", com.dbflow5.processor.ClassNames.CONTENT_URIS, Constants.PARAM_URI) } else { addStatement("return id > 0 ? 1 : 0") } @@ -190,10 +189,10 @@ class InsertMethod(private val contentProviderDefinition: ContentProviderDefinit appendDefault(code) code.endControlFlow() return MethodSpec.methodBuilder(if (isBulk) "bulkInsert" else "insert") - .addAnnotation(Override::class.java).addParameter(ClassNames.URI, Constants.PARAM_URI) - .addParameter(ClassNames.CONTENT_VALUES, Constants.PARAM_CONTENT_VALUES) + .addAnnotation(Override::class.java).addParameter(com.dbflow5.processor.ClassNames.URI, Constants.PARAM_URI) + .addParameter(com.dbflow5.processor.ClassNames.CONTENT_VALUES, Constants.PARAM_CONTENT_VALUES) .addModifiers(if (isBulk) Modifier.PROTECTED else Modifier.PUBLIC, Modifier.FINAL) - .addCode(code.build()).returns(if (isBulk) TypeName.INT else ClassNames.URI).build() + .addCode(code.build()).returns(if (isBulk) TypeName.INT else com.dbflow5.processor.ClassNames.URI).build() } } @@ -213,12 +212,12 @@ class NotifyMethod(private val tableEndpointDefinition: TableEndpointDefinition, for (i in notifyDefinitionList.indices) { val notifyDefinition = notifyDefinitionList[i] if (notifyDefinition.returnsArray) { - code.addStatement("\$T[] notifyUris\$L = \$L.\$L(\$L)", ClassNames.URI, + code.addStatement("\$T[] notifyUris\$L = \$L.\$L(\$L)", com.dbflow5.processor.ClassNames.URI, notifyDefinition.methodName, notifyDefinition.parent, notifyDefinition.methodName, notifyDefinition.params) - code.beginControlFlow("for (\$T notifyUri: notifyUris\$L)", ClassNames.URI, notifyDefinition.methodName) + code.beginControlFlow("for (\$T notifyUri: notifyUris\$L)", com.dbflow5.processor.ClassNames.URI, notifyDefinition.methodName) } else { - code.addStatement("\$T notifyUri\$L = \$L.\$L(\$L)", ClassNames.URI, + code.addStatement("\$T notifyUri\$L = \$L.\$L(\$L)", com.dbflow5.processor.ClassNames.URI, notifyDefinition.methodName, notifyDefinition.parent, notifyDefinition.methodName, notifyDefinition.params) } @@ -261,14 +260,14 @@ class QueryMethod(private val contentProviderDefinition: ContentProviderDefiniti val method = MethodSpec.methodBuilder("query") .addAnnotation(Override::class.java) .addModifiers(Modifier.PUBLIC, Modifier.FINAL) - .addParameter(ClassNames.URI, "uri") + .addParameter(com.dbflow5.processor.ClassNames.URI, "uri") .addParameter(ArrayTypeName.of(String::class.java), "projection") .addParameter(ClassName.get(String::class.java), "selection") .addParameter(ArrayTypeName.of(String::class.java), "selectionArgs") .addParameter(ClassName.get(String::class.java), "sortOrder") - .returns(ClassNames.CURSOR) + .returns(com.dbflow5.processor.ClassNames.CURSOR) - method.addStatement("\$L cursor = null", ClassNames.CURSOR) + method.addStatement("\$L cursor = null", com.dbflow5.processor.ClassNames.CURSOR) method.beginControlFlow("switch(\$L.match(uri))", ContentProviderDefinition.URI_MATCHER) for (tableEndpointDefinition in contentProviderDefinition.endpointDefinitions) { tableEndpointDefinition.contentUriDefinitions @@ -279,7 +278,7 @@ class QueryMethod(private val contentProviderDefinition: ContentProviderDefiniti beginControlFlow("case \$L:", it.name) addCode(it.getSegmentsPreparation()) addCode("cursor = \$T.getDatabase(\$T.class).query(\$S, projection, ", - ClassNames.FLOW_MANAGER, contentProviderDefinition.databaseTypeName, + com.dbflow5.processor.ClassNames.FLOW_MANAGER, contentProviderDefinition.databaseTypeName, tableEndpointDefinition.tableName) addCode(it.getSelectionAndSelectionArgs()) addCode(", null, null, sortOrder);\n") @@ -310,8 +309,8 @@ class UpdateMethod(private val contentProviderDefinition: ContentProviderDefinit val method = MethodSpec.methodBuilder("update") .addAnnotation(Override::class.java) .addModifiers(Modifier.PUBLIC) - .addParameter(ClassNames.URI, Constants.PARAM_URI) - .addParameter(ClassNames.CONTENT_VALUES, Constants.PARAM_CONTENT_VALUES) + .addParameter(com.dbflow5.processor.ClassNames.URI, Constants.PARAM_URI) + .addParameter(com.dbflow5.processor.ClassNames.CONTENT_VALUES, Constants.PARAM_CONTENT_VALUES) .addParameter(ClassName.get(String::class.java), "selection") .addParameter(ArrayTypeName.of(String::class.java), "selectionArgs") .returns(TypeName.INT) @@ -325,19 +324,19 @@ class UpdateMethod(private val contentProviderDefinition: ContentProviderDefinit method.apply { beginControlFlow("case \$L:", it.name) addStatement("\$T adapter = \$T.getModelAdapter(\$T.getTableClassForName(\$T.class, \$S))", - ClassNames.MODEL_ADAPTER, ClassNames.FLOW_MANAGER, ClassNames.FLOW_MANAGER, + com.dbflow5.processor.ClassNames.MODEL_ADAPTER, com.dbflow5.processor.ClassNames.FLOW_MANAGER, com.dbflow5.processor.ClassNames.FLOW_MANAGER, contentProviderDefinition.databaseTypeName, tableEndpointDefinition.tableName) addCode(it.getSegmentsPreparation()) addCode( "long count = \$T.getDatabase(\$T.class).updateWithOnConflict(\$S, \$L, ", - ClassNames.FLOW_MANAGER, contentProviderDefinition.databaseTypeName, + com.dbflow5.processor.ClassNames.FLOW_MANAGER, contentProviderDefinition.databaseTypeName, tableEndpointDefinition.tableName, Constants.PARAM_CONTENT_VALUES) addCode(it.getSelectionAndSelectionArgs()) addCode( ", \$T.getSQLiteDatabaseAlgorithmInt(adapter.getUpdateOnConflictAction()));\n", - ClassNames.CONFLICT_ACTION) + com.dbflow5.processor.ClassNames.CONFLICT_ACTION) val code = CodeBlock.builder() NotifyMethod(tableEndpointDefinition, it, @@ -405,7 +404,7 @@ class ContentProviderDefinition(typeElement: Element, processorManager: Processo } override val extendsClass: TypeName? - get() = ClassNames.BASE_CONTENT_PROVIDER + get() = com.dbflow5.processor.ClassNames.BASE_CONTENT_PROVIDER fun prepareForWrite() { val databaseDefinition = manager.getDatabaseHolderDefinition(databaseTypeName)!!.databaseDefinition @@ -423,7 +422,7 @@ class ContentProviderDefinition(typeElement: Element, processorManager: Processo } } - `private final field`(ClassNames.URI_MATCHER, URI_MATCHER) { `=`("new \$T(\$T.NO_MATCH)", ClassNames.URI_MATCHER, ClassNames.URI_MATCHER) } + `private final field`(com.dbflow5.processor.ClassNames.URI_MATCHER, URI_MATCHER) { `=`("new \$T(\$T.NO_MATCH)", com.dbflow5.processor.ClassNames.URI_MATCHER, com.dbflow5.processor.ClassNames.URI_MATCHER) } `override fun`(TypeName.BOOLEAN, "onCreate") { modifiers(public, final) @@ -450,10 +449,10 @@ class ContentProviderDefinition(typeElement: Element, processorManager: Processo `override fun`(String::class, "getDatabaseName") { modifiers(public, final) - `return`("\$T.getDatabaseName(\$T.class)", ClassNames.FLOW_MANAGER, databaseTypeName) + `return`("\$T.getDatabaseName(\$T.class)", com.dbflow5.processor.ClassNames.FLOW_MANAGER, databaseTypeName) } - `override fun`(String::class, "getType", param(ClassNames.URI, "uri")) { + `override fun`(String::class, "getType", param(com.dbflow5.processor.ClassNames.URI, "uri")) { modifiers(public, final) code { statement("\$T type = null", ClassName.get(String::class.java)) @@ -519,11 +518,11 @@ class ContentUriDefinition(typeElement: Element, processorManager: ProcessorMana } if (typeElement is VariableElement) { - if (ClassNames.URI != elementTypeName) { + if (com.dbflow5.processor.ClassNames.URI != elementTypeName) { processorManager.logError("Content Uri field returned wrong type. It must return a Uri") } } else if (typeElement is ExecutableElement) { - if (ClassNames.URI != elementTypeName) { + if (com.dbflow5.processor.ClassNames.URI != elementTypeName) { processorManager.logError("ContentUri method returns wrong type. It must return Uri") } } diff --git a/processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/provider/NotifyDefinition.kt b/processor/src/main/kotlin/com/dbflow5/processor/definition/provider/NotifyDefinition.kt similarity index 78% rename from processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/provider/NotifyDefinition.kt rename to processor/src/main/kotlin/com/dbflow5/processor/definition/provider/NotifyDefinition.kt index 9204f9bc6..475cf5654 100644 --- a/processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/provider/NotifyDefinition.kt +++ b/processor/src/main/kotlin/com/dbflow5/processor/definition/provider/NotifyDefinition.kt @@ -1,11 +1,10 @@ -package com.raizlabs.dbflow5.processor.definition.provider +package com.dbflow5.processor.definition.provider -import com.raizlabs.dbflow5.annotation.provider.Notify -import com.raizlabs.dbflow5.annotation.provider.NotifyMethod -import com.raizlabs.dbflow5.processor.ClassNames -import com.raizlabs.dbflow5.processor.ProcessorManager -import com.raizlabs.dbflow5.processor.definition.BaseDefinition -import com.raizlabs.dbflow5.processor.utils.annotation +import com.dbflow5.annotation.provider.Notify +import com.dbflow5.annotation.provider.NotifyMethod +import com.dbflow5.processor.ProcessorManager +import com.dbflow5.processor.definition.BaseDefinition +import com.dbflow5.processor.utils.annotation import com.squareup.javapoet.ClassName import javax.lang.model.element.Element import javax.lang.model.element.ExecutableElement @@ -61,8 +60,8 @@ class NotifyDefinition(typeElement: Element, processorManager: ProcessorManager) val typeMirror = executableElement.returnType when { - "${ClassNames.URI}[]" == typeMirror.toString() -> returnsArray = true - ClassNames.URI.toString() == typeMirror.toString() -> returnsSingle = true + "${com.dbflow5.processor.ClassNames.URI}[]" == typeMirror.toString() -> returnsArray = true + com.dbflow5.processor.ClassNames.URI.toString() == typeMirror.toString() -> returnsSingle = true else -> processorManager.logError("Notify method returns wrong type. It must return Uri or Uri[]") } } diff --git a/processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/provider/TableEndpointDefinition.kt b/processor/src/main/kotlin/com/dbflow5/processor/definition/provider/TableEndpointDefinition.kt similarity index 80% rename from processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/provider/TableEndpointDefinition.kt rename to processor/src/main/kotlin/com/dbflow5/processor/definition/provider/TableEndpointDefinition.kt index 6e379080d..6a46553df 100644 --- a/processor/src/main/kotlin/com/raizlabs/dbflow5/processor/definition/provider/TableEndpointDefinition.kt +++ b/processor/src/main/kotlin/com/dbflow5/processor/definition/provider/TableEndpointDefinition.kt @@ -1,13 +1,13 @@ -package com.raizlabs.dbflow5.processor.definition.provider +package com.dbflow5.processor.definition.provider -import com.raizlabs.dbflow5.annotation.provider.ContentUri -import com.raizlabs.dbflow5.annotation.provider.Notify -import com.raizlabs.dbflow5.annotation.provider.NotifyMethod -import com.raizlabs.dbflow5.annotation.provider.TableEndpoint -import com.raizlabs.dbflow5.processor.ProcessorManager -import com.raizlabs.dbflow5.processor.definition.BaseDefinition -import com.raizlabs.dbflow5.processor.utils.annotation -import com.raizlabs.dbflow5.processor.utils.extractTypeNameFromAnnotation +import com.dbflow5.annotation.provider.ContentUri +import com.dbflow5.annotation.provider.Notify +import com.dbflow5.annotation.provider.NotifyMethod +import com.dbflow5.annotation.provider.TableEndpoint +import com.dbflow5.processor.ProcessorManager +import com.dbflow5.processor.definition.BaseDefinition +import com.dbflow5.processor.utils.annotation +import com.dbflow5.processor.utils.extractTypeNameFromAnnotation import com.squareup.javapoet.TypeName import javax.lang.model.element.Element import javax.lang.model.element.PackageElement diff --git a/processor/src/main/kotlin/com/raizlabs/dbflow5/processor/utils/CodeExtensions.kt b/processor/src/main/kotlin/com/dbflow5/processor/utils/CodeExtensions.kt similarity index 97% rename from processor/src/main/kotlin/com/raizlabs/dbflow5/processor/utils/CodeExtensions.kt rename to processor/src/main/kotlin/com/dbflow5/processor/utils/CodeExtensions.kt index 75d66597b..321661273 100644 --- a/processor/src/main/kotlin/com/raizlabs/dbflow5/processor/utils/CodeExtensions.kt +++ b/processor/src/main/kotlin/com/dbflow5/processor/utils/CodeExtensions.kt @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5.processor.utils +package com.dbflow5.processor.utils import com.grosner.kpoet.end import com.grosner.kpoet.nextControl diff --git a/processor/src/main/kotlin/com/raizlabs/dbflow5/processor/utils/DependencyUtils.kt b/processor/src/main/kotlin/com/dbflow5/processor/utils/DependencyUtils.kt similarity index 68% rename from processor/src/main/kotlin/com/raizlabs/dbflow5/processor/utils/DependencyUtils.kt rename to processor/src/main/kotlin/com/dbflow5/processor/utils/DependencyUtils.kt index 6c11cda17..e7d382627 100644 --- a/processor/src/main/kotlin/com/raizlabs/dbflow5/processor/utils/DependencyUtils.kt +++ b/processor/src/main/kotlin/com/dbflow5/processor/utils/DependencyUtils.kt @@ -1,6 +1,6 @@ -package com.raizlabs.dbflow5.processor.utils +package com.dbflow5.processor.utils -import com.raizlabs.dbflow5.processor.ProcessorManager +import com.dbflow5.processor.ProcessorManager /** * Used to check if class exists on class path, if so, we add the annotation to generated class files. diff --git a/processor/src/main/kotlin/com/raizlabs/dbflow5/processor/utils/ElementExtensions.kt b/processor/src/main/kotlin/com/dbflow5/processor/utils/ElementExtensions.kt similarity index 92% rename from processor/src/main/kotlin/com/raizlabs/dbflow5/processor/utils/ElementExtensions.kt rename to processor/src/main/kotlin/com/dbflow5/processor/utils/ElementExtensions.kt index 27c1d0373..13805844c 100644 --- a/processor/src/main/kotlin/com/raizlabs/dbflow5/processor/utils/ElementExtensions.kt +++ b/processor/src/main/kotlin/com/dbflow5/processor/utils/ElementExtensions.kt @@ -1,6 +1,6 @@ -package com.raizlabs.dbflow5.processor.utils +package com.dbflow5.processor.utils -import com.raizlabs.dbflow5.processor.ProcessorManager +import com.dbflow5.processor.ProcessorManager import com.squareup.javapoet.ClassName import com.squareup.javapoet.TypeName import javax.lang.model.element.Element diff --git a/processor/src/main/kotlin/com/raizlabs/dbflow5/processor/utils/ElementUtility.kt b/processor/src/main/kotlin/com/dbflow5/processor/utils/ElementUtility.kt similarity index 94% rename from processor/src/main/kotlin/com/raizlabs/dbflow5/processor/utils/ElementUtility.kt rename to processor/src/main/kotlin/com/dbflow5/processor/utils/ElementUtility.kt index 4b506d724..8ceccc76c 100644 --- a/processor/src/main/kotlin/com/raizlabs/dbflow5/processor/utils/ElementUtility.kt +++ b/processor/src/main/kotlin/com/dbflow5/processor/utils/ElementUtility.kt @@ -1,7 +1,7 @@ -package com.raizlabs.dbflow5.processor.utils +package com.dbflow5.processor.utils -import com.raizlabs.dbflow5.annotation.ColumnIgnore -import com.raizlabs.dbflow5.processor.ProcessorManager +import com.dbflow5.annotation.ColumnIgnore +import com.dbflow5.processor.ProcessorManager import com.squareup.javapoet.ClassName import javax.lang.model.element.Element import javax.lang.model.element.Modifier diff --git a/processor/src/main/kotlin/com/raizlabs/dbflow5/processor/utils/JavaPoetExtensions.kt b/processor/src/main/kotlin/com/dbflow5/processor/utils/JavaPoetExtensions.kt similarity index 97% rename from processor/src/main/kotlin/com/raizlabs/dbflow5/processor/utils/JavaPoetExtensions.kt rename to processor/src/main/kotlin/com/dbflow5/processor/utils/JavaPoetExtensions.kt index bcb0443a8..142a51099 100644 --- a/processor/src/main/kotlin/com/raizlabs/dbflow5/processor/utils/JavaPoetExtensions.kt +++ b/processor/src/main/kotlin/com/dbflow5/processor/utils/JavaPoetExtensions.kt @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5.processor.utils +package com.dbflow5.processor.utils import com.grosner.kpoet.returns import com.squareup.javapoet.MethodSpec diff --git a/processor/src/main/kotlin/com/raizlabs/dbflow5/processor/utils/ModelUtils.kt b/processor/src/main/kotlin/com/dbflow5/processor/utils/ModelUtils.kt similarity index 64% rename from processor/src/main/kotlin/com/raizlabs/dbflow5/processor/utils/ModelUtils.kt rename to processor/src/main/kotlin/com/dbflow5/processor/utils/ModelUtils.kt index 67f307c37..66bc8935f 100644 --- a/processor/src/main/kotlin/com/raizlabs/dbflow5/processor/utils/ModelUtils.kt +++ b/processor/src/main/kotlin/com/dbflow5/processor/utils/ModelUtils.kt @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5.processor.utils +package com.dbflow5.processor.utils object ModelUtils { diff --git a/processor/src/main/kotlin/com/raizlabs/dbflow5/processor/utils/ProcessorUtils.kt b/processor/src/main/kotlin/com/dbflow5/processor/utils/ProcessorUtils.kt similarity index 96% rename from processor/src/main/kotlin/com/raizlabs/dbflow5/processor/utils/ProcessorUtils.kt rename to processor/src/main/kotlin/com/dbflow5/processor/utils/ProcessorUtils.kt index 8499a6bc1..47bc06bb3 100644 --- a/processor/src/main/kotlin/com/raizlabs/dbflow5/processor/utils/ProcessorUtils.kt +++ b/processor/src/main/kotlin/com/dbflow5/processor/utils/ProcessorUtils.kt @@ -1,7 +1,7 @@ -package com.raizlabs.dbflow5.processor.utils +package com.dbflow5.processor.utils -import com.raizlabs.dbflow5.processor.ProcessorManager -import com.raizlabs.dbflow5.processor.ProcessorManager.Companion.manager +import com.dbflow5.processor.ProcessorManager +import com.dbflow5.processor.ProcessorManager.Companion.manager import com.squareup.javapoet.ClassName import com.squareup.javapoet.TypeName import javax.annotation.processing.ProcessingEnvironment diff --git a/processor/src/main/kotlin/com/raizlabs/dbflow5/processor/utils/StringUtils.kt b/processor/src/main/kotlin/com/dbflow5/processor/utils/StringUtils.kt similarity index 91% rename from processor/src/main/kotlin/com/raizlabs/dbflow5/processor/utils/StringUtils.kt rename to processor/src/main/kotlin/com/dbflow5/processor/utils/StringUtils.kt index 0ff397016..ad76e6d47 100644 --- a/processor/src/main/kotlin/com/raizlabs/dbflow5/processor/utils/StringUtils.kt +++ b/processor/src/main/kotlin/com/dbflow5/processor/utils/StringUtils.kt @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5.processor.utils +package com.dbflow5.processor.utils /** * Description: diff --git a/processor/src/main/kotlin/com/raizlabs/dbflow5/processor/utils/WriterUtils.kt b/processor/src/main/kotlin/com/dbflow5/processor/utils/WriterUtils.kt similarity index 83% rename from processor/src/main/kotlin/com/raizlabs/dbflow5/processor/utils/WriterUtils.kt rename to processor/src/main/kotlin/com/dbflow5/processor/utils/WriterUtils.kt index fed113426..4c6dc1c83 100644 --- a/processor/src/main/kotlin/com/raizlabs/dbflow5/processor/utils/WriterUtils.kt +++ b/processor/src/main/kotlin/com/dbflow5/processor/utils/WriterUtils.kt @@ -1,8 +1,8 @@ -package com.raizlabs.dbflow5.processor.utils +package com.dbflow5.processor.utils import com.grosner.kpoet.javaFile -import com.raizlabs.dbflow5.processor.ProcessorManager -import com.raizlabs.dbflow5.processor.definition.BaseDefinition +import com.dbflow5.processor.ProcessorManager +import com.dbflow5.processor.definition.BaseDefinition import java.io.IOException /** diff --git a/processor/src/main/resources/META-INF/services/javax.annotation.processing.Processor b/processor/src/main/resources/META-INF/services/javax.annotation.processing.Processor index d6c2ce391..ba9eb39db 100644 --- a/processor/src/main/resources/META-INF/services/javax.annotation.processing.Processor +++ b/processor/src/main/resources/META-INF/services/javax.annotation.processing.Processor @@ -1 +1 @@ -com.raizlabs.dbflow5.processor.DBFlowProcessor \ No newline at end of file +com.dbflow5.processor.DBFlowProcessor \ No newline at end of file diff --git a/processor/src/test/java/com/raizlabs/dbflow5/processor/test/ColumnAccessCombinerTests.kt b/processor/src/test/java/com/raizlabs/dbflow5/processor/test/ColumnAccessCombinerTests.kt index 40390c6a4..98dfc03db 100644 --- a/processor/src/test/java/com/raizlabs/dbflow5/processor/test/ColumnAccessCombinerTests.kt +++ b/processor/src/test/java/com/raizlabs/dbflow5/processor/test/ColumnAccessCombinerTests.kt @@ -1,15 +1,15 @@ -package com.raizlabs.android.dbflow.processor.test - -import com.raizlabs.dbflow5.processor.definition.column.BooleanColumnAccessor -import com.raizlabs.dbflow5.processor.definition.column.Combiner -import com.raizlabs.dbflow5.processor.definition.column.ContentValuesCombiner -import com.raizlabs.dbflow5.processor.definition.column.LoadFromCursorAccessCombiner -import com.raizlabs.dbflow5.processor.definition.column.PackagePrivateScopeColumnAccessor -import com.raizlabs.dbflow5.processor.definition.column.PrimaryReferenceAccessCombiner -import com.raizlabs.dbflow5.processor.definition.column.PrivateScopeColumnAccessor -import com.raizlabs.dbflow5.processor.definition.column.SqliteStatementAccessCombiner -import com.raizlabs.dbflow5.processor.definition.column.TypeConverterScopeColumnAccessor -import com.raizlabs.dbflow5.processor.definition.column.VisibleScopeColumnAccessor +package com.dbflow5.processor.test + +import com.dbflow5.processor.definition.column.BooleanColumnAccessor +import com.dbflow5.processor.definition.column.Combiner +import com.dbflow5.processor.definition.column.ContentValuesCombiner +import com.dbflow5.processor.definition.column.LoadFromCursorAccessCombiner +import com.dbflow5.processor.definition.column.PackagePrivateScopeColumnAccessor +import com.dbflow5.processor.definition.column.PrimaryReferenceAccessCombiner +import com.dbflow5.processor.definition.column.PrivateScopeColumnAccessor +import com.dbflow5.processor.definition.column.SqliteStatementAccessCombiner +import com.dbflow5.processor.definition.column.TypeConverterScopeColumnAccessor +import com.dbflow5.processor.definition.column.VisibleScopeColumnAccessor import com.squareup.javapoet.CodeBlock import com.squareup.javapoet.NameAllocator import com.squareup.javapoet.TypeName diff --git a/processor/src/test/java/com/raizlabs/dbflow5/processor/test/ForeignKeyAccessCombinerTests.kt b/processor/src/test/java/com/raizlabs/dbflow5/processor/test/ForeignKeyAccessCombinerTests.kt index a047218dc..fdf1f6537 100644 --- a/processor/src/test/java/com/raizlabs/dbflow5/processor/test/ForeignKeyAccessCombinerTests.kt +++ b/processor/src/test/java/com/raizlabs/dbflow5/processor/test/ForeignKeyAccessCombinerTests.kt @@ -1,17 +1,17 @@ -package com.raizlabs.android.dbflow.processor.test - -import com.raizlabs.dbflow5.processor.definition.column.Combiner -import com.raizlabs.dbflow5.processor.definition.column.ContentValuesCombiner -import com.raizlabs.dbflow5.processor.definition.column.ForeignKeyAccessCombiner -import com.raizlabs.dbflow5.processor.definition.column.ForeignKeyAccessField -import com.raizlabs.dbflow5.processor.definition.column.ForeignKeyLoadFromCursorCombiner -import com.raizlabs.dbflow5.processor.definition.column.PackagePrivateScopeColumnAccessor -import com.raizlabs.dbflow5.processor.definition.column.PartialLoadFromCursorAccessCombiner -import com.raizlabs.dbflow5.processor.definition.column.PrimaryReferenceAccessCombiner -import com.raizlabs.dbflow5.processor.definition.column.PrivateScopeColumnAccessor -import com.raizlabs.dbflow5.processor.definition.column.SqliteStatementAccessCombiner -import com.raizlabs.dbflow5.processor.definition.column.TypeConverterScopeColumnAccessor -import com.raizlabs.dbflow5.processor.definition.column.VisibleScopeColumnAccessor +package com.dbflow5.processor.test + +import com.dbflow5.processor.definition.column.Combiner +import com.dbflow5.processor.definition.column.ContentValuesCombiner +import com.dbflow5.processor.definition.column.ForeignKeyAccessCombiner +import com.dbflow5.processor.definition.column.ForeignKeyAccessField +import com.dbflow5.processor.definition.column.ForeignKeyLoadFromCursorCombiner +import com.dbflow5.processor.definition.column.PackagePrivateScopeColumnAccessor +import com.dbflow5.processor.definition.column.PartialLoadFromCursorAccessCombiner +import com.dbflow5.processor.definition.column.PrimaryReferenceAccessCombiner +import com.dbflow5.processor.definition.column.PrivateScopeColumnAccessor +import com.dbflow5.processor.definition.column.SqliteStatementAccessCombiner +import com.dbflow5.processor.definition.column.TypeConverterScopeColumnAccessor +import com.dbflow5.processor.definition.column.VisibleScopeColumnAccessor import com.squareup.javapoet.ClassName import com.squareup.javapoet.CodeBlock import com.squareup.javapoet.NameAllocator @@ -83,7 +83,7 @@ class ForeignKeyAccessCombinerTest { assertEquals("if (com.fuzz.android.TestHelper_Helper.getName(model) != null) {" + "\n clause.and(test.eq(com.fuzz.android.TestHelper2_Helper.getTest(com.fuzz.android.TestHelper_Helper.getName(model))));" + "\n} else {" + - "\n clause.and(test.eq((com.raizlabs.android.dbflow.sql.language.IConditional) null));" + + "\n clause.and(test.eq((com.dbflow5.sql.language.IConditional) null));" + "\n}", builder.build().toString().trim()) } @@ -115,8 +115,8 @@ class ForeignKeyAccessCombinerTest { @Test fun test_canLoadFromCursor() { val foreignKeyAccessCombiner = ForeignKeyLoadFromCursorCombiner(VisibleScopeColumnAccessor("testModel1"), - ClassName.get("com.raizlabs.android.dbflow.test.container", "ParentModel"), - ClassName.get("com.raizlabs.android.dbflow.test.container", "ParentModel_Table"), false, + ClassName.get("com.dbflow5.test.container", "ParentModel"), + ClassName.get("com.dbflow5.test.container", "ParentModel_Table"), false, NameAllocator()) foreignKeyAccessCombiner.fieldAccesses += PartialLoadFromCursorAccessCombiner("testmodel_id", "name", TypeName.get(String::class.java), false, null) @@ -129,9 +129,9 @@ class ForeignKeyAccessCombinerTest { assertEquals("int index_testmodel_id_ParentModel_Table = cursor.getColumnIndex(\"testmodel_id\");" + "\nint index_testmodel_type_ParentModel_Table = cursor.getColumnIndex(\"testmodel_type\");" + "\nif (index_testmodel_id_ParentModel_Table != -1 && !cursor.isNull(index_testmodel_id_ParentModel_Table) && index_testmodel_type_ParentModel_Table != -1 && !cursor.isNull(index_testmodel_type_ParentModel_Table)) {" + - "\n model.testModel1 = com.raizlabs.android.dbflow.sql.language.SQLite.select().from(com.raizlabs.android.dbflow.test.container.ParentModel.class).where()" + - "\n .and(com.raizlabs.android.dbflow.test.container.ParentModel_Table.name.eq(cursor.getString(index_testmodel_id_ParentModel_Table)))" + - "\n .and(com.raizlabs.android.dbflow.test.container.ParentModel_Table.type.eq(cursor.getString(index_testmodel_type_ParentModel_Table)))" + + "\n model.testModel1 = com.dbflow5.sql.language.SQLite.select().from(com.dbflow5.test.container.ParentModel.class).where()" + + "\n .and(com.dbflow5.test.container.ParentModel_Table.name.eq(cursor.getString(index_testmodel_id_ParentModel_Table)))" + + "\n .and(com.dbflow5.test.container.ParentModel_Table.type.eq(cursor.getString(index_testmodel_type_ParentModel_Table)))" + "\n .querySingle();" + "\n} else {" + "\n model.testModel1 = null;" + @@ -141,8 +141,8 @@ class ForeignKeyAccessCombinerTest { @Test fun test_canLoadFromCursorStubbed() { val foreignKeyAccessCombiner = ForeignKeyLoadFromCursorCombiner(VisibleScopeColumnAccessor("testModel1"), - ClassName.get("com.raizlabs.android.dbflow.test.container", "ParentModel"), - ClassName.get("com.raizlabs.android.dbflow.test.container", "ParentModel_Table"), true, + ClassName.get("com.dbflow5.test.container", "ParentModel"), + ClassName.get("com.dbflow5.test.container", "ParentModel_Table"), true, NameAllocator()) foreignKeyAccessCombiner.fieldAccesses += PartialLoadFromCursorAccessCombiner("testmodel_id", "name", TypeName.get(String::class.java), false, VisibleScopeColumnAccessor("name")) @@ -155,7 +155,7 @@ class ForeignKeyAccessCombinerTest { assertEquals("int index_testmodel_id_ParentModel_Table = cursor.getColumnIndex(\"testmodel_id\");" + "\nint index_testmodel_type_ParentModel_Table = cursor.getColumnIndex(\"testmodel_type\");" + "\nif (index_testmodel_id_ParentModel_Table != -1 && !cursor.isNull(index_testmodel_id_ParentModel_Table) && index_testmodel_type_ParentModel_Table != -1 && !cursor.isNull(index_testmodel_type_ParentModel_Table)) {" + - "\n model.testModel1 = new com.raizlabs.android.dbflow.test.container.ParentModel();" + + "\n model.testModel1 = new com.dbflow5.test.container.ParentModel();" + "\n model.testModel1.name = cursor.getString(index_testmodel_id_ParentModel_Table);" + "\n model.testModel1.type = cursor.getString(index_testmodel_type_ParentModel_Table);" + "\n} else {" + diff --git a/processor/src/test/java/com/raizlabs/dbflow5/processor/test/SimpleColumnAccessorTests.kt b/processor/src/test/java/com/raizlabs/dbflow5/processor/test/SimpleColumnAccessorTests.kt index 1b0ea3bf7..136dca4f7 100644 --- a/processor/src/test/java/com/raizlabs/dbflow5/processor/test/SimpleColumnAccessorTests.kt +++ b/processor/src/test/java/com/raizlabs/dbflow5/processor/test/SimpleColumnAccessorTests.kt @@ -1,6 +1,6 @@ -package com.raizlabs.dbflow5.processor.test +package com.dbflow5.processor.test -import com.raizlabs.dbflow5.processor.definition.column.* +import com.dbflow5.processor.definition.column.* import com.squareup.javapoet.CodeBlock import com.squareup.javapoet.TypeName import org.junit.Assert.assertEquals @@ -118,7 +118,7 @@ class EnumColumnAccessorTest { @Test fun test_canSetEnum() { val access = EnumColumnAccessor(TypeName.get(TestEnum::class.java)) - assertEquals("com.raizlabs.dbflow5.processor.test.EnumColumnAccessorTest.TestEnum.valueOf(model.test)", + assertEquals("com.dbflow5.processor.test.EnumColumnAccessorTest.TestEnum.valueOf(model.test)", access.set(CodeBlock.of("model.test")).toString()) } } @@ -134,7 +134,7 @@ class BlobColumnAccessorTest() { @Test fun test_canSetBlob() { val access = BlobColumnAccessor() - assertEquals("new com.raizlabs.dbflow5.Blob(cursor.getBlob(index))", + assertEquals("new com.dbflow5.Blob(cursor.getBlob(index))", access.set(CodeBlock.of("cursor.getBlob(index)")).toString()) } } diff --git a/reactive-streams/build.gradle b/reactive-streams/build.gradle index 0378140b6..31174b324 100644 --- a/reactive-streams/build.gradle +++ b/reactive-streams/build.gradle @@ -22,7 +22,7 @@ android { } dependencies { - api project("${dbflow_project_prefix}dbflow") + api project(':lib') api deps.rx2 api deps.kotlin } diff --git a/reactive-streams/src/main/AndroidManifest.xml b/reactive-streams/src/main/AndroidManifest.xml index 2380e798a..6c0b2d71b 100644 --- a/reactive-streams/src/main/AndroidManifest.xml +++ b/reactive-streams/src/main/AndroidManifest.xml @@ -1 +1 @@ - + diff --git a/reactive-streams/src/main/kotlin/com/raizlabs/dbflow5/reactivestreams/query/CursorListFlowable.kt b/reactive-streams/src/main/kotlin/com/raizlabs/dbflow5/reactivestreams/query/CursorListFlowable.kt index 88b84c2e8..a915a25d1 100644 --- a/reactive-streams/src/main/kotlin/com/raizlabs/dbflow5/reactivestreams/query/CursorListFlowable.kt +++ b/reactive-streams/src/main/kotlin/com/raizlabs/dbflow5/reactivestreams/query/CursorListFlowable.kt @@ -1,11 +1,11 @@ -package com.raizlabs.dbflow5.reactivestreams.query +package com.dbflow5.reactivestreams.query -import com.raizlabs.dbflow5.config.DBFlowDatabase -import com.raizlabs.dbflow5.config.FlowLog -import com.raizlabs.dbflow5.query.ModelQueriable -import com.raizlabs.dbflow5.query.list.FlowCursorList -import com.raizlabs.dbflow5.reactivestreams.transaction.asSingle -import com.raizlabs.dbflow5.transaction.Transaction +import com.dbflow5.config.DBFlowDatabase +import com.dbflow5.config.FlowLog +import com.dbflow5.query.ModelQueriable +import com.dbflow5.query.list.FlowCursorList +import com.dbflow5.reactivestreams.transaction.asSingle +import com.dbflow5.transaction.Transaction import io.reactivex.Flowable import io.reactivex.SingleObserver import io.reactivex.disposables.Disposable diff --git a/reactive-streams/src/main/kotlin/com/raizlabs/dbflow5/reactivestreams/query/ModelQueriableExtensions.kt b/reactive-streams/src/main/kotlin/com/raizlabs/dbflow5/reactivestreams/query/ModelQueriableExtensions.kt index 5671bbe20..935a5be29 100644 --- a/reactive-streams/src/main/kotlin/com/raizlabs/dbflow5/reactivestreams/query/ModelQueriableExtensions.kt +++ b/reactive-streams/src/main/kotlin/com/raizlabs/dbflow5/reactivestreams/query/ModelQueriableExtensions.kt @@ -1,10 +1,10 @@ @file:JvmName("RXModelQueriable") -package com.raizlabs.dbflow5.reactivestreams.query +package com.dbflow5.reactivestreams.query -import com.raizlabs.dbflow5.config.DBFlowDatabase -import com.raizlabs.dbflow5.query.ModelQueriable -import com.raizlabs.dbflow5.transaction.ITransactionQueue +import com.dbflow5.config.DBFlowDatabase +import com.dbflow5.query.ModelQueriable +import com.dbflow5.transaction.ITransactionQueue import io.reactivex.Flowable /** diff --git a/reactive-streams/src/main/kotlin/com/raizlabs/dbflow5/reactivestreams/query/TableChangeOnSubscribe.kt b/reactive-streams/src/main/kotlin/com/raizlabs/dbflow5/reactivestreams/query/TableChangeOnSubscribe.kt index e06130af5..271dac7b3 100644 --- a/reactive-streams/src/main/kotlin/com/raizlabs/dbflow5/reactivestreams/query/TableChangeOnSubscribe.kt +++ b/reactive-streams/src/main/kotlin/com/raizlabs/dbflow5/reactivestreams/query/TableChangeOnSubscribe.kt @@ -1,15 +1,15 @@ -package com.raizlabs.dbflow5.reactivestreams.query +package com.dbflow5.reactivestreams.query -import com.raizlabs.dbflow5.config.FlowManager -import com.raizlabs.dbflow5.config.databaseForTable -import com.raizlabs.dbflow5.database.DatabaseWrapper -import com.raizlabs.dbflow5.query.Join -import com.raizlabs.dbflow5.query.ModelQueriable -import com.raizlabs.dbflow5.query.extractFrom -import com.raizlabs.dbflow5.runtime.OnTableChangedListener -import com.raizlabs.dbflow5.runtime.TableNotifierRegister -import com.raizlabs.dbflow5.reactivestreams.transaction.asMaybe -import com.raizlabs.dbflow5.structure.ChangeAction +import com.dbflow5.config.FlowManager +import com.dbflow5.config.databaseForTable +import com.dbflow5.database.DatabaseWrapper +import com.dbflow5.query.Join +import com.dbflow5.query.ModelQueriable +import com.dbflow5.query.extractFrom +import com.dbflow5.runtime.OnTableChangedListener +import com.dbflow5.runtime.TableNotifierRegister +import com.dbflow5.reactivestreams.transaction.asMaybe +import com.dbflow5.structure.ChangeAction import io.reactivex.FlowableEmitter import io.reactivex.FlowableOnSubscribe import io.reactivex.disposables.Disposables diff --git a/reactive-streams/src/main/kotlin/com/raizlabs/dbflow5/reactivestreams/structure/BaseRXModel.kt b/reactive-streams/src/main/kotlin/com/raizlabs/dbflow5/reactivestreams/structure/BaseRXModel.kt index 37a3ce1b6..9886f9b10 100644 --- a/reactive-streams/src/main/kotlin/com/raizlabs/dbflow5/reactivestreams/structure/BaseRXModel.kt +++ b/reactive-streams/src/main/kotlin/com/raizlabs/dbflow5/reactivestreams/structure/BaseRXModel.kt @@ -1,11 +1,11 @@ -package com.raizlabs.dbflow5.reactivestreams.structure - -import com.raizlabs.dbflow5.annotation.ColumnIgnore -import com.raizlabs.dbflow5.config.FlowManager -import com.raizlabs.dbflow5.structure.BaseModel -import com.raizlabs.dbflow5.structure.InvalidDBConfiguration -import com.raizlabs.dbflow5.adapter.ModelAdapter -import com.raizlabs.dbflow5.database.DatabaseWrapper +package com.dbflow5.reactivestreams.structure + +import com.dbflow5.annotation.ColumnIgnore +import com.dbflow5.config.FlowManager +import com.dbflow5.structure.BaseModel +import com.dbflow5.structure.InvalidDBConfiguration +import com.dbflow5.adapter.ModelAdapter +import com.dbflow5.database.DatabaseWrapper import io.reactivex.Completable import io.reactivex.Single diff --git a/reactive-streams/src/main/kotlin/com/raizlabs/dbflow5/reactivestreams/structure/RXModelAdapter.kt b/reactive-streams/src/main/kotlin/com/raizlabs/dbflow5/reactivestreams/structure/RXModelAdapter.kt index 09e9c829d..62e1ddb7c 100644 --- a/reactive-streams/src/main/kotlin/com/raizlabs/dbflow5/reactivestreams/structure/RXModelAdapter.kt +++ b/reactive-streams/src/main/kotlin/com/raizlabs/dbflow5/reactivestreams/structure/RXModelAdapter.kt @@ -1,8 +1,8 @@ -package com.raizlabs.dbflow5.reactivestreams.structure +package com.dbflow5.reactivestreams.structure -import com.raizlabs.dbflow5.adapter.ModelAdapter -import com.raizlabs.dbflow5.config.modelAdapter -import com.raizlabs.dbflow5.database.DatabaseWrapper +import com.dbflow5.adapter.ModelAdapter +import com.dbflow5.config.modelAdapter +import com.dbflow5.database.DatabaseWrapper import io.reactivex.Completable import io.reactivex.Completable.fromCallable import io.reactivex.Single diff --git a/reactive-streams/src/main/kotlin/com/raizlabs/dbflow5/reactivestreams/structure/RXRetrievalAdapter.kt b/reactive-streams/src/main/kotlin/com/raizlabs/dbflow5/reactivestreams/structure/RXRetrievalAdapter.kt index 75d33e88b..868533393 100644 --- a/reactive-streams/src/main/kotlin/com/raizlabs/dbflow5/reactivestreams/structure/RXRetrievalAdapter.kt +++ b/reactive-streams/src/main/kotlin/com/raizlabs/dbflow5/reactivestreams/structure/RXRetrievalAdapter.kt @@ -1,8 +1,8 @@ -package com.raizlabs.dbflow5.reactivestreams.structure +package com.dbflow5.reactivestreams.structure -import com.raizlabs.dbflow5.adapter.RetrievalAdapter -import com.raizlabs.dbflow5.config.FlowManager -import com.raizlabs.dbflow5.database.DatabaseWrapper +import com.dbflow5.adapter.RetrievalAdapter +import com.dbflow5.config.FlowManager +import com.dbflow5.database.DatabaseWrapper import io.reactivex.Completable import io.reactivex.Single diff --git a/reactive-streams/src/main/kotlin/com/raizlabs/dbflow5/reactivestreams/transaction/TransactionObservable.kt b/reactive-streams/src/main/kotlin/com/raizlabs/dbflow5/reactivestreams/transaction/TransactionObservable.kt index c121686b4..70fee229b 100644 --- a/reactive-streams/src/main/kotlin/com/raizlabs/dbflow5/reactivestreams/transaction/TransactionObservable.kt +++ b/reactive-streams/src/main/kotlin/com/raizlabs/dbflow5/reactivestreams/transaction/TransactionObservable.kt @@ -1,12 +1,12 @@ @file:JvmName("RXTransactions") -package com.raizlabs.dbflow5.reactivestreams.transaction +package com.dbflow5.reactivestreams.transaction -import com.raizlabs.dbflow5.database.DatabaseWrapper -import com.raizlabs.dbflow5.query.ModelQueriable -import com.raizlabs.dbflow5.reactivestreams.query.TableChangeOnSubscribe -import com.raizlabs.dbflow5.transaction.ITransactionQueue -import com.raizlabs.dbflow5.transaction.Transaction +import com.dbflow5.database.DatabaseWrapper +import com.dbflow5.query.ModelQueriable +import com.dbflow5.reactivestreams.query.TableChangeOnSubscribe +import com.dbflow5.transaction.ITransactionQueue +import com.dbflow5.transaction.Transaction import io.reactivex.BackpressureStrategy import io.reactivex.Flowable import io.reactivex.Maybe diff --git a/settings.gradle b/settings.gradle index 2551abee8..61aedc7fd 100644 --- a/settings.gradle +++ b/settings.gradle @@ -1,4 +1,4 @@ -include ':dbflow', ':reactive-streams', ':coroutines', +include ':lib', ':reactive-streams', ':coroutines', ':contentprovider', ':processor', ':core', ':sqlcipher', diff --git a/sqlcipher/build.gradle b/sqlcipher/build.gradle index 4cad5dbab..ae4e5043c 100644 --- a/sqlcipher/build.gradle +++ b/sqlcipher/build.gradle @@ -27,7 +27,7 @@ android { dependencies { api deps.sql_cipher - api project("${dbflow_project_prefix}dbflow") + api project(':lib') api deps.kotlin } diff --git a/sqlcipher/src/main/AndroidManifest.xml b/sqlcipher/src/main/AndroidManifest.xml index 4d1de0cf9..5f91eb09d 100644 --- a/sqlcipher/src/main/AndroidManifest.xml +++ b/sqlcipher/src/main/AndroidManifest.xml @@ -1 +1 @@ - + diff --git a/sqlcipher/src/main/kotlin/com/raizlabs/dbflow5/sqlcipher/SQLCipherDatabase.kt b/sqlcipher/src/main/kotlin/com/raizlabs/dbflow5/sqlcipher/SQLCipherDatabase.kt index 62a4b0600..ff687be17 100644 --- a/sqlcipher/src/main/kotlin/com/raizlabs/dbflow5/sqlcipher/SQLCipherDatabase.kt +++ b/sqlcipher/src/main/kotlin/com/raizlabs/dbflow5/sqlcipher/SQLCipherDatabase.kt @@ -1,9 +1,9 @@ -package com.raizlabs.dbflow5.sqlcipher +package com.dbflow5.sqlcipher import android.content.ContentValues -import com.raizlabs.dbflow5.database.DatabaseStatement -import com.raizlabs.dbflow5.database.DatabaseWrapper -import com.raizlabs.dbflow5.database.FlowCursor +import com.dbflow5.database.DatabaseStatement +import com.dbflow5.database.DatabaseWrapper +import com.dbflow5.database.FlowCursor import net.sqlcipher.database.SQLiteDatabase import net.sqlcipher.database.SQLiteException @@ -77,7 +77,7 @@ internal constructor(val database: SQLiteDatabase) : DatabaseWrapper { } } -fun SQLiteException.toDBFlowSQLiteException() = com.raizlabs.dbflow5.database.SQLiteException("A Database Error Occurred", this) +fun SQLiteException.toDBFlowSQLiteException() = com.dbflow5.database.SQLiteException("A Database Error Occurred", this) inline fun rethrowDBFlowException(fn: () -> T) = try { fn() diff --git a/sqlcipher/src/main/kotlin/com/raizlabs/dbflow5/sqlcipher/SQLCipherOpenHelper.kt b/sqlcipher/src/main/kotlin/com/raizlabs/dbflow5/sqlcipher/SQLCipherOpenHelper.kt index bc7b524e8..bbbe3adc6 100644 --- a/sqlcipher/src/main/kotlin/com/raizlabs/dbflow5/sqlcipher/SQLCipherOpenHelper.kt +++ b/sqlcipher/src/main/kotlin/com/raizlabs/dbflow5/sqlcipher/SQLCipherOpenHelper.kt @@ -1,13 +1,13 @@ -package com.raizlabs.dbflow5.sqlcipher +package com.dbflow5.sqlcipher import android.content.Context -import com.raizlabs.dbflow5.config.DBFlowDatabase -import com.raizlabs.dbflow5.config.DatabaseConfig -import com.raizlabs.dbflow5.database.BaseDatabaseHelper -import com.raizlabs.dbflow5.database.DatabaseCallback -import com.raizlabs.dbflow5.database.DatabaseHelperDelegate -import com.raizlabs.dbflow5.database.DatabaseWrapper -import com.raizlabs.dbflow5.database.OpenHelper +import com.dbflow5.config.DBFlowDatabase +import com.dbflow5.config.DatabaseConfig +import com.dbflow5.database.BaseDatabaseHelper +import com.dbflow5.database.DatabaseCallback +import com.dbflow5.database.DatabaseHelperDelegate +import com.dbflow5.database.DatabaseWrapper +import com.dbflow5.database.OpenHelper import net.sqlcipher.database.SQLiteDatabase import net.sqlcipher.database.SQLiteOpenHelper diff --git a/sqlcipher/src/main/kotlin/com/raizlabs/dbflow5/sqlcipher/SQLCipherStatement.kt b/sqlcipher/src/main/kotlin/com/raizlabs/dbflow5/sqlcipher/SQLCipherStatement.kt index 85080f094..b2f49bb7f 100644 --- a/sqlcipher/src/main/kotlin/com/raizlabs/dbflow5/sqlcipher/SQLCipherStatement.kt +++ b/sqlcipher/src/main/kotlin/com/raizlabs/dbflow5/sqlcipher/SQLCipherStatement.kt @@ -1,7 +1,7 @@ -package com.raizlabs.dbflow5.sqlcipher +package com.dbflow5.sqlcipher -import com.raizlabs.dbflow5.database.BaseDatabaseStatement -import com.raizlabs.dbflow5.database.DatabaseStatement +import com.dbflow5.database.BaseDatabaseStatement +import com.dbflow5.database.DatabaseStatement import net.sqlcipher.database.SQLiteStatement diff --git a/tests/build.gradle b/tests/build.gradle index 9eea30da0..ac373c41c 100644 --- a/tests/build.gradle +++ b/tests/build.gradle @@ -45,11 +45,12 @@ dependencies { implementation "org.jetbrains.kotlin:kotlin-stdlib" kapt project("${dbflow_project_prefix}processor") - implementation project(':dbflow') + implementation project(':lib') implementation 'com.android.support:appcompat-v7:27.1.1' - implementation project("${dbflow_project_prefix}dbflow") + implementation project(':lib') implementation project("${dbflow_project_prefix}sqlcipher") - implementation project(':dbflow-reactive-streams') + implementation project(':reactive-streams') + implementation project(':contentprovider') implementation project("${dbflow_project_prefix}coroutines") implementation project("${dbflow_project_prefix}paging") diff --git a/tests/src/androidTest/AndroidManifest.xml b/tests/src/androidTest/AndroidManifest.xml index 0ad683537..dc312f688 100644 --- a/tests/src/androidTest/AndroidManifest.xml +++ b/tests/src/androidTest/AndroidManifest.xml @@ -1,12 +1,12 @@ + android:name="com.dbflow5.test.DemoActivity"> diff --git a/tests/src/androidTest/java/com/raizlabs/dbflow5/BaseUnitTest.kt b/tests/src/androidTest/java/com/dbflow5/BaseUnitTest.kt similarity index 84% rename from tests/src/androidTest/java/com/raizlabs/dbflow5/BaseUnitTest.kt rename to tests/src/androidTest/java/com/dbflow5/BaseUnitTest.kt index 6da4576f6..e8878a285 100644 --- a/tests/src/androidTest/java/com/raizlabs/dbflow5/BaseUnitTest.kt +++ b/tests/src/androidTest/java/com/dbflow5/BaseUnitTest.kt @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5 +package com.dbflow5 import org.junit.Rule diff --git a/tests/src/androidTest/java/com/raizlabs/dbflow5/DBFlowInstrumentedTestRule.kt b/tests/src/androidTest/java/com/dbflow5/DBFlowInstrumentedTestRule.kt similarity index 79% rename from tests/src/androidTest/java/com/raizlabs/dbflow5/DBFlowInstrumentedTestRule.kt rename to tests/src/androidTest/java/com/dbflow5/DBFlowInstrumentedTestRule.kt index 331171091..a11282528 100644 --- a/tests/src/androidTest/java/com/raizlabs/dbflow5/DBFlowInstrumentedTestRule.kt +++ b/tests/src/androidTest/java/com/dbflow5/DBFlowInstrumentedTestRule.kt @@ -1,13 +1,15 @@ -package com.raizlabs.dbflow5 +package com.dbflow5 -import com.raizlabs.dbflow5.config.DBFlowDatabase -import com.raizlabs.dbflow5.config.DatabaseConfig -import com.raizlabs.dbflow5.config.FlowConfig -import com.raizlabs.dbflow5.config.FlowManager -import com.raizlabs.dbflow5.database.AndroidSQLiteOpenHelper -import com.raizlabs.dbflow5.prepackaged.PrepackagedDB -import com.raizlabs.dbflow5.runtime.ContentResolverNotifier -import com.raizlabs.dbflow5.sqlcipher.CipherDatabase +import com.dbflow5.AppDatabase +import com.dbflow5.DemoApp +import com.dbflow5.config.DBFlowDatabase +import com.dbflow5.config.DatabaseConfig +import com.dbflow5.config.FlowConfig +import com.dbflow5.config.FlowManager +import com.dbflow5.database.AndroidSQLiteOpenHelper +import com.dbflow5.prepackaged.PrepackagedDB +import com.dbflow5.runtime.ContentResolverNotifier +import com.dbflow5.sqlcipher.CipherDatabase import org.junit.rules.TestRule import org.junit.runner.Description import org.junit.runners.model.Statement diff --git a/tests/src/androidTest/java/com/raizlabs/dbflow5/ImmediateTransactionManager.kt b/tests/src/androidTest/java/com/dbflow5/ImmediateTransactionManager.kt similarity index 73% rename from tests/src/androidTest/java/com/raizlabs/dbflow5/ImmediateTransactionManager.kt rename to tests/src/androidTest/java/com/dbflow5/ImmediateTransactionManager.kt index 76833c12d..33cec2c36 100644 --- a/tests/src/androidTest/java/com/raizlabs/dbflow5/ImmediateTransactionManager.kt +++ b/tests/src/androidTest/java/com/dbflow5/ImmediateTransactionManager.kt @@ -1,9 +1,9 @@ -package com.raizlabs.dbflow5 +package com.dbflow5 -import com.raizlabs.dbflow5.config.DBFlowDatabase -import com.raizlabs.dbflow5.transaction.BaseTransactionManager -import com.raizlabs.dbflow5.transaction.ITransactionQueue -import com.raizlabs.dbflow5.transaction.Transaction +import com.dbflow5.config.DBFlowDatabase +import com.dbflow5.transaction.BaseTransactionManager +import com.dbflow5.transaction.ITransactionQueue +import com.dbflow5.transaction.Transaction /** * Description: Executes all transactions on same thread for testing. diff --git a/tests/src/androidTest/java/com/raizlabs/dbflow5/contentobserver/ContentObserverTest.kt b/tests/src/androidTest/java/com/dbflow5/contentobserver/ContentObserverTest.kt similarity index 79% rename from tests/src/androidTest/java/com/raizlabs/dbflow5/contentobserver/ContentObserverTest.kt rename to tests/src/androidTest/java/com/dbflow5/contentobserver/ContentObserverTest.kt index b9553f2bf..4b9813407 100644 --- a/tests/src/androidTest/java/com/raizlabs/dbflow5/contentobserver/ContentObserverTest.kt +++ b/tests/src/androidTest/java/com/dbflow5/contentobserver/ContentObserverTest.kt @@ -1,23 +1,23 @@ -package com.raizlabs.dbflow5.contentobserver +package com.dbflow5.contentobserver import android.net.Uri -import com.raizlabs.dbflow5.BaseInstrumentedUnitTest -import com.raizlabs.dbflow5.DemoApp -import com.raizlabs.dbflow5.TABLE_QUERY_PARAM -import com.raizlabs.dbflow5.config.databaseForTable -import com.raizlabs.dbflow5.config.modelAdapter -import com.raizlabs.dbflow5.config.tableName -import com.raizlabs.dbflow5.contentobserver.User_Table.id -import com.raizlabs.dbflow5.contentobserver.User_Table.name -import com.raizlabs.dbflow5.getNotificationUri -import com.raizlabs.dbflow5.query.SQLOperator -import com.raizlabs.dbflow5.query.delete -import com.raizlabs.dbflow5.runtime.FlowContentObserver -import com.raizlabs.dbflow5.structure.ChangeAction -import com.raizlabs.dbflow5.structure.delete -import com.raizlabs.dbflow5.structure.insert -import com.raizlabs.dbflow5.structure.save -import com.raizlabs.dbflow5.structure.update +import com.dbflow5.BaseInstrumentedUnitTest +import com.dbflow5.DemoApp +import com.dbflow5.TABLE_QUERY_PARAM +import com.dbflow5.config.databaseForTable +import com.dbflow5.config.modelAdapter +import com.dbflow5.config.tableName +import com.dbflow5.contentobserver.User_Table.id +import com.dbflow5.contentobserver.User_Table.name +import com.dbflow5.getNotificationUri +import com.dbflow5.query.SQLOperator +import com.dbflow5.query.delete +import com.dbflow5.runtime.FlowContentObserver +import com.dbflow5.structure.ChangeAction +import com.dbflow5.structure.delete +import com.dbflow5.structure.insert +import com.dbflow5.structure.save +import com.dbflow5.structure.update import org.junit.Assert.assertEquals import org.junit.Assert.assertTrue import org.junit.Before diff --git a/tests/src/androidTest/java/com/raizlabs/dbflow5/prepackaged/PrepackagedDBTest.kt b/tests/src/androidTest/java/com/dbflow5/prepackaged/PrepackagedDBTest.kt similarity index 61% rename from tests/src/androidTest/java/com/raizlabs/dbflow5/prepackaged/PrepackagedDBTest.kt rename to tests/src/androidTest/java/com/dbflow5/prepackaged/PrepackagedDBTest.kt index ce971ff60..e781fc534 100644 --- a/tests/src/androidTest/java/com/raizlabs/dbflow5/prepackaged/PrepackagedDBTest.kt +++ b/tests/src/androidTest/java/com/dbflow5/prepackaged/PrepackagedDBTest.kt @@ -1,9 +1,9 @@ -package com.raizlabs.dbflow5.prepackaged +package com.dbflow5.prepackaged -import com.raizlabs.dbflow5.BaseInstrumentedUnitTest -import com.raizlabs.dbflow5.config.databaseForTable -import com.raizlabs.dbflow5.query.list -import com.raizlabs.dbflow5.query.select +import com.dbflow5.BaseInstrumentedUnitTest +import com.dbflow5.config.databaseForTable +import com.dbflow5.query.list +import com.dbflow5.query.select import org.junit.Assert.assertTrue import org.junit.Test diff --git a/tests/src/androidTest/java/com/raizlabs/dbflow5/sqlcipher/CipherTest.kt b/tests/src/androidTest/java/com/dbflow5/sqlcipher/CipherTest.kt similarity index 70% rename from tests/src/androidTest/java/com/raizlabs/dbflow5/sqlcipher/CipherTest.kt rename to tests/src/androidTest/java/com/dbflow5/sqlcipher/CipherTest.kt index 42e4d160c..35b31ce05 100644 --- a/tests/src/androidTest/java/com/raizlabs/dbflow5/sqlcipher/CipherTest.kt +++ b/tests/src/androidTest/java/com/dbflow5/sqlcipher/CipherTest.kt @@ -1,10 +1,10 @@ -package com.raizlabs.dbflow5.sqlcipher +package com.dbflow5.sqlcipher -import com.raizlabs.dbflow5.BaseInstrumentedUnitTest -import com.raizlabs.dbflow5.config.database -import com.raizlabs.dbflow5.query.delete -import com.raizlabs.dbflow5.query.result -import com.raizlabs.dbflow5.query.select +import com.dbflow5.BaseInstrumentedUnitTest +import com.dbflow5.config.database +import com.dbflow5.query.delete +import com.dbflow5.query.result +import com.dbflow5.query.select import org.junit.Assert.assertTrue import org.junit.Test diff --git a/tests/src/main/AndroidManifest.xml b/tests/src/main/AndroidManifest.xml index 8cc416cf4..2de105f2c 100644 --- a/tests/src/main/AndroidManifest.xml +++ b/tests/src/main/AndroidManifest.xml @@ -1,18 +1,18 @@ + android:name="com.dbflow5.test.DemoActivity"> @@ -21,7 +21,7 @@ diff --git a/tests/src/main/java/com/dbflow5/AppDatabase.kt b/tests/src/main/java/com/dbflow5/AppDatabase.kt new file mode 100644 index 000000000..74df036f7 --- /dev/null +++ b/tests/src/main/java/com/dbflow5/AppDatabase.kt @@ -0,0 +1,7 @@ +package com.dbflow5 + +import com.dbflow5.annotation.Database +import com.dbflow5.config.DBFlowDatabase + +@Database(version = 1) +abstract class AppDatabase : DBFlowDatabase() \ No newline at end of file diff --git a/tests/src/main/java/com/raizlabs/dbflow5/DemoApp.kt b/tests/src/main/java/com/dbflow5/DemoApp.kt similarity index 91% rename from tests/src/main/java/com/raizlabs/dbflow5/DemoApp.kt rename to tests/src/main/java/com/dbflow5/DemoApp.kt index b5e8b375b..72a768215 100644 --- a/tests/src/main/java/com/raizlabs/dbflow5/DemoApp.kt +++ b/tests/src/main/java/com/dbflow5/DemoApp.kt @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5 +package com.dbflow5 import android.annotation.SuppressLint import android.app.Application diff --git a/tests/src/main/java/com/raizlabs/dbflow5/StubContentProvider.kt b/tests/src/main/java/com/dbflow5/StubContentProvider.kt similarity index 97% rename from tests/src/main/java/com/raizlabs/dbflow5/StubContentProvider.kt rename to tests/src/main/java/com/dbflow5/StubContentProvider.kt index 56589c445..170837eae 100644 --- a/tests/src/main/java/com/raizlabs/dbflow5/StubContentProvider.kt +++ b/tests/src/main/java/com/dbflow5/StubContentProvider.kt @@ -1,4 +1,4 @@ -package com.raizlabs.dbflow5 +package com.dbflow5 import android.content.ContentProvider import android.content.ContentValues diff --git a/tests/src/main/java/com/raizlabs/dbflow5/User.kt b/tests/src/main/java/com/dbflow5/User.kt similarity index 58% rename from tests/src/main/java/com/raizlabs/dbflow5/User.kt rename to tests/src/main/java/com/dbflow5/User.kt index 7f417004e..7b541767e 100644 --- a/tests/src/main/java/com/raizlabs/dbflow5/User.kt +++ b/tests/src/main/java/com/dbflow5/User.kt @@ -1,8 +1,8 @@ -package com.raizlabs.dbflow5 +package com.dbflow5 -import com.raizlabs.dbflow5.annotation.Column -import com.raizlabs.dbflow5.annotation.PrimaryKey -import com.raizlabs.dbflow5.annotation.Table +import com.dbflow5.annotation.Column +import com.dbflow5.annotation.PrimaryKey +import com.dbflow5.annotation.Table @Table(database = AppDatabase::class, name = "User2") class User(@PrimaryKey var id: Int = 0, diff --git a/tests/src/main/java/com/dbflow5/contentobserver/User.kt b/tests/src/main/java/com/dbflow5/contentobserver/User.kt new file mode 100644 index 000000000..a1a4cabb2 --- /dev/null +++ b/tests/src/main/java/com/dbflow5/contentobserver/User.kt @@ -0,0 +1,9 @@ +package com.dbflow5.contentobserver + +import com.dbflow5.AppDatabase +import com.dbflow5.annotation.Column +import com.dbflow5.annotation.PrimaryKey +import com.dbflow5.annotation.Table + +@Table(database = AppDatabase::class) +class User(@PrimaryKey var id: Int = 0, @PrimaryKey var name: String = "", @Column var age: Int = 0) \ No newline at end of file diff --git a/tests/src/main/java/com/dbflow5/prepackaged/PrepackagedDB.kt b/tests/src/main/java/com/dbflow5/prepackaged/PrepackagedDB.kt new file mode 100644 index 000000000..46f975d55 --- /dev/null +++ b/tests/src/main/java/com/dbflow5/prepackaged/PrepackagedDB.kt @@ -0,0 +1,24 @@ +package com.dbflow5.prepackaged + +import com.dbflow5.annotation.Column +import com.dbflow5.annotation.Database +import com.dbflow5.annotation.PrimaryKey +import com.dbflow5.annotation.Table +import com.dbflow5.config.DBFlowDatabase +import com.dbflow5.structure.BaseModel + +@Database(version = 1) +abstract class PrepackagedDB : DBFlowDatabase() + +@Table(database = PrepackagedDB::class, allFields = true) +class Dog : BaseModel() { + + @PrimaryKey + var id: Int = 0 + + @Column + var breed: String? = null + + @Column + var color: String? = null +} \ No newline at end of file diff --git a/tests/src/main/java/com/dbflow5/sqlcipher/CipherDatabase.kt b/tests/src/main/java/com/dbflow5/sqlcipher/CipherDatabase.kt new file mode 100644 index 000000000..fe1712e86 --- /dev/null +++ b/tests/src/main/java/com/dbflow5/sqlcipher/CipherDatabase.kt @@ -0,0 +1,7 @@ +package com.dbflow5.sqlcipher + +import com.dbflow5.annotation.Database +import com.dbflow5.config.DBFlowDatabase + +@Database(version = 1) +abstract class CipherDatabase : DBFlowDatabase() \ No newline at end of file diff --git a/tests/src/main/java/com/raizlabs/dbflow5/sqlcipher/CipherTestObjects.kt b/tests/src/main/java/com/dbflow5/sqlcipher/CipherTestObjects.kt similarity index 60% rename from tests/src/main/java/com/raizlabs/dbflow5/sqlcipher/CipherTestObjects.kt rename to tests/src/main/java/com/dbflow5/sqlcipher/CipherTestObjects.kt index 17d70bd00..424422b22 100644 --- a/tests/src/main/java/com/raizlabs/dbflow5/sqlcipher/CipherTestObjects.kt +++ b/tests/src/main/java/com/dbflow5/sqlcipher/CipherTestObjects.kt @@ -1,12 +1,12 @@ -package com.raizlabs.dbflow5.sqlcipher +package com.dbflow5.sqlcipher import android.content.Context -import com.raizlabs.dbflow5.annotation.Column -import com.raizlabs.dbflow5.annotation.PrimaryKey -import com.raizlabs.dbflow5.annotation.Table -import com.raizlabs.dbflow5.config.DBFlowDatabase -import com.raizlabs.dbflow5.database.DatabaseCallback -import com.raizlabs.dbflow5.structure.BaseModel +import com.dbflow5.annotation.Column +import com.dbflow5.annotation.PrimaryKey +import com.dbflow5.annotation.Table +import com.dbflow5.config.DBFlowDatabase +import com.dbflow5.database.DatabaseCallback +import com.dbflow5.structure.BaseModel class SQLCipherOpenHelperImpl(context: Context, databaseDefinition: DBFlowDatabase, diff --git a/tests/src/main/java/com/raizlabs/dbflow5/test/DemoActivity.java b/tests/src/main/java/com/dbflow5/test/DemoActivity.java similarity index 63% rename from tests/src/main/java/com/raizlabs/dbflow5/test/DemoActivity.java rename to tests/src/main/java/com/dbflow5/test/DemoActivity.java index 23d0e193d..55c51f254 100644 --- a/tests/src/main/java/com/raizlabs/dbflow5/test/DemoActivity.java +++ b/tests/src/main/java/com/dbflow5/test/DemoActivity.java @@ -1,15 +1,16 @@ -package com.raizlabs.dbflow5.test; +package com.dbflow5.test; import android.app.Activity; import android.os.Bundle; import android.view.Menu; import android.view.MenuItem; -import com.raizlabs.dbflow5.config.DatabaseConfig; -import com.raizlabs.dbflow5.config.FlowConfig; -import com.raizlabs.dbflow5.config.FlowManager; -import com.raizlabs.dbflow5.database.AndroidSQLiteOpenHelper; -import com.raizlabs.dbflow5.prepackaged.PrepackagedDB; +import com.dbflow5.config.DatabaseConfig; +import com.dbflow5.config.FlowConfig; +import com.dbflow5.config.FlowManager; +import com.dbflow5.database.AndroidSQLiteOpenHelper; +import com.dbflow5.prepackaged.PrepackagedDB; +import com.dbflow5.test.R; public class DemoActivity extends Activity { @@ -20,12 +21,12 @@ protected void onCreate(Bundle savedInstanceState) { setContentView(R.layout.activity_demo); FlowManager.init(new FlowConfig.Builder(getApplicationContext()) - .database( - DatabaseConfig.builder(PrepackagedDB.class, - (dbFlowDatabase, databaseHelperListener) -> new AndroidSQLiteOpenHelper(getApplicationContext(), dbFlowDatabase, databaseHelperListener)) - .databaseName("prepackaged") - .build()) - .build()); + .database(DatabaseConfig.builder(PrepackagedDB.class, + (dbFlowDatabase, databaseHelperListener) -> + new AndroidSQLiteOpenHelper(getApplicationContext(), dbFlowDatabase, databaseHelperListener)) + .databaseName("prepackaged") + .build()) + .build()); } diff --git a/tests/src/main/java/com/raizlabs/dbflow5/AppDatabase.kt b/tests/src/main/java/com/raizlabs/dbflow5/AppDatabase.kt deleted file mode 100644 index 7770d693e..000000000 --- a/tests/src/main/java/com/raizlabs/dbflow5/AppDatabase.kt +++ /dev/null @@ -1,7 +0,0 @@ -package com.raizlabs.dbflow5 - -import com.raizlabs.dbflow5.annotation.Database -import com.raizlabs.dbflow5.config.DBFlowDatabase - -@Database(version = 1) -abstract class AppDatabase : DBFlowDatabase() \ No newline at end of file diff --git a/tests/src/main/java/com/raizlabs/dbflow5/contentobserver/User.kt b/tests/src/main/java/com/raizlabs/dbflow5/contentobserver/User.kt deleted file mode 100644 index 643625529..000000000 --- a/tests/src/main/java/com/raizlabs/dbflow5/contentobserver/User.kt +++ /dev/null @@ -1,9 +0,0 @@ -package com.raizlabs.dbflow5.contentobserver - -import com.raizlabs.dbflow5.AppDatabase -import com.raizlabs.dbflow5.annotation.Column -import com.raizlabs.dbflow5.annotation.PrimaryKey -import com.raizlabs.dbflow5.annotation.Table - -@Table(database = AppDatabase::class) -class User(@PrimaryKey var id: Int = 0, @PrimaryKey var name: String = "", @Column var age: Int = 0) \ No newline at end of file diff --git a/tests/src/main/java/com/raizlabs/dbflow5/prepackaged/PrepackagedDB.kt b/tests/src/main/java/com/raizlabs/dbflow5/prepackaged/PrepackagedDB.kt deleted file mode 100644 index 45e7f03fa..000000000 --- a/tests/src/main/java/com/raizlabs/dbflow5/prepackaged/PrepackagedDB.kt +++ /dev/null @@ -1,24 +0,0 @@ -package com.raizlabs.dbflow5.prepackaged - -import com.raizlabs.dbflow5.annotation.Column -import com.raizlabs.dbflow5.annotation.Database -import com.raizlabs.dbflow5.annotation.PrimaryKey -import com.raizlabs.dbflow5.annotation.Table -import com.raizlabs.dbflow5.config.DBFlowDatabase -import com.raizlabs.dbflow5.structure.BaseModel - -@Database(version = 1) -abstract class PrepackagedDB : DBFlowDatabase() - -@Table(database = PrepackagedDB::class, allFields = true) -class Dog : BaseModel() { - - @PrimaryKey - var id: Int = 0 - - @Column - var breed: String? = null - - @Column - var color: String? = null -} \ No newline at end of file diff --git a/tests/src/main/java/com/raizlabs/dbflow5/sqlcipher/CipherDatabase.kt b/tests/src/main/java/com/raizlabs/dbflow5/sqlcipher/CipherDatabase.kt deleted file mode 100644 index 8bf9d547b..000000000 --- a/tests/src/main/java/com/raizlabs/dbflow5/sqlcipher/CipherDatabase.kt +++ /dev/null @@ -1,7 +0,0 @@ -package com.raizlabs.dbflow5.sqlcipher - -import com.raizlabs.dbflow5.annotation.Database -import com.raizlabs.dbflow5.config.DBFlowDatabase - -@Database(version = 1) -abstract class CipherDatabase : DBFlowDatabase() \ No newline at end of file diff --git a/tests/src/main/res/layout/activity_demo.xml b/tests/src/main/res/layout/activity_demo.xml index a097220b6..313157d13 100644 --- a/tests/src/main/res/layout/activity_demo.xml +++ b/tests/src/main/res/layout/activity_demo.xml @@ -6,7 +6,7 @@ android:paddingRight="@dimen/activity_horizontal_margin" android:paddingTop="@dimen/activity_vertical_margin" android:paddingBottom="@dimen/activity_vertical_margin" - tools:context="com.raizlabs.dbflow5.test.DemoActivity"> + tools:context="com.dbflow5.test.DemoActivity"> + tools:context="com.dbflow5.DemoActivity"> - + diff --git a/tests/src/test/java/com/raizlabs/dbflow5/BaseUnitTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/BaseUnitTest.kt deleted file mode 100644 index 3f960b816..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/BaseUnitTest.kt +++ /dev/null @@ -1,20 +0,0 @@ -package com.raizlabs.dbflow5 - -import android.content.Context -import org.junit.Rule -import org.junit.runner.RunWith -import org.robolectric.RobolectricTestRunner -import org.robolectric.RuntimeEnvironment -import org.robolectric.annotation.Config - -@RunWith(RobolectricTestRunner::class) -@Config(manifest = Config.NONE) -abstract class BaseUnitTest { - - @JvmField - @Rule - var dblflowTestRule = DBFlowTestRule.create() - - val context: Context - get() = RuntimeEnvironment.application -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/DBFlowTestRule.kt b/tests/src/test/java/com/raizlabs/dbflow5/DBFlowTestRule.kt deleted file mode 100644 index a546c7397..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/DBFlowTestRule.kt +++ /dev/null @@ -1,49 +0,0 @@ -package com.raizlabs.dbflow5 - -import android.content.Context -import com.raizlabs.dbflow5.config.DatabaseConfig -import com.raizlabs.dbflow5.config.FlowConfig -import com.raizlabs.dbflow5.config.FlowLog -import com.raizlabs.dbflow5.config.FlowManager -import com.raizlabs.dbflow5.database.AndroidSQLiteOpenHelper -import com.raizlabs.dbflow5.provider.ContentDatabase -import com.raizlabs.dbflow5.runtime.DirectModelNotifier -import org.junit.rules.TestRule -import org.junit.runner.Description -import org.junit.runners.model.Statement -import org.robolectric.RuntimeEnvironment - -class DBFlowTestRule : TestRule { - - val context: Context - get() = RuntimeEnvironment.application - - override fun apply(base: Statement, description: Description): Statement { - return object : Statement() { - - @Throws(Throwable::class) - override fun evaluate() { - FlowLog.setMinimumLoggingLevel(FlowLog.Level.V) - DirectModelNotifier().clearListeners() - FlowManager.init(FlowConfig.Builder(RuntimeEnvironment.application) - .database(DatabaseConfig.Builder(TestDatabase::class, AndroidSQLiteOpenHelper.createHelperCreator(context)) - .transactionManagerCreator(::ImmediateTransactionManager2) - .build()) - .database(DatabaseConfig.builder(ContentDatabase::class, - AndroidSQLiteOpenHelper.createHelperCreator(context)) - .databaseName("content") - .build()) - .build()) - try { - base.evaluate() - } finally { - FlowManager.destroy() - } - } - } - } - - companion object { - fun create() = DBFlowTestRule() - } -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/ImmediateTransactionManager.kt b/tests/src/test/java/com/raizlabs/dbflow5/ImmediateTransactionManager.kt deleted file mode 100644 index 4c75ba653..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/ImmediateTransactionManager.kt +++ /dev/null @@ -1,37 +0,0 @@ -package com.raizlabs.dbflow5 - -import com.raizlabs.dbflow5.config.DBFlowDatabase -import com.raizlabs.dbflow5.transaction.BaseTransactionManager -import com.raizlabs.dbflow5.transaction.ITransactionQueue -import com.raizlabs.dbflow5.transaction.Transaction - -/** - * Description: Executes all transactions on same thread for testing. - */ -class ImmediateTransactionManager2(databaseDefinition: DBFlowDatabase) - : BaseTransactionManager(ImmediateTransactionQueue2(), databaseDefinition) - - -class ImmediateTransactionQueue2 : ITransactionQueue { - - override fun add(transaction: Transaction) { - transaction.newBuilder() - .runCallbacksOnSameThread(true) - .build() - .executeSync() - } - - override fun cancel(transaction: Transaction) { - - } - - override fun startIfNotAlive() { - } - - override fun cancel(name: String) { - } - - override fun quit() { - } - -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/TestDatabase.kt b/tests/src/test/java/com/raizlabs/dbflow5/TestDatabase.kt deleted file mode 100644 index b07cc5a55..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/TestDatabase.kt +++ /dev/null @@ -1,18 +0,0 @@ -package com.raizlabs.dbflow5 - -import com.raizlabs.dbflow5.annotation.Database -import com.raizlabs.dbflow5.annotation.Migration -import com.raizlabs.dbflow5.config.DBFlowDatabase -import com.raizlabs.dbflow5.migration.UpdateTableMigration -import com.raizlabs.dbflow5.models.SimpleModel - -/** - * Description: - */ -@Database(version = 1) -abstract class TestDatabase : DBFlowDatabase() { - - @Migration(version = 1, database = TestDatabase::class) - class TestMigration : UpdateTableMigration(SimpleModel::class.java) - -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/TestExtensions.kt b/tests/src/test/java/com/raizlabs/dbflow5/TestExtensions.kt deleted file mode 100644 index 4171499de..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/TestExtensions.kt +++ /dev/null @@ -1,23 +0,0 @@ -package com.raizlabs.dbflow5 - -import com.raizlabs.dbflow5.sql.Query -import org.junit.Assert.assertEquals -import org.junit.Assert.fail -import kotlin.reflect.KClass - - -fun String.assertEquals(query: Query) = assertEquals(this, query.query.trim()) - -fun Query.assertEquals(actual: Query) = assertEquals(query.trim(), actual.query.trim()) - -fun assertThrowsException(expectedException: KClass, function: () -> Unit) { - try { - function() - fail("Expected call to fail. Unexpectedly passed") - } catch (e: Exception) { - if (e.javaClass != expectedException.java) { - e.printStackTrace() - fail("Expected $expectedException but got ${e.javaClass}") - } - } -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/config/ConfigIntegrationTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/config/ConfigIntegrationTest.kt deleted file mode 100644 index e1c3f6d52..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/config/ConfigIntegrationTest.kt +++ /dev/null @@ -1,80 +0,0 @@ -package com.raizlabs.dbflow5.config - -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.TestDatabase -import com.raizlabs.dbflow5.adapter.queriable.ListModelLoader -import com.raizlabs.dbflow5.adapter.queriable.SingleModelLoader -import com.raizlabs.dbflow5.adapter.saveable.ModelSaver -import com.raizlabs.dbflow5.database.AndroidSQLiteOpenHelper -import com.raizlabs.dbflow5.models.SimpleModel -import org.junit.Assert.assertEquals -import org.junit.Assert.assertNotNull -import org.junit.Assert.assertTrue -import org.junit.Before -import org.junit.Test - -/** - * Description: - */ -class ConfigIntegrationTest : BaseUnitTest() { - - private lateinit var builder: FlowConfig.Builder - - @Before - fun setup() { - FlowManager.reset() - FlowLog.setMinimumLoggingLevel(FlowLog.Level.V) - builder = FlowConfig.Builder(context) - } - - - @Test - fun test_flowConfig() { - val config = builder - .openDatabasesOnInit(true) - .build() - assertEquals(config.openDatabasesOnInit, true) - assertTrue(config.databaseConfigMap.isEmpty()) - assertTrue(config.databaseHolders.isEmpty()) - } - - @Test - fun test_tableConfig() { - - val customListModelLoader = ListModelLoader(SimpleModel::class.java) - val singleModelLoader = SingleModelLoader(SimpleModel::class.java) - val modelSaver = ModelSaver() - - FlowManager.init(builder - .database(DatabaseConfig.Builder(TestDatabase::class.java, - AndroidSQLiteOpenHelper.createHelperCreator(context)) - .addTableConfig(TableConfig.Builder(SimpleModel::class.java) - .singleModelLoader(singleModelLoader) - .listModelLoader(customListModelLoader) - .modelAdapterModelSaver(modelSaver) - .build()) - .build()) - .build()) - - val flowConfig = FlowManager.getConfig() - assertNotNull(flowConfig) - - val databaseConfig = flowConfig.databaseConfigMap[TestDatabase::class.java] as DatabaseConfig - assertNotNull(databaseConfig) - - - val config = databaseConfig.tableConfigMap[SimpleModel::class.java] as TableConfig - assertNotNull(config) - - assertEquals(config.listModelLoader, customListModelLoader) - assertEquals(config.singleModelLoader, singleModelLoader) - - val modelAdapter = SimpleModel::class.modelAdapter - assertEquals(modelAdapter.listModelLoader, customListModelLoader) - assertEquals(modelAdapter.singleModelLoader, singleModelLoader) - assertEquals(modelAdapter.modelSaver, modelSaver) - } - -} - - diff --git a/tests/src/test/java/com/raizlabs/dbflow5/config/DatabaseConfigTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/config/DatabaseConfigTest.kt deleted file mode 100644 index e27f1ce01..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/config/DatabaseConfigTest.kt +++ /dev/null @@ -1,88 +0,0 @@ -package com.raizlabs.dbflow5.config - -import com.nhaarman.mockito_kotlin.mock -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.TestDatabase -import com.raizlabs.dbflow5.database.AndroidSQLiteOpenHelper -import com.raizlabs.dbflow5.database.DatabaseCallback -import com.raizlabs.dbflow5.database.OpenHelper -import com.raizlabs.dbflow5.transaction.BaseTransactionManager -import org.junit.Assert -import org.junit.Before -import org.junit.Test - - -/** - * Description: - */ -class DatabaseConfigTest : BaseUnitTest() { - - private lateinit var builder: FlowConfig.Builder - - @Before - fun setup() { - FlowManager.reset() - FlowLog.setMinimumLoggingLevel(FlowLog.Level.V) - builder = FlowConfig.Builder(context) - } - - @Test - fun test_databaseConfig() { - - val helperListener = mock() - val customOpenHelper = mock() - - val openHelperCreator: ((DBFlowDatabase, DatabaseCallback?) -> OpenHelper) = { _, _ -> - customOpenHelper - } - var testTransactionManager: TestTransactionManager? = null - val managerCreator: (DBFlowDatabase) -> BaseTransactionManager = { databaseDefinition -> - testTransactionManager = TestTransactionManager(databaseDefinition) - testTransactionManager!! - } - - FlowManager.init(builder - .database(DatabaseConfig.Builder(TestDatabase::class.java, openHelperCreator) - .databaseName("Test") - .helperListener(helperListener) - .transactionManagerCreator(managerCreator) - .build()) - .build()) - - val flowConfig = FlowManager.getConfig() - Assert.assertNotNull(flowConfig) - - val databaseConfig = flowConfig.databaseConfigMap[TestDatabase::class.java]!! - Assert.assertEquals("Test", databaseConfig.databaseName) - Assert.assertEquals(".db", databaseConfig.databaseExtensionName) - Assert.assertEquals(databaseConfig.transactionManagerCreator, managerCreator) - Assert.assertEquals(databaseConfig.databaseClass, TestDatabase::class.java) - Assert.assertEquals(databaseConfig.openHelperCreator, openHelperCreator) - Assert.assertEquals(databaseConfig.callback, helperListener) - Assert.assertTrue(databaseConfig.tableConfigMap.isEmpty()) - - - val databaseDefinition = database() - Assert.assertEquals(databaseDefinition.transactionManager, testTransactionManager) - Assert.assertEquals(databaseDefinition.openHelper, customOpenHelper) - } - - @Test - fun test_EmptyName() { - FlowManager.init(builder - .database(DatabaseConfig.Builder(TestDatabase::class.java, - AndroidSQLiteOpenHelper.createHelperCreator(context)) - .databaseName("Test") - .extensionName("") - .build()) - .build()) - - val databaseConfig = FlowManager.getConfig().databaseConfigMap[TestDatabase::class.java]!! - Assert.assertEquals("Test", databaseConfig.databaseName) - Assert.assertEquals("", databaseConfig.databaseExtensionName) - } - -} - -class TestTransactionManager(databaseDefinition: DBFlowDatabase) - : BaseTransactionManager(mock(), databaseDefinition) \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/database/transaction/CoroutinesTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/database/transaction/CoroutinesTest.kt deleted file mode 100644 index 02632963d..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/database/transaction/CoroutinesTest.kt +++ /dev/null @@ -1,93 +0,0 @@ -package com.raizlabs.dbflow5.database.transaction - -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.TestDatabase -import com.raizlabs.dbflow5.config.database -import com.raizlabs.dbflow5.coroutines.awaitDelete -import com.raizlabs.dbflow5.coroutines.awaitInsert -import com.raizlabs.dbflow5.coroutines.awaitSave -import com.raizlabs.dbflow5.coroutines.awaitTransact -import com.raizlabs.dbflow5.coroutines.awaitUpdate -import com.raizlabs.dbflow5.models.SimpleModel -import com.raizlabs.dbflow5.models.SimpleModel_Table -import com.raizlabs.dbflow5.models.TwoColumnModel -import com.raizlabs.dbflow5.models.TwoColumnModel_Table -import com.raizlabs.dbflow5.query.delete -import com.raizlabs.dbflow5.query.list -import com.raizlabs.dbflow5.query.select -import com.raizlabs.dbflow5.structure.save -import kotlinx.coroutines.experimental.runBlocking -import org.junit.Test - -/** - * Description: - */ -class CoroutinesTest : BaseUnitTest() { - - @Test - fun testTransact() { - runBlocking { - database { - (0..9).forEach { - SimpleModel("$it").save() - } - - val query = awaitTransact( - select from SimpleModel::class - where SimpleModel_Table.name.eq("5")) { list } - - assert(query.size == 1) - - - val result = awaitTransact( - delete() - where SimpleModel_Table.name.eq("5")) { executeUpdateDelete(this@database) } - assert(result == 1L) - } - } - } - - @Test - fun testAwaitSaveAndDelete() { - runBlocking { - database { - val simpleModel = SimpleModel("Name") - val result = simpleModel.awaitSave(this) - assert(result) - - assert(simpleModel.awaitDelete(this)) - } - } - } - - @Test - fun testAwaitInsertAndDelete() { - runBlocking { - database { - val simpleModel = SimpleModel("Name") - val result = simpleModel.awaitInsert(this) - assert(result > 0) - assert(simpleModel.awaitDelete(this)) - } - } - } - - @Test - fun testAwaitUpdate() { - runBlocking { - database { - val simpleModel = TwoColumnModel(name = "Name", id = 5) - val result = simpleModel.awaitSave(this) - assert(result) - - simpleModel.id = 5 - val updated = simpleModel.awaitUpdate(this) - assert(updated) - - val loadedModel = awaitTransact(select from TwoColumnModel::class - where TwoColumnModel_Table.id.eq(5)) { querySingle(this@database) } - assert(loadedModel?.id == 5) - } - } - } -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/database/transaction/FastStoreModelTransactionTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/database/transaction/FastStoreModelTransactionTest.kt deleted file mode 100644 index eaf83dccb..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/database/transaction/FastStoreModelTransactionTest.kt +++ /dev/null @@ -1,64 +0,0 @@ -package com.raizlabs.dbflow5.database.transaction - -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.TestDatabase -import com.raizlabs.dbflow5.config.database -import com.raizlabs.dbflow5.models.SimpleModel -import com.raizlabs.dbflow5.models.TwoColumnModel -import com.raizlabs.dbflow5.coroutines.awaitInsert -import com.raizlabs.dbflow5.coroutines.awaitSave -import com.raizlabs.dbflow5.coroutines.awaitUpdate -import com.raizlabs.dbflow5.query.list -import com.raizlabs.dbflow5.query.select -import kotlinx.coroutines.experimental.runBlocking -import org.junit.Assert.assertEquals -import org.junit.Assert.assertNotEquals -import org.junit.Test -import java.util.* - -class FastStoreModelTransactionTest : BaseUnitTest() { - - @Test - fun testSaveBuilder() { - runBlocking { - database(TestDatabase::class) { - val result = (0..9) - .map { SimpleModel("$it") }.awaitSave(this) - val list = (select from SimpleModel::class).list - assertEquals(10, list.size) - assertEquals(10L, result) - } - } - } - - @Test - fun testInsertBuilder() { - runBlocking { - database(TestDatabase::class) { - val result = (0..9) - .map { SimpleModel("$it") }.awaitInsert(this) - val list = (select from SimpleModel::class).list - assertEquals(10, list.size) - assertEquals(10L, result) - } - } - } - - @Test - fun testUpdateBuilder() { - runBlocking { - database(TestDatabase::class) { - val oldList = (0..9).map { TwoColumnModel("$it", Random().nextInt()) } - oldList.awaitInsert(this) - - (0..9).map { TwoColumnModel("$it", Random().nextInt()) }.awaitUpdate(this) - - val list = (select from TwoColumnModel::class).list - assertEquals(10, list.size) - list.forEachIndexed { index, model -> - assertNotEquals(model, oldList[index]) - } - } - } - } -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/migration/UpdateTableMigrationTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/migration/UpdateTableMigrationTest.kt deleted file mode 100644 index f31196a1f..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/migration/UpdateTableMigrationTest.kt +++ /dev/null @@ -1,22 +0,0 @@ -package com.raizlabs.dbflow5.migration - -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.config.databaseForTable -import com.raizlabs.dbflow5.models.SimpleModel -import com.raizlabs.dbflow5.models.SimpleModel_Table -import org.junit.Test - -/** - * Description: - */ - -class UpdateTableMigrationTest : BaseUnitTest() { - - - @Test - fun testUpdateMigrationQuery() { - val update = UpdateTableMigration(SimpleModel::class.java) - update.set(SimpleModel_Table.name.eq("yes")) - update.migrate(databaseForTable()) - } -} diff --git a/tests/src/test/java/com/raizlabs/dbflow5/models/AutoIncrementTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/models/AutoIncrementTest.kt deleted file mode 100644 index 2b9c465be..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/models/AutoIncrementTest.kt +++ /dev/null @@ -1,33 +0,0 @@ -package com.raizlabs.dbflow5.models - -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.TestDatabase -import com.raizlabs.dbflow5.annotation.PrimaryKey -import com.raizlabs.dbflow5.annotation.Table -import com.raizlabs.dbflow5.structure.insert -import org.junit.Assert.assertEquals -import org.junit.Test - -/** - * Description: - */ -class AutoIncrementTest : BaseUnitTest() { - - @Test - fun testCanInsertAutoIncrement() { - val model = AutoIncrementingModel() - model.insert() - assertEquals(1L, model.id) - } - - @Test - fun testCanInsertExistingIdAutoIncrement() { - val model = AutoIncrementingModel(3) - model.insert() - assertEquals(3L, model.id) - } -} - - -@Table(database = TestDatabase::class) -class AutoIncrementingModel(@PrimaryKey(autoincrement = true) var id: Long = 0) \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/models/CachingModels.kt b/tests/src/test/java/com/raizlabs/dbflow5/models/CachingModels.kt deleted file mode 100644 index 947ceff5a..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/models/CachingModels.kt +++ /dev/null @@ -1,30 +0,0 @@ -package com.raizlabs.dbflow5.models - -import com.raizlabs.dbflow5.TestDatabase -import com.raizlabs.dbflow5.annotation.Column -import com.raizlabs.dbflow5.annotation.ForeignKey -import com.raizlabs.dbflow5.annotation.MultiCacheField -import com.raizlabs.dbflow5.annotation.PrimaryKey -import com.raizlabs.dbflow5.annotation.Table -import com.raizlabs.dbflow5.query.cache.IMultiKeyCacheConverter - -@Table(database = TestDatabase::class, cachingEnabled = true) -class SimpleCacheObject(@PrimaryKey var id: String = "") - -@Table(database = TestDatabase::class, cachingEnabled = true) -class Coordinate(@PrimaryKey var latitude: Double = 0.0, - @PrimaryKey var longitude: Double = 0.0, - @ForeignKey var path: Path? = null) { - - companion object { - @JvmField - @MultiCacheField - val cacheConverter = object : IMultiKeyCacheConverter { - override fun getCachingKey(values: Array) = "${values[0]},${values[1]}" - } - } -} - -@Table(database = TestDatabase::class) -class Path(@PrimaryKey var id: String = "", - @Column var name: String = "") \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/models/CachingModelsTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/models/CachingModelsTest.kt deleted file mode 100644 index 3a6e2fb11..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/models/CachingModelsTest.kt +++ /dev/null @@ -1,51 +0,0 @@ -package com.raizlabs.dbflow5.models - -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.TestDatabase -import com.raizlabs.dbflow5.config.database -import com.raizlabs.dbflow5.query.list -import com.raizlabs.dbflow5.query.result -import com.raizlabs.dbflow5.query.select -import com.raizlabs.dbflow5.structure.save -import org.junit.Assert.assertEquals -import org.junit.Assert.assertNotEquals -import org.junit.Test - -/** - * Description: Tests to ensure caching works as expected. - */ -class CachingModelsTest : BaseUnitTest() { - - @Test - fun testSimpleCache() = database(TestDatabase::class) { - val list = arrayListOf() - (0..9).forEach { - val simpleCacheObject = SimpleCacheObject("$it") - simpleCacheObject.save() - list += simpleCacheObject - } - - val loadedList = (select from SimpleCacheObject::class).list - - loadedList.forEachIndexed { index, simpleCacheObject -> - assertEquals(list[index], simpleCacheObject) - } - } - - @Test - fun testComplexObject() = database(TestDatabase::class) { - val path = Path("1", "Path") - path.save() - - val coordinate = Coordinate(40.5, 84.0, path) - coordinate.save() - - val oldPath = coordinate.path - - val loadedCoordinate = (select from Coordinate::class).result!! - assertEquals(coordinate, loadedCoordinate) - - // we want to ensure relationships reloaded. - assertNotEquals(oldPath, loadedCoordinate.path) - } -} diff --git a/tests/src/test/java/com/raizlabs/dbflow5/models/DontCreateModelTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/models/DontCreateModelTest.kt deleted file mode 100644 index e11dcb67d..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/models/DontCreateModelTest.kt +++ /dev/null @@ -1,24 +0,0 @@ -package com.raizlabs.dbflow5.models - -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.assertThrowsException -import com.raizlabs.dbflow5.config.databaseForTable -import com.raizlabs.dbflow5.database.SQLiteException -import com.raizlabs.dbflow5.query.list -import com.raizlabs.dbflow5.query.select -import org.junit.Test - -/** - * Description: - */ -class DontCreateModelTest : BaseUnitTest() { - - @Test - fun testModelNotCreated() { - databaseForTable { - assertThrowsException(SQLiteException::class) { - (select from DontCreateModel::class).list - } - } - } -} diff --git a/tests/src/test/java/com/raizlabs/dbflow5/models/ForeignKeyModels.kt b/tests/src/test/java/com/raizlabs/dbflow5/models/ForeignKeyModels.kt deleted file mode 100644 index c41578117..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/models/ForeignKeyModels.kt +++ /dev/null @@ -1,112 +0,0 @@ -package com.raizlabs.dbflow5.models - -import com.raizlabs.dbflow5.TestDatabase -import com.raizlabs.dbflow5.annotation.Column -import com.raizlabs.dbflow5.annotation.ColumnMap -import com.raizlabs.dbflow5.annotation.ColumnMapReference -import com.raizlabs.dbflow5.annotation.ConflictAction -import com.raizlabs.dbflow5.annotation.ForeignKey -import com.raizlabs.dbflow5.annotation.ForeignKeyAction -import com.raizlabs.dbflow5.annotation.ForeignKeyReference -import com.raizlabs.dbflow5.annotation.NotNull -import com.raizlabs.dbflow5.annotation.PrimaryKey -import com.raizlabs.dbflow5.annotation.Table -import com.raizlabs.dbflow5.annotation.TypeConverter -import com.raizlabs.dbflow5.database.FlowCursor -import com.raizlabs.dbflow5.query.LoadFromCursorListener - -/** - * Example of simple foreign key object with one foreign key object. - */ -@Table(database = TestDatabase::class) -class Blog(@PrimaryKey(autoincrement = true) var id: Int = 0, @Column var name: String = "", - @ForeignKey(saveForeignKeyModel = true) var author: Author? = null) - -/** - * Parent used as foreign key reference. - */ -@Table(database = TestDatabase::class) -class Author(@PrimaryKey(autoincrement = true) var id: Int = 0, - @Column(name = "first_name") var firstName: String = "", - @Column(name = "last_name") var lastName: String = "") - -/** - * Example of simple foreign key object with its [ForeignKey] deferred. - */ -@Table(database = TestDatabase::class) -class BlogDeferred(@PrimaryKey(autoincrement = true) var id: Int = 0, @Column var name: String = "", - @ForeignKey(deferred = true) var author: Author? = null) - -/** - * Class has example of single foreign key with [ForeignKeyReference] specified - */ -@Table(database = TestDatabase::class) -class BlogRef(@PrimaryKey(autoincrement = true) var id: Int = 0, @Column var name: String = "", - @ForeignKey(references = arrayOf( - ForeignKeyReference(columnName = "authorId", foreignKeyColumnName = "id", - defaultValue = "not gonna work"))) - var author: Author? = null) - -/** - * Class has example of single foreign key with [ForeignKeyReference] specified that is not the model object. - */ -@Table(database = TestDatabase::class) -class BlogRefNoModel(@PrimaryKey(autoincrement = true) var id: Int = 0, @Column var name: String = "", - @ForeignKey(references = arrayOf(ForeignKeyReference(columnName = "authorId", foreignKeyColumnName = "id", notNull = NotNull(onNullConflict = ConflictAction.FAIL))), - tableClass = Author::class) - var authorId: String? = null) - - -/** - * Class has example of single foreign key with [ForeignKeyReference] as [PrimaryKey] - */ -@Table(database = TestDatabase::class) -class BlogPrimary(@PrimaryKey @ForeignKey var author: Author? = null, @Column var id: Int = 0) - -/** - * Example of simple foreign key object with one foreign key object thats [ForeignKey.stubbedRelationship] - * and [ForeignKey.deleteForeignKeyModel] and [ForeignKey.saveForeignKeyModel] - */ -@Table(database = TestDatabase::class) -class BlogStubbed(@PrimaryKey(autoincrement = true) var id: Int = 0, @Column var name: String = "", - @ForeignKey(stubbedRelationship = true, deleteForeignKeyModel = true, saveForeignKeyModel = true, - onDelete = ForeignKeyAction.CASCADE, onUpdate = ForeignKeyAction.RESTRICT) - var author: Author? = null) : LoadFromCursorListener { - override fun onLoadFromCursor(cursor: FlowCursor) { - - } -} - -class DoubleToDouble(val double: Double) - -@TypeConverter -class DoubleConverter : com.raizlabs.dbflow5.converter.TypeConverter() { - override fun getDBValue(model: DoubleToDouble?) = model?.double - - override fun getModelValue(data: Double?): DoubleToDouble? = data?.let { DoubleToDouble(data) } -} - -class Location(var latitude: DoubleToDouble? = DoubleToDouble(0.0), - var longitude: DoubleToDouble? = DoubleToDouble(0.0)) - -@Table(database = TestDatabase::class) -class Position(@PrimaryKey var id: Int = 0, @ColumnMap var location: Location? = null) - -@Table(database = TestDatabase::class) -class Position2(@PrimaryKey var id: Int = 0, - @ColumnMap(references = arrayOf( - ColumnMapReference(columnName = "latitude", columnMapFieldName = "latitude", - defaultValue = "40.6"), - ColumnMapReference(columnName = "longitude", columnMapFieldName = "longitude", - defaultValue = "55.5"))) - var location: Location? = null) - -class Location2(var latitude: DoubleToDouble? = DoubleToDouble(0.0), - var longitude: Double? = 0.0) - -@Table(database = TestDatabase::class) -class PositionWithTypeConverter(@PrimaryKey var id: Int = 0, - @ColumnMap(references = arrayOf(ColumnMapReference(columnName = "latitude", - columnMapFieldName = "latitude", typeConverter = DoubleConverter::class), - ColumnMapReference(columnName = "longitude", columnMapFieldName = "longitude"))) - var location: Location2? = null) diff --git a/tests/src/test/java/com/raizlabs/dbflow5/models/IndexModels.kt b/tests/src/test/java/com/raizlabs/dbflow5/models/IndexModels.kt deleted file mode 100644 index 1b4ee29ff..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/models/IndexModels.kt +++ /dev/null @@ -1,38 +0,0 @@ -package com.raizlabs.dbflow5.models - -import com.raizlabs.dbflow5.TestDatabase -import com.raizlabs.dbflow5.annotation.Column -import com.raizlabs.dbflow5.annotation.Index -import com.raizlabs.dbflow5.annotation.IndexGroup -import com.raizlabs.dbflow5.annotation.PrimaryKey -import com.raizlabs.dbflow5.annotation.Table -import java.util.* - -/** - * Description: - */ - -@Table(database = TestDatabase::class, indexGroups = arrayOf(IndexGroup(number = 1, name = "firstIndex"), - IndexGroup(number = 2, name = "secondIndex"), - IndexGroup(number = 3, name = "thirdIndex"))) -class IndexModel { - @Index(indexGroups = intArrayOf(1, 2, 3)) - @PrimaryKey - var id: Int = 0 - - @Index(indexGroups = intArrayOf(1)) - @Column - var first_name: String? = null - - @Index(indexGroups = intArrayOf(2)) - @Column - var last_name: String? = null - - @Index(indexGroups = intArrayOf(3)) - @Column - var created_date: Date? = null - - @Index(indexGroups = intArrayOf(2, 3)) - @Column - var isPro: Boolean = false -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/models/InnerClassExample.kt b/tests/src/test/java/com/raizlabs/dbflow5/models/InnerClassExample.kt deleted file mode 100644 index 633a1b718..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/models/InnerClassExample.kt +++ /dev/null @@ -1,14 +0,0 @@ -package com.raizlabs.dbflow5.models - -import com.raizlabs.dbflow5.TestDatabase -import com.raizlabs.dbflow5.annotation.PrimaryKey -import com.raizlabs.dbflow5.annotation.Table - -/** - * Example ensuring static inner classes work. - */ -class Outer { - - @Table(database = TestDatabase::class) - class Inner(@PrimaryKey var id: Int = 0) -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/models/ManyToMany.kt b/tests/src/test/java/com/raizlabs/dbflow5/models/ManyToMany.kt deleted file mode 100644 index 424a11e72..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/models/ManyToMany.kt +++ /dev/null @@ -1,16 +0,0 @@ -package com.raizlabs.dbflow5.models - -import com.raizlabs.dbflow5.TestDatabase -import com.raizlabs.dbflow5.annotation.Column -import com.raizlabs.dbflow5.annotation.ManyToMany -import com.raizlabs.dbflow5.annotation.PrimaryKey -import com.raizlabs.dbflow5.annotation.Table - -@ManyToMany(referencedTable = Song::class) -@Table(database = TestDatabase::class) -class Artist(@PrimaryKey(autoincrement = true) var id: Int = 0, - @Column var name: String = "") - -@Table(database = TestDatabase::class) -class Song(@PrimaryKey(autoincrement = true) var id: Int = 0, - @Column var name: String = "") \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/models/ManyToManyTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/models/ManyToManyTest.kt deleted file mode 100644 index 63d9bb62c..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/models/ManyToManyTest.kt +++ /dev/null @@ -1,27 +0,0 @@ -package com.raizlabs.dbflow5.models - -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.models.Artist -import com.raizlabs.dbflow5.models.Song -import com.raizlabs.dbflow5.structure.save -import org.junit.Assert.assertTrue -import org.junit.Test - -class ManyToManyTest : BaseUnitTest() { - - @Test - fun testCanCreateManyToMany() { - val artist = Artist(name = "Andrew Grosner") - val song = Song(name = "Livin' on A Prayer") - - artist.save() - song.save() - - val artistSong = Artist_Song() - artistSong.artist = artist - artistSong.song = song - assertTrue(artistSong.save()) - - - } -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/models/ModelViewTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/models/ModelViewTest.kt deleted file mode 100644 index d0399f14f..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/models/ModelViewTest.kt +++ /dev/null @@ -1,21 +0,0 @@ -package com.raizlabs.dbflow5.models - -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.TestDatabase -import com.raizlabs.dbflow5.assertEquals -import com.raizlabs.dbflow5.config.database -import com.raizlabs.dbflow5.models.java.JavaModelView -import org.junit.Test - -class ModelViewTest : BaseUnitTest() { - - @Test - fun validateModelViewQuery() = database(TestDatabase::class) { - "SELECT `id` AS `authorId`,`first_name` || ' ' || `last_name` AS `authorName` FROM `Author`".assertEquals(AuthorView.getQuery()) - } - - @Test - fun validateJavaModelViewQuery() = database(TestDatabase::class) { - "SELECT `first_name` AS `firstName`,`id` AS `id`".assertEquals(JavaModelView.getQuery()) - } -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/models/ModelViews.kt b/tests/src/test/java/com/raizlabs/dbflow5/models/ModelViews.kt deleted file mode 100644 index 3e44977f5..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/models/ModelViews.kt +++ /dev/null @@ -1,42 +0,0 @@ -package com.raizlabs.dbflow5.models - -import com.raizlabs.dbflow5.TestDatabase -import com.raizlabs.dbflow5.annotation.Column -import com.raizlabs.dbflow5.annotation.ColumnMap -import com.raizlabs.dbflow5.annotation.ModelView -import com.raizlabs.dbflow5.annotation.ModelViewQuery -import com.raizlabs.dbflow5.models.Author_Table.first_name -import com.raizlabs.dbflow5.models.Author_Table.id -import com.raizlabs.dbflow5.models.Author_Table.last_name -import com.raizlabs.dbflow5.query.From -import com.raizlabs.dbflow5.query.property.IProperty -import com.raizlabs.dbflow5.query.property.property -import com.raizlabs.dbflow5.query.select - -class AuthorName(var name: String = "", var age: Int = 0) - - -@ModelView(database = TestDatabase::class) -class AuthorView(@Column var authorId: Int = 0, @Column var authorName: String = "", - @ColumnMap var author: AuthorName? = null) { - - companion object { - @JvmStatic - @ModelViewQuery - fun getQuery(): From = (select(id.`as`("authorId"), - first_name.concatenate(" ".property as IProperty>) - .concatenate(last_name as IProperty>) - .`as`("authorName")) - from Author::class) - } -} - -@ModelView(database = TestDatabase::class, priority = 2, allFields = true) -class PriorityView(var name: String = "") { - - companion object { - @JvmStatic - @ModelViewQuery - fun getQuery(): From = select((first_name + last_name).`as`("name")) from Author::class - } -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/models/NonTypical/nonTypicalClassName.kt b/tests/src/test/java/com/raizlabs/dbflow5/models/NonTypical/nonTypicalClassName.kt deleted file mode 100644 index d2cbd434d..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/models/NonTypical/nonTypicalClassName.kt +++ /dev/null @@ -1,11 +0,0 @@ -package com.raizlabs.dbflow5.models.NonTypical - -import com.raizlabs.dbflow5.TestDatabase -import com.raizlabs.dbflow5.annotation.PrimaryKey -import com.raizlabs.dbflow5.annotation.Table - -/** - * Tests package name capitalized, class name is lower cased. - */ -@Table(database = TestDatabase::class) -class nonTypicalClassName(@PrimaryKey var id: Int = 0) \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/models/OneToManyModelTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/models/OneToManyModelTest.kt deleted file mode 100644 index 7e6df81e1..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/models/OneToManyModelTest.kt +++ /dev/null @@ -1,49 +0,0 @@ -package com.raizlabs.dbflow5.models - -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.TestDatabase -import com.raizlabs.dbflow5.config.database -import com.raizlabs.dbflow5.query.list -import com.raizlabs.dbflow5.query.result -import com.raizlabs.dbflow5.query.select -import com.raizlabs.dbflow5.structure.delete -import com.raizlabs.dbflow5.structure.exists -import com.raizlabs.dbflow5.structure.save -import org.junit.Assert.assertFalse -import org.junit.Assert.assertNotNull -import org.junit.Assert.assertNull -import org.junit.Assert.assertTrue -import org.junit.Test - -class OneToManyModelTest : BaseUnitTest() { - - @Test - fun testOneToManyModel() { - database(TestDatabase::class) { - var testModel2 = TwoColumnModel("Greater", 4) - testModel2.save() - - testModel2 = TwoColumnModel("Lesser", 1) - testModel2.save() - - // assert we save - var oneToManyModel = OneToManyModel("HasOrders") - oneToManyModel.save() - assertTrue(oneToManyModel.exists()) - - // assert loading works as expected. - oneToManyModel = (select from OneToManyModel::class).result!! - assertNotNull(oneToManyModel.getRelatedOrders(this)) - assertTrue(!oneToManyModel.getRelatedOrders(this).isEmpty()) - - // assert the deletion cleared the variable - oneToManyModel.delete() - assertFalse(oneToManyModel.exists()) - assertNull(oneToManyModel.orders) - - // assert singular relationship was deleted. - val list = (select from TwoColumnModel::class).list - assertTrue(list.size == 1) - } - } -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/models/OneToManyModels.kt b/tests/src/test/java/com/raizlabs/dbflow5/models/OneToManyModels.kt deleted file mode 100644 index 1966dd72a..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/models/OneToManyModels.kt +++ /dev/null @@ -1,51 +0,0 @@ -package com.raizlabs.dbflow5.models - -import com.raizlabs.dbflow5.TestDatabase -import com.raizlabs.dbflow5.annotation.OneToMany -import com.raizlabs.dbflow5.annotation.OneToManyMethod -import com.raizlabs.dbflow5.annotation.PrimaryKey -import com.raizlabs.dbflow5.annotation.Table -import com.raizlabs.dbflow5.database.DatabaseWrapper -import com.raizlabs.dbflow5.models.TwoColumnModel_Table.id -import com.raizlabs.dbflow5.query.select -import com.raizlabs.dbflow5.structure.BaseModel -import com.raizlabs.dbflow5.structure.oneToMany - -@Table(database = TestDatabase::class) -class OneToManyModel(@PrimaryKey var name: String? = null) { - - var orders: List? = null - - var models: List? = null - - @get:OneToMany(oneToManyMethods = [OneToManyMethod.ALL]) - var simpleModels by oneToMany { select from OneToManyBaseModel::class } - - @OneToMany(oneToManyMethods = [OneToManyMethod.ALL], - variableName = "orders", efficientMethods = false) - fun getRelatedOrders(wrapper: DatabaseWrapper): List { - var localOrders = orders - if (localOrders == null) { - localOrders = (select from TwoColumnModel::class where id.greaterThan(3)) - .queryList(wrapper) - } - orders = localOrders - return localOrders - } - - @OneToMany(oneToManyMethods = [OneToManyMethod.DELETE], - variableName = "models") - fun getRelatedModels(wrapper: DatabaseWrapper): List { - var localModels = models - if (localModels == null) { - localModels = (select from OneToManyBaseModel::class).queryList(wrapper) - } - models = localModels - return localModels - } - - -} - -@Table(database = TestDatabase::class) -class OneToManyBaseModel(@PrimaryKey var id: Int = 0) : BaseModel() \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/models/ParentChildCachingTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/models/ParentChildCachingTest.kt deleted file mode 100644 index 960013436..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/models/ParentChildCachingTest.kt +++ /dev/null @@ -1,39 +0,0 @@ -package com.raizlabs.dbflow5.models - -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.TestDatabase -import com.raizlabs.dbflow5.config.database -import com.raizlabs.dbflow5.query.result -import com.raizlabs.dbflow5.query.select -import com.raizlabs.dbflow5.structure.load -import com.raizlabs.dbflow5.structure.save -import org.junit.Assert.assertEquals -import org.junit.Test - -/** - * Description: - */ -class ParentChildCachingTest : BaseUnitTest() { - - - @Test - fun testCanLoadChildFromCache() = database(TestDatabase::class) { - val child = TestModelChild() - child.id = 1 - child.name = "Test child" - child.save() - - var parent = TestModelParent() - parent.id = 1 - parent.name = "Test parent" - parent.child = child - parent.save() - - parent = (select from TestModelParent::class).result!! - var parentChild = parent.child!! - parentChild = parentChild.load()!! - - assertEquals(1, parentChild.id) - assertEquals("Test child", parentChild.name) - } -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/models/QueryModelTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/models/QueryModelTest.kt deleted file mode 100644 index fc926f541..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/models/QueryModelTest.kt +++ /dev/null @@ -1,37 +0,0 @@ -package com.raizlabs.dbflow5.models - -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.TestDatabase -import com.raizlabs.dbflow5.config.database -import com.raizlabs.dbflow5.models.Author_Table.id -import com.raizlabs.dbflow5.models.Blog_Table.author_id -import com.raizlabs.dbflow5.models.Blog_Table.name -import com.raizlabs.dbflow5.query.select -import com.raizlabs.dbflow5.structure.exists -import com.raizlabs.dbflow5.structure.save -import org.junit.Assert.assertEquals -import org.junit.Test - -/** - * Description: Tests to ensure we can load a Query model from the DB - */ -class QueryModelTest : BaseUnitTest() { - - @Test - fun testCanLoadAuthorBlogs() = database(TestDatabase::class) { - val author = Author(0, "Andrew", "Grosner") - author.save() - val blog = Blog(0, "My First Blog", author) - blog.save() - - assert(author.exists()) - assert(blog.exists()) - - val result = (select(name.withTable().`as`("blogName"), id.withTable().`as`("authorId"), - Blog_Table.id.withTable().`as`("blogId")) from Blog::class innerJoin - Author::class on (author_id.withTable() eq id.withTable())) - .queryCustomSingle(AuthorNameQuery::class.java, this)!! - assertEquals(author.id, result.authorId) - assertEquals(blog.id, result.blogId) - } -} diff --git a/tests/src/test/java/com/raizlabs/dbflow5/models/QueryModels.kt b/tests/src/test/java/com/raizlabs/dbflow5/models/QueryModels.kt deleted file mode 100644 index c800b703f..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/models/QueryModels.kt +++ /dev/null @@ -1,29 +0,0 @@ -package com.raizlabs.dbflow5.models - -import com.raizlabs.dbflow5.TestDatabase -import com.raizlabs.dbflow5.annotation.Column -import com.raizlabs.dbflow5.annotation.QueryModel -import com.raizlabs.dbflow5.converter.TypeConverter -import com.raizlabs.dbflow5.data.Blob - -@QueryModel(database = TestDatabase::class, allFields = true) -class AuthorNameQuery(var blogName: String = "", - var authorId: Int = 0, var blogId: Int = 0) - - -@QueryModel(database = TestDatabase::class) -class CustomBlobModel(@Column var myBlob: MyBlob? = null) { - - class MyBlob(val blob: ByteArray) - - @com.raizlabs.dbflow5.annotation.TypeConverter - class MyTypeConverter : TypeConverter() { - - override fun getDBValue(model: MyBlob?) = model?.let { Blob(model.blob) } - - override fun getModelValue(data: Blob?) = data?.blob?.let { MyBlob(it) } - } -} - -@QueryModel(database = TestDatabase::class, allFields = true) -class AllFieldsQueryModel(var model: String? = null) \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/models/SimpleTestModels.kt b/tests/src/test/java/com/raizlabs/dbflow5/models/SimpleTestModels.kt deleted file mode 100644 index 368d28415..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/models/SimpleTestModels.kt +++ /dev/null @@ -1,208 +0,0 @@ -package com.raizlabs.dbflow5.models - -import com.raizlabs.dbflow5.TestDatabase -import com.raizlabs.dbflow5.annotation.Column -import com.raizlabs.dbflow5.annotation.ColumnIgnore -import com.raizlabs.dbflow5.annotation.ConflictAction -import com.raizlabs.dbflow5.annotation.ForeignKey -import com.raizlabs.dbflow5.annotation.ManyToMany -import com.raizlabs.dbflow5.annotation.PrimaryKey -import com.raizlabs.dbflow5.annotation.QueryModel -import com.raizlabs.dbflow5.annotation.Table -import com.raizlabs.dbflow5.converter.TypeConverter -import com.raizlabs.dbflow5.data.Blob -import com.raizlabs.dbflow5.database.DatabaseStatement -import com.raizlabs.dbflow5.query.SQLiteStatementListener -import com.raizlabs.dbflow5.structure.BaseModel -import java.math.BigDecimal -import java.math.BigInteger -import java.util.* - - -/** - * Description: - */ -@Table(database = TestDatabase::class) -class SimpleModel(@PrimaryKey var name: String? = "") - -@QueryModel(database = TestDatabase::class) -class SimpleCustomModel(@Column var name: String? = "") - -@Table(database = TestDatabase::class, insertConflict = ConflictAction.FAIL, updateConflict = ConflictAction.FAIL) -class NumberModel(@PrimaryKey var id: Int = 0) - -@Table(database = TestDatabase::class) -class CharModel(@PrimaryKey var id: Int = 0, @Column var exampleChar: Char? = null) - -@Table(database = TestDatabase::class) -class TwoColumnModel(@PrimaryKey var name: String? = "", @Column(defaultValue = "56") var id: Int = 0) - -@Table(database = TestDatabase::class, createWithDatabase = false) -class DontCreateModel(@PrimaryKey var id: Int = 0) - -enum class Difficulty { - EASY, - MEDIUM, - HARD -} - -@Table(database = TestDatabase::class) -class EnumModel(@PrimaryKey var id: Int = 0, @Column var difficulty: Difficulty? = Difficulty.EASY) - -@Table(database = TestDatabase::class, allFields = true) -open class AllFieldsModel(@PrimaryKey var name: String? = null, - var count: Int? = 0, - @Column(getterName = "getTruth") - var truth: Boolean = false, - internal val finalName: String = "", - @ColumnIgnore private val hidden: Int = 0) { - - companion object { - - // example field to ensure static not used. - var COUNT: Int = 0 - } -} - -@Table(database = TestDatabase::class, allFields = true) -class SubclassAllFields(@Column var order: Int = 0) : AllFieldsModel() - -@Table(database = TestDatabase::class, assignDefaultValuesFromCursor = false) -class DontAssignDefaultModel(@PrimaryKey var name: String? = null, - @Column(getterName = "getNullableBool") var nullableBool: Boolean? = null, - @Column var index: Int = 0) - -@Table(database = TestDatabase::class, orderedCursorLookUp = true) -class OrderCursorModel(@PrimaryKey var id: Int = 0, @Column var name: String? = "", - @Column var age: Int = 0) - -@Table(database = TestDatabase::class) -class TypeConverterModel(@PrimaryKey var id: Int = 0, - @Column(typeConverter = BlobConverter::class) var opaqueData: ByteArray? = null, - @Column var blob: Blob? = null, - @Column(typeConverter = CustomTypeConverter::class) - @PrimaryKey var customType: CustomType? = null) - -@Table(database = TestDatabase::class) -class EnumTypeConverterModel(@PrimaryKey var id: Int = 0, - @Column var blob: Blob? = null, - @Column var byteArray: ByteArray? = null, - @Column(typeConverter = CustomEnumTypeConverter::class) - var difficulty: Difficulty = Difficulty.EASY) - -@Table(database = TestDatabase::class, allFields = true) -class FeedEntry(@PrimaryKey var id: Int = 0, - var title: String? = null, - var subtitle: String? = null) - -@Table(database = TestDatabase::class) -@ManyToMany( - generatedTableClassName = "Refund", referencedTable = Transfer::class, - referencedTableColumnName = "refund_in", thisTableColumnName = "refund_out", - saveForeignKeyModels = true -) -data class Transfer(@PrimaryKey var transfer_id: UUID = UUID.randomUUID()) - -@Table(database = TestDatabase::class) -data class Transfer2( - @PrimaryKey - var id: UUID = UUID.randomUUID(), - @ForeignKey(stubbedRelationship = true) - var origin: Account? = null -) - -@Table(database = TestDatabase::class) -data class Account(@PrimaryKey var id: UUID = UUID.randomUUID()) - -@Table(database = TestDatabase::class) -class SqlListenerModel(@PrimaryKey var id: Int = 0) : SQLiteStatementListener { - - override fun onBindToInsertStatement(databaseStatement: DatabaseStatement) { - TODO("not implemented") - } - - override fun onBindToUpdateStatement(databaseStatement: DatabaseStatement) { - TODO("not implemented") - } - - override fun onBindToDeleteStatement(databaseStatement: DatabaseStatement) { - TODO("not implemented") - } -} - -class CustomType(var name: Int? = 0) - -class CustomTypeConverter : TypeConverter() { - override fun getDBValue(model: CustomType?) = model?.name - - override fun getModelValue(data: Int?) = if (data == null) { - null - } else { - CustomType(data) - } - -} - -class CustomEnumTypeConverter : TypeConverter() { - override fun getDBValue(model: Difficulty?) = model?.name?.substring(0..0) - - override fun getModelValue(data: String?) = when (data) { - "E" -> Difficulty.EASY - "M" -> Difficulty.MEDIUM - "H" -> Difficulty.HARD - else -> Difficulty.HARD - } - -} - -@com.raizlabs.dbflow5.annotation.TypeConverter -class BlobConverter : TypeConverter() { - - override fun getDBValue(model: ByteArray?): Blob? { - return if (model == null) null else Blob(model) - } - - override fun getModelValue(data: Blob?): ByteArray? { - return data?.blob - } -} - -@Table(database = TestDatabase::class) -class DefaultModel(@PrimaryKey @Column(defaultValue = "5") var id: Int? = 0, - @Column(defaultValue = "5.0") var location: Double? = 0.0, - @Column(defaultValue = "\"String\"") var name: String? = "") - -@Table(database = TestDatabase::class, cachingEnabled = true) -class TestModelChild : BaseModel() { - @PrimaryKey - var id: Long = 0 - - @Column - var name: String? = null -} - -@Table(database = TestDatabase::class) -class TestModelParent : BaseModel() { - @PrimaryKey - var id: Long = 0 - - @Column - var name: String? = null - - @ForeignKey(stubbedRelationship = true) - var child: TestModelChild? = null -} - -@Table(database = TestDatabase::class) -class NullableNumbers(@PrimaryKey var id: Int = 0, - @Column var f: Float? = null, - @Column var d: Double? = null, - @Column var l: Long? = null, - @Column var i: Int? = null, - @Column var bigDecimal: BigDecimal? = null, - @Column var bigInteger: BigInteger? = null) - -@Table(database = TestDatabase::class) -class NonNullKotlinModel(@PrimaryKey var name: String = "", - @Column var date: Date = Date(), - @Column var numb: Int = 0) \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/models/SimpleTestModelsTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/models/SimpleTestModelsTest.kt deleted file mode 100644 index be2fbd8eb..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/models/SimpleTestModelsTest.kt +++ /dev/null @@ -1,22 +0,0 @@ -package com.raizlabs.dbflow5.models - -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.config.modelAdapter -import org.junit.Assert.assertEquals -import org.junit.Test - -/** - * Description: - */ -class SimpleTestModelsTest : BaseUnitTest() { - - @Test - fun validateCreationQuery() { - assertEquals("CREATE TABLE IF NOT EXISTS `TypeConverterModel`(" + - "`id` INTEGER, " + - "`opaqueData` BLOB, " + - "`blob` BLOB, " + - "`customType` INTEGER, " + - "PRIMARY KEY(`id`, `customType`))", modelAdapter().creationQuery) - } -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/models/ants/AntHill.java b/tests/src/test/java/com/raizlabs/dbflow5/models/ants/AntHill.java deleted file mode 100644 index 54c0975cb..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/models/ants/AntHill.java +++ /dev/null @@ -1,13 +0,0 @@ -package com.raizlabs.dbflow5.models.ants; - -import com.raizlabs.dbflow5.TestDatabase; -import com.raizlabs.dbflow5.annotation.PrimaryKey; -import com.raizlabs.dbflow5.annotation.Table; -import com.raizlabs.dbflow5.structure.BaseModel; - -@Table(database = TestDatabase.class) -public class AntHill extends BaseModel { - @PrimaryKey - public String hillId; -} - diff --git a/tests/src/test/java/com/raizlabs/dbflow5/models/ants/Ants.java b/tests/src/test/java/com/raizlabs/dbflow5/models/ants/Ants.java deleted file mode 100644 index 89b197e63..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/models/ants/Ants.java +++ /dev/null @@ -1,20 +0,0 @@ -package com.raizlabs.dbflow5.models.ants; - -import com.raizlabs.dbflow5.TestDatabase; -import com.raizlabs.dbflow5.annotation.ForeignKey; -import com.raizlabs.dbflow5.annotation.ForeignKeyReference; -import com.raizlabs.dbflow5.annotation.PrimaryKey; -import com.raizlabs.dbflow5.annotation.Table; -import com.raizlabs.dbflow5.structure.BaseModel; - -@Table(database = TestDatabase.class) -public class Ants extends BaseModel { - @PrimaryKey - public String antId; - - @PrimaryKey - @ForeignKey(tableClass = AntHill.class, references = { - @ForeignKeyReference(columnName = "hillIdRef", foreignKeyColumnName = "hillId") - }) - public String hillId; -} diff --git a/tests/src/test/java/com/raizlabs/dbflow5/models/issue/Issue.java b/tests/src/test/java/com/raizlabs/dbflow5/models/issue/Issue.java deleted file mode 100644 index dc421b220..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/models/issue/Issue.java +++ /dev/null @@ -1,37 +0,0 @@ -package com.raizlabs.dbflow5.models.issue; - -import com.raizlabs.dbflow5.TestDatabase; -import com.raizlabs.dbflow5.annotation.OneToMany; -import com.raizlabs.dbflow5.annotation.OneToManyMethod; -import com.raizlabs.dbflow5.annotation.PrimaryKey; -import com.raizlabs.dbflow5.annotation.Table; -import com.raizlabs.dbflow5.database.DatabaseWrapper; -import com.raizlabs.dbflow5.structure.BaseModel; - -import java.util.List; - -import static com.raizlabs.dbflow5.query.SQLite.select; - -/** - * Description: - */ - -@Table(database = TestDatabase.class) -public class Issue extends BaseModel { - - @PrimaryKey - String id; - - List subIssueList; - - @OneToMany(oneToManyMethods = {OneToManyMethod.SAVE, OneToManyMethod.DELETE}, variableName = "subIssueList") - public List getDbSubIssueList(DatabaseWrapper databaseWrapper) { - if (subIssueList == null || subIssueList.isEmpty()) { - subIssueList = select() - .from(SubIssue.class) - .where(SubIssue_Table.owningIssueId.eq(id)) - .queryList(databaseWrapper); - } - return subIssueList; - } -} diff --git a/tests/src/test/java/com/raizlabs/dbflow5/models/issue/Page.java b/tests/src/test/java/com/raizlabs/dbflow5/models/issue/Page.java deleted file mode 100644 index 28e0a327b..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/models/issue/Page.java +++ /dev/null @@ -1,25 +0,0 @@ -package com.raizlabs.dbflow5.models.issue; - -import com.raizlabs.dbflow5.TestDatabase; -import com.raizlabs.dbflow5.annotation.Column; -import com.raizlabs.dbflow5.annotation.ForeignKey; -import com.raizlabs.dbflow5.annotation.PrimaryKey; -import com.raizlabs.dbflow5.annotation.Table; -import com.raizlabs.dbflow5.structure.BaseModel; - -/** - * Description: - */ -@Table(database = TestDatabase.class) -public class Page extends BaseModel { - - @PrimaryKey - @Column - String id; - - @PrimaryKey - String owningIssueId; - - @ForeignKey(stubbedRelationship = true) - SubIssue subIssue; -} diff --git a/tests/src/test/java/com/raizlabs/dbflow5/models/issue/SubIssue.java b/tests/src/test/java/com/raizlabs/dbflow5/models/issue/SubIssue.java deleted file mode 100644 index 7da052ad5..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/models/issue/SubIssue.java +++ /dev/null @@ -1,44 +0,0 @@ -package com.raizlabs.dbflow5.models.issue; - -import com.raizlabs.dbflow5.TestDatabase; -import com.raizlabs.dbflow5.annotation.OneToMany; -import com.raizlabs.dbflow5.annotation.OneToManyMethod; -import com.raizlabs.dbflow5.annotation.PrimaryKey; -import com.raizlabs.dbflow5.annotation.Table; -import com.raizlabs.dbflow5.database.DatabaseWrapper; -import com.raizlabs.dbflow5.structure.BaseModel; - -import java.util.ArrayList; -import java.util.List; - -import static com.raizlabs.dbflow5.query.SQLite.select; - -/** - * Description: - */ - -@Table(database = TestDatabase.class) -public class SubIssue extends BaseModel { - - @PrimaryKey - String id; - - @PrimaryKey - String owningIssueId; - - List pageList; - - @OneToMany(oneToManyMethods = {OneToManyMethod.SAVE, OneToManyMethod.DELETE}, variableName = "pageList") - public List getDbPageList(DatabaseWrapper databaseWrapper) { - if (pageList == null) { - pageList = new ArrayList<>(); - } - if (pageList.isEmpty()) { - pageList = select() - .from(Page.class) - .where(Page_Table.owningIssueId.eq(owningIssueId), Page_Table.subIssue_id.eq(id)) - .queryList(databaseWrapper); - } - return pageList; - } -} diff --git a/tests/src/test/java/com/raizlabs/dbflow5/models/java/DatabaseModel.java b/tests/src/test/java/com/raizlabs/dbflow5/models/java/DatabaseModel.java deleted file mode 100644 index 5c174fd6c..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/models/java/DatabaseModel.java +++ /dev/null @@ -1,17 +0,0 @@ -package com.raizlabs.dbflow5.models.java; - -import com.raizlabs.dbflow5.annotation.PrimaryKey; -import com.raizlabs.dbflow5.structure.BaseModel; - -public class DatabaseModel extends BaseModel { - @PrimaryKey - private Integer id; - - public Integer getId() { - return id; - } - - public void setId(Integer id) { - this.id = id; - } -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/models/java/JavaModelView.java b/tests/src/test/java/com/raizlabs/dbflow5/models/java/JavaModelView.java deleted file mode 100644 index 30adc47ef..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/models/java/JavaModelView.java +++ /dev/null @@ -1,26 +0,0 @@ -package com.raizlabs.dbflow5.models.java; - -import com.raizlabs.dbflow5.TestDatabase; -import com.raizlabs.dbflow5.annotation.Column; -import com.raizlabs.dbflow5.annotation.ModelView; -import com.raizlabs.dbflow5.annotation.ModelViewQuery; -import com.raizlabs.dbflow5.database.DatabaseWrapper; -import com.raizlabs.dbflow5.models.Author_Table; -import com.raizlabs.dbflow5.query.SQLite; -import com.raizlabs.dbflow5.sql.Query; - -@ModelView(database = TestDatabase.class) -public class JavaModelView { - - @ModelViewQuery - public static Query getQuery() { - return SQLite.select(Author_Table.first_name.as("firstName"), Author_Table.id.as("id")); - } - - @Column - String id; - - @Column - Integer firstName; - -} diff --git a/tests/src/test/java/com/raizlabs/dbflow5/models/java/otherpackage/ExampleModel.java b/tests/src/test/java/com/raizlabs/dbflow5/models/java/otherpackage/ExampleModel.java deleted file mode 100644 index 11e1b3862..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/models/java/otherpackage/ExampleModel.java +++ /dev/null @@ -1,12 +0,0 @@ -package com.raizlabs.dbflow5.models.java.otherpackage; - -import com.raizlabs.dbflow5.TestDatabase; -import com.raizlabs.dbflow5.annotation.Column; -import com.raizlabs.dbflow5.annotation.Table; -import com.raizlabs.dbflow5.models.java.DatabaseModel; - -@Table(database = TestDatabase.class) -public class ExampleModel extends DatabaseModel { - @Column - String name; -} diff --git a/tests/src/test/java/com/raizlabs/dbflow5/paging/QueryDataSourceTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/paging/QueryDataSourceTest.kt deleted file mode 100644 index 77629c202..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/paging/QueryDataSourceTest.kt +++ /dev/null @@ -1,60 +0,0 @@ -package com.raizlabs.dbflow5.paging - -import android.arch.paging.PagedList -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.TestDatabase -import com.raizlabs.dbflow5.assertThrowsException -import com.raizlabs.dbflow5.config.database -import com.raizlabs.dbflow5.models.SimpleModel -import com.raizlabs.dbflow5.models.SimpleModel_Table -import com.raizlabs.dbflow5.query.select -import com.raizlabs.dbflow5.query.set -import com.raizlabs.dbflow5.query.update -import com.raizlabs.dbflow5.structure.save -import org.junit.Assert.assertEquals -import org.junit.Assert.assertTrue -import org.junit.Test - -/** - * Description: - */ -class QueryDataSourceTest : BaseUnitTest() { - - @Test - fun testLoadInitialParams() { - database { - (0 until 100).forEach { SimpleModel("$it").save(this) } - - val factory = (select from SimpleModel::class).toDataSourceFactory(this) - val list = PagedList.Builder(factory.create(), - PagedList.Config.Builder() - .setPageSize(3) - .setPrefetchDistance(6) - .setEnablePlaceholders(true).build()) - .setFetchExecutor { it.run() } // run on main - .setNotifyExecutor { it.run() } - .build() - - assertEquals(100, list.size) - - list.forEachIndexed { index, simpleModel -> - list.loadAround(index) - assertEquals(index, simpleModel.name?.toInt()) - - // assert we don't run over somehow. - assertTrue(index < 100) - } - } - } - - @Test - fun testThrowsErrorOnInvalidType() { - database { - assertThrowsException(IllegalArgumentException::class) { - (update() set (SimpleModel_Table.name.eq("name"))) - .toDataSourceFactory(this) - .create() - } - } - } -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/provider/ContentProviderObjects.kt b/tests/src/test/java/com/raizlabs/dbflow5/provider/ContentProviderObjects.kt deleted file mode 100644 index 1e7bced14..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/provider/ContentProviderObjects.kt +++ /dev/null @@ -1,94 +0,0 @@ -package com.raizlabs.dbflow5.provider - -import com.raizlabs.dbflow5.annotation.Column -import com.raizlabs.dbflow5.annotation.Database -import com.raizlabs.dbflow5.annotation.ForeignKey -import com.raizlabs.dbflow5.annotation.ForeignKeyReference -import com.raizlabs.dbflow5.annotation.PrimaryKey -import com.raizlabs.dbflow5.annotation.Table -import com.raizlabs.dbflow5.annotation.provider.ContentProvider -import com.raizlabs.dbflow5.annotation.provider.ContentType -import com.raizlabs.dbflow5.annotation.provider.ContentUri -import com.raizlabs.dbflow5.annotation.provider.TableEndpoint -import com.raizlabs.dbflow5.config.DBFlowDatabase - - -/** - * Description: - */ -@ContentProvider(authority = ContentDatabase.AUTHORITY, database = ContentDatabase::class, - baseContentUri = ContentDatabase.BASE_CONTENT_URI) -@Database(version = ContentDatabase.VERSION) -abstract class ContentDatabase : DBFlowDatabase() { - companion object { - const val BASE_CONTENT_URI = "content://" - - const val AUTHORITY = "com.raizlabs.android.content.test.ContentDatabase" - - const val VERSION = 1 - } -} - -@TableEndpoint(name = ContentProviderModel.NAME, contentProvider = ContentDatabase::class) -@Table(database = ContentDatabase::class, name = ContentProviderModel.NAME, generateContentValues = true) -class ContentProviderModel(@PrimaryKey(autoincrement = true) - var id: Long = 0, - @Column - var notes: String? = null, - @Column - var title: String? = null) : BaseProviderModel() { - - override val deleteUri get() = TestContentProvider.ContentProviderModel.CONTENT_URI - - override val insertUri get() = TestContentProvider.ContentProviderModel.CONTENT_URI - - override val updateUri get() = TestContentProvider.ContentProviderModel.CONTENT_URI - - override val queryUri get() = TestContentProvider.ContentProviderModel.CONTENT_URI - - companion object { - - const val NAME = "ContentProviderModel" - - @ContentUri(path = NAME, type = "${ContentType.VND_MULTIPLE}${NAME}") - val CONTENT_URI = ContentUtils.buildUriWithAuthority(ContentDatabase.AUTHORITY) - } -} - -@Table(database = ContentDatabase::class, generateContentValues = true) -class NoteModel(@PrimaryKey(autoincrement = true) - var id: Long = 0, - - @ForeignKey(references = arrayOf(ForeignKeyReference(columnName = "providerModel", - foreignKeyColumnName = "id"))) - var contentProviderModel: ContentProviderModel? = null, - - @Column - var note: String? = null, - - @Column - var isOpen: Boolean = false) : BaseProviderModel() { - - override val deleteUri get() = TestContentProvider.NoteModel.CONTENT_URI - - override val insertUri get() = TestContentProvider.NoteModel.CONTENT_URI - - override val updateUri get() = TestContentProvider.NoteModel.CONTENT_URI - - override val queryUri get() = TestContentProvider.NoteModel.CONTENT_URI -} - -@Table(database = ContentDatabase::class, generateContentValues = true) -class TestSyncableModel(@PrimaryKey(autoincrement = true) - var id: Long = 0, - @Column - var name: String? = null) : BaseSyncableProviderModel() { - - override val deleteUri get() = TestContentProvider.TestSyncableModel.CONTENT_URI - - override val insertUri get() = TestContentProvider.TestSyncableModel.CONTENT_URI - - override val updateUri get() = TestContentProvider.TestSyncableModel.CONTENT_URI - - override val queryUri get() = TestContentProvider.TestSyncableModel.CONTENT_URI -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/provider/ContentProviderTests.kt b/tests/src/test/java/com/raizlabs/dbflow5/provider/ContentProviderTests.kt deleted file mode 100644 index 8209c4483..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/provider/ContentProviderTests.kt +++ /dev/null @@ -1,133 +0,0 @@ -package com.raizlabs.dbflow5.provider - -import android.content.ContentResolver -import android.content.pm.ProviderInfo -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.config.database -import com.raizlabs.dbflow5.query.Delete.Companion.table -import com.raizlabs.dbflow5.query.Delete.Companion.tables -import com.raizlabs.dbflow5.query.result -import com.raizlabs.dbflow5.query.select -import com.raizlabs.dbflow5.structure.exists -import org.junit.Assert.assertEquals -import org.junit.Assert.assertFalse -import org.junit.Assert.assertTrue -import org.junit.Before -import org.junit.Test -import org.robolectric.Robolectric -import org.robolectric.RuntimeEnvironment - -/** - * Description: - */ -class ContentProviderTests : BaseUnitTest() { - private val mockContentResolver: ContentResolver - get() = RuntimeEnvironment.application.contentResolver - - @Before - fun setUp() { - val info = ProviderInfo() - info.authority = TestContentProvider.AUTHORITY - Robolectric.buildContentProvider(TestContentProvider_Provider::class.java).create(info) - } - - @Test - fun testContentProviderUtils() { - database(ContentDatabase::class) { - tables(NoteModel::class.java, ContentProviderModel::class.java) - - var contentProviderModel = ContentProviderModel() - contentProviderModel.notes = "Test" - var uri = ContentUtils.insert(mockContentResolver, TestContentProvider.ContentProviderModel.CONTENT_URI, contentProviderModel) - assertEquals(TestContentProvider.ContentProviderModel.CONTENT_URI.toString() + "/" + contentProviderModel.id, uri.toString()) - assertTrue(contentProviderModel.exists()) - - contentProviderModel.notes = "NewTest" - val update = ContentUtils.update(mockContentResolver, TestContentProvider.ContentProviderModel.CONTENT_URI, contentProviderModel) - assertEquals(update.toLong(), 1) - assertTrue(contentProviderModel.exists()) - contentProviderModel = contentProviderModel.load(this)!! - assertEquals("NewTest", contentProviderModel.notes) - - val noteModel = NoteModel() - noteModel.note = "Test" - noteModel.contentProviderModel = contentProviderModel - uri = ContentUtils.insert(mockContentResolver, TestContentProvider.NoteModel.CONTENT_URI, noteModel) - assertEquals(TestContentProvider.NoteModel.CONTENT_URI.toString() + "/" + noteModel.id, uri.toString()) - assertTrue(noteModel.exists()) - - assertTrue(ContentUtils.delete(mockContentResolver, TestContentProvider.NoteModel.CONTENT_URI, noteModel) > 0) - assertTrue(!noteModel.exists()) - - assertTrue(ContentUtils.delete(mockContentResolver, TestContentProvider.ContentProviderModel.CONTENT_URI, contentProviderModel) > 0) - assertTrue(!contentProviderModel.exists()) - - tables(NoteModel::class.java, ContentProviderModel::class.java) - } - } - - @Test - fun testContentProviderNative() { - database(ContentDatabase::class) { - tables(NoteModel::class.java, ContentProviderModel::class.java) - - var contentProviderModel = ContentProviderModel(notes = "Test") - contentProviderModel.insert() - assertTrue(contentProviderModel.exists()) - - contentProviderModel.notes = "NewTest" - contentProviderModel.update() - contentProviderModel = contentProviderModel.load(this)!! - assertEquals("NewTest", contentProviderModel.notes) - - var noteModel = NoteModel(note = "Test", contentProviderModel = contentProviderModel) - noteModel.insert() - - noteModel.note = "NewTest" - noteModel.update() - noteModel = noteModel.load(this)!! - assertEquals("NewTest", noteModel.note) - - assertTrue(noteModel.exists()) - - noteModel.delete() - assertTrue(!noteModel.exists()) - - contentProviderModel.delete() - assertTrue(!contentProviderModel.exists()) - - tables(NoteModel::class.java, ContentProviderModel::class.java) - } - } - - @Test - fun testSyncableModel() { - database(ContentDatabase::class) { - table(this, TestSyncableModel::class.java) - - var testSyncableModel = TestSyncableModel(name = "Name") - testSyncableModel.save() - - assertTrue(testSyncableModel.exists()) - - testSyncableModel.name = "TestName" - testSyncableModel.update() - assertEquals(testSyncableModel.name, "TestName") - - testSyncableModel = (select from TestSyncableModel::class - where (TestSyncableModel_Table.id.`is`(testSyncableModel.id))).result!! - - var fromContentProvider = TestSyncableModel(id = testSyncableModel.id) - fromContentProvider = fromContentProvider.load(this)!! - - assertEquals(fromContentProvider.name, testSyncableModel.name) - assertEquals(fromContentProvider.id, testSyncableModel.id) - - testSyncableModel.delete() - assertFalse(testSyncableModel.exists()) - - table(this, TestSyncableModel::class.java) - } - } - -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/provider/RealContentProvider.kt b/tests/src/test/java/com/raizlabs/dbflow5/provider/RealContentProvider.kt deleted file mode 100644 index 5cc1676ca..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/provider/RealContentProvider.kt +++ /dev/null @@ -1,42 +0,0 @@ -package com.raizlabs.dbflow5.provider - -import android.content.ContentProvider -import android.content.ContentValues -import android.database.Cursor -import android.net.Uri -import com.raizlabs.dbflow5.TestDatabase -import com.raizlabs.dbflow5.config.FlowConfig -import com.raizlabs.dbflow5.config.FlowManager -import com.raizlabs.dbflow5.config.database -import com.raizlabs.dbflow5.database.DatabaseWrapper - -class RealContentProvider : ContentProvider() { - - lateinit var database: DatabaseWrapper - - override fun onCreate(): Boolean { - FlowManager.init(FlowConfig.Builder(context).build()) - database = database() - return true - } - - override fun query(uri: Uri, projection: Array?, selection: String?, selectionArgs: Array?, sortOrder: String?): Cursor? { - return null - } - - override fun getType(uri: Uri): String? { - return null - } - - override fun insert(uri: Uri, values: ContentValues?): Uri? { - return null - } - - override fun delete(uri: Uri, selection: String?, selectionArgs: Array?): Int { - return 0 - } - - override fun update(uri: Uri, values: ContentValues?, selection: String?, selectionArgs: Array?): Int { - return 0 - } -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/provider/TestContentProvider.kt b/tests/src/test/java/com/raizlabs/dbflow5/provider/TestContentProvider.kt deleted file mode 100644 index 3290a797a..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/provider/TestContentProvider.kt +++ /dev/null @@ -1,137 +0,0 @@ -package com.raizlabs.dbflow5.provider - -import android.content.ContentValues -import android.content.Context -import android.net.Uri -import com.raizlabs.dbflow5.annotation.provider.ContentProvider -import com.raizlabs.dbflow5.annotation.provider.ContentType -import com.raizlabs.dbflow5.annotation.provider.ContentUri -import com.raizlabs.dbflow5.annotation.provider.Notify -import com.raizlabs.dbflow5.annotation.provider.NotifyMethod -import com.raizlabs.dbflow5.annotation.provider.PathSegment -import com.raizlabs.dbflow5.annotation.provider.TableEndpoint -import com.raizlabs.dbflow5.getContentValuesKey - -@ContentProvider(authority = TestContentProvider.AUTHORITY, database = ContentDatabase::class, - baseContentUri = TestContentProvider.BASE_CONTENT_URI) -object TestContentProvider { - - const val AUTHORITY = "com.raizlabs.dbflow5.test.provider" - - const val BASE_CONTENT_URI = "content://" - - private fun buildUri(vararg paths: String): Uri { - val builder = Uri.parse(BASE_CONTENT_URI + AUTHORITY).buildUpon() - for (path in paths) { - builder.appendPath(path) - } - return builder.build() - } - - @TableEndpoint(name = ContentProviderModel.ENDPOINT, contentProvider = ContentDatabase::class) - object ContentProviderModel { - - const val ENDPOINT = "ContentProviderModel" - - @JvmStatic - @ContentUri(path = ENDPOINT, - type = ContentType.VND_MULTIPLE + ENDPOINT) - var CONTENT_URI = buildUri(ENDPOINT) - - @JvmStatic - @ContentUri(path = ENDPOINT + "/#", - type = ContentType.VND_SINGLE + ENDPOINT, - segments = arrayOf(PathSegment(segment = 1, column = "id"))) - fun withId(id: Long): Uri { - return buildUri(id.toString()) - } - - @JvmStatic - @Notify(notifyMethod = NotifyMethod.INSERT, paths = arrayOf(ENDPOINT + "/#")) - fun onInsert(contentValues: ContentValues): Array { - val id = contentValues.getAsLong("id")!! - return arrayOf(withId(id)) - } - - } - - @TableEndpoint(name = NoteModel.ENDPOINT, contentProvider = ContentDatabase::class) - object NoteModel { - - const val ENDPOINT = "NoteModel" - - @ContentUri(path = ENDPOINT, type = ContentType.VND_MULTIPLE + ENDPOINT) - var CONTENT_URI = buildUri(ENDPOINT) - - @JvmStatic - @ContentUri(path = ENDPOINT + "/#", type = ContentType.VND_MULTIPLE + ENDPOINT, - segments = arrayOf(PathSegment(column = "id", segment = 1))) - fun withId(id: Long): Uri { - return buildUri(ENDPOINT, id.toString()) - } - - @JvmStatic - @ContentUri(path = ENDPOINT + "/#/#", - type = ContentType.VND_SINGLE + ContentProviderModel.ENDPOINT, - segments = arrayOf(PathSegment(column = "id", segment = 2))) - fun fromList(id: Long): Uri { - return buildUri(ENDPOINT, "fromList", id.toString()) - } - - @JvmStatic - @ContentUri(path = ENDPOINT + "/#/#", - type = ContentType.VND_SINGLE + ContentProviderModel.ENDPOINT, - segments = arrayOf(PathSegment(column = "id", segment = 1), - PathSegment(column = "isOpen", segment = 2))) - fun withOpenId(id: Long, isOpen: Boolean): Uri { - return buildUri(ENDPOINT, id.toString(), isOpen.toString()) - } - - @JvmStatic - @Notify(notifyMethod = NotifyMethod.INSERT, paths = arrayOf(ENDPOINT)) - fun onInsert(contentValues: ContentValues): Array { - val listId = contentValues.getAsLong(getContentValuesKey(contentValues, "providerModel"))!! - return arrayOf(ContentProviderModel.withId(listId), fromList(listId)) - } - - @JvmStatic - @Notify(notifyMethod = NotifyMethod.INSERT, paths = arrayOf(ENDPOINT)) - fun onInsert2(contentValues: ContentValues): Uri { - val listId = contentValues.getAsLong(getContentValuesKey(contentValues, "providerModel"))!! - return fromList(listId) - } - - @JvmStatic - @Notify(notifyMethod = NotifyMethod.UPDATE, paths = arrayOf(ENDPOINT + "/#")) - fun onUpdate(context: Context, uri: Uri): Array { - val noteId = java.lang.Long.valueOf(uri.pathSegments[1])!! - val c = context.contentResolver.query(uri, arrayOf("noteModel"), null, null, null) - c!!.moveToFirst() - val listId = c.getLong(c.getColumnIndex("providerModel")) - c.close() - - return arrayOf(withId(noteId), fromList(listId), ContentProviderModel.withId(listId)) - } - - @JvmStatic - @Notify(notifyMethod = NotifyMethod.DELETE, paths = arrayOf(ENDPOINT + "/#")) - fun onDelete(context: Context, uri: Uri): Array { - val noteId = java.lang.Long.valueOf(uri.pathSegments[1])!! - val c = context.contentResolver.query(uri, null, null, null, null) - c!!.moveToFirst() - val listId = c.getLong(c.getColumnIndex("providerModel")) - c.close() - - return arrayOf(withId(noteId), fromList(listId), ContentProviderModel.withId(listId)) - } - } - - @TableEndpoint(name = TestSyncableModel.ENDPOINT, contentProvider = ContentDatabase::class) - object TestSyncableModel { - - const val ENDPOINT = "TestSyncableModel" - - @ContentUri(path = ENDPOINT, type = "${ContentType.VND_MULTIPLE}${ENDPOINT}") - var CONTENT_URI = buildUri(ENDPOINT) - } -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/query/cache/ModelLruCacheTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/query/cache/ModelLruCacheTest.kt deleted file mode 100644 index ea4fbb46c..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/query/cache/ModelLruCacheTest.kt +++ /dev/null @@ -1,35 +0,0 @@ -package com.raizlabs.dbflow5.query.cache - -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.models.NumberModel -import org.junit.Assert -import org.junit.Test - -class ModelLruCacheTest : BaseUnitTest() { - - - @Test - fun validateCacheAddRemove() { - val cache = SimpleMapCache(10) - cache.addModel(1, NumberModel(1)) - - Assert.assertEquals(1, cache[1]!!.id) - Assert.assertEquals(1, cache.cache.size) - - cache.removeModel(1) - - Assert.assertTrue(cache.cache.isEmpty()) - } - - @Test - fun validateCacheClear() { - val cache = SimpleMapCache(10) - cache.addModel(1, NumberModel(1)) - cache.addModel(2, NumberModel(2)) - Assert.assertEquals(2, cache.cache.size) - - cache.clear() - - Assert.assertTrue(cache.cache.isEmpty()) - } -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/query/cache/SimpleMapCacheTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/query/cache/SimpleMapCacheTest.kt deleted file mode 100644 index adae8b6f6..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/query/cache/SimpleMapCacheTest.kt +++ /dev/null @@ -1,35 +0,0 @@ -package com.raizlabs.dbflow5.query.cache - -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.models.SimpleModel -import org.junit.Assert.assertEquals -import org.junit.Assert.assertTrue -import org.junit.Test - -class SimpleMapCacheTest : BaseUnitTest() { - - @Test - fun validateCacheAddRemove() { - val cache = SimpleMapCache(10) - cache.addModel("1", SimpleModel("1")) - - assertEquals("1", cache["1"]!!.name) - assertEquals(1, cache.cache.size) - - cache.removeModel("1") - - assertTrue(cache.cache.isEmpty()) - } - - @Test - fun validateCacheClear() { - val cache = SimpleMapCache(10) - cache.addModel("1", SimpleModel("1")) - cache.addModel("2", SimpleModel("2")) - assertEquals(2, cache.cache.size) - - cache.clear() - - assertTrue(cache.cache.isEmpty()) - } -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/query/list/FlowCursorIteratorTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/query/list/FlowCursorIteratorTest.kt deleted file mode 100644 index 89b4a1123..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/query/list/FlowCursorIteratorTest.kt +++ /dev/null @@ -1,76 +0,0 @@ -package com.raizlabs.dbflow5.query.list - -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.config.databaseForTable -import com.raizlabs.dbflow5.models.SimpleModel -import com.raizlabs.dbflow5.query.select -import com.raizlabs.dbflow5.structure.save -import org.junit.Assert.assertEquals -import org.junit.Assert.assertFalse -import org.junit.Assert.assertTrue -import org.junit.Test - -/** - * Description: - */ -class FlowCursorIteratorTest : BaseUnitTest() { - - - @Test - fun testCanIterateFullList() { - var count = 0 - databaseForTable().beginTransactionAsync { db -> - (0..9).forEach { - SimpleModel("$it").save(db) - } - (select from SimpleModel::class).cursorList(db).iterator() - }.success { _, iterator -> - assertFalse(iterator.isClosed) - iterator.use { cursorIterator -> - cursorIterator.forEach { - assertEquals("$count", it.name) - count++ - } - } - assertTrue(iterator.isClosed) - }.execute() - } - - @Test - fun testCanIteratePartialList() { - databaseForTable().beginTransactionAsync { db -> - (0..9).forEach { - SimpleModel("$it").save(db) - } - - (select from SimpleModel::class).cursorList(db) - .iterator(2, 7) - }.success { _, iterator -> - var count = 0 - iterator.forEach { - assertEquals("${count + 2}", it.name) - count++ - } - assertEquals(7, count) - }.execute() - } - - @Test - fun testCanSupplyBadMaximumValue() { - databaseForTable().beginTransactionAsync { db -> - (0..9).forEach { - SimpleModel("$it").save() - } - - (select from SimpleModel::class).cursorList(db) - .iterator(2, Long.MAX_VALUE) - }.success { _, iterator -> - var count = 0 - iterator.forEach { - assertEquals("${count + 2}", it.name) - count++ - } - assertEquals(8, count) - }.execute() - } -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/query/list/FlowCursorListTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/query/list/FlowCursorListTest.kt deleted file mode 100644 index 2197c74cb..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/query/list/FlowCursorListTest.kt +++ /dev/null @@ -1,81 +0,0 @@ -package com.raizlabs.dbflow5.query.list - -import com.nhaarman.mockito_kotlin.mock -import com.nhaarman.mockito_kotlin.times -import com.nhaarman.mockito_kotlin.verify -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.config.databaseForTable -import com.raizlabs.dbflow5.models.SimpleModel -import com.raizlabs.dbflow5.query.cursor -import com.raizlabs.dbflow5.query.select -import com.raizlabs.dbflow5.structure.save -import org.junit.Assert.assertEquals -import org.junit.Test - -/** - * Description: - */ -class FlowCursorListTest : BaseUnitTest() { - - @Test - fun validateCursorPassed() { - databaseForTable { - val cursor = (select from SimpleModel::class).cursor - val list = FlowCursorList.Builder(select from SimpleModel::class, this) - .cursor(cursor) - .build() - - assertEquals(cursor, list.cursor) - } - } - - @Test - fun validateModelQueriable() { - databaseForTable { - val modelQueriable = (select from SimpleModel::class) - val list = FlowCursorList.Builder(modelQueriable, this) - .build() - - assertEquals(modelQueriable, list.modelQueriable) - } - } - - @Test - fun validateGetAll() { - databaseForTable { - (0..9).forEach { - SimpleModel("$it").save() - } - - val list = (select from SimpleModel::class).cursorList(this) - val all = list.all - assertEquals(list.count, all.size.toLong()) - } - } - - @Test - fun validateCursorChange() { - databaseForTable { - (0..9).forEach { - SimpleModel("$it").save() - } - - val list = (select from SimpleModel::class).cursorList(this) - - val listener = mock>() - list.addOnCursorRefreshListener(listener) - assertEquals(10, list.count) - SimpleModel("10").save() - list.refresh() - assertEquals(11, list.count) - - verify(listener).onCursorRefreshed(list) - - list.removeOnCursorRefreshListener(listener) - - list.refresh() - verify(listener, times(1)).onCursorRefreshed(list) - } - } -} - diff --git a/tests/src/test/java/com/raizlabs/dbflow5/runtime/DirectNotifierTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/runtime/DirectNotifierTest.kt deleted file mode 100644 index 683665faf..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/runtime/DirectNotifierTest.kt +++ /dev/null @@ -1,94 +0,0 @@ -package com.raizlabs.dbflow5.runtime - -import android.content.Context -import com.nhaarman.mockito_kotlin.mock -import com.nhaarman.mockito_kotlin.verify -import com.raizlabs.dbflow5.ImmediateTransactionManager2 -import com.raizlabs.dbflow5.TestDatabase -import com.raizlabs.dbflow5.config.DatabaseConfig -import com.raizlabs.dbflow5.config.FlowConfig -import com.raizlabs.dbflow5.config.FlowManager -import com.raizlabs.dbflow5.config.databaseForTable -import com.raizlabs.dbflow5.database.AndroidSQLiteOpenHelper -import com.raizlabs.dbflow5.models.SimpleModel -import com.raizlabs.dbflow5.models.SimpleModel_Table -import com.raizlabs.dbflow5.query.columnValues -import com.raizlabs.dbflow5.query.delete -import com.raizlabs.dbflow5.query.insert -import com.raizlabs.dbflow5.query.set -import com.raizlabs.dbflow5.query.update -import com.raizlabs.dbflow5.structure.ChangeAction -import com.raizlabs.dbflow5.structure.delete -import com.raizlabs.dbflow5.structure.insert -import com.raizlabs.dbflow5.structure.save -import com.raizlabs.dbflow5.structure.update -import org.junit.After -import org.junit.Before -import org.junit.Test -import org.junit.runner.RunWith -import org.mockito.Mockito -import org.robolectric.RobolectricTestRunner -import org.robolectric.RuntimeEnvironment -import org.robolectric.annotation.Config - -@RunWith(RobolectricTestRunner::class) -@Config(manifest = Config.NONE) -class DirectNotifierTest { - - val context: Context - get() = RuntimeEnvironment.application - - @Before - fun setupTest() { - FlowManager.init(FlowConfig.Builder(context) - .database(DatabaseConfig.Builder(TestDatabase::class.java, - AndroidSQLiteOpenHelper.createHelperCreator(context)) - .transactionManagerCreator(::ImmediateTransactionManager2) - .build()).build()) - } - - @Test - fun validateCanNotifyDirect() { - val simpleModel = SimpleModel("Name") - - val modelChange = mock>() - DirectModelNotifier.get().registerForModelStateChanges(SimpleModel::class.java, modelChange) - - simpleModel.insert() - verify(modelChange).onModelChanged(simpleModel, ChangeAction.INSERT) - - simpleModel.update() - verify(modelChange).onModelChanged(simpleModel, ChangeAction.UPDATE) - - simpleModel.save() - verify(modelChange).onModelChanged(simpleModel, ChangeAction.CHANGE) - - simpleModel.delete() - verify(modelChange).onModelChanged(simpleModel, ChangeAction.DELETE) - } - - @Test - fun validateCanNotifyWrapperClasses() { - databaseForTable { - val modelChange = Mockito.mock(OnTableChangedListener::class.java) - DirectModelNotifier.get().registerForTableChanges(SimpleModel::class.java, modelChange) - - insert().columnValues(SimpleModel_Table.name to "name").executeInsert(this) - - verify(modelChange).onTableChanged(SimpleModel::class.java, ChangeAction.INSERT) - - (update() set SimpleModel_Table.name.eq("name2")).executeUpdateDelete(this) - - verify(modelChange).onTableChanged(SimpleModel::class.java, ChangeAction.UPDATE) - - delete().executeUpdateDelete(this) - - verify(modelChange).onTableChanged(SimpleModel::class.java, ChangeAction.DELETE) - } - } - - @After - fun teardown() { - FlowManager.destroy() - } -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/rx2/TransactionObservablesTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/rx2/TransactionObservablesTest.kt deleted file mode 100644 index 5c3d6f451..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/rx2/TransactionObservablesTest.kt +++ /dev/null @@ -1,60 +0,0 @@ -package com.raizlabs.dbflow5.rx2 - -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.TestDatabase -import com.raizlabs.dbflow5.config.database -import com.raizlabs.dbflow5.database.DatabaseWrapper -import com.raizlabs.dbflow5.models.SimpleModel -import com.raizlabs.dbflow5.query.list -import com.raizlabs.dbflow5.query.result -import com.raizlabs.dbflow5.query.select -import com.raizlabs.dbflow5.reactivestreams.transaction.asMaybe -import com.raizlabs.dbflow5.reactivestreams.transaction.asSingle -import com.raizlabs.dbflow5.structure.save -import org.junit.Assert.assertEquals -import org.junit.Assert.assertNull -import org.junit.Assert.assertTrue -import org.junit.Test - -/** - * Description: - */ -class TransactionObservablesTest : BaseUnitTest() { - - @Test - fun testObservableRun() { - var successCalled = false - var list: List? = null - database() - .beginTransactionAsync { db: DatabaseWrapper -> - (0 until 10).forEach { - SimpleModel("$it").save(db) - } - } - .asSingle() - .doAfterSuccess { - database() - .beginTransactionAsync { (select from SimpleModel::class).list } - .asSingle() - .subscribe { loadedList: MutableList -> - list = loadedList - successCalled = true - } - }.subscribe() - - assertTrue(successCalled) - assertEquals(10, list!!.size) - } - - @Test - fun testMaybe() { - var simpleModel: SimpleModel? = SimpleModel() - database() - .beginTransactionAsync { (select from SimpleModel::class).result } - .asMaybe() - .subscribe { - simpleModel = it - } - assertNull(simpleModel) - } -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/rx2/query/CursorResultSubscriberTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/rx2/query/CursorResultSubscriberTest.kt deleted file mode 100644 index 286413352..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/rx2/query/CursorResultSubscriberTest.kt +++ /dev/null @@ -1,88 +0,0 @@ -package com.raizlabs.dbflow5.rx2.query - -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.config.databaseForTable -import com.raizlabs.dbflow5.models.SimpleModel -import com.raizlabs.dbflow5.models.SimpleModel_Table -import com.raizlabs.dbflow5.query.insert -import com.raizlabs.dbflow5.query.requireResult -import com.raizlabs.dbflow5.query.select -import com.raizlabs.dbflow5.reactivestreams.query.queryStreamResults -import com.raizlabs.dbflow5.reactivestreams.transaction.asFlowable -import com.raizlabs.dbflow5.structure.delete -import com.raizlabs.dbflow5.structure.insert -import com.raizlabs.dbflow5.structure.save -import org.junit.Assert.assertEquals -import org.junit.Test - -class CursorResultSubscriberTest : BaseUnitTest() { - - @Test - fun testCanQueryStreamResults() { - databaseForTable { - (0..9).forEach { SimpleModel("$it").save() } - - var count = 0 - (select from SimpleModel::class) - .queryStreamResults(this) - .subscribe { - count++ - assert(it != null) - } - - assertEquals(10, count) - } - } - - @Test - fun testCanObserveOnTableChangesWithModelOps() { - var count = 0 - (select from SimpleModel::class) - .asFlowable { databaseWrapper, modelQueriable -> modelQueriable.queryList(databaseWrapper) } - .subscribe { - count++ - } - val model = SimpleModel("test") - model.save() - - model.delete() - - model.insert() - - assertEquals(4, count) // once for subscription, 3 for operations - } - - @Test - fun testCanObserveOnTableChangesWithTableOps() { - var count = 0 - var curList: MutableList = arrayListOf() - (select from SimpleModel::class) - .asFlowable { databaseWrapper, modelQueriable -> modelQueriable.queryList(databaseWrapper) } - .subscribe { - curList = it - count++ - } - insert(SimpleModel::class, SimpleModel_Table.name) - .values("test") - .executeInsert(databaseForTable()) - insert(SimpleModel::class, SimpleModel_Table.name) - .values("test1") - .executeInsert(databaseForTable()) - insert(SimpleModel::class, SimpleModel_Table.name) - .values("test2") - .executeInsert(databaseForTable()) - - - assertEquals(3, curList.size) - - val model = (select - from SimpleModel::class - where SimpleModel_Table.name.eq("test")).requireResult - model.delete() - - assertEquals(2, curList.size) - - assertEquals(5, count) // once for subscription, 4 for operations - } - -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/rx2/query/RXFlowableTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/rx2/query/RXFlowableTest.kt deleted file mode 100644 index b6ec090f9..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/rx2/query/RXFlowableTest.kt +++ /dev/null @@ -1,68 +0,0 @@ -package com.raizlabs.dbflow5.rx2.query - -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.models.Author -import com.raizlabs.dbflow5.models.Author_Table -import com.raizlabs.dbflow5.models.Blog -import com.raizlabs.dbflow5.models.Blog_Table -import com.raizlabs.dbflow5.models.SimpleModel -import com.raizlabs.dbflow5.models.SimpleModel_Table -import com.raizlabs.dbflow5.query.cast -import com.raizlabs.dbflow5.query.select -import com.raizlabs.dbflow5.reactivestreams.transaction.asFlowable -import com.raizlabs.dbflow5.structure.save -import org.junit.Assert.assertEquals -import org.junit.Test - -/** - * Description: - */ -class RXFlowableTest : BaseUnitTest() { - - @Test - fun testCanObserveChanges() { - - (0..100).forEach { SimpleModel("$it").save() } - - var list = mutableListOf() - var triggerCount = 0 - val subscription = (select from SimpleModel::class - where cast(SimpleModel_Table.name).asInteger().greaterThan(50)) - .asFlowable { db, modelQueriable -> modelQueriable.queryList(db) } - .subscribe { - list = it - triggerCount += 1 - } - - assertEquals(50, list.size) - subscription.dispose() - - SimpleModel("should not trigger").save() - assertEquals(1, triggerCount) - - } - - @Test - fun testObservesJoinTables() { - val joinOn = Blog_Table.name.withTable() - .eq(Author_Table.first_name.withTable() + " " + Author_Table.last_name.withTable()) - assertEquals("`Blog`.`name`=`Author`.`first_name`+' '+`Author`.`last_name`", joinOn.query) - - var list = mutableListOf() - var calls = 0 - (select from Blog::class - leftOuterJoin Author::class - on joinOn) - .asFlowable { db, modelQueriable -> modelQueriable.queryList(db) } - .subscribe { - calls++ - list = it - } - - val authors = (0 until 10).map { Author(it, firstName = "${it}name", lastName = "${it}last") } - (0 until 10).forEach { Blog(it, name = "${it}name ${it}last", author = authors[it]).save() } - - assertEquals(21, calls) // 1 for initial, 10 for each model object - assertEquals(10, list.size) - } -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/rx2/query/RXQueryTests.kt b/tests/src/test/java/com/raizlabs/dbflow5/rx2/query/RXQueryTests.kt deleted file mode 100644 index eabff4b6d..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/rx2/query/RXQueryTests.kt +++ /dev/null @@ -1,81 +0,0 @@ -package com.raizlabs.dbflow5.rx2.query - -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.config.databaseForTable -import com.raizlabs.dbflow5.database.DatabaseStatement -import com.raizlabs.dbflow5.database.FlowCursor -import com.raizlabs.dbflow5.models.SimpleModel -import com.raizlabs.dbflow5.models.SimpleModel_Table.name -import com.raizlabs.dbflow5.query.insert -import com.raizlabs.dbflow5.query.property.Property -import com.raizlabs.dbflow5.query.select -import com.raizlabs.dbflow5.query.selectCountOf -import com.raizlabs.dbflow5.reactivestreams.transaction.asMaybe -import com.raizlabs.dbflow5.reactivestreams.transaction.asSingle -import com.raizlabs.dbflow5.structure.save -import org.junit.Assert.assertEquals -import org.junit.Test - -class RXQueryTests : BaseUnitTest() { - - @Test - fun testCanQuery() { - SimpleModel("Name").save() - - var cursor: FlowCursor? = null - databaseForTable() - .beginTransactionAsync { (select from SimpleModel::class).cursor(it) } - .asMaybe() - .subscribe { - cursor = it - } - - assertEquals(1, cursor!!.count) - cursor!!.close() - } - - @Test - fun testCanCompileStatement() { - var databaseStatement: DatabaseStatement? = null - databaseForTable() - .beginTransactionAsync { - insert().columnValues(name.`is`("name")).compileStatement(it) - }.asSingle() - .subscribe { statement -> - databaseStatement = statement - } - databaseStatement!!.close() - } - - @Test - fun testCountMethod() { - SimpleModel("name").save() - SimpleModel("name2").save() - var count = 0L - databaseForTable() - .beginTransactionAsync { - (selectCountOf(Property.ALL_PROPERTY) from SimpleModel::class).longValue(it) - } - .asSingle() - .subscribe { value -> - count = value - } - - assertEquals(2, count) - } - - @Test - fun testInsertMethod() { - var count = 0L - databaseForTable() - .beginTransactionAsync { - (insert().columnValues(name.eq("name"))).executeInsert(it) - }.asSingle() - .subscribe { c -> - count = c - } - - assertEquals(1, count) - } - -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/rx2/query/RxModels.kt b/tests/src/test/java/com/raizlabs/dbflow5/rx2/query/RxModels.kt deleted file mode 100644 index 14a7dd23c..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/rx2/query/RxModels.kt +++ /dev/null @@ -1,10 +0,0 @@ -package com.raizlabs.dbflow5.rx2.query - -import com.raizlabs.dbflow5.TestDatabase -import com.raizlabs.dbflow5.annotation.PrimaryKey -import com.raizlabs.dbflow5.annotation.Table -import com.raizlabs.dbflow5.reactivestreams.structure.BaseRXModel - - -@Table(database = TestDatabase::class, allFields = true) -class SimpleRXModel(@PrimaryKey var id: String = "") : BaseRXModel() \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/CaseTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/sql/language/CaseTest.kt deleted file mode 100644 index 77f83bc95..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/CaseTest.kt +++ /dev/null @@ -1,33 +0,0 @@ -package com.raizlabs.dbflow5.sql.language - -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.models.SimpleModel_Table -import com.raizlabs.dbflow5.query.case -import com.raizlabs.dbflow5.query.caseWhen -import com.raizlabs.dbflow5.query.property.propertyString -import org.junit.Assert.* -import org.junit.Test - -class CaseTest : BaseUnitTest() { - - @Test - fun simpleCaseTest() { - val case = case(propertyString("country")) - .whenever("USA") - .then("Domestic") - .`else`("Foreign") - assertEquals("CASE country WHEN 'USA' THEN 'Domestic' ELSE 'Foreign' END `Country`", - case.end("Country").query.trim()) - assertTrue(case.isEfficientCase) - } - - @Test - fun searchedCaseTest() { - val case = caseWhen(SimpleModel_Table.name.eq("USA")).then("Domestic") - .whenever(SimpleModel_Table.name.eq("CA")).then("Canada") - .`else`("Foreign") - assertEquals("CASE WHEN `name`='USA' THEN 'Domestic' WHEN `name`='CA' THEN 'Canada' ELSE 'Foreign'", - case.query.trim()) - assertFalse(case.isEfficientCase) - } -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/DeleteTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/sql/language/DeleteTest.kt deleted file mode 100644 index b1b5efb8d..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/DeleteTest.kt +++ /dev/null @@ -1,46 +0,0 @@ -package com.raizlabs.dbflow5.sql.language - -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.config.databaseForTable -import com.raizlabs.dbflow5.models.SimpleModel -import com.raizlabs.dbflow5.models.SimpleModel_Table -import com.raizlabs.dbflow5.query.delete -import com.raizlabs.dbflow5.query.list -import com.raizlabs.dbflow5.query.select -import com.raizlabs.dbflow5.structure.save -import org.junit.Assert.assertEquals -import org.junit.Assert.assertFalse -import org.junit.Test - -class DeleteTest : BaseUnitTest() { - - @Test - fun validateQuery() { - databaseForTable { - assertEquals("DELETE ", delete().query) - } - } - - @Test - fun validateDeletion() { - databaseForTable { - SimpleModel("name").save() - delete().execute(this) - assertFalse((select from SimpleModel::class).hasData(this)) - } - } - - @Test - fun validateDeletionWithQuery() { - databaseForTable { - SimpleModel("name").save() - SimpleModel("another name").save() - - val where = delete().where(SimpleModel_Table.name.`is`("name")) - assertEquals("DELETE FROM `SimpleModel` WHERE `name`='name'", where.query.trim()) - where.execute(this) - - assertEquals(1, (select from SimpleModel::class).list.size) - } - } -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/ExistenceOperatorTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/sql/language/ExistenceOperatorTest.kt deleted file mode 100644 index 9ca031d56..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/ExistenceOperatorTest.kt +++ /dev/null @@ -1,25 +0,0 @@ -package com.raizlabs.dbflow5.sql.language - -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.config.databaseForTable -import com.raizlabs.dbflow5.models.SimpleModel -import com.raizlabs.dbflow5.models.SimpleModel_Table -import com.raizlabs.dbflow5.query.ExistenceOperator -import com.raizlabs.dbflow5.query.select -import org.junit.Assert.assertEquals -import org.junit.Test - -class ExistenceOperatorTest : BaseUnitTest() { - - - @Test - fun validateQuery() { - databaseForTable { - assertEquals("EXISTS (SELECT * FROM `SimpleModel` WHERE `name`='name')", - ExistenceOperator( - (select from SimpleModel::class - where SimpleModel_Table.name.eq("name"))) - .query.trim()) - } - } -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/FromTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/sql/language/FromTest.kt deleted file mode 100644 index 9b856d472..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/FromTest.kt +++ /dev/null @@ -1,46 +0,0 @@ -package com.raizlabs.dbflow5.sql.language - -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.models.SimpleModel -import com.raizlabs.dbflow5.models.SimpleModel_Table.name -import com.raizlabs.dbflow5.models.TwoColumnModel -import com.raizlabs.dbflow5.models.TwoColumnModel_Table -import com.raizlabs.dbflow5.models.TwoColumnModel_Table.id -import com.raizlabs.dbflow5.query.select -import org.junit.Assert.assertEquals -import org.junit.Assert.assertTrue -import org.junit.Test - -class FromTest : BaseUnitTest() { - - @Test - fun validateSimpleFrom() { - assertEquals("SELECT * FROM `SimpleModel`", (select from SimpleModel::class).query.trim()) - } - - @Test - fun validateProjectionFrom() { - assertEquals("SELECT `name` FROM `SimpleModel`", (select(name) from SimpleModel::class).query.trim()) - } - - @Test - fun validateMultipleProjection() { - assertEquals("SELECT `name`,`name`,`id` FROM `SimpleModel`", - (select(name, TwoColumnModel_Table.name, id) from SimpleModel::class).query.trim()) - } - - @Test - fun validateAlias() { - assertEquals("SELECT * FROM `SimpleModel` AS `Simple`", (select from SimpleModel::class `as` "Simple").query.trim()) - } - - @Test - fun validateJoins() { - val from = (select from SimpleModel::class - innerJoin TwoColumnModel::class - on name.eq(TwoColumnModel_Table.name.withTable())) - assertEquals("SELECT * FROM `SimpleModel` INNER JOIN `TwoColumnModel` ON `name`=`TwoColumnModel`.`name`", - from.query.trim()) - assertTrue(from.associatedTables.isNotEmpty()) - } -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/IndexTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/sql/language/IndexTest.kt deleted file mode 100644 index f6c8f6a19..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/IndexTest.kt +++ /dev/null @@ -1,38 +0,0 @@ -package com.raizlabs.dbflow5.sql.language - -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.config.databaseForTable -import com.raizlabs.dbflow5.models.SimpleModel -import com.raizlabs.dbflow5.models.SimpleModel_Table -import com.raizlabs.dbflow5.query.indexOn -import com.raizlabs.dbflow5.query.nameAlias -import org.junit.Assert.assertEquals -import org.junit.Test - -class IndexTest : BaseUnitTest() { - - @Test - fun validateBasicIndex() { - databaseForTable { - assertEquals("CREATE INDEX IF NOT EXISTS `index` ON `SimpleModel`(`name`)", - indexOn("index", SimpleModel_Table.name).query) - } - } - - @Test - fun validateUniqueIndex() { - databaseForTable { - assertEquals("CREATE UNIQUE INDEX IF NOT EXISTS `index` ON `SimpleModel`(`name`, `test`)", - indexOn("index").unique(true).and(SimpleModel_Table.name) - .and("test".nameAlias).query) - } - } - - @Test - fun validateBasicIndexNameAlias() { - databaseForTable { - assertEquals("CREATE INDEX IF NOT EXISTS `index` ON `SimpleModel`(`name`, `test`)", - indexOn("index", "name".nameAlias, "test".nameAlias).query) - } - } -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/IndexedByTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/sql/language/IndexedByTest.kt deleted file mode 100644 index 6b776f666..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/IndexedByTest.kt +++ /dev/null @@ -1,22 +0,0 @@ -package com.raizlabs.dbflow5.sql.language - -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.config.databaseForTable -import com.raizlabs.dbflow5.models.SimpleModel -import com.raizlabs.dbflow5.models.SimpleModel_Table -import com.raizlabs.dbflow5.query.property.IndexProperty -import com.raizlabs.dbflow5.query.select -import org.junit.Assert.assertEquals -import org.junit.Test - -class IndexedByTest : BaseUnitTest() { - - @Test - fun validateQuery() { - databaseForTable { - val indexed = (select from SimpleModel::class) - .indexedBy(IndexProperty("Index", false, SimpleModel::class.java, SimpleModel_Table.name)) - assertEquals("SELECT * FROM `SimpleModel` INDEXED BY `Index`", indexed.query.trim()) - } - } -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/InsertTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/sql/language/InsertTest.kt deleted file mode 100644 index 96b97c4f5..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/InsertTest.kt +++ /dev/null @@ -1,95 +0,0 @@ -package com.raizlabs.dbflow5.sql.language - -import android.content.ContentValues -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.config.databaseForTable -import com.raizlabs.dbflow5.database.set -import com.raizlabs.dbflow5.models.SimpleModel -import com.raizlabs.dbflow5.models.TwoColumnModel -import com.raizlabs.dbflow5.models.TwoColumnModel_Table.id -import com.raizlabs.dbflow5.models.TwoColumnModel_Table.name -import com.raizlabs.dbflow5.query.NameAlias -import com.raizlabs.dbflow5.query.Operator -import com.raizlabs.dbflow5.query.OperatorGroup -import com.raizlabs.dbflow5.query.insert -import com.raizlabs.dbflow5.query.select -import org.junit.Assert.assertEquals -import org.junit.Test - -class InsertTest : BaseUnitTest() { - - @Test - fun validateInsert() { - databaseForTable { - assertEquals("INSERT INTO `SimpleModel` VALUES('something')", - insert().values("something").query.trim()) - } - } - - @Test - fun validateInsertOr() { - databaseForTable { - assertEquals("INSERT OR REPLACE INTO `SimpleModel` VALUES('something')", - insert().orReplace().values("something").query.trim()) - assertEquals("INSERT OR FAIL INTO `SimpleModel` VALUES('something')", - insert().orFail().values("something").query.trim()) - assertEquals("INSERT OR IGNORE INTO `SimpleModel` VALUES('something')", - insert().orIgnore().values("something").query.trim()) - assertEquals("INSERT OR REPLACE INTO `SimpleModel` VALUES('something')", - insert().orReplace().values("something").query.trim()) - assertEquals("INSERT OR ROLLBACK INTO `SimpleModel` VALUES('something')", - insert().orRollback().values("something").query.trim()) - assertEquals("INSERT OR ABORT INTO `SimpleModel` VALUES('something')", - insert().orAbort().values("something").query.trim()) - } - } - - @Test - fun validateInsertProjection() { - databaseForTable { - assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 'id')", - insert().columns(name, id).values("name", "id").query.trim()) - } - } - - @Test - fun validateSelect() { - databaseForTable { - assertEquals("INSERT INTO `TwoColumnModel` SELECT * FROM `SimpleModel`", - insert().select(select from SimpleModel::class).query.trim()) - } - } - - @Test - fun validateColumns() { - databaseForTable { - assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 'id')", - insert().asColumns().values("name", "id").query.trim()) - assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 'id')", - insert().columns("name", "id").values("name", "id").query.trim()) - assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 'id')", - insert().columns(listOf(name, id)).values("name", "id").query.trim()) - } - } - - @Test - fun validateColumnValues() { - databaseForTable { - assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 0)", - insert().columnValues(name.eq("name"), id.eq(0)).query.trim()) - assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 0)", - insert().columnValues(Operator.op(NameAlias.builder("name").build()).eq("name"), - id.eq(0)).query.trim()) - assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 0)", - insert().columnValues(OperatorGroup.clause().andAll(name.eq("name"), id.eq(0))).query.trim()) - - val contentValues = ContentValues() - contentValues["name"] = "name" - contentValues["id"] = 0.toInt() - - assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 0)", - insert().columnValues(contentValues).query.trim()) - - } - } -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/JoinTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/sql/language/JoinTest.kt deleted file mode 100644 index a1f93ed7f..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/JoinTest.kt +++ /dev/null @@ -1,86 +0,0 @@ -package com.raizlabs.dbflow5.sql.language - -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.config.databaseForTable -import com.raizlabs.dbflow5.models.SimpleModel -import com.raizlabs.dbflow5.models.SimpleModel_Table -import com.raizlabs.dbflow5.models.TwoColumnModel -import com.raizlabs.dbflow5.models.TwoColumnModel_Table -import com.raizlabs.dbflow5.query.select -import org.junit.Assert.assertEquals -import org.junit.Test - - -class JoinTest : BaseUnitTest() { - - @Test - fun validateAliasJoin() { - databaseForTable { - assertEquals("SELECT * FROM `SimpleModel` INNER JOIN `TwoColumnModel` AS `Name` ON `TwoColumnModel`.`name`=`name`", - ((select from SimpleModel::class innerJoin - TwoColumnModel::class).`as`("Name") on TwoColumnModel_Table.name.withTable().eq(SimpleModel_Table.name)).query.trim()) - } - } - - @Test - fun testInnerJoin() { - databaseForTable { - val join = select from SimpleModel::class innerJoin - TwoColumnModel::class on TwoColumnModel_Table.name.withTable().eq(SimpleModel_Table.name) - assertEquals("SELECT * FROM `SimpleModel` INNER JOIN `TwoColumnModel` ON `TwoColumnModel`.`name`=`name`", - join.query.trim()) - } - } - - @Test - fun testLeftOuterJoin() { - databaseForTable { - val join = select from SimpleModel::class leftOuterJoin - TwoColumnModel::class on TwoColumnModel_Table.name.withTable().eq(SimpleModel_Table.name) - assertEquals("SELECT * FROM `SimpleModel` LEFT OUTER JOIN `TwoColumnModel` ON `TwoColumnModel`.`name`=`name`", - join.query.trim()) - } - } - - @Test - fun testCrossJoin() { - databaseForTable { - val join = select from SimpleModel::class crossJoin - TwoColumnModel::class on TwoColumnModel_Table.name.withTable().eq(SimpleModel_Table.name) - assertEquals("SELECT * FROM `SimpleModel` CROSS JOIN `TwoColumnModel` ON `TwoColumnModel`.`name`=`name`", - join.query.trim()) - } - } - - @Test - fun testMultiJoin() { - databaseForTable { - val join = select from SimpleModel::class innerJoin - TwoColumnModel::class on TwoColumnModel_Table.name.withTable().eq(SimpleModel_Table.name) crossJoin - TwoColumnModel::class on TwoColumnModel_Table.id.withTable().eq(SimpleModel_Table.name) - assertEquals("SELECT * FROM `SimpleModel` INNER JOIN `TwoColumnModel` ON `TwoColumnModel`.`name`=`name`" + - " CROSS JOIN `TwoColumnModel` ON `TwoColumnModel`.`id`=`name`", - join.query.trim()) - } - } - - @Test - fun testInnerJoinOnUsing() { - databaseForTable { - val join = select from SimpleModel::class innerJoin - TwoColumnModel::class using SimpleModel_Table.name.withTable() - assertEquals("SELECT * FROM `SimpleModel` INNER JOIN `TwoColumnModel` USING (`SimpleModel`.`name`)", - join.query.trim()) - } - } - - @Test - fun testNaturalJoin() { - databaseForTable { - val join = (select from SimpleModel::class naturalJoin - TwoColumnModel::class).end() - assertEquals("SELECT * FROM `SimpleModel` NATURAL JOIN `TwoColumnModel`", - join.query.trim()) - } - } -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/MethodTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/sql/language/MethodTest.kt deleted file mode 100644 index 2310c8a44..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/MethodTest.kt +++ /dev/null @@ -1,77 +0,0 @@ -package com.raizlabs.dbflow5.sql.language - -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.models.TwoColumnModel_Table.id -import com.raizlabs.dbflow5.models.TwoColumnModel_Table.name -import com.raizlabs.dbflow5.query.avg -import com.raizlabs.dbflow5.query.cast -import com.raizlabs.dbflow5.query.count -import com.raizlabs.dbflow5.query.date -import com.raizlabs.dbflow5.query.datetime -import com.raizlabs.dbflow5.query.groupConcat -import com.raizlabs.dbflow5.query.ifNull -import com.raizlabs.dbflow5.query.max -import com.raizlabs.dbflow5.query.min -import com.raizlabs.dbflow5.query.nullIf -import com.raizlabs.dbflow5.query.replace -import com.raizlabs.dbflow5.query.strftime -import com.raizlabs.dbflow5.query.sum -import com.raizlabs.dbflow5.query.total -import com.raizlabs.dbflow5.sql.SQLiteType -import org.junit.Assert.assertEquals -import org.junit.Test - -class MethodTest : BaseUnitTest() { - - @Test - fun testMainMethods() { - assertEquals("AVG(`name`, `id`)", avg(name, id).query) - assertEquals("COUNT(`name`, `id`)", count(name, id).query) - assertEquals("GROUP_CONCAT(`name`, `id`)", groupConcat(name, id).query) - assertEquals("MAX(`name`, `id`)", max(name, id).query) - assertEquals("MIN(`name`, `id`)", min(name, id).query) - assertEquals("SUM(`name`, `id`)", sum(name, id).query) - assertEquals("TOTAL(`name`, `id`)", total(name, id).query) - assertEquals("CAST(`name` AS INTEGER)", cast(name).`as`(SQLiteType.INTEGER).query) - assertEquals("REPLACE(`name`, 'Andrew', 'Grosner')", replace(name, "Andrew", "Grosner").query) - } - - @Test - fun test_strftime() { - assertEquals("strftime('%s', 'now')", strftime("%s", "now").query) - } - - @Test - fun test_dateMethod() { - assertEquals("date('now', 'start of month', '+1 month')", - date("now", "start of month", "+1 month").query) - } - - @Test - fun test_datetimeMethod() { - assertEquals("datetime(1092941466, 'unix epoch')", - datetime(1092941466, "unix epoch").query) - } - - @Test - fun testIfNull() { - assertEquals("IFNULL(`name`, `id`)", ifNull(name, id).query) - } - - @Test - fun testNulllIf() { - assertEquals("NULLIF(`name`, `id`)", nullIf(name, id).query) - } - - @Test - fun testOpMethods() { - assertEquals("AVG(`name` + `id`)", avg(name + id).query) - assertEquals("AVG(`name` + `id`)", (avg(name) + id).query) - assertEquals("AVG(`name` - `id`)", avg(name - id).query) - assertEquals("AVG(`name` - `id`)", (avg(name) - id).query) - assertEquals("AVG(`name` / `id`)", avg(name / id).query) - assertEquals("AVG(`name` * `id`)", (avg(name) * id).query) - assertEquals("AVG(`name` % `id`)", avg(name % id).query) - assertEquals("AVG(`name` % `id`)", (avg(name) % id).query) - } -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/NameAliasTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/sql/language/NameAliasTest.kt deleted file mode 100644 index 5688d8c60..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/NameAliasTest.kt +++ /dev/null @@ -1,42 +0,0 @@ -package com.raizlabs.dbflow5.sql.language - -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.query.NameAlias -import com.raizlabs.dbflow5.query.`as` -import com.raizlabs.dbflow5.query.nameAlias -import org.junit.Assert.assertEquals -import org.junit.Assert.assertFalse -import org.junit.Test - -class NameAliasTest : BaseUnitTest() { - - @Test - fun testSimpleCase() { - assertEquals("`name`", "name".nameAlias.query) - } - - @Test - fun testAlias() { - assertEquals("`name` AS `alias`", "name".`as`("alias").fullQuery) - } - - @Test - fun validateBuilder() { - val nameAlias = NameAlias.builder("name") - .keyword("DISTINCT") - .`as`("Alias") - .withTable("MyTable") - .shouldAddIdentifierToAliasName(false) - .shouldAddIdentifierToName(false) - .shouldStripAliasName(false) - .shouldStripIdentifier(false).build() - assertEquals("DISTINCT", nameAlias.keyword) - assertEquals("Alias", nameAlias.aliasName()) - assertEquals("Alias", nameAlias.aliasNameRaw()) - assertEquals("`MyTable`", nameAlias.tableName) - assertFalse(nameAlias.shouldStripAliasName) - assertFalse(nameAlias.shouldStripIdentifier) - assertEquals("Alias", nameAlias.nameAsKey) - assertEquals("DISTINCT `MyTable`.name AS Alias", nameAlias.fullQuery) - } -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/OperatorGroupTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/sql/language/OperatorGroupTest.kt deleted file mode 100644 index 43cfed123..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/OperatorGroupTest.kt +++ /dev/null @@ -1,48 +0,0 @@ -package com.raizlabs.dbflow5.sql.language - -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.assertEquals -import com.raizlabs.dbflow5.models.TwoColumnModel_Table.id -import com.raizlabs.dbflow5.models.TwoColumnModel_Table.name -import com.raizlabs.dbflow5.query.OperatorGroup -import com.raizlabs.dbflow5.query.and -import com.raizlabs.dbflow5.query.andAll -import com.raizlabs.dbflow5.query.or -import com.raizlabs.dbflow5.query.orAll -import org.junit.Test - -class OperatorGroupTest : BaseUnitTest() { - - - @Test - fun validateCommaSeparated() { - "(`name`='name', `id`=0)".assertEquals(OperatorGroup.clause().setAllCommaSeparated(true).andAll(name.eq("name"), id.eq(0))) - } - - @Test - fun validateParanthesis() { - "`name`='name'".assertEquals(OperatorGroup.nonGroupingClause(name.eq("name")).setUseParenthesis(false)) - } - - @Test - fun validateOr() { - "(`name`='name' OR `id`=0)".assertEquals(name.eq("name") or id.eq(0)) - } - - @Test - fun validateOrAll() { - "(`name`='name' OR `id`=0 OR `name`='test')".assertEquals(name.eq("name") orAll arrayListOf(id.eq(0), name.eq("test"))) - } - - @Test - - fun validateAnd() { - "(`name`='name' AND `id`=0)".assertEquals(name.eq("name") and id.eq(0)) - } - - @Test - fun validateAndAll() { - "(`name`='name' AND `id`=0 AND `name`='test')".assertEquals(name.eq("name") andAll arrayListOf(id.eq(0), name.eq("test"))) - } - -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/OperatorTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/sql/language/OperatorTest.kt deleted file mode 100644 index c3248a397..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/OperatorTest.kt +++ /dev/null @@ -1,65 +0,0 @@ -package com.raizlabs.dbflow5.sql.language - -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.annotation.Collate -import com.raizlabs.dbflow5.assertEquals -import com.raizlabs.dbflow5.config.databaseForTable -import com.raizlabs.dbflow5.models.SimpleModel -import com.raizlabs.dbflow5.models.TwoColumnModel_Table.id -import com.raizlabs.dbflow5.query.op -import com.raizlabs.dbflow5.query.select -import org.junit.Test - -class OperatorTest : BaseUnitTest() { - - @Test - fun testEquals() { - "`name`='name'".assertEquals("name".op().eq("name")) - "`name`='name'".assertEquals("name".op().`is`("name")) - } - - @Test - fun testNotEquals() { - "`name`!='name'".assertEquals("name".op().notEq("name")) - "`name`!='name'".assertEquals("name".op().isNot("name")) - } - - @Test - fun testLike() { - "`name` LIKE 'name'".assertEquals("name".op().like("name")) - "`name` NOT LIKE 'name'".assertEquals("name".op().notLike("name")) - "`name` GLOB 'name'".assertEquals("name".op().glob("name")) - } - - @Test - fun testMath() { - "`name`>'name'".assertEquals("name".op().greaterThan("name")) - "`name`>='name'".assertEquals("name".op().greaterThanOrEq("name")) - "`name`<'name'".assertEquals("name".op().lessThan("name")) - "`name`<='name'".assertEquals("name".op().lessThanOrEq("name")) - "`name`+'name'".assertEquals("name".op() + "name") - "`name`-'name'".assertEquals("name".op() - "name") - "`name`/'name'".assertEquals("name".op() / "name") - "`name`*'name'".assertEquals("name".op() * "name") - "`name`%'name'".assertEquals("name".op() % "name") - } - - @Test - fun testCollate() { - "`name` COLLATE NOCASE".assertEquals("name".op() collate Collate.NOCASE) - "`name` COLLATE NOCASE".assertEquals("name".op() collate "NOCASE") - } - - @Test - fun testBetween() { - "`id` BETWEEN 6 AND 7".assertEquals(id.between(6) and 7) - } - - @Test - fun testIn() { - databaseForTable { - "`id` IN (5,6,7,8,9)".assertEquals(id.`in`(5, 6, 7, 8) and 9) - "`id` NOT IN (SELECT * FROM `SimpleModel`)".assertEquals(id.notIn(select from SimpleModel::class)) - } - } -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/OrderByTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/sql/language/OrderByTest.kt deleted file mode 100644 index 8fb7eef24..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/OrderByTest.kt +++ /dev/null @@ -1,34 +0,0 @@ -package com.raizlabs.dbflow5.sql.language - -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.annotation.Collate -import com.raizlabs.dbflow5.assertEquals -import com.raizlabs.dbflow5.models.SimpleModel_Table.name -import com.raizlabs.dbflow5.query.OrderBy -import com.raizlabs.dbflow5.query.collate -import com.raizlabs.dbflow5.query.nameAlias -import org.junit.Test - -class OrderByTest : BaseUnitTest() { - - - @Test - fun validateBasicOrderBy() { - "`name` ASC".assertEquals(OrderBy.fromProperty(name).ascending()) - } - - @Test - fun validateDescendingOrderBy() { - "`name` DESC".assertEquals(OrderBy.fromNameAlias("name".nameAlias).descending()) - } - - @Test - fun validateCollate() { - "`name` COLLATE RTRIM ASC".assertEquals(OrderBy.fromProperty(name).ascending() collate Collate.RTRIM) - } - - @Test - fun validateCustomOrdrBy() { - "`name` ASC This is custom".assertEquals(OrderBy.fromString("`name` ASC This is custom")) - } -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/SelectTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/sql/language/SelectTest.kt deleted file mode 100644 index c748fc61f..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/SelectTest.kt +++ /dev/null @@ -1,28 +0,0 @@ -package com.raizlabs.dbflow5.sql.language - -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.assertEquals -import com.raizlabs.dbflow5.config.databaseForTable -import com.raizlabs.dbflow5.models.SimpleModel -import com.raizlabs.dbflow5.models.TwoColumnModel -import com.raizlabs.dbflow5.models.TwoColumnModel_Table.id -import com.raizlabs.dbflow5.models.TwoColumnModel_Table.name -import com.raizlabs.dbflow5.query.select -import org.junit.Test - -class SelectTest : BaseUnitTest() { - - @Test - fun validateSelect() { - databaseForTable { - "SELECT `name`,`id` FROM `TwoColumnModel`".assertEquals(select(name, id) from TwoColumnModel::class) - } - } - - @Test - fun validateSelectDistinct() { - databaseForTable { - "SELECT DISTINCT `name` FROM `SimpleModel`".assertEquals(select(name).distinct() from SimpleModel::class) - } - } -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/SetTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/sql/language/SetTest.kt deleted file mode 100644 index 182a6a105..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/SetTest.kt +++ /dev/null @@ -1,28 +0,0 @@ -package com.raizlabs.dbflow5.sql.language - -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.assertEquals -import com.raizlabs.dbflow5.config.databaseForTable -import com.raizlabs.dbflow5.models.SimpleModel -import com.raizlabs.dbflow5.models.SimpleModel_Table.name -import com.raizlabs.dbflow5.models.TwoColumnModel_Table.id -import com.raizlabs.dbflow5.query.set -import com.raizlabs.dbflow5.query.update -import org.junit.Test - -class SetTest : BaseUnitTest() { - - @Test - fun validateSetWithConditions() { - databaseForTable { - "UPDATE `SimpleModel` SET `name`='name'".assertEquals(update() set name.`is`("name")) - } - } - - @Test - fun validateMultipleConditions() { - databaseForTable { - "UPDATE `SimpleModel` SET `name`='name', `id`=0".assertEquals(update() set name.eq("name") and id.eq(0)) - } - } -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/TriggerTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/sql/language/TriggerTest.kt deleted file mode 100644 index 8a5949f8c..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/TriggerTest.kt +++ /dev/null @@ -1,69 +0,0 @@ -package com.raizlabs.dbflow5.sql.language - -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.assertEquals -import com.raizlabs.dbflow5.config.databaseForTable -import com.raizlabs.dbflow5.models.SimpleModel -import com.raizlabs.dbflow5.models.SimpleModel_Table.name -import com.raizlabs.dbflow5.models.TwoColumnModel -import com.raizlabs.dbflow5.models.TwoColumnModel_Table.id -import com.raizlabs.dbflow5.query.NameAlias -import com.raizlabs.dbflow5.query.cast -import com.raizlabs.dbflow5.query.columnValues -import com.raizlabs.dbflow5.query.createTempTrigger -import com.raizlabs.dbflow5.query.createTrigger -import com.raizlabs.dbflow5.query.insert -import com.raizlabs.dbflow5.query.insertOn -import com.raizlabs.dbflow5.query.property.property -import com.raizlabs.dbflow5.query.select -import com.raizlabs.dbflow5.query.updateOn -import com.raizlabs.dbflow5.sql.SQLiteType -import com.raizlabs.dbflow5.structure.insert -import org.junit.Assert.assertNotNull -import org.junit.Test - -class TriggerTest : BaseUnitTest() { - - @Test - fun validateBasicTrigger() { - databaseForTable { - ("CREATE TRIGGER IF NOT EXISTS `MyTrigger` AFTER INSERT ON `SimpleModel` " + - "\nBEGIN" + - "\nINSERT INTO `TwoColumnModel`(`name`) VALUES(`new`.`name`);" + - "\nEND").assertEquals(createTrigger("MyTrigger").after() insertOn SimpleModel::class begin - insert(TwoColumnModel::class).columnValues(name to NameAlias.ofTable("new", "name"))) - } - } - - @Test - fun validateUpdateTriggerMultiline() { - databaseForTable { - ("CREATE TEMP TRIGGER IF NOT EXISTS `MyTrigger` BEFORE UPDATE ON `SimpleModel` " + - "\nBEGIN" + - "\nINSERT INTO `TwoColumnModel`(`name`) VALUES(`new`.`name`);" + - "\nINSERT INTO `TwoColumnModel`(`id`) VALUES(CAST(`new`.`name` AS INTEGER));" + - "\nEND") - .assertEquals( - ( - createTempTrigger("MyTrigger").before() updateOn SimpleModel::class - begin - insert(TwoColumnModel::class, name).values(NameAlias.ofTable("new", "name")) - and - insert(TwoColumnModel::class, id).values( - cast(NameAlias.ofTable("new", "name").property).`as`(SQLiteType.INTEGER)))) - } - } - - @Test - fun validateTriggerWorks() { - databaseForTable { - val trigger = createTrigger("MyTrigger").after() insertOn SimpleModel::class begin - insert(TwoColumnModel::class).columnValues(name to NameAlias.ofTable("new", "name")) - trigger.enable(this) - SimpleModel("Test").insert() - - val result = select from TwoColumnModel::class where (name eq "Test") - assertNotNull(result) - } - } -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/UnsafeStringOperatorTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/sql/language/UnsafeStringOperatorTest.kt deleted file mode 100644 index c7d233120..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/UnsafeStringOperatorTest.kt +++ /dev/null @@ -1,21 +0,0 @@ -package com.raizlabs.dbflow5.sql.language - -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.assertEquals -import com.raizlabs.dbflow5.config.databaseForTable -import com.raizlabs.dbflow5.models.SimpleModel -import com.raizlabs.dbflow5.query.UnSafeStringOperator -import com.raizlabs.dbflow5.query.select -import org.junit.Test - -class UnsafeStringOperatorTest : BaseUnitTest() { - - @Test - fun testCanIncludeInQuery() { - databaseForTable { - val op = UnSafeStringOperator("name = ?, id = ?, test = ?", arrayOf("'name'", "0", "'test'")) - "name = 'name', id = 0, test = 'test'".assertEquals(op) - "SELECT * FROM `SimpleModel` WHERE name = 'name', id = 0, test = 'test'".assertEquals(select from SimpleModel::class where op) - } - } -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/UpdateTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/sql/language/UpdateTest.kt deleted file mode 100644 index 2724e0e3b..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/UpdateTest.kt +++ /dev/null @@ -1,68 +0,0 @@ -package com.raizlabs.dbflow5.sql.language - -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.annotation.ConflictAction -import com.raizlabs.dbflow5.assertEquals -import com.raizlabs.dbflow5.config.databaseForTable -import com.raizlabs.dbflow5.models.NumberModel -import com.raizlabs.dbflow5.models.NumberModel_Table.id -import com.raizlabs.dbflow5.models.SimpleModel -import com.raizlabs.dbflow5.models.SimpleModel_Table.name -import com.raizlabs.dbflow5.query.property.Property -import com.raizlabs.dbflow5.query.set -import com.raizlabs.dbflow5.query.update -import org.junit.Test - -class UpdateTest : BaseUnitTest() { - - @Test - fun validateUpdateRollback() { - databaseForTable { - "UPDATE OR ROLLBACK `SimpleModel`".assertEquals(update().orRollback()) - } - } - - @Test - fun validateUpdateFail() { - databaseForTable { - "UPDATE OR FAIL `SimpleModel`".assertEquals(update().orFail()) - } - } - - @Test - fun validateUpdateIgnore() { - databaseForTable { - "UPDATE OR IGNORE `SimpleModel`".assertEquals(update().orIgnore()) - } - } - - @Test - fun validateUpdateReplace() { - databaseForTable { - "UPDATE OR REPLACE `SimpleModel`".assertEquals(update().orReplace()) - } - } - - @Test - fun validateUpdateAbort() { - databaseForTable { - "UPDATE OR ABORT `SimpleModel`".assertEquals(update().orAbort()) - } - } - - @Test - fun validateSetQuery() { - databaseForTable { - "UPDATE `SimpleModel` SET `name`='name'".assertEquals(update() set (name eq "name")) - } - } - - @Test - fun validateWildcardQuery() { - databaseForTable { - "UPDATE OR FAIL `NumberModel` SET `id`=? WHERE `id`=?".assertEquals(update().or(ConflictAction.FAIL) - .set(id.eq(Property.WILDCARD)) - .where(id.eq(Property.WILDCARD))) - } - } -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/WhereTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/sql/language/WhereTest.kt deleted file mode 100644 index f987c406f..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/WhereTest.kt +++ /dev/null @@ -1,180 +0,0 @@ -package com.raizlabs.dbflow5.sql.language - -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.assertEquals -import com.raizlabs.dbflow5.config.databaseForTable -import com.raizlabs.dbflow5.models.SimpleModel -import com.raizlabs.dbflow5.models.SimpleModel_Table.name -import com.raizlabs.dbflow5.models.TwoColumnModel -import com.raizlabs.dbflow5.models.TwoColumnModel_Table.id -import com.raizlabs.dbflow5.query.OrderBy.Companion.fromNameAlias -import com.raizlabs.dbflow5.query.Where -import com.raizlabs.dbflow5.query.groupBy -import com.raizlabs.dbflow5.query.having -import com.raizlabs.dbflow5.query.list -import com.raizlabs.dbflow5.query.nameAlias -import com.raizlabs.dbflow5.query.or -import com.raizlabs.dbflow5.query.result -import com.raizlabs.dbflow5.query.select -import com.raizlabs.dbflow5.query.update -import org.junit.Assert.assertTrue -import org.junit.Assert.fail -import org.junit.Test - -class WhereTest : BaseUnitTest() { - - @Test - fun validateBasicWhere() { - databaseForTable { - val query = select from SimpleModel::class where name.`is`("name") - "SELECT * FROM `SimpleModel` WHERE `name`='name'".assertEquals(query) - assertCanCopyQuery(query) - } - } - - @Test - fun validateComplexQueryWhere() { - databaseForTable { - val query = select from SimpleModel::class where name.`is`("name") or id.eq(1) and (id.`is`(0) or name.eq("hi")) - "SELECT * FROM `SimpleModel` WHERE `name`='name' OR `id`=1 AND (`id`=0 OR `name`='hi')".assertEquals(query) - assertCanCopyQuery(query) - } - } - - @Test - fun validateGroupBy() { - databaseForTable { - val query = select from SimpleModel::class where name.`is`("name") groupBy name - "SELECT * FROM `SimpleModel` WHERE `name`='name' GROUP BY `name`".assertEquals(query) - assertCanCopyQuery(query) - - } - } - - @Test - fun validateGroupByNameAlias() { - databaseForTable { - val query = (select from SimpleModel::class where name.`is`("name")).groupBy("name".nameAlias, "id".nameAlias) - "SELECT * FROM `SimpleModel` WHERE `name`='name' GROUP BY `name`,`id`".assertEquals(query) - assertCanCopyQuery(query) - } - } - - @Test - fun validateGroupByNameProps() { - databaseForTable { - val query = (select from SimpleModel::class where name.`is`("name")).groupBy(name, id) - "SELECT * FROM `SimpleModel` WHERE `name`='name' GROUP BY `name`,`id`".assertEquals(query) - assertCanCopyQuery(query) - } - } - - @Test - fun validateHaving() { - databaseForTable { - val query = select from SimpleModel::class where name.`is`("name") having name.like("That") - "SELECT * FROM `SimpleModel` WHERE `name`='name' HAVING `name` LIKE 'That'".assertEquals(query) - assertCanCopyQuery(query) - } - } - - @Test - fun validateLimit() { - databaseForTable { - val query = select from SimpleModel::class where name.`is`("name") limit 10 - "SELECT * FROM `SimpleModel` WHERE `name`='name' LIMIT 10".assertEquals(query) - assertCanCopyQuery(query) - } - } - - @Test - fun validateOffset() { - databaseForTable { - val query = select from SimpleModel::class where name.`is`("name") offset 10 - "SELECT * FROM `SimpleModel` WHERE `name`='name' OFFSET 10".assertEquals(query) - assertCanCopyQuery(query) - } - } - - @Test - fun validateWhereExists() { - databaseForTable { - val query = (select from SimpleModel::class - whereExists (select(name) from SimpleModel::class where name.like("Andrew"))) - ("SELECT * FROM `SimpleModel` " + - "WHERE EXISTS (SELECT `name` FROM `SimpleModel` WHERE `name` LIKE 'Andrew')").assertEquals(query) - assertCanCopyQuery(query) - } - } - - @Test - fun validateOrderByWhere() { - databaseForTable { - val query = (select from SimpleModel::class - where name.eq("name")).orderBy(name, true) - ("SELECT * FROM `SimpleModel` WHERE `name`='name' ORDER BY `name` ASC").assertEquals(query) - assertCanCopyQuery(query) - } - } - - @Test - fun validateOrderByWhereAlias() { - databaseForTable { - val query = (select from SimpleModel::class - where name.eq("name")).orderBy("name".nameAlias, true) - ("SELECT * FROM `SimpleModel` " + - "WHERE `name`='name' ORDER BY `name` ASC").assertEquals(query) - assertCanCopyQuery(query) - } - } - - @Test - fun validateOrderBy() { - databaseForTable { - val query = (select from SimpleModel::class - where name.eq("name") orderBy fromNameAlias("name".nameAlias).ascending()) - ("SELECT * FROM `SimpleModel` " + - "WHERE `name`='name' ORDER BY `name` ASC").assertEquals(query) - assertCanCopyQuery(query) - } - } - - private fun assertCanCopyQuery(query: Where) { - val actual = query.cloneSelf() - query.assertEquals(actual) - assertTrue(actual !== query) - } - - @Test - fun validateOrderByAll() { - databaseForTable { - val query = (select from TwoColumnModel::class - where name.eq("name")) - .orderByAll(listOf( - fromNameAlias("name".nameAlias).ascending(), - fromNameAlias("id".nameAlias).descending())) - ("SELECT * FROM `TwoColumnModel` " + - "WHERE `name`='name' ORDER BY `name` ASC,`id` DESC").assertEquals(query) - assertCanCopyQuery(query) - } - } - - @Test - fun validateNonSelectThrowError() { - databaseForTable { - try { - update().set(name.`is`("name")).result - fail("Non select passed") - } catch (i: IllegalArgumentException) { - // expected - } - - try { - update().set(name.`is`("name")).list - fail("Non select passed") - } catch (i: IllegalArgumentException) { - // expected - } - } - } -} diff --git a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/BytePropertyTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/BytePropertyTest.kt deleted file mode 100644 index 563bf32c7..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/BytePropertyTest.kt +++ /dev/null @@ -1,42 +0,0 @@ -package com.raizlabs.dbflow5.sql.language.property - -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.models.SimpleModel -import com.raizlabs.dbflow5.query.NameAlias -import com.raizlabs.dbflow5.query.property.Property -import org.junit.Assert.assertEquals -import org.junit.Test - -class BytePropertyTest : BaseUnitTest() { - - @Test - fun testOperators() { - val prop = Property(SimpleModel::class.java, "Prop") - assertEquals("`Prop`=5", prop.`is`(5).query.trim()) - assertEquals("`Prop`=5", prop.eq(5).query.trim()) - assertEquals("`Prop`!=5", prop.notEq(5).query.trim()) - assertEquals("`Prop`!=5", prop.isNot(5).query.trim()) - assertEquals("`Prop`>5", prop.greaterThan(5).query.trim()) - assertEquals("`Prop`>=5", prop.greaterThanOrEq(5).query.trim()) - assertEquals("`Prop`<5", prop.lessThan(5).query.trim()) - assertEquals("`Prop`<=5", prop.lessThanOrEq(5).query.trim()) - assertEquals("`Prop` BETWEEN 5 AND 6", prop.between(5).and(6).query.trim()) - assertEquals("`Prop` IN (5,6,7,8)", prop.`in`(5, 6, 7, 8).query.trim()) - assertEquals("`Prop` NOT IN (5,6,7,8)", prop.notIn(5, 6, 7, 8).query.trim()) - assertEquals("`Prop`=`Prop` + 5", prop.concatenate(5).query.trim()) - } - - @Test - fun testAlias() { - val prop = Property(SimpleModel::class.java, "Prop", "Alias") - assertEquals("`Prop` AS `Alias`", prop.toString().trim()) - - val prop2 = Property(SimpleModel::class.java, - NameAlias.builder("Prop") - .shouldAddIdentifierToName(false) - .`as`("Alias") - .shouldAddIdentifierToAliasName(false) - .build()) - assertEquals("Prop AS Alias", prop2.toString().trim()) - } -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/CharPropertyTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/CharPropertyTest.kt deleted file mode 100644 index b959d2f25..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/CharPropertyTest.kt +++ /dev/null @@ -1,42 +0,0 @@ -package com.raizlabs.dbflow5.sql.language.property - -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.models.SimpleModel -import com.raizlabs.dbflow5.query.NameAlias -import com.raizlabs.dbflow5.query.property.Property -import org.junit.Assert.assertEquals -import org.junit.Test - -class CharPropertyTest : BaseUnitTest() { - - @Test - fun testOperators() { - val prop = Property(SimpleModel::class.java, "Prop") - assertEquals("`Prop`='5'", prop.`is`('5').query.trim()) - assertEquals("`Prop`='5'", prop.eq('5').query.trim()) - assertEquals("`Prop`!='5'", prop.notEq('5').query.trim()) - assertEquals("`Prop`!='5'", prop.isNot('5').query.trim()) - assertEquals("`Prop`>'5'", prop.greaterThan('5').query.trim()) - assertEquals("`Prop`>='5'", prop.greaterThanOrEq('5').query.trim()) - assertEquals("`Prop`<'5'", prop.lessThan('5').query.trim()) - assertEquals("`Prop`<='5'", prop.lessThanOrEq('5').query.trim()) - assertEquals("`Prop` BETWEEN '5' AND '6'", prop.between('5').and('6').query.trim()) - assertEquals("`Prop` IN ('5','6','7','8')", prop.`in`('5', '6', '7', '8').query.trim()) - assertEquals("`Prop` NOT IN ('5','6','7','8')", prop.notIn('5', '6', '7', '8').query.trim()) - assertEquals("`Prop`=`Prop` || '5'", prop.concatenate('5').query.trim()) - } - - @Test - fun testAlias() { - val prop = Property(SimpleModel::class.java, "Prop", "Alias") - assertEquals("`Prop` AS `Alias`", prop.toString().trim()) - - val prop2 = Property(SimpleModel::class.java, - NameAlias.builder("Prop") - .shouldAddIdentifierToName(false) - .`as`("Alias") - .shouldAddIdentifierToAliasName(false) - .build()) - assertEquals("Prop AS Alias", prop2.toString().trim()) - } -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/DoublePropertyTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/DoublePropertyTest.kt deleted file mode 100644 index e12e4912c..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/DoublePropertyTest.kt +++ /dev/null @@ -1,42 +0,0 @@ -package com.raizlabs.dbflow5.sql.language.property - -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.models.SimpleModel -import com.raizlabs.dbflow5.query.NameAlias -import com.raizlabs.dbflow5.query.property.Property -import org.junit.Assert.assertEquals -import org.junit.Test - -class DoublePropertyTest : BaseUnitTest() { - - @Test - fun testOperators() { - val prop = Property(SimpleModel::class.java, "Prop") - assertEquals("`Prop`=5.0", prop.`is`(5.0).query.trim()) - assertEquals("`Prop`=5.0", prop.eq(5.0).query.trim()) - assertEquals("`Prop`!=5.0", prop.notEq(5.0).query.trim()) - assertEquals("`Prop`!=5.0", prop.isNot(5.0).query.trim()) - assertEquals("`Prop`>5.0", prop.greaterThan(5.0).query.trim()) - assertEquals("`Prop`>=5.0", prop.greaterThanOrEq(5.0).query.trim()) - assertEquals("`Prop`<5.0", prop.lessThan(5.0).query.trim()) - assertEquals("`Prop`<=5.0", prop.lessThanOrEq(5.0).query.trim()) - assertEquals("`Prop` BETWEEN 5.0 AND 6.0", prop.between(5.0).and(6.0).query.trim()) - assertEquals("`Prop` IN (5.0,6.0,7.0,8.0)", prop.`in`(5.0, 6.0, 7.0, 8.0).query.trim()) - assertEquals("`Prop` NOT IN (5.0,6.0,7.0,8.0)", prop.notIn(5.0, 6.0, 7.0, 8.0).query.trim()) - assertEquals("`Prop`=`Prop` + 5.0", prop.concatenate(5.0).query.trim()) - } - - @Test - fun testAlias() { - val prop = Property(SimpleModel::class.java, "Prop", "Alias") - assertEquals("`Prop` AS `Alias`", prop.toString().trim()) - - val prop2 = Property(SimpleModel::class.java, - NameAlias.builder("Prop") - .shouldAddIdentifierToName(false) - .`as`("Alias") - .shouldAddIdentifierToAliasName(false) - .build()) - assertEquals("Prop AS Alias", prop2.toString().trim()) - } -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/FloatPropertyTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/FloatPropertyTest.kt deleted file mode 100644 index 348baf360..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/FloatPropertyTest.kt +++ /dev/null @@ -1,42 +0,0 @@ -package com.raizlabs.dbflow5.sql.language.property - -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.models.SimpleModel -import com.raizlabs.dbflow5.query.NameAlias -import com.raizlabs.dbflow5.query.property.Property -import org.junit.Assert.assertEquals -import org.junit.Test - -class FloatPropertyTest : BaseUnitTest() { - - @Test - fun testOperators() { - val prop = Property(SimpleModel::class.java, "Prop") - assertEquals("`Prop`=5.0", prop.`is`(5f).query.trim()) - assertEquals("`Prop`=5.0", prop.eq(5f).query.trim()) - assertEquals("`Prop`!=5.0", prop.notEq(5f).query.trim()) - assertEquals("`Prop`!=5.0", prop.isNot(5f).query.trim()) - assertEquals("`Prop`>5.0", prop.greaterThan(5f).query.trim()) - assertEquals("`Prop`>=5.0", prop.greaterThanOrEq(5f).query.trim()) - assertEquals("`Prop`<5.0", prop.lessThan(5f).query.trim()) - assertEquals("`Prop`<=5.0", prop.lessThanOrEq(5f).query.trim()) - assertEquals("`Prop` BETWEEN 5.0 AND 6.0", prop.between(5f).and(6f).query.trim()) - assertEquals("`Prop` IN (5.0,6.0,7.0,8.0)", prop.`in`(5f, 6f, 7f, 8f).query.trim()) - assertEquals("`Prop` NOT IN (5.0,6.0,7.0,8.0)", prop.notIn(5f, 6f, 7f, 8f).query.trim()) - assertEquals("`Prop`=`Prop` + 5.0", prop.concatenate(5f).query.trim()) - } - - @Test - fun testAlias() { - val prop = Property(SimpleModel::class.java, "Prop", "Alias") - assertEquals("`Prop` AS `Alias`", prop.toString().trim()) - - val prop2 = Property(SimpleModel::class.java, - NameAlias.builder("Prop") - .shouldAddIdentifierToName(false) - .`as`("Alias") - .shouldAddIdentifierToAliasName(false) - .build()) - assertEquals("Prop AS Alias", prop2.toString().trim()) - } -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/IndexPropertyTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/IndexPropertyTest.kt deleted file mode 100644 index 419cf934d..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/IndexPropertyTest.kt +++ /dev/null @@ -1,24 +0,0 @@ -package com.raizlabs.dbflow5.sql.language.property - -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.config.databaseForTable -import com.raizlabs.dbflow5.models.SimpleModel -import com.raizlabs.dbflow5.models.SimpleModel_Table -import com.raizlabs.dbflow5.query.property.IndexProperty -import org.junit.Assert.assertEquals -import org.junit.Test - -class IndexPropertyTest : BaseUnitTest() { - - - @Test - fun validateIndexProperty() { - databaseForTable { - val prop = IndexProperty("Index", true, SimpleModel::class.java, - SimpleModel_Table.name) - prop.createIfNotExists(this) - prop.drop(this) - assertEquals("`Index`", prop.indexName) - } - } -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/IntPropertyTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/IntPropertyTest.kt deleted file mode 100644 index 04dfe9aa3..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/IntPropertyTest.kt +++ /dev/null @@ -1,42 +0,0 @@ -package com.raizlabs.dbflow5.sql.language.property - -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.models.SimpleModel -import com.raizlabs.dbflow5.query.NameAlias -import com.raizlabs.dbflow5.query.property.Property -import org.junit.Assert.assertEquals -import org.junit.Test - -class IntPropertyTest : BaseUnitTest() { - - @Test - fun testOperators() { - val prop = Property(SimpleModel::class.java, "Prop") - assertEquals("`Prop`=5", prop.`is`(5).query.trim()) - assertEquals("`Prop`=5", prop.eq(5).query.trim()) - assertEquals("`Prop`!=5", prop.notEq(5).query.trim()) - assertEquals("`Prop`!=5", prop.isNot(5).query.trim()) - assertEquals("`Prop`>5", prop.greaterThan(5).query.trim()) - assertEquals("`Prop`>=5", prop.greaterThanOrEq(5).query.trim()) - assertEquals("`Prop`<5", prop.lessThan(5).query.trim()) - assertEquals("`Prop`<=5", prop.lessThanOrEq(5).query.trim()) - assertEquals("`Prop` BETWEEN 5 AND 6", prop.between(5).and(6).query.trim()) - assertEquals("`Prop` IN (5,6,7,8)", prop.`in`(5, 6, 7, 8).query.trim()) - assertEquals("`Prop` NOT IN (5,6,7,8)", prop.notIn(5, 6, 7, 8).query.trim()) - assertEquals("`Prop`=`Prop` + 5", prop.concatenate(5).query.trim()) - } - - @Test - fun testAlias() { - val prop = Property(SimpleModel::class.java, "Prop", "Alias") - assertEquals("`Prop` AS `Alias`", prop.toString().trim()) - - val prop2 = Property(SimpleModel::class.java, - NameAlias.builder("Prop") - .shouldAddIdentifierToName(false) - .`as`("Alias") - .shouldAddIdentifierToAliasName(false) - .build()) - assertEquals("Prop AS Alias", prop2.toString().trim()) - } -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/LongPropertyTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/LongPropertyTest.kt deleted file mode 100644 index b9ef8175c..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/LongPropertyTest.kt +++ /dev/null @@ -1,42 +0,0 @@ -package com.raizlabs.dbflow5.sql.language.property - -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.models.SimpleModel -import com.raizlabs.dbflow5.query.NameAlias -import com.raizlabs.dbflow5.query.property.Property -import org.junit.Assert.assertEquals -import org.junit.Test - -class LongPropertyTest : BaseUnitTest() { - - @Test - fun testOperators() { - val prop = Property(SimpleModel::class.java, "Prop") - assertEquals("`Prop`=5", prop.`is`(5).query.trim()) - assertEquals("`Prop`=5", prop.eq(5).query.trim()) - assertEquals("`Prop`!=5", prop.notEq(5).query.trim()) - assertEquals("`Prop`!=5", prop.isNot(5).query.trim()) - assertEquals("`Prop`>5", prop.greaterThan(5).query.trim()) - assertEquals("`Prop`>=5", prop.greaterThanOrEq(5).query.trim()) - assertEquals("`Prop`<5", prop.lessThan(5).query.trim()) - assertEquals("`Prop`<=5", prop.lessThanOrEq(5).query.trim()) - assertEquals("`Prop` BETWEEN 5 AND 6", prop.between(5).and(6).query.trim()) - assertEquals("`Prop` IN (5,6,7,8)", prop.`in`(5, 6, 7, 8).query.trim()) - assertEquals("`Prop` NOT IN (5,6,7,8)", prop.notIn(5, 6, 7, 8).query.trim()) - assertEquals("`Prop`=`Prop` + 5", prop.concatenate(5).query.trim()) - } - - @Test - fun testAlias() { - val prop = Property(SimpleModel::class.java, "Prop", "Alias") - assertEquals("`Prop` AS `Alias`", prop.toString().trim()) - - val prop2 = Property(SimpleModel::class.java, - NameAlias.builder("Prop") - .shouldAddIdentifierToName(false) - .`as`("Alias") - .shouldAddIdentifierToAliasName(false) - .build()) - assertEquals("Prop AS Alias", prop2.toString().trim()) - } -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/PropertyFactoryTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/PropertyFactoryTest.kt deleted file mode 100644 index 672b78786..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/PropertyFactoryTest.kt +++ /dev/null @@ -1,30 +0,0 @@ -package com.raizlabs.dbflow5.sql.language.property - -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.config.databaseForTable -import com.raizlabs.dbflow5.models.SimpleModel -import com.raizlabs.dbflow5.query.property.property -import com.raizlabs.dbflow5.query.property.propertyString -import com.raizlabs.dbflow5.query.select -import org.junit.Assert.assertEquals -import org.junit.Test - -class PropertyFactoryTest : BaseUnitTest() { - - @Test - fun testPrimitives() { - assertEquals("'c'", 'c'.property.query) - assertEquals("5", 5.property.query) - assertEquals("5.0", 5.0.property.query) - assertEquals("5.0", 5.0f.property.query) - assertEquals("5", 5L.property.query) - assertEquals("5", 5.toShort().property.query) - assertEquals("5", 5.toByte().property.query) - val nullable: Any? = null - assertEquals("NULL", nullable.property.query) - databaseForTable { - assertEquals("(SELECT * FROM `SimpleModel`)", (select from SimpleModel::class).property.query) - } - assertEquals("SomethingCool", propertyString("SomethingCool").query) - } -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/PropertyTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/PropertyTest.kt deleted file mode 100644 index 80aee56b1..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/PropertyTest.kt +++ /dev/null @@ -1,45 +0,0 @@ -package com.raizlabs.dbflow5.sql.language.property - -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.models.SimpleModel -import com.raizlabs.dbflow5.query.NameAlias -import com.raizlabs.dbflow5.query.property.Property -import org.junit.Assert -import org.junit.Test - -class PropertyTest : BaseUnitTest() { - - @Test - fun testOperators() { - val prop = Property(SimpleModel::class.java, "Prop") - Assert.assertEquals("`Prop`='5'", prop.`is`("5").query.trim()) - Assert.assertEquals("`Prop`='5'", prop.eq("5").query.trim()) - Assert.assertEquals("`Prop`!='5'", prop.notEq("5").query.trim()) - Assert.assertEquals("`Prop`!='5'", prop.isNot("5").query.trim()) - Assert.assertEquals("`Prop` LIKE '5'", prop.like("5").query.trim()) - Assert.assertEquals("`Prop` NOT LIKE '5'", prop.notLike("5").query.trim()) - Assert.assertEquals("`Prop` GLOB '5'", prop.glob("5").query.trim()) - Assert.assertEquals("`Prop`>'5'", prop.greaterThan("5").query.trim()) - Assert.assertEquals("`Prop`>='5'", prop.greaterThanOrEq("5").query.trim()) - Assert.assertEquals("`Prop`<'5'", prop.lessThan("5").query.trim()) - Assert.assertEquals("`Prop`<='5'", prop.lessThanOrEq("5").query.trim()) - Assert.assertEquals("`Prop` BETWEEN '5' AND '6'", prop.between("5").and("6").query.trim()) - Assert.assertEquals("`Prop` IN ('5','6','7','8')", prop.`in`("5", "6", "7", "8").query.trim()) - Assert.assertEquals("`Prop` NOT IN ('5','6','7','8')", prop.notIn("5", "6", "7", "8").query.trim()) - Assert.assertEquals("`Prop`=`Prop` || '5'", prop.concatenate("5").query.trim()) - } - - @Test - fun testAlias() { - val prop = Property(SimpleModel::class.java, "Prop", "Alias") - Assert.assertEquals("`Prop` AS `Alias`", prop.toString().trim()) - - val prop2 = Property(SimpleModel::class.java, - NameAlias.builder("Prop") - .shouldAddIdentifierToName(false) - .`as`("Alias") - .shouldAddIdentifierToAliasName(false) - .build()) - Assert.assertEquals("Prop AS Alias", prop2.toString().trim()) - } -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/ShortPropertyTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/ShortPropertyTest.kt deleted file mode 100644 index 0e54eb960..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/ShortPropertyTest.kt +++ /dev/null @@ -1,42 +0,0 @@ -package com.raizlabs.dbflow5.sql.language.property - -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.models.SimpleModel -import com.raizlabs.dbflow5.query.NameAlias -import com.raizlabs.dbflow5.query.property.Property -import org.junit.Assert.assertEquals -import org.junit.Test - -class ShortPropertyTest : BaseUnitTest() { - - @Test - fun testOperators() { - val prop = Property(SimpleModel::class.java, "Prop") - assertEquals("`Prop`=5", prop.`is`(5).query.trim()) - assertEquals("`Prop`=5", prop.eq(5).query.trim()) - assertEquals("`Prop`!=5", prop.notEq(5).query.trim()) - assertEquals("`Prop`!=5", prop.isNot(5).query.trim()) - assertEquals("`Prop`>5", prop.greaterThan(5).query.trim()) - assertEquals("`Prop`>=5", prop.greaterThanOrEq(5).query.trim()) - assertEquals("`Prop`<5", prop.lessThan(5).query.trim()) - assertEquals("`Prop`<=5", prop.lessThanOrEq(5).query.trim()) - assertEquals("`Prop` BETWEEN 5 AND 6", prop.between(5).and(6).query.trim()) - assertEquals("`Prop` IN (5,6,7,8)", prop.`in`(5, 6, 7, 8).query.trim()) - assertEquals("`Prop` NOT IN (5,6,7,8)", prop.notIn(5, 6, 7, 8).query.trim()) - assertEquals("`Prop`=`Prop` + 5", prop.concatenate(5).query.trim()) - } - - @Test - fun testAlias() { - val prop = Property(SimpleModel::class.java, "Prop", "Alias") - assertEquals("`Prop` AS `Alias`", prop.toString().trim()) - - val prop2 = Property(SimpleModel::class.java, - NameAlias.builder("Prop") - .shouldAddIdentifierToName(false) - .`as`("Alias") - .shouldAddIdentifierToAliasName(false) - .build()) - assertEquals("Prop AS Alias", prop2.toString().trim()) - } -} \ No newline at end of file diff --git a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/TypeConvertedPropertyTest.kt b/tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/TypeConvertedPropertyTest.kt deleted file mode 100644 index e0c5a0446..000000000 --- a/tests/src/test/java/com/raizlabs/dbflow5/sql/language/property/TypeConvertedPropertyTest.kt +++ /dev/null @@ -1,42 +0,0 @@ -package com.raizlabs.dbflow5.sql.language.property - -import com.raizlabs.dbflow5.BaseUnitTest -import com.raizlabs.dbflow5.converter.DateConverter -import com.raizlabs.dbflow5.converter.TypeConverter -import com.raizlabs.dbflow5.models.Difficulty -import com.raizlabs.dbflow5.models.EnumTypeConverterModel_Table -import com.raizlabs.dbflow5.models.SimpleModel -import com.raizlabs.dbflow5.query.NameAlias -import com.raizlabs.dbflow5.query.property.TypeConvertedProperty -import org.junit.Assert.assertEquals -import org.junit.Test -import java.util.* - -class TypeConvertedPropertyTest : BaseUnitTest() { - - - @Test - fun testTypeConverter() { - val property = TypeConvertedProperty(SimpleModel::class.java, "Prop", true, - object : TypeConvertedProperty.TypeConverterGetter { - override fun getTypeConverter(modelClass: Class<*>): TypeConverter<*, *> = DateConverter() - }) - assertEquals("`Prop`", property.toString()) - - val date = Date() - assertEquals("`Prop`=${date.time}", property.eq(date).query) - - assertEquals("`SimpleModel`.`Prop`=${date.time}", property.withTable().eq(date).query) - - val inverted = property.invertProperty() - assertEquals("`Prop`=5050505", inverted.eq(5050505).query) - } - - @Test - fun testCustomEnumTypeConverter() { - - assertEquals("`difficulty`='H'", EnumTypeConverterModel_Table.difficulty.eq(Difficulty.HARD).query) - assertEquals("`EnumTypeConverterModel`.`difficulty`='H'", EnumTypeConverterModel_Table.difficulty.withTable().eq(Difficulty.HARD).query) - assertEquals("`et`.`difficulty`='H'", EnumTypeConverterModel_Table.difficulty.withTable(NameAlias.tableNameBuilder("et").build()).eq(Difficulty.HARD).query) - } -} \ No newline at end of file diff --git a/usage2/ContentProviderGeneration.md b/usage2/ContentProviderGeneration.md index fd461cb72..fe6f1e601 100644 --- a/usage2/ContentProviderGeneration.md +++ b/usage2/ContentProviderGeneration.md @@ -15,7 +15,7 @@ In order to define a `ContentProvider`, you must define it in a placeholder clas baseContentUri = TestContentProvider.BASE_CONTENT_URI) public class TestContentProvider { - public static final String AUTHORITY = "com.raizlabs.dbflow5.test.provider"; + public static final String AUTHORITY = "com.dbflow5.test.provider"; public static final String BASE_CONTENT_URI = "content://"; @@ -36,7 +36,7 @@ public class TestDatabase { public static final int VERSION = "1"; - public static final String AUTHORITY = "com.raizlabs.dbflow5.test.provider"; + public static final String AUTHORITY = "com.dbflow5.test.provider"; public static final String BASE_CONTENT_URI = "content://"; @@ -49,7 +49,7 @@ In other applications or your current's `AndroidManifest.xml` add the **generate ```xml ``` diff --git a/usage2/Intro.md b/usage2/Intro.md index 39bfafd30..5e06f124f 100644 --- a/usage2/Intro.md +++ b/usage2/Intro.md @@ -63,7 +63,7 @@ Since DBFlow uses annotation processing, which is run pre-proguard phase, the configuration is highly minimal: ``` --keep class * extends com.raizlabs.dbflow5.config.DatabaseHolder { *; } +-keep class * extends com.dbflow5.config.DatabaseHolder { *; } ``` ## Sections diff --git a/usage2/KotlinSupport.md b/usage2/KotlinSupport.md index fde094179..74824a419 100644 --- a/usage2/KotlinSupport.md +++ b/usage2/KotlinSupport.md @@ -2,15 +2,6 @@ DBFlow supports Kotlin out of the box and is fairly easily to use and implement. -To add useful Kotlin-specific extensions: -``` -dependencies { - compile "com.github.Raizlabs.DBFlow:dbflow-kotlinextensions:${dbflow_version}@aar" -} - -``` -We also support [kotlin extensions for RX 1 + 2](RXSupport.md)! - ## Classes DBFlow Classes are beautifully concise to write: diff --git a/usage2/Migrations.md b/usage2/Migrations.md index b9ca5e593..d8a93b87f 100644 --- a/usage2/Migrations.md +++ b/usage2/Migrations.md @@ -105,7 +105,7 @@ For renaming tables, you should rename the `Model` class' `@Table(name = "{newNa this `Migration`. The reason is that DBFlow will know the new name only and the existing database will get caught up on it through this migration. Any new database created on a device will automatically have the new table name. -For adding columns, we only support `SQLiteType` (all supported ones [here](https://www.sqlite.org/datatype3.html)) operations to add or remove columns. This is to enforce that the columns are created properly. If a column needs to be a `TypeConverter` column, use the database value from it. We map the associated type of the database field to a `SQLiteType` in [SQLiteType.java](/dbflow/src/main/java/com/raizlabs/android/dbflow/sql/SQLiteType.java). So if you have a `DateConverter` that specifies a `Date` column converted to `Long`, then you should look up `Long` in the `Map`. In this case `Long` converts to `INTEGER`. +For adding columns, we only support `SQLiteType` (all supported ones [here](https://www.sqlite.org/datatype3.html)) operations to add or remove columns. This is to enforce that the columns are created properly. If a column needs to be a `TypeConverter` column, use the database value from it. We map the associated type of the database field to a `SQLiteType` in [SQLiteType.kt](/dbflow/src/main/java/com/dbflow5/sql/SQLiteType.kt). So if you have a `DateConverter` that specifies a `Date` column converted to `Long`, then you should look up `Long` in the `Map`. In this case `Long` converts to `INTEGER`. ```java diff --git a/usage2/Relationships.md b/usage2/Relationships.md index 6692dc434..48dc2a187 100644 --- a/usage2/Relationships.md +++ b/usage2/Relationships.md @@ -230,7 +230,7 @@ A class can use both: @Table(database = TestDatabase.class) @ManyToMany(referencedTable = TestModel1.class) @MultipleManyToMany({@ManyToMany(referencedTable = TestModel2.class), - @ManyToMany(referencedTable = com.raizlabs.dbflow5.test.sql.TestModel3.class)}) + @ManyToMany(referencedTable = com.dbflow5.test.sql.TestModel3.class)}) public class ManyToManyModel extends BaseModel { @PrimaryKey diff --git a/usage2/TypeConverters.md b/usage2/TypeConverters.md index 31def043a..1b32dee16 100644 --- a/usage2/TypeConverters.md +++ b/usage2/TypeConverters.md @@ -27,7 +27,7 @@ This example creates a `TypeConverter` for a field that is `JSONObject` and conv ```java -@com.raizlabs.dbflow5.annotation.TypeConverter +@com.dbflow5.annotation.TypeConverter public class JSONConverter extends TypeConverter { @Override diff --git a/usage2/including-in-project.md b/usage2/including-in-project.md index 1b58dfa29..ab013a81e 100644 --- a/usage2/including-in-project.md +++ b/usage2/including-in-project.md @@ -6,61 +6,67 @@ DBFlow has a number of artifacts that you can include in the project. **Core:** Contains the main annotations and misc classes that are shared across all of DBFlow. -**DBFlow: **The main library artifact used in conjunction with the previous two artifacts. +**DBFlow:** The main library artifact used in conjunction with the previous two artifacts. -**SCLCipher Support:** Replaces most of inner database interaction with an [Encrypted Database](https://www.zetetic.net/sqlcipher/) that's useful for sensitive information. DBFlow contains wrapper around most of the implementation, so adding it is minimal. +**Coroutines:** Adds coroutine support for queries. -**Kotlin: **DBFlow has Kotlin extensions support for the library, enabling more concise syntax and tons of inline helper methods! Also most of the public library API is annotated with `@Nullable` or `@NonNull`, providing nice interop when used in Kotlin. +**RX Java:** Enable applications to be reactive by listening to DB changes and ensuring your subscribers are up-to-date. -**RXJava: **RX1 and RX2 supported. Wraps around normal DB operations by providing RXJava support for Model CRUD updates and SQLite wrapper language. Also Kotlin extensions exist for RX-specific methods. +**Paging:** Android architecture component paging library support for queries via `QueryDataSource`. + +**SQLCipher:** Easy database encryption support in this library. ### Add the jitpack.io repository This repo is used to publish the artifacts. It also enables [dynamic builds](https://jitpack.io/docs/), allowing you to specify specific branches or commit hashes of the project to include outside of normal releases. -```Groovy +```groovy + allProjects { repositories { + google() // required to find the project's artifacts + // place last maven { url "https://www.jitpack.io" } } } ``` -```Groovy +Add artifacts to your project: - apply plugin: 'kotlin-kapt' // required for Kotlin +```groovy - def dbflow_version = "xxxx" // reference the releases tab on Github for latest versions - // or you can grab a 10-digit commit hash of any commit in the project that builds. + apply plugin: 'kotlin-kapt' // only required for kotlin consumers. + + def dbflow_version = "5.0.0-alpha1" + // or 10-digit short-hash of a specific commit. (Useful for bugs fixed in develop, but not in a release yet) dependencies { - annotationProcessor "com.github.Raizlabs.DBFlow:dbflow-processor:${dbflow_version}" - // use kapt for kotlin apt if you're a Kotlin user - kapt "com.github.Raizlabs.DBFlow:dbflow-processor:${dbflow_version}" + // Use if Kotlin user. + kapt "com.github.agrosner.dbflow:processor:${dbflow_version}" + + // Annotation Processor + // if only using Java, use this. If using Kotlin do NOT use this. + annotationProcessor "com.github.agrosner.dbflow:processor:${dbflow_version}" - compile "com.github.Raizlabs.DBFlow:dbflow-core:${dbflow_version}" - compile "com.github.Raizlabs.DBFlow:dbflow:${dbflow_version}" + + // core set of libraries + compile "com.github.agrosner.dbflow:core:${dbflow_version}" + compile "com.github.agrosner.dbflow:lib:${dbflow_version}" // sql-cipher database encryption (optional) - compile "com.github.Raizlabs.DBFlow:dbflow-sqlcipher:${dbflow_version}" + compile "com.github.agrosner.dbflow:sqlcipher:${dbflow_version}" compile "net.zetetic:android-database-sqlcipher:${sqlcipher_version}@aar" - // kotlin extensions - compile "com.github.Raizlabs.DBFlow:dbflow-kotlinextensions:${dbflow_version}" - - // RXJava 1 support - compile "com.github.Raizlabs.DBFlow:dbflow-rx:${dbflow_version}" - - // RXJava 1 Kotlin Extensions Support - compile "com.github.Raizlabs.DBFlow:dbflow-rx-kotlinextensions:${dbflow_version}" - // RXJava 2 support - compile "com.github.Raizlabs.DBFlow:dbflow-rx2:${dbflow_version}" + compile "com.github.agrosner.dbflow:reactive-streams:${dbflow_version}" + + // Kotlin Coroutines + compile "com.github.agrosner.dbflow:coroutines:${dbflow_version}" - // RXJava 2 Kotlin Extensions Support - compile "com.github.Raizlabs.DBFlow:dbflow-rx2-kotlinextensions:${dbflow_version}" + // Android Architecture Components Paging Library Support + compile "com.github.agrosner.dbflow:paging:${dbflow_version}" } diff --git a/usage2/proguard.md b/usage2/proguard.md index 3c27c2978..0c40189c3 100644 --- a/usage2/proguard.md +++ b/usage2/proguard.md @@ -3,7 +3,7 @@ Since DBFlow uses annotation processing, which is run pre-proguard phase, the configuration is highly minimal. Also since we combine all generated files into the `GeneratedDatabaseHolder`, any other class generated can be obfuscated. ``` --keep class * extends com.raizlabs.dbflow5.config.DatabaseHolder { *; } +-keep class * extends com.dbflow5.config.DatabaseHolder { *; } ``` This also works on modules from other library projects that use DBFlow. From 953b09abf8a4ce028e93fd1ec59a024cdc3b10df Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Thu, 24 May 2018 14:17:47 -0400 Subject: [PATCH 214/234] fix accidental test removal. move content provider classes into separate lib. --- README.md | 3 + contentprovider-annotations/.gitignore | 1 + contentprovider-annotations/build.gradle | 19 ++ contentprovider-annotations/gradle.properties | 3 + .../annotation}/ContentProvider.kt | 2 +- .../contentprovider/annotation}/ContentUri.kt | 2 +- .../contentprovider/annotation}/Notify.kt | 2 +- .../annotation}/TableEndpoint.kt | 2 +- contentprovider/build.gradle | 2 +- .../dbflow5/provider/BaseContentProvider.kt | 0 .../com/dbflow5/provider/BaseProviderModel.kt | 0 .../provider/BaseSyncableProviderModel.kt | 0 .../com/dbflow5/provider/ContentUtils.kt | 2 +- .../com/dbflow5/provider/ModelProvider.kt | 0 .../dbflow5/provider/StubContentProvider.kt | 0 .../dbflow5/query/ContentValuesListener.kt | 3 +- .../main/kotlin/com/dbflow5/query/Where.kt | 29 ++- processor/build.gradle | 1 + .../com/dbflow5/processor/DBFlowProcessor.kt | 4 +- .../kotlin/com/dbflow5/processor/Handlers.kt | 4 +- .../definition/provider/ContentProvider.kt | 10 +- .../definition/provider/NotifyDefinition.kt | 4 +- .../provider/TableEndpointDefinition.kt | 8 +- settings.gradle | 2 +- .../src/test/java/com/dbflow5/BaseUnitTest.kt | 20 ++ .../test/java/com/dbflow5/DBFlowTestRule.kt | 49 +++++ .../dbflow5/ImmediateTransactionManager.kt | 37 ++++ .../src/test/java/com/dbflow5/TestDatabase.kt | 18 ++ .../test/java/com/dbflow5/TestExtensions.kt | 23 ++ .../dbflow5/config/ConfigIntegrationTest.kt | 80 +++++++ .../com/dbflow5/config/DatabaseConfigTest.kt | 88 ++++++++ .../database/transaction/CoroutinesTest.kt | 93 ++++++++ .../FastStoreModelTransactionTest.kt | 64 ++++++ .../migration/UpdateTableMigrationTest.kt | 22 ++ .../com/dbflow5/models/AutoIncrementTest.kt | 33 +++ .../java/com/dbflow5/models/CachingModels.kt | 30 +++ .../com/dbflow5/models/CachingModelsTest.kt | 51 +++++ .../com/dbflow5/models/DontCreateModelTest.kt | 24 ++ .../com/dbflow5/models/ForeignKeyModels.kt | 112 ++++++++++ .../java/com/dbflow5/models/IndexModels.kt | 38 ++++ .../com/dbflow5/models/InnerClassExample.kt | 14 ++ .../java/com/dbflow5/models/ManyToMany.kt | 16 ++ .../java/com/dbflow5/models/ManyToManyTest.kt | 27 +++ .../java/com/dbflow5/models/ModelViewTest.kt | 21 ++ .../java/com/dbflow5/models/ModelViews.kt | 42 ++++ .../models/NonTypical/nonTypicalClassName.kt | 11 + .../com/dbflow5/models/OneToManyModelTest.kt | 49 +++++ .../com/dbflow5/models/OneToManyModels.kt | 51 +++++ .../dbflow5/models/ParentChildCachingTest.kt | 39 ++++ .../java/com/dbflow5/models/QueryModelTest.kt | 37 ++++ .../java/com/dbflow5/models/QueryModels.kt | 29 +++ .../com/dbflow5/models/SimpleTestModels.kt | 208 ++++++++++++++++++ .../dbflow5/models/SimpleTestModelsTest.kt | 22 ++ .../dbflow5/models/java/DatabaseModel.java | 17 ++ .../dbflow5/models/java/JavaModelView.java | 26 +++ .../java/otherpackage/ExampleModel.java | 12 + .../com/dbflow5/paging/QueryDataSourceTest.kt | 60 +++++ .../provider/ContentProviderObjects.kt | 93 ++++++++ .../dbflow5/provider/ContentProviderTests.kt | 133 +++++++++++ .../dbflow5/provider/RealContentProvider.kt | 42 ++++ .../dbflow5/provider/TestContentProvider.kt | 137 ++++++++++++ .../dbflow5/query/cache/ModelLruCacheTest.kt | 35 +++ .../dbflow5/query/cache/SimpleMapCacheTest.kt | 35 +++ .../query/list/FlowCursorIteratorTest.kt | 76 +++++++ .../dbflow5/query/list/FlowCursorListTest.kt | 81 +++++++ .../com/dbflow5/runtime/DirectNotifierTest.kt | 94 ++++++++ .../dbflow5/rx2/TransactionObservablesTest.kt | 60 +++++ .../rx2/query/CursorResultSubscriberTest.kt | 88 ++++++++ .../com/dbflow5/rx2/query/RXFlowableTest.kt | 68 ++++++ .../com/dbflow5/rx2/query/RXQueryTests.kt | 81 +++++++ .../java/com/dbflow5/rx2/query/RxModels.kt | 10 + .../java/com/dbflow5/sql/language/CaseTest.kt | 33 +++ .../com/dbflow5/sql/language/DeleteTest.kt | 46 ++++ .../sql/language/ExistenceOperatorTest.kt | 25 +++ .../java/com/dbflow5/sql/language/FromTest.kt | 46 ++++ .../com/dbflow5/sql/language/IndexTest.kt | 38 ++++ .../com/dbflow5/sql/language/IndexedByTest.kt | 22 ++ .../com/dbflow5/sql/language/InsertTest.kt | 95 ++++++++ .../java/com/dbflow5/sql/language/JoinTest.kt | 86 ++++++++ .../com/dbflow5/sql/language/MethodTest.kt | 77 +++++++ .../com/dbflow5/sql/language/NameAliasTest.kt | 42 ++++ .../dbflow5/sql/language/OperatorGroupTest.kt | 48 ++++ .../com/dbflow5/sql/language/OperatorTest.kt | 65 ++++++ .../com/dbflow5/sql/language/OrderByTest.kt | 34 +++ .../com/dbflow5/sql/language/SelectTest.kt | 28 +++ .../java/com/dbflow5/sql/language/SetTest.kt | 28 +++ .../com/dbflow5/sql/language/TriggerTest.kt | 69 ++++++ .../sql/language/UnsafeStringOperatorTest.kt | 21 ++ .../com/dbflow5/sql/language/UpdateTest.kt | 68 ++++++ .../com/dbflow5/sql/language/WhereTest.kt | 180 +++++++++++++++ .../sql/language/property/BytePropertyTest.kt | 42 ++++ .../sql/language/property/CharPropertyTest.kt | 42 ++++ .../language/property/DoublePropertyTest.kt | 42 ++++ .../language/property/FloatPropertyTest.kt | 42 ++++ .../language/property/IndexPropertyTest.kt | 24 ++ .../sql/language/property/IntPropertyTest.kt | 42 ++++ .../sql/language/property/LongPropertyTest.kt | 42 ++++ .../language/property/PropertyFactoryTest.kt | 30 +++ .../sql/language/property/PropertyTest.kt | 45 ++++ .../language/property/ShortPropertyTest.kt | 42 ++++ .../property/TypeConvertedPropertyTest.kt | 42 ++++ usage2/RXJavaSupport.md | 9 +- usage2/SQLCipherSupport.md | 2 +- usage2/including-in-project.md | 3 + 104 files changed, 4052 insertions(+), 47 deletions(-) create mode 100644 contentprovider-annotations/.gitignore create mode 100644 contentprovider-annotations/build.gradle create mode 100644 contentprovider-annotations/gradle.properties rename {core/src/main/kotlin/com/dbflow5/annotation/provider => contentprovider-annotations/src/main/kotlin/com/dbflow5/contentprovider/annotation}/ContentProvider.kt (92%) rename {core/src/main/kotlin/com/dbflow5/annotation/provider => contentprovider-annotations/src/main/kotlin/com/dbflow5/contentprovider/annotation}/ContentUri.kt (97%) rename {core/src/main/kotlin/com/dbflow5/annotation/provider => contentprovider-annotations/src/main/kotlin/com/dbflow5/contentprovider/annotation}/Notify.kt (94%) rename {core/src/main/kotlin/com/dbflow5/annotation/provider => contentprovider-annotations/src/main/kotlin/com/dbflow5/contentprovider/annotation}/TableEndpoint.kt (91%) rename contentprovider/src/main/{java => kotlin}/com/dbflow5/provider/BaseContentProvider.kt (100%) rename contentprovider/src/main/{java => kotlin}/com/dbflow5/provider/BaseProviderModel.kt (100%) rename contentprovider/src/main/{java => kotlin}/com/dbflow5/provider/BaseSyncableProviderModel.kt (100%) rename contentprovider/src/main/{java => kotlin}/com/dbflow5/provider/ContentUtils.kt (99%) rename contentprovider/src/main/{java => kotlin}/com/dbflow5/provider/ModelProvider.kt (100%) rename contentprovider/src/main/{java => kotlin}/com/dbflow5/provider/StubContentProvider.kt (100%) create mode 100644 tests/src/test/java/com/dbflow5/BaseUnitTest.kt create mode 100644 tests/src/test/java/com/dbflow5/DBFlowTestRule.kt create mode 100644 tests/src/test/java/com/dbflow5/ImmediateTransactionManager.kt create mode 100644 tests/src/test/java/com/dbflow5/TestDatabase.kt create mode 100644 tests/src/test/java/com/dbflow5/TestExtensions.kt create mode 100644 tests/src/test/java/com/dbflow5/config/ConfigIntegrationTest.kt create mode 100644 tests/src/test/java/com/dbflow5/config/DatabaseConfigTest.kt create mode 100644 tests/src/test/java/com/dbflow5/database/transaction/CoroutinesTest.kt create mode 100644 tests/src/test/java/com/dbflow5/database/transaction/FastStoreModelTransactionTest.kt create mode 100644 tests/src/test/java/com/dbflow5/migration/UpdateTableMigrationTest.kt create mode 100644 tests/src/test/java/com/dbflow5/models/AutoIncrementTest.kt create mode 100644 tests/src/test/java/com/dbflow5/models/CachingModels.kt create mode 100644 tests/src/test/java/com/dbflow5/models/CachingModelsTest.kt create mode 100644 tests/src/test/java/com/dbflow5/models/DontCreateModelTest.kt create mode 100644 tests/src/test/java/com/dbflow5/models/ForeignKeyModels.kt create mode 100644 tests/src/test/java/com/dbflow5/models/IndexModels.kt create mode 100644 tests/src/test/java/com/dbflow5/models/InnerClassExample.kt create mode 100644 tests/src/test/java/com/dbflow5/models/ManyToMany.kt create mode 100644 tests/src/test/java/com/dbflow5/models/ManyToManyTest.kt create mode 100644 tests/src/test/java/com/dbflow5/models/ModelViewTest.kt create mode 100644 tests/src/test/java/com/dbflow5/models/ModelViews.kt create mode 100644 tests/src/test/java/com/dbflow5/models/NonTypical/nonTypicalClassName.kt create mode 100644 tests/src/test/java/com/dbflow5/models/OneToManyModelTest.kt create mode 100644 tests/src/test/java/com/dbflow5/models/OneToManyModels.kt create mode 100644 tests/src/test/java/com/dbflow5/models/ParentChildCachingTest.kt create mode 100644 tests/src/test/java/com/dbflow5/models/QueryModelTest.kt create mode 100644 tests/src/test/java/com/dbflow5/models/QueryModels.kt create mode 100644 tests/src/test/java/com/dbflow5/models/SimpleTestModels.kt create mode 100644 tests/src/test/java/com/dbflow5/models/SimpleTestModelsTest.kt create mode 100644 tests/src/test/java/com/dbflow5/models/java/DatabaseModel.java create mode 100644 tests/src/test/java/com/dbflow5/models/java/JavaModelView.java create mode 100644 tests/src/test/java/com/dbflow5/models/java/otherpackage/ExampleModel.java create mode 100644 tests/src/test/java/com/dbflow5/paging/QueryDataSourceTest.kt create mode 100644 tests/src/test/java/com/dbflow5/provider/ContentProviderObjects.kt create mode 100644 tests/src/test/java/com/dbflow5/provider/ContentProviderTests.kt create mode 100644 tests/src/test/java/com/dbflow5/provider/RealContentProvider.kt create mode 100644 tests/src/test/java/com/dbflow5/provider/TestContentProvider.kt create mode 100644 tests/src/test/java/com/dbflow5/query/cache/ModelLruCacheTest.kt create mode 100644 tests/src/test/java/com/dbflow5/query/cache/SimpleMapCacheTest.kt create mode 100644 tests/src/test/java/com/dbflow5/query/list/FlowCursorIteratorTest.kt create mode 100644 tests/src/test/java/com/dbflow5/query/list/FlowCursorListTest.kt create mode 100644 tests/src/test/java/com/dbflow5/runtime/DirectNotifierTest.kt create mode 100644 tests/src/test/java/com/dbflow5/rx2/TransactionObservablesTest.kt create mode 100644 tests/src/test/java/com/dbflow5/rx2/query/CursorResultSubscriberTest.kt create mode 100644 tests/src/test/java/com/dbflow5/rx2/query/RXFlowableTest.kt create mode 100644 tests/src/test/java/com/dbflow5/rx2/query/RXQueryTests.kt create mode 100644 tests/src/test/java/com/dbflow5/rx2/query/RxModels.kt create mode 100644 tests/src/test/java/com/dbflow5/sql/language/CaseTest.kt create mode 100644 tests/src/test/java/com/dbflow5/sql/language/DeleteTest.kt create mode 100644 tests/src/test/java/com/dbflow5/sql/language/ExistenceOperatorTest.kt create mode 100644 tests/src/test/java/com/dbflow5/sql/language/FromTest.kt create mode 100644 tests/src/test/java/com/dbflow5/sql/language/IndexTest.kt create mode 100644 tests/src/test/java/com/dbflow5/sql/language/IndexedByTest.kt create mode 100644 tests/src/test/java/com/dbflow5/sql/language/InsertTest.kt create mode 100644 tests/src/test/java/com/dbflow5/sql/language/JoinTest.kt create mode 100644 tests/src/test/java/com/dbflow5/sql/language/MethodTest.kt create mode 100644 tests/src/test/java/com/dbflow5/sql/language/NameAliasTest.kt create mode 100644 tests/src/test/java/com/dbflow5/sql/language/OperatorGroupTest.kt create mode 100644 tests/src/test/java/com/dbflow5/sql/language/OperatorTest.kt create mode 100644 tests/src/test/java/com/dbflow5/sql/language/OrderByTest.kt create mode 100644 tests/src/test/java/com/dbflow5/sql/language/SelectTest.kt create mode 100644 tests/src/test/java/com/dbflow5/sql/language/SetTest.kt create mode 100644 tests/src/test/java/com/dbflow5/sql/language/TriggerTest.kt create mode 100644 tests/src/test/java/com/dbflow5/sql/language/UnsafeStringOperatorTest.kt create mode 100644 tests/src/test/java/com/dbflow5/sql/language/UpdateTest.kt create mode 100644 tests/src/test/java/com/dbflow5/sql/language/WhereTest.kt create mode 100644 tests/src/test/java/com/dbflow5/sql/language/property/BytePropertyTest.kt create mode 100644 tests/src/test/java/com/dbflow5/sql/language/property/CharPropertyTest.kt create mode 100644 tests/src/test/java/com/dbflow5/sql/language/property/DoublePropertyTest.kt create mode 100644 tests/src/test/java/com/dbflow5/sql/language/property/FloatPropertyTest.kt create mode 100644 tests/src/test/java/com/dbflow5/sql/language/property/IndexPropertyTest.kt create mode 100644 tests/src/test/java/com/dbflow5/sql/language/property/IntPropertyTest.kt create mode 100644 tests/src/test/java/com/dbflow5/sql/language/property/LongPropertyTest.kt create mode 100644 tests/src/test/java/com/dbflow5/sql/language/property/PropertyFactoryTest.kt create mode 100644 tests/src/test/java/com/dbflow5/sql/language/property/PropertyTest.kt create mode 100644 tests/src/test/java/com/dbflow5/sql/language/property/ShortPropertyTest.kt create mode 100644 tests/src/test/java/com/dbflow5/sql/language/property/TypeConvertedPropertyTest.kt diff --git a/README.md b/README.md index 31d582d6f..a5ef61483 100644 --- a/README.md +++ b/README.md @@ -78,6 +78,9 @@ Add artifacts to your project: // Android Architecture Components Paging Library Support compile "com.github.agrosner.dbflow:paging:${dbflow_version}" + // adds generated content provider annotations + support. + compile "com.github.agrosner.dbflow:contentprovider:${dbflow_version}" + } ``` diff --git a/contentprovider-annotations/.gitignore b/contentprovider-annotations/.gitignore new file mode 100644 index 000000000..796b96d1c --- /dev/null +++ b/contentprovider-annotations/.gitignore @@ -0,0 +1 @@ +/build diff --git a/contentprovider-annotations/build.gradle b/contentprovider-annotations/build.gradle new file mode 100644 index 000000000..5c403ec64 --- /dev/null +++ b/contentprovider-annotations/build.gradle @@ -0,0 +1,19 @@ +apply plugin: 'kotlin' + +project.ext.artifactId = bt_name + +targetCompatibility = JavaVersion.VERSION_1_8 +sourceCompatibility = JavaVersion.VERSION_1_8 + +dependencies { + compile deps.kotlin + compile project(':core') +} + +apply from: '../kotlin-artifacts.gradle' + +compileKotlin { + kotlinOptions { + apiVersion = "1.2" + } +} \ No newline at end of file diff --git a/contentprovider-annotations/gradle.properties b/contentprovider-annotations/gradle.properties new file mode 100644 index 000000000..ec906f2d6 --- /dev/null +++ b/contentprovider-annotations/gradle.properties @@ -0,0 +1,3 @@ +bt_name=contentprovider-annotations +bt_packaging=jar +bt_artifact_id=contentprovider-annotations \ No newline at end of file diff --git a/core/src/main/kotlin/com/dbflow5/annotation/provider/ContentProvider.kt b/contentprovider-annotations/src/main/kotlin/com/dbflow5/contentprovider/annotation/ContentProvider.kt similarity index 92% rename from core/src/main/kotlin/com/dbflow5/annotation/provider/ContentProvider.kt rename to contentprovider-annotations/src/main/kotlin/com/dbflow5/contentprovider/annotation/ContentProvider.kt index 64fc0ff19..9446b01ae 100644 --- a/core/src/main/kotlin/com/dbflow5/annotation/provider/ContentProvider.kt +++ b/contentprovider-annotations/src/main/kotlin/com/dbflow5/contentprovider/annotation/ContentProvider.kt @@ -1,4 +1,4 @@ -package com.dbflow5.annotation.provider +package com.dbflow5.contentprovider.annotation import kotlin.reflect.KClass diff --git a/core/src/main/kotlin/com/dbflow5/annotation/provider/ContentUri.kt b/contentprovider-annotations/src/main/kotlin/com/dbflow5/contentprovider/annotation/ContentUri.kt similarity index 97% rename from core/src/main/kotlin/com/dbflow5/annotation/provider/ContentUri.kt rename to contentprovider-annotations/src/main/kotlin/com/dbflow5/contentprovider/annotation/ContentUri.kt index 9adaed3c0..da0ad2d6a 100644 --- a/core/src/main/kotlin/com/dbflow5/annotation/provider/ContentUri.kt +++ b/contentprovider-annotations/src/main/kotlin/com/dbflow5/contentprovider/annotation/ContentUri.kt @@ -1,4 +1,4 @@ -package com.dbflow5.annotation.provider +package com.dbflow5.contentprovider.annotation /** * Description: Defines the URI for a content provider. diff --git a/core/src/main/kotlin/com/dbflow5/annotation/provider/Notify.kt b/contentprovider-annotations/src/main/kotlin/com/dbflow5/contentprovider/annotation/Notify.kt similarity index 94% rename from core/src/main/kotlin/com/dbflow5/annotation/provider/Notify.kt rename to contentprovider-annotations/src/main/kotlin/com/dbflow5/contentprovider/annotation/Notify.kt index cf5e18703..fc6c0d257 100644 --- a/core/src/main/kotlin/com/dbflow5/annotation/provider/Notify.kt +++ b/contentprovider-annotations/src/main/kotlin/com/dbflow5/contentprovider/annotation/Notify.kt @@ -1,4 +1,4 @@ -package com.dbflow5.annotation.provider +package com.dbflow5.contentprovider.annotation /** * Description: Annotates a method part of [com.dbflow5.annotation.provider.TableEndpoint] diff --git a/core/src/main/kotlin/com/dbflow5/annotation/provider/TableEndpoint.kt b/contentprovider-annotations/src/main/kotlin/com/dbflow5/contentprovider/annotation/TableEndpoint.kt similarity index 91% rename from core/src/main/kotlin/com/dbflow5/annotation/provider/TableEndpoint.kt rename to contentprovider-annotations/src/main/kotlin/com/dbflow5/contentprovider/annotation/TableEndpoint.kt index 076fc4607..cc3b48b24 100644 --- a/core/src/main/kotlin/com/dbflow5/annotation/provider/TableEndpoint.kt +++ b/contentprovider-annotations/src/main/kotlin/com/dbflow5/contentprovider/annotation/TableEndpoint.kt @@ -1,4 +1,4 @@ -package com.dbflow5.annotation.provider +package com.dbflow5.contentprovider.annotation import kotlin.reflect.KClass diff --git a/contentprovider/build.gradle b/contentprovider/build.gradle index 23fa310f7..ab1d03325 100644 --- a/contentprovider/build.gradle +++ b/contentprovider/build.gradle @@ -26,7 +26,7 @@ android { } dependencies { - api project(':core') + api project(':contentprovider-annotations') api project(':lib') api "com.android.support:support-annotations:27.1.1" api "org.jetbrains.kotlin:kotlin-stdlib:${kotlin_version}" diff --git a/contentprovider/src/main/java/com/dbflow5/provider/BaseContentProvider.kt b/contentprovider/src/main/kotlin/com/dbflow5/provider/BaseContentProvider.kt similarity index 100% rename from contentprovider/src/main/java/com/dbflow5/provider/BaseContentProvider.kt rename to contentprovider/src/main/kotlin/com/dbflow5/provider/BaseContentProvider.kt diff --git a/contentprovider/src/main/java/com/dbflow5/provider/BaseProviderModel.kt b/contentprovider/src/main/kotlin/com/dbflow5/provider/BaseProviderModel.kt similarity index 100% rename from contentprovider/src/main/java/com/dbflow5/provider/BaseProviderModel.kt rename to contentprovider/src/main/kotlin/com/dbflow5/provider/BaseProviderModel.kt diff --git a/contentprovider/src/main/java/com/dbflow5/provider/BaseSyncableProviderModel.kt b/contentprovider/src/main/kotlin/com/dbflow5/provider/BaseSyncableProviderModel.kt similarity index 100% rename from contentprovider/src/main/java/com/dbflow5/provider/BaseSyncableProviderModel.kt rename to contentprovider/src/main/kotlin/com/dbflow5/provider/BaseSyncableProviderModel.kt diff --git a/contentprovider/src/main/java/com/dbflow5/provider/ContentUtils.kt b/contentprovider/src/main/kotlin/com/dbflow5/provider/ContentUtils.kt similarity index 99% rename from contentprovider/src/main/java/com/dbflow5/provider/ContentUtils.kt rename to contentprovider/src/main/kotlin/com/dbflow5/provider/ContentUtils.kt index 893f5ee26..87f092a1d 100644 --- a/contentprovider/src/main/java/com/dbflow5/provider/ContentUtils.kt +++ b/contentprovider/src/main/kotlin/com/dbflow5/provider/ContentUtils.kt @@ -5,7 +5,7 @@ import android.content.ContentValues import android.content.Context import android.net.Uri import com.dbflow5.adapter.ModelAdapter -import com.dbflow5.annotation.provider.ContentProvider +import com.dbflow5.contentprovider.annotation.ContentProvider import com.dbflow5.config.FlowLog import com.dbflow5.config.modelAdapter import com.dbflow5.database.DatabaseWrapper diff --git a/contentprovider/src/main/java/com/dbflow5/provider/ModelProvider.kt b/contentprovider/src/main/kotlin/com/dbflow5/provider/ModelProvider.kt similarity index 100% rename from contentprovider/src/main/java/com/dbflow5/provider/ModelProvider.kt rename to contentprovider/src/main/kotlin/com/dbflow5/provider/ModelProvider.kt diff --git a/contentprovider/src/main/java/com/dbflow5/provider/StubContentProvider.kt b/contentprovider/src/main/kotlin/com/dbflow5/provider/StubContentProvider.kt similarity index 100% rename from contentprovider/src/main/java/com/dbflow5/provider/StubContentProvider.kt rename to contentprovider/src/main/kotlin/com/dbflow5/provider/StubContentProvider.kt diff --git a/lib/src/main/kotlin/com/dbflow5/query/ContentValuesListener.kt b/lib/src/main/kotlin/com/dbflow5/query/ContentValuesListener.kt index d2f7c9860..5fa747da8 100644 --- a/lib/src/main/kotlin/com/dbflow5/query/ContentValuesListener.kt +++ b/lib/src/main/kotlin/com/dbflow5/query/ContentValuesListener.kt @@ -3,7 +3,6 @@ package com.dbflow5.query import android.content.ContentValues import com.dbflow5.adapter.ModelAdapter import com.dbflow5.annotation.Table -import com.dbflow5.annotation.provider.ContentProvider import com.dbflow5.structure.Model /** @@ -36,7 +35,7 @@ interface ContentValuesListener { * It enables you to customly change the values as necessary during insert * to the database for a [ContentProvider]. * - * @param contentValues The content values to insert into DB for a [ContentProvider] + * @param contentValues The content values to insert into DB for a ContentProvider */ fun onBindToInsertValues(contentValues: ContentValues) } diff --git a/lib/src/main/kotlin/com/dbflow5/query/Where.kt b/lib/src/main/kotlin/com/dbflow5/query/Where.kt index 530a97977..dcc829013 100644 --- a/lib/src/main/kotlin/com/dbflow5/query/Where.kt +++ b/lib/src/main/kotlin/com/dbflow5/query/Where.kt @@ -1,6 +1,5 @@ package com.dbflow5.query -import com.dbflow5.annotation.provider.ContentProvider import com.dbflow5.appendQualifier import com.dbflow5.database.DatabaseWrapper import com.dbflow5.database.FlowCursor @@ -19,12 +18,12 @@ class Where * @param whereBase The FROM or SET statement chunk */ internal constructor( - /** - * The first chunk of the SQL statement before this query. - */ - val whereBase: WhereBase, vararg conditions: SQLOperator) + /** + * The first chunk of the SQL statement before this query. + */ + val whereBase: WhereBase, vararg conditions: SQLOperator) : BaseModelQueriable(whereBase.table), - ModelQueriable, Transformable, QueryCloneable> { + ModelQueriable, Transformable, QueryCloneable> { /** * Helps to build the where statement easily @@ -60,10 +59,10 @@ internal constructor( get() { val fromQuery = whereBase.query.trim { it <= ' ' } val queryBuilder = StringBuilder(fromQuery).append(" ") - .appendQualifier("WHERE", operatorGroup.query) - .appendQualifier("GROUP BY", groupByList.joinToString(separator = ",")) - .appendQualifier("HAVING", havingGroup.query) - .appendQualifier("ORDER BY", orderByList.joinToString(separator = ",")) + .appendQualifier("WHERE", operatorGroup.query) + .appendQualifier("GROUP BY", groupByList.joinToString(separator = ",")) + .appendQualifier("HAVING", havingGroup.query) + .appendQualifier("ORDER BY", orderByList.joinToString(separator = ",")) if (limit > VALUE_UNSET) { queryBuilder.appendQualifier("LIMIT", limit.toString()) @@ -138,7 +137,7 @@ internal constructor( } /** - * For use in [ContentProvider] generation. Appends all ORDER BY here. + * For use in ContentProvider generation. Appends all ORDER BY here. * * @param orderByList The order by. * @return this instance. @@ -169,10 +168,10 @@ internal constructor( * @return the result of the query as a [FlowCursor]. */ override fun cursor(databaseWrapper: DatabaseWrapper): FlowCursor? =// Query the sql here - when { - whereBase.queryBuilderBase is Select -> databaseWrapper.rawQuery(query, null) - else -> super.cursor(databaseWrapper) - } + when { + whereBase.queryBuilderBase is Select -> databaseWrapper.rawQuery(query, null) + else -> super.cursor(databaseWrapper) + } /** * Queries for all of the results this statement returns from a DB cursor in the form of the [T] diff --git a/processor/build.gradle b/processor/build.gradle index 1c6571ffd..e6c448361 100644 --- a/processor/build.gradle +++ b/processor/build.gradle @@ -7,6 +7,7 @@ sourceCompatibility = JavaVersion.VERSION_1_8 dependencies { compile project("${dbflow_project_prefix}core") + compile project(':contentprovider-annotations') compile deps.javapoet compile deps.kpoet compile deps.kotlin diff --git a/processor/src/main/kotlin/com/dbflow5/processor/DBFlowProcessor.kt b/processor/src/main/kotlin/com/dbflow5/processor/DBFlowProcessor.kt index eaae8fa26..bd3d16214 100644 --- a/processor/src/main/kotlin/com/dbflow5/processor/DBFlowProcessor.kt +++ b/processor/src/main/kotlin/com/dbflow5/processor/DBFlowProcessor.kt @@ -7,8 +7,8 @@ import com.dbflow5.annotation.ModelView import com.dbflow5.annotation.QueryModel import com.dbflow5.annotation.Table import com.dbflow5.annotation.TypeConverter -import com.dbflow5.annotation.provider.ContentProvider -import com.dbflow5.annotation.provider.TableEndpoint +import com.dbflow5.contentprovider.annotation.ContentProvider +import com.dbflow5.contentprovider.annotation.TableEndpoint import com.dbflow5.processor.definition.DatabaseHolderDefinition import javax.annotation.processing.AbstractProcessor import javax.annotation.processing.ProcessingEnvironment diff --git a/processor/src/main/kotlin/com/dbflow5/processor/Handlers.kt b/processor/src/main/kotlin/com/dbflow5/processor/Handlers.kt index 1562e8c27..621e948af 100644 --- a/processor/src/main/kotlin/com/dbflow5/processor/Handlers.kt +++ b/processor/src/main/kotlin/com/dbflow5/processor/Handlers.kt @@ -8,8 +8,8 @@ import com.dbflow5.annotation.MultipleManyToMany import com.dbflow5.annotation.QueryModel import com.dbflow5.annotation.Table import com.dbflow5.annotation.TypeConverter -import com.dbflow5.annotation.provider.ContentProvider -import com.dbflow5.annotation.provider.TableEndpoint +import com.dbflow5.contentprovider.annotation.ContentProvider +import com.dbflow5.contentprovider.annotation.TableEndpoint import com.dbflow5.converter.BigDecimalConverter import com.dbflow5.converter.BigIntegerConverter import com.dbflow5.converter.BooleanConverter diff --git a/processor/src/main/kotlin/com/dbflow5/processor/definition/provider/ContentProvider.kt b/processor/src/main/kotlin/com/dbflow5/processor/definition/provider/ContentProvider.kt index e8bfaed69..3c43624f5 100644 --- a/processor/src/main/kotlin/com/dbflow5/processor/definition/provider/ContentProvider.kt +++ b/processor/src/main/kotlin/com/dbflow5/processor/definition/provider/ContentProvider.kt @@ -14,11 +14,11 @@ import com.grosner.kpoet.param import com.grosner.kpoet.parameterized import com.grosner.kpoet.public import com.grosner.kpoet.statement -import com.dbflow5.annotation.provider.ContentProvider -import com.dbflow5.annotation.provider.ContentUri -import com.dbflow5.annotation.provider.NotifyMethod -import com.dbflow5.annotation.provider.PathSegment -import com.dbflow5.annotation.provider.TableEndpoint +import com.dbflow5.contentprovider.annotation.ContentProvider +import com.dbflow5.contentprovider.annotation.ContentUri +import com.dbflow5.contentprovider.annotation.NotifyMethod +import com.dbflow5.contentprovider.annotation.PathSegment +import com.dbflow5.contentprovider.annotation.TableEndpoint import com.dbflow5.processor.ProcessorManager import com.dbflow5.processor.TableEndpointValidator import com.dbflow5.processor.definition.BaseDefinition diff --git a/processor/src/main/kotlin/com/dbflow5/processor/definition/provider/NotifyDefinition.kt b/processor/src/main/kotlin/com/dbflow5/processor/definition/provider/NotifyDefinition.kt index 475cf5654..6129b8768 100644 --- a/processor/src/main/kotlin/com/dbflow5/processor/definition/provider/NotifyDefinition.kt +++ b/processor/src/main/kotlin/com/dbflow5/processor/definition/provider/NotifyDefinition.kt @@ -1,7 +1,7 @@ package com.dbflow5.processor.definition.provider -import com.dbflow5.annotation.provider.Notify -import com.dbflow5.annotation.provider.NotifyMethod +import com.dbflow5.contentprovider.annotation.Notify +import com.dbflow5.contentprovider.annotation.NotifyMethod import com.dbflow5.processor.ProcessorManager import com.dbflow5.processor.definition.BaseDefinition import com.dbflow5.processor.utils.annotation diff --git a/processor/src/main/kotlin/com/dbflow5/processor/definition/provider/TableEndpointDefinition.kt b/processor/src/main/kotlin/com/dbflow5/processor/definition/provider/TableEndpointDefinition.kt index 6a46553df..35c6b52db 100644 --- a/processor/src/main/kotlin/com/dbflow5/processor/definition/provider/TableEndpointDefinition.kt +++ b/processor/src/main/kotlin/com/dbflow5/processor/definition/provider/TableEndpointDefinition.kt @@ -1,9 +1,9 @@ package com.dbflow5.processor.definition.provider -import com.dbflow5.annotation.provider.ContentUri -import com.dbflow5.annotation.provider.Notify -import com.dbflow5.annotation.provider.NotifyMethod -import com.dbflow5.annotation.provider.TableEndpoint +import com.dbflow5.contentprovider.annotation.Notify +import com.dbflow5.contentprovider.annotation.NotifyMethod +import com.dbflow5.contentprovider.annotation.ContentUri +import com.dbflow5.contentprovider.annotation.TableEndpoint import com.dbflow5.processor.ProcessorManager import com.dbflow5.processor.definition.BaseDefinition import com.dbflow5.processor.utils.annotation diff --git a/settings.gradle b/settings.gradle index 61aedc7fd..e658a89d2 100644 --- a/settings.gradle +++ b/settings.gradle @@ -1,4 +1,4 @@ -include ':lib', ':reactive-streams', ':coroutines', ':contentprovider', +include ':lib', ':reactive-streams', ':coroutines', ':contentprovider', ':contentprovider-annotations', ':processor', ':core', ':sqlcipher', diff --git a/tests/src/test/java/com/dbflow5/BaseUnitTest.kt b/tests/src/test/java/com/dbflow5/BaseUnitTest.kt new file mode 100644 index 000000000..aeaaa30ec --- /dev/null +++ b/tests/src/test/java/com/dbflow5/BaseUnitTest.kt @@ -0,0 +1,20 @@ +package com.dbflow5 + +import android.content.Context +import org.junit.Rule +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.RuntimeEnvironment +import org.robolectric.annotation.Config + +@RunWith(RobolectricTestRunner::class) +@Config(manifest = Config.NONE) +abstract class BaseUnitTest { + + @JvmField + @Rule + var dblflowTestRule = DBFlowTestRule.create() + + val context: Context + get() = RuntimeEnvironment.application +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/DBFlowTestRule.kt b/tests/src/test/java/com/dbflow5/DBFlowTestRule.kt new file mode 100644 index 000000000..349ed7ce8 --- /dev/null +++ b/tests/src/test/java/com/dbflow5/DBFlowTestRule.kt @@ -0,0 +1,49 @@ +package com.dbflow5 + +import android.content.Context +import com.dbflow5.config.DatabaseConfig +import com.dbflow5.config.FlowConfig +import com.dbflow5.config.FlowLog +import com.dbflow5.config.FlowManager +import com.dbflow5.database.AndroidSQLiteOpenHelper +import com.dbflow5.provider.ContentDatabase +import com.dbflow5.runtime.DirectModelNotifier +import org.junit.rules.TestRule +import org.junit.runner.Description +import org.junit.runners.model.Statement +import org.robolectric.RuntimeEnvironment + +class DBFlowTestRule : TestRule { + + val context: Context + get() = RuntimeEnvironment.application + + override fun apply(base: Statement, description: Description): Statement { + return object : Statement() { + + @Throws(Throwable::class) + override fun evaluate() { + FlowLog.setMinimumLoggingLevel(FlowLog.Level.V) + DirectModelNotifier().clearListeners() + FlowManager.init(FlowConfig.Builder(RuntimeEnvironment.application) + .database(DatabaseConfig.Builder(TestDatabase::class, AndroidSQLiteOpenHelper.createHelperCreator(context)) + .transactionManagerCreator(::ImmediateTransactionManager2) + .build()) + .database(DatabaseConfig.builder(ContentDatabase::class, + AndroidSQLiteOpenHelper.createHelperCreator(context)) + .databaseName("content") + .build()) + .build()) + try { + base.evaluate() + } finally { + FlowManager.destroy() + } + } + } + } + + companion object { + fun create() = DBFlowTestRule() + } +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/ImmediateTransactionManager.kt b/tests/src/test/java/com/dbflow5/ImmediateTransactionManager.kt new file mode 100644 index 000000000..b0c3733a3 --- /dev/null +++ b/tests/src/test/java/com/dbflow5/ImmediateTransactionManager.kt @@ -0,0 +1,37 @@ +package com.dbflow5 + +import com.dbflow5.config.DBFlowDatabase +import com.dbflow5.transaction.BaseTransactionManager +import com.dbflow5.transaction.ITransactionQueue +import com.dbflow5.transaction.Transaction + +/** + * Description: Executes all transactions on same thread for testing. + */ +class ImmediateTransactionManager2(databaseDefinition: DBFlowDatabase) + : BaseTransactionManager(ImmediateTransactionQueue2(), databaseDefinition) + + +class ImmediateTransactionQueue2 : ITransactionQueue { + + override fun add(transaction: Transaction) { + transaction.newBuilder() + .runCallbacksOnSameThread(true) + .build() + .executeSync() + } + + override fun cancel(transaction: Transaction) { + + } + + override fun startIfNotAlive() { + } + + override fun cancel(name: String) { + } + + override fun quit() { + } + +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/TestDatabase.kt b/tests/src/test/java/com/dbflow5/TestDatabase.kt new file mode 100644 index 000000000..93aaf2d8d --- /dev/null +++ b/tests/src/test/java/com/dbflow5/TestDatabase.kt @@ -0,0 +1,18 @@ +package com.dbflow5 + +import com.dbflow5.annotation.Database +import com.dbflow5.annotation.Migration +import com.dbflow5.config.DBFlowDatabase +import com.dbflow5.migration.UpdateTableMigration +import com.dbflow5.models.SimpleModel + +/** + * Description: + */ +@Database(version = 1) +abstract class TestDatabase : DBFlowDatabase() { + + @Migration(version = 1, database = TestDatabase::class) + class TestMigration : UpdateTableMigration(SimpleModel::class.java) + +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/TestExtensions.kt b/tests/src/test/java/com/dbflow5/TestExtensions.kt new file mode 100644 index 000000000..378b2ba74 --- /dev/null +++ b/tests/src/test/java/com/dbflow5/TestExtensions.kt @@ -0,0 +1,23 @@ +package com.dbflow5 + +import com.dbflow5.sql.Query +import org.junit.Assert.assertEquals +import org.junit.Assert.fail +import kotlin.reflect.KClass + + +fun String.assertEquals(query: Query) = assertEquals(this, query.query.trim()) + +fun Query.assertEquals(actual: Query) = assertEquals(query.trim(), actual.query.trim()) + +fun assertThrowsException(expectedException: KClass, function: () -> Unit) { + try { + function() + fail("Expected call to fail. Unexpectedly passed") + } catch (e: Exception) { + if (e.javaClass != expectedException.java) { + e.printStackTrace() + fail("Expected $expectedException but got ${e.javaClass}") + } + } +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/config/ConfigIntegrationTest.kt b/tests/src/test/java/com/dbflow5/config/ConfigIntegrationTest.kt new file mode 100644 index 000000000..663d1215e --- /dev/null +++ b/tests/src/test/java/com/dbflow5/config/ConfigIntegrationTest.kt @@ -0,0 +1,80 @@ +package com.dbflow5.config + +import com.dbflow5.BaseUnitTest +import com.dbflow5.TestDatabase +import com.dbflow5.adapter.queriable.ListModelLoader +import com.dbflow5.adapter.queriable.SingleModelLoader +import com.dbflow5.adapter.saveable.ModelSaver +import com.dbflow5.database.AndroidSQLiteOpenHelper +import com.dbflow5.models.SimpleModel +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNotNull +import org.junit.Assert.assertTrue +import org.junit.Before +import org.junit.Test + +/** + * Description: + */ +class ConfigIntegrationTest : BaseUnitTest() { + + private lateinit var builder: FlowConfig.Builder + + @Before + fun setup() { + FlowManager.reset() + FlowLog.setMinimumLoggingLevel(FlowLog.Level.V) + builder = FlowConfig.Builder(context) + } + + + @Test + fun test_flowConfig() { + val config = builder + .openDatabasesOnInit(true) + .build() + assertEquals(config.openDatabasesOnInit, true) + assertTrue(config.databaseConfigMap.isEmpty()) + assertTrue(config.databaseHolders.isEmpty()) + } + + @Test + fun test_tableConfig() { + + val customListModelLoader = ListModelLoader(SimpleModel::class.java) + val singleModelLoader = SingleModelLoader(SimpleModel::class.java) + val modelSaver = ModelSaver() + + FlowManager.init(builder + .database(DatabaseConfig.Builder(TestDatabase::class.java, + AndroidSQLiteOpenHelper.createHelperCreator(context)) + .addTableConfig(TableConfig.Builder(SimpleModel::class.java) + .singleModelLoader(singleModelLoader) + .listModelLoader(customListModelLoader) + .modelAdapterModelSaver(modelSaver) + .build()) + .build()) + .build()) + + val flowConfig = FlowManager.getConfig() + assertNotNull(flowConfig) + + val databaseConfig = flowConfig.databaseConfigMap[TestDatabase::class.java] as DatabaseConfig + assertNotNull(databaseConfig) + + + val config = databaseConfig.tableConfigMap[SimpleModel::class.java] as TableConfig + assertNotNull(config) + + assertEquals(config.listModelLoader, customListModelLoader) + assertEquals(config.singleModelLoader, singleModelLoader) + + val modelAdapter = SimpleModel::class.modelAdapter + assertEquals(modelAdapter.listModelLoader, customListModelLoader) + assertEquals(modelAdapter.singleModelLoader, singleModelLoader) + assertEquals(modelAdapter.modelSaver, modelSaver) + } + +} + + diff --git a/tests/src/test/java/com/dbflow5/config/DatabaseConfigTest.kt b/tests/src/test/java/com/dbflow5/config/DatabaseConfigTest.kt new file mode 100644 index 000000000..72014a5ee --- /dev/null +++ b/tests/src/test/java/com/dbflow5/config/DatabaseConfigTest.kt @@ -0,0 +1,88 @@ +package com.dbflow5.config + +import com.nhaarman.mockito_kotlin.mock +import com.dbflow5.BaseUnitTest +import com.dbflow5.TestDatabase +import com.dbflow5.database.AndroidSQLiteOpenHelper +import com.dbflow5.database.DatabaseCallback +import com.dbflow5.database.OpenHelper +import com.dbflow5.transaction.BaseTransactionManager +import org.junit.Assert +import org.junit.Before +import org.junit.Test + + +/** + * Description: + */ +class DatabaseConfigTest : BaseUnitTest() { + + private lateinit var builder: FlowConfig.Builder + + @Before + fun setup() { + FlowManager.reset() + FlowLog.setMinimumLoggingLevel(FlowLog.Level.V) + builder = FlowConfig.Builder(context) + } + + @Test + fun test_databaseConfig() { + + val helperListener = mock() + val customOpenHelper = mock() + + val openHelperCreator: ((DBFlowDatabase, DatabaseCallback?) -> OpenHelper) = { _, _ -> + customOpenHelper + } + var testTransactionManager: TestTransactionManager? = null + val managerCreator: (DBFlowDatabase) -> BaseTransactionManager = { databaseDefinition -> + testTransactionManager = TestTransactionManager(databaseDefinition) + testTransactionManager!! + } + + FlowManager.init(builder + .database(DatabaseConfig.Builder(TestDatabase::class.java, openHelperCreator) + .databaseName("Test") + .helperListener(helperListener) + .transactionManagerCreator(managerCreator) + .build()) + .build()) + + val flowConfig = FlowManager.getConfig() + Assert.assertNotNull(flowConfig) + + val databaseConfig = flowConfig.databaseConfigMap[TestDatabase::class.java]!! + Assert.assertEquals("Test", databaseConfig.databaseName) + Assert.assertEquals(".db", databaseConfig.databaseExtensionName) + Assert.assertEquals(databaseConfig.transactionManagerCreator, managerCreator) + Assert.assertEquals(databaseConfig.databaseClass, TestDatabase::class.java) + Assert.assertEquals(databaseConfig.openHelperCreator, openHelperCreator) + Assert.assertEquals(databaseConfig.callback, helperListener) + Assert.assertTrue(databaseConfig.tableConfigMap.isEmpty()) + + + val databaseDefinition = database() + Assert.assertEquals(databaseDefinition.transactionManager, testTransactionManager) + Assert.assertEquals(databaseDefinition.openHelper, customOpenHelper) + } + + @Test + fun test_EmptyName() { + FlowManager.init(builder + .database(DatabaseConfig.Builder(TestDatabase::class.java, + AndroidSQLiteOpenHelper.createHelperCreator(context)) + .databaseName("Test") + .extensionName("") + .build()) + .build()) + + val databaseConfig = FlowManager.getConfig().databaseConfigMap[TestDatabase::class.java]!! + Assert.assertEquals("Test", databaseConfig.databaseName) + Assert.assertEquals("", databaseConfig.databaseExtensionName) + } + +} + +class TestTransactionManager(databaseDefinition: DBFlowDatabase) + : BaseTransactionManager(mock(), databaseDefinition) \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/database/transaction/CoroutinesTest.kt b/tests/src/test/java/com/dbflow5/database/transaction/CoroutinesTest.kt new file mode 100644 index 000000000..8cd61c5c2 --- /dev/null +++ b/tests/src/test/java/com/dbflow5/database/transaction/CoroutinesTest.kt @@ -0,0 +1,93 @@ +package com.dbflow5.database.transaction + +import com.dbflow5.BaseUnitTest +import com.dbflow5.TestDatabase +import com.dbflow5.config.database +import com.dbflow5.coroutines.awaitDelete +import com.dbflow5.coroutines.awaitInsert +import com.dbflow5.coroutines.awaitSave +import com.dbflow5.coroutines.awaitTransact +import com.dbflow5.coroutines.awaitUpdate +import com.dbflow5.models.SimpleModel +import com.dbflow5.models.SimpleModel_Table +import com.dbflow5.models.TwoColumnModel +import com.dbflow5.models.TwoColumnModel_Table +import com.dbflow5.query.delete +import com.dbflow5.query.list +import com.dbflow5.query.select +import com.dbflow5.structure.save +import kotlinx.coroutines.experimental.runBlocking +import org.junit.Test + +/** + * Description: + */ +class CoroutinesTest : BaseUnitTest() { + + @Test + fun testTransact() { + runBlocking { + database { + (0..9).forEach { + SimpleModel("$it").save() + } + + val query = awaitTransact( + select from SimpleModel::class + where SimpleModel_Table.name.eq("5")) { list } + + assert(query.size == 1) + + + val result = awaitTransact( + delete() + where SimpleModel_Table.name.eq("5")) { executeUpdateDelete(this@database) } + assert(result == 1L) + } + } + } + + @Test + fun testAwaitSaveAndDelete() { + runBlocking { + database { + val simpleModel = SimpleModel("Name") + val result = simpleModel.awaitSave(this) + assert(result) + + assert(simpleModel.awaitDelete(this)) + } + } + } + + @Test + fun testAwaitInsertAndDelete() { + runBlocking { + database { + val simpleModel = SimpleModel("Name") + val result = simpleModel.awaitInsert(this) + assert(result > 0) + assert(simpleModel.awaitDelete(this)) + } + } + } + + @Test + fun testAwaitUpdate() { + runBlocking { + database { + val simpleModel = TwoColumnModel(name = "Name", id = 5) + val result = simpleModel.awaitSave(this) + assert(result) + + simpleModel.id = 5 + val updated = simpleModel.awaitUpdate(this) + assert(updated) + + val loadedModel = awaitTransact(select from TwoColumnModel::class + where TwoColumnModel_Table.id.eq(5)) { querySingle(this@database) } + assert(loadedModel?.id == 5) + } + } + } +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/database/transaction/FastStoreModelTransactionTest.kt b/tests/src/test/java/com/dbflow5/database/transaction/FastStoreModelTransactionTest.kt new file mode 100644 index 000000000..e840ea69a --- /dev/null +++ b/tests/src/test/java/com/dbflow5/database/transaction/FastStoreModelTransactionTest.kt @@ -0,0 +1,64 @@ +package com.dbflow5.database.transaction + +import com.dbflow5.BaseUnitTest +import com.dbflow5.TestDatabase +import com.dbflow5.config.database +import com.dbflow5.models.SimpleModel +import com.dbflow5.models.TwoColumnModel +import com.dbflow5.coroutines.awaitInsert +import com.dbflow5.coroutines.awaitSave +import com.dbflow5.coroutines.awaitUpdate +import com.dbflow5.query.list +import com.dbflow5.query.select +import kotlinx.coroutines.experimental.runBlocking +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNotEquals +import org.junit.Test +import java.util.* + +class FastStoreModelTransactionTest : BaseUnitTest() { + + @Test + fun testSaveBuilder() { + runBlocking { + database(TestDatabase::class) { + val result = (0..9) + .map { SimpleModel("$it") }.awaitSave(this) + val list = (select from SimpleModel::class).list + assertEquals(10, list.size) + assertEquals(10L, result) + } + } + } + + @Test + fun testInsertBuilder() { + runBlocking { + database(TestDatabase::class) { + val result = (0..9) + .map { SimpleModel("$it") }.awaitInsert(this) + val list = (select from SimpleModel::class).list + assertEquals(10, list.size) + assertEquals(10L, result) + } + } + } + + @Test + fun testUpdateBuilder() { + runBlocking { + database(TestDatabase::class) { + val oldList = (0..9).map { TwoColumnModel("$it", Random().nextInt()) } + oldList.awaitInsert(this) + + (0..9).map { TwoColumnModel("$it", Random().nextInt()) }.awaitUpdate(this) + + val list = (select from TwoColumnModel::class).list + assertEquals(10, list.size) + list.forEachIndexed { index, model -> + assertNotEquals(model, oldList[index]) + } + } + } + } +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/migration/UpdateTableMigrationTest.kt b/tests/src/test/java/com/dbflow5/migration/UpdateTableMigrationTest.kt new file mode 100644 index 000000000..41f5416c3 --- /dev/null +++ b/tests/src/test/java/com/dbflow5/migration/UpdateTableMigrationTest.kt @@ -0,0 +1,22 @@ +package com.dbflow5.migration + +import com.dbflow5.BaseUnitTest +import com.dbflow5.config.databaseForTable +import com.dbflow5.models.SimpleModel +import com.dbflow5.models.SimpleModel_Table +import org.junit.Test + +/** + * Description: + */ + +class UpdateTableMigrationTest : BaseUnitTest() { + + + @Test + fun testUpdateMigrationQuery() { + val update = UpdateTableMigration(SimpleModel::class.java) + update.set(SimpleModel_Table.name.eq("yes")) + update.migrate(databaseForTable()) + } +} diff --git a/tests/src/test/java/com/dbflow5/models/AutoIncrementTest.kt b/tests/src/test/java/com/dbflow5/models/AutoIncrementTest.kt new file mode 100644 index 000000000..a868cf816 --- /dev/null +++ b/tests/src/test/java/com/dbflow5/models/AutoIncrementTest.kt @@ -0,0 +1,33 @@ +package com.dbflow5.models + +import com.dbflow5.BaseUnitTest +import com.dbflow5.TestDatabase +import com.dbflow5.annotation.PrimaryKey +import com.dbflow5.annotation.Table +import com.dbflow5.structure.insert +import org.junit.Assert.assertEquals +import org.junit.Test + +/** + * Description: + */ +class AutoIncrementTest : BaseUnitTest() { + + @Test + fun testCanInsertAutoIncrement() { + val model = AutoIncrementingModel() + model.insert() + assertEquals(1L, model.id) + } + + @Test + fun testCanInsertExistingIdAutoIncrement() { + val model = AutoIncrementingModel(3) + model.insert() + assertEquals(3L, model.id) + } +} + + +@Table(database = TestDatabase::class) +class AutoIncrementingModel(@PrimaryKey(autoincrement = true) var id: Long = 0) \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/models/CachingModels.kt b/tests/src/test/java/com/dbflow5/models/CachingModels.kt new file mode 100644 index 000000000..15bc28968 --- /dev/null +++ b/tests/src/test/java/com/dbflow5/models/CachingModels.kt @@ -0,0 +1,30 @@ +package com.dbflow5.models + +import com.dbflow5.TestDatabase +import com.dbflow5.annotation.Column +import com.dbflow5.annotation.ForeignKey +import com.dbflow5.annotation.MultiCacheField +import com.dbflow5.annotation.PrimaryKey +import com.dbflow5.annotation.Table +import com.dbflow5.query.cache.IMultiKeyCacheConverter + +@Table(database = TestDatabase::class, cachingEnabled = true) +class SimpleCacheObject(@PrimaryKey var id: String = "") + +@Table(database = TestDatabase::class, cachingEnabled = true) +class Coordinate(@PrimaryKey var latitude: Double = 0.0, + @PrimaryKey var longitude: Double = 0.0, + @ForeignKey var path: Path? = null) { + + companion object { + @JvmField + @MultiCacheField + val cacheConverter = object : IMultiKeyCacheConverter { + override fun getCachingKey(values: Array) = "${values[0]},${values[1]}" + } + } +} + +@Table(database = TestDatabase::class) +class Path(@PrimaryKey var id: String = "", + @Column var name: String = "") \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/models/CachingModelsTest.kt b/tests/src/test/java/com/dbflow5/models/CachingModelsTest.kt new file mode 100644 index 000000000..3b35ee04d --- /dev/null +++ b/tests/src/test/java/com/dbflow5/models/CachingModelsTest.kt @@ -0,0 +1,51 @@ +package com.dbflow5.models + +import com.dbflow5.BaseUnitTest +import com.dbflow5.TestDatabase +import com.dbflow5.config.database +import com.dbflow5.query.list +import com.dbflow5.query.result +import com.dbflow5.query.select +import com.dbflow5.structure.save +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNotEquals +import org.junit.Test + +/** + * Description: Tests to ensure caching works as expected. + */ +class CachingModelsTest : BaseUnitTest() { + + @Test + fun testSimpleCache() = database(TestDatabase::class) { + val list = arrayListOf() + (0..9).forEach { + val simpleCacheObject = SimpleCacheObject("$it") + simpleCacheObject.save() + list += simpleCacheObject + } + + val loadedList = (select from SimpleCacheObject::class).list + + loadedList.forEachIndexed { index, simpleCacheObject -> + assertEquals(list[index], simpleCacheObject) + } + } + + @Test + fun testComplexObject() = database(TestDatabase::class) { + val path = Path("1", "Path") + path.save() + + val coordinate = Coordinate(40.5, 84.0, path) + coordinate.save() + + val oldPath = coordinate.path + + val loadedCoordinate = (select from Coordinate::class).result!! + assertEquals(coordinate, loadedCoordinate) + + // we want to ensure relationships reloaded. + assertNotEquals(oldPath, loadedCoordinate.path) + } +} diff --git a/tests/src/test/java/com/dbflow5/models/DontCreateModelTest.kt b/tests/src/test/java/com/dbflow5/models/DontCreateModelTest.kt new file mode 100644 index 000000000..101cf9359 --- /dev/null +++ b/tests/src/test/java/com/dbflow5/models/DontCreateModelTest.kt @@ -0,0 +1,24 @@ +package com.dbflow5.models + +import com.dbflow5.BaseUnitTest +import com.dbflow5.assertThrowsException +import com.dbflow5.config.databaseForTable +import com.dbflow5.database.SQLiteException +import com.dbflow5.query.list +import com.dbflow5.query.select +import org.junit.Test + +/** + * Description: + */ +class DontCreateModelTest : BaseUnitTest() { + + @Test + fun testModelNotCreated() { + databaseForTable { + assertThrowsException(SQLiteException::class) { + (select from DontCreateModel::class).list + } + } + } +} diff --git a/tests/src/test/java/com/dbflow5/models/ForeignKeyModels.kt b/tests/src/test/java/com/dbflow5/models/ForeignKeyModels.kt new file mode 100644 index 000000000..ddb4183a5 --- /dev/null +++ b/tests/src/test/java/com/dbflow5/models/ForeignKeyModels.kt @@ -0,0 +1,112 @@ +package com.dbflow5.models + +import com.dbflow5.TestDatabase +import com.dbflow5.annotation.Column +import com.dbflow5.annotation.ColumnMap +import com.dbflow5.annotation.ColumnMapReference +import com.dbflow5.annotation.ConflictAction +import com.dbflow5.annotation.ForeignKey +import com.dbflow5.annotation.ForeignKeyAction +import com.dbflow5.annotation.ForeignKeyReference +import com.dbflow5.annotation.NotNull +import com.dbflow5.annotation.PrimaryKey +import com.dbflow5.annotation.Table +import com.dbflow5.annotation.TypeConverter +import com.dbflow5.database.FlowCursor +import com.dbflow5.query.LoadFromCursorListener + +/** + * Example of simple foreign key object with one foreign key object. + */ +@Table(database = TestDatabase::class) +class Blog(@PrimaryKey(autoincrement = true) var id: Int = 0, @Column var name: String = "", + @ForeignKey(saveForeignKeyModel = true) var author: Author? = null) + +/** + * Parent used as foreign key reference. + */ +@Table(database = TestDatabase::class) +class Author(@PrimaryKey(autoincrement = true) var id: Int = 0, + @Column(name = "first_name") var firstName: String = "", + @Column(name = "last_name") var lastName: String = "") + +/** + * Example of simple foreign key object with its [ForeignKey] deferred. + */ +@Table(database = TestDatabase::class) +class BlogDeferred(@PrimaryKey(autoincrement = true) var id: Int = 0, @Column var name: String = "", + @ForeignKey(deferred = true) var author: Author? = null) + +/** + * Class has example of single foreign key with [ForeignKeyReference] specified + */ +@Table(database = TestDatabase::class) +class BlogRef(@PrimaryKey(autoincrement = true) var id: Int = 0, @Column var name: String = "", + @ForeignKey(references = arrayOf( + ForeignKeyReference(columnName = "authorId", foreignKeyColumnName = "id", + defaultValue = "not gonna work"))) + var author: Author? = null) + +/** + * Class has example of single foreign key with [ForeignKeyReference] specified that is not the model object. + */ +@Table(database = TestDatabase::class) +class BlogRefNoModel(@PrimaryKey(autoincrement = true) var id: Int = 0, @Column var name: String = "", + @ForeignKey(references = arrayOf(ForeignKeyReference(columnName = "authorId", foreignKeyColumnName = "id", notNull = NotNull(onNullConflict = ConflictAction.FAIL))), + tableClass = Author::class) + var authorId: String? = null) + + +/** + * Class has example of single foreign key with [ForeignKeyReference] as [PrimaryKey] + */ +@Table(database = TestDatabase::class) +class BlogPrimary(@PrimaryKey @ForeignKey var author: Author? = null, @Column var id: Int = 0) + +/** + * Example of simple foreign key object with one foreign key object thats [ForeignKey.stubbedRelationship] + * and [ForeignKey.deleteForeignKeyModel] and [ForeignKey.saveForeignKeyModel] + */ +@Table(database = TestDatabase::class) +class BlogStubbed(@PrimaryKey(autoincrement = true) var id: Int = 0, @Column var name: String = "", + @ForeignKey(stubbedRelationship = true, deleteForeignKeyModel = true, saveForeignKeyModel = true, + onDelete = ForeignKeyAction.CASCADE, onUpdate = ForeignKeyAction.RESTRICT) + var author: Author? = null) : LoadFromCursorListener { + override fun onLoadFromCursor(cursor: FlowCursor) { + + } +} + +class DoubleToDouble(val double: Double) + +@TypeConverter +class DoubleConverter : com.dbflow5.converter.TypeConverter() { + override fun getDBValue(model: DoubleToDouble?) = model?.double + + override fun getModelValue(data: Double?): DoubleToDouble? = data?.let { DoubleToDouble(data) } +} + +class Location(var latitude: DoubleToDouble? = DoubleToDouble(0.0), + var longitude: DoubleToDouble? = DoubleToDouble(0.0)) + +@Table(database = TestDatabase::class) +class Position(@PrimaryKey var id: Int = 0, @ColumnMap var location: Location? = null) + +@Table(database = TestDatabase::class) +class Position2(@PrimaryKey var id: Int = 0, + @ColumnMap(references = arrayOf( + ColumnMapReference(columnName = "latitude", columnMapFieldName = "latitude", + defaultValue = "40.6"), + ColumnMapReference(columnName = "longitude", columnMapFieldName = "longitude", + defaultValue = "55.5"))) + var location: Location? = null) + +class Location2(var latitude: DoubleToDouble? = DoubleToDouble(0.0), + var longitude: Double? = 0.0) + +@Table(database = TestDatabase::class) +class PositionWithTypeConverter(@PrimaryKey var id: Int = 0, + @ColumnMap(references = arrayOf(ColumnMapReference(columnName = "latitude", + columnMapFieldName = "latitude", typeConverter = DoubleConverter::class), + ColumnMapReference(columnName = "longitude", columnMapFieldName = "longitude"))) + var location: Location2? = null) diff --git a/tests/src/test/java/com/dbflow5/models/IndexModels.kt b/tests/src/test/java/com/dbflow5/models/IndexModels.kt new file mode 100644 index 000000000..025946aa2 --- /dev/null +++ b/tests/src/test/java/com/dbflow5/models/IndexModels.kt @@ -0,0 +1,38 @@ +package com.dbflow5.models + +import com.dbflow5.TestDatabase +import com.dbflow5.annotation.Column +import com.dbflow5.annotation.Index +import com.dbflow5.annotation.IndexGroup +import com.dbflow5.annotation.PrimaryKey +import com.dbflow5.annotation.Table +import java.util.* + +/** + * Description: + */ + +@Table(database = TestDatabase::class, indexGroups = arrayOf(IndexGroup(number = 1, name = "firstIndex"), + IndexGroup(number = 2, name = "secondIndex"), + IndexGroup(number = 3, name = "thirdIndex"))) +class IndexModel { + @Index(indexGroups = intArrayOf(1, 2, 3)) + @PrimaryKey + var id: Int = 0 + + @Index(indexGroups = intArrayOf(1)) + @Column + var first_name: String? = null + + @Index(indexGroups = intArrayOf(2)) + @Column + var last_name: String? = null + + @Index(indexGroups = intArrayOf(3)) + @Column + var created_date: Date? = null + + @Index(indexGroups = intArrayOf(2, 3)) + @Column + var isPro: Boolean = false +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/models/InnerClassExample.kt b/tests/src/test/java/com/dbflow5/models/InnerClassExample.kt new file mode 100644 index 000000000..61255b4a4 --- /dev/null +++ b/tests/src/test/java/com/dbflow5/models/InnerClassExample.kt @@ -0,0 +1,14 @@ +package com.dbflow5.models + +import com.dbflow5.TestDatabase +import com.dbflow5.annotation.PrimaryKey +import com.dbflow5.annotation.Table + +/** + * Example ensuring static inner classes work. + */ +class Outer { + + @Table(database = TestDatabase::class) + class Inner(@PrimaryKey var id: Int = 0) +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/models/ManyToMany.kt b/tests/src/test/java/com/dbflow5/models/ManyToMany.kt new file mode 100644 index 000000000..0e190f518 --- /dev/null +++ b/tests/src/test/java/com/dbflow5/models/ManyToMany.kt @@ -0,0 +1,16 @@ +package com.dbflow5.models + +import com.dbflow5.TestDatabase +import com.dbflow5.annotation.Column +import com.dbflow5.annotation.ManyToMany +import com.dbflow5.annotation.PrimaryKey +import com.dbflow5.annotation.Table + +@ManyToMany(referencedTable = Song::class) +@Table(database = TestDatabase::class) +class Artist(@PrimaryKey(autoincrement = true) var id: Int = 0, + @Column var name: String = "") + +@Table(database = TestDatabase::class) +class Song(@PrimaryKey(autoincrement = true) var id: Int = 0, + @Column var name: String = "") \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/models/ManyToManyTest.kt b/tests/src/test/java/com/dbflow5/models/ManyToManyTest.kt new file mode 100644 index 000000000..b3e94a94f --- /dev/null +++ b/tests/src/test/java/com/dbflow5/models/ManyToManyTest.kt @@ -0,0 +1,27 @@ +package com.dbflow5.models + +import com.dbflow5.BaseUnitTest +import com.dbflow5.models.Artist +import com.dbflow5.models.Song +import com.dbflow5.structure.save +import org.junit.Assert.assertTrue +import org.junit.Test + +class ManyToManyTest : BaseUnitTest() { + + @Test + fun testCanCreateManyToMany() { + val artist = Artist(name = "Andrew Grosner") + val song = Song(name = "Livin' on A Prayer") + + artist.save() + song.save() + + val artistSong = Artist_Song() + artistSong.artist = artist + artistSong.song = song + assertTrue(artistSong.save()) + + + } +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/models/ModelViewTest.kt b/tests/src/test/java/com/dbflow5/models/ModelViewTest.kt new file mode 100644 index 000000000..7598dcdc1 --- /dev/null +++ b/tests/src/test/java/com/dbflow5/models/ModelViewTest.kt @@ -0,0 +1,21 @@ +package com.dbflow5.models + +import com.dbflow5.BaseUnitTest +import com.dbflow5.TestDatabase +import com.dbflow5.assertEquals +import com.dbflow5.config.database +import com.dbflow5.models.java.JavaModelView +import org.junit.Test + +class ModelViewTest : BaseUnitTest() { + + @Test + fun validateModelViewQuery() = database(TestDatabase::class) { + "SELECT `id` AS `authorId`,`first_name` || ' ' || `last_name` AS `authorName` FROM `Author`".assertEquals(AuthorView.getQuery()) + } + + @Test + fun validateJavaModelViewQuery() = database(TestDatabase::class) { + "SELECT `first_name` AS `firstName`,`id` AS `id`".assertEquals(JavaModelView.getQuery()) + } +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/models/ModelViews.kt b/tests/src/test/java/com/dbflow5/models/ModelViews.kt new file mode 100644 index 000000000..f64fdebb9 --- /dev/null +++ b/tests/src/test/java/com/dbflow5/models/ModelViews.kt @@ -0,0 +1,42 @@ +package com.dbflow5.models + +import com.dbflow5.TestDatabase +import com.dbflow5.annotation.Column +import com.dbflow5.annotation.ColumnMap +import com.dbflow5.annotation.ModelView +import com.dbflow5.annotation.ModelViewQuery +import com.dbflow5.models.Author_Table.first_name +import com.dbflow5.models.Author_Table.id +import com.dbflow5.models.Author_Table.last_name +import com.dbflow5.query.From +import com.dbflow5.query.property.IProperty +import com.dbflow5.query.property.property +import com.dbflow5.query.select + +class AuthorName(var name: String = "", var age: Int = 0) + + +@ModelView(database = TestDatabase::class) +class AuthorView(@Column var authorId: Int = 0, @Column var authorName: String = "", + @ColumnMap var author: AuthorName? = null) { + + companion object { + @JvmStatic + @ModelViewQuery + fun getQuery(): From = (select(id.`as`("authorId"), + first_name.concatenate(" ".property as IProperty>) + .concatenate(last_name as IProperty>) + .`as`("authorName")) + from Author::class) + } +} + +@ModelView(database = TestDatabase::class, priority = 2, allFields = true) +class PriorityView(var name: String = "") { + + companion object { + @JvmStatic + @ModelViewQuery + fun getQuery(): From = select((first_name + last_name).`as`("name")) from Author::class + } +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/models/NonTypical/nonTypicalClassName.kt b/tests/src/test/java/com/dbflow5/models/NonTypical/nonTypicalClassName.kt new file mode 100644 index 000000000..00b92a96b --- /dev/null +++ b/tests/src/test/java/com/dbflow5/models/NonTypical/nonTypicalClassName.kt @@ -0,0 +1,11 @@ +package com.dbflow5.models.NonTypical + +import com.dbflow5.TestDatabase +import com.dbflow5.annotation.PrimaryKey +import com.dbflow5.annotation.Table + +/** + * Tests package name capitalized, class name is lower cased. + */ +@Table(database = TestDatabase::class) +class nonTypicalClassName(@PrimaryKey var id: Int = 0) \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/models/OneToManyModelTest.kt b/tests/src/test/java/com/dbflow5/models/OneToManyModelTest.kt new file mode 100644 index 000000000..bab68bc34 --- /dev/null +++ b/tests/src/test/java/com/dbflow5/models/OneToManyModelTest.kt @@ -0,0 +1,49 @@ +package com.dbflow5.models + +import com.dbflow5.BaseUnitTest +import com.dbflow5.TestDatabase +import com.dbflow5.config.database +import com.dbflow5.query.list +import com.dbflow5.query.result +import com.dbflow5.query.select +import com.dbflow5.structure.delete +import com.dbflow5.structure.exists +import com.dbflow5.structure.save +import org.junit.Assert.assertFalse +import org.junit.Assert.assertNotNull +import org.junit.Assert.assertNull +import org.junit.Assert.assertTrue +import org.junit.Test + +class OneToManyModelTest : BaseUnitTest() { + + @Test + fun testOneToManyModel() { + database(TestDatabase::class) { + var testModel2 = TwoColumnModel("Greater", 4) + testModel2.save() + + testModel2 = TwoColumnModel("Lesser", 1) + testModel2.save() + + // assert we save + var oneToManyModel = OneToManyModel("HasOrders") + oneToManyModel.save() + assertTrue(oneToManyModel.exists()) + + // assert loading works as expected. + oneToManyModel = (select from OneToManyModel::class).result!! + assertNotNull(oneToManyModel.getRelatedOrders(this)) + assertTrue(!oneToManyModel.getRelatedOrders(this).isEmpty()) + + // assert the deletion cleared the variable + oneToManyModel.delete() + assertFalse(oneToManyModel.exists()) + assertNull(oneToManyModel.orders) + + // assert singular relationship was deleted. + val list = (select from TwoColumnModel::class).list + assertTrue(list.size == 1) + } + } +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/models/OneToManyModels.kt b/tests/src/test/java/com/dbflow5/models/OneToManyModels.kt new file mode 100644 index 000000000..1abfba2ca --- /dev/null +++ b/tests/src/test/java/com/dbflow5/models/OneToManyModels.kt @@ -0,0 +1,51 @@ +package com.dbflow5.models + +import com.dbflow5.TestDatabase +import com.dbflow5.annotation.OneToMany +import com.dbflow5.annotation.OneToManyMethod +import com.dbflow5.annotation.PrimaryKey +import com.dbflow5.annotation.Table +import com.dbflow5.database.DatabaseWrapper +import com.dbflow5.models.TwoColumnModel_Table.id +import com.dbflow5.query.select +import com.dbflow5.structure.BaseModel +import com.dbflow5.structure.oneToMany + +@Table(database = TestDatabase::class) +class OneToManyModel(@PrimaryKey var name: String? = null) { + + var orders: List? = null + + var models: List? = null + + @get:OneToMany(oneToManyMethods = [OneToManyMethod.ALL]) + var simpleModels by oneToMany { select from OneToManyBaseModel::class } + + @OneToMany(oneToManyMethods = [OneToManyMethod.ALL], + variableName = "orders", efficientMethods = false) + fun getRelatedOrders(wrapper: DatabaseWrapper): List { + var localOrders = orders + if (localOrders == null) { + localOrders = (select from TwoColumnModel::class where id.greaterThan(3)) + .queryList(wrapper) + } + orders = localOrders + return localOrders + } + + @OneToMany(oneToManyMethods = [OneToManyMethod.DELETE], + variableName = "models") + fun getRelatedModels(wrapper: DatabaseWrapper): List { + var localModels = models + if (localModels == null) { + localModels = (select from OneToManyBaseModel::class).queryList(wrapper) + } + models = localModels + return localModels + } + + +} + +@Table(database = TestDatabase::class) +class OneToManyBaseModel(@PrimaryKey var id: Int = 0) : BaseModel() \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/models/ParentChildCachingTest.kt b/tests/src/test/java/com/dbflow5/models/ParentChildCachingTest.kt new file mode 100644 index 000000000..d9f0dae14 --- /dev/null +++ b/tests/src/test/java/com/dbflow5/models/ParentChildCachingTest.kt @@ -0,0 +1,39 @@ +package com.dbflow5.models + +import com.dbflow5.BaseUnitTest +import com.dbflow5.TestDatabase +import com.dbflow5.config.database +import com.dbflow5.query.result +import com.dbflow5.query.select +import com.dbflow5.structure.load +import com.dbflow5.structure.save +import org.junit.Assert.assertEquals +import org.junit.Test + +/** + * Description: + */ +class ParentChildCachingTest : BaseUnitTest() { + + + @Test + fun testCanLoadChildFromCache() = database(TestDatabase::class) { + val child = TestModelChild() + child.id = 1 + child.name = "Test child" + child.save() + + var parent = TestModelParent() + parent.id = 1 + parent.name = "Test parent" + parent.child = child + parent.save() + + parent = (select from TestModelParent::class).result!! + var parentChild = parent.child!! + parentChild = parentChild.load()!! + + assertEquals(1, parentChild.id) + assertEquals("Test child", parentChild.name) + } +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/models/QueryModelTest.kt b/tests/src/test/java/com/dbflow5/models/QueryModelTest.kt new file mode 100644 index 000000000..e9090e6cc --- /dev/null +++ b/tests/src/test/java/com/dbflow5/models/QueryModelTest.kt @@ -0,0 +1,37 @@ +package com.dbflow5.models + +import com.dbflow5.BaseUnitTest +import com.dbflow5.TestDatabase +import com.dbflow5.config.database +import com.dbflow5.models.Author_Table.id +import com.dbflow5.models.Blog_Table.author_id +import com.dbflow5.models.Blog_Table.name +import com.dbflow5.query.select +import com.dbflow5.structure.exists +import com.dbflow5.structure.save +import org.junit.Assert.assertEquals +import org.junit.Test + +/** + * Description: Tests to ensure we can load a Query model from the DB + */ +class QueryModelTest : BaseUnitTest() { + + @Test + fun testCanLoadAuthorBlogs() = database(TestDatabase::class) { + val author = Author(0, "Andrew", "Grosner") + author.save() + val blog = Blog(0, "My First Blog", author) + blog.save() + + assert(author.exists()) + assert(blog.exists()) + + val result = (select(name.withTable().`as`("blogName"), id.withTable().`as`("authorId"), + Blog_Table.id.withTable().`as`("blogId")) from Blog::class innerJoin + Author::class on (author_id.withTable() eq id.withTable())) + .queryCustomSingle(AuthorNameQuery::class.java, this)!! + assertEquals(author.id, result.authorId) + assertEquals(blog.id, result.blogId) + } +} diff --git a/tests/src/test/java/com/dbflow5/models/QueryModels.kt b/tests/src/test/java/com/dbflow5/models/QueryModels.kt new file mode 100644 index 000000000..7f6c928b7 --- /dev/null +++ b/tests/src/test/java/com/dbflow5/models/QueryModels.kt @@ -0,0 +1,29 @@ +package com.dbflow5.models + +import com.dbflow5.TestDatabase +import com.dbflow5.annotation.Column +import com.dbflow5.annotation.QueryModel +import com.dbflow5.converter.TypeConverter +import com.dbflow5.data.Blob + +@QueryModel(database = TestDatabase::class, allFields = true) +class AuthorNameQuery(var blogName: String = "", + var authorId: Int = 0, var blogId: Int = 0) + + +@QueryModel(database = TestDatabase::class) +class CustomBlobModel(@Column var myBlob: MyBlob? = null) { + + class MyBlob(val blob: ByteArray) + + @com.dbflow5.annotation.TypeConverter + class MyTypeConverter : TypeConverter() { + + override fun getDBValue(model: MyBlob?) = model?.let { Blob(model.blob) } + + override fun getModelValue(data: Blob?) = data?.blob?.let { MyBlob(it) } + } +} + +@QueryModel(database = TestDatabase::class, allFields = true) +class AllFieldsQueryModel(var model: String? = null) \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/models/SimpleTestModels.kt b/tests/src/test/java/com/dbflow5/models/SimpleTestModels.kt new file mode 100644 index 000000000..0ead6d493 --- /dev/null +++ b/tests/src/test/java/com/dbflow5/models/SimpleTestModels.kt @@ -0,0 +1,208 @@ +package com.dbflow5.models + +import com.dbflow5.TestDatabase +import com.dbflow5.annotation.Column +import com.dbflow5.annotation.ColumnIgnore +import com.dbflow5.annotation.ConflictAction +import com.dbflow5.annotation.ForeignKey +import com.dbflow5.annotation.ManyToMany +import com.dbflow5.annotation.PrimaryKey +import com.dbflow5.annotation.QueryModel +import com.dbflow5.annotation.Table +import com.dbflow5.converter.TypeConverter +import com.dbflow5.data.Blob +import com.dbflow5.database.DatabaseStatement +import com.dbflow5.query.SQLiteStatementListener +import com.dbflow5.structure.BaseModel +import java.math.BigDecimal +import java.math.BigInteger +import java.util.* + + +/** + * Description: + */ +@Table(database = TestDatabase::class) +class SimpleModel(@PrimaryKey var name: String? = "") + +@QueryModel(database = TestDatabase::class) +class SimpleCustomModel(@Column var name: String? = "") + +@Table(database = TestDatabase::class, insertConflict = ConflictAction.FAIL, updateConflict = ConflictAction.FAIL) +class NumberModel(@PrimaryKey var id: Int = 0) + +@Table(database = TestDatabase::class) +class CharModel(@PrimaryKey var id: Int = 0, @Column var exampleChar: Char? = null) + +@Table(database = TestDatabase::class) +class TwoColumnModel(@PrimaryKey var name: String? = "", @Column(defaultValue = "56") var id: Int = 0) + +@Table(database = TestDatabase::class, createWithDatabase = false) +class DontCreateModel(@PrimaryKey var id: Int = 0) + +enum class Difficulty { + EASY, + MEDIUM, + HARD +} + +@Table(database = TestDatabase::class) +class EnumModel(@PrimaryKey var id: Int = 0, @Column var difficulty: Difficulty? = Difficulty.EASY) + +@Table(database = TestDatabase::class, allFields = true) +open class AllFieldsModel(@PrimaryKey var name: String? = null, + var count: Int? = 0, + @Column(getterName = "getTruth") + var truth: Boolean = false, + internal val finalName: String = "", + @ColumnIgnore private val hidden: Int = 0) { + + companion object { + + // example field to ensure static not used. + var COUNT: Int = 0 + } +} + +@Table(database = TestDatabase::class, allFields = true) +class SubclassAllFields(@Column var order: Int = 0) : AllFieldsModel() + +@Table(database = TestDatabase::class, assignDefaultValuesFromCursor = false) +class DontAssignDefaultModel(@PrimaryKey var name: String? = null, + @Column(getterName = "getNullableBool") var nullableBool: Boolean? = null, + @Column var index: Int = 0) + +@Table(database = TestDatabase::class, orderedCursorLookUp = true) +class OrderCursorModel(@PrimaryKey var id: Int = 0, @Column var name: String? = "", + @Column var age: Int = 0) + +@Table(database = TestDatabase::class) +class TypeConverterModel(@PrimaryKey var id: Int = 0, + @Column(typeConverter = BlobConverter::class) var opaqueData: ByteArray? = null, + @Column var blob: Blob? = null, + @Column(typeConverter = CustomTypeConverter::class) + @PrimaryKey var customType: CustomType? = null) + +@Table(database = TestDatabase::class) +class EnumTypeConverterModel(@PrimaryKey var id: Int = 0, + @Column var blob: Blob? = null, + @Column var byteArray: ByteArray? = null, + @Column(typeConverter = CustomEnumTypeConverter::class) + var difficulty: Difficulty = Difficulty.EASY) + +@Table(database = TestDatabase::class, allFields = true) +class FeedEntry(@PrimaryKey var id: Int = 0, + var title: String? = null, + var subtitle: String? = null) + +@Table(database = TestDatabase::class) +@ManyToMany( + generatedTableClassName = "Refund", referencedTable = Transfer::class, + referencedTableColumnName = "refund_in", thisTableColumnName = "refund_out", + saveForeignKeyModels = true +) +data class Transfer(@PrimaryKey var transfer_id: UUID = UUID.randomUUID()) + +@Table(database = TestDatabase::class) +data class Transfer2( + @PrimaryKey + var id: UUID = UUID.randomUUID(), + @ForeignKey(stubbedRelationship = true) + var origin: Account? = null +) + +@Table(database = TestDatabase::class) +data class Account(@PrimaryKey var id: UUID = UUID.randomUUID()) + +@Table(database = TestDatabase::class) +class SqlListenerModel(@PrimaryKey var id: Int = 0) : SQLiteStatementListener { + + override fun onBindToInsertStatement(databaseStatement: DatabaseStatement) { + TODO("not implemented") + } + + override fun onBindToUpdateStatement(databaseStatement: DatabaseStatement) { + TODO("not implemented") + } + + override fun onBindToDeleteStatement(databaseStatement: DatabaseStatement) { + TODO("not implemented") + } +} + +class CustomType(var name: Int? = 0) + +class CustomTypeConverter : TypeConverter() { + override fun getDBValue(model: CustomType?) = model?.name + + override fun getModelValue(data: Int?) = if (data == null) { + null + } else { + CustomType(data) + } + +} + +class CustomEnumTypeConverter : TypeConverter() { + override fun getDBValue(model: Difficulty?) = model?.name?.substring(0..0) + + override fun getModelValue(data: String?) = when (data) { + "E" -> Difficulty.EASY + "M" -> Difficulty.MEDIUM + "H" -> Difficulty.HARD + else -> Difficulty.HARD + } + +} + +@com.dbflow5.annotation.TypeConverter +class BlobConverter : TypeConverter() { + + override fun getDBValue(model: ByteArray?): Blob? { + return if (model == null) null else Blob(model) + } + + override fun getModelValue(data: Blob?): ByteArray? { + return data?.blob + } +} + +@Table(database = TestDatabase::class) +class DefaultModel(@PrimaryKey @Column(defaultValue = "5") var id: Int? = 0, + @Column(defaultValue = "5.0") var location: Double? = 0.0, + @Column(defaultValue = "\"String\"") var name: String? = "") + +@Table(database = TestDatabase::class, cachingEnabled = true) +class TestModelChild : BaseModel() { + @PrimaryKey + var id: Long = 0 + + @Column + var name: String? = null +} + +@Table(database = TestDatabase::class) +class TestModelParent : BaseModel() { + @PrimaryKey + var id: Long = 0 + + @Column + var name: String? = null + + @ForeignKey(stubbedRelationship = true) + var child: TestModelChild? = null +} + +@Table(database = TestDatabase::class) +class NullableNumbers(@PrimaryKey var id: Int = 0, + @Column var f: Float? = null, + @Column var d: Double? = null, + @Column var l: Long? = null, + @Column var i: Int? = null, + @Column var bigDecimal: BigDecimal? = null, + @Column var bigInteger: BigInteger? = null) + +@Table(database = TestDatabase::class) +class NonNullKotlinModel(@PrimaryKey var name: String = "", + @Column var date: Date = Date(), + @Column var numb: Int = 0) \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/models/SimpleTestModelsTest.kt b/tests/src/test/java/com/dbflow5/models/SimpleTestModelsTest.kt new file mode 100644 index 000000000..901bb8dda --- /dev/null +++ b/tests/src/test/java/com/dbflow5/models/SimpleTestModelsTest.kt @@ -0,0 +1,22 @@ +package com.dbflow5.models + +import com.dbflow5.BaseUnitTest +import com.dbflow5.config.modelAdapter +import org.junit.Assert.assertEquals +import org.junit.Test + +/** + * Description: + */ +class SimpleTestModelsTest : BaseUnitTest() { + + @Test + fun validateCreationQuery() { + assertEquals("CREATE TABLE IF NOT EXISTS `TypeConverterModel`(" + + "`id` INTEGER, " + + "`opaqueData` BLOB, " + + "`blob` BLOB, " + + "`customType` INTEGER, " + + "PRIMARY KEY(`id`, `customType`))", modelAdapter().creationQuery) + } +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/models/java/DatabaseModel.java b/tests/src/test/java/com/dbflow5/models/java/DatabaseModel.java new file mode 100644 index 000000000..4b9294842 --- /dev/null +++ b/tests/src/test/java/com/dbflow5/models/java/DatabaseModel.java @@ -0,0 +1,17 @@ +package com.dbflow5.models.java; + +import com.dbflow5.annotation.PrimaryKey; +import com.dbflow5.structure.BaseModel; + +public class DatabaseModel extends BaseModel { + @PrimaryKey + private Integer id; + + public Integer getId() { + return id; + } + + public void setId(Integer id) { + this.id = id; + } +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/models/java/JavaModelView.java b/tests/src/test/java/com/dbflow5/models/java/JavaModelView.java new file mode 100644 index 000000000..e6f788630 --- /dev/null +++ b/tests/src/test/java/com/dbflow5/models/java/JavaModelView.java @@ -0,0 +1,26 @@ +package com.dbflow5.models.java; + +import com.dbflow5.TestDatabase; +import com.dbflow5.annotation.Column; +import com.dbflow5.annotation.ModelView; +import com.dbflow5.annotation.ModelViewQuery; +import com.dbflow5.database.DatabaseWrapper; +import com.dbflow5.models.Author_Table; +import com.dbflow5.query.SQLite; +import com.dbflow5.sql.Query; + +@ModelView(database = TestDatabase.class) +public class JavaModelView { + + @ModelViewQuery + public static Query getQuery() { + return SQLite.select(Author_Table.first_name.as("firstName"), Author_Table.id.as("id")); + } + + @Column + String id; + + @Column + Integer firstName; + +} diff --git a/tests/src/test/java/com/dbflow5/models/java/otherpackage/ExampleModel.java b/tests/src/test/java/com/dbflow5/models/java/otherpackage/ExampleModel.java new file mode 100644 index 000000000..2e6cbc0b7 --- /dev/null +++ b/tests/src/test/java/com/dbflow5/models/java/otherpackage/ExampleModel.java @@ -0,0 +1,12 @@ +package com.dbflow5.models.java.otherpackage; + +import com.dbflow5.TestDatabase; +import com.dbflow5.annotation.Column; +import com.dbflow5.annotation.Table; +import com.dbflow5.models.java.DatabaseModel; + +@Table(database = TestDatabase.class) +public class ExampleModel extends DatabaseModel { + @Column + String name; +} diff --git a/tests/src/test/java/com/dbflow5/paging/QueryDataSourceTest.kt b/tests/src/test/java/com/dbflow5/paging/QueryDataSourceTest.kt new file mode 100644 index 000000000..94f23181c --- /dev/null +++ b/tests/src/test/java/com/dbflow5/paging/QueryDataSourceTest.kt @@ -0,0 +1,60 @@ +package com.dbflow5.paging + +import android.arch.paging.PagedList +import com.dbflow5.BaseUnitTest +import com.dbflow5.TestDatabase +import com.dbflow5.assertThrowsException +import com.dbflow5.config.database +import com.dbflow5.models.SimpleModel +import com.dbflow5.models.SimpleModel_Table +import com.dbflow5.query.select +import com.dbflow5.query.set +import com.dbflow5.query.update +import com.dbflow5.structure.save +import org.junit.Assert.assertEquals +import org.junit.Assert.assertTrue +import org.junit.Test + +/** + * Description: + */ +class QueryDataSourceTest : BaseUnitTest() { + + @Test + fun testLoadInitialParams() { + database { + (0 until 100).forEach { SimpleModel("$it").save(this) } + + val factory = (select from SimpleModel::class).toDataSourceFactory(this) + val list = PagedList.Builder(factory.create(), + PagedList.Config.Builder() + .setPageSize(3) + .setPrefetchDistance(6) + .setEnablePlaceholders(true).build()) + .setFetchExecutor { it.run() } // run on main + .setNotifyExecutor { it.run() } + .build() + + assertEquals(100, list.size) + + list.forEachIndexed { index, simpleModel -> + list.loadAround(index) + assertEquals(index, simpleModel.name?.toInt()) + + // assert we don't run over somehow. + assertTrue(index < 100) + } + } + } + + @Test + fun testThrowsErrorOnInvalidType() { + database { + assertThrowsException(IllegalArgumentException::class) { + (update() set (SimpleModel_Table.name.eq("name"))) + .toDataSourceFactory(this) + .create() + } + } + } +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/provider/ContentProviderObjects.kt b/tests/src/test/java/com/dbflow5/provider/ContentProviderObjects.kt new file mode 100644 index 000000000..a85cf2b6e --- /dev/null +++ b/tests/src/test/java/com/dbflow5/provider/ContentProviderObjects.kt @@ -0,0 +1,93 @@ +package com.dbflow5.provider + +import com.dbflow5.annotation.Column +import com.dbflow5.annotation.Database +import com.dbflow5.annotation.ForeignKey +import com.dbflow5.annotation.ForeignKeyReference +import com.dbflow5.annotation.PrimaryKey +import com.dbflow5.annotation.Table +import com.dbflow5.config.DBFlowDatabase +import com.dbflow5.contentprovider.annotation.ContentProvider +import com.dbflow5.contentprovider.annotation.ContentType +import com.dbflow5.contentprovider.annotation.ContentUri +import com.dbflow5.contentprovider.annotation.TableEndpoint + +/** + * Description: + */ +@ContentProvider(authority = ContentDatabase.AUTHORITY, database = ContentDatabase::class, + baseContentUri = ContentDatabase.BASE_CONTENT_URI) +@Database(version = ContentDatabase.VERSION) +abstract class ContentDatabase : DBFlowDatabase() { + companion object { + const val BASE_CONTENT_URI = "content://" + + const val AUTHORITY = "com.raizlabs.android.content.test.ContentDatabase" + + const val VERSION = 1 + } +} + +@TableEndpoint(name = ContentProviderModel.NAME, contentProvider = ContentDatabase::class) +@Table(database = ContentDatabase::class, name = ContentProviderModel.NAME, generateContentValues = true) +class ContentProviderModel(@PrimaryKey(autoincrement = true) + var id: Long = 0, + @Column + var notes: String? = null, + @Column + var title: String? = null) : BaseProviderModel() { + + override val deleteUri get() = TestContentProvider.ContentProviderModel.CONTENT_URI + + override val insertUri get() = TestContentProvider.ContentProviderModel.CONTENT_URI + + override val updateUri get() = TestContentProvider.ContentProviderModel.CONTENT_URI + + override val queryUri get() = TestContentProvider.ContentProviderModel.CONTENT_URI + + companion object { + + const val NAME = "ContentProviderModel" + + @ContentUri(path = NAME, type = "${ContentType.VND_MULTIPLE}${NAME}") + val CONTENT_URI = ContentUtils.buildUriWithAuthority(ContentDatabase.AUTHORITY) + } +} + +@Table(database = ContentDatabase::class, generateContentValues = true) +class NoteModel(@PrimaryKey(autoincrement = true) + var id: Long = 0, + + @ForeignKey(references = arrayOf(ForeignKeyReference(columnName = "providerModel", + foreignKeyColumnName = "id"))) + var contentProviderModel: ContentProviderModel? = null, + + @Column + var note: String? = null, + + @Column + var isOpen: Boolean = false) : BaseProviderModel() { + + override val deleteUri get() = TestContentProvider.NoteModel.CONTENT_URI + + override val insertUri get() = TestContentProvider.NoteModel.CONTENT_URI + + override val updateUri get() = TestContentProvider.NoteModel.CONTENT_URI + + override val queryUri get() = TestContentProvider.NoteModel.CONTENT_URI +} + +@Table(database = ContentDatabase::class, generateContentValues = true) +class TestSyncableModel(@PrimaryKey(autoincrement = true) + var id: Long = 0, + @Column + var name: String? = null) : BaseSyncableProviderModel() { + + override val deleteUri get() = TestContentProvider.TestSyncableModel.CONTENT_URI + + override val insertUri get() = TestContentProvider.TestSyncableModel.CONTENT_URI + + override val updateUri get() = TestContentProvider.TestSyncableModel.CONTENT_URI + + override val queryUri get() = TestContentProvider.TestSyncableModel.CONTENT_URI +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/provider/ContentProviderTests.kt b/tests/src/test/java/com/dbflow5/provider/ContentProviderTests.kt new file mode 100644 index 000000000..cb8976709 --- /dev/null +++ b/tests/src/test/java/com/dbflow5/provider/ContentProviderTests.kt @@ -0,0 +1,133 @@ +package com.dbflow5.provider + +import android.content.ContentResolver +import android.content.pm.ProviderInfo +import com.dbflow5.BaseUnitTest +import com.dbflow5.config.database +import com.dbflow5.query.Delete.Companion.table +import com.dbflow5.query.Delete.Companion.tables +import com.dbflow5.query.result +import com.dbflow5.query.select +import com.dbflow5.structure.exists +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue +import org.junit.Before +import org.junit.Test +import org.robolectric.Robolectric +import org.robolectric.RuntimeEnvironment + +/** + * Description: + */ +class ContentProviderTests : BaseUnitTest() { + private val mockContentResolver: ContentResolver + get() = RuntimeEnvironment.application.contentResolver + + @Before + fun setUp() { + val info = ProviderInfo() + info.authority = TestContentProvider.AUTHORITY + Robolectric.buildContentProvider(TestContentProvider_Provider::class.java).create(info) + } + + @Test + fun testContentProviderUtils() { + database(ContentDatabase::class) { + tables(NoteModel::class.java, ContentProviderModel::class.java) + + var contentProviderModel = ContentProviderModel() + contentProviderModel.notes = "Test" + var uri = ContentUtils.insert(mockContentResolver, TestContentProvider.ContentProviderModel.CONTENT_URI, contentProviderModel) + assertEquals(TestContentProvider.ContentProviderModel.CONTENT_URI.toString() + "/" + contentProviderModel.id, uri.toString()) + assertTrue(contentProviderModel.exists()) + + contentProviderModel.notes = "NewTest" + val update = ContentUtils.update(mockContentResolver, TestContentProvider.ContentProviderModel.CONTENT_URI, contentProviderModel) + assertEquals(update.toLong(), 1) + assertTrue(contentProviderModel.exists()) + contentProviderModel = contentProviderModel.load(this)!! + assertEquals("NewTest", contentProviderModel.notes) + + val noteModel = NoteModel() + noteModel.note = "Test" + noteModel.contentProviderModel = contentProviderModel + uri = ContentUtils.insert(mockContentResolver, TestContentProvider.NoteModel.CONTENT_URI, noteModel) + assertEquals(TestContentProvider.NoteModel.CONTENT_URI.toString() + "/" + noteModel.id, uri.toString()) + assertTrue(noteModel.exists()) + + assertTrue(ContentUtils.delete(mockContentResolver, TestContentProvider.NoteModel.CONTENT_URI, noteModel) > 0) + assertTrue(!noteModel.exists()) + + assertTrue(ContentUtils.delete(mockContentResolver, TestContentProvider.ContentProviderModel.CONTENT_URI, contentProviderModel) > 0) + assertTrue(!contentProviderModel.exists()) + + tables(NoteModel::class.java, ContentProviderModel::class.java) + } + } + + @Test + fun testContentProviderNative() { + database(ContentDatabase::class) { + tables(NoteModel::class.java, ContentProviderModel::class.java) + + var contentProviderModel = ContentProviderModel(notes = "Test") + contentProviderModel.insert() + assertTrue(contentProviderModel.exists()) + + contentProviderModel.notes = "NewTest" + contentProviderModel.update() + contentProviderModel = contentProviderModel.load(this)!! + assertEquals("NewTest", contentProviderModel.notes) + + var noteModel = NoteModel(note = "Test", contentProviderModel = contentProviderModel) + noteModel.insert() + + noteModel.note = "NewTest" + noteModel.update() + noteModel = noteModel.load(this)!! + assertEquals("NewTest", noteModel.note) + + assertTrue(noteModel.exists()) + + noteModel.delete() + assertTrue(!noteModel.exists()) + + contentProviderModel.delete() + assertTrue(!contentProviderModel.exists()) + + tables(NoteModel::class.java, ContentProviderModel::class.java) + } + } + + @Test + fun testSyncableModel() { + database(ContentDatabase::class) { + table(this, TestSyncableModel::class.java) + + var testSyncableModel = TestSyncableModel(name = "Name") + testSyncableModel.save() + + assertTrue(testSyncableModel.exists()) + + testSyncableModel.name = "TestName" + testSyncableModel.update() + assertEquals(testSyncableModel.name, "TestName") + + testSyncableModel = (select from TestSyncableModel::class + where (TestSyncableModel_Table.id.`is`(testSyncableModel.id))).result!! + + var fromContentProvider = TestSyncableModel(id = testSyncableModel.id) + fromContentProvider = fromContentProvider.load(this)!! + + assertEquals(fromContentProvider.name, testSyncableModel.name) + assertEquals(fromContentProvider.id, testSyncableModel.id) + + testSyncableModel.delete() + assertFalse(testSyncableModel.exists()) + + table(this, TestSyncableModel::class.java) + } + } + +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/provider/RealContentProvider.kt b/tests/src/test/java/com/dbflow5/provider/RealContentProvider.kt new file mode 100644 index 000000000..0c3511599 --- /dev/null +++ b/tests/src/test/java/com/dbflow5/provider/RealContentProvider.kt @@ -0,0 +1,42 @@ +package com.dbflow5.provider + +import android.content.ContentProvider +import android.content.ContentValues +import android.database.Cursor +import android.net.Uri +import com.dbflow5.TestDatabase +import com.dbflow5.config.FlowConfig +import com.dbflow5.config.FlowManager +import com.dbflow5.config.database +import com.dbflow5.database.DatabaseWrapper + +class RealContentProvider : ContentProvider() { + + lateinit var database: DatabaseWrapper + + override fun onCreate(): Boolean { + FlowManager.init(FlowConfig.Builder(context).build()) + database = database() + return true + } + + override fun query(uri: Uri, projection: Array?, selection: String?, selectionArgs: Array?, sortOrder: String?): Cursor? { + return null + } + + override fun getType(uri: Uri): String? { + return null + } + + override fun insert(uri: Uri, values: ContentValues?): Uri? { + return null + } + + override fun delete(uri: Uri, selection: String?, selectionArgs: Array?): Int { + return 0 + } + + override fun update(uri: Uri, values: ContentValues?, selection: String?, selectionArgs: Array?): Int { + return 0 + } +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/provider/TestContentProvider.kt b/tests/src/test/java/com/dbflow5/provider/TestContentProvider.kt new file mode 100644 index 000000000..d00a9ee2a --- /dev/null +++ b/tests/src/test/java/com/dbflow5/provider/TestContentProvider.kt @@ -0,0 +1,137 @@ +package com.dbflow5.provider + +import android.content.ContentValues +import android.content.Context +import android.net.Uri +import com.dbflow5.contentprovider.annotation.ContentProvider +import com.dbflow5.contentprovider.annotation.ContentType +import com.dbflow5.contentprovider.annotation.ContentUri +import com.dbflow5.contentprovider.annotation.Notify +import com.dbflow5.contentprovider.annotation.NotifyMethod +import com.dbflow5.contentprovider.annotation.PathSegment +import com.dbflow5.contentprovider.annotation.TableEndpoint +import com.dbflow5.getContentValuesKey + +@ContentProvider(authority = TestContentProvider.AUTHORITY, database = ContentDatabase::class, + baseContentUri = TestContentProvider.BASE_CONTENT_URI) +object TestContentProvider { + + const val AUTHORITY = "com.dbflow5.test.provider" + + const val BASE_CONTENT_URI = "content://" + + private fun buildUri(vararg paths: String): Uri { + val builder = Uri.parse(BASE_CONTENT_URI + AUTHORITY).buildUpon() + for (path in paths) { + builder.appendPath(path) + } + return builder.build() + } + + @TableEndpoint(name = ContentProviderModel.ENDPOINT, contentProvider = ContentDatabase::class) + object ContentProviderModel { + + const val ENDPOINT = "ContentProviderModel" + + @JvmStatic + @ContentUri(path = ENDPOINT, + type = ContentType.VND_MULTIPLE + ENDPOINT) + var CONTENT_URI = buildUri(ENDPOINT) + + @JvmStatic + @ContentUri(path = ENDPOINT + "/#", + type = ContentType.VND_SINGLE + ENDPOINT, + segments = arrayOf(PathSegment(segment = 1, column = "id"))) + fun withId(id: Long): Uri { + return buildUri(id.toString()) + } + + @JvmStatic + @Notify(notifyMethod = NotifyMethod.INSERT, paths = arrayOf(ENDPOINT + "/#")) + fun onInsert(contentValues: ContentValues): Array { + val id = contentValues.getAsLong("id")!! + return arrayOf(withId(id)) + } + + } + + @TableEndpoint(name = NoteModel.ENDPOINT, contentProvider = ContentDatabase::class) + object NoteModel { + + const val ENDPOINT = "NoteModel" + + @ContentUri(path = ENDPOINT, type = ContentType.VND_MULTIPLE + ENDPOINT) + var CONTENT_URI = buildUri(ENDPOINT) + + @JvmStatic + @ContentUri(path = ENDPOINT + "/#", type = ContentType.VND_MULTIPLE + ENDPOINT, + segments = arrayOf(PathSegment(column = "id", segment = 1))) + fun withId(id: Long): Uri { + return buildUri(ENDPOINT, id.toString()) + } + + @JvmStatic + @ContentUri(path = ENDPOINT + "/#/#", + type = ContentType.VND_SINGLE + ContentProviderModel.ENDPOINT, + segments = arrayOf(PathSegment(column = "id", segment = 2))) + fun fromList(id: Long): Uri { + return buildUri(ENDPOINT, "fromList", id.toString()) + } + + @JvmStatic + @ContentUri(path = ENDPOINT + "/#/#", + type = ContentType.VND_SINGLE + ContentProviderModel.ENDPOINT, + segments = arrayOf(PathSegment(column = "id", segment = 1), + PathSegment(column = "isOpen", segment = 2))) + fun withOpenId(id: Long, isOpen: Boolean): Uri { + return buildUri(ENDPOINT, id.toString(), isOpen.toString()) + } + + @JvmStatic + @Notify(notifyMethod = NotifyMethod.INSERT, paths = arrayOf(ENDPOINT)) + fun onInsert(contentValues: ContentValues): Array { + val listId = contentValues.getAsLong(getContentValuesKey(contentValues, "providerModel"))!! + return arrayOf(ContentProviderModel.withId(listId), fromList(listId)) + } + + @JvmStatic + @Notify(notifyMethod = NotifyMethod.INSERT, paths = arrayOf(ENDPOINT)) + fun onInsert2(contentValues: ContentValues): Uri { + val listId = contentValues.getAsLong(getContentValuesKey(contentValues, "providerModel"))!! + return fromList(listId) + } + + @JvmStatic + @Notify(notifyMethod = NotifyMethod.UPDATE, paths = arrayOf(ENDPOINT + "/#")) + fun onUpdate(context: Context, uri: Uri): Array { + val noteId = java.lang.Long.valueOf(uri.pathSegments[1])!! + val c = context.contentResolver.query(uri, arrayOf("noteModel"), null, null, null) + c!!.moveToFirst() + val listId = c.getLong(c.getColumnIndex("providerModel")) + c.close() + + return arrayOf(withId(noteId), fromList(listId), ContentProviderModel.withId(listId)) + } + + @JvmStatic + @Notify(notifyMethod = NotifyMethod.DELETE, paths = arrayOf(ENDPOINT + "/#")) + fun onDelete(context: Context, uri: Uri): Array { + val noteId = java.lang.Long.valueOf(uri.pathSegments[1])!! + val c = context.contentResolver.query(uri, null, null, null, null) + c!!.moveToFirst() + val listId = c.getLong(c.getColumnIndex("providerModel")) + c.close() + + return arrayOf(withId(noteId), fromList(listId), ContentProviderModel.withId(listId)) + } + } + + @TableEndpoint(name = TestSyncableModel.ENDPOINT, contentProvider = ContentDatabase::class) + object TestSyncableModel { + + const val ENDPOINT = "TestSyncableModel" + + @ContentUri(path = ENDPOINT, type = "${ContentType.VND_MULTIPLE}${ENDPOINT}") + var CONTENT_URI = buildUri(ENDPOINT) + } +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/query/cache/ModelLruCacheTest.kt b/tests/src/test/java/com/dbflow5/query/cache/ModelLruCacheTest.kt new file mode 100644 index 000000000..20f09e05d --- /dev/null +++ b/tests/src/test/java/com/dbflow5/query/cache/ModelLruCacheTest.kt @@ -0,0 +1,35 @@ +package com.dbflow5.query.cache + +import com.dbflow5.BaseUnitTest +import com.dbflow5.models.NumberModel +import org.junit.Assert +import org.junit.Test + +class ModelLruCacheTest : BaseUnitTest() { + + + @Test + fun validateCacheAddRemove() { + val cache = SimpleMapCache(10) + cache.addModel(1, NumberModel(1)) + + Assert.assertEquals(1, cache[1]!!.id) + Assert.assertEquals(1, cache.cache.size) + + cache.removeModel(1) + + Assert.assertTrue(cache.cache.isEmpty()) + } + + @Test + fun validateCacheClear() { + val cache = SimpleMapCache(10) + cache.addModel(1, NumberModel(1)) + cache.addModel(2, NumberModel(2)) + Assert.assertEquals(2, cache.cache.size) + + cache.clear() + + Assert.assertTrue(cache.cache.isEmpty()) + } +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/query/cache/SimpleMapCacheTest.kt b/tests/src/test/java/com/dbflow5/query/cache/SimpleMapCacheTest.kt new file mode 100644 index 000000000..d3cd6b106 --- /dev/null +++ b/tests/src/test/java/com/dbflow5/query/cache/SimpleMapCacheTest.kt @@ -0,0 +1,35 @@ +package com.dbflow5.query.cache + +import com.dbflow5.BaseUnitTest +import com.dbflow5.models.SimpleModel +import org.junit.Assert.assertEquals +import org.junit.Assert.assertTrue +import org.junit.Test + +class SimpleMapCacheTest : BaseUnitTest() { + + @Test + fun validateCacheAddRemove() { + val cache = SimpleMapCache(10) + cache.addModel("1", SimpleModel("1")) + + assertEquals("1", cache["1"]!!.name) + assertEquals(1, cache.cache.size) + + cache.removeModel("1") + + assertTrue(cache.cache.isEmpty()) + } + + @Test + fun validateCacheClear() { + val cache = SimpleMapCache(10) + cache.addModel("1", SimpleModel("1")) + cache.addModel("2", SimpleModel("2")) + assertEquals(2, cache.cache.size) + + cache.clear() + + assertTrue(cache.cache.isEmpty()) + } +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/query/list/FlowCursorIteratorTest.kt b/tests/src/test/java/com/dbflow5/query/list/FlowCursorIteratorTest.kt new file mode 100644 index 000000000..20c3cdcd3 --- /dev/null +++ b/tests/src/test/java/com/dbflow5/query/list/FlowCursorIteratorTest.kt @@ -0,0 +1,76 @@ +package com.dbflow5.query.list + +import com.dbflow5.BaseUnitTest +import com.dbflow5.config.databaseForTable +import com.dbflow5.models.SimpleModel +import com.dbflow5.query.select +import com.dbflow5.structure.save +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue +import org.junit.Test + +/** + * Description: + */ +class FlowCursorIteratorTest : BaseUnitTest() { + + + @Test + fun testCanIterateFullList() { + var count = 0 + databaseForTable().beginTransactionAsync { db -> + (0..9).forEach { + SimpleModel("$it").save(db) + } + (select from SimpleModel::class).cursorList(db).iterator() + }.success { _, iterator -> + assertFalse(iterator.isClosed) + iterator.use { cursorIterator -> + cursorIterator.forEach { + assertEquals("$count", it.name) + count++ + } + } + assertTrue(iterator.isClosed) + }.execute() + } + + @Test + fun testCanIteratePartialList() { + databaseForTable().beginTransactionAsync { db -> + (0..9).forEach { + SimpleModel("$it").save(db) + } + + (select from SimpleModel::class).cursorList(db) + .iterator(2, 7) + }.success { _, iterator -> + var count = 0 + iterator.forEach { + assertEquals("${count + 2}", it.name) + count++ + } + assertEquals(7, count) + }.execute() + } + + @Test + fun testCanSupplyBadMaximumValue() { + databaseForTable().beginTransactionAsync { db -> + (0..9).forEach { + SimpleModel("$it").save() + } + + (select from SimpleModel::class).cursorList(db) + .iterator(2, Long.MAX_VALUE) + }.success { _, iterator -> + var count = 0 + iterator.forEach { + assertEquals("${count + 2}", it.name) + count++ + } + assertEquals(8, count) + }.execute() + } +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/query/list/FlowCursorListTest.kt b/tests/src/test/java/com/dbflow5/query/list/FlowCursorListTest.kt new file mode 100644 index 000000000..ddb9918e6 --- /dev/null +++ b/tests/src/test/java/com/dbflow5/query/list/FlowCursorListTest.kt @@ -0,0 +1,81 @@ +package com.dbflow5.query.list + +import com.nhaarman.mockito_kotlin.mock +import com.nhaarman.mockito_kotlin.times +import com.nhaarman.mockito_kotlin.verify +import com.dbflow5.BaseUnitTest +import com.dbflow5.config.databaseForTable +import com.dbflow5.models.SimpleModel +import com.dbflow5.query.cursor +import com.dbflow5.query.select +import com.dbflow5.structure.save +import org.junit.Assert.assertEquals +import org.junit.Test + +/** + * Description: + */ +class FlowCursorListTest : BaseUnitTest() { + + @Test + fun validateCursorPassed() { + databaseForTable { + val cursor = (select from SimpleModel::class).cursor + val list = FlowCursorList.Builder(select from SimpleModel::class, this) + .cursor(cursor) + .build() + + assertEquals(cursor, list.cursor) + } + } + + @Test + fun validateModelQueriable() { + databaseForTable { + val modelQueriable = (select from SimpleModel::class) + val list = FlowCursorList.Builder(modelQueriable, this) + .build() + + assertEquals(modelQueriable, list.modelQueriable) + } + } + + @Test + fun validateGetAll() { + databaseForTable { + (0..9).forEach { + SimpleModel("$it").save() + } + + val list = (select from SimpleModel::class).cursorList(this) + val all = list.all + assertEquals(list.count, all.size.toLong()) + } + } + + @Test + fun validateCursorChange() { + databaseForTable { + (0..9).forEach { + SimpleModel("$it").save() + } + + val list = (select from SimpleModel::class).cursorList(this) + + val listener = mock>() + list.addOnCursorRefreshListener(listener) + assertEquals(10, list.count) + SimpleModel("10").save() + list.refresh() + assertEquals(11, list.count) + + verify(listener).onCursorRefreshed(list) + + list.removeOnCursorRefreshListener(listener) + + list.refresh() + verify(listener, times(1)).onCursorRefreshed(list) + } + } +} + diff --git a/tests/src/test/java/com/dbflow5/runtime/DirectNotifierTest.kt b/tests/src/test/java/com/dbflow5/runtime/DirectNotifierTest.kt new file mode 100644 index 000000000..6dd2e7591 --- /dev/null +++ b/tests/src/test/java/com/dbflow5/runtime/DirectNotifierTest.kt @@ -0,0 +1,94 @@ +package com.dbflow5.runtime + +import android.content.Context +import com.nhaarman.mockito_kotlin.mock +import com.nhaarman.mockito_kotlin.verify +import com.dbflow5.ImmediateTransactionManager2 +import com.dbflow5.TestDatabase +import com.dbflow5.config.DatabaseConfig +import com.dbflow5.config.FlowConfig +import com.dbflow5.config.FlowManager +import com.dbflow5.config.databaseForTable +import com.dbflow5.database.AndroidSQLiteOpenHelper +import com.dbflow5.models.SimpleModel +import com.dbflow5.models.SimpleModel_Table +import com.dbflow5.query.columnValues +import com.dbflow5.query.delete +import com.dbflow5.query.insert +import com.dbflow5.query.set +import com.dbflow5.query.update +import com.dbflow5.structure.ChangeAction +import com.dbflow5.structure.delete +import com.dbflow5.structure.insert +import com.dbflow5.structure.save +import com.dbflow5.structure.update +import org.junit.After +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith +import org.mockito.Mockito +import org.robolectric.RobolectricTestRunner +import org.robolectric.RuntimeEnvironment +import org.robolectric.annotation.Config + +@RunWith(RobolectricTestRunner::class) +@Config(manifest = Config.NONE) +class DirectNotifierTest { + + val context: Context + get() = RuntimeEnvironment.application + + @Before + fun setupTest() { + FlowManager.init(FlowConfig.Builder(context) + .database(DatabaseConfig.Builder(TestDatabase::class.java, + AndroidSQLiteOpenHelper.createHelperCreator(context)) + .transactionManagerCreator(::ImmediateTransactionManager2) + .build()).build()) + } + + @Test + fun validateCanNotifyDirect() { + val simpleModel = SimpleModel("Name") + + val modelChange = mock>() + DirectModelNotifier.get().registerForModelStateChanges(SimpleModel::class.java, modelChange) + + simpleModel.insert() + verify(modelChange).onModelChanged(simpleModel, ChangeAction.INSERT) + + simpleModel.update() + verify(modelChange).onModelChanged(simpleModel, ChangeAction.UPDATE) + + simpleModel.save() + verify(modelChange).onModelChanged(simpleModel, ChangeAction.CHANGE) + + simpleModel.delete() + verify(modelChange).onModelChanged(simpleModel, ChangeAction.DELETE) + } + + @Test + fun validateCanNotifyWrapperClasses() { + databaseForTable { + val modelChange = Mockito.mock(OnTableChangedListener::class.java) + DirectModelNotifier.get().registerForTableChanges(SimpleModel::class.java, modelChange) + + insert().columnValues(SimpleModel_Table.name to "name").executeInsert(this) + + verify(modelChange).onTableChanged(SimpleModel::class.java, ChangeAction.INSERT) + + (update() set SimpleModel_Table.name.eq("name2")).executeUpdateDelete(this) + + verify(modelChange).onTableChanged(SimpleModel::class.java, ChangeAction.UPDATE) + + delete().executeUpdateDelete(this) + + verify(modelChange).onTableChanged(SimpleModel::class.java, ChangeAction.DELETE) + } + } + + @After + fun teardown() { + FlowManager.destroy() + } +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/rx2/TransactionObservablesTest.kt b/tests/src/test/java/com/dbflow5/rx2/TransactionObservablesTest.kt new file mode 100644 index 000000000..b8895a56e --- /dev/null +++ b/tests/src/test/java/com/dbflow5/rx2/TransactionObservablesTest.kt @@ -0,0 +1,60 @@ +package com.dbflow5.rx2 + +import com.dbflow5.BaseUnitTest +import com.dbflow5.TestDatabase +import com.dbflow5.config.database +import com.dbflow5.database.DatabaseWrapper +import com.dbflow5.models.SimpleModel +import com.dbflow5.query.list +import com.dbflow5.query.result +import com.dbflow5.query.select +import com.dbflow5.reactivestreams.transaction.asMaybe +import com.dbflow5.reactivestreams.transaction.asSingle +import com.dbflow5.structure.save +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNull +import org.junit.Assert.assertTrue +import org.junit.Test + +/** + * Description: + */ +class TransactionObservablesTest : BaseUnitTest() { + + @Test + fun testObservableRun() { + var successCalled = false + var list: List? = null + database() + .beginTransactionAsync { db: DatabaseWrapper -> + (0 until 10).forEach { + SimpleModel("$it").save(db) + } + } + .asSingle() + .doAfterSuccess { + database() + .beginTransactionAsync { (select from SimpleModel::class).list } + .asSingle() + .subscribe { loadedList: MutableList -> + list = loadedList + successCalled = true + } + }.subscribe() + + assertTrue(successCalled) + assertEquals(10, list!!.size) + } + + @Test + fun testMaybe() { + var simpleModel: SimpleModel? = SimpleModel() + database() + .beginTransactionAsync { (select from SimpleModel::class).result } + .asMaybe() + .subscribe { + simpleModel = it + } + assertNull(simpleModel) + } +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/rx2/query/CursorResultSubscriberTest.kt b/tests/src/test/java/com/dbflow5/rx2/query/CursorResultSubscriberTest.kt new file mode 100644 index 000000000..03f790033 --- /dev/null +++ b/tests/src/test/java/com/dbflow5/rx2/query/CursorResultSubscriberTest.kt @@ -0,0 +1,88 @@ +package com.dbflow5.rx2.query + +import com.dbflow5.BaseUnitTest +import com.dbflow5.config.databaseForTable +import com.dbflow5.models.SimpleModel +import com.dbflow5.models.SimpleModel_Table +import com.dbflow5.query.insert +import com.dbflow5.query.requireResult +import com.dbflow5.query.select +import com.dbflow5.reactivestreams.query.queryStreamResults +import com.dbflow5.reactivestreams.transaction.asFlowable +import com.dbflow5.structure.delete +import com.dbflow5.structure.insert +import com.dbflow5.structure.save +import org.junit.Assert.assertEquals +import org.junit.Test + +class CursorResultSubscriberTest : BaseUnitTest() { + + @Test + fun testCanQueryStreamResults() { + databaseForTable { + (0..9).forEach { SimpleModel("$it").save() } + + var count = 0 + (select from SimpleModel::class) + .queryStreamResults(this) + .subscribe { + count++ + assert(it != null) + } + + assertEquals(10, count) + } + } + + @Test + fun testCanObserveOnTableChangesWithModelOps() { + var count = 0 + (select from SimpleModel::class) + .asFlowable { databaseWrapper, modelQueriable -> modelQueriable.queryList(databaseWrapper) } + .subscribe { + count++ + } + val model = SimpleModel("test") + model.save() + + model.delete() + + model.insert() + + assertEquals(4, count) // once for subscription, 3 for operations + } + + @Test + fun testCanObserveOnTableChangesWithTableOps() { + var count = 0 + var curList: MutableList = arrayListOf() + (select from SimpleModel::class) + .asFlowable { databaseWrapper, modelQueriable -> modelQueriable.queryList(databaseWrapper) } + .subscribe { + curList = it + count++ + } + insert(SimpleModel::class, SimpleModel_Table.name) + .values("test") + .executeInsert(databaseForTable()) + insert(SimpleModel::class, SimpleModel_Table.name) + .values("test1") + .executeInsert(databaseForTable()) + insert(SimpleModel::class, SimpleModel_Table.name) + .values("test2") + .executeInsert(databaseForTable()) + + + assertEquals(3, curList.size) + + val model = (select + from SimpleModel::class + where SimpleModel_Table.name.eq("test")).requireResult + model.delete() + + assertEquals(2, curList.size) + + assertEquals(5, count) // once for subscription, 4 for operations + } + +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/rx2/query/RXFlowableTest.kt b/tests/src/test/java/com/dbflow5/rx2/query/RXFlowableTest.kt new file mode 100644 index 000000000..22ff8a124 --- /dev/null +++ b/tests/src/test/java/com/dbflow5/rx2/query/RXFlowableTest.kt @@ -0,0 +1,68 @@ +package com.dbflow5.rx2.query + +import com.dbflow5.BaseUnitTest +import com.dbflow5.models.Author +import com.dbflow5.models.Author_Table +import com.dbflow5.models.Blog +import com.dbflow5.models.Blog_Table +import com.dbflow5.models.SimpleModel +import com.dbflow5.models.SimpleModel_Table +import com.dbflow5.query.cast +import com.dbflow5.query.select +import com.dbflow5.reactivestreams.transaction.asFlowable +import com.dbflow5.structure.save +import org.junit.Assert.assertEquals +import org.junit.Test + +/** + * Description: + */ +class RXFlowableTest : BaseUnitTest() { + + @Test + fun testCanObserveChanges() { + + (0..100).forEach { SimpleModel("$it").save() } + + var list = mutableListOf() + var triggerCount = 0 + val subscription = (select from SimpleModel::class + where cast(SimpleModel_Table.name).asInteger().greaterThan(50)) + .asFlowable { db, modelQueriable -> modelQueriable.queryList(db) } + .subscribe { + list = it + triggerCount += 1 + } + + assertEquals(50, list.size) + subscription.dispose() + + SimpleModel("should not trigger").save() + assertEquals(1, triggerCount) + + } + + @Test + fun testObservesJoinTables() { + val joinOn = Blog_Table.name.withTable() + .eq(Author_Table.first_name.withTable() + " " + Author_Table.last_name.withTable()) + assertEquals("`Blog`.`name`=`Author`.`first_name`+' '+`Author`.`last_name`", joinOn.query) + + var list = mutableListOf() + var calls = 0 + (select from Blog::class + leftOuterJoin Author::class + on joinOn) + .asFlowable { db, modelQueriable -> modelQueriable.queryList(db) } + .subscribe { + calls++ + list = it + } + + val authors = (0 until 10).map { Author(it, firstName = "${it}name", lastName = "${it}last") } + (0 until 10).forEach { Blog(it, name = "${it}name ${it}last", author = authors[it]).save() } + + assertEquals(21, calls) // 1 for initial, 10 for each model object + assertEquals(10, list.size) + } +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/rx2/query/RXQueryTests.kt b/tests/src/test/java/com/dbflow5/rx2/query/RXQueryTests.kt new file mode 100644 index 000000000..d9d1d422c --- /dev/null +++ b/tests/src/test/java/com/dbflow5/rx2/query/RXQueryTests.kt @@ -0,0 +1,81 @@ +package com.dbflow5.rx2.query + +import com.dbflow5.BaseUnitTest +import com.dbflow5.config.databaseForTable +import com.dbflow5.database.DatabaseStatement +import com.dbflow5.database.FlowCursor +import com.dbflow5.models.SimpleModel +import com.dbflow5.models.SimpleModel_Table.name +import com.dbflow5.query.insert +import com.dbflow5.query.property.Property +import com.dbflow5.query.select +import com.dbflow5.query.selectCountOf +import com.dbflow5.reactivestreams.transaction.asMaybe +import com.dbflow5.reactivestreams.transaction.asSingle +import com.dbflow5.structure.save +import org.junit.Assert.assertEquals +import org.junit.Test + +class RXQueryTests : BaseUnitTest() { + + @Test + fun testCanQuery() { + SimpleModel("Name").save() + + var cursor: FlowCursor? = null + databaseForTable() + .beginTransactionAsync { (select from SimpleModel::class).cursor(it) } + .asMaybe() + .subscribe { + cursor = it + } + + assertEquals(1, cursor!!.count) + cursor!!.close() + } + + @Test + fun testCanCompileStatement() { + var databaseStatement: DatabaseStatement? = null + databaseForTable() + .beginTransactionAsync { + insert().columnValues(name.`is`("name")).compileStatement(it) + }.asSingle() + .subscribe { statement -> + databaseStatement = statement + } + databaseStatement!!.close() + } + + @Test + fun testCountMethod() { + SimpleModel("name").save() + SimpleModel("name2").save() + var count = 0L + databaseForTable() + .beginTransactionAsync { + (selectCountOf(Property.ALL_PROPERTY) from SimpleModel::class).longValue(it) + } + .asSingle() + .subscribe { value -> + count = value + } + + assertEquals(2, count) + } + + @Test + fun testInsertMethod() { + var count = 0L + databaseForTable() + .beginTransactionAsync { + (insert().columnValues(name.eq("name"))).executeInsert(it) + }.asSingle() + .subscribe { c -> + count = c + } + + assertEquals(1, count) + } + +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/rx2/query/RxModels.kt b/tests/src/test/java/com/dbflow5/rx2/query/RxModels.kt new file mode 100644 index 000000000..22b63a3a0 --- /dev/null +++ b/tests/src/test/java/com/dbflow5/rx2/query/RxModels.kt @@ -0,0 +1,10 @@ +package com.dbflow5.rx2.query + +import com.dbflow5.TestDatabase +import com.dbflow5.annotation.PrimaryKey +import com.dbflow5.annotation.Table +import com.dbflow5.reactivestreams.structure.BaseRXModel + + +@Table(database = TestDatabase::class, allFields = true) +class SimpleRXModel(@PrimaryKey var id: String = "") : BaseRXModel() \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/sql/language/CaseTest.kt b/tests/src/test/java/com/dbflow5/sql/language/CaseTest.kt new file mode 100644 index 000000000..2511aac17 --- /dev/null +++ b/tests/src/test/java/com/dbflow5/sql/language/CaseTest.kt @@ -0,0 +1,33 @@ +package com.dbflow5.sql.language + +import com.dbflow5.BaseUnitTest +import com.dbflow5.models.SimpleModel_Table +import com.dbflow5.query.case +import com.dbflow5.query.caseWhen +import com.dbflow5.query.property.propertyString +import org.junit.Assert.* +import org.junit.Test + +class CaseTest : BaseUnitTest() { + + @Test + fun simpleCaseTest() { + val case = case(propertyString("country")) + .whenever("USA") + .then("Domestic") + .`else`("Foreign") + assertEquals("CASE country WHEN 'USA' THEN 'Domestic' ELSE 'Foreign' END `Country`", + case.end("Country").query.trim()) + assertTrue(case.isEfficientCase) + } + + @Test + fun searchedCaseTest() { + val case = caseWhen(SimpleModel_Table.name.eq("USA")).then("Domestic") + .whenever(SimpleModel_Table.name.eq("CA")).then("Canada") + .`else`("Foreign") + assertEquals("CASE WHEN `name`='USA' THEN 'Domestic' WHEN `name`='CA' THEN 'Canada' ELSE 'Foreign'", + case.query.trim()) + assertFalse(case.isEfficientCase) + } +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/sql/language/DeleteTest.kt b/tests/src/test/java/com/dbflow5/sql/language/DeleteTest.kt new file mode 100644 index 000000000..95c906e0d --- /dev/null +++ b/tests/src/test/java/com/dbflow5/sql/language/DeleteTest.kt @@ -0,0 +1,46 @@ +package com.dbflow5.sql.language + +import com.dbflow5.BaseUnitTest +import com.dbflow5.config.databaseForTable +import com.dbflow5.models.SimpleModel +import com.dbflow5.models.SimpleModel_Table +import com.dbflow5.query.delete +import com.dbflow5.query.list +import com.dbflow5.query.select +import com.dbflow5.structure.save +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Test + +class DeleteTest : BaseUnitTest() { + + @Test + fun validateQuery() { + databaseForTable { + assertEquals("DELETE ", delete().query) + } + } + + @Test + fun validateDeletion() { + databaseForTable { + SimpleModel("name").save() + delete().execute(this) + assertFalse((select from SimpleModel::class).hasData(this)) + } + } + + @Test + fun validateDeletionWithQuery() { + databaseForTable { + SimpleModel("name").save() + SimpleModel("another name").save() + + val where = delete().where(SimpleModel_Table.name.`is`("name")) + assertEquals("DELETE FROM `SimpleModel` WHERE `name`='name'", where.query.trim()) + where.execute(this) + + assertEquals(1, (select from SimpleModel::class).list.size) + } + } +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/sql/language/ExistenceOperatorTest.kt b/tests/src/test/java/com/dbflow5/sql/language/ExistenceOperatorTest.kt new file mode 100644 index 000000000..5367f85b7 --- /dev/null +++ b/tests/src/test/java/com/dbflow5/sql/language/ExistenceOperatorTest.kt @@ -0,0 +1,25 @@ +package com.dbflow5.sql.language + +import com.dbflow5.BaseUnitTest +import com.dbflow5.config.databaseForTable +import com.dbflow5.models.SimpleModel +import com.dbflow5.models.SimpleModel_Table +import com.dbflow5.query.ExistenceOperator +import com.dbflow5.query.select +import org.junit.Assert.assertEquals +import org.junit.Test + +class ExistenceOperatorTest : BaseUnitTest() { + + + @Test + fun validateQuery() { + databaseForTable { + assertEquals("EXISTS (SELECT * FROM `SimpleModel` WHERE `name`='name')", + ExistenceOperator( + (select from SimpleModel::class + where SimpleModel_Table.name.eq("name"))) + .query.trim()) + } + } +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/sql/language/FromTest.kt b/tests/src/test/java/com/dbflow5/sql/language/FromTest.kt new file mode 100644 index 000000000..8c3e8308c --- /dev/null +++ b/tests/src/test/java/com/dbflow5/sql/language/FromTest.kt @@ -0,0 +1,46 @@ +package com.dbflow5.sql.language + +import com.dbflow5.BaseUnitTest +import com.dbflow5.models.SimpleModel +import com.dbflow5.models.SimpleModel_Table.name +import com.dbflow5.models.TwoColumnModel +import com.dbflow5.models.TwoColumnModel_Table +import com.dbflow5.models.TwoColumnModel_Table.id +import com.dbflow5.query.select +import org.junit.Assert.assertEquals +import org.junit.Assert.assertTrue +import org.junit.Test + +class FromTest : BaseUnitTest() { + + @Test + fun validateSimpleFrom() { + assertEquals("SELECT * FROM `SimpleModel`", (select from SimpleModel::class).query.trim()) + } + + @Test + fun validateProjectionFrom() { + assertEquals("SELECT `name` FROM `SimpleModel`", (select(name) from SimpleModel::class).query.trim()) + } + + @Test + fun validateMultipleProjection() { + assertEquals("SELECT `name`,`name`,`id` FROM `SimpleModel`", + (select(name, TwoColumnModel_Table.name, id) from SimpleModel::class).query.trim()) + } + + @Test + fun validateAlias() { + assertEquals("SELECT * FROM `SimpleModel` AS `Simple`", (select from SimpleModel::class `as` "Simple").query.trim()) + } + + @Test + fun validateJoins() { + val from = (select from SimpleModel::class + innerJoin TwoColumnModel::class + on name.eq(TwoColumnModel_Table.name.withTable())) + assertEquals("SELECT * FROM `SimpleModel` INNER JOIN `TwoColumnModel` ON `name`=`TwoColumnModel`.`name`", + from.query.trim()) + assertTrue(from.associatedTables.isNotEmpty()) + } +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/sql/language/IndexTest.kt b/tests/src/test/java/com/dbflow5/sql/language/IndexTest.kt new file mode 100644 index 000000000..92e5c9184 --- /dev/null +++ b/tests/src/test/java/com/dbflow5/sql/language/IndexTest.kt @@ -0,0 +1,38 @@ +package com.dbflow5.sql.language + +import com.dbflow5.BaseUnitTest +import com.dbflow5.config.databaseForTable +import com.dbflow5.models.SimpleModel +import com.dbflow5.models.SimpleModel_Table +import com.dbflow5.query.indexOn +import com.dbflow5.query.nameAlias +import org.junit.Assert.assertEquals +import org.junit.Test + +class IndexTest : BaseUnitTest() { + + @Test + fun validateBasicIndex() { + databaseForTable { + assertEquals("CREATE INDEX IF NOT EXISTS `index` ON `SimpleModel`(`name`)", + indexOn("index", SimpleModel_Table.name).query) + } + } + + @Test + fun validateUniqueIndex() { + databaseForTable { + assertEquals("CREATE UNIQUE INDEX IF NOT EXISTS `index` ON `SimpleModel`(`name`, `test`)", + indexOn("index").unique(true).and(SimpleModel_Table.name) + .and("test".nameAlias).query) + } + } + + @Test + fun validateBasicIndexNameAlias() { + databaseForTable { + assertEquals("CREATE INDEX IF NOT EXISTS `index` ON `SimpleModel`(`name`, `test`)", + indexOn("index", "name".nameAlias, "test".nameAlias).query) + } + } +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/sql/language/IndexedByTest.kt b/tests/src/test/java/com/dbflow5/sql/language/IndexedByTest.kt new file mode 100644 index 000000000..466b6feb5 --- /dev/null +++ b/tests/src/test/java/com/dbflow5/sql/language/IndexedByTest.kt @@ -0,0 +1,22 @@ +package com.dbflow5.sql.language + +import com.dbflow5.BaseUnitTest +import com.dbflow5.config.databaseForTable +import com.dbflow5.models.SimpleModel +import com.dbflow5.models.SimpleModel_Table +import com.dbflow5.query.property.IndexProperty +import com.dbflow5.query.select +import org.junit.Assert.assertEquals +import org.junit.Test + +class IndexedByTest : BaseUnitTest() { + + @Test + fun validateQuery() { + databaseForTable { + val indexed = (select from SimpleModel::class) + .indexedBy(IndexProperty("Index", false, SimpleModel::class.java, SimpleModel_Table.name)) + assertEquals("SELECT * FROM `SimpleModel` INDEXED BY `Index`", indexed.query.trim()) + } + } +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/sql/language/InsertTest.kt b/tests/src/test/java/com/dbflow5/sql/language/InsertTest.kt new file mode 100644 index 000000000..b620ac9d2 --- /dev/null +++ b/tests/src/test/java/com/dbflow5/sql/language/InsertTest.kt @@ -0,0 +1,95 @@ +package com.dbflow5.sql.language + +import android.content.ContentValues +import com.dbflow5.BaseUnitTest +import com.dbflow5.config.databaseForTable +import com.dbflow5.database.set +import com.dbflow5.models.SimpleModel +import com.dbflow5.models.TwoColumnModel +import com.dbflow5.models.TwoColumnModel_Table.id +import com.dbflow5.models.TwoColumnModel_Table.name +import com.dbflow5.query.NameAlias +import com.dbflow5.query.Operator +import com.dbflow5.query.OperatorGroup +import com.dbflow5.query.insert +import com.dbflow5.query.select +import org.junit.Assert.assertEquals +import org.junit.Test + +class InsertTest : BaseUnitTest() { + + @Test + fun validateInsert() { + databaseForTable { + assertEquals("INSERT INTO `SimpleModel` VALUES('something')", + insert().values("something").query.trim()) + } + } + + @Test + fun validateInsertOr() { + databaseForTable { + assertEquals("INSERT OR REPLACE INTO `SimpleModel` VALUES('something')", + insert().orReplace().values("something").query.trim()) + assertEquals("INSERT OR FAIL INTO `SimpleModel` VALUES('something')", + insert().orFail().values("something").query.trim()) + assertEquals("INSERT OR IGNORE INTO `SimpleModel` VALUES('something')", + insert().orIgnore().values("something").query.trim()) + assertEquals("INSERT OR REPLACE INTO `SimpleModel` VALUES('something')", + insert().orReplace().values("something").query.trim()) + assertEquals("INSERT OR ROLLBACK INTO `SimpleModel` VALUES('something')", + insert().orRollback().values("something").query.trim()) + assertEquals("INSERT OR ABORT INTO `SimpleModel` VALUES('something')", + insert().orAbort().values("something").query.trim()) + } + } + + @Test + fun validateInsertProjection() { + databaseForTable { + assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 'id')", + insert().columns(name, id).values("name", "id").query.trim()) + } + } + + @Test + fun validateSelect() { + databaseForTable { + assertEquals("INSERT INTO `TwoColumnModel` SELECT * FROM `SimpleModel`", + insert().select(select from SimpleModel::class).query.trim()) + } + } + + @Test + fun validateColumns() { + databaseForTable { + assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 'id')", + insert().asColumns().values("name", "id").query.trim()) + assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 'id')", + insert().columns("name", "id").values("name", "id").query.trim()) + assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 'id')", + insert().columns(listOf(name, id)).values("name", "id").query.trim()) + } + } + + @Test + fun validateColumnValues() { + databaseForTable { + assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 0)", + insert().columnValues(name.eq("name"), id.eq(0)).query.trim()) + assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 0)", + insert().columnValues(Operator.op(NameAlias.builder("name").build()).eq("name"), + id.eq(0)).query.trim()) + assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 0)", + insert().columnValues(OperatorGroup.clause().andAll(name.eq("name"), id.eq(0))).query.trim()) + + val contentValues = ContentValues() + contentValues["name"] = "name" + contentValues["id"] = 0.toInt() + + assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 0)", + insert().columnValues(contentValues).query.trim()) + + } + } +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/sql/language/JoinTest.kt b/tests/src/test/java/com/dbflow5/sql/language/JoinTest.kt new file mode 100644 index 000000000..350a768ca --- /dev/null +++ b/tests/src/test/java/com/dbflow5/sql/language/JoinTest.kt @@ -0,0 +1,86 @@ +package com.dbflow5.sql.language + +import com.dbflow5.BaseUnitTest +import com.dbflow5.config.databaseForTable +import com.dbflow5.models.SimpleModel +import com.dbflow5.models.SimpleModel_Table +import com.dbflow5.models.TwoColumnModel +import com.dbflow5.models.TwoColumnModel_Table +import com.dbflow5.query.select +import org.junit.Assert.assertEquals +import org.junit.Test + + +class JoinTest : BaseUnitTest() { + + @Test + fun validateAliasJoin() { + databaseForTable { + assertEquals("SELECT * FROM `SimpleModel` INNER JOIN `TwoColumnModel` AS `Name` ON `TwoColumnModel`.`name`=`name`", + ((select from SimpleModel::class innerJoin + TwoColumnModel::class).`as`("Name") on TwoColumnModel_Table.name.withTable().eq(SimpleModel_Table.name)).query.trim()) + } + } + + @Test + fun testInnerJoin() { + databaseForTable { + val join = select from SimpleModel::class innerJoin + TwoColumnModel::class on TwoColumnModel_Table.name.withTable().eq(SimpleModel_Table.name) + assertEquals("SELECT * FROM `SimpleModel` INNER JOIN `TwoColumnModel` ON `TwoColumnModel`.`name`=`name`", + join.query.trim()) + } + } + + @Test + fun testLeftOuterJoin() { + databaseForTable { + val join = select from SimpleModel::class leftOuterJoin + TwoColumnModel::class on TwoColumnModel_Table.name.withTable().eq(SimpleModel_Table.name) + assertEquals("SELECT * FROM `SimpleModel` LEFT OUTER JOIN `TwoColumnModel` ON `TwoColumnModel`.`name`=`name`", + join.query.trim()) + } + } + + @Test + fun testCrossJoin() { + databaseForTable { + val join = select from SimpleModel::class crossJoin + TwoColumnModel::class on TwoColumnModel_Table.name.withTable().eq(SimpleModel_Table.name) + assertEquals("SELECT * FROM `SimpleModel` CROSS JOIN `TwoColumnModel` ON `TwoColumnModel`.`name`=`name`", + join.query.trim()) + } + } + + @Test + fun testMultiJoin() { + databaseForTable { + val join = select from SimpleModel::class innerJoin + TwoColumnModel::class on TwoColumnModel_Table.name.withTable().eq(SimpleModel_Table.name) crossJoin + TwoColumnModel::class on TwoColumnModel_Table.id.withTable().eq(SimpleModel_Table.name) + assertEquals("SELECT * FROM `SimpleModel` INNER JOIN `TwoColumnModel` ON `TwoColumnModel`.`name`=`name`" + + " CROSS JOIN `TwoColumnModel` ON `TwoColumnModel`.`id`=`name`", + join.query.trim()) + } + } + + @Test + fun testInnerJoinOnUsing() { + databaseForTable { + val join = select from SimpleModel::class innerJoin + TwoColumnModel::class using SimpleModel_Table.name.withTable() + assertEquals("SELECT * FROM `SimpleModel` INNER JOIN `TwoColumnModel` USING (`SimpleModel`.`name`)", + join.query.trim()) + } + } + + @Test + fun testNaturalJoin() { + databaseForTable { + val join = (select from SimpleModel::class naturalJoin + TwoColumnModel::class).end() + assertEquals("SELECT * FROM `SimpleModel` NATURAL JOIN `TwoColumnModel`", + join.query.trim()) + } + } +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/sql/language/MethodTest.kt b/tests/src/test/java/com/dbflow5/sql/language/MethodTest.kt new file mode 100644 index 000000000..a8855bf1d --- /dev/null +++ b/tests/src/test/java/com/dbflow5/sql/language/MethodTest.kt @@ -0,0 +1,77 @@ +package com.dbflow5.sql.language + +import com.dbflow5.BaseUnitTest +import com.dbflow5.models.TwoColumnModel_Table.id +import com.dbflow5.models.TwoColumnModel_Table.name +import com.dbflow5.query.avg +import com.dbflow5.query.cast +import com.dbflow5.query.count +import com.dbflow5.query.date +import com.dbflow5.query.datetime +import com.dbflow5.query.groupConcat +import com.dbflow5.query.ifNull +import com.dbflow5.query.max +import com.dbflow5.query.min +import com.dbflow5.query.nullIf +import com.dbflow5.query.replace +import com.dbflow5.query.strftime +import com.dbflow5.query.sum +import com.dbflow5.query.total +import com.dbflow5.sql.SQLiteType +import org.junit.Assert.assertEquals +import org.junit.Test + +class MethodTest : BaseUnitTest() { + + @Test + fun testMainMethods() { + assertEquals("AVG(`name`, `id`)", avg(name, id).query) + assertEquals("COUNT(`name`, `id`)", count(name, id).query) + assertEquals("GROUP_CONCAT(`name`, `id`)", groupConcat(name, id).query) + assertEquals("MAX(`name`, `id`)", max(name, id).query) + assertEquals("MIN(`name`, `id`)", min(name, id).query) + assertEquals("SUM(`name`, `id`)", sum(name, id).query) + assertEquals("TOTAL(`name`, `id`)", total(name, id).query) + assertEquals("CAST(`name` AS INTEGER)", cast(name).`as`(SQLiteType.INTEGER).query) + assertEquals("REPLACE(`name`, 'Andrew', 'Grosner')", replace(name, "Andrew", "Grosner").query) + } + + @Test + fun test_strftime() { + assertEquals("strftime('%s', 'now')", strftime("%s", "now").query) + } + + @Test + fun test_dateMethod() { + assertEquals("date('now', 'start of month', '+1 month')", + date("now", "start of month", "+1 month").query) + } + + @Test + fun test_datetimeMethod() { + assertEquals("datetime(1092941466, 'unix epoch')", + datetime(1092941466, "unix epoch").query) + } + + @Test + fun testIfNull() { + assertEquals("IFNULL(`name`, `id`)", ifNull(name, id).query) + } + + @Test + fun testNulllIf() { + assertEquals("NULLIF(`name`, `id`)", nullIf(name, id).query) + } + + @Test + fun testOpMethods() { + assertEquals("AVG(`name` + `id`)", avg(name + id).query) + assertEquals("AVG(`name` + `id`)", (avg(name) + id).query) + assertEquals("AVG(`name` - `id`)", avg(name - id).query) + assertEquals("AVG(`name` - `id`)", (avg(name) - id).query) + assertEquals("AVG(`name` / `id`)", avg(name / id).query) + assertEquals("AVG(`name` * `id`)", (avg(name) * id).query) + assertEquals("AVG(`name` % `id`)", avg(name % id).query) + assertEquals("AVG(`name` % `id`)", (avg(name) % id).query) + } +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/sql/language/NameAliasTest.kt b/tests/src/test/java/com/dbflow5/sql/language/NameAliasTest.kt new file mode 100644 index 000000000..4b679eb38 --- /dev/null +++ b/tests/src/test/java/com/dbflow5/sql/language/NameAliasTest.kt @@ -0,0 +1,42 @@ +package com.dbflow5.sql.language + +import com.dbflow5.BaseUnitTest +import com.dbflow5.query.NameAlias +import com.dbflow5.query.`as` +import com.dbflow5.query.nameAlias +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Test + +class NameAliasTest : BaseUnitTest() { + + @Test + fun testSimpleCase() { + assertEquals("`name`", "name".nameAlias.query) + } + + @Test + fun testAlias() { + assertEquals("`name` AS `alias`", "name".`as`("alias").fullQuery) + } + + @Test + fun validateBuilder() { + val nameAlias = NameAlias.builder("name") + .keyword("DISTINCT") + .`as`("Alias") + .withTable("MyTable") + .shouldAddIdentifierToAliasName(false) + .shouldAddIdentifierToName(false) + .shouldStripAliasName(false) + .shouldStripIdentifier(false).build() + assertEquals("DISTINCT", nameAlias.keyword) + assertEquals("Alias", nameAlias.aliasName()) + assertEquals("Alias", nameAlias.aliasNameRaw()) + assertEquals("`MyTable`", nameAlias.tableName) + assertFalse(nameAlias.shouldStripAliasName) + assertFalse(nameAlias.shouldStripIdentifier) + assertEquals("Alias", nameAlias.nameAsKey) + assertEquals("DISTINCT `MyTable`.name AS Alias", nameAlias.fullQuery) + } +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/sql/language/OperatorGroupTest.kt b/tests/src/test/java/com/dbflow5/sql/language/OperatorGroupTest.kt new file mode 100644 index 000000000..221f9d84b --- /dev/null +++ b/tests/src/test/java/com/dbflow5/sql/language/OperatorGroupTest.kt @@ -0,0 +1,48 @@ +package com.dbflow5.sql.language + +import com.dbflow5.BaseUnitTest +import com.dbflow5.assertEquals +import com.dbflow5.models.TwoColumnModel_Table.id +import com.dbflow5.models.TwoColumnModel_Table.name +import com.dbflow5.query.OperatorGroup +import com.dbflow5.query.and +import com.dbflow5.query.andAll +import com.dbflow5.query.or +import com.dbflow5.query.orAll +import org.junit.Test + +class OperatorGroupTest : BaseUnitTest() { + + + @Test + fun validateCommaSeparated() { + "(`name`='name', `id`=0)".assertEquals(OperatorGroup.clause().setAllCommaSeparated(true).andAll(name.eq("name"), id.eq(0))) + } + + @Test + fun validateParanthesis() { + "`name`='name'".assertEquals(OperatorGroup.nonGroupingClause(name.eq("name")).setUseParenthesis(false)) + } + + @Test + fun validateOr() { + "(`name`='name' OR `id`=0)".assertEquals(name.eq("name") or id.eq(0)) + } + + @Test + fun validateOrAll() { + "(`name`='name' OR `id`=0 OR `name`='test')".assertEquals(name.eq("name") orAll arrayListOf(id.eq(0), name.eq("test"))) + } + + @Test + + fun validateAnd() { + "(`name`='name' AND `id`=0)".assertEquals(name.eq("name") and id.eq(0)) + } + + @Test + fun validateAndAll() { + "(`name`='name' AND `id`=0 AND `name`='test')".assertEquals(name.eq("name") andAll arrayListOf(id.eq(0), name.eq("test"))) + } + +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/sql/language/OperatorTest.kt b/tests/src/test/java/com/dbflow5/sql/language/OperatorTest.kt new file mode 100644 index 000000000..79eea2aca --- /dev/null +++ b/tests/src/test/java/com/dbflow5/sql/language/OperatorTest.kt @@ -0,0 +1,65 @@ +package com.dbflow5.sql.language + +import com.dbflow5.BaseUnitTest +import com.dbflow5.annotation.Collate +import com.dbflow5.assertEquals +import com.dbflow5.config.databaseForTable +import com.dbflow5.models.SimpleModel +import com.dbflow5.models.TwoColumnModel_Table.id +import com.dbflow5.query.op +import com.dbflow5.query.select +import org.junit.Test + +class OperatorTest : BaseUnitTest() { + + @Test + fun testEquals() { + "`name`='name'".assertEquals("name".op().eq("name")) + "`name`='name'".assertEquals("name".op().`is`("name")) + } + + @Test + fun testNotEquals() { + "`name`!='name'".assertEquals("name".op().notEq("name")) + "`name`!='name'".assertEquals("name".op().isNot("name")) + } + + @Test + fun testLike() { + "`name` LIKE 'name'".assertEquals("name".op().like("name")) + "`name` NOT LIKE 'name'".assertEquals("name".op().notLike("name")) + "`name` GLOB 'name'".assertEquals("name".op().glob("name")) + } + + @Test + fun testMath() { + "`name`>'name'".assertEquals("name".op().greaterThan("name")) + "`name`>='name'".assertEquals("name".op().greaterThanOrEq("name")) + "`name`<'name'".assertEquals("name".op().lessThan("name")) + "`name`<='name'".assertEquals("name".op().lessThanOrEq("name")) + "`name`+'name'".assertEquals("name".op() + "name") + "`name`-'name'".assertEquals("name".op() - "name") + "`name`/'name'".assertEquals("name".op() / "name") + "`name`*'name'".assertEquals("name".op() * "name") + "`name`%'name'".assertEquals("name".op() % "name") + } + + @Test + fun testCollate() { + "`name` COLLATE NOCASE".assertEquals("name".op() collate Collate.NOCASE) + "`name` COLLATE NOCASE".assertEquals("name".op() collate "NOCASE") + } + + @Test + fun testBetween() { + "`id` BETWEEN 6 AND 7".assertEquals(id.between(6) and 7) + } + + @Test + fun testIn() { + databaseForTable { + "`id` IN (5,6,7,8,9)".assertEquals(id.`in`(5, 6, 7, 8) and 9) + "`id` NOT IN (SELECT * FROM `SimpleModel`)".assertEquals(id.notIn(select from SimpleModel::class)) + } + } +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/sql/language/OrderByTest.kt b/tests/src/test/java/com/dbflow5/sql/language/OrderByTest.kt new file mode 100644 index 000000000..d0c5b4f53 --- /dev/null +++ b/tests/src/test/java/com/dbflow5/sql/language/OrderByTest.kt @@ -0,0 +1,34 @@ +package com.dbflow5.sql.language + +import com.dbflow5.BaseUnitTest +import com.dbflow5.annotation.Collate +import com.dbflow5.assertEquals +import com.dbflow5.models.SimpleModel_Table.name +import com.dbflow5.query.OrderBy +import com.dbflow5.query.collate +import com.dbflow5.query.nameAlias +import org.junit.Test + +class OrderByTest : BaseUnitTest() { + + + @Test + fun validateBasicOrderBy() { + "`name` ASC".assertEquals(OrderBy.fromProperty(name).ascending()) + } + + @Test + fun validateDescendingOrderBy() { + "`name` DESC".assertEquals(OrderBy.fromNameAlias("name".nameAlias).descending()) + } + + @Test + fun validateCollate() { + "`name` COLLATE RTRIM ASC".assertEquals(OrderBy.fromProperty(name).ascending() collate Collate.RTRIM) + } + + @Test + fun validateCustomOrdrBy() { + "`name` ASC This is custom".assertEquals(OrderBy.fromString("`name` ASC This is custom")) + } +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/sql/language/SelectTest.kt b/tests/src/test/java/com/dbflow5/sql/language/SelectTest.kt new file mode 100644 index 000000000..60123170f --- /dev/null +++ b/tests/src/test/java/com/dbflow5/sql/language/SelectTest.kt @@ -0,0 +1,28 @@ +package com.dbflow5.sql.language + +import com.dbflow5.BaseUnitTest +import com.dbflow5.assertEquals +import com.dbflow5.config.databaseForTable +import com.dbflow5.models.SimpleModel +import com.dbflow5.models.TwoColumnModel +import com.dbflow5.models.TwoColumnModel_Table.id +import com.dbflow5.models.TwoColumnModel_Table.name +import com.dbflow5.query.select +import org.junit.Test + +class SelectTest : BaseUnitTest() { + + @Test + fun validateSelect() { + databaseForTable { + "SELECT `name`,`id` FROM `TwoColumnModel`".assertEquals(select(name, id) from TwoColumnModel::class) + } + } + + @Test + fun validateSelectDistinct() { + databaseForTable { + "SELECT DISTINCT `name` FROM `SimpleModel`".assertEquals(select(name).distinct() from SimpleModel::class) + } + } +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/sql/language/SetTest.kt b/tests/src/test/java/com/dbflow5/sql/language/SetTest.kt new file mode 100644 index 000000000..18e5f0831 --- /dev/null +++ b/tests/src/test/java/com/dbflow5/sql/language/SetTest.kt @@ -0,0 +1,28 @@ +package com.dbflow5.sql.language + +import com.dbflow5.BaseUnitTest +import com.dbflow5.assertEquals +import com.dbflow5.config.databaseForTable +import com.dbflow5.models.SimpleModel +import com.dbflow5.models.SimpleModel_Table.name +import com.dbflow5.models.TwoColumnModel_Table.id +import com.dbflow5.query.set +import com.dbflow5.query.update +import org.junit.Test + +class SetTest : BaseUnitTest() { + + @Test + fun validateSetWithConditions() { + databaseForTable { + "UPDATE `SimpleModel` SET `name`='name'".assertEquals(update() set name.`is`("name")) + } + } + + @Test + fun validateMultipleConditions() { + databaseForTable { + "UPDATE `SimpleModel` SET `name`='name', `id`=0".assertEquals(update() set name.eq("name") and id.eq(0)) + } + } +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/sql/language/TriggerTest.kt b/tests/src/test/java/com/dbflow5/sql/language/TriggerTest.kt new file mode 100644 index 000000000..2731c4893 --- /dev/null +++ b/tests/src/test/java/com/dbflow5/sql/language/TriggerTest.kt @@ -0,0 +1,69 @@ +package com.dbflow5.sql.language + +import com.dbflow5.BaseUnitTest +import com.dbflow5.assertEquals +import com.dbflow5.config.databaseForTable +import com.dbflow5.models.SimpleModel +import com.dbflow5.models.SimpleModel_Table.name +import com.dbflow5.models.TwoColumnModel +import com.dbflow5.models.TwoColumnModel_Table.id +import com.dbflow5.query.NameAlias +import com.dbflow5.query.cast +import com.dbflow5.query.columnValues +import com.dbflow5.query.createTempTrigger +import com.dbflow5.query.createTrigger +import com.dbflow5.query.insert +import com.dbflow5.query.insertOn +import com.dbflow5.query.property.property +import com.dbflow5.query.select +import com.dbflow5.query.updateOn +import com.dbflow5.sql.SQLiteType +import com.dbflow5.structure.insert +import org.junit.Assert.assertNotNull +import org.junit.Test + +class TriggerTest : BaseUnitTest() { + + @Test + fun validateBasicTrigger() { + databaseForTable { + ("CREATE TRIGGER IF NOT EXISTS `MyTrigger` AFTER INSERT ON `SimpleModel` " + + "\nBEGIN" + + "\nINSERT INTO `TwoColumnModel`(`name`) VALUES(`new`.`name`);" + + "\nEND").assertEquals(createTrigger("MyTrigger").after() insertOn SimpleModel::class begin + insert(TwoColumnModel::class).columnValues(name to NameAlias.ofTable("new", "name"))) + } + } + + @Test + fun validateUpdateTriggerMultiline() { + databaseForTable { + ("CREATE TEMP TRIGGER IF NOT EXISTS `MyTrigger` BEFORE UPDATE ON `SimpleModel` " + + "\nBEGIN" + + "\nINSERT INTO `TwoColumnModel`(`name`) VALUES(`new`.`name`);" + + "\nINSERT INTO `TwoColumnModel`(`id`) VALUES(CAST(`new`.`name` AS INTEGER));" + + "\nEND") + .assertEquals( + ( + createTempTrigger("MyTrigger").before() updateOn SimpleModel::class + begin + insert(TwoColumnModel::class, name).values(NameAlias.ofTable("new", "name")) + and + insert(TwoColumnModel::class, id).values( + cast(NameAlias.ofTable("new", "name").property).`as`(SQLiteType.INTEGER)))) + } + } + + @Test + fun validateTriggerWorks() { + databaseForTable { + val trigger = createTrigger("MyTrigger").after() insertOn SimpleModel::class begin + insert(TwoColumnModel::class).columnValues(name to NameAlias.ofTable("new", "name")) + trigger.enable(this) + SimpleModel("Test").insert() + + val result = select from TwoColumnModel::class where (name eq "Test") + assertNotNull(result) + } + } +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/sql/language/UnsafeStringOperatorTest.kt b/tests/src/test/java/com/dbflow5/sql/language/UnsafeStringOperatorTest.kt new file mode 100644 index 000000000..703cdfe92 --- /dev/null +++ b/tests/src/test/java/com/dbflow5/sql/language/UnsafeStringOperatorTest.kt @@ -0,0 +1,21 @@ +package com.dbflow5.sql.language + +import com.dbflow5.BaseUnitTest +import com.dbflow5.assertEquals +import com.dbflow5.config.databaseForTable +import com.dbflow5.models.SimpleModel +import com.dbflow5.query.UnSafeStringOperator +import com.dbflow5.query.select +import org.junit.Test + +class UnsafeStringOperatorTest : BaseUnitTest() { + + @Test + fun testCanIncludeInQuery() { + databaseForTable { + val op = UnSafeStringOperator("name = ?, id = ?, test = ?", arrayOf("'name'", "0", "'test'")) + "name = 'name', id = 0, test = 'test'".assertEquals(op) + "SELECT * FROM `SimpleModel` WHERE name = 'name', id = 0, test = 'test'".assertEquals(select from SimpleModel::class where op) + } + } +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/sql/language/UpdateTest.kt b/tests/src/test/java/com/dbflow5/sql/language/UpdateTest.kt new file mode 100644 index 000000000..1260b917c --- /dev/null +++ b/tests/src/test/java/com/dbflow5/sql/language/UpdateTest.kt @@ -0,0 +1,68 @@ +package com.dbflow5.sql.language + +import com.dbflow5.BaseUnitTest +import com.dbflow5.annotation.ConflictAction +import com.dbflow5.assertEquals +import com.dbflow5.config.databaseForTable +import com.dbflow5.models.NumberModel +import com.dbflow5.models.NumberModel_Table.id +import com.dbflow5.models.SimpleModel +import com.dbflow5.models.SimpleModel_Table.name +import com.dbflow5.query.property.Property +import com.dbflow5.query.set +import com.dbflow5.query.update +import org.junit.Test + +class UpdateTest : BaseUnitTest() { + + @Test + fun validateUpdateRollback() { + databaseForTable { + "UPDATE OR ROLLBACK `SimpleModel`".assertEquals(update().orRollback()) + } + } + + @Test + fun validateUpdateFail() { + databaseForTable { + "UPDATE OR FAIL `SimpleModel`".assertEquals(update().orFail()) + } + } + + @Test + fun validateUpdateIgnore() { + databaseForTable { + "UPDATE OR IGNORE `SimpleModel`".assertEquals(update().orIgnore()) + } + } + + @Test + fun validateUpdateReplace() { + databaseForTable { + "UPDATE OR REPLACE `SimpleModel`".assertEquals(update().orReplace()) + } + } + + @Test + fun validateUpdateAbort() { + databaseForTable { + "UPDATE OR ABORT `SimpleModel`".assertEquals(update().orAbort()) + } + } + + @Test + fun validateSetQuery() { + databaseForTable { + "UPDATE `SimpleModel` SET `name`='name'".assertEquals(update() set (name eq "name")) + } + } + + @Test + fun validateWildcardQuery() { + databaseForTable { + "UPDATE OR FAIL `NumberModel` SET `id`=? WHERE `id`=?".assertEquals(update().or(ConflictAction.FAIL) + .set(id.eq(Property.WILDCARD)) + .where(id.eq(Property.WILDCARD))) + } + } +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/sql/language/WhereTest.kt b/tests/src/test/java/com/dbflow5/sql/language/WhereTest.kt new file mode 100644 index 000000000..69fcca04c --- /dev/null +++ b/tests/src/test/java/com/dbflow5/sql/language/WhereTest.kt @@ -0,0 +1,180 @@ +package com.dbflow5.sql.language + +import com.dbflow5.BaseUnitTest +import com.dbflow5.assertEquals +import com.dbflow5.config.databaseForTable +import com.dbflow5.models.SimpleModel +import com.dbflow5.models.SimpleModel_Table.name +import com.dbflow5.models.TwoColumnModel +import com.dbflow5.models.TwoColumnModel_Table.id +import com.dbflow5.query.OrderBy.Companion.fromNameAlias +import com.dbflow5.query.Where +import com.dbflow5.query.groupBy +import com.dbflow5.query.having +import com.dbflow5.query.list +import com.dbflow5.query.nameAlias +import com.dbflow5.query.or +import com.dbflow5.query.result +import com.dbflow5.query.select +import com.dbflow5.query.update +import org.junit.Assert.assertTrue +import org.junit.Assert.fail +import org.junit.Test + +class WhereTest : BaseUnitTest() { + + @Test + fun validateBasicWhere() { + databaseForTable { + val query = select from SimpleModel::class where name.`is`("name") + "SELECT * FROM `SimpleModel` WHERE `name`='name'".assertEquals(query) + assertCanCopyQuery(query) + } + } + + @Test + fun validateComplexQueryWhere() { + databaseForTable { + val query = select from SimpleModel::class where name.`is`("name") or id.eq(1) and (id.`is`(0) or name.eq("hi")) + "SELECT * FROM `SimpleModel` WHERE `name`='name' OR `id`=1 AND (`id`=0 OR `name`='hi')".assertEquals(query) + assertCanCopyQuery(query) + } + } + + @Test + fun validateGroupBy() { + databaseForTable { + val query = select from SimpleModel::class where name.`is`("name") groupBy name + "SELECT * FROM `SimpleModel` WHERE `name`='name' GROUP BY `name`".assertEquals(query) + assertCanCopyQuery(query) + + } + } + + @Test + fun validateGroupByNameAlias() { + databaseForTable { + val query = (select from SimpleModel::class where name.`is`("name")).groupBy("name".nameAlias, "id".nameAlias) + "SELECT * FROM `SimpleModel` WHERE `name`='name' GROUP BY `name`,`id`".assertEquals(query) + assertCanCopyQuery(query) + } + } + + @Test + fun validateGroupByNameProps() { + databaseForTable { + val query = (select from SimpleModel::class where name.`is`("name")).groupBy(name, id) + "SELECT * FROM `SimpleModel` WHERE `name`='name' GROUP BY `name`,`id`".assertEquals(query) + assertCanCopyQuery(query) + } + } + + @Test + fun validateHaving() { + databaseForTable { + val query = select from SimpleModel::class where name.`is`("name") having name.like("That") + "SELECT * FROM `SimpleModel` WHERE `name`='name' HAVING `name` LIKE 'That'".assertEquals(query) + assertCanCopyQuery(query) + } + } + + @Test + fun validateLimit() { + databaseForTable { + val query = select from SimpleModel::class where name.`is`("name") limit 10 + "SELECT * FROM `SimpleModel` WHERE `name`='name' LIMIT 10".assertEquals(query) + assertCanCopyQuery(query) + } + } + + @Test + fun validateOffset() { + databaseForTable { + val query = select from SimpleModel::class where name.`is`("name") offset 10 + "SELECT * FROM `SimpleModel` WHERE `name`='name' OFFSET 10".assertEquals(query) + assertCanCopyQuery(query) + } + } + + @Test + fun validateWhereExists() { + databaseForTable { + val query = (select from SimpleModel::class + whereExists (select(name) from SimpleModel::class where name.like("Andrew"))) + ("SELECT * FROM `SimpleModel` " + + "WHERE EXISTS (SELECT `name` FROM `SimpleModel` WHERE `name` LIKE 'Andrew')").assertEquals(query) + assertCanCopyQuery(query) + } + } + + @Test + fun validateOrderByWhere() { + databaseForTable { + val query = (select from SimpleModel::class + where name.eq("name")).orderBy(name, true) + ("SELECT * FROM `SimpleModel` WHERE `name`='name' ORDER BY `name` ASC").assertEquals(query) + assertCanCopyQuery(query) + } + } + + @Test + fun validateOrderByWhereAlias() { + databaseForTable { + val query = (select from SimpleModel::class + where name.eq("name")).orderBy("name".nameAlias, true) + ("SELECT * FROM `SimpleModel` " + + "WHERE `name`='name' ORDER BY `name` ASC").assertEquals(query) + assertCanCopyQuery(query) + } + } + + @Test + fun validateOrderBy() { + databaseForTable { + val query = (select from SimpleModel::class + where name.eq("name") orderBy fromNameAlias("name".nameAlias).ascending()) + ("SELECT * FROM `SimpleModel` " + + "WHERE `name`='name' ORDER BY `name` ASC").assertEquals(query) + assertCanCopyQuery(query) + } + } + + private fun assertCanCopyQuery(query: Where) { + val actual = query.cloneSelf() + query.assertEquals(actual) + assertTrue(actual !== query) + } + + @Test + fun validateOrderByAll() { + databaseForTable { + val query = (select from TwoColumnModel::class + where name.eq("name")) + .orderByAll(listOf( + fromNameAlias("name".nameAlias).ascending(), + fromNameAlias("id".nameAlias).descending())) + ("SELECT * FROM `TwoColumnModel` " + + "WHERE `name`='name' ORDER BY `name` ASC,`id` DESC").assertEquals(query) + assertCanCopyQuery(query) + } + } + + @Test + fun validateNonSelectThrowError() { + databaseForTable { + try { + update().set(name.`is`("name")).result + fail("Non select passed") + } catch (i: IllegalArgumentException) { + // expected + } + + try { + update().set(name.`is`("name")).list + fail("Non select passed") + } catch (i: IllegalArgumentException) { + // expected + } + } + } +} diff --git a/tests/src/test/java/com/dbflow5/sql/language/property/BytePropertyTest.kt b/tests/src/test/java/com/dbflow5/sql/language/property/BytePropertyTest.kt new file mode 100644 index 000000000..7aff63b26 --- /dev/null +++ b/tests/src/test/java/com/dbflow5/sql/language/property/BytePropertyTest.kt @@ -0,0 +1,42 @@ +package com.dbflow5.sql.language.property + +import com.dbflow5.BaseUnitTest +import com.dbflow5.models.SimpleModel +import com.dbflow5.query.NameAlias +import com.dbflow5.query.property.Property +import org.junit.Assert.assertEquals +import org.junit.Test + +class BytePropertyTest : BaseUnitTest() { + + @Test + fun testOperators() { + val prop = Property(SimpleModel::class.java, "Prop") + assertEquals("`Prop`=5", prop.`is`(5).query.trim()) + assertEquals("`Prop`=5", prop.eq(5).query.trim()) + assertEquals("`Prop`!=5", prop.notEq(5).query.trim()) + assertEquals("`Prop`!=5", prop.isNot(5).query.trim()) + assertEquals("`Prop`>5", prop.greaterThan(5).query.trim()) + assertEquals("`Prop`>=5", prop.greaterThanOrEq(5).query.trim()) + assertEquals("`Prop`<5", prop.lessThan(5).query.trim()) + assertEquals("`Prop`<=5", prop.lessThanOrEq(5).query.trim()) + assertEquals("`Prop` BETWEEN 5 AND 6", prop.between(5).and(6).query.trim()) + assertEquals("`Prop` IN (5,6,7,8)", prop.`in`(5, 6, 7, 8).query.trim()) + assertEquals("`Prop` NOT IN (5,6,7,8)", prop.notIn(5, 6, 7, 8).query.trim()) + assertEquals("`Prop`=`Prop` + 5", prop.concatenate(5).query.trim()) + } + + @Test + fun testAlias() { + val prop = Property(SimpleModel::class.java, "Prop", "Alias") + assertEquals("`Prop` AS `Alias`", prop.toString().trim()) + + val prop2 = Property(SimpleModel::class.java, + NameAlias.builder("Prop") + .shouldAddIdentifierToName(false) + .`as`("Alias") + .shouldAddIdentifierToAliasName(false) + .build()) + assertEquals("Prop AS Alias", prop2.toString().trim()) + } +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/sql/language/property/CharPropertyTest.kt b/tests/src/test/java/com/dbflow5/sql/language/property/CharPropertyTest.kt new file mode 100644 index 000000000..f4dbf2a73 --- /dev/null +++ b/tests/src/test/java/com/dbflow5/sql/language/property/CharPropertyTest.kt @@ -0,0 +1,42 @@ +package com.dbflow5.sql.language.property + +import com.dbflow5.BaseUnitTest +import com.dbflow5.models.SimpleModel +import com.dbflow5.query.NameAlias +import com.dbflow5.query.property.Property +import org.junit.Assert.assertEquals +import org.junit.Test + +class CharPropertyTest : BaseUnitTest() { + + @Test + fun testOperators() { + val prop = Property(SimpleModel::class.java, "Prop") + assertEquals("`Prop`='5'", prop.`is`('5').query.trim()) + assertEquals("`Prop`='5'", prop.eq('5').query.trim()) + assertEquals("`Prop`!='5'", prop.notEq('5').query.trim()) + assertEquals("`Prop`!='5'", prop.isNot('5').query.trim()) + assertEquals("`Prop`>'5'", prop.greaterThan('5').query.trim()) + assertEquals("`Prop`>='5'", prop.greaterThanOrEq('5').query.trim()) + assertEquals("`Prop`<'5'", prop.lessThan('5').query.trim()) + assertEquals("`Prop`<='5'", prop.lessThanOrEq('5').query.trim()) + assertEquals("`Prop` BETWEEN '5' AND '6'", prop.between('5').and('6').query.trim()) + assertEquals("`Prop` IN ('5','6','7','8')", prop.`in`('5', '6', '7', '8').query.trim()) + assertEquals("`Prop` NOT IN ('5','6','7','8')", prop.notIn('5', '6', '7', '8').query.trim()) + assertEquals("`Prop`=`Prop` || '5'", prop.concatenate('5').query.trim()) + } + + @Test + fun testAlias() { + val prop = Property(SimpleModel::class.java, "Prop", "Alias") + assertEquals("`Prop` AS `Alias`", prop.toString().trim()) + + val prop2 = Property(SimpleModel::class.java, + NameAlias.builder("Prop") + .shouldAddIdentifierToName(false) + .`as`("Alias") + .shouldAddIdentifierToAliasName(false) + .build()) + assertEquals("Prop AS Alias", prop2.toString().trim()) + } +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/sql/language/property/DoublePropertyTest.kt b/tests/src/test/java/com/dbflow5/sql/language/property/DoublePropertyTest.kt new file mode 100644 index 000000000..3475b750e --- /dev/null +++ b/tests/src/test/java/com/dbflow5/sql/language/property/DoublePropertyTest.kt @@ -0,0 +1,42 @@ +package com.dbflow5.sql.language.property + +import com.dbflow5.BaseUnitTest +import com.dbflow5.models.SimpleModel +import com.dbflow5.query.NameAlias +import com.dbflow5.query.property.Property +import org.junit.Assert.assertEquals +import org.junit.Test + +class DoublePropertyTest : BaseUnitTest() { + + @Test + fun testOperators() { + val prop = Property(SimpleModel::class.java, "Prop") + assertEquals("`Prop`=5.0", prop.`is`(5.0).query.trim()) + assertEquals("`Prop`=5.0", prop.eq(5.0).query.trim()) + assertEquals("`Prop`!=5.0", prop.notEq(5.0).query.trim()) + assertEquals("`Prop`!=5.0", prop.isNot(5.0).query.trim()) + assertEquals("`Prop`>5.0", prop.greaterThan(5.0).query.trim()) + assertEquals("`Prop`>=5.0", prop.greaterThanOrEq(5.0).query.trim()) + assertEquals("`Prop`<5.0", prop.lessThan(5.0).query.trim()) + assertEquals("`Prop`<=5.0", prop.lessThanOrEq(5.0).query.trim()) + assertEquals("`Prop` BETWEEN 5.0 AND 6.0", prop.between(5.0).and(6.0).query.trim()) + assertEquals("`Prop` IN (5.0,6.0,7.0,8.0)", prop.`in`(5.0, 6.0, 7.0, 8.0).query.trim()) + assertEquals("`Prop` NOT IN (5.0,6.0,7.0,8.0)", prop.notIn(5.0, 6.0, 7.0, 8.0).query.trim()) + assertEquals("`Prop`=`Prop` + 5.0", prop.concatenate(5.0).query.trim()) + } + + @Test + fun testAlias() { + val prop = Property(SimpleModel::class.java, "Prop", "Alias") + assertEquals("`Prop` AS `Alias`", prop.toString().trim()) + + val prop2 = Property(SimpleModel::class.java, + NameAlias.builder("Prop") + .shouldAddIdentifierToName(false) + .`as`("Alias") + .shouldAddIdentifierToAliasName(false) + .build()) + assertEquals("Prop AS Alias", prop2.toString().trim()) + } +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/sql/language/property/FloatPropertyTest.kt b/tests/src/test/java/com/dbflow5/sql/language/property/FloatPropertyTest.kt new file mode 100644 index 000000000..097274acc --- /dev/null +++ b/tests/src/test/java/com/dbflow5/sql/language/property/FloatPropertyTest.kt @@ -0,0 +1,42 @@ +package com.dbflow5.sql.language.property + +import com.dbflow5.BaseUnitTest +import com.dbflow5.models.SimpleModel +import com.dbflow5.query.NameAlias +import com.dbflow5.query.property.Property +import org.junit.Assert.assertEquals +import org.junit.Test + +class FloatPropertyTest : BaseUnitTest() { + + @Test + fun testOperators() { + val prop = Property(SimpleModel::class.java, "Prop") + assertEquals("`Prop`=5.0", prop.`is`(5f).query.trim()) + assertEquals("`Prop`=5.0", prop.eq(5f).query.trim()) + assertEquals("`Prop`!=5.0", prop.notEq(5f).query.trim()) + assertEquals("`Prop`!=5.0", prop.isNot(5f).query.trim()) + assertEquals("`Prop`>5.0", prop.greaterThan(5f).query.trim()) + assertEquals("`Prop`>=5.0", prop.greaterThanOrEq(5f).query.trim()) + assertEquals("`Prop`<5.0", prop.lessThan(5f).query.trim()) + assertEquals("`Prop`<=5.0", prop.lessThanOrEq(5f).query.trim()) + assertEquals("`Prop` BETWEEN 5.0 AND 6.0", prop.between(5f).and(6f).query.trim()) + assertEquals("`Prop` IN (5.0,6.0,7.0,8.0)", prop.`in`(5f, 6f, 7f, 8f).query.trim()) + assertEquals("`Prop` NOT IN (5.0,6.0,7.0,8.0)", prop.notIn(5f, 6f, 7f, 8f).query.trim()) + assertEquals("`Prop`=`Prop` + 5.0", prop.concatenate(5f).query.trim()) + } + + @Test + fun testAlias() { + val prop = Property(SimpleModel::class.java, "Prop", "Alias") + assertEquals("`Prop` AS `Alias`", prop.toString().trim()) + + val prop2 = Property(SimpleModel::class.java, + NameAlias.builder("Prop") + .shouldAddIdentifierToName(false) + .`as`("Alias") + .shouldAddIdentifierToAliasName(false) + .build()) + assertEquals("Prop AS Alias", prop2.toString().trim()) + } +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/sql/language/property/IndexPropertyTest.kt b/tests/src/test/java/com/dbflow5/sql/language/property/IndexPropertyTest.kt new file mode 100644 index 000000000..de5199cdc --- /dev/null +++ b/tests/src/test/java/com/dbflow5/sql/language/property/IndexPropertyTest.kt @@ -0,0 +1,24 @@ +package com.dbflow5.sql.language.property + +import com.dbflow5.BaseUnitTest +import com.dbflow5.config.databaseForTable +import com.dbflow5.models.SimpleModel +import com.dbflow5.models.SimpleModel_Table +import com.dbflow5.query.property.IndexProperty +import org.junit.Assert.assertEquals +import org.junit.Test + +class IndexPropertyTest : BaseUnitTest() { + + + @Test + fun validateIndexProperty() { + databaseForTable { + val prop = IndexProperty("Index", true, SimpleModel::class.java, + SimpleModel_Table.name) + prop.createIfNotExists(this) + prop.drop(this) + assertEquals("`Index`", prop.indexName) + } + } +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/sql/language/property/IntPropertyTest.kt b/tests/src/test/java/com/dbflow5/sql/language/property/IntPropertyTest.kt new file mode 100644 index 000000000..a5e4ba22e --- /dev/null +++ b/tests/src/test/java/com/dbflow5/sql/language/property/IntPropertyTest.kt @@ -0,0 +1,42 @@ +package com.dbflow5.sql.language.property + +import com.dbflow5.BaseUnitTest +import com.dbflow5.models.SimpleModel +import com.dbflow5.query.NameAlias +import com.dbflow5.query.property.Property +import org.junit.Assert.assertEquals +import org.junit.Test + +class IntPropertyTest : BaseUnitTest() { + + @Test + fun testOperators() { + val prop = Property(SimpleModel::class.java, "Prop") + assertEquals("`Prop`=5", prop.`is`(5).query.trim()) + assertEquals("`Prop`=5", prop.eq(5).query.trim()) + assertEquals("`Prop`!=5", prop.notEq(5).query.trim()) + assertEquals("`Prop`!=5", prop.isNot(5).query.trim()) + assertEquals("`Prop`>5", prop.greaterThan(5).query.trim()) + assertEquals("`Prop`>=5", prop.greaterThanOrEq(5).query.trim()) + assertEquals("`Prop`<5", prop.lessThan(5).query.trim()) + assertEquals("`Prop`<=5", prop.lessThanOrEq(5).query.trim()) + assertEquals("`Prop` BETWEEN 5 AND 6", prop.between(5).and(6).query.trim()) + assertEquals("`Prop` IN (5,6,7,8)", prop.`in`(5, 6, 7, 8).query.trim()) + assertEquals("`Prop` NOT IN (5,6,7,8)", prop.notIn(5, 6, 7, 8).query.trim()) + assertEquals("`Prop`=`Prop` + 5", prop.concatenate(5).query.trim()) + } + + @Test + fun testAlias() { + val prop = Property(SimpleModel::class.java, "Prop", "Alias") + assertEquals("`Prop` AS `Alias`", prop.toString().trim()) + + val prop2 = Property(SimpleModel::class.java, + NameAlias.builder("Prop") + .shouldAddIdentifierToName(false) + .`as`("Alias") + .shouldAddIdentifierToAliasName(false) + .build()) + assertEquals("Prop AS Alias", prop2.toString().trim()) + } +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/sql/language/property/LongPropertyTest.kt b/tests/src/test/java/com/dbflow5/sql/language/property/LongPropertyTest.kt new file mode 100644 index 000000000..cdb69f24c --- /dev/null +++ b/tests/src/test/java/com/dbflow5/sql/language/property/LongPropertyTest.kt @@ -0,0 +1,42 @@ +package com.dbflow5.sql.language.property + +import com.dbflow5.BaseUnitTest +import com.dbflow5.models.SimpleModel +import com.dbflow5.query.NameAlias +import com.dbflow5.query.property.Property +import org.junit.Assert.assertEquals +import org.junit.Test + +class LongPropertyTest : BaseUnitTest() { + + @Test + fun testOperators() { + val prop = Property(SimpleModel::class.java, "Prop") + assertEquals("`Prop`=5", prop.`is`(5).query.trim()) + assertEquals("`Prop`=5", prop.eq(5).query.trim()) + assertEquals("`Prop`!=5", prop.notEq(5).query.trim()) + assertEquals("`Prop`!=5", prop.isNot(5).query.trim()) + assertEquals("`Prop`>5", prop.greaterThan(5).query.trim()) + assertEquals("`Prop`>=5", prop.greaterThanOrEq(5).query.trim()) + assertEquals("`Prop`<5", prop.lessThan(5).query.trim()) + assertEquals("`Prop`<=5", prop.lessThanOrEq(5).query.trim()) + assertEquals("`Prop` BETWEEN 5 AND 6", prop.between(5).and(6).query.trim()) + assertEquals("`Prop` IN (5,6,7,8)", prop.`in`(5, 6, 7, 8).query.trim()) + assertEquals("`Prop` NOT IN (5,6,7,8)", prop.notIn(5, 6, 7, 8).query.trim()) + assertEquals("`Prop`=`Prop` + 5", prop.concatenate(5).query.trim()) + } + + @Test + fun testAlias() { + val prop = Property(SimpleModel::class.java, "Prop", "Alias") + assertEquals("`Prop` AS `Alias`", prop.toString().trim()) + + val prop2 = Property(SimpleModel::class.java, + NameAlias.builder("Prop") + .shouldAddIdentifierToName(false) + .`as`("Alias") + .shouldAddIdentifierToAliasName(false) + .build()) + assertEquals("Prop AS Alias", prop2.toString().trim()) + } +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/sql/language/property/PropertyFactoryTest.kt b/tests/src/test/java/com/dbflow5/sql/language/property/PropertyFactoryTest.kt new file mode 100644 index 000000000..8b0c379c4 --- /dev/null +++ b/tests/src/test/java/com/dbflow5/sql/language/property/PropertyFactoryTest.kt @@ -0,0 +1,30 @@ +package com.dbflow5.sql.language.property + +import com.dbflow5.BaseUnitTest +import com.dbflow5.config.databaseForTable +import com.dbflow5.models.SimpleModel +import com.dbflow5.query.property.property +import com.dbflow5.query.property.propertyString +import com.dbflow5.query.select +import org.junit.Assert.assertEquals +import org.junit.Test + +class PropertyFactoryTest : BaseUnitTest() { + + @Test + fun testPrimitives() { + assertEquals("'c'", 'c'.property.query) + assertEquals("5", 5.property.query) + assertEquals("5.0", 5.0.property.query) + assertEquals("5.0", 5.0f.property.query) + assertEquals("5", 5L.property.query) + assertEquals("5", 5.toShort().property.query) + assertEquals("5", 5.toByte().property.query) + val nullable: Any? = null + assertEquals("NULL", nullable.property.query) + databaseForTable { + assertEquals("(SELECT * FROM `SimpleModel`)", (select from SimpleModel::class).property.query) + } + assertEquals("SomethingCool", propertyString("SomethingCool").query) + } +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/sql/language/property/PropertyTest.kt b/tests/src/test/java/com/dbflow5/sql/language/property/PropertyTest.kt new file mode 100644 index 000000000..82506bfe5 --- /dev/null +++ b/tests/src/test/java/com/dbflow5/sql/language/property/PropertyTest.kt @@ -0,0 +1,45 @@ +package com.dbflow5.sql.language.property + +import com.dbflow5.BaseUnitTest +import com.dbflow5.models.SimpleModel +import com.dbflow5.query.NameAlias +import com.dbflow5.query.property.Property +import org.junit.Assert +import org.junit.Test + +class PropertyTest : BaseUnitTest() { + + @Test + fun testOperators() { + val prop = Property(SimpleModel::class.java, "Prop") + Assert.assertEquals("`Prop`='5'", prop.`is`("5").query.trim()) + Assert.assertEquals("`Prop`='5'", prop.eq("5").query.trim()) + Assert.assertEquals("`Prop`!='5'", prop.notEq("5").query.trim()) + Assert.assertEquals("`Prop`!='5'", prop.isNot("5").query.trim()) + Assert.assertEquals("`Prop` LIKE '5'", prop.like("5").query.trim()) + Assert.assertEquals("`Prop` NOT LIKE '5'", prop.notLike("5").query.trim()) + Assert.assertEquals("`Prop` GLOB '5'", prop.glob("5").query.trim()) + Assert.assertEquals("`Prop`>'5'", prop.greaterThan("5").query.trim()) + Assert.assertEquals("`Prop`>='5'", prop.greaterThanOrEq("5").query.trim()) + Assert.assertEquals("`Prop`<'5'", prop.lessThan("5").query.trim()) + Assert.assertEquals("`Prop`<='5'", prop.lessThanOrEq("5").query.trim()) + Assert.assertEquals("`Prop` BETWEEN '5' AND '6'", prop.between("5").and("6").query.trim()) + Assert.assertEquals("`Prop` IN ('5','6','7','8')", prop.`in`("5", "6", "7", "8").query.trim()) + Assert.assertEquals("`Prop` NOT IN ('5','6','7','8')", prop.notIn("5", "6", "7", "8").query.trim()) + Assert.assertEquals("`Prop`=`Prop` || '5'", prop.concatenate("5").query.trim()) + } + + @Test + fun testAlias() { + val prop = Property(SimpleModel::class.java, "Prop", "Alias") + Assert.assertEquals("`Prop` AS `Alias`", prop.toString().trim()) + + val prop2 = Property(SimpleModel::class.java, + NameAlias.builder("Prop") + .shouldAddIdentifierToName(false) + .`as`("Alias") + .shouldAddIdentifierToAliasName(false) + .build()) + Assert.assertEquals("Prop AS Alias", prop2.toString().trim()) + } +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/sql/language/property/ShortPropertyTest.kt b/tests/src/test/java/com/dbflow5/sql/language/property/ShortPropertyTest.kt new file mode 100644 index 000000000..2e6a5d93c --- /dev/null +++ b/tests/src/test/java/com/dbflow5/sql/language/property/ShortPropertyTest.kt @@ -0,0 +1,42 @@ +package com.dbflow5.sql.language.property + +import com.dbflow5.BaseUnitTest +import com.dbflow5.models.SimpleModel +import com.dbflow5.query.NameAlias +import com.dbflow5.query.property.Property +import org.junit.Assert.assertEquals +import org.junit.Test + +class ShortPropertyTest : BaseUnitTest() { + + @Test + fun testOperators() { + val prop = Property(SimpleModel::class.java, "Prop") + assertEquals("`Prop`=5", prop.`is`(5).query.trim()) + assertEquals("`Prop`=5", prop.eq(5).query.trim()) + assertEquals("`Prop`!=5", prop.notEq(5).query.trim()) + assertEquals("`Prop`!=5", prop.isNot(5).query.trim()) + assertEquals("`Prop`>5", prop.greaterThan(5).query.trim()) + assertEquals("`Prop`>=5", prop.greaterThanOrEq(5).query.trim()) + assertEquals("`Prop`<5", prop.lessThan(5).query.trim()) + assertEquals("`Prop`<=5", prop.lessThanOrEq(5).query.trim()) + assertEquals("`Prop` BETWEEN 5 AND 6", prop.between(5).and(6).query.trim()) + assertEquals("`Prop` IN (5,6,7,8)", prop.`in`(5, 6, 7, 8).query.trim()) + assertEquals("`Prop` NOT IN (5,6,7,8)", prop.notIn(5, 6, 7, 8).query.trim()) + assertEquals("`Prop`=`Prop` + 5", prop.concatenate(5).query.trim()) + } + + @Test + fun testAlias() { + val prop = Property(SimpleModel::class.java, "Prop", "Alias") + assertEquals("`Prop` AS `Alias`", prop.toString().trim()) + + val prop2 = Property(SimpleModel::class.java, + NameAlias.builder("Prop") + .shouldAddIdentifierToName(false) + .`as`("Alias") + .shouldAddIdentifierToAliasName(false) + .build()) + assertEquals("Prop AS Alias", prop2.toString().trim()) + } +} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/sql/language/property/TypeConvertedPropertyTest.kt b/tests/src/test/java/com/dbflow5/sql/language/property/TypeConvertedPropertyTest.kt new file mode 100644 index 000000000..56ee64063 --- /dev/null +++ b/tests/src/test/java/com/dbflow5/sql/language/property/TypeConvertedPropertyTest.kt @@ -0,0 +1,42 @@ +package com.dbflow5.sql.language.property + +import com.dbflow5.BaseUnitTest +import com.dbflow5.converter.DateConverter +import com.dbflow5.converter.TypeConverter +import com.dbflow5.models.Difficulty +import com.dbflow5.models.EnumTypeConverterModel_Table +import com.dbflow5.models.SimpleModel +import com.dbflow5.query.NameAlias +import com.dbflow5.query.property.TypeConvertedProperty +import org.junit.Assert.assertEquals +import org.junit.Test +import java.util.* + +class TypeConvertedPropertyTest : BaseUnitTest() { + + + @Test + fun testTypeConverter() { + val property = TypeConvertedProperty(SimpleModel::class.java, "Prop", true, + object : TypeConvertedProperty.TypeConverterGetter { + override fun getTypeConverter(modelClass: Class<*>): TypeConverter<*, *> = DateConverter() + }) + assertEquals("`Prop`", property.toString()) + + val date = Date() + assertEquals("`Prop`=${date.time}", property.eq(date).query) + + assertEquals("`SimpleModel`.`Prop`=${date.time}", property.withTable().eq(date).query) + + val inverted = property.invertProperty() + assertEquals("`Prop`=5050505", inverted.eq(5050505).query) + } + + @Test + fun testCustomEnumTypeConverter() { + + assertEquals("`difficulty`='H'", EnumTypeConverterModel_Table.difficulty.eq(Difficulty.HARD).query) + assertEquals("`EnumTypeConverterModel`.`difficulty`='H'", EnumTypeConverterModel_Table.difficulty.withTable().eq(Difficulty.HARD).query) + assertEquals("`et`.`difficulty`='H'", EnumTypeConverterModel_Table.difficulty.withTable(NameAlias.tableNameBuilder("et").build()).eq(Difficulty.HARD).query) + } +} \ No newline at end of file diff --git a/usage2/RXJavaSupport.md b/usage2/RXJavaSupport.md index 37ca77be8..c8a5c124b 100644 --- a/usage2/RXJavaSupport.md +++ b/usage2/RXJavaSupport.md @@ -16,16 +16,11 @@ Add the separate packages to your project: dependencies { // RXJava1 - compile "com.github.Raizlabs.DBFlow:dbflow-rx:${dbflow_version}" - - // optional, for use with Kotlin as a nice companion. - compile "com.github.Raizlabs.DBFlow:dbflow-rx-kotlinextensions:${dbflow_version}" + compile "com.github.agrosner.dbflow:rx:${dbflow_version}" // RXJava2 - compile "com.github.Raizlabs.DBFlow:dbflow-rx2:${dbflow_version}" + compile "com.github.agrosner.dbflow:rx2:${dbflow_version}" - // optional, for use with Kotlin as a nice companion. - compile "com.github.Raizlabs.DBFlow:dbflow-rx2-kotlinextensions:${dbflow_version}" } ``` diff --git a/usage2/SQLCipherSupport.md b/usage2/SQLCipherSupport.md index a2a3fe873..1bafc61f0 100644 --- a/usage2/SQLCipherSupport.md +++ b/usage2/SQLCipherSupport.md @@ -6,7 +6,7 @@ To add the library add the library to your `build.gradle` with same version you ```groovy dependencies { - compile "com.github.Raizlabs.DBFlow:dbflow-sqlcipher:${version}" + compile "com.github.agrosner.dbflow:sqlcipher:${version}" compile "net.zetetic:android-database-sqlcipher:${sqlcipher_version}@aar" } diff --git a/usage2/including-in-project.md b/usage2/including-in-project.md index ab013a81e..a00bc77e4 100644 --- a/usage2/including-in-project.md +++ b/usage2/including-in-project.md @@ -68,6 +68,9 @@ Add artifacts to your project: // Android Architecture Components Paging Library Support compile "com.github.agrosner.dbflow:paging:${dbflow_version}" + // adds generated content provider annotations + support. + compile "com.github.agrosner.dbflow:contentprovider:${dbflow_version}" + } ``` From 083d002c3dff89790ff8b78c89ade8a8d03f15ff Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Thu, 24 May 2018 14:22:00 -0400 Subject: [PATCH 215/234] [tests] fix calculation looop. --- tests/src/test/java/com/dbflow5/rx2/query/RXFlowableTest.kt | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tests/src/test/java/com/dbflow5/rx2/query/RXFlowableTest.kt b/tests/src/test/java/com/dbflow5/rx2/query/RXFlowableTest.kt index 22ff8a124..e885c235a 100644 --- a/tests/src/test/java/com/dbflow5/rx2/query/RXFlowableTest.kt +++ b/tests/src/test/java/com/dbflow5/rx2/query/RXFlowableTest.kt @@ -51,7 +51,7 @@ class RXFlowableTest : BaseUnitTest() { var list = mutableListOf() var calls = 0 (select from Blog::class - leftOuterJoin Author::class + leftOuterJoin Author::class on joinOn) .asFlowable { db, modelQueriable -> modelQueriable.queryList(db) } .subscribe { @@ -59,8 +59,8 @@ class RXFlowableTest : BaseUnitTest() { list = it } - val authors = (0 until 10).map { Author(it, firstName = "${it}name", lastName = "${it}last") } - (0 until 10).forEach { Blog(it, name = "${it}name ${it}last", author = authors[it]).save() } + val authors = (1 until 11).map { Author(it, firstName = "${it}name", lastName = "${it}last") } + (1 until 11).forEach { Blog(it, name = "${it}name ${it}last", author = authors[it - 1]).save() } assertEquals(21, calls) // 1 for initial, 10 for each model object assertEquals(10, list.size) From b944e8d67e9f49a4d22714fc17f6158d579f5530 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Mon, 28 May 2018 18:00:42 -0400 Subject: [PATCH 216/234] [kotlin] update kotlin to 1.2.41 --- build.gradle | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/build.gradle b/build.gradle index 55f0cfc4b..b9fa75a65 100644 --- a/build.gradle +++ b/build.gradle @@ -1,6 +1,6 @@ buildscript { ext { - kotlin_version = '1.2.31' + kotlin_version = '1.2.41' target_sdk = 27 min_sdk = 7 min_sdk_rx = 15 From dc4358d48755be3c52d8bb0b8f2d74fb5f51dc83 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Tue, 25 Sep 2018 20:25:47 -0400 Subject: [PATCH 217/234] [deps] update dependencies to latest except android sdk. --- build.gradle | 29 ++++++++++++------------ contentprovider/build.gradle | 2 +- gradle/wrapper/gradle-wrapper.properties | 4 ++-- lib/build.gradle | 2 +- 4 files changed, 19 insertions(+), 18 deletions(-) diff --git a/build.gradle b/build.gradle index b9fa75a65..5caf34c22 100644 --- a/build.gradle +++ b/build.gradle @@ -1,23 +1,24 @@ buildscript { ext { - kotlin_version = '1.2.41' + kotlin_version = '1.2.71' target_sdk = 27 min_sdk = 7 min_sdk_rx = 15 sql_cipher_min = 7 arch_min = 14 + support_version = "28.0.0" deps = [ - kotlin : "org.jetbrains.kotlin:kotlin-stdlib:${kotlin_version}", - sql_cipher : "net.zetetic:android-database-sqlcipher:3.5.7@aar", - rx1 : 'io.reactivex:rxjava:1.3.4', - rx2 : 'io.reactivex.rxjava2:rxjava:2.1.12', - coroutines : "org.jetbrains.kotlinx:kotlinx-coroutines-core:0.22.5", - javapoet : 'com.squareup:javapoet:1.11.1', - kpoet : 'com.github.agrosner:KPoet:1.0.0', - javax_annotation: 'org.glassfish:javax.annotation:10.0-b28', - junit : 'junit:junit:4.12', - paging : "android.arch.paging:runtime:1.0.0", + kotlin : "org.jetbrains.kotlin:kotlin-stdlib:${kotlin_version}", + sql_cipher : "net.zetetic:android-database-sqlcipher:3.5.9@aar", + rx2 : 'io.reactivex.rxjava2:rxjava:2.2.2', + coroutines : "org.jetbrains.kotlinx:kotlinx-coroutines-core:0.26.1", + javapoet : 'com.squareup:javapoet:1.11.1', + kpoet : 'com.github.agrosner:KPoet:1.0.0', + javax_annotation : 'org.glassfish:javax.annotation:10.0-b28', + junit : 'junit:junit:4.12', + paging : "android.arch.paging:runtime:1.0.0", + support_annotations: "com.android.support:support-annotations:${support_version}", ] } repositories { @@ -25,9 +26,9 @@ buildscript { google() } dependencies { - classpath 'com.android.tools.build:gradle:3.1.2' - classpath 'com.github.dcendents:android-maven-gradle-plugin:2.0' - classpath 'com.getkeepsafe.dexcount:dexcount-gradle-plugin:0.8.2' + classpath 'com.android.tools.build:gradle:3.3.0-alpha11' + classpath 'com.github.dcendents:android-maven-gradle-plugin:2.1' + classpath 'com.getkeepsafe.dexcount:dexcount-gradle-plugin:0.8.3' classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version" } } diff --git a/contentprovider/build.gradle b/contentprovider/build.gradle index ab1d03325..97f0317a8 100644 --- a/contentprovider/build.gradle +++ b/contentprovider/build.gradle @@ -28,7 +28,7 @@ android { dependencies { api project(':contentprovider-annotations') api project(':lib') - api "com.android.support:support-annotations:27.1.1" + api deps.support_annotations api "org.jetbrains.kotlin:kotlin-stdlib:${kotlin_version}" } diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties index 7b9fe21ec..2318f51e5 100644 --- a/gradle/wrapper/gradle-wrapper.properties +++ b/gradle/wrapper/gradle-wrapper.properties @@ -1,6 +1,6 @@ -#Sun Feb 11 13:54:27 EST 2018 +#Tue Sep 25 20:13:49 EDT 2018 distributionBase=GRADLE_USER_HOME distributionPath=wrapper/dists zipStoreBase=GRADLE_USER_HOME zipStorePath=wrapper/dists -distributionUrl=https\://services.gradle.org/distributions/gradle-4.4-all.zip +distributionUrl=https\://services.gradle.org/distributions/gradle-4.10-all.zip diff --git a/lib/build.gradle b/lib/build.gradle index d60dd9c98..e476417d4 100644 --- a/lib/build.gradle +++ b/lib/build.gradle @@ -27,7 +27,7 @@ android { dependencies { api project(':core') - api "com.android.support:support-annotations:27.1.1" + api deps.support_annotations api "org.jetbrains.kotlin:kotlin-stdlib:${kotlin_version}" } From 08ad2dc092397c3095d5f3be0a3530908178ec4e Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Tue, 25 Sep 2018 20:27:43 -0400 Subject: [PATCH 218/234] [Coroutines] use invokeOnCancellation instead. --- .../com/dbflow5/coroutines/Coroutines.kt | 32 +++++++------------ 1 file changed, 11 insertions(+), 21 deletions(-) diff --git a/coroutines/src/main/kotlin/com/dbflow5/coroutines/Coroutines.kt b/coroutines/src/main/kotlin/com/dbflow5/coroutines/Coroutines.kt index ed6889f22..aa939907e 100644 --- a/coroutines/src/main/kotlin/com/dbflow5/coroutines/Coroutines.kt +++ b/coroutines/src/main/kotlin/com/dbflow5/coroutines/Coroutines.kt @@ -21,8 +21,7 @@ import kotlinx.coroutines.experimental.suspendCancellableCoroutine */ suspend inline fun DBFlowDatabase.awaitTransact( modelQueriable: Q, - crossinline queriableFunction: Q.() -> R) - = suspendCancellableCoroutine { continuation -> + crossinline queriableFunction: Q.() -> R) = suspendCancellableCoroutine { continuation -> com.dbflow5.coroutines.constructCoroutine(continuation, this) { queriableFunction(modelQueriable) } } @@ -37,7 +36,7 @@ inline fun constructCoroutine(continuation: CancellableContinuation constructCoroutine(continuation: CancellableContinuation M.awaitSave(databaseDefinition: DBFlowDatabase) - = suspendCancellableCoroutine { continuation -> +suspend inline fun M.awaitSave(databaseDefinition: DBFlowDatabase) = suspendCancellableCoroutine { continuation -> constructCoroutine(continuation, databaseDefinition) { save(databaseDefinition) } } @@ -58,8 +56,7 @@ suspend inline fun M.awaitSave(databaseDefinition: DBFlowDatab * Description: Puts a [Model] operation inside a coroutine. Inside the [queriableFunction] * execute the db operation. */ -suspend inline fun M.awaitInsert(databaseDefinition: DBFlowDatabase) - = suspendCancellableCoroutine { continuation -> +suspend inline fun M.awaitInsert(databaseDefinition: DBFlowDatabase) = suspendCancellableCoroutine { continuation -> constructCoroutine(continuation, databaseDefinition) { insert(databaseDefinition) } } @@ -67,8 +64,7 @@ suspend inline fun M.awaitInsert(databaseDefinition: DBFlowDat * Description: Puts a [Model] operation inside a coroutine. Inside the [queriableFunction] * execute the db operation. */ -suspend inline fun M.awaitDelete(databaseDefinition: DBFlowDatabase) - = suspendCancellableCoroutine { continuation -> +suspend inline fun M.awaitDelete(databaseDefinition: DBFlowDatabase) = suspendCancellableCoroutine { continuation -> constructCoroutine(continuation, databaseDefinition) { delete(databaseDefinition) } } @@ -76,8 +72,7 @@ suspend inline fun M.awaitDelete(databaseDefinition: DBFlowDat * Description: Puts a [Model] operation inside a coroutine. Inside the [queriableFunction] * execute the db operation. */ -suspend inline fun M.awaitUpdate(databaseDefinition: DBFlowDatabase) - = suspendCancellableCoroutine { continuation -> +suspend inline fun M.awaitUpdate(databaseDefinition: DBFlowDatabase) = suspendCancellableCoroutine { continuation -> constructCoroutine(continuation, databaseDefinition) { update(databaseDefinition) } } @@ -85,40 +80,35 @@ suspend inline fun M.awaitUpdate(databaseDefinition: DBFlowDat * Description: Puts a [Model] operation inside a coroutine. Inside the [queriableFunction] * execute the db operation. */ -suspend inline fun M.awaitLoad(databaseDefinition: DBFlowDatabase) - = suspendCancellableCoroutine { continuation -> +suspend inline fun M.awaitLoad(databaseDefinition: DBFlowDatabase) = suspendCancellableCoroutine { continuation -> constructCoroutine(continuation, databaseDefinition) { load(databaseDefinition) } } /** * Description: Puts the [Collection] inside a [FastStoreModelTransaction] coroutine. */ -suspend inline fun > M.awaitSave(databaseDefinition: DBFlowDatabase) - = suspendCancellableCoroutine { continuation -> +suspend inline fun > M.awaitSave(databaseDefinition: DBFlowDatabase) = suspendCancellableCoroutine { continuation -> constructFastCoroutine(continuation, databaseDefinition) { fastSave() } } /** * Description: Puts the [Collection] inside a [FastStoreModelTransaction] coroutine. */ -suspend inline fun > M.awaitInsert(databaseDefinition: DBFlowDatabase) - = suspendCancellableCoroutine { continuation -> +suspend inline fun > M.awaitInsert(databaseDefinition: DBFlowDatabase) = suspendCancellableCoroutine { continuation -> constructFastCoroutine(continuation, databaseDefinition) { fastInsert() } } /** * Description: Puts the [Collection] inside a [FastStoreModelTransaction] coroutine. */ -suspend inline fun > M.awaitUpdate(databaseDefinition: DBFlowDatabase) - = suspendCancellableCoroutine { continuation -> +suspend inline fun > M.awaitUpdate(databaseDefinition: DBFlowDatabase) = suspendCancellableCoroutine { continuation -> constructFastCoroutine(continuation, databaseDefinition) { fastUpdate() } } /** * Description: Puts the [Collection] inside a [FastStoreModelTransaction] coroutine. */ -suspend inline fun > M.awaitDelete(databaseDefinition: DBFlowDatabase) - = suspendCancellableCoroutine { continuation -> +suspend inline fun > M.awaitDelete(databaseDefinition: DBFlowDatabase) = suspendCancellableCoroutine { continuation -> constructFastCoroutine(continuation, databaseDefinition) { fastDelete() } } From bd1fef8cd7b3f636ee14d3291c988f109c51cab2 Mon Sep 17 00:00:00 2001 From: Justin Kaufman Date: Mon, 15 Oct 2018 16:16:37 -0400 Subject: [PATCH 219/234] Update README.md - Add a note about library history. --- README.md | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index e9e018333..b9b387801 100644 --- a/README.md +++ b/README.md @@ -89,5 +89,7 @@ I welcome and encourage all pull requests. Please read over these guidelines to 4. Pull requests _must_ be made against `develop` branch. Any other branch (unless specified by the maintainers) will get rejected. 5. Have fun! -# Maintained By -[agrosner](https://github.com/agrosner) ([@agrosner](https://www.twitter.com/agrosner)) +# Maintainer +Originally created by [Raizlabs](https://www.raizlabs.com), a [Rightpoint](https://www.rightpoint.com) company + +Maintained by [agrosner](https://github.com/agrosner) ([@agrosner](https://www.twitter.com/agrosner)) From fb3739caa4c894d50fd0d7873c70a33416c145e6 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sat, 20 Oct 2018 14:35:36 -0400 Subject: [PATCH 220/234] [Versions] update to androidx dependencies. update to use new robolectric/androidx dependencies. --- build.gradle | 9 ++-- gradle/wrapper/gradle-wrapper.properties | 4 +- .../dbflow5/migration/AlterTableMigration.kt | 2 +- .../transaction/PriorityTransactionWrapper.kt | 3 +- tests/build.gradle | 26 ++++++------ tests/gradle.properties | 1 + .../com/dbflow5/DBFlowInstrumentedTestRule.kt | 37 ++++++++-------- .../contentobserver/ContentObserverTest.kt | 17 ++++---- .../provider/ContentProviderObjects.kt | 0 .../dbflow5/provider/ContentProviderTests.kt | 31 ++++++-------- .../dbflow5/provider/TestContentProvider.kt | 0 .../java/com/dbflow5/sqlcipher/CipherTest.kt | 4 +- .../src/test/java/com/dbflow5/BaseUnitTest.kt | 10 ++--- .../test/java/com/dbflow5/DBFlowTestRule.kt | 17 +++----- .../com/dbflow5/config/DatabaseConfigTest.kt | 2 +- .../dbflow5/provider/RealContentProvider.kt | 42 ------------------- .../dbflow5/query/list/FlowCursorListTest.kt | 12 +++--- .../com/dbflow5/runtime/DirectNotifierTest.kt | 14 +++---- 18 files changed, 89 insertions(+), 142 deletions(-) create mode 100644 tests/gradle.properties rename tests/src/{test => androidTest}/java/com/dbflow5/provider/ContentProviderObjects.kt (100%) rename tests/src/{test => androidTest}/java/com/dbflow5/provider/ContentProviderTests.kt (86%) rename tests/src/{test => androidTest}/java/com/dbflow5/provider/TestContentProvider.kt (100%) delete mode 100644 tests/src/test/java/com/dbflow5/provider/RealContentProvider.kt diff --git a/build.gradle b/build.gradle index 5caf34c22..103a7aa0f 100644 --- a/build.gradle +++ b/build.gradle @@ -1,12 +1,11 @@ buildscript { ext { kotlin_version = '1.2.71' - target_sdk = 27 + target_sdk = 28 min_sdk = 7 min_sdk_rx = 15 sql_cipher_min = 7 arch_min = 14 - support_version = "28.0.0" deps = [ kotlin : "org.jetbrains.kotlin:kotlin-stdlib:${kotlin_version}", @@ -18,7 +17,7 @@ buildscript { javax_annotation : 'org.glassfish:javax.annotation:10.0-b28', junit : 'junit:junit:4.12', paging : "android.arch.paging:runtime:1.0.0", - support_annotations: "com.android.support:support-annotations:${support_version}", + support_annotations: "androidx.annotation:annotation:1.0.0", ] } repositories { @@ -26,9 +25,9 @@ buildscript { google() } dependencies { - classpath 'com.android.tools.build:gradle:3.3.0-alpha11' + classpath 'com.android.tools.build:gradle:3.3.0-beta01' classpath 'com.github.dcendents:android-maven-gradle-plugin:2.1' - classpath 'com.getkeepsafe.dexcount:dexcount-gradle-plugin:0.8.3' + classpath 'com.getkeepsafe.dexcount:dexcount-gradle-plugin:0.8.4' classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version" } } diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties index 2318f51e5..956a16b52 100644 --- a/gradle/wrapper/gradle-wrapper.properties +++ b/gradle/wrapper/gradle-wrapper.properties @@ -1,6 +1,6 @@ -#Tue Sep 25 20:13:49 EDT 2018 +#Mon Oct 15 17:14:01 EDT 2018 distributionBase=GRADLE_USER_HOME distributionPath=wrapper/dists zipStoreBase=GRADLE_USER_HOME zipStorePath=wrapper/dists -distributionUrl=https\://services.gradle.org/distributions/gradle-4.10-all.zip +distributionUrl=https\://services.gradle.org/distributions/gradle-4.10.1-all.zip diff --git a/lib/src/main/kotlin/com/dbflow5/migration/AlterTableMigration.kt b/lib/src/main/kotlin/com/dbflow5/migration/AlterTableMigration.kt index bd35d3a87..82126af73 100644 --- a/lib/src/main/kotlin/com/dbflow5/migration/AlterTableMigration.kt +++ b/lib/src/main/kotlin/com/dbflow5/migration/AlterTableMigration.kt @@ -1,6 +1,6 @@ package com.dbflow5.migration -import android.support.annotation.CallSuper +import androidx.annotation.CallSuper import com.dbflow5.appendQuotedIfNeeded import com.dbflow5.config.FlowManager import com.dbflow5.database.DatabaseWrapper diff --git a/lib/src/main/kotlin/com/dbflow5/transaction/PriorityTransactionWrapper.kt b/lib/src/main/kotlin/com/dbflow5/transaction/PriorityTransactionWrapper.kt index 4193acd17..583885446 100644 --- a/lib/src/main/kotlin/com/dbflow5/transaction/PriorityTransactionWrapper.kt +++ b/lib/src/main/kotlin/com/dbflow5/transaction/PriorityTransactionWrapper.kt @@ -1,7 +1,6 @@ package com.dbflow5.transaction -import android.support.annotation.IntDef - +import androidx.annotation.IntDef import com.dbflow5.database.DatabaseWrapper /** diff --git a/tests/build.gradle b/tests/build.gradle index ac373c41c..c022b3af7 100644 --- a/tests/build.gradle +++ b/tests/build.gradle @@ -46,7 +46,7 @@ dependencies { kapt project("${dbflow_project_prefix}processor") implementation project(':lib') - implementation 'com.android.support:appcompat-v7:27.1.1' + implementation 'com.android.support:appcompat-v7:28.0.0' implementation project(':lib') implementation project("${dbflow_project_prefix}sqlcipher") implementation project(':reactive-streams') @@ -58,21 +58,23 @@ dependencies { kaptAndroidTest project("${dbflow_project_prefix}processor") testImplementation deps.javax_annotation - - testImplementation deps.junit - testImplementation "org.robolectric:robolectric:3.5.1" - testImplementation("com.nhaarman:mockito-kotlin:1.5.0") { + testImplementation("com.nhaarman.mockitokotlin2:mockito-kotlin:2.0.0-RC3") { exclude group: "org.jetbrains.kotlin" } - testImplementation 'org.mockito:mockito-core:2.8.9' + testImplementation 'org.mockito:mockito-core:2.23.0' androidTestImplementation deps.junit - androidTestImplementation('com.android.support.test:runner:0.5') { - exclude group: 'com.android.support', module: 'support-annotations' - } - androidTestImplementation('com.android.support.test:rules:0.5') { - exclude group: 'com.android.support', module: 'support-annotations' - } + testImplementation deps.junit + androidTestImplementation "androidx.test:core:1.0.0-beta02" + androidTestImplementation "androidx.test:runner:1.1.0-beta02" + androidTestImplementation "androidx.test:rules:1.1.0-beta02" + testImplementation "androidx.test:core:1.0.0-beta02" + testImplementation "androidx.test:runner:1.1.0-beta02" + testImplementation "androidx.test:rules:1.1.0-beta02" + testImplementation 'com.google.android:android-test:4.1.1.4' + + testImplementation "org.robolectric:robolectric:4.0-beta-1" + } android.applicationVariants.all { variant -> diff --git a/tests/gradle.properties b/tests/gradle.properties new file mode 100644 index 000000000..b01dd7c1d --- /dev/null +++ b/tests/gradle.properties @@ -0,0 +1 @@ +android.enableUnitTestBinaryResources=true \ No newline at end of file diff --git a/tests/src/androidTest/java/com/dbflow5/DBFlowInstrumentedTestRule.kt b/tests/src/androidTest/java/com/dbflow5/DBFlowInstrumentedTestRule.kt index a11282528..6a5d6cd00 100644 --- a/tests/src/androidTest/java/com/dbflow5/DBFlowInstrumentedTestRule.kt +++ b/tests/src/androidTest/java/com/dbflow5/DBFlowInstrumentedTestRule.kt @@ -1,13 +1,12 @@ package com.dbflow5 -import com.dbflow5.AppDatabase -import com.dbflow5.DemoApp import com.dbflow5.config.DBFlowDatabase import com.dbflow5.config.DatabaseConfig import com.dbflow5.config.FlowConfig import com.dbflow5.config.FlowManager import com.dbflow5.database.AndroidSQLiteOpenHelper import com.dbflow5.prepackaged.PrepackagedDB +import com.dbflow5.provider.ContentDatabase import com.dbflow5.runtime.ContentResolverNotifier import com.dbflow5.sqlcipher.CipherDatabase import org.junit.rules.TestRule @@ -22,21 +21,25 @@ class DBFlowInstrumentedTestRule : TestRule { @Throws(Throwable::class) override fun evaluate() { FlowManager.init(FlowConfig.Builder(DemoApp.context) - .database(DatabaseConfig( - databaseClass = AppDatabase::class.java, - openHelperCreator = AndroidSQLiteOpenHelper.createHelperCreator(DemoApp.context), - modelNotifier = ContentResolverNotifier(DemoApp.context, "com.grosner.content"), - transactionManagerCreator = { databaseDefinition: DBFlowDatabase -> - ImmediateTransactionManager(databaseDefinition) - })) - .database(DatabaseConfig( - openHelperCreator = AndroidSQLiteOpenHelper.createHelperCreator(DemoApp.context), - databaseClass = PrepackagedDB::class.java, - databaseName = "prepackaged")) - .database(DatabaseConfig( - openHelperCreator = AndroidSQLiteOpenHelper.createHelperCreator(DemoApp.context), - databaseClass = CipherDatabase::class.java)) - .build()) + .database(DatabaseConfig( + databaseClass = AppDatabase::class.java, + openHelperCreator = AndroidSQLiteOpenHelper.createHelperCreator(DemoApp.context), + modelNotifier = ContentResolverNotifier(DemoApp.context, "com.grosner.content"), + transactionManagerCreator = { databaseDefinition: DBFlowDatabase -> + ImmediateTransactionManager(databaseDefinition) + })) + .database(DatabaseConfig( + openHelperCreator = AndroidSQLiteOpenHelper.createHelperCreator(DemoApp.context), + databaseClass = PrepackagedDB::class.java, + databaseName = "prepackaged")) + .database(DatabaseConfig( + openHelperCreator = AndroidSQLiteOpenHelper.createHelperCreator(DemoApp.context), + databaseClass = CipherDatabase::class.java)) + .database(DatabaseConfig.builder(ContentDatabase::class, + AndroidSQLiteOpenHelper.createHelperCreator(DemoApp.context)) + .databaseName("content") + .build()) + .build()) try { base.evaluate() } finally { diff --git a/tests/src/androidTest/java/com/dbflow5/contentobserver/ContentObserverTest.kt b/tests/src/androidTest/java/com/dbflow5/contentobserver/ContentObserverTest.kt index 4b9813407..fe48212ce 100644 --- a/tests/src/androidTest/java/com/dbflow5/contentobserver/ContentObserverTest.kt +++ b/tests/src/androidTest/java/com/dbflow5/contentobserver/ContentObserverTest.kt @@ -19,7 +19,6 @@ import com.dbflow5.structure.insert import com.dbflow5.structure.save import com.dbflow5.structure.update import org.junit.Assert.assertEquals -import org.junit.Assert.assertTrue import org.junit.Before import org.junit.Test import java.util.concurrent.CountDownLatch @@ -33,7 +32,7 @@ class ContentObserverTest : BaseInstrumentedUnitTest() { @Before fun setupUser() { databaseForTable { - (delete() from User::class).execute() + delete().execute(this) } user = User(5, "Something", 55) } @@ -41,10 +40,10 @@ class ContentObserverTest : BaseInstrumentedUnitTest() { @Test fun testSpecificUris() { val conditionGroup = User::class.modelAdapter - .getPrimaryConditionClause(user) + .getPrimaryConditionClause(user) val uri = getNotificationUri(contentUri, - User::class.java, ChangeAction.DELETE, - conditionGroup.conditions.toTypedArray()) + User::class.java, ChangeAction.DELETE, + conditionGroup.conditions.toTypedArray()) assertEquals(uri.authority, contentUri) assertEquals(tableName(), uri.getQueryParameter(TABLE_QUERY_PARAM)) @@ -55,25 +54,25 @@ class ContentObserverTest : BaseInstrumentedUnitTest() { @Test fun testSpecificUrlInsert() { - assertProperConditions(ChangeAction.INSERT, { it.insert() }) + assertProperConditions(ChangeAction.INSERT) { it.insert() } } @Test fun testSpecificUrlUpdate() { - assertProperConditions(ChangeAction.UPDATE, { it.apply { age = 56 }.update() }) + assertProperConditions(ChangeAction.UPDATE) { it.apply { age = 56 }.update() } } @Test fun testSpecificUrlSave() { // insert on SAVE - assertProperConditions(ChangeAction.INSERT, { it.apply { age = 57 }.save() }) + assertProperConditions(ChangeAction.INSERT) { it.apply { age = 57 }.save() } } @Test fun testSpecificUrlDelete() { user.save() - assertProperConditions(ChangeAction.DELETE, { it.delete() }) + assertProperConditions(ChangeAction.DELETE) { it.delete() } } private fun assertProperConditions(action: ChangeAction, userFunc: (User) -> Unit) { diff --git a/tests/src/test/java/com/dbflow5/provider/ContentProviderObjects.kt b/tests/src/androidTest/java/com/dbflow5/provider/ContentProviderObjects.kt similarity index 100% rename from tests/src/test/java/com/dbflow5/provider/ContentProviderObjects.kt rename to tests/src/androidTest/java/com/dbflow5/provider/ContentProviderObjects.kt diff --git a/tests/src/test/java/com/dbflow5/provider/ContentProviderTests.kt b/tests/src/androidTest/java/com/dbflow5/provider/ContentProviderTests.kt similarity index 86% rename from tests/src/test/java/com/dbflow5/provider/ContentProviderTests.kt rename to tests/src/androidTest/java/com/dbflow5/provider/ContentProviderTests.kt index cb8976709..932b25cdb 100644 --- a/tests/src/test/java/com/dbflow5/provider/ContentProviderTests.kt +++ b/tests/src/androidTest/java/com/dbflow5/provider/ContentProviderTests.kt @@ -1,35 +1,30 @@ package com.dbflow5.provider import android.content.ContentResolver -import android.content.pm.ProviderInfo -import com.dbflow5.BaseUnitTest +import android.content.Context +import androidx.test.core.app.ApplicationProvider +import androidx.test.rule.provider.ProviderTestRule +import com.dbflow5.BaseInstrumentedUnitTest import com.dbflow5.config.database import com.dbflow5.query.Delete.Companion.table import com.dbflow5.query.Delete.Companion.tables import com.dbflow5.query.result import com.dbflow5.query.select import com.dbflow5.structure.exists -import org.junit.Assert.assertEquals -import org.junit.Assert.assertFalse -import org.junit.Assert.assertTrue -import org.junit.Before +import org.junit.Assert.* +import org.junit.Rule import org.junit.Test -import org.robolectric.Robolectric -import org.robolectric.RuntimeEnvironment /** * Description: */ -class ContentProviderTests : BaseUnitTest() { - private val mockContentResolver: ContentResolver - get() = RuntimeEnvironment.application.contentResolver +class ContentProviderTests : BaseInstrumentedUnitTest() { - @Before - fun setUp() { - val info = ProviderInfo() - info.authority = TestContentProvider.AUTHORITY - Robolectric.buildContentProvider(TestContentProvider_Provider::class.java).create(info) - } + @get:Rule + val contentProviderRule = ProviderTestRule.Builder(TestContentProvider_Provider::class.java, TestContentProvider.AUTHORITY).build() + + private val mockContentResolver: ContentResolver + get() = ApplicationProvider.getApplicationContext().contentResolver @Test fun testContentProviderUtils() { @@ -115,7 +110,7 @@ class ContentProviderTests : BaseUnitTest() { assertEquals(testSyncableModel.name, "TestName") testSyncableModel = (select from TestSyncableModel::class - where (TestSyncableModel_Table.id.`is`(testSyncableModel.id))).result!! + where (TestSyncableModel_Table.id.`is`(testSyncableModel.id))).result!! var fromContentProvider = TestSyncableModel(id = testSyncableModel.id) fromContentProvider = fromContentProvider.load(this)!! diff --git a/tests/src/test/java/com/dbflow5/provider/TestContentProvider.kt b/tests/src/androidTest/java/com/dbflow5/provider/TestContentProvider.kt similarity index 100% rename from tests/src/test/java/com/dbflow5/provider/TestContentProvider.kt rename to tests/src/androidTest/java/com/dbflow5/provider/TestContentProvider.kt diff --git a/tests/src/androidTest/java/com/dbflow5/sqlcipher/CipherTest.kt b/tests/src/androidTest/java/com/dbflow5/sqlcipher/CipherTest.kt index 35b31ce05..d8115b16c 100644 --- a/tests/src/androidTest/java/com/dbflow5/sqlcipher/CipherTest.kt +++ b/tests/src/androidTest/java/com/dbflow5/sqlcipher/CipherTest.kt @@ -15,7 +15,7 @@ class CipherTest : BaseInstrumentedUnitTest() { @Test fun testCipherModel() = database(CipherDatabase::class) { - (delete() from CipherModel::class).execute() + (delete() from CipherModel::class).execute(this) val model = CipherModel(name = "name") model.save(this) assertTrue(model.exists(this)) @@ -24,6 +24,6 @@ class CipherTest : BaseInstrumentedUnitTest() { where CipherModel_Table.name.eq("name")) .result assertTrue(retrieval!!.id == model.id) - (delete() from CipherModel::class).execute() + (delete() from CipherModel::class).execute(this) } } \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/BaseUnitTest.kt b/tests/src/test/java/com/dbflow5/BaseUnitTest.kt index aeaaa30ec..7de60c751 100644 --- a/tests/src/test/java/com/dbflow5/BaseUnitTest.kt +++ b/tests/src/test/java/com/dbflow5/BaseUnitTest.kt @@ -1,14 +1,12 @@ package com.dbflow5 import android.content.Context +import androidx.test.core.app.ApplicationProvider +import androidx.test.runner.AndroidJUnit4 import org.junit.Rule import org.junit.runner.RunWith -import org.robolectric.RobolectricTestRunner -import org.robolectric.RuntimeEnvironment -import org.robolectric.annotation.Config -@RunWith(RobolectricTestRunner::class) -@Config(manifest = Config.NONE) +@RunWith(AndroidJUnit4::class) abstract class BaseUnitTest { @JvmField @@ -16,5 +14,5 @@ abstract class BaseUnitTest { var dblflowTestRule = DBFlowTestRule.create() val context: Context - get() = RuntimeEnvironment.application + get() = ApplicationProvider.getApplicationContext() } \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/DBFlowTestRule.kt b/tests/src/test/java/com/dbflow5/DBFlowTestRule.kt index 349ed7ce8..e34aa845c 100644 --- a/tests/src/test/java/com/dbflow5/DBFlowTestRule.kt +++ b/tests/src/test/java/com/dbflow5/DBFlowTestRule.kt @@ -1,22 +1,21 @@ package com.dbflow5 import android.content.Context +import androidx.test.core.app.ApplicationProvider import com.dbflow5.config.DatabaseConfig import com.dbflow5.config.FlowConfig import com.dbflow5.config.FlowLog import com.dbflow5.config.FlowManager import com.dbflow5.database.AndroidSQLiteOpenHelper -import com.dbflow5.provider.ContentDatabase import com.dbflow5.runtime.DirectModelNotifier import org.junit.rules.TestRule import org.junit.runner.Description import org.junit.runners.model.Statement -import org.robolectric.RuntimeEnvironment class DBFlowTestRule : TestRule { val context: Context - get() = RuntimeEnvironment.application + get() = ApplicationProvider.getApplicationContext() override fun apply(base: Statement, description: Description): Statement { return object : Statement() { @@ -25,15 +24,11 @@ class DBFlowTestRule : TestRule { override fun evaluate() { FlowLog.setMinimumLoggingLevel(FlowLog.Level.V) DirectModelNotifier().clearListeners() - FlowManager.init(FlowConfig.Builder(RuntimeEnvironment.application) - .database(DatabaseConfig.Builder(TestDatabase::class, AndroidSQLiteOpenHelper.createHelperCreator(context)) - .transactionManagerCreator(::ImmediateTransactionManager2) + FlowManager.init(FlowConfig.Builder(context) + .database(DatabaseConfig.Builder(TestDatabase::class, AndroidSQLiteOpenHelper.createHelperCreator(context)) + .transactionManagerCreator(::ImmediateTransactionManager2) + .build()) .build()) - .database(DatabaseConfig.builder(ContentDatabase::class, - AndroidSQLiteOpenHelper.createHelperCreator(context)) - .databaseName("content") - .build()) - .build()) try { base.evaluate() } finally { diff --git a/tests/src/test/java/com/dbflow5/config/DatabaseConfigTest.kt b/tests/src/test/java/com/dbflow5/config/DatabaseConfigTest.kt index 72014a5ee..d27c8d3ee 100644 --- a/tests/src/test/java/com/dbflow5/config/DatabaseConfigTest.kt +++ b/tests/src/test/java/com/dbflow5/config/DatabaseConfigTest.kt @@ -1,6 +1,6 @@ package com.dbflow5.config -import com.nhaarman.mockito_kotlin.mock +import com.nhaarman.mockitokotlin2.mock import com.dbflow5.BaseUnitTest import com.dbflow5.TestDatabase import com.dbflow5.database.AndroidSQLiteOpenHelper diff --git a/tests/src/test/java/com/dbflow5/provider/RealContentProvider.kt b/tests/src/test/java/com/dbflow5/provider/RealContentProvider.kt deleted file mode 100644 index 0c3511599..000000000 --- a/tests/src/test/java/com/dbflow5/provider/RealContentProvider.kt +++ /dev/null @@ -1,42 +0,0 @@ -package com.dbflow5.provider - -import android.content.ContentProvider -import android.content.ContentValues -import android.database.Cursor -import android.net.Uri -import com.dbflow5.TestDatabase -import com.dbflow5.config.FlowConfig -import com.dbflow5.config.FlowManager -import com.dbflow5.config.database -import com.dbflow5.database.DatabaseWrapper - -class RealContentProvider : ContentProvider() { - - lateinit var database: DatabaseWrapper - - override fun onCreate(): Boolean { - FlowManager.init(FlowConfig.Builder(context).build()) - database = database() - return true - } - - override fun query(uri: Uri, projection: Array?, selection: String?, selectionArgs: Array?, sortOrder: String?): Cursor? { - return null - } - - override fun getType(uri: Uri): String? { - return null - } - - override fun insert(uri: Uri, values: ContentValues?): Uri? { - return null - } - - override fun delete(uri: Uri, selection: String?, selectionArgs: Array?): Int { - return 0 - } - - override fun update(uri: Uri, values: ContentValues?, selection: String?, selectionArgs: Array?): Int { - return 0 - } -} \ No newline at end of file diff --git a/tests/src/test/java/com/dbflow5/query/list/FlowCursorListTest.kt b/tests/src/test/java/com/dbflow5/query/list/FlowCursorListTest.kt index ddb9918e6..dcf4f4661 100644 --- a/tests/src/test/java/com/dbflow5/query/list/FlowCursorListTest.kt +++ b/tests/src/test/java/com/dbflow5/query/list/FlowCursorListTest.kt @@ -1,14 +1,14 @@ package com.dbflow5.query.list -import com.nhaarman.mockito_kotlin.mock -import com.nhaarman.mockito_kotlin.times -import com.nhaarman.mockito_kotlin.verify import com.dbflow5.BaseUnitTest import com.dbflow5.config.databaseForTable import com.dbflow5.models.SimpleModel import com.dbflow5.query.cursor import com.dbflow5.query.select import com.dbflow5.structure.save +import com.nhaarman.mockitokotlin2.mock +import com.nhaarman.mockitokotlin2.times +import com.nhaarman.mockitokotlin2.verify import org.junit.Assert.assertEquals import org.junit.Test @@ -22,8 +22,8 @@ class FlowCursorListTest : BaseUnitTest() { databaseForTable { val cursor = (select from SimpleModel::class).cursor val list = FlowCursorList.Builder(select from SimpleModel::class, this) - .cursor(cursor) - .build() + .cursor(cursor) + .build() assertEquals(cursor, list.cursor) } @@ -34,7 +34,7 @@ class FlowCursorListTest : BaseUnitTest() { databaseForTable { val modelQueriable = (select from SimpleModel::class) val list = FlowCursorList.Builder(modelQueriable, this) - .build() + .build() assertEquals(modelQueriable, list.modelQueriable) } diff --git a/tests/src/test/java/com/dbflow5/runtime/DirectNotifierTest.kt b/tests/src/test/java/com/dbflow5/runtime/DirectNotifierTest.kt index 6dd2e7591..1263fa8fa 100644 --- a/tests/src/test/java/com/dbflow5/runtime/DirectNotifierTest.kt +++ b/tests/src/test/java/com/dbflow5/runtime/DirectNotifierTest.kt @@ -1,8 +1,8 @@ package com.dbflow5.runtime import android.content.Context -import com.nhaarman.mockito_kotlin.mock -import com.nhaarman.mockito_kotlin.verify +import androidx.test.core.app.ApplicationProvider +import androidx.test.runner.AndroidJUnit4 import com.dbflow5.ImmediateTransactionManager2 import com.dbflow5.TestDatabase import com.dbflow5.config.DatabaseConfig @@ -22,21 +22,19 @@ import com.dbflow5.structure.delete import com.dbflow5.structure.insert import com.dbflow5.structure.save import com.dbflow5.structure.update +import com.nhaarman.mockitokotlin2.mock +import com.nhaarman.mockitokotlin2.verify import org.junit.After import org.junit.Before import org.junit.Test import org.junit.runner.RunWith import org.mockito.Mockito -import org.robolectric.RobolectricTestRunner -import org.robolectric.RuntimeEnvironment -import org.robolectric.annotation.Config -@RunWith(RobolectricTestRunner::class) -@Config(manifest = Config.NONE) +@RunWith(AndroidJUnit4::class) class DirectNotifierTest { val context: Context - get() = RuntimeEnvironment.application + get() = ApplicationProvider.getApplicationContext() @Before fun setupTest() { From 773d395f059e50be6b221e5d973bb224df07240c Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sat, 20 Oct 2018 15:11:58 -0400 Subject: [PATCH 221/234] [Documentation] update to kotlin usage. --- usage2/Intro.md | 113 ------------------------------- usage2/README.md | 7 ++ usage2/Relationships.md | 144 ++++++++++++---------------------------- 3 files changed, 48 insertions(+), 216 deletions(-) delete mode 100644 usage2/Intro.md diff --git a/usage2/Intro.md b/usage2/Intro.md deleted file mode 100644 index 5e06f124f..000000000 --- a/usage2/Intro.md +++ /dev/null @@ -1,113 +0,0 @@ -# DBFlow -## Outdated - use https://agrosner.gitbooks.io/dbflow/content - -DBFlow for Android lets you write very efficient database code while remaining -expressive and concise. -DBFlow fully supports Kotlin and public API reflects that via `@NonNull` and `@Nullable` annotations. - -```kotlin - -@Table(database = AppDatabase::class) -class Automobile(@PrimaryKey var vin: String? = null, - @Column var make: String? = null, - @Column var model: String = "", // nullability of kotlin fields respected - @Column var year: Int = 0) // default constructor required - -val venza = new Automobile(vin = "499499449", - make = "Toyota", - model = "Venza", - year = 2013) -venza.save() -// inserts if not exists by primary key, updates if exists. -// Kotlin extensions add methods found in BaseModel - -// querying -// SELECT * FROM `Automobile` WHERE `year`=2001 AND `model`='Camry' -// we autogen a "_Table" class that contains convenience Properties which provide easy SQL ops. -(select from Automobile:::class - where Automobile_Table.year.is(2001) - and Automobile_Table.model.is("Camry")).async() - -(select from Automobile::class - where Automobile_Table.year.`is`(2001) - and Automobile_Table.model.`is`("Camry")).async() - .queryResultCallback { transaction, tResult -> - // called when query returns on UI thread - val autos = tResult.toListClose() - // do something with results - } - .error { transaction, error -> - // handle any errors - }.execute() - - // run a transaction synchronous easily. - val database = database() - database.executeTransaction { - // do something here - } - - // run asynchronous transactions easily, with expressive builders - database.beginTransactionAsync { - // do something in BG - }.success { transaction -> - - }.error { transaction, error -> - - }.build().execute() - -``` - -## Proguard - -Since DBFlow uses annotation processing, which is run pre-proguard phase, -the configuration is highly minimal: - -``` --keep class * extends com.dbflow5.config.DatabaseHolder { *; } -``` - -## Sections - -For migrating from 3.x to 4.0, read [here](/usage2/Migration4Guide.md) - -The list of documentation is listed here: - - [Getting Started](/usage2/GettingStarted.md) - - [Databases](/usage2/Databases.md) - - [Models](/usage2/Models.md) - - [Relationships](/usage2/Relationships.md) - - [Storing Data](/usage2/StoringData.md) - - [Retrieval](/usage2/Retrieval.md) - - [The SQLite Wrapper Language](/usage2/SQLiteWrapperLanguage.md) - - [Caching](/usage2/Caching.md) - - [List-Based Queries](/usage2/ListBasedQueries.md) - - [Migrations](/usage2/Migrations.md) - - [Observability](/usage2/Observability.md) - - [Type Converters](/usage2/TypeConverters.md) - -For advanced DBFlow usages: - - [Kotlin Support](/usage2/KotlinSupport.md) - - [RX Java Support](/usage2/RXSupport.md) - - [Multiple Modules](/usage2/MultipleModules.md) - - [Views](/usage2/ModelViews.md) - - [Query Models](/usage2/QueryModels.md) - - [Indexing](/usage2/Indexing.md) - - [SQLCipher](/usage2/SQLCipherSupport.md) diff --git a/usage2/README.md b/usage2/README.md index ee93e2019..8cf5464b6 100644 --- a/usage2/README.md +++ b/usage2/README.md @@ -77,4 +77,11 @@ success = { transaction, result -> error = { transaction, error -> // handle any errors }) + +// use coroutines! +async { + database.awaitTransact( + delete() where SimpleModel_Table.name.eq("5")) { executeUpdateDelete(database) + } +} ``` diff --git a/usage2/Relationships.md b/usage2/Relationships.md index 48dc2a187..3748db323 100644 --- a/usage2/Relationships.md +++ b/usage2/Relationships.md @@ -8,21 +8,12 @@ We can link `@Table` in DBFlow via 1-1, 1-many, or many-to-many. For 1-1 we use DBFlow supports multiple `@ForeignKey` right out of the box as well (and for the most part, they can also be `@PrimaryKey`). -```java -@Table(database = AppDatabase.class) -public class Dog extends BaseModel { - - @PrimaryKey - String name; - - @ForeignKey(tableClass = Breed.class) - @PrimaryKey - String breed; - - @ForeignKey - Owner owner; -} - +```kotlin +@Table(database = AppDatabase::class) +class Dog(@PrimaryKey var name: String, + @ForeignKey(tableClass = Breed::class) + @PrimaryKey var breed: String, + @ForeignKey var owner: Owner? = null) ``` `@ForeignKey` can only be a subset of types: @@ -34,7 +25,9 @@ If you create a circular reference (i.e. two tables with strong references to `M ## Stubbed Relationships -For efficiency reasons we recommend specifying `@ForeignKey(stubbedRelationship = true)`. What this will do is only _preset_ the primary key references into a table object. All other fields will not be set. If you need to access the full object, you will have to call `load()` for `Model`, or use the `ModelAdapter` to load the object from the DB. +For efficiency reasons we recommend specifying `@ForeignKey(stubbedRelationship = true)`. What this will do is only _preset_ the primary key references into a table object. + + All other fields will not be set. If you need to access the full object, you will have to call `load()` for `Model`, or use the `ModelAdapter` to load the object from the DB. From our previous example of `Dog`, instead of using a `String` field for **breed** we recommended by using a `Breed`. It is nearly identical, but the difference being @@ -55,21 +48,13 @@ get you in a `StackOverFlowError` if two tables strongly reference each other in Our modified example now looks like this: -```java -@Table(database = AppDatabase.class) -public class Dog extends BaseModel { - - @PrimaryKey - String name; - - @ForeignKey(stubbedRelationship = true) - @PrimaryKey - Breed breed; // tableClass only needed for single-field refs that are not Model. - - @ForeignKey(stubbedRelationship = true) - Owner owner; -} - +```kotlin +@Table(database = AppDatabase::class) +class Dog(@PrimaryKey var name: String, + @ForeignKey(stubbedRelationship = true) + @PrimaryKey var breed: Breed? = null, + @ForeignKey(stubbedRelationship = true) + var owner: Owner? = null) ``` ## One To Many @@ -77,34 +62,18 @@ public class Dog extends BaseModel { In DBFlow, `@OneToMany` is an annotation that you provide to a method in your `Model` class that will allow management of those objects during CRUD operations. This can allow you to combine a relationship of objects to a single `Model` to happen together on load, save, insert, update, and deletion. -```java - -@Table(database = ColonyDatabase.class) -public class Queen extends BaseModel { - - @PrimaryKey(autoincrement = true) - long id; - - @Column - String name; - - @ForeignKey(saveForeignKeyModel = false) - Colony colony; +```kotlin +@Table(database = ColonyDatabase::class) +class Queen(@PrimaryKey(autoincrement = true) + var id: Long = 0, + var name: String? = null, + @ForeignKey(saveForeignKeyModel = false) + var colony: Colony? = null) : BaseModel() { - List ants; + @get:OneToMany + val ants: List? by oneToMany { select from Ant::class where Ant_Table.queen_id.eq(id) } - @OneToMany(methods = {OneToMany.Method.ALL}, variableName = "ants") - public List getMyAnts() { - if (ants == null || ants.isEmpty()) { - ants = SQLite.select() - .from(Ant.class) - .where(Ant_Table.queen_id.eq(id)) - .queryList(); - } - return ants; - } } - ``` ### Efficient Methods @@ -113,50 +82,26 @@ If you have nested `@ManyToMany` (which should strongly be avoided), you can tur Call `@OneToMany(efficientMethods = false)` and it will instead loop through each model and perform `save()`, `delete()`, etc when the parent model is called. -### Kotlin Support - -Also, with DBFlow Kotlin extensions, we can make this much more concise: -```kotlin - -@get:OneToMany(methods = arrayOf(OneToMany.Method.ALL)) -var ants by oneToMany { select from Ant::class where (Ant_Table.queen_id.eq(id)) } -``` - -This creates a delegated property which does the same operation as above. The only difference is the -variable is nullable. - ### Custom ForeignKeyReferences When simple `@ForeignKey` annotation is not enough, you can manually specify references for your table: -```java +```kotlin @ForeignKey(saveForeignKeyModel = false, -references = {@ForeignKeyReference(columnName = "colony", foreignKeyColumnName = "id")}) -Colony colony; +references = {ForeignKeyReference(columnName = "colony", foreignKeyColumnName = "id")}) +var colony: Colony? = null; ``` By default not specifying references will take each field and append "${foreignKeyFieldName}_${ForeignKeyReferenceColumnName}" to make the reference column name. So by default the previous example would use `colony_id` without references. With references it becomes `colony`. ## Many To Many - - In DBFlow many to many is done via source-gen. A simple table: -```java - -@Table(database = TestDatabase.class) -@ManyToMany(referencedTable = Follower.class) -public class User extends BaseModel { - - @PrimaryKey - String name; - - @PrimaryKey - int id; - -} - +```kotlin +@Table(database = AppDatabase::class) +@ManyToMany(referencedTable = Follower::class) +class User(@PrimaryKey var id: Int = 0, @PrimaryKey var name: String = "") ``` Generates a `@Table` class named `User_Follower`, which DBFlow treats as if you @@ -226,20 +171,13 @@ than a single `@ManyToMany` relationship on the table. A class can use both: -```java -@Table(database = TestDatabase.class) -@ManyToMany(referencedTable = TestModel1.class) -@MultipleManyToMany({@ManyToMany(referencedTable = TestModel2.class), - @ManyToMany(referencedTable = com.dbflow5.test.sql.TestModel3.class)}) -public class ManyToManyModel extends BaseModel { - - @PrimaryKey - String name; - - @PrimaryKey - int id; - - @Column - char anotherColumn; -} +```kotlin +@Table(database = TestDatabase::class) +@ManyToMany(referencedTable = TestModel1::class) +@MultipleManyToMany({@ManyToMany(referencedTable = TestModel2::class), + @ManyToMany(referencedTable = TestModel3::class)}) +class ManyToManyModel( + @PrimaryKey var name: String = "", + @PrimaryKey var id: Int = 0, + @PrimaryKey var anotherColumn: Char? = null) ``` From cc6e7c0c5d396140b503c86877e5716d279780da Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sat, 20 Oct 2018 20:19:56 -0400 Subject: [PATCH 222/234] [Documentation] update to kotlin usage for some of the files. rework Transaction.execute to supply the callbacks for success, error, and completion into the execute call. --- .../com/dbflow5/config/DBFlowDatabase.kt | 22 ---- .../com/dbflow5/query/ModelQueriable.kt | 15 ++- .../com/dbflow5/transaction/Transaction.kt | 21 ++-- usage2/Retrieval.md | 101 +++++------------- 4 files changed, 55 insertions(+), 104 deletions(-) diff --git a/lib/src/main/kotlin/com/dbflow5/config/DBFlowDatabase.kt b/lib/src/main/kotlin/com/dbflow5/config/DBFlowDatabase.kt index fbab7d2a4..182ef2b72 100644 --- a/lib/src/main/kotlin/com/dbflow5/config/DBFlowDatabase.kt +++ b/lib/src/main/kotlin/com/dbflow5/config/DBFlowDatabase.kt @@ -23,9 +23,7 @@ import com.dbflow5.structure.BaseModelView import com.dbflow5.transaction.BaseTransactionManager import com.dbflow5.transaction.DefaultTransactionManager import com.dbflow5.transaction.DefaultTransactionQueue -import com.dbflow5.transaction.Error import com.dbflow5.transaction.ITransaction -import com.dbflow5.transaction.Success import com.dbflow5.transaction.Transaction /** @@ -276,26 +274,6 @@ abstract class DBFlowDatabase : DatabaseWrapper { return notifier } - /** - * Executes and returns the executed transaction. - */ - fun executeTransactionAsync(transaction: ITransaction, - success: (Success)? = null, - error: (Error)? = null): Transaction = beginTransactionAsync(transaction) - .success(success) - .error(error) - .execute() - - /** - * Executes and returns the executed transaction. - */ - fun executeTransactionAsync(transaction: (DatabaseWrapper) -> R, - success: (Success)? = null, - error: (Error)? = null): Transaction = beginTransactionAsync(transaction) - .success(success) - .error(error) - .execute() - fun beginTransactionAsync(transaction: ITransaction): Transaction.Builder = Transaction.Builder(transaction, this) diff --git a/lib/src/main/kotlin/com/dbflow5/query/ModelQueriable.kt b/lib/src/main/kotlin/com/dbflow5/query/ModelQueriable.kt index 074999ad8..3cc69ebb2 100644 --- a/lib/src/main/kotlin/com/dbflow5/query/ModelQueriable.kt +++ b/lib/src/main/kotlin/com/dbflow5/query/ModelQueriable.kt @@ -3,6 +3,7 @@ package com.dbflow5.query import com.dbflow5.config.DBFlowDatabase import com.dbflow5.config.databaseForTable import com.dbflow5.database.DatabaseWrapper +import com.dbflow5.database.SQLiteException import com.dbflow5.query.list.FlowCursorList import com.dbflow5.query.list.FlowQueryList import com.dbflow5.structure.BaseQueryModel @@ -45,7 +46,7 @@ interface ModelQueriable : Queriable { * Returns a [List] based on the custom [TQueryModel] you pass in. * * @param queryModelClass The query model class to use. - * @param The class that extends [BaseQueryModel] + * @param The class that extends [BaseueryModel] * @return A list of custom models that are not tied to a table. */ fun queryCustomList(queryModelClass: Class, @@ -70,21 +71,27 @@ interface ModelQueriable : Queriable { fun async(databaseWrapper: DBFlowDatabase, modelQueriableFn: ModelQueriable.(DatabaseWrapper) -> R) = - databaseWrapper.beginTransactionAsync { modelQueriableFn(it) } + databaseWrapper.beginTransactionAsync { modelQueriableFn(it) } } internal inline val ModelQueriable.enclosedQuery - get() = "(${query.trim({ it <= ' ' })})" + get() = "(${query.trim { it <= ' ' }})" inline val ModelQueriable.list get() = queryList(databaseForTable()) +inline fun ModelQueriable<*>.customList() = + queryCustomList(T::class.java, databaseForTable()) + +inline fun ModelQueriable<*>.customSingle() = + queryCustomSingle(T::class.java, databaseForTable()) + inline val ModelQueriable.result get() = querySingle(databaseForTable()) inline val ModelQueriable.requireResult - get() = result!! + get() = result ?: throw SQLiteException("Model result not found for $this") inline val ModelQueriable.flowQueryList get() = flowQueryList(databaseForTable()) diff --git a/lib/src/main/kotlin/com/dbflow5/transaction/Transaction.kt b/lib/src/main/kotlin/com/dbflow5/transaction/Transaction.kt index 976364105..6d89e73e8 100644 --- a/lib/src/main/kotlin/com/dbflow5/transaction/Transaction.kt +++ b/lib/src/main/kotlin/com/dbflow5/transaction/Transaction.kt @@ -132,24 +132,26 @@ class Transaction( /** * Specify an error callback to return all and any [Throwable] that occured during a [Transaction]. + * @param error Invoked on the UI thread, unless [runCallbacksOnSameThread] is true. */ - fun error(errorCallback: Error?) = apply { - this.errorCallback = errorCallback + fun error(error: Error?) = apply { + this.errorCallback = error } /** * Specify a listener for successful transactions. This is called when the [ITransaction] * specified is finished and it is posted on the UI thread. * - * @param successCallback The callback, invoked on the UI thread. + * @param success The callback, invoked on the UI thread, unless [runCallbacksOnSameThread] is true. */ - fun success(successCallback: Success?) = apply { - this.successCallback = successCallback + fun success(success: Success?) = apply { + this.successCallback = success } /** * Runs exactly once, no matter if it was successful or failed, at the end of the execution * of this transaction. + * @param completion Invoked on the UI thread, unless [runCallbacksOnSameThread] is true. */ fun completion(completion: Completion?) = apply { this.completion = completion @@ -193,7 +195,14 @@ class Transaction( /** * Convenience method to simply execute a transaction. */ - fun execute() = build().execute() + @JvmOverloads + fun execute(error: Error? = null, completion: Completion? = null, + success: Success? = null) = + this.apply { + success?.let(this::success) + error?.let(this::error) + completion?.let(this::completion) + }.build().execute() } companion object { diff --git a/usage2/Retrieval.md b/usage2/Retrieval.md index d4148dbfd..b301835ae 100644 --- a/usage2/Retrieval.md +++ b/usage2/Retrieval.md @@ -14,29 +14,28 @@ Using the [SQLite query language](SQLiteWrapperLanguage.md) we can retrieve data easily and expressively. To perform it synchronously: -```java +```kotlin // list -List employees = SQLite.select() - .from(Employee.class) - .queryList(); +val employees = (select from Employee:class).list // single result, we apply a limit(1) automatically to get the result even faster. -Employee employee = SQLite.select() - .from(Employee.class) - .where(Employee_Table.name.eq("Andrew Grosner")) - .querySingle(); +val employee: Employee? = (select from Employee::class + where Employee_Table.name.eq("Andrew Grosner")).result + +// can require result to get non-null if you know it exists +// throws a SQLiteException if missing +val employee: Employee? = (select from Employee::class + where Employee_Table.name.eq("Andrew Grosner")).requireResult // get a custom list -List employees = SQLite.select() - .from(Employee.class) - .queryCustomList(AnotherTable.class); +val employees = (select from Employee::class) + .customList(database) // custom object -AnotherTable anotherObject = SQLite.select() - .from(Employee.class) - .where(Employee_Table.name.eq("Andrew Grosner")) - .queryCustomSingle(AnotherTable.class); +val anotherObject = (select from Employee::class + where(Employee_Table.name.eq("Andrew Grosner"))) + .customSingle(); ``` @@ -44,73 +43,31 @@ To query custom objects or lists, see how to do so in [QueryModel](QueryModels.m Also you can query a `FlowCursorList`/`FlowTableList` from a query easily via `queryCursorList()` and the `queryTableList()` methods. To see more on these, -go to [Flow Lists](FlowLists.md). - +go to [Flow Lists](ListBasedQueries.md). ## Asynchronous Retrieval DBFlow provides the very-handy `Transaction` system that allows you to place all -calls to the DB in a queue. Using this system, we recommend placing retrieval queries +calls to the DB in a background queue. Using this system, we recommend placing retrieval queries on this queue to help prevent locking and threading issues when using a database. -A quick sample of retrieving data asyncly: - -```java - -SQLite.select() - .from(TestModel1.class) - .where(TestModel1_Table.name.is("Async")) - .async() - .queryResultCallback(new QueryTransaction.QueryResultCallback() { - @Override - public void onQueryResult(QueryTransaction transaction, @NonNull CursorResult tResult) { - - } - }).execute(); - -``` - -This is fundamentally equal to: +We wrap our queries in a `beginTransactionAsync` block, executing and providing call backs to the method as follows: ```java - -FlowManager.getDatabaseForTable(TestModel1.class) - .beginTransactionAsync(new QueryTransaction.Builder<>( - SQLite.select() - .from(TestModel1.class) - .where(TestModel1_Table.name.is("Async"))) - .queryResult(new QueryTransaction.QueryResultCallback() { - @Override - public void onQueryResult(QueryTransaction transaction, @NonNull CursorResult tResult) { - - } - }).build()) -.build().execute(); - +database.beginTransactionAsync { db -> + (select from TestModel1::class + where TestModel1_Table.name.is("Async")).querySingle(db) + } + .execute( + success = { transaction, r -> }, // if successful + error = { transaction, throwable -> }, // any exception thrown is put here + completion = { transaction -> }) // always called success or failure ``` -The first example in this section is more of a convenience for (2). - -By default the library uses the `DefaultTransactionManager` which utilizes -a `DefaultTransactionQueue`. This queue is essentially an ordered queue that -executes FIFO (first-in-first-out) and blocks itself until new `Transaction` are added. - -If you wish to customize and provide a different queue (or map it to an existing system), read up on [Transactions](StoringData.md). - - -Compared to pre-3.0 DBFlow, this is a breaking change from the old, priority-based -queue system. The reason for this change was to simplify the queuing system and -allow other systems to exist without confusing loss of functionality. To keep the old -system read [Transactions](StoringData.md). - -## Faster Retrieval +A `ITransaction` simply returns a result, `R` , which could be a query, or a result from multiple queries combined into one result. -In an effort to squeeze out more speed at the potential cost of flexibility, DBFlow provides a -couple ways to optimize loads from the DB. If you do not wish to use caching but wish -to speed conversion from `Cursor` to `Model`, read on. +By default the library uses an ordered queue that +executes FIFO (first-in-first-out) and blocks itself until new `Transaction` are added. Each subsequent call to the `database.beginTransactionAsync` places a new transaction on this queue. - If you simply retrieve a `List` of `Model` -without any projection from your DB, you can take advantage of 2 features: - 1. `@Table(orderedCursorLookUp = true)` -> We do not call `Cursor.getColumnIndex()` and assume that the `Cursor` is ordered by column declarations in the class. - 2. `@Table(assignDefaultValuesFromCursor = false)` -> We do not expect to reuse an object from the DB (or care) if the corresponding fields aren't assigned a value when missing from the `Cursor`. +If you wish to customize and provide a different queue (or map it to an existing system), read up on [Transactions](StoringData.md). We also provide constructs such as coroutines and RX `Observables` to map to your team's needs. From b03d9e5cbb3e6f4b6e23d427178cabc7f67bedc5 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sat, 20 Oct 2018 21:11:56 -0400 Subject: [PATCH 223/234] [Database] replace usage of executeTransactionAsync to begin version to fix changes. --- .../database/DatabaseHelperDelegate.kt | 34 +++++++++---------- .../com/dbflow5/paging/QueryDataSource.kt | 22 ++++++------ .../dbflow5/provider/ContentProviderTests.kt | 5 ++- 3 files changed, 29 insertions(+), 32 deletions(-) diff --git a/lib/src/main/kotlin/com/dbflow5/database/DatabaseHelperDelegate.kt b/lib/src/main/kotlin/com/dbflow5/database/DatabaseHelperDelegate.kt index a44d473c4..11b7d9193 100644 --- a/lib/src/main/kotlin/com/dbflow5/database/DatabaseHelperDelegate.kt +++ b/lib/src/main/kotlin/com/dbflow5/database/DatabaseHelperDelegate.kt @@ -15,10 +15,10 @@ import java.io.InputStream * used in other helper class definitions. */ class DatabaseHelperDelegate( - context: Context, - private var databaseCallback: DatabaseCallback?, - databaseDefinition: DBFlowDatabase, - private val backupHelper: OpenHelper?) + context: Context, + private var databaseCallback: DatabaseCallback?, + databaseDefinition: DBFlowDatabase, + private val backupHelper: OpenHelper?) : BaseDatabaseHelper(context, databaseDefinition) { /** @@ -43,12 +43,12 @@ class DatabaseHelperDelegate( fun performRestoreFromBackup() { movePrepackagedDB(databaseDefinition.databaseFileName, - databaseDefinition.databaseFileName) + databaseDefinition.databaseFileName) if (databaseDefinition.backupEnabled()) { if (backupHelper == null) { throw IllegalStateException("the passed backup helper was null, even though backup" + - " is enabled. Ensure that its passed in.") + " is enabled. Ensure that its passed in.") } restoreDatabase(tempDbFileName, databaseDefinition.databaseFileName) backupHelper.database @@ -108,10 +108,10 @@ class DatabaseHelperDelegate( val inputStream: InputStream // if it exists and the integrity is ok we use backup as the main DB is no longer valid inputStream = if (existingDb.exists() - && (!databaseDefinition.backupEnabled() || - (databaseDefinition.backupEnabled() - && backupHelper != null - && isDatabaseIntegrityOk(backupHelper.database)))) { + && (!databaseDefinition.backupEnabled() || + (databaseDefinition.backupEnabled() + && backupHelper != null + && isDatabaseIntegrityOk(backupHelper.database)))) { FileInputStream(existingDb) } else { context.assets.open(prepackagedName) @@ -224,8 +224,8 @@ class DatabaseHelperDelegate( val inputStream: InputStream // if it exists and the integrity is ok inputStream = if (existingDb.exists() - && (databaseDefinition.backupEnabled() && backupHelper != null - && isDatabaseIntegrityOk(backupHelper.database))) { + && (databaseDefinition.backupEnabled() && backupHelper != null + && isDatabaseIntegrityOk(backupHelper.database))) { FileInputStream(existingDb) } else { context.assets.open(prepackagedName) @@ -245,11 +245,11 @@ class DatabaseHelperDelegate( fun backupDB() { if (!databaseDefinition.backupEnabled() || !databaseDefinition.areConsistencyChecksEnabled()) { throw IllegalStateException("Backups are not enabled for : " + - "${databaseDefinition.databaseName}. Please consider adding both backupEnabled " + - "and consistency checks enabled to the Database annotation") + "${databaseDefinition.databaseName}. Please consider adding both backupEnabled " + + "and consistency checks enabled to the Database annotation") } - databaseDefinition.executeTransactionAsync({ + databaseDefinition.beginTransactionAsync { val backup = context.getDatabasePath(tempDbFileName) val temp = context.getDatabasePath("$TEMP_DB_NAME-2-${databaseDefinition.databaseFileName}") @@ -272,7 +272,7 @@ class DatabaseHelperDelegate( FlowLog.logError(e) } - }) + }.execute() } @@ -281,6 +281,6 @@ class DatabaseHelperDelegate( val TEMP_DB_NAME = "temp-" fun getTempDbFileName(databaseDefinition: DBFlowDatabase): String = - "$TEMP_DB_NAME${databaseDefinition.databaseName}.db" + "$TEMP_DB_NAME${databaseDefinition.databaseName}.db" } } diff --git a/paging/src/main/kotlin/com/dbflow5/paging/QueryDataSource.kt b/paging/src/main/kotlin/com/dbflow5/paging/QueryDataSource.kt index 8f68dc582..9a2d50b29 100644 --- a/paging/src/main/kotlin/com/dbflow5/paging/QueryDataSource.kt +++ b/paging/src/main/kotlin/com/dbflow5/paging/QueryDataSource.kt @@ -41,27 +41,25 @@ internal constructor(private val transformable: TQuery, } override fun loadRange(params: LoadRangeParams, callback: LoadRangeCallback) { - database.executeTransactionAsync({ + database.beginTransactionAsync { db -> transformable.constrain(params.startPosition.toLong(), params.loadSize.toLong()) - .queryList(database) - }, - success = { _, list -> callback.onResult(list) }) + .queryList(db) + }.execute { _, list -> callback.onResult(list) } } override fun loadInitial(params: LoadInitialParams, callback: LoadInitialCallback) { - database.executeTransactionAsync({ db -> selectCountOf().from(transformable).longValue(db) }, - success = { _, count -> + database.beginTransactionAsync { db -> selectCountOf().from(transformable).longValue(db) } + .execute { _, count -> val max = when { params.requestedLoadSize >= count - 1 -> count.toInt() else -> params.requestedLoadSize } - database.executeTransactionAsync({ db -> + database.beginTransactionAsync { db -> transformable.constrain(params.requestedStartPosition.toLong(), max.toLong()).queryList(db) - }, - success = { _, list -> - callback.onResult(list, params.requestedStartPosition, count.toInt()) - }) - }) + }.execute { _, list -> + callback.onResult(list, params.requestedStartPosition, count.toInt()) + } + } } class Factory diff --git a/tests/src/androidTest/java/com/dbflow5/provider/ContentProviderTests.kt b/tests/src/androidTest/java/com/dbflow5/provider/ContentProviderTests.kt index 932b25cdb..512cab2d9 100644 --- a/tests/src/androidTest/java/com/dbflow5/provider/ContentProviderTests.kt +++ b/tests/src/androidTest/java/com/dbflow5/provider/ContentProviderTests.kt @@ -6,7 +6,6 @@ import androidx.test.core.app.ApplicationProvider import androidx.test.rule.provider.ProviderTestRule import com.dbflow5.BaseInstrumentedUnitTest import com.dbflow5.config.database -import com.dbflow5.query.Delete.Companion.table import com.dbflow5.query.Delete.Companion.tables import com.dbflow5.query.result import com.dbflow5.query.select @@ -98,7 +97,7 @@ class ContentProviderTests : BaseInstrumentedUnitTest() { @Test fun testSyncableModel() { database(ContentDatabase::class) { - table(this, TestSyncableModel::class.java) + com.dbflow5.query.delete().execute(this) var testSyncableModel = TestSyncableModel(name = "Name") testSyncableModel.save() @@ -121,7 +120,7 @@ class ContentProviderTests : BaseInstrumentedUnitTest() { testSyncableModel.delete() assertFalse(testSyncableModel.exists()) - table(this, TestSyncableModel::class.java) + com.dbflow5.query.delete().execute(this) } } From 4c94a744361f0ff2264dc8ab0675acdc9d7b0942 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sat, 20 Oct 2018 21:12:33 -0400 Subject: [PATCH 224/234] [Delete] remove static methods, and require use of SQLite file. --- .../main/kotlin/com/dbflow5/query/Delete.kt | 33 --- usage2/SQLCipherSupport.md | 38 +-- usage2/SQLiteWrapperLanguage.md | 227 ++++++++---------- 3 files changed, 118 insertions(+), 180 deletions(-) diff --git a/lib/src/main/kotlin/com/dbflow5/query/Delete.kt b/lib/src/main/kotlin/com/dbflow5/query/Delete.kt index 210047780..52e7f3fc4 100644 --- a/lib/src/main/kotlin/com/dbflow5/query/Delete.kt +++ b/lib/src/main/kotlin/com/dbflow5/query/Delete.kt @@ -1,6 +1,5 @@ package com.dbflow5.query -import com.dbflow5.database.DatabaseWrapper import com.dbflow5.sql.Query import kotlin.reflect.KClass @@ -23,37 +22,5 @@ class Delete internal constructor() : Query { infix fun from(table: KClass): From = from(table.java) - companion object { - - @JvmStatic - fun delete(modelClass: KClass) = delete(modelClass.java) - - @JvmStatic - inline fun delete() = delete(T::class) - - /** - * Deletes the specified table - * - * @param table The table to delete - * @param conditions The list of conditions to use to delete from the specified table - * @param [T] The class that implements [com.dbflow5.structure.Model] - */ - @JvmStatic - fun table(databaseWrapper: DatabaseWrapper, - table: Class, - vararg conditions: SQLOperator): Long = - delete(table).where(*conditions).executeUpdateDelete(databaseWrapper) - - /** - * Deletes the list of tables specified. - * WARNING: this will completely clear all rows from each table. - * - * @param tables The list of tables to wipe. - */ - @JvmStatic - fun DatabaseWrapper.tables(vararg tables: Class<*>) { - tables.forEach { table(this, it) } - } - } } diff --git a/usage2/SQLCipherSupport.md b/usage2/SQLCipherSupport.md index 1bafc61f0..12fcc48ce 100644 --- a/usage2/SQLCipherSupport.md +++ b/usage2/SQLCipherSupport.md @@ -6,9 +6,8 @@ To add the library add the library to your `build.gradle` with same version you ```groovy dependencies { - compile "com.github.agrosner.dbflow:sqlcipher:${version}" - compile "net.zetetic:android-database-sqlcipher:${sqlcipher_version}@aar" - + implementation "com.dbflow5:sqlcipher:${version}" + implementation "net.zetetic:android-database-sqlcipher:${sqlcipher_version}@aar" } ``` @@ -20,17 +19,12 @@ You also need to add the Proguard rule: Next, you need to subclass the provided `SQLCipherOpenHelper` (taken from test files): -```java -public class SQLCipherHelperImpl extends SQLCipherOpenHelper { - - public SQLCipherHelperImpl(DatabaseDefinition databaseDefinition, DatabaseHelperListener listener) { - super(databaseDefinition, listener); - } - - @Override - protected String getCipherSecret() { - return "dbflow-rules"; - } +```kotlin +class SQLCipherOpenHelperImpl(context: Context, + databaseDefinition: DBFlowDatabase, + callback: DatabaseCallback?) + : SQLCipherOpenHelper(context, databaseDefinition, callback) { + override val cipherSecret get() = "dbflow-rules" } ``` @@ -38,20 +32,12 @@ _Note:_ that the constructor with `DatabaseDefinition` and `DatabaseHelperListen Then in your application class when initializing DBFlow: -```java - -FlowManager.init(new FlowConfig.Builder(this) +```kotlin +FlowManager.init(FlowConfig.Builder(this) .database( - new DatabaseConfig.Builder(CipherDatabase.class) - .openHelper(new DatabaseConfig.OpenHelperCreator() { - @Override - public OpenHelper createHelper(DatabaseDefinition databaseDefinition, DatabaseHelperListener callback) { - return new SQLCipherHelperImpl(databaseDefinition, callback); - } - }) + DatabaseConfig.Builder(CipherDatabase::class) { db, callback -> SQLCipherHelperImpl(databaseDefinition, callback)) .build()) - .build()); - + .build()) ``` And that's it. You're all set to start using SQLCipher! diff --git a/usage2/SQLiteWrapperLanguage.md b/usage2/SQLiteWrapperLanguage.md index 9780121a9..212da13c9 100644 --- a/usage2/SQLiteWrapperLanguage.md +++ b/usage2/SQLiteWrapperLanguage.md @@ -10,10 +10,8 @@ for how to formulate queries, as DBFlow follows it as much as possible. The way to query data, `SELECT` are started by: -```java - -SQLite.select().from(SomeTable.class) - +```kotlin +select from SomeTable::class ``` ### Projections @@ -24,20 +22,20 @@ meaning all columns are returned in the results. To specify individual columns, you _must_ use `Property` variables. These get generated when you annotate your `Model` with columns, or created manually. -```java +```kotlin -SQLite.select(Player_Table.name, Player_Table.position) - .from(Player.class) +select(Player_Table.name, Player_Table.position) + from Player::class ``` To specify methods such as `COUNT()` or `SUM()` (static import on `Method`): -```java +```kotlin -SQLite.select(count(Employee_Table.name), sum(Employee_Table.salary)) - .from(Employee.class) +select(count(Employee_Table.name), sum(Employee_Table.salary)) + from Employee::class ``` @@ -60,14 +58,12 @@ which represent a set of `SQLOperator` subclasses combined into a SQLite conditi They make it very easy to construct concise and meaningful queries: -```java - -int taxBracketCount = SQLite.select(count(Employee_Table.name)) - .from(Employee.class) - .where(Employee_Table.salary.lessThan(150000)) - .and(Employee_Table.salary.greaterThan(80000)) - .count(); - +```kotlin +val taxBracketCount = (select(count(Employee_Table.name)) + from Employee::class + where Employee_Table.salary.lessThan(150000) + and Employee_Table.salary.greaterThan(80000)) + .count(database) ``` Translates to: @@ -96,16 +92,12 @@ To create nested conditions (in parenthesis more often than not), just include an `OperatorGroup` as a `SQLOperator` in a query: -```java - -SQLite.select() - .from(Location.class) - .where(Location_Table.latitude.eq(home.getLatitude())) - .and(OperatorGroup.clause() - .and(Location_Table.latitude - .minus(PropertyFactory.from(home.getLatitude()) - .eq(1000L)))) - +```kotlin +(select from Location::class + where Location_Table.latitude.eq(home.latitude) + and (Location_Table.latitude + - home.latitude) eq 1000L + ) ``` Translates to: @@ -118,12 +110,10 @@ SELECT * FROM `Location` WHERE `latitude`=45.05 AND (`latitude` - 45.05) = 1000 #### Nested Queries -To create a nested query simply include it as a `Property` via `PropertyFactory.from(BaseQueriable)`: - -```java - -.where(PropertyFactory.from(SQLite.select().from(...).where(...)) +To create a nested query simply include a query as a `Property` via `(query).property`: +```kotlin +.where((select from(...) where(...)).property) ``` This appends a `WHERE (SELECT * FROM {table} )` to the query. @@ -142,15 +132,14 @@ For example we have a table named `Customer` and another named `Reservations`. SELECT FROM `Customer` AS `C` INNER JOIN `Reservations` AS `R` ON `C`.`customerId`=`R`.`customerId` ``` -```java +```kotlin // use the different QueryModel (instead of Table) if the result cannot be applied to existing Model classes. -List customers = new Select() - .from(Customer.class).as("C") - .join(Reservations.class, JoinType.INNER).as("R") - .on(Customer_Table.customerId - .withTable(NameAlias.builder("C").build()) - .eq(Reservations_Table.customerId.withTable("R")) - .queryCustomList(CustomTable.class); +val customers = (select from Customer::class).as("C") + innerJoin().as("R") + on(Customer_Table.customerId + .withTable("C".nameAlias) + eq Reservations_Table.customerId.withTable("R")) + .customList()); ``` The `IProperty.withTable()` method will prepend a `NameAlias` or the `Table` alias to the `IProperty` in the query, convenient for JOIN queries: @@ -162,50 +151,45 @@ SELECT EMP_ID, NAME, DEPT FROM COMPANY LEFT OUTER JOIN DEPARTMENT in DBFlow: -```java -SQLite.select(Company_Table.EMP_ID, Company_Table.DEPT) - .from(Company.class) - .leftOuterJoin(Department.class) +```kotlin +(select(Company_Table.EMP_ID, Company_Table.DEPT) + from Company::class + leftOuterJoin() .on(Company_Table.ID.withTable().eq(Department_Table.EMP_ID.withTable())) +) ``` ### Order By -```java +```kotlin -// true for 'ASC', false for 'DESC' -SQLite.select() - .from(table) - .where() - .orderBy(Customer_Table.customer_id, true) - - SQLite.select() - .from(table) - .where() - .orderBy(Customer_Table.customer_id, true) - .orderBy(Customer_Table.name, false) +// true for 'ASC', false for 'DESC'. ASC is default. +(select from table + orderBy(Customer_Table.customer_id) + + (select from table + orderBy(Customer_Table.customer_id, ascending = true) + orderBy(Customer_Table.name, ascending = false)) ``` ### Group By -```java -SQLite.select() - .from(table) +```kotlin +(select from table) .groupBy(Customer_Table.customer_id, Customer_Table.customer_name) ``` ### HAVING -```java -SQLite.select() - .from(table) +```kotlin +(select from table) .groupBy(Customer_Table.customer_id, Customer_Table.customer_name)) .having(Customer_Table.customer_id.greaterThan(2)) ``` ### LIMIT + OFFSET -```java +```kotlin SQLite.select() .from(table) .limit(3) @@ -231,15 +215,15 @@ UPDATE Ant SET type = 'other' WHERE male = 1 AND type = 'worker'; Using DBFlow: -```java +```kotlin // Native SQL wrapper -SQLite.update(Ant.class) - .set(Ant_Table.type.eq("other")) - .where(Ant_Table.type.is("worker")) - .and(Ant_Table.isMale.is(true)) - .async() - .execute(); // non-UI blocking +database.beginTransactionAsync { db -> (update() + set Ant_Table.type.eq("other") + where Ant_Table.type.is("worker") + and Ant_Table.isMale.is(true)) + .executeUpdateDelete(db) + }.execute { _, count -> }; // non-UI blocking ``` The `Set` part of the `Update` supports different kinds of values: @@ -259,20 +243,17 @@ section we speak on (2). **Note:** if using model caching, you'll need to clear post an operation from (2). -```java +```kotlin // Delete a whole table -Delete.table(MyTable.class); - -// Delete multiple instantly -Delete.tables(MyTable1.class, MyTable2.class); +delete().execute(database) // Delete using query -SQLite.delete(MyTable.class) - .where(DeviceObject_Table.carrier.is("T-MOBILE")) - .and(DeviceObject_Table.device.is("Samsung-Galaxy-S5")) - .async() - .execute(); +database.beginTransactionAsync { db -> delete() + where DeviceObject_Table.carrier.is("T-MOBILE") + and DeviceObject_Table.device.is("Samsung-Galaxy-S5")) + .executeUpdateDelete(db) + }.execute { _, count -> }; ``` ## INSERT @@ -288,44 +269,43 @@ For powerful multiple `Model` insertion that can span many rows, use (2). In thi section we speak on (2). **Note:** using model caching, you'll need to clear it out post an operation from (2). -```java +```kotlin -// columns + values separately -SQLite.insert(SomeTable.class) - .columns(SomeTable_Table.name, SomeTable_Table.phoneNumber) - .values("Default", "5555555") - .async() - .execute() +// columns + values via pairs +database.beginTransactionAsync { db -> + (insert(SomeTable_Table.name to "Default", + MSomeTable_Table.phoneNumber to "5555555") + .executeInsert(db) +}.execute() // or combine into Operators - SQLite.insert(SomeTable.class) - .columnValues(SomeTable_Table.name.eq("Default"), - SomeTable_Table.phoneNumber.eq("5555555")) - .async() - .execute() - +database.beginTransactionAsync { db -> + (insert(SomeTable_Table.name eq "Default", + MSomeTable_Table.phoneNumber eq "5555555") + .executeInsert(db) +}.execute() ``` `INSERT` supports inserting multiple rows as well. -```java +```kotlin // columns + values separately -SQLite.insert(SomeTable.class) - .columns(SomeTable_Table.name, SomeTable_Table.phoneNumber) +database.beginTransactionAsync { db -> + (insert(SomeTable_Table.name, SomeTable_Table.phoneNumber) .values("Default1", "5555555") - .values("Default2", "6666666") - .async() - .execute() + .values("Default2", "6666666")) + .executeInsert(db) +}.execute() // or combine into Operators - SQLite.insert(SomeTable.class) - .columnValues(SomeTable_Table.name.eq("Default1"), +database.beginTransactionAsync { db -> + (insert(SomeTable_Table.name.eq("Default1"), SomeTable_Table.phoneNumber.eq("5555555")) .columnValues(SomeTable_Table.name.eq("Default2"), - SomeTable_Table.phoneNumber.eq("6666666")) - .async() - .execute() + SomeTable_Table.phoneNumber.eq("6666666"))) + .executeInsert(db) + }.execute() ``` @@ -334,12 +314,13 @@ SQLite.insert(SomeTable.class) Triggers enable SQLite-level listener operations that perform some operation, modification, or action to run when a specific database event occurs. [See](https://www.sqlite.org/lang_createtrigger.html) for more documentation on its usage. -```java - -Trigger.create("SomeTrigger") - .after().insert(ConditionModel.class).begin(new Update<>(TestUpdateModel.class) - .set(TestUpdateModel_Table.value.is("Fired"))).enable(); // enables the trigger if it does not exist, so subsequent calls are OK +```kotlin +*createTrigger("SomeTrigger") + .after() insertOn()) + .begin(update() + .set(TestUpdateModel_Table.value.is("Fired")))) + .enable(); // enables the trigger if it does not exist, so subsequent calls are OK ``` @@ -354,15 +335,17 @@ We have two kinds of case: The simple CASE query in DBFlow: -```java +```kotlin -SQLite.select(CaseModel_Table.customerId, +select(CaseModel_Table.customerId, CaseModel_Table.firstName, CaseModel_Table.lastName, - SQLite.case(CaseModel_Table.country) - .when("USA").then("Domestic") - ._else("Foreign") - .end("CustomerGroup")).from(CaseModel.class) + (case(CaseModel_Table.country) + whenever "USA" + then "Domestic" + `else` "Foreign") + .end("CustomerGroup")) + from() ``` @@ -373,12 +356,14 @@ set from the SELECT. The search CASE is a little more complicated in that each `when()` statement represents a `SQLOperator`, which return a `boolean` expression: -```java +```kotlin -SQLite.select(CaseModel_Table.customerId, +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); + caseWhen(CaseModel_Table.country.eq("USA")) + then "Domestic" + `else` "Foreign") + .end("CustomerGroup")) + from() ``` From cab52b60bbb4b4a58f35dddf48b280cdf2c34158 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sat, 20 Oct 2018 21:13:04 -0400 Subject: [PATCH 225/234] [Insert] add kotlin pair method handling. --- .../main/kotlin/com/dbflow5/query/Insert.kt | 62 ++++++++----------- .../main/kotlin/com/dbflow5/query/SQLite.kt | 3 + 2 files changed, 30 insertions(+), 35 deletions(-) diff --git a/lib/src/main/kotlin/com/dbflow5/query/Insert.kt b/lib/src/main/kotlin/com/dbflow5/query/Insert.kt index f93790357..c356fdb39 100644 --- a/lib/src/main/kotlin/com/dbflow5/query/Insert.kt +++ b/lib/src/main/kotlin/com/dbflow5/query/Insert.kt @@ -31,7 +31,7 @@ internal constructor(table: Class, vararg columns: Property<*>) /** * The values to specify in this query */ - private var valuesList: MutableList> = arrayListOf() + private var valuesList: MutableList> = arrayListOf() /** * The conflict algorithm to use to resolve inserts. @@ -48,14 +48,14 @@ internal constructor(table: Class, vararg columns: Property<*>) queryBuilder.append("OR").append(" $conflictAction ") } queryBuilder.append("INTO") - .append(" ") - .append(FlowManager.getTableName(table)) + .append(" ") + .append(FlowManager.getTableName(table)) columns?.let { columns -> if (columns.isNotEmpty()) { queryBuilder.append("(") - .appendArray(*columns.toTypedArray()) - .append(")") + .appendArray(*columns.toTypedArray()) + .append(")") } } val selectFrom = this.selectFrom @@ -64,16 +64,16 @@ internal constructor(table: Class, vararg columns: Property<*>) } else { if (valuesList.size < 1) { throw IllegalStateException("The insert of ${FlowManager.getTableName(table)} " + - "should have at least one value specified for the insert") + "should have at least one value specified for the insert") } else columns?.takeIf { it.isNotEmpty() }?.let { columns -> valuesList.asSequence() - .filter { it.size != columns.size } - .forEach { - throw IllegalStateException( - """The Insert of ${FlowManager.getTableName(table)} + .filter { it.size != columns.size } + .forEach { + throw IllegalStateException( + """The Insert of ${FlowManager.getTableName(table)} |when specifying columns needs to have the same amount |of values and columns. found ${it.size} != ${columns.size}""".trimMargin()) - } + } } queryBuilder.append(" VALUES(") @@ -127,8 +127,7 @@ internal constructor(table: Class, vararg columns: Property<*>) fun asColumnValues() = apply { asColumns() columns?.let { columns -> - val values = arrayListOf() - columns.indices.forEach { values.add("?") } + val values = columns.indices.map { "?" } valuesList.add(values) } } @@ -159,35 +158,28 @@ internal constructor(table: Class, vararg columns: Property<*>) * @param conditions The conditions that we use to fill the columns and values of this INSERT */ fun columnValues(vararg conditions: SQLOperator) = apply { - val columns = arrayListOf() - val values = arrayListOf() - - for (i in conditions.indices) { - val condition = conditions[i] - columns += condition.columnName() - values += condition.value() - } - - return columns(*columns.toTypedArray()).values(values) + return columns(*conditions.map { it.columnName() }.toTypedArray()) + .values(conditions.map { it.value() }) } /** * Uses the [Operator] pairs to fill this insert query. * - * @param operatorGroup The OperatorGroup to use + * @param conditions The conditions that we use to fill the columns and values of this INSERT */ - fun columnValues(operatorGroup: OperatorGroup) = apply { - val size = operatorGroup.size - val columns = arrayListOf() - val values = arrayListOf() - - for (i in 0 until size) { - val condition = operatorGroup.conditions[i] - columns += condition.columnName() - values += condition.value() - } + fun columnValues(vararg conditions: Pair, Any?>) = apply { + return columns(*conditions.map { it.first }.toTypedArray()) + .values(conditions.map { it.second }) + } - return columns(*columns.toTypedArray()).values(values) + /** + * Uses the [Operator] pairs to fill this insert query. + * + * @param group The [Iterable] of [SQLOperator] + */ + fun columnValues(group: Iterable) = apply { + return columns(*group.map { it.columnName() }.toTypedArray()) + .values(group.map { it.value() }) } fun columnValues(contentValues: ContentValues) = apply { diff --git a/lib/src/main/kotlin/com/dbflow5/query/SQLite.kt b/lib/src/main/kotlin/com/dbflow5/query/SQLite.kt index bf6f2b5fc..d449bd26f 100644 --- a/lib/src/main/kotlin/com/dbflow5/query/SQLite.kt +++ b/lib/src/main/kotlin/com/dbflow5/query/SQLite.kt @@ -40,6 +40,9 @@ fun update(table: KClass) = update(table.java) inline fun insert(vararg columns: Property<*>) = insert(T::class, *columns) +inline fun insert(vararg columnValues: Pair, Any?>) = insert(T::class) + .columnValues(*columnValues) + /** * @param table The table to insert. * @return A new INSERT statement. From 727093dab4343ed8d95e199c531976cfba60da2d Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sat, 20 Oct 2018 21:13:23 -0400 Subject: [PATCH 226/234] [Query] add default arg for orderby to ascending = true. --- lib/src/main/kotlin/com/dbflow5/query/Transformable.kt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/lib/src/main/kotlin/com/dbflow5/query/Transformable.kt b/lib/src/main/kotlin/com/dbflow5/query/Transformable.kt index 07079a29f..b4089285d 100644 --- a/lib/src/main/kotlin/com/dbflow5/query/Transformable.kt +++ b/lib/src/main/kotlin/com/dbflow5/query/Transformable.kt @@ -15,9 +15,9 @@ interface Transformable { fun groupBy(vararg properties: IProperty<*>): Where - fun orderBy(nameAlias: NameAlias, ascending: Boolean): Where + fun orderBy(nameAlias: NameAlias, ascending: Boolean = true): Where - fun orderBy(property: IProperty<*>, ascending: Boolean): Where + fun orderBy(property: IProperty<*>, ascending: Boolean = true): Where infix fun orderBy(orderBy: OrderBy): Where From 62d8aee42de4f0b2b807144d876aaa8c5a6f0e39 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sat, 20 Oct 2018 21:28:52 -0400 Subject: [PATCH 227/234] [Insert] fix compile from changes of adding pair to insert class directly. --- .../main/kotlin/com/dbflow5/query/Insert.kt | 17 ++------- .../main/kotlin/com/dbflow5/query/SQLite.kt | 5 +++ .../com/dbflow5/rx2/query/RXQueryTests.kt | 4 +-- .../com/dbflow5/sql/language/InsertTest.kt | 36 +++++++++---------- 4 files changed, 27 insertions(+), 35 deletions(-) diff --git a/lib/src/main/kotlin/com/dbflow5/query/Insert.kt b/lib/src/main/kotlin/com/dbflow5/query/Insert.kt index c356fdb39..3351dd1f5 100644 --- a/lib/src/main/kotlin/com/dbflow5/query/Insert.kt +++ b/lib/src/main/kotlin/com/dbflow5/query/Insert.kt @@ -167,7 +167,7 @@ internal constructor(table: Class, vararg columns: Property<*>) * * @param conditions The conditions that we use to fill the columns and values of this INSERT */ - fun columnValues(vararg conditions: Pair, Any?>) = apply { + fun columnValues(vararg conditions: Pair, *>) = apply { return columns(*conditions.map { it.first }.toTypedArray()) .values(conditions.map { it.second }) } @@ -276,17 +276,4 @@ infix fun Insert.orFail(into: Array, *>>) = o infix fun Insert.orIgnore(into: Array, *>>) = orIgnore().columnValues(*into) -infix fun Insert.select(from: From<*>): Insert = select(from) - -fun columnValues(vararg pairs: Pair, *>): Array, *>> = pairs - -fun Insert.columnValues(vararg pairs: Pair, *>): Insert { - val columns: MutableList> = mutableListOf() - val values = mutableListOf() - pairs.forEach { - columns.add(it.first) - values.add(it.second) - } - this.columns(columns).values(values) - return this -} +infix fun Insert.select(from: From<*>): Insert = select(from) \ No newline at end of file diff --git a/lib/src/main/kotlin/com/dbflow5/query/SQLite.kt b/lib/src/main/kotlin/com/dbflow5/query/SQLite.kt index d449bd26f..fa85d1246 100644 --- a/lib/src/main/kotlin/com/dbflow5/query/SQLite.kt +++ b/lib/src/main/kotlin/com/dbflow5/query/SQLite.kt @@ -38,11 +38,16 @@ fun update(table: Class): Update = Update(table) */ fun update(table: KClass) = update(table.java) +inline fun insertInto() = insert(columns = *arrayOf()) + inline fun insert(vararg columns: Property<*>) = insert(T::class, *columns) inline fun insert(vararg columnValues: Pair, Any?>) = insert(T::class) .columnValues(*columnValues) +inline fun insert(vararg operators: SQLOperator) = insert(T::class) + .columnValues(*operators) + /** * @param table The table to insert. * @return A new INSERT statement. diff --git a/tests/src/test/java/com/dbflow5/rx2/query/RXQueryTests.kt b/tests/src/test/java/com/dbflow5/rx2/query/RXQueryTests.kt index d9d1d422c..5e55690e7 100644 --- a/tests/src/test/java/com/dbflow5/rx2/query/RXQueryTests.kt +++ b/tests/src/test/java/com/dbflow5/rx2/query/RXQueryTests.kt @@ -39,7 +39,7 @@ class RXQueryTests : BaseUnitTest() { var databaseStatement: DatabaseStatement? = null databaseForTable() .beginTransactionAsync { - insert().columnValues(name.`is`("name")).compileStatement(it) + insert(name.`is`("name")).compileStatement(it) }.asSingle() .subscribe { statement -> databaseStatement = statement @@ -69,7 +69,7 @@ class RXQueryTests : BaseUnitTest() { var count = 0L databaseForTable() .beginTransactionAsync { - (insert().columnValues(name.eq("name"))).executeInsert(it) + (insert(name.eq("name"))).executeInsert(it) }.asSingle() .subscribe { c -> count = c diff --git a/tests/src/test/java/com/dbflow5/sql/language/InsertTest.kt b/tests/src/test/java/com/dbflow5/sql/language/InsertTest.kt index b620ac9d2..46504c399 100644 --- a/tests/src/test/java/com/dbflow5/sql/language/InsertTest.kt +++ b/tests/src/test/java/com/dbflow5/sql/language/InsertTest.kt @@ -11,7 +11,7 @@ import com.dbflow5.models.TwoColumnModel_Table.name import com.dbflow5.query.NameAlias import com.dbflow5.query.Operator import com.dbflow5.query.OperatorGroup -import com.dbflow5.query.insert +import com.dbflow5.query.insertInto import com.dbflow5.query.select import org.junit.Assert.assertEquals import org.junit.Test @@ -22,7 +22,7 @@ class InsertTest : BaseUnitTest() { fun validateInsert() { databaseForTable { assertEquals("INSERT INTO `SimpleModel` VALUES('something')", - insert().values("something").query.trim()) + insertInto().values("something").query.trim()) } } @@ -30,17 +30,17 @@ class InsertTest : BaseUnitTest() { fun validateInsertOr() { databaseForTable { assertEquals("INSERT OR REPLACE INTO `SimpleModel` VALUES('something')", - insert().orReplace().values("something").query.trim()) + insertInto().orReplace().values("something").query.trim()) assertEquals("INSERT OR FAIL INTO `SimpleModel` VALUES('something')", - insert().orFail().values("something").query.trim()) + insertInto().orFail().values("something").query.trim()) assertEquals("INSERT OR IGNORE INTO `SimpleModel` VALUES('something')", - insert().orIgnore().values("something").query.trim()) + insertInto().orIgnore().values("something").query.trim()) assertEquals("INSERT OR REPLACE INTO `SimpleModel` VALUES('something')", - insert().orReplace().values("something").query.trim()) + insertInto().orReplace().values("something").query.trim()) assertEquals("INSERT OR ROLLBACK INTO `SimpleModel` VALUES('something')", - insert().orRollback().values("something").query.trim()) + insertInto().orRollback().values("something").query.trim()) assertEquals("INSERT OR ABORT INTO `SimpleModel` VALUES('something')", - insert().orAbort().values("something").query.trim()) + insertInto().orAbort().values("something").query.trim()) } } @@ -48,7 +48,7 @@ class InsertTest : BaseUnitTest() { fun validateInsertProjection() { databaseForTable { assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 'id')", - insert().columns(name, id).values("name", "id").query.trim()) + insertInto().columns(name, id).values("name", "id").query.trim()) } } @@ -56,7 +56,7 @@ class InsertTest : BaseUnitTest() { fun validateSelect() { databaseForTable { assertEquals("INSERT INTO `TwoColumnModel` SELECT * FROM `SimpleModel`", - insert().select(select from SimpleModel::class).query.trim()) + insertInto().select(select from SimpleModel::class).query.trim()) } } @@ -64,11 +64,11 @@ class InsertTest : BaseUnitTest() { fun validateColumns() { databaseForTable { assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 'id')", - insert().asColumns().values("name", "id").query.trim()) + insertInto().asColumns().values("name", "id").query.trim()) assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 'id')", - insert().columns("name", "id").values("name", "id").query.trim()) + insertInto().columns("name", "id").values("name", "id").query.trim()) assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 'id')", - insert().columns(listOf(name, id)).values("name", "id").query.trim()) + insertInto().columns(listOf(name, id)).values("name", "id").query.trim()) } } @@ -76,19 +76,19 @@ class InsertTest : BaseUnitTest() { fun validateColumnValues() { databaseForTable { assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 0)", - insert().columnValues(name.eq("name"), id.eq(0)).query.trim()) + insertInto().columnValues(name.eq("name"), id.eq(0)).query.trim()) assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 0)", - insert().columnValues(Operator.op(NameAlias.builder("name").build()).eq("name"), + insertInto().columnValues(Operator.op(NameAlias.builder("name").build()).eq("name"), id.eq(0)).query.trim()) assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 0)", - insert().columnValues(OperatorGroup.clause().andAll(name.eq("name"), id.eq(0))).query.trim()) + insertInto().columnValues(group = OperatorGroup.clause().andAll(name.eq("name"), id.eq(0))).query.trim()) val contentValues = ContentValues() contentValues["name"] = "name" - contentValues["id"] = 0.toInt() + contentValues["id"] = 0 assertEquals("INSERT INTO `TwoColumnModel`(`name`, `id`) VALUES('name', 0)", - insert().columnValues(contentValues).query.trim()) + insertInto().columnValues(contentValues).query.trim()) } } From 912b6975d1461d6fdafe0d5cb8bcd9e9607d5d23 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sat, 20 Oct 2018 21:50:45 -0400 Subject: [PATCH 228/234] [Process] convert process function into a single method interface. remove some redundant helper constructs and require vanilla use. --- .../transaction/ProcessModelTransaction.kt | 86 +++------- usage2/StoringData.md | 148 +++++------------- 2 files changed, 65 insertions(+), 169 deletions(-) diff --git a/lib/src/main/kotlin/com/dbflow5/transaction/ProcessModelTransaction.kt b/lib/src/main/kotlin/com/dbflow5/transaction/ProcessModelTransaction.kt index 1479072da..d83230e65 100644 --- a/lib/src/main/kotlin/com/dbflow5/transaction/ProcessModelTransaction.kt +++ b/lib/src/main/kotlin/com/dbflow5/transaction/ProcessModelTransaction.kt @@ -1,20 +1,31 @@ package com.dbflow5.transaction -import com.dbflow5.config.databaseForTable import com.dbflow5.database.DatabaseWrapper import com.dbflow5.structure.Model typealias ProcessFunction = (T, DatabaseWrapper) -> Unit +/** + * Listener for providing callbacks as models are processed in this [ITransaction]. + * + * Called when model has been operated on. + * + * @param current The current index of items processed. + * @param total The total number of items to process. + * @param modifiedModel The model previously modified. + * @param The model class. + */ +typealias OnModelProcessListener = (current: Long, total: Long, modifiedModel: TModel) -> Unit + /** * Description: Allows you to process a single or [List] of models in a transaction. You * can operate on a set of [Model] to [Model.save], [Model.update], etc. */ class ProcessModelTransaction( - private val models: List = arrayListOf(), - private val processListener: OnModelProcessListener? = null, - private val processModel: ProcessModel, - private val runProcessListenerOnSameThread: Boolean) : ITransaction { + private val models: List = arrayListOf(), + private val processListener: OnModelProcessListener? = null, + private val processModel: ProcessModel, + private val runProcessListenerOnSameThread: Boolean) : ITransaction { /** @@ -31,28 +42,11 @@ class ProcessModelTransaction( fun processModel(model: TModel, wrapper: DatabaseWrapper) } - /** - * Listener for providing callbacks as models are processed in this [ITransaction]. - * - * @param The model class. - */ - interface OnModelProcessListener { - - /** - * Called when model has been operated on. - * - * @param current The current index of items processed. - * @param total The total number of items to process. - * @param modifiedModel The model previously modified. - */ - fun onModelProcessed(current: Long, total: Long, modifiedModel: TModel) - } - internal constructor(builder: Builder) : this( - processListener = builder.processListener, - models = builder.models, - processModel = builder.processModel, - runProcessListenerOnSameThread = builder.runProcessListenerOnSameThread + processListener = builder.processListener, + models = builder.models, + processModel = builder.processModel, + runProcessListenerOnSameThread = builder.runProcessListenerOnSameThread ) override fun execute(databaseWrapper: DatabaseWrapper) { @@ -63,10 +57,10 @@ class ProcessModelTransaction( if (processListener != null) { if (runProcessListenerOnSameThread) { - processListener.onModelProcessed(i.toLong(), size.toLong(), model) + processListener.invoke(i.toLong(), size.toLong(), model) } else { Transaction.transactionHandler.post { - processListener.onModelProcessed(i.toLong(), size.toLong(), model) + processListener.invoke(i.toLong(), size.toLong(), model) } } } @@ -146,39 +140,11 @@ class ProcessModelTransaction( } } - -/** - * Enables a collection of T objects to easily operate on them within a synchronous database transaction. - */ -@Deprecated(message = "Use the coroutines awaitSave, awaitInsert, awaitDelete, awaitUpdate") -inline fun Collection.processInTransaction( - crossinline processFunction: ProcessFunction) { - databaseForTable().executeTransaction { db -> forEach { processFunction(it, db) } } -} - -inline fun processModel(crossinline function: (T, DatabaseWrapper) -> Unit) - = object : ProcessModelTransaction.ProcessModel { +inline fun processModel(crossinline function: (T, DatabaseWrapper) -> Unit) = object : ProcessModelTransaction.ProcessModel { override fun processModel(model: T, wrapper: DatabaseWrapper) = function(model, wrapper) } -/** - * Places the [Collection] of items on the [ITransactionQueue]. Use the [processFunction] to perform - * an action on each individual [Model]. This happens on a non-UI thread. - */ -inline fun Collection.processInTransactionAsync( - crossinline processFunction: ProcessFunction, - noinline success: Success? = null, - noinline error: Error? = null, - processListener: ProcessModelTransaction.OnModelProcessListener? = null) { - val builder = this.processTransaction(processFunction) - processListener?.let { builder.processListener(processListener) } - databaseForTable().beginTransactionAsync(builder.build()) - .success(success) - .error(error) - .execute() -} - inline fun Collection.processTransaction( - crossinline processFunction: ProcessFunction): ProcessModelTransaction.Builder = - ProcessModelTransaction.Builder(processModel { model, wrapper -> processFunction(model, wrapper) }) - .addAll(this) + crossinline processFunction: ProcessFunction): ProcessModelTransaction.Builder = + ProcessModelTransaction.Builder(processModel { model, wrapper -> processFunction(model, wrapper) }) + .addAll(this) diff --git a/usage2/StoringData.md b/usage2/StoringData.md index bf408b0e3..14a3dc25f 100644 --- a/usage2/StoringData.md +++ b/usage2/StoringData.md @@ -9,53 +9,21 @@ to store information. While generally saving data synchronous should be avoided, for small amounts of data it has little effect. -```java - -FlowManager.getModelAdapter(SomeTable.class).save(model); - -FlowManager.getModelAdapter(SomeTable.class).insert(model); - -FlowManager.getModelAdapter(SomeTable.class).update(model); - -model.insert(); // inserts -model.update(); // updates -model.save(); // checks if exists, if true update, else insert. - -``` - -Code (without running in a transaction) like this should be avoided: - -```java - -for (int i = 0; i < models.size(), i++) { - models.get(i).save(); -} - +```kotlin +model.save() +model.insert() +model.update() ``` -Doing operations on the main thread can block it if you read and write to the DB on a different thread while accessing DB on the main. - -## Synchronous Transactions +Avoid saving large amounts of models outside of a transaction: +```kotlin -A simple database transaction can be wrapped in a call: - -```java - -FlowManager.getDatabase(AppDatabase.class).executeTransaction(new ITransaction() { - @Override - public void execute(DatabaseWrapper databaseWrapper) { - // something here - Player player = new Player("Andrew", "Grosner"); - player.save(databaseWrapper); // use wrapper (from BaseModel) - } -}); +// AVOID +models.forEach { it.save() } ``` -Even though DBFlow is ridiculously fast, this should be put on a separate thread - outside of the UI, so that your UI remains responsive on all devices. - - Instead we should move onto `Transaction` (the preferred method). +Doing operations on the main thread can block it if you read and write to the DB on a different thread while accessing DB on the main. Instead, use Async Transactions. ### Async Transactions @@ -74,42 +42,21 @@ Also to use the legacy, priority-based system, read [here](StoringData.md#priori A basic transaction: - ```java + ```kotlin -DatabaseDefinition database = FlowManager.getDatabase(AppDatabase.class); -Transaction transaction = database.beginTransactionAsync(new ITransaction() { - @Override - public void execute(DatabaseWrapper databaseWrapper) { - called.set(true); - } - }).build(); -transaction.execute(); // execute + val transaction = database().beginTransactionAsync { db -> + // handle to DB + // return a result, or execute a method that returns a result + }.build() +transaction.execute( + error = { transaction, error -> // handle any exceptions here }, + completion = { transaction -> // called when transaction completes success or fail } + ) { transaction, result -> + // utilize the result returned transaction.cancel(); // attempt to cancel before its run. If it's already ran, this call has no effect. - ``` - - `Transaction` have callbacks to allow you to "listen" for success and errors. - - ```java - - - transaction - .success(new Transaction.Success() { - @Override - public void onSuccess(Transaction transaction) { - // called post-execution on the UI thread. - } - }) - .error(new Transaction.Error() { - @Override - public void onError(Transaction transaction, Throwable error) { - // call if any errors occur in the transaction. - } - }); - - ``` The `Success` callback runs post-transaction on the UI thread. @@ -127,38 +74,23 @@ method in the `Builder`. You can listen for when each are processed inside a nor It is a convenient way to operate on them: -```java +```kotlin -ProcessModelTransaction processModelTransaction = - new ProcessModelTransaction.Builder<>(new ProcessModelTransaction.ProcessModel() { - @Override - public void processModel(TestModel1 model) { - // call some operation on model here - model.save(); - model.insert(); // or - model.delete(); // or - } - }).processListener(new ProcessModelTransaction.OnModelProcessListener() { - @Override - public void onModelProcessed(long current, long total, TestModel1 modifiedModel) { - modelProcessedCount.incrementAndGet(); - } - }).addAll(items).build(); -Transaction transaction = database.beginTransactionAsync(processModelTransaction).build(); -transaction.execute(); +database.beginTransactionAsync(items.processTransaction { model, db -> + // call some operation on model here + model.save() + model.insert() // or + model.delete() // or + } + .processListener { current, total, modifiedModel -> + // for every model looped through and completes + modelProcessedCount.incrementAndGet(); + } + .build()) + .execute() ``` -In Kotlin (with `dbflow-kotlinextensions`), we can drastically simplify: - -```java - -items.processInTransactionAsync({ it, databaseWrapper -> it.delete(databaseWrapper) }, - ProcessModelTransaction.OnModelProcessListener { current, size, model -> - modelProcessedCount.incrementAndGet(); - }) - -``` You can listen to when operations complete for each model via the `OnModelProcessListener`. These callbacks occur on the UI thread. If you wish to run them on same thread (great for tests), set `runProcessListenerOnSameThread()` to `true`. @@ -171,15 +103,13 @@ The `FastStoreModelTransaction` is the quickest, lightest way to store a `List` 2. No progress listening 3. Can only `save`, `insert`, or `update` the whole list entirely. -```java - -FastStoreModelTransaction - .insertBuilder(FlowManager.getModelAdapter(TestModel2.class)) - .addAll(modelList) - .build() - - // updateBuilder + saveBuilder also available. - +```kotlin +database.beginTransactionAsync(list.fastSave().build()) + .execute() +database.beginTransactionAsync(list.fastInsert().build()) + .execute() +database.beginTransactionAsync(list.fastUpdate().build()) + .execute() ``` What it provides: From 3105540c796d44266fa1909a82c9fc936f811ab7 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sat, 20 Oct 2018 21:51:00 -0400 Subject: [PATCH 229/234] [Coroutines] dont use deprecated method. --- .../src/main/kotlin/com/dbflow5/coroutines/Coroutines.kt | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/coroutines/src/main/kotlin/com/dbflow5/coroutines/Coroutines.kt b/coroutines/src/main/kotlin/com/dbflow5/coroutines/Coroutines.kt index aa939907e..feeacdded 100644 --- a/coroutines/src/main/kotlin/com/dbflow5/coroutines/Coroutines.kt +++ b/coroutines/src/main/kotlin/com/dbflow5/coroutines/Coroutines.kt @@ -124,9 +124,7 @@ inline fun constructFastCoroutine(continuation: CancellableContinuati }.build() transaction.execute() - continuation.invokeOnCompletion { - if (continuation.isCancelled) { - transaction.cancel() - } + continuation.invokeOnCancellation { + transaction.cancel() } } \ No newline at end of file From 252a388aded7c3a16a038a7c62fb9d3e0614fc95 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sat, 20 Oct 2018 22:00:48 -0400 Subject: [PATCH 230/234] [Transactions] updated doc to latest api. --- .../dbflow5/transaction/ITransactionQueue.kt | 2 +- .../com/dbflow5/DBFlowInstrumentedTestRule.kt | 1 + usage2/StoringData.md | 103 +++++++----------- 3 files changed, 42 insertions(+), 64 deletions(-) diff --git a/lib/src/main/kotlin/com/dbflow5/transaction/ITransactionQueue.kt b/lib/src/main/kotlin/com/dbflow5/transaction/ITransactionQueue.kt index b17ad5b84..890957dce 100644 --- a/lib/src/main/kotlin/com/dbflow5/transaction/ITransactionQueue.kt +++ b/lib/src/main/kotlin/com/dbflow5/transaction/ITransactionQueue.kt @@ -36,4 +36,4 @@ interface ITransactionQueue { */ fun quit() -} +} \ No newline at end of file diff --git a/tests/src/androidTest/java/com/dbflow5/DBFlowInstrumentedTestRule.kt b/tests/src/androidTest/java/com/dbflow5/DBFlowInstrumentedTestRule.kt index 6a5d6cd00..88e87082a 100644 --- a/tests/src/androidTest/java/com/dbflow5/DBFlowInstrumentedTestRule.kt +++ b/tests/src/androidTest/java/com/dbflow5/DBFlowInstrumentedTestRule.kt @@ -13,6 +13,7 @@ import org.junit.rules.TestRule import org.junit.runner.Description import org.junit.runners.model.Statement + class DBFlowInstrumentedTestRule : TestRule { override fun apply(base: Statement, description: Description): Statement { diff --git a/usage2/StoringData.md b/usage2/StoringData.md index 14a3dc25f..ba1aa2aa2 100644 --- a/usage2/StoringData.md +++ b/usage2/StoringData.md @@ -125,34 +125,27 @@ system you can override the default system included. To begin you must implement a `ITransactionQueue`: -```java +```kotlin -public class CustomQueue implements ITransactionQueue { +class CustomQueue : ITransactionQueue { + override fun add(transaction: Transaction) { - @Override - public void add(Transaction transaction) { + } - } + override fun cancel(transaction: Transaction) { - @Override - public void cancel(Transaction transaction) { + } - } + override fun startIfNotAlive() { + } - @Override - public void startIfNotAlive() { + override fun cancel(name: String) { - } + } - @Override - public void cancel(String name) { + override fun quit() { - } - - @Override - public void quit() { - - } + } } ``` @@ -165,36 +158,25 @@ a thread). Next you can override the `BaseTransactionManager` (not required, see later): -```java - -public class CustomTransactionManager extends BaseTransactionManager { - - public CustomTransactionManager(DatabaseDefinition databaseDefinition) { - super(new CustomTransactionQueue(), databaseDefinition); - } +```kotlin -} +class CustomTransactionManager(databaseDefinition: DBFlowDatabase) + : BaseTransactionManager(CustomTransactionQueue(), databaseDefinition) ``` To register it with DBFlow, in your `FlowConfig`, you must: -```java - -FlowManager.init(builder - .database(new DatabaseConfig.Builder(AppDatabase.class) - .transactionManagerCreator(new DatabaseConfig.TransactionManagerCreator() { - @Override - public BaseTransactionManager createManager(DatabaseDefinition databaseDefinition) { - // this will be called once database modules are loaded and created. - return new CustomTransactionManager(databaseDefinition); +```kotlin - // or you can: - //return new DefaultTransactionManager(new CustomTransactionQueue(), databaseDefinition); - } - }) - .build()) - .build()); +FlowManager.init(FlowConfig.Builder(DemoApp.context) + .database(DatabaseConfig( + databaseClass = AppDatabase::class.java, + transactionManagerCreator = { databaseDefinition -> + CustomTransactionManager(databaseDefinition) + }) + .build()) +.build()) ``` @@ -207,22 +189,18 @@ keep the legacy way, a `PriorityTransactionQueue` was created. As seen in [Custom Transaction Managers](StoringData.md#custom-transactionmanager), we provide a custom instance of the `DefaultTransactionManager` with the `PriorityTransactionQueue` specified: -```java - -FlowManager.init(builder - .database(new DatabaseConfig.Builder(AppDatabase.class) - .transactionManagerCreator(new DatabaseConfig.TransactionManagerCreator() { - @Override - public BaseTransactionManager createManager(DatabaseDefinition databaseDefinition) { - // this will be called once database modules are loaded and created. - return new DefaultTransactionManager( - new PriorityTransactionQueue("DBFlow Priority Queue"), - databaseDefinition); - } - }) - .build()) - .build()); +```kotlin +FlowManager.init(FlowConfig.builder(context) + .database(DatabaseConfig.Builder(AppDatabase::class.java) + .transactionManagerCreator { db -> + // this will be called once database modules are loaded and created. + DefaultTransactionManager( + PriorityTransactionQueue("DBFlow Priority Queue"), + db) + } + .build()) + .build()) ``` What this does is for the specified database (in this case `AppDatabase`), @@ -231,13 +209,12 @@ the `PriorityTransactionWrapper`. Otherwise an the `PriorityTransactionQueue` wraps the existing `Transaction` in a `PriorityTransactionWrapper` with normal priority. -To specify a priority: +To specify a priority, wrap your original `ITransaction` with a `PriorityTransactionWrapper`: -```java - -FlowManager.getDatabase(AppDatabase.class) - .beginTransactionAsync(new PriorityTransactionWrapper.Builder(myTransaction) +```kotlin +database() + .beginTransactionAsync(PriorityTransactionWrapper.Builder(myTransaction) .priority(PriorityTransactionWrapper.PRIORITY_HIGH).build()) - .build().execute(); + .execute(); ``` From cfc5d46409eea6570d0e2a7c6adc27d8b581f0c1 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sun, 21 Oct 2018 02:10:17 +0000 Subject: [PATCH 231/234] GitBook: [develop] 60 pages modified --- .github/README.md | 2 + .github/{CONTRIBUTING.md => contributing.md} | 19 +- README.md | 35 ++-- SUMMARY.md | 35 ++++ ISSUE_TEMPLATE.md => issue_template.md | 3 + usage2/ListBasedQueries.md | 163 ------------------ usage2/README.md | 3 +- usage2/SUMMARY.md | 29 ---- .../README.md} | 2 - .../{Caching.md => advanced-usage/caching.md} | 67 ++----- .../indexing.md} | 25 +-- usage2/advanced-usage/listbasedqueries.md | 122 +++++++++++++ .../multiplemodules.md} | 23 +-- .../querymodels.md} | 36 +--- .../sqlciphersupport.md} | 8 +- ...ration.md => contentprovidergeneration.md} | 53 +++--- .../{GettingStarted.md => gettingstarted.md} | 77 +++------ usage2/including-in-project.md | 10 +- usage2/{KotlinSupport.md => kotlinsupport.md} | 60 ++----- ...{Migration3Guide.md => migration3guide.md} | 143 ++++++--------- ...{Migration4Guide.md => migration4guide.md} | 30 +--- usage2/proguard.md | 2 +- usage2/{RXJavaSupport.md => rxjavasupport.md} | 53 ++---- usage2/summary.md | 29 ++++ usage2/{Usage.md => usage/README.md} | 30 ++-- usage2/{Databases.md => usage/databases.md} | 77 +++------ usage2/{Migrations.md => usage/migrations.md} | 65 ++----- usage2/{Models.md => usage/models.md} | 57 ++---- usage2/{ModelViews.md => usage/modelviews.md} | 28 +-- .../observability.md} | 55 ++---- .../relationships.md} | 63 +++---- usage2/{Retrieval.md => usage/retrieval.md} | 33 ++-- .../sqlitewrapperlanguage.md} | 134 +++++--------- .../{StoringData.md => usage/storingdata.md} | 91 +++------- .../typeconverters.md} | 30 +--- 35 files changed, 584 insertions(+), 1108 deletions(-) create mode 100644 .github/README.md rename .github/{CONTRIBUTING.md => contributing.md} (81%) create mode 100644 SUMMARY.md rename ISSUE_TEMPLATE.md => issue_template.md (73%) delete mode 100644 usage2/ListBasedQueries.md delete mode 100644 usage2/SUMMARY.md rename usage2/{advanced-usage.md => advanced-usage/README.md} (97%) rename usage2/{Caching.md => advanced-usage/caching.md} (60%) rename usage2/{Indexing.md => advanced-usage/indexing.md} (80%) create mode 100644 usage2/advanced-usage/listbasedqueries.md rename usage2/{MultipleModules.md => advanced-usage/multiplemodules.md} (51%) rename usage2/{QueryModels.md => advanced-usage/querymodels.md} (68%) rename usage2/{SQLCipherSupport.md => advanced-usage/sqlciphersupport.md} (91%) rename usage2/{ContentProviderGeneration.md => contentprovidergeneration.md} (83%) rename usage2/{GettingStarted.md => gettingstarted.md} (68%) rename usage2/{KotlinSupport.md => kotlinsupport.md} (83%) rename usage2/{Migration3Guide.md => migration3guide.md} (79%) rename usage2/{Migration4Guide.md => migration4guide.md} (64%) rename usage2/{RXJavaSupport.md => rxjavasupport.md} (67%) create mode 100644 usage2/summary.md rename usage2/{Usage.md => usage/README.md} (82%) rename usage2/{Databases.md => usage/databases.md} (75%) rename usage2/{Migrations.md => usage/migrations.md} (62%) rename usage2/{Models.md => usage/models.md} (60%) rename usage2/{ModelViews.md => usage/modelviews.md} (52%) rename usage2/{Observability.md => usage/observability.md} (79%) rename usage2/{Relationships.md => usage/relationships.md} (59%) rename usage2/{Retrieval.md => usage/retrieval.md} (54%) rename usage2/{SQLiteWrapperLanguage.md => usage/sqlitewrapperlanguage.md} (69%) rename usage2/{StoringData.md => usage/storingdata.md} (57%) rename usage2/{TypeConverters.md => usage/typeconverters.md} (57%) diff --git a/.github/README.md b/.github/README.md new file mode 100644 index 000000000..c41e0e049 --- /dev/null +++ b/.github/README.md @@ -0,0 +1,2 @@ +# .github + diff --git a/.github/CONTRIBUTING.md b/.github/contributing.md similarity index 81% rename from .github/CONTRIBUTING.md rename to .github/contributing.md index 3b59e12fd..e232eaa7b 100644 --- a/.github/CONTRIBUTING.md +++ b/.github/contributing.md @@ -1,5 +1,6 @@ -Contributing Guidelines --------------------------------------------------- +# CONTRIBUTING + +## Contributing Guidelines This document provides general guidelines about how to contribute to the project. Keep in mind these important things before you start contributing. @@ -8,7 +9,7 @@ This document provides general guidelines about how to contribute to the project * Use [github issues](https://github.com/agrosner/DBFlow/issues) to report a bug. * Before creating a new issue: * Make sure you are using the [latest release](https://github.com/agrosner/DBFlow/releases). - * Check if the issue was [already reported or fixed](https://github.com/agrosner/DBFlow/issues?utf8=%E2%9C%93&q=is%3Aissue). Notice that it may not be released yet. + * Check if the issue was [already reported or fixed](https://github.com/agrosner/DBFlow/issues?utf8=✓&q=is%3Aissue). Notice that it may not be released yet. * If you found a match add the github "+1" reaction brief comment. This helps prioritize the issues addressing the most common and critical ones first. If possible, add additional information to help us reproduce, and find the issue. Please use your best judgement. * Reporting issues: * Please include the following information to help maintainers to fix the problem faster: @@ -16,15 +17,9 @@ This document provides general guidelines about how to contribute to the project * Full console output of stack trace or code compilation error. * Any other additional detail you think it would be useful to understand and solve the problem. - ## Pull requests -I welcome and encourage all pull requests. It usually will take me within 24-48 hours to respond to any issue or request. Here are some basic rules to follow to ensure timely addition of your request: - 1. Match coding style (braces, spacing, etc.) This is best achieved using CMD+Option+L (Reformat code) on Mac (not sure for Windows) with Android Studio defaults. - 2. If its a feature, bugfix, or anything please only change code to what you specify. - 3. Please keep PR titles easy to read and descriptive of changes, this will make them easier to merge :) - 4. Pull requests _must_ be made against `develop` branch. Any other branch (unless specified by the maintainers) will get rejected. - +I welcome and encourage all pull requests. It usually will take me within 24-48 hours to respond to any issue or request. Here are some basic rules to follow to ensure timely addition of your request: 1. Match coding style \(braces, spacing, etc.\) This is best achieved using CMD+Option+L \(Reformat code\) on Mac \(not sure for Windows\) with Android Studio defaults. 2. If its a feature, bugfix, or anything please only change code to what you specify. 3. Please keep PR titles easy to read and descriptive of changes, this will make them easier to merge :\) 4. Pull requests _must_ be made against `develop` branch. Any other branch \(unless specified by the maintainers\) will get rejected. ### Suggested git workflow to contribute @@ -39,7 +34,6 @@ I welcome and encourage all pull requests. It usually will take me within 24-48 9. Push your branch into your forked remote repository. 10. Create a new pull request adding any useful comment. - ### Feature proposal We would love to hear your ideas and make discussions about it. @@ -47,4 +41,5 @@ We would love to hear your ideas and make discussions about it. * Use github issues to make feature proposals. * We use `type: feature request` label to mark all [feature request issues](https://github.com/agrosner/DBFlow/labels/type%3A%20feature%20request). * Before submitting your proposal make sure there is no similar feature request. If you find a match, feel free to join the discussion or just or just act with a reaction if you think the feature is worth implementing. -* Be as specific as possible providing a precise explanation of the feature so anyone can understand the problem and the benefits of solving it. \ No newline at end of file +* Be as specific as possible providing a precise explanation of the feature so anyone can understand the problem and the benefits of solving it. + diff --git a/README.md b/README.md index f7aee2616..e3e682cb8 100644 --- a/README.md +++ b/README.md @@ -1,10 +1,12 @@ +# README + ![Image](https://github.com/agrosner/DBFlow/blob/develop/dbflow_banner.png?raw=true) [![JitPack.io](https://img.shields.io/badge/JitPack.io-5.0.0alpha1-red.svg?style=flat)](https://jitpack.io/#Raizlabs/DBFlow) [![Android Weekly](http://img.shields.io/badge/Android%20Weekly-%23129-2CB3E5.svg?style=flat)](http://androidweekly.net/issues/issue-129) [![Android Arsenal](https://img.shields.io/badge/Android%20Arsenal-DBFlow-brightgreen.svg?style=flat)](https://android-arsenal.com/details/1/1134) DBFlow is fast, efficient, and feature-rich Kotlin database library built on SQLite for Android. DBFlow utilizes annotation processing to generate SQLite boilerplate for you and provides a powerful SQLite query language that makes using SQLite a joy. -DBFlow is built from a collection of some of the best features of many database libraries. Don't let an ORM or library get in your way, let the code you write in your applications be the best as possible. +DBFlow is built from a collection of some of the best features of many database libraries. Don't let an ORM or library get in your way, let the code you write in your applications be the best as possible. Supports: @@ -18,20 +20,21 @@ Supports: **SQLCipher:** Easy database encryption support in this library. -**SQLite Query Language:** Enabling autocompletion on sqlite queries combined with Kotlin language features means SQLite-like syntax. +**SQLite Query Language:** Enabling autocompletion on sqlite queries combined with Kotlin language features means SQLite-like syntax. -# Changelog +## Changelog Changes exist in the [releases tab](https://github.com/Raizlabs/DBFlow/releases). -# Usage Docs +## Usage Docs + For more detailed usage, check out it out [here](https://agrosner.gitbooks.io/dbflow/content/) -# Including in your project +## Including in your project Add jitpack.io to your project's repositories: -```groovy +```groovy allProjects { repositories { google() @@ -45,7 +48,6 @@ allProjects { Add artifacts to your project: ```groovy - apply plugin: 'kotlin-kapt' // only required for kotlin consumers. def dbflow_version = "5.0.0-alpha1" @@ -60,7 +62,7 @@ Add artifacts to your project: // if only using Java, use this. If using Kotlin do NOT use this. annotationProcessor "com.github.agrosner.dbflow:processor:${dbflow_version}" - + // core set of libraries compile "com.github.agrosner.dbflow:core:${dbflow_version}" compile "com.github.agrosner.dbflow:lib:${dbflow_version}" @@ -82,18 +84,15 @@ Add artifacts to your project: compile "com.github.agrosner.dbflow:contentprovider:${dbflow_version}" } - ``` -# Pull Requests -I welcome and encourage all pull requests. Here are some basic rules to follow to ensure timely addition of your request: - 1. Match coding style (braces, spacing, etc.) This is best achieved using **Reformat Code** shortcut, command+option+L on Mac and Ctrl+Alt+L on Windows, with Android Studio defaults. - 2. If its a feature, bugfix, or anything please only change code to what you specify. - 3. Please keep PR titles easy to read and descriptive of changes, this will make them easier to merge :) - 4. Pull requests _must_ be made against `develop` branch. Any other branch (unless specified by the maintainers) will get **rejected**. - 5. Have fun! +## Pull Requests + +I welcome and encourage all pull requests. Here are some basic rules to follow to ensure timely addition of your request: 1. Match coding style \(braces, spacing, etc.\) This is best achieved using **Reformat Code** shortcut, command+option+L on Mac and Ctrl+Alt+L on Windows, with Android Studio defaults. 2. If its a feature, bugfix, or anything please only change code to what you specify. 3. Please keep PR titles easy to read and descriptive of changes, this will make them easier to merge :\) 4. Pull requests _must_ be made against `develop` branch. Any other branch \(unless specified by the maintainers\) will get **rejected**. 5. Have fun! + +## Maintainer -# Maintainer Originally created by [Raizlabs](https://www.raizlabs.com), a [Rightpoint](https://www.rightpoint.com) company -Maintained by [agrosner](https://github.com/agrosner) ([@agrosner](https://www.twitter.com/agrosner)) +Maintained by [agrosner](https://github.com/agrosner) \([@agrosner](https://www.twitter.com/agrosner)\) + diff --git a/SUMMARY.md b/SUMMARY.md new file mode 100644 index 000000000..e87200748 --- /dev/null +++ b/SUMMARY.md @@ -0,0 +1,35 @@ +# Table of contents + +* [README](README.md) +* [README](usage2/README.md) + * [Including In Project](usage2/including-in-project.md) + * [Proguard](usage2/proguard.md) + * [Usage](usage2/usage/README.md) + * [Databases](usage2/usage/databases.md) + * [Models](usage2/usage/models.md) + * [Migrations](usage2/usage/migrations.md) + * [Views](usage2/usage/modelviews.md) + * [Relationships](usage2/usage/relationships.md) + * [Storing Data](usage2/usage/storingdata.md) + * [Retrieval](usage2/usage/retrieval.md) + * [SQLite Query Language](usage2/usage/sqlitewrapperlanguage.md) + * [TypeConverters](usage2/usage/typeconverters.md) + * [Observability](usage2/usage/observability.md) + * [RXJavaSupport](usage2/rxjavasupport.md) + * [Advanced Usage](usage2/advanced-usage/README.md) + * [Caching](usage2/advanced-usage/caching.md) + * [ListBasedQueries](usage2/advanced-usage/listbasedqueries.md) + * [MultipleModules](usage2/advanced-usage/multiplemodules.md) + * [QueryModels](usage2/advanced-usage/querymodels.md) + * [Indexing](usage2/advanced-usage/indexing.md) + * [SQLCipher](usage2/advanced-usage/sqlciphersupport.md) + * [ContentProviderGeneration](usage2/contentprovidergeneration.md) + * [GettingStarted](usage2/gettingstarted.md) + * [Migration3Guide](usage2/migration3guide.md) + * [Migration4Guide](usage2/migration4guide.md) + * [KotlinSupport](usage2/kotlinsupport.md) + * [SUMMARY](usage2/summary.md) +* [ISSUE\_TEMPLATE](issue_template.md) +* [.github](.github/README.md) + * [CONTRIBUTING](.github/contributing.md) + diff --git a/ISSUE_TEMPLATE.md b/issue_template.md similarity index 73% rename from ISSUE_TEMPLATE.md rename to issue_template.md index 0f7f1d5c8..51b578b33 100644 --- a/ISSUE_TEMPLATE.md +++ b/issue_template.md @@ -1,5 +1,8 @@ +# ISSUE\_TEMPLATE + DBFlow Version: Bug or Feature Request: Description: + diff --git a/usage2/ListBasedQueries.md b/usage2/ListBasedQueries.md deleted file mode 100644 index 593a29c57..000000000 --- a/usage2/ListBasedQueries.md +++ /dev/null @@ -1,163 +0,0 @@ -# List-Based Queries - -When we have large datasets from the database in our application, we wish to -display them in a `ListView`, `RecyclerView` or some other component that recycles -it's views. Instead of running a potentially very large query on the database, -converting it to a `List` and then keeping that chunk of memory active, we -can lazy-load each row from the query/table. - -DBFlow makes it easy using the `FlowCursorList`, for simple `BaseAdapter`-like methods, -or the `FlowQueryList`, which implements the `List` interface. - -Getting one of these lists is as simple as: - -```java - -FlowQueryList list = SQLite.select() - .from(MyTable.class) - .where(...) // some conditions - .flowQueryList(); -FlowCursorList list = SQLite.select() - .from(MyTable.class) - .where(...) // some conditions - .cursorList(); - - list.close(); // ensure you close these, as they utilize active cursors :) - -``` - -```kotlin -val list = (select from MyTable::class where (...)).cursorList -val list = (select from MyTable::class where (...)).flowQueryList -list.close() -``` - -Any query method allows you to retrieve a default implementation of each. You -can also manually instantiate them: - -```java - -FlowQueryList list = new FlowQueryList.Builder<>(SQLite.select().from(MyTable.class)) - .cachingEnabled(false) // caching enabled by default - .build(); - -FlowCursorList list = new FlowCursorList.Builder<>(SQLite.select().from(MyTable.class)) - .cachingEnabled(true) - .modelCache(cache) // provide custom cache for this list - .build(); - -``` - -## Caching - -Both of these classes come with the ability to cache `Model` used in it's queries -so that loading only happens once and performance can remain high once loaded. The default -caching mechanism is a `ModelLruCache`, which provides an `LruCache` to manage -loading `Model`. - -They are done in almost the same way: - -```java - -FlowCursorList list = new FlowCursorList.Builder<>(SQLite.select().from(MyTable.class)) - .modelCache(cache) // provide custom cache for this list - .build(); -FlowQueryList list = new FlowQueryList.Builder<>(SQLite.select().from(MyTable.class)) - .modelCache(cache) - .build(); - -``` - -## FlowCursorList - -The `FlowCursorList` is simply a wrapper around a standard `Cursor`, giving it the -ability to cache `Model`, load items at specific position with conversion, and refresh -it's content easily. - -The `FlowCursorList` by default caches its results, for fast usage. The cache size is determined by the `ModelCache` you're using. Read on [here](Caching.md). - -The `FlowCursorList` provides these methods: - - 1. `getItem(position)` - loads item from `Cursor` at specified position, caching and loading from cache (if enabled) - 2. `refresh()` - re-queries the underlying `Cursor`, clears out the cache, and reconstructs it. Use a `OnCursorRefreshListener` to get callbacks when this occurs. - 3. `getAll()` - returns a `List` of all items from the `Cursor`, no caching used - 4. `getCount()` - returns count of `Cursor` or 0 if `Cursor` is `null` - 5. `isEmpty()` - returns if count == 0 - 6. `clearCache()` - manually clears cache - -## Flow Query List - -This class is a much more powerful version of the `FlowCursorList`. It contains a `FlowCursorList`, -which backs it's retrieval operations. - -This class acts as `List` and can be used almost wherever a `List` is used. Also, it is a `FlowContentObserver` -see [Observability](Observability.md), meaning other classes can listen -for its specific changes and it can auto-refresh itself when content changes. - -Feature rundown: - 1. `List` implementation of a Query - 2. `FlowContentObserver`, only for the table that it corresponds to in its initial `ModelQueriable` query statement. Mostly used for self refreshes. - 3. Transact changes to the query asynchronously (note that this refreshes itself every callback unless in a transaction state) - 5. Caching (almost same implementation as `FlowCursorList`) - -### List Implementation - -The `List` implementation is mostly for convenience. Please note that most of the modification -methods (`add`, `addAll` etc.) may not affect the query that you expect it to, unless the object you pass -objects that are valid for the query and you enable self refreshes. - -The retrieval methods are where the query works as you would expect. `get()` calls -`getItem()` on the internal `FlowCursorList`, `isEmpty()`, `getCount()`, etc all correspond -to the `Cursor` underneath. - -Both `FlowQueryList` and `FlowTableList` support `Iterator` and provide a very -efficient class: `FlowCursorIterator` that iterates through each row in a `Cursor` -and provides efficient operations. - -**Note**: any retrieval operation that turns it into another object (i.e. `subList()`, -`toArray`, etc) retrieves all objects contained in the query into memory, -and then converts it using the associated method on that returned `List`. - -### FlowContentObserver Implementation - -Using the `FlowContentObserver`, we can enable self-refreshes whenever a model changes -for the table this query points to. See [Observability](Observability.md). - -To turn on self-refreshes, call `registerForContentChanges(context)`, which requeries -the data whenever it changes. - -We recommend placing this within a transaction on the `FlowQueryList`, so we only -refresh content the minimal amount of times: - -```java - -flowQueryList.beginTransaction(); - -// perform a bunch of modifications - -flowQueryList.endTransactionAndNotify(); - -``` - -To listen for `Cursor` refreshes register a `OnCursorRefreshListener`: - -```java - -modelList - .addOnCursorRefreshListener(new FlowCursorList.OnCursorRefreshListener() { - @Override - public void onCursorRefreshed(FlowCursorList cursorList) { - - } - }); - -``` - - -### Transact Changes Asynchronously - -If you want to pass or modify the `FlowQueryList` asynchronously, set `setTransact(true)`. -This will run all modifications in a `Transaction` and when completed, a `Cursor` refresh occurs. - -You can also register `Transaction.Error` and `Transaction.Success` callbacks for these modifications -on the `FlowQueryList` to handle when these `Transaction` finish. diff --git a/usage2/README.md b/usage2/README.md index 8cf5464b6..0cc64b19f 100644 --- a/usage2/README.md +++ b/usage2/README.md @@ -1,4 +1,4 @@ -# DBFlow +# README DBFlow is a Kotlin SQLite library for Android that makes it ridiculously easy to interact and use databases. Built with Annotation Processing, code use within a DB is fast, efficient, and type-safe. It removes the tedious \(and tough-to-maintain\) database interaction code, while providing a very SQLite-like query syntax. @@ -85,3 +85,4 @@ async { } } ``` + diff --git a/usage2/SUMMARY.md b/usage2/SUMMARY.md deleted file mode 100644 index 6b7273716..000000000 --- a/usage2/SUMMARY.md +++ /dev/null @@ -1,29 +0,0 @@ -# Summary - -* [Introduction](README.md) -* [Including in Project](including-in-project.md) -* [Proguard](proguard.md) -* [Usage](Usage.md) - * [Databases](Databases.md) - * [Models](Models.md) - * [Migrations](Migrations.md) - * [Views](ModelViews.md) - * [Relationships](Relationships.md) - * [Storing Data](StoringData.md) - * [Retrieval](Retrieval.md) - * [SQLite Wrapper Language](SQLiteWrapperLanguage.md) - * [Migrations](Migrations.md) - * [Type Converters](TypeConverters.md) - * [Observability](Observability.md) -* [Kotlin Support](KotlinSupport.md) -* [RX Java Support](RXJavaSupport.md) -* [Advanced Usage](advanced-usage.md) - * [Caching](Caching.md) - * [List Based Queries](ListBasedQueries.md) - * [Multiple Modules](MultipleModules.md) - * [Query Models](QueryModels.md) - * [Indexing](Indexing.md) - * [SQLCipher](SQLCipher.md) -* [Migration 3 Guide](Migration3Guide.md) -* [Migration 4 Guide](Migration4Guide.md) - diff --git a/usage2/advanced-usage.md b/usage2/advanced-usage/README.md similarity index 97% rename from usage2/advanced-usage.md rename to usage2/advanced-usage/README.md index 0eb5b4c7c..a4ebff1fc 100644 --- a/usage2/advanced-usage.md +++ b/usage2/advanced-usage/README.md @@ -2,5 +2,3 @@ This section details the more advanced usages of DBFlow. - - diff --git a/usage2/Caching.md b/usage2/advanced-usage/caching.md similarity index 60% rename from usage2/Caching.md rename to usage2/advanced-usage/caching.md index 591405b0d..e2bd3775a 100644 --- a/usage2/Caching.md +++ b/usage2/advanced-usage/caching.md @@ -1,7 +1,6 @@ # Caching -DBFlow provides powerful caching mechanisms to speed up retrieval from the database -to enable high performance in our applications. +DBFlow provides powerful caching mechanisms to speed up retrieval from the database to enable high performance in our applications. Caching is not enabled by default, but it is very easy to enable. @@ -12,41 +11,25 @@ Caching is not enabled by default, but it is very easy to enable. ## When Not To Use Caching -Do not use caching when: -1. you need a subset of columns from the DB. i.e. (`select(name, age, firstName)`) -2. The data is expected to change frequently as any operation on the DB we do that is not tied to model instances will invalidate our cache anyways. -3. You load data from `@OneToMany`, or have nested `@OneToMany` fields within inner objects. +Do not use caching when: 1. you need a subset of columns from the DB. i.e. \(`select(name, age, firstName)`\) 2. The data is expected to change frequently as any operation on the DB we do that is not tied to model instances will invalidate our cache anyways. 3. You load data from `@OneToMany`, or have nested `@OneToMany` fields within inner objects. **Note**: DBFlow is fast and efficient. Caching may not be required at all, except in very particular use-cases. Do not abuse. You can call `disableCaching()` on a query to ensure it's a fresh dataset. ## How Caching Works -Caching under the hood is done by storing an instance of each `Model` returned from a query on a specific table into memory. - 1. Developer enables caching on Table A - 2. Query from Table A - 3. When receiving the `Cursor`, we read the primary key values from it and look them up from `ModelCache`. If the `Model` exists, return it from cache; otherwise create new instance, read in values, and store in cache. - 4. That instance remains in memory such on next query, we return that instance instead of recreating one from a `Cursor`. - 5. When we call `ModelAdapter.save()`, `insert()`, `update()`, or `delete()`, we update model in the cache so that on next retrieval, the model with proper values is returned. - 6. When wrapper operations are performed on tables with caching, caches are not modified. When doing such a call, please call `TableA_Table.cacheAdapter.clearCache()` +Caching under the hood is done by storing an instance of each `Model` returned from a query on a specific table into memory. 1. Developer enables caching on Table A 2. Query from Table A 3. When receiving the `Cursor`, we read the primary key values from it and look them up from `ModelCache`. If the `Model` exists, return it from cache; otherwise create new instance, read in values, and store in cache. 4. That instance remains in memory such on next query, we return that instance instead of recreating one from a `Cursor`. 5. When we call `ModelAdapter.save()`, `insert()`, `update()`, or `delete()`, we update model in the cache so that on next retrieval, the model with proper values is returned. 6. When wrapper operations are performed on tables with caching, caches are not modified. When doing such a call, please call `TableA_Table.cacheAdapter.clearCache()` ### Supported Backing Objects -Caching is supported under the hood for: - 1. `SparseArray` via `SparseArrayBasedCache` (platform SparseArray) - 2. `Map` via `SimpleMapCache` - 3. `LruCache` via `ModelLruCache` (copy of `LruCache`, so dependency avoided) - 4. Custom Caching classes that implement `ModelCache` +Caching is supported under the hood for: 1. `SparseArray` via `SparseArrayBasedCache` \(platform SparseArray\) 2. `Map` via `SimpleMapCache` 3. `LruCache` via `ModelLruCache` \(copy of `LruCache`, so dependency avoided\) 4. Custom Caching classes that implement `ModelCache` -Cache sizes are not supported for `SimpleMapCache`. This is because `Map` can hold -arbitrary size of contents. +Cache sizes are not supported for `SimpleMapCache`. This is because `Map` can hold arbitrary size of contents. ### Enable Caching To enable caching on a single-primary key table, simply specify that it is enabled: - ```kotlin - @Table(database = AppDatabase.class, cachingEnabled = true) class CacheableModel { @@ -56,14 +39,11 @@ class CacheableModel { @Column var name: String? = null } - ``` or in Java: ```java - - @Table(database = AppDatabase.class, cachingEnabled = true) public class CacheableModel { @@ -73,44 +53,34 @@ public class CacheableModel { @Column String name; } - ``` -to use caching on a table that uses multiple primary keys, [see](Caching.md#multiple-primary-key-caching). +to use caching on a table that uses multiple primary keys, [see](caching.md#multiple-primary-key-caching). -By default we use a `SimpleMapCache`, which loads `Model` into a `Map`. The key is -either the primary key of the object or a combination of the two, but it should have -an associated `HashCode` and `equals()` value. +By default we use a `SimpleMapCache`, which loads `Model` into a `Map`. The key is either the primary key of the object or a combination of the two, but it should have an associated `HashCode` and `equals()` value. ## Modifying Cache Objects -Any time a field on these objects are modified, you _should_ immediately save those -since we have a direct reference to the object from the cache. Otherwise, the DB -and cache could get into an inconsistent state. +Any time a field on these objects are modified, you _should_ immediately save those since we have a direct reference to the object from the cache. Otherwise, the DB and cache could get into an inconsistent state. ```kotlin - database { (select from MyModel::class where (...)).result?.let { result -> result.name = "Name" result.save() } } - ``` ```java - MyModel model = SQLite.select(db).from(MyModel.class).where(...).querySingle(); model.setName("Name"); model.save(); // save it to DB post any modifications to this object. - ``` ## Disable Caching For Some Queries -To disable caching on certain queries as you might want to project on only a few columns, -rather than the full dataset. Just call `disableCaching()`: +To disable caching on certain queries as you might want to project on only a few columns, rather than the full dataset. Just call `disableCaching()`: ```kotlin database { @@ -124,20 +94,17 @@ database { or in Java: ```java - select(db, My_Table.column, My_Table.column2) .from(My.class) .disableCaching() .queryList(); - ``` ## Advanced ### Specifying cache Size -To specify cache size, set `@Table(cacheSize = {size})`. Please note that not all -caches support sizing. It's up to each cache. +To specify cache size, set `@Table(cacheSize = {size})`. Please note that not all caches support sizing. It's up to each cache. ### Custom Caches @@ -150,6 +117,7 @@ companion object { val modelCache = SimpleMapCache() } ``` + or in Java using `public static final`: ```java @@ -159,12 +127,9 @@ public static ModelCache modelCache = new SimpleMapCache<>() ### Multiple Primary Key Caching -This allows for tables that have multiple primary keys be used in caching. To use, -add a `@MultiCacheField` `@JvmField` field. -for example we have a `Coordinate` class: +This allows for tables that have multiple primary keys be used in caching. To use, add a `@MultiCacheField` `@JvmField` field. for example we have a `Coordinate` class: ```kotlin - @Table(database = AppDatabase.class, cachingEnabled = true) class Coordinate(@PrimaryKey latitude: Double = 0.0, @PrimaryKey longitude: Double = 0.0) { @@ -175,8 +140,8 @@ class Coordinate(@PrimaryKey latitude: Double = 0.0, val cacheConverter = IMultiKeyCacheConverter { values -> "${values[0]},${values[1]}" } } } - ``` + or in Java: ```java @@ -200,7 +165,5 @@ public class Coordinate { double longitude; ``` -In this case we use the `IMultiKeyCacheConverter` class, which specifies a key type -that the object returns. The `getCachingKey` method returns an ordered set of `@PrimaryKey` -columns in declaration order. Also the value that is returned should have an `equals()` or `hashcode()` specified (use a `data class`) -especially when used in the `SimpleMapCache`. +In this case we use the `IMultiKeyCacheConverter` class, which specifies a key type that the object returns. The `getCachingKey` method returns an ordered set of `@PrimaryKey` columns in declaration order. Also the value that is returned should have an `equals()` or `hashcode()` specified \(use a `data class`\) especially when used in the `SimpleMapCache`. + diff --git a/usage2/Indexing.md b/usage2/advanced-usage/indexing.md similarity index 80% rename from usage2/Indexing.md rename to usage2/advanced-usage/indexing.md index 75744c81b..61d6db294 100644 --- a/usage2/Indexing.md +++ b/usage2/advanced-usage/indexing.md @@ -2,19 +2,15 @@ In SQLite, an `Index` is a pointer to specific columns in a table that enable super-fast retrieval. -__Note__: The database size can increase significantly, however if performance is more important, the tradeoff is worth it. +**Note**: The database size can increase significantly, however if performance is more important, the tradeoff is worth it. -Indexes are defined using the `indexGroups()` property of the `@Table` annotation. These operate similar to how `UniqueGroup` work: -1. specify an `@IndexGroup` -2. Add the `@Index` -3. Build and an `IndexProperty` gets generated. This allows super-easy access to the index so you can enable/disable it with ease. +Indexes are defined using the `indexGroups()` property of the `@Table` annotation. These operate similar to how `UniqueGroup` work: 1. specify an `@IndexGroup` 2. Add the `@Index` 3. Build and an `IndexProperty` gets generated. This allows super-easy access to the index so you can enable/disable it with ease. -__Note__: `Index` are not explicitly enabled unless coupled with an `IndexMigration`. ([read here](Migrations.md#index-migrations)). +**Note**: `Index` are not explicitly enabled unless coupled with an `IndexMigration`. \([read here](../usage/migrations.md#index-migrations)\). You can define as many `@IndexGroup` you want within a `@Table` as long as one field references the group. Also individual `@Column` can belong to any number of groups: ```java - @Table(database = TestDatabase.class, indexGroups = [ @IndexGroup(number = 1, name = "firstIndex"), @@ -45,11 +41,9 @@ public class IndexModel2 { } ``` -By defining the index this way, we generate an `IndexProperty`, which makes it very -easy to enable, disable, and use it within queries: +By defining the index this way, we generate an `IndexProperty`, which makes it very easy to enable, disable, and use it within queries: ```java - IndexModel2_Table.firstIndex.createIfNotExists(); SQLite.select() @@ -61,22 +55,18 @@ IndexModel2_Table.firstIndex.drop(); // turn it off when no longer needed. ``` ```kotlin - IndexModel2_Table.firstIndex.createIfNotExists() (select from IndexModel2::class indexedBy IndexModel2_Table.firstIndex where (...)) IndexModel2_Table.firstIndex.drop() // turn it off when no longer needed. - ``` ## SQLite Index Wrapper -For flexibility, we also support the SQLite `Index` wrapper object, in which the `IndexProperty` -uses underneath. +For flexibility, we also support the SQLite `Index` wrapper object, in which the `IndexProperty` uses underneath. ```java - Index index = SQLite.index("MyIndex") .on(SomeTable.class, SomeTable_Table.name, SomeTable_Table.othercolumn); index.enable(); @@ -84,15 +74,12 @@ index.enable(); // do some operations index.disable(); // disable when no longer needed - ``` - ```kotlin - val index = indexOn("MyIndex", SomeTable_Table.name, SomeTable_Table.othercolumn) index.enable() index.disable() - ``` + diff --git a/usage2/advanced-usage/listbasedqueries.md b/usage2/advanced-usage/listbasedqueries.md new file mode 100644 index 000000000..2a98ca1c0 --- /dev/null +++ b/usage2/advanced-usage/listbasedqueries.md @@ -0,0 +1,122 @@ +# ListBasedQueries + +When we have large datasets from the database in our application, we wish to display them in a `ListView`, `RecyclerView` or some other component that recycles it's views. Instead of running a potentially very large query on the database, converting it to a `List` and then keeping that chunk of memory active, we can lazy-load each row from the query/table. + +DBFlow makes it easy using the `FlowCursorList`, for simple `BaseAdapter`-like methods, or the `FlowQueryList`, which implements the `List` interface. + +Getting one of these lists is as simple as: + +```java +FlowQueryList list = SQLite.select() + .from(MyTable.class) + .where(...) // some conditions + .flowQueryList(); +FlowCursorList list = SQLite.select() + .from(MyTable.class) + .where(...) // some conditions + .cursorList(); + + list.close(); // ensure you close these, as they utilize active cursors :) +``` + +```kotlin +val list = (select from MyTable::class where (...)).cursorList +val list = (select from MyTable::class where (...)).flowQueryList +list.close() +``` + +Any query method allows you to retrieve a default implementation of each. You can also manually instantiate them: + +```java +FlowQueryList list = new FlowQueryList.Builder<>(SQLite.select().from(MyTable.class)) + .cachingEnabled(false) // caching enabled by default + .build(); + +FlowCursorList list = new FlowCursorList.Builder<>(SQLite.select().from(MyTable.class)) + .cachingEnabled(true) + .modelCache(cache) // provide custom cache for this list + .build(); +``` + +## Caching + +Both of these classes come with the ability to cache `Model` used in it's queries so that loading only happens once and performance can remain high once loaded. The default caching mechanism is a `ModelLruCache`, which provides an `LruCache` to manage loading `Model`. + +They are done in almost the same way: + +```java +FlowCursorList list = new FlowCursorList.Builder<>(SQLite.select().from(MyTable.class)) + .modelCache(cache) // provide custom cache for this list + .build(); +FlowQueryList list = new FlowQueryList.Builder<>(SQLite.select().from(MyTable.class)) + .modelCache(cache) + .build(); +``` + +## FlowCursorList + +The `FlowCursorList` is simply a wrapper around a standard `Cursor`, giving it the ability to cache `Model`, load items at specific position with conversion, and refresh it's content easily. + +The `FlowCursorList` by default caches its results, for fast usage. The cache size is determined by the `ModelCache` you're using. Read on [here](caching.md). + +The `FlowCursorList` provides these methods: + +1. `getItem(position)` - loads item from `Cursor` at specified position, caching and loading from cache \(if enabled\) +2. `refresh()` - re-queries the underlying `Cursor`, clears out the cache, and reconstructs it. Use a `OnCursorRefreshListener` to get callbacks when this occurs. +3. `getAll()` - returns a `List` of all items from the `Cursor`, no caching used +4. `getCount()` - returns count of `Cursor` or 0 if `Cursor` is `null` +5. `isEmpty()` - returns if count == 0 +6. `clearCache()` - manually clears cache + +## Flow Query List + +This class is a much more powerful version of the `FlowCursorList`. It contains a `FlowCursorList`, which backs it's retrieval operations. + +This class acts as `List` and can be used almost wherever a `List` is used. Also, it is a `FlowContentObserver` see [Observability](../usage/observability.md), meaning other classes can listen for its specific changes and it can auto-refresh itself when content changes. + +Feature rundown: 1. `List` implementation of a Query 2. `FlowContentObserver`, only for the table that it corresponds to in its initial `ModelQueriable` query statement. Mostly used for self refreshes. 3. Transact changes to the query asynchronously \(note that this refreshes itself every callback unless in a transaction state\) 5. Caching \(almost same implementation as `FlowCursorList`\) + +### List Implementation + +The `List` implementation is mostly for convenience. Please note that most of the modification methods \(`add`, `addAll` etc.\) may not affect the query that you expect it to, unless the object you pass objects that are valid for the query and you enable self refreshes. + +The retrieval methods are where the query works as you would expect. `get()` calls `getItem()` on the internal `FlowCursorList`, `isEmpty()`, `getCount()`, etc all correspond to the `Cursor` underneath. + +Both `FlowQueryList` and `FlowTableList` support `Iterator` and provide a very efficient class: `FlowCursorIterator` that iterates through each row in a `Cursor` and provides efficient operations. + +**Note**: any retrieval operation that turns it into another object \(i.e. `subList()`, `toArray`, etc\) retrieves all objects contained in the query into memory, and then converts it using the associated method on that returned `List`. + +### FlowContentObserver Implementation + +Using the `FlowContentObserver`, we can enable self-refreshes whenever a model changes for the table this query points to. See [Observability](../usage/observability.md). + +To turn on self-refreshes, call `registerForContentChanges(context)`, which requeries the data whenever it changes. + +We recommend placing this within a transaction on the `FlowQueryList`, so we only refresh content the minimal amount of times: + +```java +flowQueryList.beginTransaction(); + +// perform a bunch of modifications + +flowQueryList.endTransactionAndNotify(); +``` + +To listen for `Cursor` refreshes register a `OnCursorRefreshListener`: + +```java +modelList + .addOnCursorRefreshListener(new FlowCursorList.OnCursorRefreshListener() { + @Override + public void onCursorRefreshed(FlowCursorList cursorList) { + + } + }); +``` + +### Transact Changes Asynchronously + +If you want to pass or modify the `FlowQueryList` asynchronously, set `setTransact(true)`. This will run all modifications in a `Transaction` and when completed, a `Cursor` refresh occurs. + +You can also register `Transaction.Error` and `Transaction.Success` callbacks for these modifications on the `FlowQueryList` to handle when these `Transaction` finish. + diff --git a/usage2/MultipleModules.md b/usage2/advanced-usage/multiplemodules.md similarity index 51% rename from usage2/MultipleModules.md rename to usage2/advanced-usage/multiplemodules.md index 8b2ce6f57..bb27d8bf9 100644 --- a/usage2/MultipleModules.md +++ b/usage2/advanced-usage/multiplemodules.md @@ -1,14 +1,10 @@ -# Multiple Database Modules +# MultipleModules -In apps that want to share DBFlow across multiple modules or when developing a library -module that uses DBFlow, we have to provide a little extra configuration to properly -ensure that all database classes are accounted for. +In apps that want to share DBFlow across multiple modules or when developing a library module that uses DBFlow, we have to provide a little extra configuration to properly ensure that all database classes are accounted for. -It's directly related to the fact that annotation processors are isolated between projects -and are not shared. +It's directly related to the fact that annotation processors are isolated between projects and are not shared. -In order to add support for multiple modules, in each and every library/subproject that uses -a DBFlow instance, you must add an APT argument (using the [android-apt plugin](https://bitbucket.org/hvisser/android-apt)) to its `build.gradle`: +In order to add support for multiple modules, in each and every library/subproject that uses a DBFlow instance, you must add an APT argument \(using the [android-apt plugin](https://bitbucket.org/hvisser/android-apt)\) to its `build.gradle`: ```java apt { @@ -29,20 +25,15 @@ kapt { } ``` +By passing the targetModuleName, we append that to the `GeneratedDatabaseHolder` class name to create the `{targetModuleName}GeneratedDatabaseHolder` module. **Note**: Specifying this in code means you need to specify the module when initializing DBFlow: -By passing the targetModuleName, we append that to the `GeneratedDatabaseHolder` class name to create the `{targetModuleName}GeneratedDatabaseHolder` module. __Note__: Specifying this in code means -you need to specify the module when initializing DBFlow: - -From previous sample code, we recommend initializing the specific module inside your library, -to prevent developer error. __Note__: Multiple calls to `FlowManager` will not adversely -affect DBFlow. If DBFlow is already initialized, we append the module to DBFlow if and only if it does not already exist. +From previous sample code, we recommend initializing the specific module inside your library, to prevent developer error. **Note**: Multiple calls to `FlowManager` will not adversely affect DBFlow. If DBFlow is already initialized, we append the module to DBFlow if and only if it does not already exist. ```java - public void initialize(Context context) { FlowManager.init(FlowConfig.builder(context) .addDatabaseHolder(SomeUniqueModuleNameGeneratedDatabaseHolder.class) .build()); } - ``` + diff --git a/usage2/QueryModels.md b/usage2/advanced-usage/querymodels.md similarity index 68% rename from usage2/QueryModels.md rename to usage2/advanced-usage/querymodels.md index 804d1ad40..23a66736d 100644 --- a/usage2/QueryModels.md +++ b/usage2/advanced-usage/querymodels.md @@ -1,20 +1,16 @@ -# Query Models +# QueryModels -A `QueryModel` is purely an ORM object that maps rows from a `Cursor` into -a `Model` such that when loading from the DB, we can easily use the data from it. +A `QueryModel` is purely an ORM object that maps rows from a `Cursor` into a `Model` such that when loading from the DB, we can easily use the data from it. -We use a different annotation, `@QueryModel`, to define it separately. These -do not allow for modifications in the DB, rather act as a marshal agent out of the DB. +We use a different annotation, `@QueryModel`, to define it separately. These do not allow for modifications in the DB, rather act as a marshal agent out of the DB. ## Define a QueryModel -For this example, we have a list of employees that we want to gather the average salary -for each position in each department from our company. +For this example, we have a list of employees that we want to gather the average salary for each position in each department from our company. We defined an `Employee` table: ```java - @Table(database = AppDatabase.class) public class EmployeeModel { @@ -33,22 +29,16 @@ public class EmployeeModel { @Column String department; } - ``` -We need someway to retrieve the results of this query, since we want to avoid -dealing with the `Cursor` directly. We can use a SQLite query with our existing models, but -we have no way to map it currently to our tables, since the query returns new Columns -that do not represent any existing table: +We need someway to retrieve the results of this query, since we want to avoid dealing with the `Cursor` directly. We can use a SQLite query with our existing models, but we have no way to map it currently to our tables, since the query returns new Columns that do not represent any existing table: ```java - SQLite.select(EmployeeModel_Table.department, Method.avg(EmployeeModel_Table.salary.as("average_salary")), EmployeeModel_Table.title) .from(EmployeeModel.class) .groupBy(EmployeeModel_Table.department, EmployeeModel_Table.title); - ``` So we must define a `QueryModel`, representing the results of the query: @@ -71,7 +61,6 @@ public class AverageSalary { And adjust our query to handle the new output: ```java - SQLite.select(EmployeeModel_Table.department, Method.avg(EmployeeModel_Table.salary.as("average_salary")), EmployeeModel_Table.title) @@ -86,22 +75,15 @@ SQLite.select(EmployeeModel_Table.department, // do something with the result } }).execute(); - ``` ## Query Model Support `QueryModel` support only a limited subset of `Model` features. -If you use the optional base class of `BaseQueryModel`, - Modifications such as `insert()`, `update()`, `save()`, and `delete()` will throw - an `InvalidSqlViewOperationException`. Otherwise, `RetrievalAdapter` do not - contain modification methods. +If you use the optional base class of `BaseQueryModel`, Modifications such as `insert()`, `update()`, `save()`, and `delete()` will throw an `InvalidSqlViewOperationException`. Otherwise, `RetrievalAdapter` do not contain modification methods. + +They support `allFields` and inheritance and visibility modifiers as defined by [Models](../usage/models.md). -They support `allFields` and inheritance and visibility modifiers as defined by [Models](Models.md). +`QueryModel` **do not** support: 1. `InheritedField`/`InheritedPrimaryKey` 2. `@PrimaryKey`/`@ForeignKey` 3. caching 4. changing "useBooleanGetterSetters" for private boolean fields. -`QueryModel` **do not** support: - 1. `InheritedField`/`InheritedPrimaryKey` - 2. `@PrimaryKey`/`@ForeignKey` - 3. caching - 4. changing "useBooleanGetterSetters" for private boolean fields. diff --git a/usage2/SQLCipherSupport.md b/usage2/advanced-usage/sqlciphersupport.md similarity index 91% rename from usage2/SQLCipherSupport.md rename to usage2/advanced-usage/sqlciphersupport.md index 12fcc48ce..64ed22055 100644 --- a/usage2/SQLCipherSupport.md +++ b/usage2/advanced-usage/sqlciphersupport.md @@ -1,4 +1,4 @@ -# SQLCipher Support +# SQLCipher As of 3.0.0-beta2+, DBFlow now supports [SQLCipher](https://www.zetetic.net/sqlcipher/) fairly easily. @@ -12,12 +12,13 @@ dependencies { ``` You also need to add the Proguard rule: -``` + +```text -keep class net.sqlcipher.** { *; } -dontwarn net.sqlcipher.** ``` -Next, you need to subclass the provided `SQLCipherOpenHelper` (taken from test files): +Next, you need to subclass the provided `SQLCipherOpenHelper` \(taken from test files\): ```kotlin class SQLCipherOpenHelperImpl(context: Context, @@ -41,3 +42,4 @@ FlowManager.init(FlowConfig.Builder(this) ``` And that's it. You're all set to start using SQLCipher! + diff --git a/usage2/ContentProviderGeneration.md b/usage2/contentprovidergeneration.md similarity index 83% rename from usage2/ContentProviderGeneration.md rename to usage2/contentprovidergeneration.md index fe6f1e601..4acc637f4 100644 --- a/usage2/ContentProviderGeneration.md +++ b/usage2/contentprovidergeneration.md @@ -1,15 +1,16 @@ -# Content Provider Generation +# ContentProviderGeneration + This library includes a very fast, easy way to use `ContentProvider`! Using annotations, you can generate `ContentProvider` with ease. ## Getting Started -This feature is largely based off of [schematic](https://github.com/SimonVT/schematic), - while leveraging DBFlow's power. + +This feature is largely based off of [schematic](https://github.com/SimonVT/schematic), while leveraging DBFlow's power. ### Placeholder ContentProvider + In order to define a `ContentProvider`, you must define it in a placeholder class: ```java - @ContentProvider(authority = TestContentProvider.AUTHORITY, database = TestDatabase.class, baseContentUri = TestContentProvider.BASE_CONTENT_URI) @@ -25,7 +26,6 @@ public class TestContentProvider { or you can use the annotation in any class you wish. The recommended place would be in a `@Database` placeholder class. This is to simplify some of the declarations and keep it all in one place. ```java - @ContentProvider(authority = TestDatabase.AUTHORITY, database = TestDatabase.class, baseContentUri = TestDatabase.BASE_CONTENT_URI) @@ -44,10 +44,10 @@ public class TestDatabase { ``` ### Adding To Manifest -In other applications or your current's `AndroidManifest.xml` add the **generated $Provider** class: -```xml +In other applications or your current's `AndroidManifest.xml` add the **generated $Provider** class: +```markup { @@ -144,6 +137,7 @@ public class ContentProviderModel extends BaseProviderModel ``` -A database within DBFlow is only initialized once you call `database()`. If you -don't want this behavior or prefer it to happen immediately, modify your `FlowConfig`: +A database within DBFlow is only initialized once you call `database()`. If you don't want this behavior or prefer it to happen immediately, modify your `FlowConfig`: ```kotlin - override fun onCreate() { super.onCreate() FlowManager.init(FlowConfig.builder(this) .openDatabasesOnInit(true) .build()) } - ``` ```java - @Override public void onCreate() { super.onCreate(); @@ -97,46 +80,36 @@ public void onCreate() { .openDatabasesOnInit(true) .build()); } - ``` If you do not like the built-in `DefaultTransactionManager`, or just want to roll your own existing system: ```kotlin - FlowManager.init(FlowConfig.builder(this) .database(DatabaseConfig.builder(AppDatabase::class) .transactionManager(CustomTransactionManager()) .build())) - ``` -You can define different kinds for each database. -To read more on transactions and subclassing `BaseTransactionManager` go [here](StoringData.md) +You can define different kinds for each database. To read more on transactions and subclassing `BaseTransactionManager` go [here](usage/storingdata.md) ## Create Models -Creating models are as simple as defining the model class, and adding the `@Table` annotation. -To read more on this, read [here](Models.md). +Creating models are as simple as defining the model class, and adding the `@Table` annotation. To read more on this, read [here](usage/models.md). -**For now**: Models must provide a default, parameterless constructor. -An example: +**For now**: Models must provide a default, parameterless constructor. An example: ```kotlin - @Table(database = TestDatabase::class) class Currency(@PrimaryKey(autoincrement = true) var id: Long = 0, @Column @Unique var symbol: String? = null, @Column var shortName: String? = null, @Column @Unique var name: String = "") // nullability of fields are respected. We will not assign a null value to this field. - ``` or with Java: ```java - - @Table(database = TestDatabase.class) public class Currency { @@ -162,7 +135,6 @@ public class Currency { this.name = name; } } - ``` ## Perform Some Queries @@ -171,16 +143,13 @@ DBFlow uses expressive builders to represent and translate to the SQLite languag A simple query in SQLite: -```sqlite - +```text SELECT * FROM Currency WHERE symbol='$'; - ``` -DBFlow Kotlin (by using our `dbflow-coroutines` module): +DBFlow Kotlin \(by using our `dbflow-coroutines` module\): ```kotlin - async { database{ val list = awaitTransact( @@ -190,21 +159,17 @@ async { // use the objects here } } - ``` or in Java with fluent syntax ```java - SQLite.select(FlowManager.getDatabase(AppDatabase.class)) .from(Currency.class) .where(Currency_Table.symbol.eq("$")); - ``` -We support many kinds of complex and complicated queries using the builder -language. To read more about this, see [the wrapper language docs](SQLiteWrapperLanguage.md) +We support many kinds of complex and complicated queries using the builder language. To read more about this, see [the wrapper language docs](usage/sqlitewrapperlanguage.md) + +There is much more you can do in DBFlow. Read through the other docs to get a sense of the library. -There is much more you can do in DBFlow. Read through the other docs to -get a sense of the library. diff --git a/usage2/including-in-project.md b/usage2/including-in-project.md index a00bc77e4..40c4eb912 100644 --- a/usage2/including-in-project.md +++ b/usage2/including-in-project.md @@ -1,4 +1,4 @@ -# Including in your Project +# Including In Project DBFlow has a number of artifacts that you can include in the project. @@ -16,12 +16,11 @@ DBFlow has a number of artifacts that you can include in the project. **SQLCipher:** Easy database encryption support in this library. -### Add the jitpack.io repository +## Add the jitpack.io repository This repo is used to publish the artifacts. It also enables [dynamic builds](https://jitpack.io/docs/), allowing you to specify specific branches or commit hashes of the project to include outside of normal releases. ```groovy - allProjects { repositories { google() @@ -35,7 +34,6 @@ allProjects { Add artifacts to your project: ```groovy - apply plugin: 'kotlin-kapt' // only required for kotlin consumers. def dbflow_version = "5.0.0-alpha1" @@ -50,7 +48,7 @@ Add artifacts to your project: // if only using Java, use this. If using Kotlin do NOT use this. annotationProcessor "com.github.agrosner.dbflow:processor:${dbflow_version}" - + // core set of libraries compile "com.github.agrosner.dbflow:core:${dbflow_version}" compile "com.github.agrosner.dbflow:lib:${dbflow_version}" @@ -72,5 +70,5 @@ Add artifacts to your project: compile "com.github.agrosner.dbflow:contentprovider:${dbflow_version}" } - ``` + diff --git a/usage2/KotlinSupport.md b/usage2/kotlinsupport.md similarity index 83% rename from usage2/KotlinSupport.md rename to usage2/kotlinsupport.md index 74824a419..eb9cf5268 100644 --- a/usage2/KotlinSupport.md +++ b/usage2/kotlinsupport.md @@ -1,4 +1,4 @@ -# Kotlin Support + Extensions +# KotlinSupport DBFlow supports Kotlin out of the box and is fairly easily to use and implement. @@ -18,41 +18,36 @@ Also `data` classes are supported. data class Car(@PrimaryKey var id: Int = 0, @Column var name: String? = null) ``` -In 4.0.0+, DBFlow contains a few extensions for Kotlin models which enable you -to keep your models acting like `BaseModel`, but do not have to explicitly extend -the class! +In 4.0.0+, DBFlow contains a few extensions for Kotlin models which enable you to keep your models acting like `BaseModel`, but do not have to explicitly extend the class! ```kotlin - car.save() // extension method, optional databaseWrapper parameter. car.insert() car.update() car.delete() car.exists() - ``` ## Null Safety -DBFlow reflects the nullability on fields defined in their classes. If you define a -`@Column` as not null, it will not assign a null value to that field in the generated java. + +DBFlow reflects the nullability on fields defined in their classes. If you define a `@Column` as not null, it will not assign a null value to that field in the generated java. ## Query LINQ Syntax -Kotlin has nice support for custim `infix` operators. Using this we can convert a regular, Plain old java query into a C#-like LINQ syntax. +Kotlin has nice support for custim `infix` operators. Using this we can convert a regular, Plain old java query into a C\#-like LINQ syntax. java: -``` +```text List = SQLite.select() .from(Result.class) .where(Result_Table.column.eq(6)) .and(Result_Table.column2.in("5", "6", "9")).queryList() - ``` kotlin: -``` +```text val results = (select from Result::class where (column eq 6) @@ -65,17 +60,11 @@ val results = (select Enabling us to write code that is closer in syntax to SQLite! -This supported for almost any SQLite operator that this library provides including: - 1. `Select` - 2. `Insert` - 3. `Update` - 4. `Delete` +This supported for almost any SQLite operator that this library provides including: 1. `Select` 2. `Insert` 3. `Update` 4. `Delete` -**Async Operations**: -With extensions we also support `async` operations on queries: +**Async Operations**: With extensions we also support `async` operations on queries: ```kotlin - // easy async list query (select from Result::class @@ -99,34 +88,27 @@ val model = Result() model.async save { // completed, now do something with model } - ``` ### Property Extensions With Kotlin, we can define extension methods on pretty much any class. -With this, we added methods to easily create `IProperty` from anything to make -queries a little more streamlined. In this query, we also make use of the extension -method for `from` to streamline the query even more. +With this, we added methods to easily create `IProperty` from anything to make queries a little more streamlined. In this query, we also make use of the extension method for `from` to streamline the query even more. ```kotlin - var query = (select from TestModel::class where (5.property lessThan column) and (clause(date.property between start_date) and(end_date))) - - ``` ### Query Extensions -We can easily create nested `Operator` into `OperatorGroup` also fairly easily, also -other, random extensions: -```kotlin +We can easily create nested `Operator` into `OperatorGroup` also fairly easily, also other, random extensions: +```kotlin select from SomeTable::class where (name.eq("name") and id.eq(0)) "name".op() collate NOCASE @@ -138,10 +120,8 @@ select from SomeTable::class where (name.eq("name") and id.eq(0)) // query sugar select from SomeTable::class where (name eq "name") or (id eq 0) - ``` - ### Database Extensions #### Process Models Asynchronously @@ -149,7 +129,6 @@ select from SomeTable::class where (name eq "name") or (id eq 0) In Java, we need to write something of the fashion: ```java - List items = SQLite.select() .from(TestModel.class) .queryList(); @@ -164,13 +143,11 @@ List items = SQLite.select() .success(successCallback) .error(errorCallback).build() .execute(); - ``` In Kotlin, we can use a combo of DSL and extension methods to: ```kotlin - var items = (select from TestModel1::class).list // easily delete all these items. @@ -189,27 +166,21 @@ items.processInTransactionAsync({ it, databaseWrapper -> it.delete(databaseWrapp error = { transaction, throwable -> }) - ``` -The extension method on `Collection` allows you to perform this on all -collections from your Table! +The extension method on `Collection` allows you to perform this on all collections from your Table! If you wish to easily do them _synchronously_ then use: ```kotlin - items.processInTransaction { it, databaseWrapper -> it.delete(databaseWrapper) } - ``` #### Class Extensions -If you need access to the Database, ModelAdapter, etc for a specific class you -can now use the following (and more) inline reified global functions for easy access! +If you need access to the Database, ModelAdapter, etc for a specific class you can now use the following \(and more\) inline reified global functions for easy access! ```kotlin - database() databaseForTable() @@ -219,8 +190,7 @@ writableDatabaseForTable() tableName() modelAdapter() - - ``` Which under-the-hood call their corresponding `FlowManager` methods. + diff --git a/usage2/Migration3Guide.md b/usage2/migration3guide.md similarity index 79% rename from usage2/Migration3Guide.md rename to usage2/migration3guide.md index ca35a671e..22a64fa5b 100644 --- a/usage2/Migration3Guide.md +++ b/usage2/migration3guide.md @@ -1,27 +1,23 @@ -# DBFlow 3.0 Migration Guide +# Migration3Guide + DBFlow has undergone the most _significant_ changes in its lifetime in 3.0. This guide is meant to assist you in migrating from 2.1.x and above and _may not_ be fully inclusive of all changes. This doc will mention the most glaring and significant changes. If in doubt, consult the usage2 docs. A significant portion of the changes include the _complete_ overhaul of the underlying annotation processor, leading to wonderful improvements in maintainability of the code, readability, and stability of the generated code. Now it uses the updated [JavaPoet](https://github.com/square/javapoet) vs the outdated JavaWriter. The changes in this library alone _significantly_ helps out the stability of the generated code. -_Some Changes to Note:_ -1. `update` no longer attempts to `insert` if it fails. -2. Package private fields from other packages are now automatically accessible via generated `_Helper` classes. The referenced fields must be annotated with `@Column`, `@PrimaryKey`, or `@ForeignKey`. if its a legacy `ForeignKeyReference`, `referendFieldIsPackagePrivate()` must be set to true. -3. `@Column` no longer required in conjunction with `@PrimaryKey` or `@ForeignKey` -4. Can now have DBFlow in multiple modules, libraries, etc via "Modules"! -5. `TransactionManager` has been replaced with a new per-database `BaseTransactionManager`. Each DB has its own `DBTransactionQueue` and you can replace the default with your own system. Also, no longer is this priority-based, but rather order-based. See more [here](Transactions.md) +_Some Changes to Note:_ 1. `update` no longer attempts to `insert` if it fails. 2. Package private fields from other packages are now automatically accessible via generated `_Helper` classes. The referenced fields must be annotated with `@Column`, `@PrimaryKey`, or `@ForeignKey`. if its a legacy `ForeignKeyReference`, `referendFieldIsPackagePrivate()` must be set to true. 3. `@Column` no longer required in conjunction with `@PrimaryKey` or `@ForeignKey` 4. Can now have DBFlow in multiple modules, libraries, etc via "Modules"! 5. `TransactionManager` has been replaced with a new per-database `BaseTransactionManager`. Each DB has its own `DBTransactionQueue` and you can replace the default with your own system. Also, no longer is this priority-based, but rather order-based. See more [here](https://github.com/agrosner/DBFlow/tree/fb3739caa4c894d50fd0d7873c70a33416c145e6/usage2/Transactions.md) -This doc is to provide some basic examples of what has changed, but read all of the new usage docs! -Starting with [Intro](Intro.md) +This doc is to provide some basic examples of what has changed, but read all of the new usage docs! Starting with [Intro]() ## Table Of Contents - 1. [Initialization](Migration3Guide.md#initialization) - 2. [Database + Table Structure](Migration3Guide.md#database-and-table-structure) - 3. [Transactions Overhaul](Migration3Guide.md#transactions-overhaul) - 4. [Properties](Migration3Guide.md#properties) - 5. [ModelContainers](Migration3Guide.md#modelcontainers) - 6. [ModelViews](Migration3Guide.md#modelviews) - 7. [Caching](Migration3Guide.md#caching) - 8. [Database Modules](Migration3Guide.md#database-modules) + +1. [Initialization](migration3guide.md#initialization) +2. [Database + Table Structure](migration3guide.md#database-and-table-structure) +3. [Transactions Overhaul](migration3guide.md#transactions-overhaul) +4. [Properties](migration3guide.md#properties) +5. [ModelContainers](migration3guide.md#modelcontainers) +6. [ModelViews](migration3guide.md#modelviews) +7. [Caching](migration3guide.md#caching) +8. [Database Modules](migration3guide.md#database-modules) ## Initialization @@ -36,7 +32,6 @@ public class ExampleApplication extends Application { FlowManager.init(this); } } - ``` Now we use the `FlowConfig.Builder`: @@ -50,28 +45,27 @@ public class ExampleApplication extends Application { FlowManager.init(new FlowConfig.Builder(this).build()); } } - ``` -See more of what you can customize [here](GettingStarted.md) +See more of what you can customize [here](gettingstarted.md) ## Database And Table Structure + ### Database changes + The default `generatedClassSeparator` is now `_` instead of `$` to play nice with Kotlin by default. A simple addition of: ```java - @Database(generatedClassSeparator = "$") ``` will keep your generated "Table" and other classes the same name. -Globally, we no longer reference what `@Database` any database-specific element (Table, Migration, etc) by `String` name, but by `Class` now. +Globally, we no longer reference what `@Database` any database-specific element \(Table, Migration, etc\) by `String` name, but by `Class` now. Before: ```java - @Table(databaseName = AppDatabase.NAME) @Migration(databaseName = AppDatabase.NAME) ``` @@ -79,7 +73,6 @@ Before: After: ```java - @Table(database = AppDatabase.class) @Migration(database = AppDatabase.class) ``` @@ -87,21 +80,18 @@ After: Why: We decided that referencing it directly by class name enforces type-safety and direct enforcement of the database placeholder class. Previously, ```java - @Table(databaseName = "AppDatabase") ``` was a valid specifier, which might lead to typos or errors. ## Table Changes + `@Table` have some significant changes. -Private boolean fields by default have changed. -`useIsForPrivateBooleans()` has changed to `useBooleanGetterSetters()`. By default -this is enabled, meaning `boolean` variables follow the convention: +Private boolean fields by default have changed. `useIsForPrivateBooleans()` has changed to `useBooleanGetterSetters()`. By default this is enabled, meaning `boolean` variables follow the convention: ```java - private boolean isEnabled; public boolean isEnabled() { @@ -111,15 +101,13 @@ public boolean isEnabled() { public void setEnabled(boolean isEnabled) { this.isEnabled = isEnabled; } - ``` -Instead of generating just `String` column name within a corresponding `$Table` class, it now generates `Property` fields. These fields are significantly smarter and more powerful. They considerably aid in the simplification of many complex queries and make the code in general more readable, type-safe, and just overall better. _NOTE: the properties are no longer capitalized, rather they match exact casing of the Column name._ +Instead of generating just `String` column name within a corresponding `$Table` class, it now generates `Property` fields. These fields are significantly smarter and more powerful. They considerably aid in the simplification of many complex queries and make the code in general more readable, type-safe, and just overall better. _NOTE: the properties are no longer capitalized, rather they match exact casing of the Column name._ Previously, when you defined a class as: ```java - @Table(databaseName = TestDatabase.NAME) @ModelContainer public class TestModel2 extends BaseModel { @@ -136,7 +124,6 @@ public class TestModel2 extends BaseModel { It generated a `TestModel2$Table` class: ```java - public final class TestModel2_Table { public static final String NAME = "name"; @@ -181,9 +168,10 @@ The `getProperty()` method allows to keep compatibility with the old format, sol To read on how these properties interact read "Properties, Conditions, Queries, Replacement of ConditionQueryBuilder and more". ### Index changes + Added was an `IndexGroup[]` of `indexGroups()`. -Now we can generate `IndexProperty` (see properties for more information), which provide us a convenient generated `Index` to use for the table. This then is used in a queries that rely on indexes and make it dead simple to activate and deactivate indexes. +Now we can generate `IndexProperty` \(see properties for more information\), which provide us a convenient generated `Index` to use for the table. This then is used in a queries that rely on indexes and make it dead simple to activate and deactivate indexes. A class written like: @@ -232,7 +220,9 @@ public final class IndexModel2_Table { ``` ### Foreign Key Changes -`@ForeignKey` fields no longer need to specify it's references or the `@Column` annotation!!! The old way still works, but is no longer necessary for `Model`-based ForeignKeys. The annotation processor takes the primary keys of the referenced table and generates a column with {fieldName}_{referencedColumnName} that represents the same SQLite Type of the field.
_Note: that is not backwards compatible_ with apps already with references. + +`@ForeignKey` fields no longer need to specify it's references or the `@Column` annotation!!! The old way still works, but is no longer necessary for `Model`-based ForeignKeys. The annotation processor takes the primary keys of the referenced table and generates a column with {fieldName}_{referencedColumnName} that represents the same SQLite Type of the field._ +_\_Note: that is not backwards compatible_ with apps already with references. Going forward with new tables, you can leave them out. @@ -278,14 +268,11 @@ If you wish to keep old references, please keep in mind that `foreignColumnName` ## Transactions Overhaul -In 3.0, Transactions got a serious facelift and should be easier to use and handle. -Also their logic and use are much more consolidated a focused. There is no longer -just one `TransactionManager`, rather each database has its own instance so that -operations between databases don't interfere. +In 3.0, Transactions got a serious facelift and should be easier to use and handle. Also their logic and use are much more consolidated a focused. There is no longer just one `TransactionManager`, rather each database has its own instance so that operations between databases don't interfere. ### Inserting Data -The format of how to declare them has changed: -Previously to run a transaction, you had to set it up as so: + +The format of how to declare them has changed: Previously to run a transaction, you had to set it up as so: ```java ProcessModelInfo processModelInfo = ProcessModelInfo.withModels(models) @@ -294,15 +281,11 @@ ProcessModelInfo processModelInfo = ProcessModelInfo.withM TransactionManager.getInstance().addTransaction(new SaveModelTransaction<>(processModelInfo)) TransactionManager.getInstance().addTransaction(new UpdateModelListTransaction<>(processModelInfo)) TransactionManager.getInstance().addTransaction(new DeleteModelListTransaction<>(processModelInfo)) - - ``` -In 3.0, we have dropped the individual transaction types, use a new builder notation, -and with _every_ `Transaction` you get completion and error handling: +In 3.0, we have dropped the individual transaction types, use a new builder notation, and with _every_ `Transaction` you get completion and error handling: ```java - FlowManager.getDatabase(AppDatabase.class) .beginTransactionAsync(new ProcessModelTransaction.Builder<>( new ProcessModelTransaction.ProcessModel() { @@ -323,56 +306,43 @@ FlowManager.getDatabase(AppDatabase.class) } }).build().execute(); - ``` -One thing to note about the `Transaction.Error` is that if specified, _all_ exceptions -are caught and passed to the callback, otherwise any exception that happens in the Transaction system -gets thrown. +One thing to note about the `Transaction.Error` is that if specified, _all_ exceptions are caught and passed to the callback, otherwise any exception that happens in the Transaction system gets thrown. You still can use the `DBBatchSaveQueue` for batch saves: Previously: ```java - TransactionManager.getInstance().saveOnSaveQueue(models); - ``` In 3.0: ```java - FlowManager.getDatabase(AppDatabase.class).getTransactionManager() .getSaveQueue().addAll(models); - - ``` ### Querying Data -Previously when you queried data you have a few different classes that did almost same thing -such as `SelectListTransaction`, `BaseResultTransaction`, `QueryTransaction`, etc. -3.0 consolidates these into much simpler operations via: +Previously when you queried data you have a few different classes that did almost same thing such as `SelectListTransaction`, `BaseResultTransaction`, `QueryTransaction`, etc. 3.0 consolidates these into much simpler operations via: Previously: ```java - TransactionManager.getInstance().addTransaction(new SelectListTransaction<>(new TransactionListenerAdapter() { @Override public void onResultReceived(List testModels) { } }, TestModel.class, condition1, condition2,..); - - ``` + In 3.0: ```java - database.beginTransactionAsync( new QueryTransaction.Builder<>( SQLite.select().from(TestModel1.class)) @@ -382,11 +352,9 @@ database.beginTransactionAsync( } }).build()).build(); - ``` -The `QueryResultCallback` gives back a `CursorResult`, which is a wrapper around abstract -`Cursor` that lets you retrieve easily `Models` from that cursor: +The `QueryResultCallback` gives back a `CursorResult`, which is a wrapper around abstract `Cursor` that lets you retrieve easily `Models` from that cursor: ```java List models = result.toListClose(); @@ -397,8 +365,7 @@ Just ensure that you close the `Cursor`. ### Callback Changes -With 3.0, we modified the callback for a `Transaction`. Instead of having the -3 methods: +With 3.0, we modified the callback for a `Transaction`. Instead of having the 3 methods: ```java public interface TransactionListener { @@ -415,8 +382,6 @@ public interface TransactionListener { Each `Transaction` automatically gives you ability to handle callbacks: ```java - - FlowManager.getDatabase(AppDatabase.class) .beginTransactionAsync(new ITransaction() { @Override @@ -436,22 +401,21 @@ FlowManager.getDatabase(AppDatabase.class) } }).build().execute(); - ``` -For more usage on the new system, including the ability to roll your own `TransactionManager`, -visit [Transactions](Transactions.md) - +For more usage on the new system, including the ability to roll your own `TransactionManager`, visit [Transactions](https://github.com/agrosner/DBFlow/tree/fb3739caa4c894d50fd0d7873c70a33416c145e6/usage2/Transactions.md) ## Properties + Perhaps the most significant external change to this library is making queries, conditions, and interactions with the database much stricter and more type-safe. ### Property -Properties replace `String` column names generated in the "$Table" classes. They also match exact case to the column name. They have methods that generate `Condition` that drastically simplify queries. (Please note the `Condition` class has moved to the `.language` package). -Properties are represented by the interface `IProperty` which are subclassed into `Property`, `Method`, and the primitive properties (`IntProperty`, `CharProperty`, etc). +Properties replace `String` column names generated in the "$Table" classes. They also match exact case to the column name. They have methods that generate `Condition` that drastically simplify queries. \(Please note the `Condition` class has moved to the `.language` package\). -Properties can also be represented by values via the `PropertyFactory` class, enabling values to appear first in queries: +Properties are represented by the interface `IProperty` which are subclassed into `Property`, `Method`, and the primitive properties \(`IntProperty`, `CharProperty`, etc\). + +Properties can also be represented by values via the `PropertyFactory` class, enabling values to appear first in queries: ```java PropertyFactory.from(5l) // generates LongProperty @@ -483,7 +447,7 @@ List items = .queryCustomList(SomeQueryTable.class); ``` -Now (with static import on `SomeTable_Table` and `Method` ): +Now \(with static import on `SomeTable_Table` and `Method` \): ```java List items = @@ -499,6 +463,7 @@ List items = The code instantly becomes cleaner, and reads more like an actual query. ### Replacement of the ConditionQueryBuilder + ConditionQueryBuilder was fundamentally flawed. It represented a group of `Condition`, required a `Table`, yet extended `QueryBuilder`, meaning arbitrary `String` information could be appended to it, leading to potential for messy piece of query. It has been replaced with the `ConditionGroup` class. This class represents an arbitrary group of `SQLCondition` in which it's sole purpose is to group together `SQLCondition`. Even better a `ConditionGroup` itself is a `SQLCondition`, meaning it can _nest_ inside of other `ConditionGroup` to allow complicated and insane queries. @@ -522,32 +487,21 @@ SQLite.select() ``` ## ModelContainers -Now `ModelContainer` objects have a multitude of type-safe methods to ensure that they can convert their contained object's data into the field they associate with. What this means is that if our `Model` has a `long` field, while the data object for the `ModelContainer` has a `Integer` object. Previously, we would get a classcastexception. Now what it does is "coerce" the value into the type you need. Supported Types: -1. Integer/int -2. Double/Double -3. Boolean/boolean -4. Short/short -5. Long/long -6. Float/Float -7. String -8. Blob/byte[]/Byte[] -9. Byte/byte -10. Using TypeConverter to retrieve value safely. + +Now `ModelContainer` objects have a multitude of type-safe methods to ensure that they can convert their contained object's data into the field they associate with. What this means is that if our `Model` has a `long` field, while the data object for the `ModelContainer` has a `Integer` object. Previously, we would get a classcastexception. Now what it does is "coerce" the value into the type you need. Supported Types: 1. Integer/int 2. Double/Double 3. Boolean/boolean 4. Short/short 5. Long/long 6. Float/Float 7. String 8. Blob/byte\[\]/Byte\[\] 9. Byte/byte 10. Using TypeConverter to retrieve value safely. You can now `queryModelContainer` from the database to retrieve a single `Model` into `ModelContainer` format instead of into `Model` and then `ModelContainer`: ```java - JSONModel model = SQLite.select().from(SomeTable.class).where(SomeTable_Table.id.eq(5)).queryModelContainer(new JSONModel()); JSONObject json = model.getData(); // has data now ``` -For the `toModel()` conversion/parse method from `ModelContainer` to `Model`, you can now: -1. Have `@Column` excluded from it via `excludeFromToModelMethod()` -2. include other fields in the method as well by adding the `@ContainerKey` annotation to them. +For the `toModel()` conversion/parse method from `ModelContainer` to `Model`, you can now: 1. Have `@Column` excluded from it via `excludeFromToModelMethod()` 2. include other fields in the method as well by adding the `@ContainerKey` annotation to them. ## ModelViews + No longer do we need to specify the query for the `ModelView` in the annotation without ability to use the wrappper classes. We define a `@ModelViewQuery` field to use and then it simply becomes: ```java @@ -559,6 +513,7 @@ No longer do we need to specify the query for the `ModelView` in the annotation What this means is that its easier than before to use Views. ## Caching + I significantly revamped model caching in this release to make it easier, support more tables, and more consistent. Some of the significant changes: Previously you needed to extend `BaseCacheableModel` to enable model caching. No longer! The code that was there now generates in the corresponding `ModelAdapter` by setting `cachingEnabled = true` in the `@Table` annotation. @@ -627,4 +582,6 @@ public class MultipleCacheableModel extends BaseModel { Please note that the field must be of type `IMultiKeyCacheConverter` in order to compile and convert correctly. You must provide one, otherwise caching will not work. Also the return caching key _must_ be unique, otherwise inconsistent results may occur from within the cache. ## Database Modules -Now in DBFlow we have support for libraries, other subprojects, and more in general to all use DBFlow at the same time. The only requirement is that they specify an argument to `apt` in order to prevent clashes and the library loads the class during the initialization phase. To read on how to do this (fairly simply), please check it out here: ([Database Modules](https://github.com/Raizlabs/DBFlow/blob/master/usage/DatabaseModules.md)) + +Now in DBFlow we have support for libraries, other subprojects, and more in general to all use DBFlow at the same time. The only requirement is that they specify an argument to `apt` in order to prevent clashes and the library loads the class during the initialization phase. To read on how to do this \(fairly simply\), please check it out here: \([Database Modules](https://github.com/Raizlabs/DBFlow/blob/master/usage/DatabaseModules.md)\) + diff --git a/usage2/Migration4Guide.md b/usage2/migration4guide.md similarity index 64% rename from usage2/Migration4Guide.md rename to usage2/migration4guide.md index d90d65c75..e5f142a42 100644 --- a/usage2/Migration4Guide.md +++ b/usage2/migration4guide.md @@ -1,40 +1,20 @@ -# DBFlow 4.0 Migration guide +# Migration4Guide 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 much less 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. - -8. `Condition` are now `Operator`, this includes `SQLCondition` -> `SQLOperator`, `ConditionGroup` -> `OperatorGroup`. `Operator` are now typed and safer to use. - 1. `Operator` now also have `div`, `times`, `rem`, `plus` and `minus` methods. - -9. Property class changes: - 1. All primitive `Property` classes have been removed. We already boxed the values internally anyways so removing them cut down on method count and maintenance. - 2. `BaseProperty` no longer needs to exist, so all of it's methods now exist in `Property` - 3. `mod` method is now `rem` (remainder) method to match Kotlin 1.1's changes. - 4. `dividedBy` is now `div` to match Kotlin operators. - 5. `multipliedBy` is now `times` to match Kotlin operators. - +8. `Condition` are now `Operator`, this includes `SQLCondition` -> `SQLOperator`, `ConditionGroup` -> `OperatorGroup`. `Operator` are now typed and safer to use. 1. `Operator` now also have `div`, `times`, `rem`, `plus` and `minus` methods. +9. Property class changes: 1. All primitive `Property` classes have been removed. We already boxed the values internally anyways so removing them cut down on method count and maintenance. 2. `BaseProperty` no longer needs to exist, so all of it's methods now exist in `Property` 3. `mod` method is now `rem` \(remainder\) method to match Kotlin 1.1's changes. 4. `dividedBy` is now `div` to match Kotlin operators. 5. `multipliedBy` is now `times` to match Kotlin operators. 10. Rewrote all Unit tests to be more concise, better tested, and cleaner. - 11. A lot of bug fixes - -12. Kotlin: - 1. Added more Kotlin extensions. - 2. Most importantly you don't need to use `BaseModel`/`Model` at all anymore if you so choose. There are `Model`-like extension methods that supply the `Model` methods. - 3. Updated to version 1.1.1 - +12. Kotlin: 1. Added more Kotlin extensions. 2. Most importantly you don't need to use `BaseModel`/`Model` at all anymore if you so choose. There are `Model`-like extension methods that supply the `Model` methods. 3. Updated to version 1.1.1 13. RXJava1 and RXJava2 support! Can now write queries that return `Observable` and more. + diff --git a/usage2/proguard.md b/usage2/proguard.md index 0c40189c3..398e9895d 100644 --- a/usage2/proguard.md +++ b/usage2/proguard.md @@ -2,7 +2,7 @@ Since DBFlow uses annotation processing, which is run pre-proguard phase, the configuration is highly minimal. Also since we combine all generated files into the `GeneratedDatabaseHolder`, any other class generated can be obfuscated. -``` +```text -keep class * extends com.dbflow5.config.DatabaseHolder { *; } ``` diff --git a/usage2/RXJavaSupport.md b/usage2/rxjavasupport.md similarity index 67% rename from usage2/RXJavaSupport.md rename to usage2/rxjavasupport.md index c8a5c124b..824579257 100644 --- a/usage2/RXJavaSupport.md +++ b/usage2/rxjavasupport.md @@ -1,19 +1,14 @@ -# RXJava Support +# RXJavaSupport RXJava support in DBFlow is an _incubating_ feature and likely to change over time. We support both RX1 and RX2 and have made the extensions + DBFlow compatibility almost identical - save for the changes and where it makes sense in each version. -Currently it supports - 1. `Insert`, `Update`, `Delete`, `Set`, `Join`, and all wrapper query mechanisms by wrapping them in `rx()` - 2. Single + `List` model `save()`, `insert()`, `update()`, and `delete()`. - 3. Streaming a set of results from a query - 4. Observing on table changes for specific `ModelQueriable` and providing ability to query from that set repeatedly as needed. - 5. Kotlin extension methods in a separate artifact that enhance the conversion. +Currently it supports 1. `Insert`, `Update`, `Delete`, `Set`, `Join`, and all wrapper query mechanisms by wrapping them in `rx()` 2. Single + `List` model `save()`, `insert()`, `update()`, and `delete()`. 3. Streaming a set of results from a query 4. Observing on table changes for specific `ModelQueriable` and providing ability to query from that set repeatedly as needed. 5. Kotlin extension methods in a separate artifact that enhance the conversion. ## Getting Started Add the separate packages to your project: -```groovy +```groovy dependencies { // RXJava1 compile "com.github.agrosner.dbflow:rx:${dbflow_version}" @@ -22,82 +17,73 @@ dependencies { compile "com.github.agrosner.dbflow:rx2:${dbflow_version}" } - ``` ## Wrapper Language -Using the classes is as easy as wrapping all SQL wrapper calls with `RXSQLite.rx()` (Kotlin we supply extension method): + +Using the classes is as easy as wrapping all SQL wrapper calls with `RXSQLite.rx()` \(Kotlin we supply extension method\): Before: -```java +```java List list = SQLite.select() .from(MyTable.class) .queryList(); - ``` After: ```java - RXSQLite.rx( SQLite.select().from(MyTable.class)) .queryList() .subscribe((list) -> { }); - ``` or with Kotlin + extension methods: -```kotlin +```kotlin select.from(MyTable::class.java) .rx() .list { list -> } - ``` ## Model operations + To make the transition as smoothest as possible, we've provided a `BaseRXModel` which replaces `BaseModel` for convenience in the RX space. ```kotlin - class Person(@PrimaryKey var id: Int = 0, @Column var name: String? = "") : BaseRXModel - ``` Operations are as easy as: -```java +```java new Person(5, "Andrew Grosner") .insert() .subscribe((rowId) -> { }); - ``` or with Kotlin+extensions: -```kotlin +```kotlin Person(5, "Andrew Grosner") .insert { rowId -> } - ``` ## Query Stream -We can use RX to stream the result set, one at a time from the `ModelQueriable` using -the method `queryStreamResults()`: +We can use RX to stream the result set, one at a time from the `ModelQueriable` using the method `queryStreamResults()`: ```java - RXSQLite.rx( SQLite.select() .from(TestModel1.class)) @@ -105,47 +91,36 @@ RXSQLite.rx( .subscribe((model) -> { }); - ``` ## Kotlin Support -Most of the support mirrors [kotlin support](KotlinSupport.md) with a few -minor changes. +Most of the support mirrors [kotlin support](kotlinsupport.md) with a few minor changes. -Extension properties/methods include: - 1. `rx()` extension method making it super easy to integrate RX. - 2. `RXModelQueriable.streamResults` - stream results one at time to a `Subscription` - 3. `list`, `result`,`streamResults`, `cursorResult`,`statement`, `hasData`, `cursor`, and `count` all provide a method lambda that is called within a `Subscription`. +Extension properties/methods include: 1. `rx()` extension method making it super easy to integrate RX. 2. `RXModelQueriable.streamResults` - stream results one at time to a `Subscription` 3. `list`, `result`,`streamResults`, `cursorResult`,`statement`, `hasData`, `cursor`, and `count` all provide a method lambda that is called within a `Subscription`. ```kotlin - select from MyTable::class where (MyTable.name `is` "Good") list { list -> // } - ``` which is the same with RX as: ```kotlin - (select.from(MyTable::class.java) .where(MyTable.name `is` "Good")) .rx() .list { list -> } - ``` - Or if we want to get pretty with `BaseRXModel` + extensions: ```kotlin - Person("Somebody").save { success -> // do something } @@ -161,5 +136,5 @@ Person("Somebody").insert { rowId -> Person("Somebody").delete { success -> // do something } - ``` + diff --git a/usage2/summary.md b/usage2/summary.md new file mode 100644 index 000000000..c82ed08fe --- /dev/null +++ b/usage2/summary.md @@ -0,0 +1,29 @@ +# SUMMARY + +* [Introduction](./) +* [Including in Project](including-in-project.md) +* [Proguard](proguard.md) +* [Usage](usage/) + * [Databases](usage/databases.md) + * [Models](usage/models.md) + * [Migrations](usage/migrations.md) + * [Views](usage/modelviews.md) + * [Relationships](usage/relationships.md) + * [Storing Data](usage/storingdata.md) + * [Retrieval](usage/retrieval.md) + * [SQLite Wrapper Language](usage/sqlitewrapperlanguage.md) + * [Migrations](usage/migrations.md) + * [Type Converters](usage/typeconverters.md) + * [Observability](usage/observability.md) +* [Kotlin Support](kotlinsupport.md) +* [RX Java Support](rxjavasupport.md) +* [Advanced Usage](advanced-usage/) + * [Caching](advanced-usage/caching.md) + * [List Based Queries](advanced-usage/listbasedqueries.md) + * [Multiple Modules](advanced-usage/multiplemodules.md) + * [Query Models](advanced-usage/querymodels.md) + * [Indexing](advanced-usage/indexing.md) + * [SQLCipher](https://github.com/agrosner/DBFlow/tree/fb3739caa4c894d50fd0d7873c70a33416c145e6/usage2/SQLCipher.md) +* [Migration 3 Guide](migration3guide.md) +* [Migration 4 Guide](migration4guide.md) + diff --git a/usage2/Usage.md b/usage2/usage/README.md similarity index 82% rename from usage2/Usage.md rename to usage2/usage/README.md index 6c6952438..579f6e691 100644 --- a/usage2/Usage.md +++ b/usage2/usage/README.md @@ -8,7 +8,7 @@ There are a few concepts to familiarize yourself with. We will go more in depth **SQLite Wrapper Language:** DBFlow provides a number of convenience methods, extensions, and generated helpers that produce a concise, flowable query syntax. A few examples below: -``` +```text List users = SQLite.select() .from(User.class) .where(name.is("Andrew Grosner")) @@ -35,28 +35,30 @@ try { Or in Kotlin: - val users = (select from User::class where (name `is` "Andrew Grosner")).list +```text +val users = (select from User::class where (name `is` "Andrew Grosner")).list - (update() set (name eq "Andrew Grosner") where (name eq "Andy Grosner")).executeUpdateDelete() +(update() set (name eq "Andrew Grosner") where (name eq "Andy Grosner")).executeUpdateDelete() - database().beginTransactionAsync { +database().beginTransactionAsync { - } +} - (select from User::class).queryResults().use { results -> - for (user in results) { +(select from User::class).queryResults().use { results -> + for (user in results) { - } - } + } +} +``` -**Caching: **DBFlow supports caching in models. Caching them greatly increases speed, but cache carefully as it can lead to problems such as stale data. +**Caching:** DBFlow supports caching in models. Caching them greatly increases speed, but cache carefully as it can lead to problems such as stale data. -``` +```text @Table(cachingEnabled = true) public class User ``` -**Migrations: **Migrations are made very simple in DBFlow. We only support the kinds that [SQLite provide](https://sqlite.org/lang_altertable.html), but also allow you to modify the data within the DB in a structured way during these. They are also run whenever the `SQLiteOpenHelper` detects a version change in the order of version they specify. +**Migrations:** Migrations are made very simple in DBFlow. We only support the kinds that [SQLite provide](https://sqlite.org/lang_altertable.html), but also allow you to modify the data within the DB in a structured way during these. They are also run whenever the `SQLiteOpenHelper` detects a version change in the order of version they specify. **Multiple Modules:** DBFlow can be used in library projects, in any number of inner-project modules simultaneously. However these models must reside in separate databases. @@ -68,9 +70,9 @@ public class User **Encrypted Databases:** DBFlow supports database encryption for security using SQLCipher through a separate, easy-to-integrate artifact. -**Indexes: **A SQLite feature that drastically improves query performance on large datasets. Dead-easy to implement. +**Indexes:** A SQLite feature that drastically improves query performance on large datasets. Dead-easy to implement. -**Reactive: **Easily listen to changes in database data via `ModelNotifier` system. +**Reactive:** Easily listen to changes in database data via `ModelNotifier` system. **Transaction Management:** Place all transactions and retrievals on same background thread for maximum efficiency and to prevent UI-hiccups. diff --git a/usage2/Databases.md b/usage2/usage/databases.md similarity index 75% rename from usage2/Databases.md rename to usage2/usage/databases.md index 48b25e47d..7369116c0 100644 --- a/usage2/Databases.md +++ b/usage2/usage/databases.md @@ -1,99 +1,85 @@ # Databases -This section describes how databases are created in DBFlow and some more -advanced features. +This section describes how databases are created in DBFlow and some more advanced features. ## Creating a Database -In DBFlow, creating a database is as simple as only a few lines of code. DBFlow -supports any number of databases, however individual tables and other related files -can only be associated with one database. **Note**: Starting with DBFlow 5.0, databases are required to extend `DBFlowDatabase`. +In DBFlow, creating a database is as simple as only a few lines of code. DBFlow supports any number of databases, however individual tables and other related files can only be associated with one database. **Note**: Starting with DBFlow 5.0, databases are required to extend `DBFlowDatabase`. ```kotlin @Database(version = 1) abstract class AppDatabase : DBFlowDatabase() ``` + or in Java: ```java - @Database(version = 1) public abstract class AppDatabase extends DBFlowDatabase() { } - ``` + ## Initialization -To specify a custom **name** to the database, in previous versions of DBFlow (< 4.1.0), you had to specify it in the `@Database` annotation. As of 5.0 now you pass it in the initialization of the `FlowManager`: +To specify a custom **name** to the database, in previous versions of DBFlow \(< 4.1.0\), you had to specify it in the `@Database` annotation. As of 5.0 now you pass it in the initialization of the `FlowManager`: ```kotlin - FlowManager.init(FlowConfig.builder() .database(DatabaseConfig.builder(AppDatabase::class) .databaseName("AppDatabase") .build()) .build()) - ``` To dynamically change the database name, call: -```kotlin +```kotlin database() .reopen(DatabaseConfig.builder(AppDatabase::class) .databaseName("AppDatabase-2") .build()) - ``` + or in Java: -```java +```java FlowManager.getDatabase(AppDatabase.class) .reopen(DatabaseConfig.builder(AppDatabase.class) .databaseName("AppDatabase-2") .build()) - ``` This will close the open DB, reopen the DB, and replace previous `DatabaseConfig` with this new one. Ensure that you persist the changes to the `DatabaseConfig` somewhere as next time app is launched and DBFlow is initialized, the new config would get overwritten. ### In Memory Databases -As with **name**, in previous versions of DBFlow (< 5.0), you specified `inMemory` in the `@Database` annotation. Starting with 5.0 that is replaced with: -```kotlin +As with **name**, in previous versions of DBFlow \(< 5.0\), you specified `inMemory` in the `@Database` annotation. Starting with 5.0 that is replaced with: +```kotlin FlowManager.init(FlowConfig.builder() .database(DatabaseConfig.inMemoryBuilder(AppDatabase::class.java) .databaseName("AppDatabase") .build()) .build()) - ``` ```java - FlowManager.init(FlowConfig.builder() .database(DatabaseConfig.inMemoryBuilder(AppDatabase::class) .databaseName("AppDatabase") .build()) .build()) - ``` This will allow you to use in-memory databases in your tests, while writing to disk in your apps. Also if your device the app is running on is low on memory, you could also swap the DB into memory by calling `reopen(DatabaseConfig)` as explained above. ## Database Migrations -Database migrations are run when upon open of the database connection, -the version number increases on an existing database. - -It is preferred that `Migration` files go in the same file as the database, for -organizational purposes. -An example migration: +Database migrations are run when upon open of the database connection, the version number increases on an existing database. +It is preferred that `Migration` files go in the same file as the database, for organizational purposes. An example migration: ```kotlin - @Database(version = 2) abstract class AppDatabase : DBFlowDatabase() { @@ -105,11 +91,9 @@ abstract class AppDatabase : DBFlowDatabase() { } } } - ``` ```java - @Database(version = 2) public abstract class AppDatabase extends DBFlowDatabase { @@ -126,74 +110,54 @@ public abstract class AppDatabase extends DBFlowDatabase { } } } - ``` - -This simple example adds a column to the `User` table named "email". In code, just add -the column to the `Model` class and this migration runs only on existing dbs. - To read more on migrations and more examples of different kinds, visit the [page](Migrations.md). +This simple example adds a column to the `User` table named "email". In code, just add the column to the `Model` class and this migration runs only on existing dbs. To read more on migrations and more examples of different kinds, visit the [page](migrations.md). ## Advanced Database features -This section goes through features that are for more advanced use of a database, -and may be very useful. +This section goes through features that are for more advanced use of a database, and may be very useful. ### Prepackaged Databases -To include a prepackaged database for your application, simply include the ".db" file in `src/main/assets/{databaseName}.db`. On creation of the database, we copy over the file into the application for usage. Since this is prepackaged within the APK, we cannot delete it once it's copied over, -which can bulk up your raw APK size. _Note_ this is only copied over on initial creation -of the database for the app. + +To include a prepackaged database for your application, simply include the ".db" file in `src/main/assets/{databaseName}.db`. On creation of the database, we copy over the file into the application for usage. Since this is prepackaged within the APK, we cannot delete it once it's copied over, which can bulk up your raw APK size. _Note_ this is only copied over on initial creation of the database for the app. ### Global Conflict Handling + In DBFlow when an INSERT or UPDATE are performed, by default, we use `NONE`. If you wish to configure this globally, you can define it to apply for all tables from a given database: ```kotlin @Database(version = 2, insertConflict = ConflictAction.IGNORE, updateConflict= ConflictAction.REPLACE) abstract class AppDatabase : DBFlowDatabase() - ``` ```java - @Database(version = 2, insertConflict = ConflictAction.IGNORE, updateConflict= ConflictAction.REPLACE) public abstract class AppDatabase extends DBFlowDatabase { } - ``` These follow the SQLite standard [here](https://www.sqlite.org/conflict.html). ### Integrity Checking -Databases can get corrupted or in an invalid state at some point. If you specify -`consistencyChecksEnabled=true` It runs a `PRAGMA quick_check(1)` -whenever the database is opened. If it fails, you should provide a backup database -that it will copy over. If not, **we wipe the internal database**. Note that during this -time in case of failure we create a **third copy of the database** in case transfer fails. +Databases can get corrupted or in an invalid state at some point. If you specify `consistencyChecksEnabled=true` It runs a `PRAGMA quick_check(1)` whenever the database is opened. If it fails, you should provide a backup database that it will copy over. If not, **we wipe the internal database**. Note that during this time in case of failure we create a **third copy of the database** in case transfer fails. ### Custom FlowSQLiteOpenHelper -For variety of reasons, you may want to provide your own `FlowSQLiteOpenHelper` -to manage database interactions. To do so, you must implement `OpenHelper`, but -for convenience you should extend `AndroidSQLiteOpenHelper` (for Android databases), -or `SQLCipherOpenHelper` for SQLCipher. Read more [here](SQLCipherSupport.md) - +For variety of reasons, you may want to provide your own `FlowSQLiteOpenHelper` to manage database interactions. To do so, you must implement `OpenHelper`, but for convenience you should extend `AndroidSQLiteOpenHelper` \(for Android databases\), or `SQLCipherOpenHelper` for SQLCipher. Read more [here](../advanced-usage/sqlciphersupport.md) ```kotlin - class CustomFlowSQliteOpenHelper(context: Contect, databaseDefinition: DatabaseDefinition, listener: DatabaseHelperListener) : FlowSQLiteOpenHelper(context, databaseDefinition, listener) - ``` ```java - public class CustomFlowSQliteOpenHelper extends FlowSQLiteOpenHelper { public CustomFlowSQliteOpenHelper(Context context, BaseDatabaseDefinition databaseDefinition, @Nullable DatabaseCallback callback) { super(context, databaseDefinition, callback); } } - ``` Then in your `DatabaseConfig`: @@ -204,11 +168,9 @@ FlowManager.init(FlowConfig.builder(context) .openHelper(::CustomFlowSQliteOpenHelper) .build()) .build()) - ``` ```java - FlowManager.init(FlowConfig.builder(context) .database( DatabaseConfig.builder(CipherDatabase.class) @@ -221,3 +183,4 @@ FlowManager.init(FlowConfig.builder(context) .build()) .build()); ``` + diff --git a/usage2/Migrations.md b/usage2/usage/migrations.md similarity index 62% rename from usage2/Migrations.md rename to usage2/usage/migrations.md index d8a93b87f..484deee09 100644 --- a/usage2/Migrations.md +++ b/usage2/usage/migrations.md @@ -1,26 +1,20 @@ # Migrations -In this section we will discuss how migrations work, how each of the provided -migration classes work, and how to create your own custom one. +In this section we will discuss how migrations work, how each of the provided migration classes work, and how to create your own custom one. -There are two kinds of migrations that DBFlow supports: Script-based SQL files -and class annotation-based migrations. +There are two kinds of migrations that DBFlow supports: Script-based SQL files and class annotation-based migrations. ## How Migrations Work -In SQL databases, migrations are used to modify or change existing database schema to adapt -to changing format or nature of stored data. In SQLite we have a limited ability -compared to SQL to modify tables and columns of an existing database. There are only -two kinds of modifications that exist: rename table and add a new column. +In SQL databases, migrations are used to modify or change existing database schema to adapt to changing format or nature of stored data. In SQLite we have a limited ability compared to SQL to modify tables and columns of an existing database. There are only two kinds of modifications that exist: rename table and add a new column. -In DBFlow migrations are not only used to modify the _structure_ of the database, but also other operations such as insert data into a database (for prepopulate), or add an index on a specific table. +In DBFlow migrations are not only used to modify the _structure_ of the database, but also other operations such as insert data into a database \(for prepopulate\), or add an index on a specific table. -Migrations are only run on an existing database _except_ for the "0th" migration. Read [initial database setup](Migrations.md#initial-database-setup) +Migrations are only run on an existing database _except_ for the "0th" migration. Read [initial database setup](migrations.md#initial-database-setup) ### Migration Classes -We recommend placing any `Migration` inside an associated `@Database` class so it's apparent the migration is tied to it. -An example migration class: +We recommend placing any `Migration` inside an associated `@Database` class so it's apparent the migration is tied to it. An example migration class: ```java @Database(version = 2) @@ -61,25 +55,17 @@ object AppDatabase { The classes provide the ability to set a `priority` on the `Migration` so that an order is established. The higher the priority, that one will execute first. -`Migration` have three methods: - 1. `onPreMigrate()` - called first, do setup, and construction here. - 2. `migrate()` -> called with the `DatabaseWrapper` specified, this is where the actual migration code should execute. - 3. `onPostMigrate()` -> perform some cleanup, or any notifications that it was executed. +`Migration` have three methods: 1. `onPreMigrate()` - called first, do setup, and construction here. 2. `migrate()` -> called with the `DatabaseWrapper` specified, this is where the actual migration code should execute. 3. `onPostMigrate()` -> perform some cleanup, or any notifications that it was executed. ### Migration files -DBFlow also supports `.sql` migration files. The rules on these follows must be followed: - 1. Place them in `assets/migrations/{DATABASE_NAME}/{versionNumber}.sql`. So that an example `AppDatabase` migration for version 2 resides in `assets/migrations/AppDatabase/2.sql` - 2. The file can contain any number of SQL statements - they are executed in order. Each statement must be on a single line or multiline and must end with `;` - 3. Comments are allowed as long as they appear on an individual file with standard SQLite comment syntax `--` +DBFlow also supports `.sql` migration files. The rules on these follows must be followed: 1. Place them in `assets/migrations/{DATABASE_NAME}/{versionNumber}.sql`. So that an example `AppDatabase` migration for version 2 resides in `assets/migrations/AppDatabase/2.sql` 2. The file can contain any number of SQL statements - they are executed in order. Each statement must be on a single line or multiline and must end with `;` 3. Comments are allowed as long as they appear on an individual file with standard SQLite comment syntax `--` ### Prevent Recursive Access to the DB Since `Migration` occur when the database is opening, we cannot recursively access the database object in our models, SQLite wrapper statements, and other classes in DBFlow that are inside a `Migration`. -To remedy that, DBFlow comes with support to pass the `DatabaseWrapper` into almost all places that require it: - 1. All query language `BaseQueriable` objects such as `Select`, `Insert`, `Update`, `Delete`, etc have methods that take in the `DatabaseWrapper` - 2. Any subclass of `BaseModel` (`Model` does not provide the methods for simplicity) +To remedy that, DBFlow comes with support to pass the `DatabaseWrapper` into almost all places that require it: 1. All query language `BaseQueriable` objects such as `Select`, `Insert`, `Update`, `Delete`, etc have methods that take in the `DatabaseWrapper` 2. Any subclass of `BaseModel` \(`Model` does not provide the methods for simplicity\) ### Initial Database Setup @@ -87,29 +73,19 @@ DBFlow supports `Migration` that run on version "0" of a database. When Android ## Provided Migration Classes -In DBFlow we provide a few helper `Migration` subclasses -to provide default and easier implementation: - 1. `AlterTableMigration` - 2. `IndexMigration/IndexPropertyMigration` - 3. `UpdateTableMigration` +In DBFlow we provide a few helper `Migration` subclasses to provide default and easier implementation: 1. `AlterTableMigration` 2. `IndexMigration/IndexPropertyMigration` 3. `UpdateTableMigration` ### AlterTableMigration The _structural_ modification of a table is brought to a handy `Migration` subclass. -It performs both of SQLite supported operations: - 1. Rename tables - 2. Add columns. +It performs both of SQLite supported operations: 1. Rename tables 2. Add columns. -For renaming tables, you should rename the `Model` class' `@Table(name = "{newName}")` before running -this `Migration`. The reason is that DBFlow will know -the new name only and the existing database will get caught up on it through this migration. Any new database created on a device will automatically have the new table name. +For renaming tables, you should rename the `Model` class' `@Table(name = "{newName}")` before running this `Migration`. The reason is that DBFlow will know the new name only and the existing database will get caught up on it through this migration. Any new database created on a device will automatically have the new table name. -For adding columns, we only support `SQLiteType` (all supported ones [here](https://www.sqlite.org/datatype3.html)) operations to add or remove columns. This is to enforce that the columns are created properly. If a column needs to be a `TypeConverter` column, use the database value from it. We map the associated type of the database field to a `SQLiteType` in [SQLiteType.kt](/dbflow/src/main/java/com/dbflow5/sql/SQLiteType.kt). So if you have a `DateConverter` that specifies a `Date` column converted to `Long`, then you should look up `Long` in the `Map`. In this case `Long` converts to `INTEGER`. +For adding columns, we only support `SQLiteType` \(all supported ones [here](https://www.sqlite.org/datatype3.html)\) operations to add or remove columns. This is to enforce that the columns are created properly. If a column needs to be a `TypeConverter` column, use the database value from it. We map the associated type of the database field to a `SQLiteType` in [SQLiteType.kt](https://github.com/agrosner/DBFlow/tree/fb3739caa4c894d50fd0d7873c70a33416c145e6/dbflow/src/main/java/com/dbflow5/sql/SQLiteType.kt). So if you have a `DateConverter` that specifies a `Date` column converted to `Long`, then you should look up `Long` in the `Map`. In this case `Long` converts to `INTEGER`. ```java - - @Migration(version = 2, database = AppDatabase.class) public class Migration2 extends AlterTableMigration { @@ -123,10 +99,8 @@ public class Migration2 extends AlterTableMigration { addColumn(SQLiteType.REAL, "anotherColumn"); } } - ``` - ```kotlin @Migration(version = 2, database = AppDatabase.class) class Migration2 : AlterTableMigration(AModel::class.java) { @@ -136,19 +110,17 @@ class Migration2 : AlterTableMigration(AModel::class.java) { addColumn(SQLiteType.REAL, "anotherColumn") } } - ``` ### Index Migrations -An `IndexMigration` (and `IndexPropertyMigration`) is used to structurally activate an `Index` on the database at a specific version. See [here](Indexing.md) for information on creating them. +An `IndexMigration` \(and `IndexPropertyMigration`\) is used to structurally activate an `Index` on the database at a specific version. See [here](../advanced-usage/indexing.md) for information on creating them. `IndexMigration` does not require an `IndexProperty` to run, while `IndexPropertyMigration` makes use of the property to run. An `IndexMigration`: ```java - @Migration(version = 2, priority = 0, database = MigrationDatabase.class) public static class IndexMigration2 extends IndexMigration { @@ -170,13 +142,11 @@ class IndexMigration2 : IndexMigration(MigrationModel::class.jav override fun getName() = "TestIndex" } - ``` An `IndexPropertyMigration`: ```java - @Migration(version = 2, priority = 1, database = MigrationDatabase.class) public static class IndexPropertyMigration2 extends IndexPropertyMigration { @@ -186,7 +156,6 @@ public static class IndexPropertyMigration2 extends IndexPropertyMigration { return IndexModel_Table.index_customIndex; } } - ``` ```kotlin @@ -195,7 +164,6 @@ class IndexPropertyMigration2 : IndexPropertyMigration { override fun getIndexProperty() = IndexModel_Table.index_customIndex } - ``` ### Update Table Migration @@ -203,8 +171,6 @@ class IndexPropertyMigration2 : IndexPropertyMigration { A simple wrapper around `Update`, provides simply a default way to update data during a migration. ```java - - @Migration(version = 2, priority = 2, database = MigrationDatabase.class) public static class UpdateMigration2 extends UpdateTableMigration { @@ -219,4 +185,5 @@ public static class UpdateMigration2 extends UpdateTableMigration` : List columns are not supported and not generally proper for a relational database. However, you can get away with a non-generic `List` column via a `TypeConverter`. But again, avoid this if you can. - 2. Anything that is generically typed (even with an associated `TypeConverter`). If you need to include the field, subclass the generic object and provide a `TypeConverter`. +**Unsupported Types**: 1. `List` : List columns are not supported and not generally proper for a relational database. However, you can get away with a non-generic `List` column via a `TypeConverter`. But again, avoid this if you can. 2. Anything that is generically typed \(even with an associated `TypeConverter`\). If you need to include the field, subclass the generic object and provide a `TypeConverter`. ## Inherited Columns -Since we don't require extension on `BaseModel` directly, tables can extend non-model classes and inherit their fields directly (given proper accessibility) via the `@InheritedColumn` annotation (or `@InheritedPrimaryKey` for primary keys): +Since we don't require extension on `BaseModel` directly, tables can extend non-model classes and inherit their fields directly \(given proper accessibility\) via the `@InheritedColumn` annotation \(or `@InheritedPrimaryKey` for primary keys\): ```java - @Table(database = AppDatabase.class, inheritedColumns = {@InheritedColumn(column = @Column, fieldName = "name"), @InheritedColumn(column = @Column, fieldName = "number")}, @@ -82,7 +69,6 @@ Since we don't require extension on `BaseModel` directly, tables can extend non- primaryKey = @PrimaryKey, fieldName = "inherited_primary_key")}) public class InheritorModel extends InheritedModel implements Model { - ``` ## Primary Keys @@ -100,36 +86,33 @@ public class Dog extends BaseModel { String breed; } - ``` ```kotlin @Table(database = AppDatabase::class) class Dog(@PrimaryKey var name: String? = null, @PrimaryKey var breed: String? = null) - ``` - If we want an auto-incrementing key, you specify `@PrimaryKey(autoincrement = true)`, but only one of these kind can exist in a table and you cannot mix with regular primary keys. ## Unique Columns -DBFlow has support for SQLite `UNIQUE` constraint (here for documentation)[http://www.tutorialspoint.com/sqlite/sqlite_constraints.htm]. +DBFlow has support for SQLite `UNIQUE` constraint \(here for documentation\)\[[http://www.tutorialspoint.com/sqlite/sqlite\_constraints.htm](http://www.tutorialspoint.com/sqlite/sqlite_constraints.htm)\]. -Add `@Unique` annotation to your existing `@Column` and DBFlow adds it as a constraint when -the database table is first created. This means that once it is created you should not change or modify this. +Add `@Unique` annotation to your existing `@Column` and DBFlow adds it as a constraint when the database table is first created. This means that once it is created you should not change or modify this. We can _also_ support multiple unique clauses in order to ensure any combination of fields are unique. For example: To generate this in the creation query: -```sqlite + +```text UNIQUE('name', 'number') ON CONFLICT FAIL, UNIQUE('name', 'address') ON CONFLICT ROLLBACK ``` + We declare the annotations as such: ```java - @Table(database = AppDatabase.class, uniqueColumnGroups = {@UniqueGroup(groupNumber = 1, uniqueConflict = ConflictAction.FAIL), @UniqueGroup(groupNumber = 2, uniqueConflict = ConflictAction.ROLLBACK)) @@ -148,23 +131,17 @@ public class UniqueModel { String address; } - ``` The `groupNumber` within each defined `uniqueColumnGroups` with an associated `@Unique` column. We need to specify `unique=false` for any column used in a group so we expect the column to be part of a group. If true as well, the column will _also_ alone be unique. ## Default Values -DBFlow supports default values in a slighty different way that SQLite does. Since we do not know -exactly the intention of missing data when saving a `Model`, since we group all fields, `defaultValue` specifies -a value that we replace when saving to the database when the value of the field is `null`. +DBFlow supports default values in a slighty different way that SQLite does. Since we do not know exactly the intention of missing data when saving a `Model`, since we group all fields, `defaultValue` specifies a value that we replace when saving to the database when the value of the field is `null`. -This feature only works on Boxed primitive and the `DataClass` equivalent of objects (such as from TypeConverter), such as String, Integer, Long, Double, etc. -__Note__: If the `DataClass` is a `Blob`, unfortunately this will not work. -For `Boolean` classes, use "1" for true, "0" for false. +This feature only works on Boxed primitive and the `DataClass` equivalent of objects \(such as from TypeConverter\), such as String, Integer, Long, Double, etc. **Note**: If the `DataClass` is a `Blob`, unfortunately this will not work. For `Boolean` classes, use "1" for true, "0" for false. ```java - @Column(defaultValue = "55") Integer count; @@ -176,7 +153,7 @@ Date date; @Column(defaultValue = "1") Boolean aBoolean; - ``` DBFlow inserts it's literal value into the `ModelAdapter` for the table so any `String` must be escaped. + diff --git a/usage2/ModelViews.md b/usage2/usage/modelviews.md similarity index 52% rename from usage2/ModelViews.md rename to usage2/usage/modelviews.md index 3c6e49436..a473e91f1 100644 --- a/usage2/ModelViews.md +++ b/usage2/usage/modelviews.md @@ -1,14 +1,10 @@ -# ModelViews +# Views -A `ModelView` is a SQLite representation of a `VIEW`. Read official SQLite docs -[here](https://www.sqlite.org/lang_createview.html) for more information. +A `ModelView` is a SQLite representation of a `VIEW`. Read official SQLite docs [here](https://www.sqlite.org/lang_createview.html) for more information. -As with SQLite a `ModelView` cannot insert, update, or delete itself as it's -read-only. It is a virtual "view" placed on top of a regular table as a prepackaged -`Select` statement. In DBFlow using a `ModelView` should feel familiar and be very simple. +As with SQLite a `ModelView` cannot insert, update, or delete itself as it's read-only. It is a virtual "view" placed on top of a regular table as a prepackaged `Select` statement. In DBFlow using a `ModelView` should feel familiar and be very simple. ```java - @ModelView(database = TestDatabase.class) public class TestModelView { @@ -19,7 +15,6 @@ public class TestModelView { @Column long model_order; } - ``` ```kotlin @@ -31,32 +26,21 @@ class TestModelView(@Column modelOrder: Long = 0L) { val query = (select from TestModel2::class where TestModel2_Table.model_order.greaterThan(5)) } } - ``` -To specify the query that a `ModelView` creates itself with, we _must_ define -a public static final field annotated with `@ModelViewQuery`. This tells DBFlow -what field is the query. This query is used only once when the database is created -(or updated) to create the view. +To specify the query that a `ModelView` creates itself with, we _must_ define a public static final field annotated with `@ModelViewQuery`. This tells DBFlow what field is the query. This query is used only once when the database is created \(or updated\) to create the view. -The full list of limitations/supported types are: - 1. Only `@Column`/`@ColumnMap` are allowed - 2. No `@PrimaryKey` or `@ForeignKey` - 3. Supports all fields, and accessibility modifiers that `Model` support - 4. Does not support `@InheritedField`, `@InheritedPrimaryKey` - 5. Basic, type-converted, non-model `@Column`. - 6. __Cannot__: update, insert, or delete +The full list of limitations/supported types are: 1. Only `@Column`/`@ColumnMap` are allowed 2. No `@PrimaryKey` or `@ForeignKey` 3. Supports all fields, and accessibility modifiers that `Model` support 4. Does not support `@InheritedField`, `@InheritedPrimaryKey` 5. Basic, type-converted, non-model `@Column`. 6. **Cannot**: update, insert, or delete `ModelView` are used identical to `Model` when retrieving from the database: ```java - SQLite.select() .from(TestModelView.class) .where(...) // ETC - ``` ```kotlin (select from TestModelView::class where (...)) ``` + diff --git a/usage2/Observability.md b/usage2/usage/observability.md similarity index 79% rename from usage2/Observability.md rename to usage2/usage/observability.md index 9a4b6bbd8..9eec1fcde 100644 --- a/usage2/Observability.md +++ b/usage2/usage/observability.md @@ -1,41 +1,39 @@ # Observability +## Observability + DBFlow provides a flexible way to observe changes on models and tables in this library. -By default, DBFlow utilizes the [`ContentResolver`](https://developer.android.com/reference/android/content/ContentResolver.html) -to send changes through the android system. We then can utilize [`ContentObserver`](http://developer.android.com/reference/android/database/ContentObserver.html) to listen for these changes via the `FlowContentObserver`. +By default, DBFlow utilizes the [`ContentResolver`](https://developer.android.com/reference/android/content/ContentResolver.html) to send changes through the android system. We then can utilize [`ContentObserver`](http://developer.android.com/reference/android/database/ContentObserver.html) to listen for these changes via the `FlowContentObserver`. -Also, DBFlow also supports direct [model notification](Observability.md#direct-changes) via a custom `ModelNotifier`. +Also, DBFlow also supports direct [model notification](observability.md#direct-changes) via a custom `ModelNotifier`. -## FlowContentObserver +### FlowContentObserver The content observer converts each model passed to it into `Uri` format that describes the `Action`, primary keys, and table of the class that changed. A model: -```kotlin +```kotlin @Table(database = AppDatabase.class) class User(@PrimaryKey var id: Int = 0, @Column var name: String = "") - ``` with data: -```kotlin +```kotlin User(55, "Andrew Grosner").delete() - ``` converts to: -``` +```text dbflow://%60User%60?%2560id%2560=55#DELETE ``` Then after we register a `FlowContentObserver`: ```java - FlowContentObserver observer = new FlowContentObserver(); observer.registerForContentChanges(context, User.class); @@ -43,57 +41,47 @@ observer.registerForContentChanges(context, User.class); // do something here // unregister when done observer.unregisterForContentChanges(context); - ``` -## Model Changes +### Model Changes It will now receive the `Uri` for that table. Once we have that, we can register for model changes on that content: ```java - observer.addModelChangeListener(new OnModelStateChangedListener() { @Override public void onModelStateChanged(@Nullable Class table, BaseModel.Action action, @NonNull SQLOperator[] primaryKeyValues) { // do something here } }); - - ``` -The method will return the `Action` which is one of: - 1. `SAVE` (will call `INSERT` or `UPDATE` as well if that operation was used) - 2. `INSERT` - 3. `UPDATE` - 4. `DELETE` + +The method will return the `Action` which is one of: 1. `SAVE` \(will call `INSERT` or `UPDATE` as well if that operation was used\) 2. `INSERT` 3. `UPDATE` 4. `DELETE` The `SQLOperator[]` passed back specify the primary column and value pairs that were changed for the model. If we want to get less granular and just get notifications when generally a table changes, read on. -## Register for Table Changes +### Register for Table Changes Table change events are similar to `OnModelStateChangedListener`, except that they only specify the table and action taken. These get called for any action on a table, including granular model changes. We recommend batching those events together, which we describe in the next section. ```java - addOnTableChangedListener(new OnTableChangedListener() { @Override public void onTableChanged(@Nullable Class tableChanged, BaseModel.Action action) { // perform an action. May get called many times! Use batch transactions to combine them. } }); - ``` -## Batch Up Many Events +### Batch Up Many Events Sometimes we're modifying tens or hundreds of items at the same time and we do not wish to get notified for _every_ one but only once for each _kind_ of change that occurs. To batch up the notifications so that they fire all at once, we use batch transactions: ```java - FlowContentObserver observer = new FlowContentObserver(); observer.beginTransaction(); @@ -104,34 +92,30 @@ for(User user: users) { } observer.endTransactionAndNotify(); // callback batched - ``` -Batch interactions will store up all unique `Uri` for each action (these include `@Primary` key of the `Model` changed). When `endTransactionAndNotify()` is called, -all those `Uri` are called in the `onChange()` method from the `FlowContentObserver` as expected. +Batch interactions will store up all unique `Uri` for each action \(these include `@Primary` key of the `Model` changed\). When `endTransactionAndNotify()` is called, all those `Uri` are called in the `onChange()` method from the `FlowContentObserver` as expected. -If we are using `OnTableChangedListener` callbacks, then by default we will receive one callback per `Action` per table. If we wish to only receive a single callback, set `setNotifyAllUris(false)`, which will make the `Uri` all only specify `CHANGE`. +If we are using `OnTableChangedListener` callbacks, then by default we will receive one callback per `Action` per table. If we wish to only receive a single callback, set `setNotifyAllUris(false)`, which will make the `Uri` all only specify `CHANGE`. -# Direct Changes +## Direct Changes DBFlow also supports direct observability on model changes rather than convert those models into `Uri` and have to decipher what has changed. To set up direct changes we override the default `ModelNotifier`: ```java - FlowManager.init(FlowConfig.Builder(context) .database(DatabaseConfig.Builder(TestDatabase.class) .modelNotifier(DirectModelNotifier.get()) .build()).build()); - ``` We must use the shared instance of the `DirectModelNotifier` since if we do not, your listeners will not receive callbacks. Next register for changes on the `DirectModelNotifier`: -```java +```java DirectModelNotifier.get().registerForModelChanges(User.class, new ModelChangedListener() { @Override public void onModelChanged(User model, BaseModel.Action action) { @@ -143,12 +127,11 @@ DirectModelNotifier.get().registerForModelChanges(User.class, new ModelChangedLi // react to table changes. } };) - ``` -Then unregister your model change listener when you don't need it anymore (to prevent memory leaks): +Then unregister your model change listener when you don't need it anymore \(to prevent memory leaks\): ```java DirectModelNotifier.get().unregisterForModelChanges(Userr.class, modelChangedListener); - ``` + diff --git a/usage2/Relationships.md b/usage2/usage/relationships.md similarity index 59% rename from usage2/Relationships.md rename to usage2/usage/relationships.md index 3748db323..c1e3b64d7 100644 --- a/usage2/Relationships.md +++ b/usage2/usage/relationships.md @@ -1,12 +1,10 @@ # Relationships -We can link `@Table` in DBFlow via 1-1, 1-many, or many-to-many. For 1-1 we use -`@PrimaryKey`, for 1-many we use `@OneToMany`, and for many-to-many we use the `@ManyToMany` annotation. - +We can link `@Table` in DBFlow via 1-1, 1-many, or many-to-many. For 1-1 we use `@PrimaryKey`, for 1-many we use `@OneToMany`, and for many-to-many we use the `@ManyToMany` annotation. ## One To One -DBFlow supports multiple `@ForeignKey` right out of the box as well (and for the most part, they can also be `@PrimaryKey`). +DBFlow supports multiple `@ForeignKey` right out of the box as well \(and for the most part, they can also be `@PrimaryKey`\). ```kotlin @Table(database = AppDatabase::class) @@ -16,35 +14,23 @@ class Dog(@PrimaryKey var name: String, @ForeignKey var owner: Owner? = null) ``` -`@ForeignKey` can only be a subset of types: - 1. `Model` - 2. Any field not requiring a `TypeConverter`. If not a `Model` or a table class, you _must_ specify the `tableClass` it points to. - 3. Cannot inherit `@ForeignKey` from non-model classes (see [Inherited Columns](Models.md#inherited-columns)) +`@ForeignKey` can only be a subset of types: 1. `Model` 2. Any field not requiring a `TypeConverter`. If not a `Model` or a table class, you _must_ specify the `tableClass` it points to. 3. Cannot inherit `@ForeignKey` from non-model classes \(see [Inherited Columns](models.md#inherited-columns)\) -If you create a circular reference (i.e. two tables with strong references to `Model` as `@ForeignKey` to each other), read on. +If you create a circular reference \(i.e. two tables with strong references to `Model` as `@ForeignKey` to each other\), read on. ## Stubbed Relationships For efficiency reasons we recommend specifying `@ForeignKey(stubbedRelationship = true)`. What this will do is only _preset_ the primary key references into a table object. - All other fields will not be set. If you need to access the full object, you will have to call `load()` for `Model`, or use the `ModelAdapter` to load the object from the DB. +All other fields will not be set. If you need to access the full object, you will have to call `load()` for `Model`, or use the `ModelAdapter` to load the object from the DB. -From our previous example of `Dog`, instead of using a `String` field for **breed** -we recommended by using a `Breed`. It is nearly identical, but the difference being -we would then only need to call `load()` on the reference and it would query the `Breed` -table for a row with the `breed` id. This also makes it easier if the table you -reference has multiple primary keys, since DBFlow will handle the work for you. +From our previous example of `Dog`, instead of using a `String` field for **breed** we recommended by using a `Breed`. It is nearly identical, but the difference being we would then only need to call `load()` on the reference and it would query the `Breed` table for a row with the `breed` id. This also makes it easier if the table you reference has multiple primary keys, since DBFlow will handle the work for you. Multiple calls to `load()` will query the DB every time, so call when needed. Also if you don't specify `@Database(foreignKeyConstraintsEnforced = true)`, calling `load()` may not have any effect. Essentially without enforcing `@ForeignKey` at a SQLite level, you can end up with floating key references that do not exist in the referenced table. -In normal circumstances, for every load of a `Dog` object from the database, -we would also do a load of related `Owner`. This means that even if multiple `Dog` say (50) -all point to same owner we end up doing 2x retrievals for every load of `Dog`. Replacing -that model field of `Owner` with a stubbed relationship prevents the extra N lookup time, -leading to much faster loads of `Dog`. +In normal circumstances, for every load of a `Dog` object from the database, we would also do a load of related `Owner`. This means that even if multiple `Dog` say \(50\) all point to same owner we end up doing 2x retrievals for every load of `Dog`. Replacing that model field of `Owner` with a stubbed relationship prevents the extra N lookup time, leading to much faster loads of `Dog`. -__Note__: using stubbed relationships also helps to prevent circular references that can -get you in a `StackOverFlowError` if two tables strongly reference each other in `@ForeignKey`. +**Note**: using stubbed relationships also helps to prevent circular references that can get you in a `StackOverFlowError` if two tables strongly reference each other in `@ForeignKey`. Our modified example now looks like this: @@ -59,8 +45,7 @@ class Dog(@PrimaryKey var name: String, ## One To Many -In DBFlow, `@OneToMany` is an annotation that you provide to a method in your `Model` class that will allow management of those objects during CRUD operations. -This can allow you to combine a relationship of objects to a single `Model` to happen together on load, save, insert, update, and deletion. +In DBFlow, `@OneToMany` is an annotation that you provide to a method in your `Model` class that will allow management of those objects during CRUD operations. This can allow you to combine a relationship of objects to a single `Model` to happen together on load, save, insert, update, and deletion. ```kotlin @Table(database = ColonyDatabase::class) @@ -77,25 +62,23 @@ class Queen(@PrimaryKey(autoincrement = true) ``` ### Efficient Methods -When using `@ManyToMany`, by default we skip the `Model` methods in each retrieved `Ant` (in this example). -If you have nested `@ManyToMany` (which should strongly be avoided), you can turn off the efficient operations. -Call `@OneToMany(efficientMethods = false)` and it will instead loop through each model and perform `save()`, `delete()`, etc -when the parent model is called. + +When using `@ManyToMany`, by default we skip the `Model` methods in each retrieved `Ant` \(in this example\). If you have nested `@ManyToMany` \(which should strongly be avoided\), you can turn off the efficient operations. Call `@OneToMany(efficientMethods = false)` and it will instead loop through each model and perform `save()`, `delete()`, etc when the parent model is called. ### Custom ForeignKeyReferences + When simple `@ForeignKey` annotation is not enough, you can manually specify references for your table: ```kotlin - @ForeignKey(saveForeignKeyModel = false, references = {ForeignKeyReference(columnName = "colony", foreignKeyColumnName = "id")}) var colony: Colony? = null; - ``` -By default not specifying references will take each field and append "${foreignKeyFieldName}_${ForeignKeyReferenceColumnName}" to make the reference column name. So by default the previous example would use `colony_id` without references. With references it becomes `colony`. +By default not specifying references will take each field and append "${foreignKeyFieldName}\_${ForeignKeyReferenceColumnName}" to make the reference column name. So by default the previous example would use `colony_id` without references. With references it becomes `colony`. ## Many To Many + In DBFlow many to many is done via source-gen. A simple table: ```kotlin @@ -104,11 +87,9 @@ In DBFlow many to many is done via source-gen. A simple table: class User(@PrimaryKey var id: Int = 0, @PrimaryKey var name: String = "") ``` -Generates a `@Table` class named `User_Follower`, which DBFlow treats as if you -coded the class yourself!: +Generates a `@Table` class named `User_Follower`, which DBFlow treats as if you coded the class yourself!: ```java - @Table( database = TestDatabase.class ) @@ -148,26 +129,21 @@ public final class User_Follower extends BaseModel { user = param; } } - ``` This annotation makes it very easy to generate "join" tables for you to use in the app for a ManyToMany relationship. It only generates the table you need. To use it you must reference it in code as normal. -_Note_: This annotation is only a helper to generate tables that otherwise you -would have to write yourself. It is expected that management still is done by you, the developer. +_Note_: This annotation is only a helper to generate tables that otherwise you would have to write yourself. It is expected that management still is done by you, the developer. ### Custom Column Names -You can change the name of the columns that are generated. By default they are simply -lower case first letter version of the table name. +You can change the name of the columns that are generated. By default they are simply lower case first letter version of the table name. -`referencedTableColumnName` -> Refers to the referenced table. -`thisTableColumnName` -> Refers to the table that is creating the reference. +`referencedTableColumnName` -> Refers to the referenced table. `thisTableColumnName` -> Refers to the table that is creating the reference. ### Multiple ManyToMany -You can also specify `@MultipleManyToMany` which enables you to define more -than a single `@ManyToMany` relationship on the table. +You can also specify `@MultipleManyToMany` which enables you to define more than a single `@ManyToMany` relationship on the table. A class can use both: @@ -181,3 +157,4 @@ class ManyToManyModel( @PrimaryKey var id: Int = 0, @PrimaryKey var anotherColumn: Char? = null) ``` + diff --git a/usage2/Retrieval.md b/usage2/usage/retrieval.md similarity index 54% rename from usage2/Retrieval.md rename to usage2/usage/retrieval.md index b301835ae..9905e537f 100644 --- a/usage2/Retrieval.md +++ b/usage2/usage/retrieval.md @@ -1,21 +1,16 @@ # Retrieval -DBFlow provides a few ways to retrieve information from the database. Through -the `Model` classes we can map this information to easy-to-use objects. +DBFlow provides a few ways to retrieve information from the database. Through the `Model` classes we can map this information to easy-to-use objects. -DBFlow provides a few different ways to retrieve information from the database. We -can retrieve synchronously or asynchronous (preferred). +DBFlow provides a few different ways to retrieve information from the database. We can retrieve synchronously or asynchronous \(preferred\). -We can also use `ModelView` ([read here](ModelViews.md)) and `@Index` ([read here](Indexing.md)) to perform faster retrieval on a set of data constantly queried. +We can also use `ModelView` \([read here](modelviews.md)\) and `@Index` \([read here](../advanced-usage/indexing.md)\) to perform faster retrieval on a set of data constantly queried. ## Synchronous Retrieval -Using the [SQLite query language](SQLiteWrapperLanguage.md) we can retrieve -data easily and expressively. To perform it synchronously: - +Using the [SQLite query language](sqlitewrapperlanguage.md) we can retrieve data easily and expressively. To perform it synchronously: ```kotlin - // list val employees = (select from Employee:class).list @@ -36,25 +31,19 @@ val employees = (select from Employee::class) val anotherObject = (select from Employee::class where(Employee_Table.name.eq("Andrew Grosner"))) .customSingle(); - ``` -To query custom objects or lists, see how to do so in [QueryModel](QueryModels.md). +To query custom objects or lists, see how to do so in [QueryModel](../advanced-usage/querymodels.md). -Also you can query a `FlowCursorList`/`FlowTableList` from a query easily -via `queryCursorList()` and the `queryTableList()` methods. To see more on these, -go to [Flow Lists](ListBasedQueries.md). +Also you can query a `FlowCursorList`/`FlowTableList` from a query easily via `queryCursorList()` and the `queryTableList()` methods. To see more on these, go to [Flow Lists](../advanced-usage/listbasedqueries.md). ## Asynchronous Retrieval -DBFlow provides the very-handy `Transaction` system that allows you to place all -calls to the DB in a background queue. Using this system, we recommend placing retrieval queries -on this queue to help prevent locking and threading issues when using a database. +DBFlow provides the very-handy `Transaction` system that allows you to place all calls to the DB in a background queue. Using this system, we recommend placing retrieval queries on this queue to help prevent locking and threading issues when using a database. We wrap our queries in a `beginTransactionAsync` block, executing and providing call backs to the method as follows: ```java - database.beginTransactionAsync { db -> (select from TestModel1::class where TestModel1_Table.name.is("Async")).querySingle(db) @@ -65,9 +54,9 @@ database.beginTransactionAsync { db -> completion = { transaction -> }) // always called success or failure ``` -A `ITransaction` simply returns a result, `R` , which could be a query, or a result from multiple queries combined into one result. +A `ITransaction` simply returns a result, `R` , which could be a query, or a result from multiple queries combined into one result. + +By default the library uses an ordered queue that executes FIFO \(first-in-first-out\) and blocks itself until new `Transaction` are added. Each subsequent call to the `database.beginTransactionAsync` places a new transaction on this queue. -By default the library uses an ordered queue that -executes FIFO (first-in-first-out) and blocks itself until new `Transaction` are added. Each subsequent call to the `database.beginTransactionAsync` places a new transaction on this queue. +If you wish to customize and provide a different queue \(or map it to an existing system\), read up on [Transactions](storingdata.md). We also provide constructs such as coroutines and RX `Observables` to map to your team's needs. -If you wish to customize and provide a different queue (or map it to an existing system), read up on [Transactions](StoringData.md). We also provide constructs such as coroutines and RX `Observables` to map to your team's needs. diff --git a/usage2/SQLiteWrapperLanguage.md b/usage2/usage/sqlitewrapperlanguage.md similarity index 69% rename from usage2/SQLiteWrapperLanguage.md rename to usage2/usage/sqlitewrapperlanguage.md index 212da13c9..bb7e10b8f 100644 --- a/usage2/SQLiteWrapperLanguage.md +++ b/usage2/usage/sqlitewrapperlanguage.md @@ -1,10 +1,8 @@ -# SQLite Wrapper Language +# SQLite Query Language -DBFlow's SQLite wrapper language attempts to make it as easy as possible to -write queries, execute statements, and more. +DBFlow's SQLite wrapper language attempts to make it as easy as possible to write queries, execute statements, and more. -We will attempt to make this doc comprehensive, but reference the SQLite language -for how to formulate queries, as DBFlow follows it as much as possible. +We will attempt to make this doc comprehensive, but reference the SQLite language for how to formulate queries, as DBFlow follows it as much as possible. ## SELECT @@ -16,45 +14,33 @@ select from SomeTable::class ### Projections -By default if no parameters are specified in the `select()` query, we use the `*` wildcard qualifier, -meaning all columns are returned in the results. +By default if no parameters are specified in the `select()` query, we use the `*` wildcard qualifier, meaning all columns are returned in the results. -To specify individual columns, you _must_ use `Property` variables. -These get generated when you annotate your `Model` with columns, or created manually. +To specify individual columns, you _must_ use `Property` variables. These get generated when you annotate your `Model` with columns, or created manually. ```kotlin - select(Player_Table.name, Player_Table.position) from Player::class - ``` -To specify methods such as `COUNT()` or `SUM()` (static import on `Method`): - +To specify methods such as `COUNT()` or `SUM()` \(static import on `Method`\): ```kotlin - select(count(Employee_Table.name), sum(Employee_Table.salary)) from Employee::class - ``` Translates to: -```sqlite - +```text SELECT COUNT(`name`), SUM(`salary`) FROM `Employee`; - ``` There are more handy methods in `Method`. ### Operators -DBFlow supports many kinds of operations. They are formulated into a `OperatorGroup`, -which represent a set of `SQLOperator` subclasses combined into a SQLite conditional piece. -`Property` translate themselves into `SQLOperator` via their conditional methods such as -`eq()`, `lessThan()`, `greaterThan()`, `between()`, `in()`, etc. +DBFlow supports many kinds of operations. They are formulated into a `OperatorGroup`, which represent a set of `SQLOperator` subclasses combined into a SQLite conditional piece. `Property` translate themselves into `SQLOperator` via their conditional methods such as `eq()`, `lessThan()`, `greaterThan()`, `between()`, `in()`, etc. They make it very easy to construct concise and meaningful queries: @@ -68,29 +54,25 @@ val taxBracketCount = (select(count(Employee_Table.name)) Translates to: -```sqlite - +```text SELECT COUNT(`name`) FROM `Employee` WHERE `salary`<150000 AND `salary`>80000; - ``` DBFlow supports `IN`/`NOT IN` and `BETWEEN` as well. A more comprehensive list of operations DBFlow supports and what they translate to: - 1. is(), eq() -> = - 2. isNot(), notEq() -> != - 3. isNull() -> IS NULL / isNotNull() -> IS NOT NULL - 4. like(), glob() - 5. greaterThan(), greaterThanOrEqual(), lessThan(), lessThanOrEqual() - 6. between() -> BETWEEN - 7. in(), notIn() +1. is\(\), eq\(\) -> = +2. isNot\(\), notEq\(\) -> != +3. isNull\(\) -> IS NULL / isNotNull\(\) -> IS NOT NULL +4. like\(\), glob\(\) +5. greaterThan\(\), greaterThanOrEqual\(\), lessThan\(\), lessThanOrEqual\(\) +6. between\(\) -> BETWEEN +7. in\(\), notIn\(\) #### Nested Conditions -To create nested conditions (in parenthesis more often than not), just include -an `OperatorGroup` as a `SQLOperator` in a query: - +To create nested conditions \(in parenthesis more often than not\), just include an `OperatorGroup` as a `SQLOperator` in a query: ```kotlin (select from Location::class @@ -102,10 +84,8 @@ an `OperatorGroup` as a `SQLOperator` in a query: Translates to: -```sqlite - +```text SELECT * FROM `Location` WHERE `latitude`=45.05 AND (`latitude` - 45.05) = 1000 - ``` #### Nested Queries @@ -120,15 +100,13 @@ This appends a `WHERE (SELECT * FROM {table} )` to the query. ### JOINS -For reference, ([JOIN examples](http://www.tutorialspoint.com/sqlite/sqlite_using_joins.htm)). +For reference, \([JOIN examples](http://www.tutorialspoint.com/sqlite/sqlite_using_joins.htm)\). -`JOIN` statements are great for combining many-to-many relationships. -If your query returns non-table fields and cannot map to an existing object, -see about [query models](QueryModels.md) +`JOIN` statements are great for combining many-to-many relationships. If your query returns non-table fields and cannot map to an existing object, see about [query models](../advanced-usage/querymodels.md) For example we have a table named `Customer` and another named `Reservations`. -```SQL +```sql SELECT FROM `Customer` AS `C` INNER JOIN `Reservations` AS `R` ON `C`.`customerId`=`R`.`customerId` ``` @@ -142,9 +120,9 @@ val customers = (select from Customer::class).as("C") .customList()); ``` -The `IProperty.withTable()` method will prepend a `NameAlias` or the `Table` alias to the `IProperty` in the query, convenient for JOIN queries: +The `IProperty.withTable()` method will prepend a `NameAlias` or the `Table` alias to the `IProperty` in the query, convenient for JOIN queries: -```sqlite +```text SELECT EMP_ID, NAME, DEPT FROM COMPANY LEFT OUTER JOIN DEPARTMENT ON COMPANY.ID = DEPARTMENT.EMP_ID ``` @@ -162,7 +140,6 @@ in DBFlow: ### Order By ```kotlin - // true for 'ASC', false for 'DESC'. ASC is default. (select from table orderBy(Customer_Table.customer_id) @@ -198,25 +175,17 @@ SQLite.select() ## UPDATE -DBFlow supports two kind of UPDATE: - 1. `Model.update()` - 2. `SQLite.update()` - -For simple `UPDATE` for a single or few, concrete set of `Model` stick with (1). -For powerful multiple `Model` update that can span many rows, use (2). In this -section we speak on (2). **Note:** if using model caching, you'll need to clear it out -post an operation from (2). +DBFlow supports two kind of UPDATE: 1. `Model.update()` 2. `SQLite.update()` +For simple `UPDATE` for a single or few, concrete set of `Model` stick with \(1\). For powerful multiple `Model` update that can span many rows, use \(2\). In this section we speak on \(2\). **Note:** if using model caching, you'll need to clear it out post an operation from \(2\). ```sql - UPDATE Ant SET type = 'other' WHERE male = 1 AND type = 'worker'; ``` Using DBFlow: ```kotlin - // Native SQL wrapper database.beginTransactionAsync { db -> (update() set Ant_Table.type.eq("other") @@ -226,25 +195,18 @@ database.beginTransactionAsync { db -> (update() }.execute { _, count -> }; // non-UI blocking ``` -The `Set` part of the `Update` supports different kinds of values: - 1. `ContentValues` -> converts to key/value as a `SQLOperator` of `is()`/`eq()` - 2. `SQLOperator`, which are grouped together as part of the `SET` statement. +The `Set` part of the `Update` supports different kinds of values: 1. `ContentValues` -> converts to key/value as a `SQLOperator` of `is()`/`eq()` 2. `SQLOperator`, which are grouped together as part of the `SET` statement. ## DELETE `DELETE` queries in DBFlow are similiar to `Update` in that we have two kinds: - 1. `Model.delete()` - 2. `SQLite.delete()` - -For simple `DELETE` for a single or few, concrete set of `Model` stick with (1). -For powerful multiple `Model` deletion that can span many rows, use (2). In this -section we speak on (2). **Note:** if using model caching, you'll need to clear it out -post an operation from (2). +1. `Model.delete()` +2. `SQLite.delete()` +For simple `DELETE` for a single or few, concrete set of `Model` stick with \(1\). For powerful multiple `Model` deletion that can span many rows, use \(2\). In this section we speak on \(2\). **Note:** if using model caching, you'll need to clear it out post an operation from \(2\). ```kotlin - // Delete a whole table delete().execute(database) @@ -258,19 +220,14 @@ database.beginTransactionAsync { db -> delete() ## INSERT -`INSERT` queries in DBFlow are also similiar to `Update` and `Delete` in that we -have two kinds: +`INSERT` queries in DBFlow are also similiar to `Update` and `Delete` in that we have two kinds: - 1. `Model.insert()` - 2. `SQLite.insert()` +1. `Model.insert()` +2. `SQLite.insert()` -For simple `INSERT` for a single or few, concrete set of `Model` stick with (1). -For powerful multiple `Model` insertion that can span many rows, use (2). In this -section we speak on (2). **Note:** using model caching, you'll need to clear it out -post an operation from (2). +For simple `INSERT` for a single or few, concrete set of `Model` stick with \(1\). For powerful multiple `Model` insertion that can span many rows, use \(2\). In this section we speak on \(2\). **Note:** using model caching, you'll need to clear it out post an operation from \(2\). ```kotlin - // columns + values via pairs database.beginTransactionAsync { db -> (insert(SomeTable_Table.name to "Default", @@ -289,7 +246,6 @@ database.beginTransactionAsync { db -> `INSERT` supports inserting multiple rows as well. ```kotlin - // columns + values separately database.beginTransactionAsync { db -> (insert(SomeTable_Table.name, SomeTable_Table.phoneNumber) @@ -306,37 +262,29 @@ database.beginTransactionAsync { db -> SomeTable_Table.phoneNumber.eq("6666666"))) .executeInsert(db) }.execute() - ``` ## Trigger -Triggers enable SQLite-level listener operations that perform some operation, modification, -or action to run when a specific database event occurs. [See](https://www.sqlite.org/lang_createtrigger.html) for more documentation on its usage. +Triggers enable SQLite-level listener operations that perform some operation, modification, or action to run when a specific database event occurs. [See](https://www.sqlite.org/lang_createtrigger.html) for more documentation on its usage. ```kotlin - *createTrigger("SomeTrigger") .after() insertOn()) .begin(update() .set(TestUpdateModel_Table.value.is("Fired")))) .enable(); // enables the trigger if it does not exist, so subsequent calls are OK - ``` ## Case -The SQLite `CASE` operator is very useful to evaluate a set of conditions and "map" them -to a certain value that returns in a SELECT query. +The SQLite `CASE` operator is very useful to evaluate a set of conditions and "map" them to a certain value that returns in a SELECT query. -We have two kinds of case: -1. Simple -2. Searched +We have two kinds of case: 1. Simple 2. Searched The simple CASE query in DBFlow: ```kotlin - select(CaseModel_Table.customerId, CaseModel_Table.firstName, CaseModel_Table.lastName, @@ -346,18 +294,13 @@ select(CaseModel_Table.customerId, `else` "Foreign") .end("CustomerGroup")) from() - ``` -The CASE is returned as `CustomerGroup` with the valyes of "Domestic" if the country is from -the 'USA' otherwise we mark the value as "Foreign". These appear alongside the results -set from the SELECT. +The CASE is returned as `CustomerGroup` with the valyes of "Domestic" if the country is from the 'USA' otherwise we mark the value as "Foreign". These appear alongside the results set from the SELECT. -The search CASE is a little more complicated in that each `when()` statement -represents a `SQLOperator`, which return a `boolean` expression: +The search CASE is a little more complicated in that each `when()` statement represents a `SQLOperator`, which return a `boolean` expression: ```kotlin - select(CaseModel_Table.customerId, CaseModel_Table.firstName, CaseModel_Table.lastName, @@ -367,3 +310,4 @@ select(CaseModel_Table.customerId, .end("CustomerGroup")) from() ``` + diff --git a/usage2/StoringData.md b/usage2/usage/storingdata.md similarity index 57% rename from usage2/StoringData.md rename to usage2/usage/storingdata.md index ba1aa2aa2..5b4ef8913 100644 --- a/usage2/StoringData.md +++ b/usage2/usage/storingdata.md @@ -1,13 +1,10 @@ # Storing Data -DBFlow provide a few mechanisms by which we store data to the database. The difference of options -should not provide confusion but rather allow flexibility in what you decide is the best way -to store information. +DBFlow provide a few mechanisms by which we store data to the database. The difference of options should not provide confusion but rather allow flexibility in what you decide is the best way to store information. ## Synchronous Storage -While generally saving data synchronous should be avoided, for small amounts of data -it has little effect. +While generally saving data synchronous should be avoided, for small amounts of data it has little effect. ```kotlin model.save() @@ -16,11 +13,10 @@ model.update() ``` Avoid saving large amounts of models outside of a transaction: -```kotlin +```kotlin // AVOID models.forEach { it.save() } - ``` Doing operations on the main thread can block it if you read and write to the DB on a different thread while accessing DB on the main. Instead, use Async Transactions. @@ -29,21 +25,15 @@ Doing operations on the main thread can block it if you read and write to the DB ## Transactions -Transactions are ACID in SQLite, meaning they either occur completely or not at all. -Using transactions significantly speed up the time it takes to store. So recommendation -you should use transactions whenever you can. +Transactions are ACID in SQLite, meaning they either occur completely or not at all. Using transactions significantly speed up the time it takes to store. So recommendation you should use transactions whenever you can. -Async is the preferred method. Transactions, using the `DefaultTransactionManager`, - occur on one thread per-database (to prevent flooding from other DB in your app) - and receive callbacks on the UI. You can override this behavior and roll your own - or hook into an existing system, read [here](StoringData.md#custom-transactionmanager). +Async is the preferred method. Transactions, using the `DefaultTransactionManager`, occur on one thread per-database \(to prevent flooding from other DB in your app\) and receive callbacks on the UI. You can override this behavior and roll your own or hook into an existing system, read [here](storingdata.md#custom-transactionmanager). -Also to use the legacy, priority-based system, read [here](StoringData.md#priority-queue). +Also to use the legacy, priority-based system, read [here](storingdata.md#priority-queue). - A basic transaction: - - ```kotlin +A basic transaction: +```kotlin val transaction = database().beginTransactionAsync { db -> // handle to DB // return a result, or execute a method that returns a result @@ -56,26 +46,17 @@ transaction.execute( transaction.cancel(); // attempt to cancel before its run. If it's already ran, this call has no effect. +``` - ``` - - The `Success` callback runs post-transaction on the UI thread. - The `Error` callback is called on the UI thread if and only if it is specified and an exception occurs, - otherwise it is thrown in the `Transaction` as a `RuntimeException`. **Note**: - all exceptions are caught when specifying the callback. Ensure you handle all - errors, otherwise you might miss some problems. +The `Success` callback runs post-transaction on the UI thread. The `Error` callback is called on the UI thread if and only if it is specified and an exception occurs, otherwise it is thrown in the `Transaction` as a `RuntimeException`. **Note**: all exceptions are caught when specifying the callback. Ensure you handle all errors, otherwise you might miss some problems. ### ProcessModelTransaction -`ProcessModelTransaction` allows for more flexibility and for you to easily operate on a set of `Model` in a -`Transaction` easily. It holds a list of `Model` by which you provide the modification -method in the `Builder`. You can listen for when each are processed inside a normal -`Transaction`. +`ProcessModelTransaction` allows for more flexibility and for you to easily operate on a set of `Model` in a `Transaction` easily. It holds a list of `Model` by which you provide the modification method in the `Builder`. You can listen for when each are processed inside a normal `Transaction`. It is a convenient way to operate on them: ```kotlin - database.beginTransactionAsync(items.processTransaction { model, db -> // call some operation on model here model.save() @@ -88,20 +69,13 @@ database.beginTransactionAsync(items.processTransaction { model, db -> } .build()) .execute() - ``` -You can listen to when operations complete for each model via the `OnModelProcessListener`. -These callbacks occur on the UI thread. If you wish to run them on same thread (great for tests), -set `runProcessListenerOnSameThread()` to `true`. +You can listen to when operations complete for each model via the `OnModelProcessListener`. These callbacks occur on the UI thread. If you wish to run them on same thread \(great for tests\), set `runProcessListenerOnSameThread()` to `true`. ### FastStoreModelTransaction -The `FastStoreModelTransaction` is the quickest, lightest way to store a `List` of -`Model` into the database through a `Transaction`. It comes with some restrictions when compared to `ProcessModelTransaction`: - 1. All `Model` must be from same Table/Model Class. - 2. No progress listening - 3. Can only `save`, `insert`, or `update` the whole list entirely. +The `FastStoreModelTransaction` is the quickest, lightest way to store a `List` of `Model` into the database through a `Transaction`. It comes with some restrictions when compared to `ProcessModelTransaction`: 1. All `Model` must be from same Table/Model Class. 2. No progress listening 3. Can only `save`, `insert`, or `update` the whole list entirely. ```kotlin database.beginTransactionAsync(list.fastSave().build()) @@ -112,21 +86,15 @@ database.beginTransactionAsync(list.fastUpdate().build()) .execute() ``` -What it provides: - 1. Reuses `ContentValues`, `DatabaseStatement`, and other classes where possible. - 2. Opens and closes own `DatabaseStatement` per total execution. - 3. Significant speed bump over `ProcessModelTransaction` at the expense of flexibility. +What it provides: 1. Reuses `ContentValues`, `DatabaseStatement`, and other classes where possible. 2. Opens and closes own `DatabaseStatement` per total execution. 3. Significant speed bump over `ProcessModelTransaction` at the expense of flexibility. ### Custom TransactionManager -If you prefer to roll your own thread-management system or have an existing -system you can override the default system included. - +If you prefer to roll your own thread-management system or have an existing system you can override the default system included. To begin you must implement a `ITransactionQueue`: ```kotlin - class CustomQueue : ITransactionQueue { override fun add(transaction: Transaction) { @@ -147,28 +115,22 @@ class CustomQueue : ITransactionQueue { } } - ``` -You must provide ways to `add()`, `cancel(Transaction)`, and `startIfNotAlive()`. -The other two methods are optional, but recommended. +You must provide ways to `add()`, `cancel(Transaction)`, and `startIfNotAlive()`. The other two methods are optional, but recommended. -`startIfNotAlive()` in the `DefaultTransactionQueue` will start itself (since it's -a thread). +`startIfNotAlive()` in the `DefaultTransactionQueue` will start itself \(since it's a thread\). - Next you can override the `BaseTransactionManager` (not required, see later): +Next you can override the `BaseTransactionManager` \(not required, see later\): ```kotlin - class CustomTransactionManager(databaseDefinition: DBFlowDatabase) : BaseTransactionManager(CustomTransactionQueue(), databaseDefinition) - ``` To register it with DBFlow, in your `FlowConfig`, you must: ```kotlin - FlowManager.init(FlowConfig.Builder(DemoApp.context) .database(DatabaseConfig( databaseClass = AppDatabase::class.java, @@ -177,20 +139,15 @@ FlowManager.init(FlowConfig.Builder(DemoApp.context) }) .build()) .build()) - ``` ### Priority Queue -In versions pre-3.0, DBFlow utilized a `PriorityBlockingQueue` to manage the asynchronous -dispatch of `Transaction`. As of 3.0, it has switched to simply a FIFO queue. To -keep the legacy way, a `PriorityTransactionQueue` was created. +In versions pre-3.0, DBFlow utilized a `PriorityBlockingQueue` to manage the asynchronous dispatch of `Transaction`. As of 3.0, it has switched to simply a FIFO queue. To keep the legacy way, a `PriorityTransactionQueue` was created. -As seen in [Custom Transaction Managers](StoringData.md#custom-transactionmanager), -we provide a custom instance of the `DefaultTransactionManager` with the `PriorityTransactionQueue` specified: +As seen in [Custom Transaction Managers](storingdata.md#custom-transactionmanager), we provide a custom instance of the `DefaultTransactionManager` with the `PriorityTransactionQueue` specified: ```kotlin - FlowManager.init(FlowConfig.builder(context) .database(DatabaseConfig.Builder(AppDatabase::class.java) .transactionManagerCreator { db -> @@ -203,11 +160,7 @@ FlowManager.init(FlowConfig.builder(context) .build()) ``` -What this does is for the specified database (in this case `AppDatabase`), -now require each `ITransaction` specified for the database should wrap itself around -the `PriorityTransactionWrapper`. Otherwise an the `PriorityTransactionQueue` -wraps the existing `Transaction` in a `PriorityTransactionWrapper` with normal priority. - +What this does is for the specified database \(in this case `AppDatabase`\), now require each `ITransaction` specified for the database should wrap itself around the `PriorityTransactionWrapper`. Otherwise an the `PriorityTransactionQueue` wraps the existing `Transaction` in a `PriorityTransactionWrapper` with normal priority. To specify a priority, wrap your original `ITransaction` with a `PriorityTransactionWrapper`: @@ -216,5 +169,5 @@ database() .beginTransactionAsync(PriorityTransactionWrapper.Builder(myTransaction) .priority(PriorityTransactionWrapper.PRIORITY_HIGH).build()) .execute(); - ``` + diff --git a/usage2/TypeConverters.md b/usage2/usage/typeconverters.md similarity index 57% rename from usage2/TypeConverters.md rename to usage2/usage/typeconverters.md index 1b32dee16..09f4010d3 100644 --- a/usage2/TypeConverters.md +++ b/usage2/usage/typeconverters.md @@ -1,23 +1,8 @@ -# Type conversion - -When building out `Model` classes, you may wish to provide a different type of `@Column` that from the standard supported column types. To recap the standard column types include: - 1. `String`, `char`, `Character` - 2. All numbers types (primitive + boxed) - 3. `byte[]`/`Byte` - 4. `Blob` (DBFlow's version) - 5. `Date`/`java.sql.Date` - 6. Bools - 7. `Model` as `@ForeignKey` - 8. `Calendar` - 9. `BigDecimal` - 10. `UUID` - -`TypeConverter` do _not_ support: - 1. Any Parameterized fields. - 2. `List`, `Map`, etc. Best way to fix this is to create a separate table [relationship](Relationships.md) - 3. Conversion from one type-converter to another (i.e `JSONObject` to `Date`). The first parameter of `TypeConverter` is the value of the type as if it was a primitive/boxed type. - 4. Conversion from custom type to `Model`, or `Model` to a supported type. - 5. The custom class _must_ map to a non-complex field such as `String`, numbers, `char`/`Character` or `Blob` +# TypeConverters + +When building out `Model` classes, you may wish to provide a different type of `@Column` that from the standard supported column types. To recap the standard column types include: 1. `String`, `char`, `Character` 2. All numbers types \(primitive + boxed\) 3. `byte[]`/`Byte` 4. `Blob` \(DBFlow's version\) 5. `Date`/`java.sql.Date` 6. Bools 7. `Model` as `@ForeignKey` 8. `Calendar` 9. `BigDecimal` 10. `UUID` + +`TypeConverter` do _not_ support: 1. Any Parameterized fields. 2. `List`, `Map`, etc. Best way to fix this is to create a separate table [relationship](relationships.md) 3. Conversion from one type-converter to another \(i.e `JSONObject` to `Date`\). The first parameter of `TypeConverter` is the value of the type as if it was a primitive/boxed type. 4. Conversion from custom type to `Model`, or `Model` to a supported type. 5. The custom class _must_ map to a non-complex field such as `String`, numbers, `char`/`Character` or `Blob` ## Define a TypeConverter @@ -26,7 +11,6 @@ Defining a `TypeConverter` is quick and easy. This example creates a `TypeConverter` for a field that is `JSONObject` and converts it to a `String` representation: ```java - @com.dbflow5.annotation.TypeConverter public class JSONConverter extends TypeConverter { @@ -46,13 +30,13 @@ public class JSONConverter extends TypeConverter { return jsonObject; } } - ``` Once this is defined, by using the annotation `@TypeConverter`, it is registered automatically accross all databases. -There are cases where you wish to provide multiple `TypeConverter` for same kind of field (i.e. `Date` with different date formats stored in a DB). +There are cases where you wish to provide multiple `TypeConverter` for same kind of field \(i.e. `Date` with different date formats stored in a DB\). ## TypeConverter for specific `@Column` In DBFlow, specifying a `TypeConverter` for a `@Column` is as easy as `@Column(typeConverter = JSONConverter.class)`. What it will do is create the converter once for use only when that column is used. + From 04cd2ef83361b2671a34c4a2324a3fecc815ff87 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sat, 20 Oct 2018 22:10:28 -0400 Subject: [PATCH 232/234] [Doc] remove kotlin support as lib is not kotlin. --- usage2/KotlinSupport.md | 226 ---------------------------------------- 1 file changed, 226 deletions(-) delete mode 100644 usage2/KotlinSupport.md diff --git a/usage2/KotlinSupport.md b/usage2/KotlinSupport.md deleted file mode 100644 index 74824a419..000000000 --- a/usage2/KotlinSupport.md +++ /dev/null @@ -1,226 +0,0 @@ -# Kotlin Support + Extensions - -DBFlow supports Kotlin out of the box and is fairly easily to use and implement. - -## Classes - -DBFlow Classes are beautifully concise to write: - -```kotlin -@Table(database = KotlinDatabase::class) -class Person(@PrimaryKey var id: Int = 0, @Column var name: String? = null) -``` - -Also `data` classes are supported. - -```kotlin -@Table(database = KotlinTestDatabase::class) -data class Car(@PrimaryKey var id: Int = 0, @Column var name: String? = null) -``` - -In 4.0.0+, DBFlow contains a few extensions for Kotlin models which enable you -to keep your models acting like `BaseModel`, but do not have to explicitly extend -the class! - -```kotlin - -car.save() // extension method, optional databaseWrapper parameter. -car.insert() -car.update() -car.delete() -car.exists() - -``` - -## Null Safety -DBFlow reflects the nullability on fields defined in their classes. If you define a -`@Column` as not null, it will not assign a null value to that field in the generated java. - -## Query LINQ Syntax - -Kotlin has nice support for custim `infix` operators. Using this we can convert a regular, Plain old java query into a C#-like LINQ syntax. - -java: -``` - -List = SQLite.select() - .from(Result.class) - .where(Result_Table.column.eq(6)) - .and(Result_Table.column2.in("5", "6", "9")).queryList() - -``` - -kotlin: - -``` -val 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 -``` - -Enabling us to write code that is closer in syntax to SQLite! - -This supported for almost any SQLite operator that this library provides including: - 1. `Select` - 2. `Insert` - 3. `Update` - 4. `Delete` - -**Async Operations**: -With extensions we also support `async` operations on queries: - -```kotlin - -// easy async list query -(select - from Result::class - where (column eq 6)) -.async list { transaction, list -> - // do something here - updateUI(list) -} - -// easy single result query -(select - from Result::class - where (column eq 6)) -.async result { transaction, model -> - // do something here - updateUI(model) -} - -val model = Result() - -model.async save { - // completed, now do something with model -} - -``` - -### Property Extensions - -With Kotlin, we can define extension methods on pretty much any class. - -With this, we added methods to easily create `IProperty` from anything to make -queries a little more streamlined. In this query, we also make use of the extension -method for `from` to streamline the query even more. - -```kotlin - -var query = (select - from TestModel::class - where (5.property lessThan column) - and (clause(date.property between start_date) - and(end_date))) - - -``` - -### Query Extensions - -We can easily create nested `Operator` into `OperatorGroup` also fairly easily, also -other, random extensions: -```kotlin - -select from SomeTable::class where (name.eq("name") and id.eq(0)) - -"name".op() collate NOCASE - -"name".nameAlias - -"name".nameAlias `as` "My Name" - -// query sugar - -select from SomeTable::class where (name eq "name") or (id eq 0) - -``` - - -### Database Extensions - -#### Process Models Asynchronously - -In Java, we need to write something of the fashion: - -```java - -List items = SQLite.select() - .from(TestModel.class) - .queryList(); - - database.beginTransactionAsync(new ProcessModelTransaction.Builder<>( - new ProcessModel() { - @Override - public void processModel(TestModel model, DatabaseWrapper database) { - - } - }) - .success(successCallback) - .error(errorCallback).build() - .execute(); - -``` - -In Kotlin, we can use a combo of DSL and extension methods to: - -```kotlin - -var items = (select from TestModel1::class).list - - // easily delete all these items. - items.processInTransactionAsync { it, databaseWrapper -> it.delete(databaseWrapper) } - - // easily delete all these items with success - items.processInTransactionAsync({ it, databaseWrapper -> it.delete(databaseWrapper) }, - success = { transaction -> - // do something here - }) -// delete with all callbacks -items.processInTransactionAsync({ it, databaseWrapper -> it.delete(databaseWrapper) }, - success = { transaction -> - // do something here - }, - error = { transaction, throwable -> - - }) - -``` - -The extension method on `Collection` allows you to perform this on all -collections from your Table! - -If you wish to easily do them _synchronously_ then use: - -```kotlin - -items.processInTransaction { it, databaseWrapper -> it.delete(databaseWrapper) } - -``` - -#### Class Extensions - -If you need access to the Database, ModelAdapter, etc for a specific class you -can now use the following (and more) inline reified global functions for easy access! - -```kotlin - -database() - -databaseForTable() - -writableDatabaseForTable() - -tableName() - -modelAdapter() - - -``` - -Which under-the-hood call their corresponding `FlowManager` methods. From 58c6a1f43a608cb77e03cb03e803021c55991f91 Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sun, 21 Oct 2018 02:15:57 +0000 Subject: [PATCH 233/234] GitBook: [develop] 9 pages modified --- .github/README.md | 2 + SUMMARY.md | 9 +- usage2/gettingstarted.md => gettingstarted.md | 12 +- usage2/README.md | 2 +- usage2/migration3guide.md | 587 ------------------ usage2/rxjavasupport.md | 2 +- usage2/summary.md | 29 - usage2/usage/README.md | 2 +- 8 files changed, 14 insertions(+), 631 deletions(-) rename usage2/gettingstarted.md => gettingstarted.md (94%) delete mode 100644 usage2/migration3guide.md delete mode 100644 usage2/summary.md diff --git a/.github/README.md b/.github/README.md index c41e0e049..715a11e59 100644 --- a/.github/README.md +++ b/.github/README.md @@ -1,2 +1,4 @@ # .github + + diff --git a/SUMMARY.md b/SUMMARY.md index e87200748..93783a91d 100644 --- a/SUMMARY.md +++ b/SUMMARY.md @@ -1,10 +1,11 @@ # Table of contents * [README](README.md) -* [README](usage2/README.md) +* [GettingStarted](gettingstarted.md) +* [Usage Docs](usage2/README.md) * [Including In Project](usage2/including-in-project.md) * [Proguard](usage2/proguard.md) - * [Usage](usage2/usage/README.md) + * [Main Usage](usage2/usage/README.md) * [Databases](usage2/usage/databases.md) * [Models](usage2/usage/models.md) * [Migrations](usage2/usage/migrations.md) @@ -24,11 +25,7 @@ * [Indexing](usage2/advanced-usage/indexing.md) * [SQLCipher](usage2/advanced-usage/sqlciphersupport.md) * [ContentProviderGeneration](usage2/contentprovidergeneration.md) - * [GettingStarted](usage2/gettingstarted.md) - * [Migration3Guide](usage2/migration3guide.md) * [Migration4Guide](usage2/migration4guide.md) - * [KotlinSupport](usage2/kotlinsupport.md) - * [SUMMARY](usage2/summary.md) * [ISSUE\_TEMPLATE](issue_template.md) * [.github](.github/README.md) * [CONTRIBUTING](.github/contributing.md) diff --git a/usage2/gettingstarted.md b/gettingstarted.md similarity index 94% rename from usage2/gettingstarted.md rename to gettingstarted.md index d194ea17b..faa8a3c49 100644 --- a/usage2/gettingstarted.md +++ b/gettingstarted.md @@ -17,11 +17,11 @@ public abstract class AppDatabase extends DBFlowDatabase { } ``` -The name of the database by default is the class name. To change it, read [here](usage/databases.md). +The name of the database by default is the class name. To change it, read [here](usage2/usage/databases.md). Writing this file generates \(by default\) a `AppDatabaseAppDatabase_Database.java` file, which contains tables, views, and more all tied to a specific database. This class is automatically placed into the main `GeneratedDatabaseHolder`, which holds potentially many databases. The name, `AppDatabaseAppDatabase_Database.java`, is generated via {DatabaseClassName}{DatabaseFileName}\_Database -To learn more about what you can configure in a database, read [here](usage/databases.md) +To learn more about what you can configure in a database, read [here](usage2/usage/databases.md) ## Initialize FlowManager @@ -50,7 +50,7 @@ public class ExampleApplication extends Application { } ``` -By default without passing in a `DatabaseConfig`, we construct an `AndroidSQLiteOpenHelper` database instance. To learn more about what you can configure in a database, read [here](usage/databases.md), including providing own database instances. +By default without passing in a `DatabaseConfig`, we construct an `AndroidSQLiteOpenHelper` database instance. To learn more about what you can configure in a database, read [here](usage2/usage/databases.md), including providing own database instances. Finally, add the custom `Application` definition to the manifest \(with the name that you chose for the class\): @@ -91,11 +91,11 @@ FlowManager.init(FlowConfig.builder(this) .build())) ``` -You can define different kinds for each database. To read more on transactions and subclassing `BaseTransactionManager` go [here](usage/storingdata.md) +You can define different kinds for each database. To read more on transactions and subclassing `BaseTransactionManager` go [here](usage2/usage/storingdata.md) ## Create Models -Creating models are as simple as defining the model class, and adding the `@Table` annotation. To read more on this, read [here](usage/models.md). +Creating models are as simple as defining the model class, and adding the `@Table` annotation. To read more on this, read [here](usage2/usage/models.md). **For now**: Models must provide a default, parameterless constructor. An example: @@ -169,7 +169,7 @@ SQLite.select(FlowManager.getDatabase(AppDatabase.class)) .where(Currency_Table.symbol.eq("$")); ``` -We support many kinds of complex and complicated queries using the builder language. To read more about this, see [the wrapper language docs](usage/sqlitewrapperlanguage.md) +We support many kinds of complex and complicated queries using the builder language. To read more about this, see [the wrapper language docs](usage2/usage/sqlitewrapperlanguage.md) There is much more you can do in DBFlow. Read through the other docs to get a sense of the library. diff --git a/usage2/README.md b/usage2/README.md index 0cc64b19f..c136ca8b1 100644 --- a/usage2/README.md +++ b/usage2/README.md @@ -1,4 +1,4 @@ -# README +# Usage Docs DBFlow is a Kotlin SQLite library for Android that makes it ridiculously easy to interact and use databases. Built with Annotation Processing, code use within a DB is fast, efficient, and type-safe. It removes the tedious \(and tough-to-maintain\) database interaction code, while providing a very SQLite-like query syntax. diff --git a/usage2/migration3guide.md b/usage2/migration3guide.md deleted file mode 100644 index 22a64fa5b..000000000 --- a/usage2/migration3guide.md +++ /dev/null @@ -1,587 +0,0 @@ -# Migration3Guide - -DBFlow has undergone the most _significant_ changes in its lifetime in 3.0. This guide is meant to assist you in migrating from 2.1.x and above and _may not_ be fully inclusive of all changes. This doc will mention the most glaring and significant changes. If in doubt, consult the usage2 docs. - -A significant portion of the changes include the _complete_ overhaul of the underlying annotation processor, leading to wonderful improvements in maintainability of the code, readability, and stability of the generated code. Now it uses the updated [JavaPoet](https://github.com/square/javapoet) vs the outdated JavaWriter. The changes in this library alone _significantly_ helps out the stability of the generated code. - -_Some Changes to Note:_ 1. `update` no longer attempts to `insert` if it fails. 2. Package private fields from other packages are now automatically accessible via generated `_Helper` classes. The referenced fields must be annotated with `@Column`, `@PrimaryKey`, or `@ForeignKey`. if its a legacy `ForeignKeyReference`, `referendFieldIsPackagePrivate()` must be set to true. 3. `@Column` no longer required in conjunction with `@PrimaryKey` or `@ForeignKey` 4. Can now have DBFlow in multiple modules, libraries, etc via "Modules"! 5. `TransactionManager` has been replaced with a new per-database `BaseTransactionManager`. Each DB has its own `DBTransactionQueue` and you can replace the default with your own system. Also, no longer is this priority-based, but rather order-based. See more [here](https://github.com/agrosner/DBFlow/tree/fb3739caa4c894d50fd0d7873c70a33416c145e6/usage2/Transactions.md) - -This doc is to provide some basic examples of what has changed, but read all of the new usage docs! Starting with [Intro]() - -## Table Of Contents - -1. [Initialization](migration3guide.md#initialization) -2. [Database + Table Structure](migration3guide.md#database-and-table-structure) -3. [Transactions Overhaul](migration3guide.md#transactions-overhaul) -4. [Properties](migration3guide.md#properties) -5. [ModelContainers](migration3guide.md#modelcontainers) -6. [ModelViews](migration3guide.md#modelviews) -7. [Caching](migration3guide.md#caching) -8. [Database Modules](migration3guide.md#database-modules) - -## Initialization - -Previously DBFlow was intialized via: - -```java -public class ExampleApplication extends Application { - - @Override - public void onCreate() { - super.onCreate(); - FlowManager.init(this); - } -} -``` - -Now we use the `FlowConfig.Builder`: - -```java -public class ExampleApplication extends Application { - - @Override - public void onCreate() { - super.onCreate(); - FlowManager.init(new FlowConfig.Builder(this).build()); - } -} -``` - -See more of what you can customize [here](gettingstarted.md) - -## Database And Table Structure - -### Database changes - -The default `generatedClassSeparator` is now `_` instead of `$` to play nice with Kotlin by default. A simple addition of: - -```java -@Database(generatedClassSeparator = "$") -``` - -will keep your generated "Table" and other classes the same name. - -Globally, we no longer reference what `@Database` any database-specific element \(Table, Migration, etc\) by `String` name, but by `Class` now. - -Before: - -```java -@Table(databaseName = AppDatabase.NAME) -@Migration(databaseName = AppDatabase.NAME) -``` - -After: - -```java -@Table(database = AppDatabase.class) -@Migration(database = AppDatabase.class) -``` - -Why: We decided that referencing it directly by class name enforces type-safety and direct enforcement of the database placeholder class. Previously, - -```java -@Table(databaseName = "AppDatabase") -``` - -was a valid specifier, which might lead to typos or errors. - -## Table Changes - -`@Table` have some significant changes. - -Private boolean fields by default have changed. `useIsForPrivateBooleans()` has changed to `useBooleanGetterSetters()`. By default this is enabled, meaning `boolean` variables follow the convention: - -```java -private boolean isEnabled; - -public boolean isEnabled() { - return isEnabled; -} - -public void setEnabled(boolean isEnabled) { - this.isEnabled = isEnabled; -} -``` - -Instead of generating just `String` column name within a corresponding `$Table` class, it now generates `Property` fields. These fields are significantly smarter and more powerful. They considerably aid in the simplification of many complex queries and make the code in general more readable, type-safe, and just overall better. _NOTE: the properties are no longer capitalized, rather they match exact casing of the Column name._ - -Previously, when you defined a class as: - -```java -@Table(databaseName = TestDatabase.NAME) -@ModelContainer -public class TestModel2 extends BaseModel { - - @Column - @PrimaryKey - String name; - - @Column(name = "model_order") - int order; -} -``` - -It generated a `TestModel2$Table` class: - -```java -public final class TestModel2_Table { - - public static final String NAME = "name"; - - public static final String MODEL_ORDER = "model_order"; -} -``` - -Now when you define a class, it generates a definition as follows: - -```java -public final class TestModel2_Table { - public static final Property name = new Property(TestModel2.class, "name"); - - public static final IntProperty model_order = new IntProperty(TestModel2.class, "model_order"); - - public static IProperty[] getAllColumnProperties() { - return new IProperty[]{name,model_order}; - } - - public static BaseProperty getProperty(String columnName) { - columnName = QueryBuilder.quoteIfNeeded(columnName); - switch (columnName) { - case "`name`": { - return name; - } - case "`model_order`": { - return model_order; - } - default: { - throw new IllegalArgumentException("Invalid column name passed. Ensure you are calling the correct table's column"); - } - } - } -} -``` - -Each `Property` now is used for each all references to a column in query statements. - -The `getProperty()` method allows to keep compatibility with the old format, solve some `ContentProvider` compatibility issues, or allow looking up `Property` by key. - -To read on how these properties interact read "Properties, Conditions, Queries, Replacement of ConditionQueryBuilder and more". - -### Index changes - -Added was an `IndexGroup[]` of `indexGroups()`. - -Now we can generate `IndexProperty` \(see properties for more information\), which provide us a convenient generated `Index` to use for the table. This then is used in a queries that rely on indexes and make it dead simple to activate and deactivate indexes. - -A class written like: - -```java -@Table(database = TestDatabase.class, - indexGroups = { - @IndexGroup(number = 1, name = "firstIndex"), - @IndexGroup(number = 2, name = "secondIndex"), - @IndexGroup(number = 3, name = "thirdIndex") - }) -public class IndexModel2 extends BaseModel { - - @Index(indexGroups = {1, 2, 3}) - @PrimaryKey - int id; - - @Index(indexGroups = 1) - @Column - String first_name; - - @Index(indexGroups = 2) - @Column - String last_name; - - @Index(indexGroups = {1, 3}) - @Column - Date created_date; - - @Index(indexGroups = {2, 3}) - @Column - boolean isPro; -} -``` - -Generates in its "Table" class: - -```java -public final class IndexModel2_Table { - //...previous code omitted - - public static final IndexProperty index_firstIndex = new IndexProperty<>("firstIndex", false, IndexModel2.class, id, first_name, created_date); - - public static final IndexProperty index_secondIndex = new IndexProperty<>("secondIndex", false, IndexModel2.class, id, last_name, isPro); - - public static final IndexProperty index_thirdIndex = new IndexProperty<>("thirdIndex", false, IndexModel2.class, id, created_date, isPro); -``` - -### Foreign Key Changes - -`@ForeignKey` fields no longer need to specify it's references or the `@Column` annotation!!! The old way still works, but is no longer necessary for `Model`-based ForeignKeys. The annotation processor takes the primary keys of the referenced table and generates a column with {fieldName}_{referencedColumnName} that represents the same SQLite Type of the field._ -_\_Note: that is not backwards compatible_ with apps already with references. - -Going forward with new tables, you can leave them out. - -Previously: - -```java -@Table(database = TestDatabase.class) -public class ForeignInteractionModel extends TestModel1 { - - @Column - @ForeignKey( - onDelete = ForeignKeyAction.CASCADE, - onUpdate = ForeignKeyAction.CASCADE, - references = - {@ForeignKeyReference(columnName = "testmodel_id", - foreignColumnName = "name", - columnType = String.class), - @ForeignKeyReference(columnName = "testmodel_type", - foreignColumnName = "type", - columnType = String.class)}, - saveForeignKeyModel = false) - ForeignKeyContainer testModel1; -} -``` - -Now: - -```java -@Table(database = TestDatabase.class) -public class ForeignInteractionModel extends TestModel1 { - - @ForeignKey( - onDelete = ForeignKeyAction.CASCADE, - onUpdate = ForeignKeyAction.CASCADE, - saveForeignKeyModel = false) - ForeignKeyContainer testModel1; -} -``` - -The result is _significantly_ cleaner and less overhead to maintain. - -If you wish to keep old references, please keep in mind that `foreignColumnName` is now `foreignKeyColumnName`. - -## Transactions Overhaul - -In 3.0, Transactions got a serious facelift and should be easier to use and handle. Also their logic and use are much more consolidated a focused. There is no longer just one `TransactionManager`, rather each database has its own instance so that operations between databases don't interfere. - -### Inserting Data - -The format of how to declare them has changed: Previously to run a transaction, you had to set it up as so: - -```java -ProcessModelInfo processModelInfo = ProcessModelInfo.withModels(models) - .result(resultReceiver) - .info(myInfo); -TransactionManager.getInstance().addTransaction(new SaveModelTransaction<>(processModelInfo)) -TransactionManager.getInstance().addTransaction(new UpdateModelListTransaction<>(processModelInfo)) -TransactionManager.getInstance().addTransaction(new DeleteModelListTransaction<>(processModelInfo)) -``` - -In 3.0, we have dropped the individual transaction types, use a new builder notation, and with _every_ `Transaction` you get completion and error handling: - -```java -FlowManager.getDatabase(AppDatabase.class) - .beginTransactionAsync(new ProcessModelTransaction.Builder<>( - new ProcessModelTransaction.ProcessModel() { - @Override - public void processModel(Model model) { - - } - }).build()) - .error(new Transaction.Error() { - @Override - public void onError(Transaction transaction, Throwable error) { - - } - }) - .success(new Transaction.Success() { - @Override - public void onSuccess(Transaction transaction) { - - } - }).build().execute(); -``` - -One thing to note about the `Transaction.Error` is that if specified, _all_ exceptions are caught and passed to the callback, otherwise any exception that happens in the Transaction system gets thrown. - -You still can use the `DBBatchSaveQueue` for batch saves: - -Previously: - -```java -TransactionManager.getInstance().saveOnSaveQueue(models); -``` - -In 3.0: - -```java -FlowManager.getDatabase(AppDatabase.class).getTransactionManager() - .getSaveQueue().addAll(models); -``` - -### Querying Data - -Previously when you queried data you have a few different classes that did almost same thing such as `SelectListTransaction`, `BaseResultTransaction`, `QueryTransaction`, etc. 3.0 consolidates these into much simpler operations via: - -Previously: - -```java -TransactionManager.getInstance().addTransaction(new SelectListTransaction<>(new TransactionListenerAdapter() { - @Override - public void onResultReceived(List testModels) { - - } - }, TestModel.class, condition1, condition2,..); -``` - -In 3.0: - -```java -database.beginTransactionAsync( - new QueryTransaction.Builder<>( - SQLite.select().from(TestModel1.class)) - .queryResult(new QueryTransaction.QueryResultCallback() { - @Override - public void onQueryResult(QueryTransaction transaction, @NonNull CursorResult result) { - - } - }).build()).build(); -``` - -The `QueryResultCallback` gives back a `CursorResult`, which is a wrapper around abstract `Cursor` that lets you retrieve easily `Models` from that cursor: - -```java -List models = result.toListClose(); -TestModel1 singleModel = result.toModelClose(); -``` - -Just ensure that you close the `Cursor`. - -### Callback Changes - -With 3.0, we modified the callback for a `Transaction`. Instead of having the 3 methods: - -```java -public interface TransactionListener { - - void onResultReceived(ResultClass result); - - boolean onReady(BaseTransaction transaction); - - boolean hasResult(BaseTransaction transaction, ResultClass result); - -} -``` - -Each `Transaction` automatically gives you ability to handle callbacks: - -```java -FlowManager.getDatabase(AppDatabase.class) - .beginTransactionAsync(new ITransaction() { - @Override - public void execute(DatabaseWrapper databaseWrapper) { - // do anything you want here. - } - }).build()) - .error(new Transaction.Error() { - @Override - public void onError(Transaction transaction, Throwable error) { - - } - }) - .success(new Transaction.Success() { - @Override - public void onSuccess(Transaction transaction) { - - } - }).build().execute(); -``` - -For more usage on the new system, including the ability to roll your own `TransactionManager`, visit [Transactions](https://github.com/agrosner/DBFlow/tree/fb3739caa4c894d50fd0d7873c70a33416c145e6/usage2/Transactions.md) - -## Properties - -Perhaps the most significant external change to this library is making queries, conditions, and interactions with the database much stricter and more type-safe. - -### Property - -Properties replace `String` column names generated in the "$Table" classes. They also match exact case to the column name. They have methods that generate `Condition` that drastically simplify queries. \(Please note the `Condition` class has moved to the `.language` package\). - -Properties are represented by the interface `IProperty` which are subclassed into `Property`, `Method`, and the primitive properties \(`IntProperty`, `CharProperty`, etc\). - -Properties can also be represented by values via the `PropertyFactory` class, enabling values to appear first in queries: - -```java -PropertyFactory.from(5l) // generates LongProperty -PropertyFactory.from(5d) // generates DoubleProperty -PropertyFactory.from("Hello") // generates Property -PropertyFactory.from(Date.class, someDate) // generates Property -``` - -It will become apparent why this change was necessary with some examples: - -A non-simple query by SQLite standards: - -```sql -SELECT `name` AS `employee_name`, AVG(`salary`) AS `average_salary`, `order`, SUM(`salary`) as `sum_salary` - FROM `SomeTable` - WHERE `salary` > 150000 -``` - -Before: - -```java -List items = - new Select(ColumnAlias.column(SomeTable$Table.NAME).as("employee_name"), - ColumnAlias.columnsWithFunction("AVG", SomeTable$Table.SALARY).as("average_salary"), - SomeTable$Table.ORDER, - ColumnAlias.columnsWithFunction("SUM", SomeTable$Table.SALARY).as("sum_salary")) - .from(SomeTable.class) - .where(Condition.column(SomeTable$Table.SALARY).greaterThan(150000)) - .queryCustomList(SomeQueryTable.class); -``` - -Now \(with static import on `SomeTable_Table` and `Method` \): - -```java -List items = - SQLite.select(name.as("employee_name"), - avg(salary).as("average_salary"), - order, - sum(salary).as("sum_salary")) - .from(SomeTable.class) - .where(salary.greaterThan(150000)) - .queryCustomList(SomeQueryTable.class); -``` - -The code instantly becomes cleaner, and reads more like an actual query. - -### Replacement of the ConditionQueryBuilder - -ConditionQueryBuilder was fundamentally flawed. It represented a group of `Condition`, required a `Table`, yet extended `QueryBuilder`, meaning arbitrary `String` information could be appended to it, leading to potential for messy piece of query. - -It has been replaced with the `ConditionGroup` class. This class represents an arbitrary group of `SQLCondition` in which it's sole purpose is to group together `SQLCondition`. Even better a `ConditionGroup` itself is a `SQLCondition`, meaning it can _nest_ inside of other `ConditionGroup` to allow complicated and insane queries. - -Now you can take this: - -```sql -SELECT FROM `SomeTable` WHERE 0 < `latitude` AND (`longitude` > 50 OR `longitude` < 25) AND `name`='MyHome' -``` - -and turn it into: - -```java -SQLite.select() - .from(SomeTable.class) - .where(PropertyFactory.from(0).lessThan(SomeTable_Table.latitude)) - .and(ConditionGroup.clause() - .and(SomeTable_Table.longitude.greaterThan(50)) - .or(SomeTable_Table.longitude.lessThan(25))) - .and(SomeTable_Table.name.eq("MyHome")) -``` - -## ModelContainers - -Now `ModelContainer` objects have a multitude of type-safe methods to ensure that they can convert their contained object's data into the field they associate with. What this means is that if our `Model` has a `long` field, while the data object for the `ModelContainer` has a `Integer` object. Previously, we would get a classcastexception. Now what it does is "coerce" the value into the type you need. Supported Types: 1. Integer/int 2. Double/Double 3. Boolean/boolean 4. Short/short 5. Long/long 6. Float/Float 7. String 8. Blob/byte\[\]/Byte\[\] 9. Byte/byte 10. Using TypeConverter to retrieve value safely. - -You can now `queryModelContainer` from the database to retrieve a single `Model` into `ModelContainer` format instead of into `Model` and then `ModelContainer`: - -```java -JSONModel model = SQLite.select().from(SomeTable.class).where(SomeTable_Table.id.eq(5)).queryModelContainer(new JSONModel()); -JSONObject json = model.getData(); -// has data now -``` - -For the `toModel()` conversion/parse method from `ModelContainer` to `Model`, you can now: 1. Have `@Column` excluded from it via `excludeFromToModelMethod()` 2. include other fields in the method as well by adding the `@ContainerKey` annotation to them. - -## ModelViews - -No longer do we need to specify the query for the `ModelView` in the annotation without ability to use the wrappper classes. We define a `@ModelViewQuery` field to use and then it simply becomes: - -```java -@ModelViewQuery - public static final Query QUERY = new Select(AModel_Table.time) - .from(AModel.class).where(AModel_Table.time.greaterThan(0l)); -``` - -What this means is that its easier than before to use Views. - -## Caching - -I significantly revamped model caching in this release to make it easier, support more tables, and more consistent. Some of the significant changes: - -Previously you needed to extend `BaseCacheableModel` to enable model caching. No longer! The code that was there now generates in the corresponding `ModelAdapter` by setting `cachingEnabled = true` in the `@Table` annotation. - -Before - -```java -@Table(databaseName = TestDatabase.NAME) -public class CacheableModel extends BaseCacheableModel { - - @Column - @PrimaryKey(autoincrement = true) - long id; - - @Column - String name; - - @Override - public int getCacheSize() { - return 1000; - } -} -``` - -After: - -```java -@Table(database = TestDatabase.class, cachingEnabled = true, cacheSize = 1000) -public class CacheableModel extends BaseModel { - - @PrimaryKey(autoincrement = true) - long id; - - @Column - String name; -} -``` - -Also, you can now have caching objects with _multiple_ primary keys!!! - -Simply in your model class define a `@MultiCacheField` and now you can cache objects with multiple primary keys: - -```java -@Table(database = TestDatabase.class, cachingEnabled = true) -public class MultipleCacheableModel extends BaseModel { - - @MultiCacheField - public static IMultiKeyCacheConverter multiKeyCacheModel = new IMultiKeyCacheConverter() { - - @Override - @NonNull - public String getCachingKey(@NonNull Object[] values) { - return "(" + values[0] + "," + values[1] + ")"; - } - }; - - @PrimaryKey - double latitude; - - @PrimaryKey - double longitude; - -} -``` - -Please note that the field must be of type `IMultiKeyCacheConverter` in order to compile and convert correctly. You must provide one, otherwise caching will not work. Also the return caching key _must_ be unique, otherwise inconsistent results may occur from within the cache. - -## Database Modules - -Now in DBFlow we have support for libraries, other subprojects, and more in general to all use DBFlow at the same time. The only requirement is that they specify an argument to `apt` in order to prevent clashes and the library loads the class during the initialization phase. To read on how to do this \(fairly simply\), please check it out here: \([Database Modules](https://github.com/Raizlabs/DBFlow/blob/master/usage/DatabaseModules.md)\) - diff --git a/usage2/rxjavasupport.md b/usage2/rxjavasupport.md index 824579257..766bacd19 100644 --- a/usage2/rxjavasupport.md +++ b/usage2/rxjavasupport.md @@ -95,7 +95,7 @@ RXSQLite.rx( ## Kotlin Support -Most of the support mirrors [kotlin support](kotlinsupport.md) with a few minor changes. +Most of the support mirrors [kotlin support]() with a few minor changes. Extension properties/methods include: 1. `rx()` extension method making it super easy to integrate RX. 2. `RXModelQueriable.streamResults` - stream results one at time to a `Subscription` 3. `list`, `result`,`streamResults`, `cursorResult`,`statement`, `hasData`, `cursor`, and `count` all provide a method lambda that is called within a `Subscription`. diff --git a/usage2/summary.md b/usage2/summary.md deleted file mode 100644 index c82ed08fe..000000000 --- a/usage2/summary.md +++ /dev/null @@ -1,29 +0,0 @@ -# SUMMARY - -* [Introduction](./) -* [Including in Project](including-in-project.md) -* [Proguard](proguard.md) -* [Usage](usage/) - * [Databases](usage/databases.md) - * [Models](usage/models.md) - * [Migrations](usage/migrations.md) - * [Views](usage/modelviews.md) - * [Relationships](usage/relationships.md) - * [Storing Data](usage/storingdata.md) - * [Retrieval](usage/retrieval.md) - * [SQLite Wrapper Language](usage/sqlitewrapperlanguage.md) - * [Migrations](usage/migrations.md) - * [Type Converters](usage/typeconverters.md) - * [Observability](usage/observability.md) -* [Kotlin Support](kotlinsupport.md) -* [RX Java Support](rxjavasupport.md) -* [Advanced Usage](advanced-usage/) - * [Caching](advanced-usage/caching.md) - * [List Based Queries](advanced-usage/listbasedqueries.md) - * [Multiple Modules](advanced-usage/multiplemodules.md) - * [Query Models](advanced-usage/querymodels.md) - * [Indexing](advanced-usage/indexing.md) - * [SQLCipher](https://github.com/agrosner/DBFlow/tree/fb3739caa4c894d50fd0d7873c70a33416c145e6/usage2/SQLCipher.md) -* [Migration 3 Guide](migration3guide.md) -* [Migration 4 Guide](migration4guide.md) - diff --git a/usage2/usage/README.md b/usage2/usage/README.md index 579f6e691..4a8ed12c0 100644 --- a/usage2/usage/README.md +++ b/usage2/usage/README.md @@ -1,4 +1,4 @@ -# Usage +# Main Usage DBFlow supports a number of database features that will enhance and decrease time you need to spend coding with databases. We support multiple databases at the same time \(and in separate modules\) as long as there's no shared models. From cee64f0d74edac7edfbaf83a651f48e4415eb9af Mon Sep 17 00:00:00 2001 From: Andrew Grosner Date: Sat, 20 Oct 2018 22:21:18 -0400 Subject: [PATCH 234/234] [Doc] update compile to implementation. --- usage2/including-in-project.md | 20 +++++++++----------- 1 file changed, 9 insertions(+), 11 deletions(-) diff --git a/usage2/including-in-project.md b/usage2/including-in-project.md index 40c4eb912..b9bbd4762 100644 --- a/usage2/including-in-project.md +++ b/usage2/including-in-project.md @@ -23,7 +23,7 @@ This repo is used to publish the artifacts. It also enables [dynamic builds](htt ```groovy allProjects { repositories { - google() + google() // required to find the project's artifacts // place last maven { url "https://www.jitpack.io" } @@ -48,27 +48,25 @@ Add artifacts to your project: // if only using Java, use this. If using Kotlin do NOT use this. annotationProcessor "com.github.agrosner.dbflow:processor:${dbflow_version}" - // core set of libraries - compile "com.github.agrosner.dbflow:core:${dbflow_version}" - compile "com.github.agrosner.dbflow:lib:${dbflow_version}" + implementation "com.github.agrosner.dbflow:core:${dbflow_version}" + implementation "com.github.agrosner.dbflow:lib:${dbflow_version}" // sql-cipher database encryption (optional) - compile "com.github.agrosner.dbflow:sqlcipher:${dbflow_version}" - compile "net.zetetic:android-database-sqlcipher:${sqlcipher_version}@aar" + implementation "com.github.agrosner.dbflow:sqlcipher:${dbflow_version}" + implementation "net.zetetic:android-database-sqlcipher:${sqlcipher_version}@aar" // RXJava 2 support - compile "com.github.agrosner.dbflow:reactive-streams:${dbflow_version}" + implementation "com.github.agrosner.dbflow:reactive-streams:${dbflow_version}" // Kotlin Coroutines - compile "com.github.agrosner.dbflow:coroutines:${dbflow_version}" + implementation "com.github.agrosner.dbflow:coroutines:${dbflow_version}" // Android Architecture Components Paging Library Support - compile "com.github.agrosner.dbflow:paging:${dbflow_version}" + implementation "com.github.agrosner.dbflow:paging:${dbflow_version}" // adds generated content provider annotations + support. - compile "com.github.agrosner.dbflow:contentprovider:${dbflow_version}" + implementation "com.github.agrosner.dbflow:contentprovider:${dbflow_version}" } ``` -