io.requery.BlockingEntityStore Java Examples

@Test
public void testRunInTransactionFromBlocking() {
    final BlockingEntityStore<Persistable> blocking = data.toBlocking();
    Completable.fromCallable(new Callable<Object>() {
        @Override
        public Object call() throws Exception {
            blocking.runInTransaction(new Callable<Object>() {
                @Override
                public Object call() throws Exception {
                    final Person person = randomPerson();
                    blocking.insert(person);
                    blocking.update(person);
                    return null;
                }
            });
            return null;
        }
    }).subscribe();
    assertEquals(1, data.count(Person.class).get().value().intValue());
}
 

public BlockingEntityStore<Persistable> getData() {
    if (dataStore == null) {
        // override onUpgrade to handle migrating to a new version
        DatabaseSource source = new DatabaseSource(this, Models.DEFAULT, 6);
        Configuration configuration = source.getConfiguration();
        dataStore = new EntityDataStore<Persistable>(configuration);
    }
    return dataStore;
}
 

@CheckReturnValue
public <R> Single<R> runInTransaction(final Function<BlockingEntityStore<T>, R> function) {
    return Single.fromCallable(new Callable<R>() {
        @Override
        public R call() throws Exception {
            return function.apply(toBlocking());
        }
    });
}
 

private void indexedStringEntityQueriesRun(BlockingEntityStore<Object> database, int count) {
    // create entities
    List<IndexedStringEntity> entities = new ArrayList<>(count);
    String[] fixedRandomStrings = StringGenerator.createFixedRandomStrings(count);
    for (int i = 0; i < count; i++) {
        IndexedStringEntity entity = new IndexedStringEntity();
        entity.setId((long) i);
        entity.setIndexedString(fixedRandomStrings[i]);
        entities.add(entity);
    }
    log("Built entities.");

    // insert entities
    database.insert(entities);
    log("Inserted entities.");

    // query for entities by indexed string at random
    int[] randomIndices = StringGenerator.getFixedRandomIndices(getQueryCount(), count - 1);

    startClock();
    for (int i = 0; i < getQueryCount(); i++) {
        int nextIndex = randomIndices[i];

        Result<IndexedStringEntity> results = database.select(
                IndexedStringEntity.class)
                .where(IndexedStringEntity.INDEXED_STRING.eq(
                        fixedRandomStrings[nextIndex]))
                .get();

        //noinspection unused
        IndexedStringEntity indexedStringEntity = results.first();

        results.close();
    }
    stopClock(Benchmark.Type.QUERY_INDEXED);

    // delete all entities
    database.delete(IndexedStringEntity.class).get().value();
    log("Deleted all entities.");
}
 

@CheckReturnValue
public abstract <R> Single<R> runInTransaction(Function<BlockingEntityStore<T>, R> function);
 

public static <S> ReactiveEntityStore<S> toReactiveStore(BlockingEntityStore<S> store) {
    return new WrappedEntityStore<>(store);
}
 

WrappedEntityStore(BlockingEntityStore<T> delegate) {
    this.delegate = Objects.requireNotNull(delegate);
}
 

@Override
public BlockingEntityStore<T> toBlocking() {
    return delegate;
}
 

@Override
public BlockingEntityStore<T> toBlocking() {
    return this;
}
 

public ReactorEntityStore(BlockingEntityStore<T> delegate) {
    this.delegate = Objects.requireNotNull(delegate);
}
 

@Override
public BlockingEntityStore<T> toBlocking() {
    return delegate;
}
 

public CompletableEntityStore(BlockingEntityStore<T> delegate) {
    this.delegate = Objects.requireNotNull(delegate);
    this.executor = Executors.newSingleThreadExecutor();
    createdExecutor = true;
}
 

public CompletableEntityStore(BlockingEntityStore<T> delegate, Executor executor) {
    this.delegate = Objects.requireNotNull(delegate);
    this.executor = Objects.requireNotNull(executor);
    createdExecutor = false;
}
 

@Override
public BlockingEntityStore<T> toBlocking() {
    return delegate;
}
 

private void deleteAll(BlockingEntityStore<Object> database) {
    database.delete(SimpleEntityNotNull.class).get().value();
}