pushtorefresh / storio Goto Github PK

Remove putResolver()

Use _id

For better readability

Via transactions (#41)

Like this:

bambooStorage()
            .delete()
            .objects(users)
            .mapFunc(User.MAP_TO_DELETE_QUERY)
            .inTransaction(true)
            .prepare()
            .createObservable();

There is no JavaDoc at all...

I think it should be part of BambooStorage, we can provide blocking and Observable variants.

bambooStorage().execSql(SQLQuery).prepare()
Execute a single SQL statement that is NOT a SELECT/INSERT/UPDATE/DELETE.

And SQLQuery + SQLQueryBuilder, which will be same as RawQuery

@nikitin-da any comments?

All design tests for operations should be named like this: "operationDesignTest"

Or vice versa.

Personally, I don't like difference:

List<User> users = bambooStorage()
                .get()
                .query(new QueryBuilder()
                        .table("users")
                        .where("email = ?")
                        .whereArgs("[email protected]")
                        .build())
                .resultAsObjects(User.MAP_FROM_CURSOR) // <-- this 
                .executeAsBlocking();

Observable<SinglePutResult> observablePutResult = bambooStorage()
                .put()
                .object(user) // <-- and this
                .mapFunc(User.MAP_TO_CONTENT_VALUES)
                .putResolver(User.PUT_RESOLVER)
                .prepare() // <-- and this
                .createObservable();

Prepare Design of API for delete operation

get().asCursor() -> get().cursor()

get().asListOfObjects() -> get().listOfObjects()

Support two overloads

bambooStorage.put().objects(@NonNull T... objects)
bambooStorage.put().objects(@NonNull Iterable<T> objects)

"@ContentPathForContentResolver" annotation can be used for this

For example, I want to make all queries on Schedulers.io() and observe them on AndroidSchedulers.mainThread()

It can be done via compose() operator, here is useful article from @dlew http://blog.danlew.net/2015/03/02/dont-break-the-chain/

Possible syntax:

Transformer<Observable, Observable> transformer = new Transformer<>() {
  @Override Observable transform(Observable observable) {
    return observable
                 .subscribeOn(Schedulers.io())
                 .observeOn(AndroidSchedulers.mainThread());
  }
};

BambooStorage bambooStorage = new BSSQLiteDatabase.Builder()
  .db(sqliteDatabase)
  .observableTransformer(transformer)
  .build();

Because it's very similar to get() operation and can confuse user.

One of the variants: just internal()

Many developers don't want to deal with ContentProvider, so, we can add support of direct usage BambooStorage with SQLiteDatabase

What about request builder instead of tons of methods with overloads

We should provide an option for using observable created for get() operation as reactive stream:

For example:

Observable<List<User>> observableUsers = bambooStorage
  .get()
  .listOfObjects(User.class)
  .withMapFunc(User.MAP_FROM_CURSOR)
  .withQuery(Users.QUERY_ALL)
  .prepare()
  .createObservableStream();

observableUsers.subscribe(new Observer<List<Users>>() {
  @Override public void onNext(List<User> users) {
      // will be called after each change in users table
  }

  // ...
});

Should be nice

I realised, that current IBambooStorableItem methods names are not good, so, they will be renamed

Currently, we need several methods:

areTransactionsSupported()
beginTransaction()
setTransactionSuccessful()
endTransaction()

Just like pure SQLiteDatabase

Will be useful for #40 put(collection) and delete(collection) operations

It should be part of get() operation, like get().cursor() or get().listOfObjects() -> get().numberOfResults()

In fact, it's get().cursor() with returning cursor.getCount() and auto closing, but will be better to use COUNT from SQL for this

Check Observable support for Non-blocking IO, should be useful and interesting

Currently it used just for NonNull and Nullable annotations, so maybe it's better to forget about this annotations and remove support.v4

Will be great to use transactions for this

Use case:

User just want to get count of some query results without managing cursor or wasting memory and time on collection creation and entities parsing

Should provide blocking and observable variants

It would be a great feature!

For example, you'll be able to send event about change to the event bus or do a custom post processing of change in ContentProvider

Create common thing for put(object) and delete(object) operations

With Arrays.asList()