下面列出了io.reactivex.functions.Cancellable#io.objectbox.query.Query 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
private void showStoredMultipleDaysWeather() {
Query<MultipleDaysWeather> query = DbUtil.getMultipleDaysWeatherQuery(multipleDaysWeatherBox);
query.subscribe().on(AndroidScheduler.mainThread())
.observer(new DataObserver<List<MultipleDaysWeather>>() {
@Override
public void onData(@NonNull List<MultipleDaysWeather> data) {
if (data.size() > 0) {
final Handler handler = new Handler();
handler.postDelayed(new Runnable() {
@Override
public void run() {
data.remove(0);
mItemAdapter.clear();
mItemAdapter.add(data);
}
}, 500);
}
}
});
}
private void showStoredCurrentWeather() {
Query<CurrentWeather> query = DbUtil.getCurrentWeatherQuery(currentWeatherBox);
query.subscribe(subscriptions).on(AndroidScheduler.mainThread())
.observer(new DataObserver<List<CurrentWeather>>() {
@Override
public void onData(@NonNull List<CurrentWeather> data) {
if (data.size() > 0) {
hideEmptyLayout();
CurrentWeather currentWeather = data.get(0);
if (isLoad) {
tempTextView.setText(String.format(Locale.getDefault(), "%.0f°", currentWeather.getTemp()));
descriptionTextView.setText(AppUtil.getWeatherStatus(currentWeather.getWeatherId(), AppUtil.isRTL(MainActivity.this)));
humidityTextView.setText(String.format(Locale.getDefault(), "%d%%", currentWeather.getHumidity()));
windTextView.setText(String.format(Locale.getDefault(), getResources().getString(R.string.wind_unit_label), currentWeather.getWindSpeed()));
} else {
tempTextView.setCurrentText(String.format(Locale.getDefault(), "%.0f°", currentWeather.getTemp()));
descriptionTextView.setCurrentText(AppUtil.getWeatherStatus(currentWeather.getWeatherId(), AppUtil.isRTL(MainActivity.this)));
humidityTextView.setCurrentText(String.format(Locale.getDefault(), "%d%%", currentWeather.getHumidity()));
windTextView.setCurrentText(String.format(Locale.getDefault(), getResources().getString(R.string.wind_unit_label), currentWeather.getWindSpeed()));
}
animationView.setAnimation(AppUtil.getWeatherAnimation(currentWeather.getWeatherId()));
animationView.playAnimation();
}
}
});
}
static <T> void createListItemEmitter(final Query<T> query, final FlowableEmitter<T> emitter) {
final DataSubscription dataSubscription = query.subscribe().observer(new DataObserver<List<T>>() {
@Override
public void onData(List<T> data) {
for (T datum : data) {
if (emitter.isCancelled()) {
return;
} else {
emitter.onNext(datum);
}
}
if (!emitter.isCancelled()) {
emitter.onComplete();
}
}
});
emitter.setCancellable(new Cancellable() {
@Override
public void cancel() throws Exception {
dataSubscription.cancel();
}
});
}
/**
* The returned Observable emits Query results as Lists.
* Never completes, so you will get updates when underlying data changes.
*/
public static <T> Observable<List<T>> observable(final Query<T> query) {
return Observable.create(new ObservableOnSubscribe<List<T>>() {
@Override
public void subscribe(final ObservableEmitter<List<T>> emitter) throws Exception {
final DataSubscription dataSubscription = query.subscribe().observer(new DataObserver<List<T>>() {
@Override
public void onData(List<T> data) {
if (!emitter.isDisposed()) {
emitter.onNext(data);
}
}
});
emitter.setCancellable(new Cancellable() {
@Override
public void cancel() throws Exception {
dataSubscription.cancel();
}
});
}
});
}
/**
* The returned Single emits one Query result as a List.
*/
public static <T> Single<List<T>> single(final Query<T> query) {
return Single.create(new SingleOnSubscribe<List<T>>() {
@Override
public void subscribe(final SingleEmitter<List<T>> emitter) throws Exception {
query.subscribe().single().observer(new DataObserver<List<T>>() {
@Override
public void onData(List<T> data) {
if (!emitter.isDisposed()) {
emitter.onSuccess(data);
}
}
});
// no need to cancel, single never subscribes
}
});
}
@Test
public void testOldReaderWithIndex() {
final Box<EntityLongIndex> box = store.boxFor(EntityLongIndex.class);
final int initialValue = 1;
final Query<EntityLongIndex> query = box.query().equal(EntityLongIndex_.indexedLong, 0).build();
assertNull(query.findUnique());
System.out.println("BEFORE put: " + box.getReaderDebugInfo());
System.out.println("count before: " + box.count());
box.put(createEntityLongIndex(initialValue));
System.out.println("AFTER put: " + box.getReaderDebugInfo());
System.out.println("count after: " + box.count());
query.setParameter(EntityLongIndex_.indexedLong, initialValue);
assertNotNull(query.findUnique());
query.setParameter(EntityLongIndex_.indexedLong, 0);
assertNull(query.findUnique());
}
private Query<Content> queryContentUniversalContent(
String queryStr,
boolean filterFavourites,
long[] additionalIds,
int orderField,
boolean orderDesc) {
QueryBuilder<Content> query = store.boxFor(Content.class).query();
query.in(Content_.status, libraryStatus);
if (filterFavourites) query.equal(Content_.favourite, true);
query.contains(Content_.title, queryStr, QueryBuilder.StringOrder.CASE_INSENSITIVE);
query.or().equal(Content_.uniqueSiteId, queryStr);
// query.or().link(Content_.attributes).contains(Attribute_.name, queryStr, QueryBuilder.StringOrder.CASE_INSENSITIVE); // Use of or() here is not possible yet with ObjectBox v2.3.1
query.or().in(Content_.id, additionalIds);
applySortOrder(query, orderField, orderDesc);
return query.build();
}
private void showStoredFiveDayWeather() {
Query<FiveDayWeather> query = DbUtil.getFiveDayWeatherQuery(fiveDayWeatherBox);
query.subscribe(subscriptions).on(AndroidScheduler.mainThread())
.observer(new DataObserver<List<FiveDayWeather>>() {
@Override
public void onData(@NonNull List<FiveDayWeather> data) {
if (data.size() > 0) {
todayFiveDayWeather = data.remove(0);
mItemAdapter.clear();
mItemAdapter.add(data);
}
}
});
}
private void showItemHourlyDB() {
Query<ItemHourlyDB> query = DbUtil.getItemHourlyDBQuery(itemHourlyDBBox, fiveDayWeather.getId());
query.subscribe().on(AndroidScheduler.mainThread())
.observer(new DataObserver<List<ItemHourlyDB>>() {
@Override
public void onData(@NonNull List<ItemHourlyDB> data) {
if (data.size() > 0) {
mItemAdapter.clear();
mItemAdapter.add(data);
setChartValues(data);
}
}
});
}
public Observable<Boolean> deleteCollectArticle(String title, String author) {
return Observable.create(emitter -> {
Query query = CollectArticleTableManager.collectArticleBox.query().equal(CollectArticleDB_.title, title).equal(CollectArticleDB_.author, author).build();
query.remove();
emitter.onNext(true);
emitter.onComplete();
});
}
public Observable<Boolean> isExists(String title, String author) {
return Observable.create((emitter -> {
Query query = CollectArticleTableManager.collectArticleBox.query().equal(CollectArticleDB_.title, title).equal(CollectArticleDB_.author, author).build();
List<CollectArticleDB> collectArticleDBList = query.find();
if (collectArticleDBList == null || collectArticleDBList.size() == 0) {
emitter.onNext(false);
} else {
emitter.onNext(true);
}
emitter.onComplete();
}));
}
public Observable<List<CollectArticleDB>> getAllCollectArticle() {
return Observable.create((emitter -> {
String accountName = AccountManager.getInstance().getCurrentAccount().getUsername();
Query query = CollectArticleTableManager.collectArticleBox.query().equal(CollectArticleDB_.accountName, accountName).build();
List<CollectArticleDB> data = query.find();
emitter.onNext(data);
emitter.onComplete();
}));
}
public Observable<StockPortfolioItem> getPortfolioItems() {
Query<StockPortfolioItem> query = portfolioItemBox.query()
.build();
return RxQuery.observable(query)
.take(1)
.flatMap(Observable::fromIterable);
}
/**
* The returned Flowable emits Query results one by one. Once all results have been processed, onComplete is called.
* Uses given BackpressureStrategy.
*/
public static <T> Flowable<T> flowableOneByOne(final Query<T> query, BackpressureStrategy strategy) {
return Flowable.create(new FlowableOnSubscribe<T>() {
@Override
public void subscribe(final FlowableEmitter<T> emitter) throws Exception {
createListItemEmitter(query, emitter);
}
}, strategy);
}
static <T> void createListItemEmitter(final Query<T> query, final FlowableEmitter<T> emitter) {
final DataSubscription dataSubscription = query.subscribe().observer(data -> {
for (T datum : data) {
if (emitter.isCancelled()) {
return;
} else {
emitter.onNext(datum);
}
}
if (!emitter.isCancelled()) {
emitter.onComplete();
}
});
emitter.setCancellable(dataSubscription::cancel);
}
/**
* The returned Observable emits Query results as Lists.
* Never completes, so you will get updates when underlying data changes
* (see {@link Query#subscribe()} for details).
*/
public static <T> Observable<List<T>> observable(final Query<T> query) {
return Observable.create(emitter -> {
final DataSubscription dataSubscription = query.subscribe().observer(data -> {
if (!emitter.isDisposed()) {
emitter.onNext(data);
}
});
emitter.setCancellable(dataSubscription::cancel);
});
}
/**
* The returned Single emits one Query result as a List.
*/
public static <T> Single<List<T>> single(final Query<T> query) {
return Single.create(emitter -> {
query.subscribe().single().observer(data -> {
if (!emitter.isDisposed()) {
emitter.onSuccess(data);
}
});
// no need to cancel, single never subscribes
});
}
@Test
public void testRelationToOneQuery() {
Customer customer = putCustomer();
Order order = putOrder(customer, "Bananas");
Query<Order> query = orderBox.query().equal(Order_.customerId, customer.getId()).build();
Order orderFound = query.findUnique();
assertEquals(order.getId(), orderFound.getId());
}
@Test
public void testEagerToMany_NoResult() {
Query<Customer> query = customerBox.query().eager(Customer_.orders).build();
query.find();
query.findFirst();
query.forEach(data -> {
});
}
@Test
public void testEagerToSingle_NoResult() {
Query<Order> query = orderBox.query().eager(Order_.customer).build();
query.find();
query.findFirst();
query.forEach(data -> {
});
}
static <T> void createListItemEmitter(final Query<T> query, final FlowableEmitter<T> emitter) {
final DataSubscription dataSubscription = query.subscribe().observer(data -> {
for (T datum : data) {
if (emitter.isCancelled()) {
return;
} else {
emitter.onNext(datum);
}
}
if (!emitter.isCancelled()) {
emitter.onComplete();
}
});
emitter.setCancellable(dataSubscription::cancel);
}
/**
* The returned Observable emits Query results as Lists.
* Never completes, so you will get updates when underlying data changes
* (see {@link Query#subscribe()} for details).
*/
public static <T> Observable<List<T>> observable(final Query<T> query) {
return Observable.create(emitter -> {
final DataSubscription dataSubscription = query.subscribe().observer(data -> {
if (!emitter.isDisposed()) {
emitter.onNext(data);
}
});
emitter.setCancellable(dataSubscription::cancel);
});
}
/**
* The returned Single emits one Query result as a List.
*/
public static <T> Single<List<T>> single(final Query<T> query) {
return Single.create(emitter -> {
query.subscribe().single().observer(data -> {
if (!emitter.isDisposed()) {
emitter.onSuccess(data);
}
});
// no need to cancel, single never subscribes
});
}
private List<T> shuffleRandomSort(Query<T> query, int startPosition, int loadCount) {
LazyList<T> lazyList = query.findLazy();
List<Integer> order = new ArrayList<>();
for (int i = 0; i < lazyList.size(); i++) order.add(i);
Collections.shuffle(order, new Random(RandomSeedSingleton.getInstance().getSeed()));
int maxPage = Math.min(startPosition + loadCount, order.size());
List<T> result = new ArrayList<>();
for (int i = startPosition; i < maxPage; i++) {
result.add(lazyList.get(order.get(i)));
}
return result;
}
long insertContent(Content content) {
List<Attribute> attributes = content.getAttributes();
Box<Attribute> attrBox = store.boxFor(Attribute.class);
Query attrByUniqueKey = attrBox.query().equal(Attribute_.type, 0).equal(Attribute_.name, "").build();
return store.callInTxNoException(() -> {
// Master data management managed manually
// Ensure all known attributes are replaced by their ID before being inserted
// Watch https://github.com/objectbox/objectbox-java/issues/509 for a lighter solution based on @Unique annotation
Attribute dbAttr;
Attribute inputAttr;
if (attributes != null)
for (int i = 0; i < attributes.size(); i++) {
inputAttr = attributes.get(i);
dbAttr = (Attribute) attrByUniqueKey.setParameter(Attribute_.name, inputAttr.getName())
.setParameter(Attribute_.type, inputAttr.getType().getCode())
.findFirst();
if (dbAttr != null) {
attributes.set(i, dbAttr); // If existing -> set the existing attribute
dbAttr.addLocationsFrom(inputAttr);
attrBox.put(dbAttr);
} else {
inputAttr.setName(inputAttr.getName().toLowerCase().trim()); // If new -> normalize the attribute
}
}
return store.boxFor(Content.class).put(content);
});
}
Query<Content> selectAllLibraryBooksQ(boolean favsOnly) {
// All statuses except SAVED, DOWNLOADING, PAUSED and ERROR that imply the book is in the download queue
int[] storedContentStatus = new int[]{
StatusContent.DOWNLOADED.getCode(),
StatusContent.MIGRATED.getCode(),
StatusContent.IGNORED.getCode(),
StatusContent.UNHANDLED_ERROR.getCode(),
StatusContent.CANCELED.getCode(),
StatusContent.ONLINE.getCode()
};
QueryBuilder<Content> query = store.boxFor(Content.class).query().in(Content_.status, storedContentStatus);
if (favsOnly) query.equal(Content_.favourite, true);
return query.build();
}
Query<Content> selectAllQueueBooksQ() {
int[] storedContentStatus = new int[]{
StatusContent.SAVED.getCode(),
StatusContent.DOWNLOADING.getCode(),
StatusContent.PAUSED.getCode(),
StatusContent.ERROR.getCode()
};
return store.boxFor(Content.class).query().in(Content_.status, storedContentStatus).build();
}
Query<Content> queryContentSearchContent(
String title,
List<Attribute> metadata,
boolean filterFavourites,
int orderField,
boolean orderDesc) {
AttributeMap metadataMap = new AttributeMap();
metadataMap.addAll(metadata);
boolean hasTitleFilter = (title != null && title.length() > 0);
boolean hasSiteFilter = metadataMap.containsKey(AttributeType.SOURCE)
&& (metadataMap.get(AttributeType.SOURCE) != null)
&& !(metadataMap.get(AttributeType.SOURCE).isEmpty());
boolean hasTagFilter = metadataMap.keySet().size() > (hasSiteFilter ? 1 : 0);
QueryBuilder<Content> query = store.boxFor(Content.class).query();
query.in(Content_.status, libraryStatus);
if (hasSiteFilter)
query.in(Content_.site, getIdsFromAttributes(metadataMap.get(AttributeType.SOURCE)));
if (filterFavourites) query.equal(Content_.favourite, true);
if (hasTitleFilter) query.contains(Content_.title, title);
if (hasTagFilter) {
for (Map.Entry<AttributeType, List<Attribute>> entry : metadataMap.entrySet()) {
AttributeType attrType = entry.getKey();
if (!attrType.equals(AttributeType.SOURCE)) { // Not a "real" attribute in database
List<Attribute> attrs = entry.getValue();
if (attrs != null && !attrs.isEmpty()) {
query.in(Content_.id, selectFilteredContent(attrs, false));
}
}
}
}
applySortOrder(query, orderField, orderDesc);
return query.build();
}
private Query<Content> queryContentUniversalAttributes(String queryStr, boolean filterFavourites) {
QueryBuilder<Content> query = store.boxFor(Content.class).query();
query.in(Content_.status, libraryStatus);
if (filterFavourites) query.equal(Content_.favourite, true);
query.link(Content_.attributes).contains(Attribute_.name, queryStr, QueryBuilder.StringOrder.CASE_INSENSITIVE);
return query.build();
}
Query<Content> queryContentUniversal(
String queryStr,
boolean filterFavourites,
int orderField,
boolean orderDesc) {
// Due to objectBox limitations (see https://github.com/objectbox/objectbox-java/issues/497 and https://github.com/objectbox/objectbox-java/issues/201)
// querying Content and attributes have to be done separately
Query<Content> contentAttrSubQuery = queryContentUniversalAttributes(queryStr, filterFavourites);
return queryContentUniversalContent(queryStr, filterFavourites, contentAttrSubQuery.findIds(), orderField, orderDesc);
}