Java RealmQuery.endGroup方法代码示例

import io.realm.RealmQuery; //导入方法依赖的package包/类
@Override
public List<Item> getItems(Realm realm, boolean onlyUnread) {
    // Get all feeds belonging to Folder treeItem
    List<Feed> feeds = getFeeds(realm, onlyUnread);
    RealmQuery<Item> query = null;
    if(feeds != null && feeds.size() > 0) {
        // Find all items belonging to any feed from this folder
        Iterator<Feed> feedIterator = feeds.iterator();
        query = realm.where(Item.class).beginGroup()
                .equalTo(Item.FEED_ID, feedIterator.next().getId());
        while (feedIterator.hasNext()) {
            query.or().equalTo(Item.FEED_ID, feedIterator.next().getId());
        }
        query.endGroup();
        if(onlyUnread)
            query.equalTo(Item.UNREAD, true);
    }
    return query != null ? query.distinct(Item.FINGERPRINT) : null;
}
 

import io.realm.RealmQuery; //导入方法依赖的package包/类
private void updateRackList() {

		rackList.clear();

		// Build lazy query
		RealmQuery<Rack> query = realm.where(Rack.class);

		if (!accessFilter.equals("")) {
			// isPublic values can be "true", "false", or "" (info not available)
			// Default behaviour will be always bring "" if filtering -- we can change it later
			query.beginGroup()
					.equalTo("isPublic", accessFilter)
					.or()
					.equalTo("isPublic", "")
					.endGroup();
		}

		if (!structureTypeFilter.isEmpty()) {
			query.in("structureType", structureTypeFilter.toArray(new String[structureTypeFilter.size()]));
		}

		if (!ratingRangeFilter.isEmpty()) {
			query.beginGroup();
			for (int i = 0; i < ratingRangeFilter.size(); ++i) {
				Pair<Float, Float> range = ratingRangeFilter.get(i);
				query.between("averageRating", range.first, range.second);
				if (i + 1 < ratingRangeFilter.size()) {
					query.or();
				}
			}
			query.endGroup();
		}

		rackList.addAll(query.findAll());

		if (rackListCallback != null) {
			rackListCallback.onRackListUpdate(rackList);
		}
	}
 

import io.realm.RealmQuery; //导入方法依赖的package包/类
@Override
public <T extends RealmModel> RealmQuery<T> transform(RealmQuery<T> realmQuery, Condition condition) {
    // Check condition.
    if (condition.getType() != Condition.Type.END_GROUP)
        throw new IllegalArgumentException("Condition type is not END_GROUP.");
    // Transform query.
    return realmQuery.endGroup();
}
 

import io.realm.RealmQuery; //导入方法依赖的package包/类
/**
 * Sucht nach der ersten passenden Lehrveranstaltung die als nächstes in der aktuellen Woche stattfindet
 *
 * @param realm    aktuelle Datenbankverbindung
 * @param calendar aktuelle Zeitpunkt ab welchem gesucht werden soll
 * @return erste passende {@link LessonUser} oder null
 */
@Nullable
private static LessonUser getStartNextLessonInWeek(@NonNull final Realm realm, @NonNull final Calendar calendar) {
    final long currentTime = getMinutesSinceMidnight(calendar);
    final int currentDs = getCurrentDS(currentTime);

    // Nur Lehrveranstaltungen suchen die nicht ausgeblendet werden sollen
    final RealmQuery<LessonUser> realmQuery = realm.where(LessonUser.class).equalTo(Const.database.Lesson.HIDE_LESSON, false);

    // Lehrveranstaltungen auf aktuelle Woche einschränken
    realmQuery.beginGroup()
            .equalTo(Const.database.Lesson.WEEK, getWeekTyp(calendar.get(Calendar.WEEK_OF_YEAR)))
            .or()
            .equalTo(Const.database.Lesson.WEEK, 0)
            .endGroup()
            .beginGroup()
            .isEmpty(Const.database.Lesson.WEEKS_ONLY)
            .or().equalTo(Const.database.Lesson.WEEKS_ONLY + ".weekOfYear", calendar.get(Calendar.WEEK_OF_YEAR))
            .endGroup();

    // Veranstaltungen in der restlichen Woche
    realmQuery.beginGroup()
            // Veranstaltungen in der restlichen Woche
            .greaterThan(Const.database.Lesson.DAY, calendar.get(Calendar.DAY_OF_WEEK) - 1);

    // Heutige Lehrveranstaltungen innerhalb der Vorlesungszeit mit berücksichtigen
    if (currentDs > 0) {
        realmQuery.or()
                // Veranstaltungen die noch heute stattfinden, aber...
                .beginGroup()
                .equalTo(Const.database.Lesson.DAY, calendar.get(Calendar.DAY_OF_WEEK) - 1)
                .beginGroup()
                // ... erst nach dieser Stunde anfangen ...
                .greaterThan(Const.database.Lesson.BEGIN_TIME, endDS[currentDs - 1])
                .or()
                // ... oder erst nach dieser Stunde enden
                .beginGroup()
                .greaterThan(Const.database.Lesson.END_TIME, endDS[currentDs - 1])
                .lessThan(Const.database.Lesson.END_TIME, currentTime)
                .endGroup()
                .endGroup()
                .endGroup();
    }
    // Heutige Lehrveranstaltungen vor der der Vorlesungszeit berücksichtigen
    else if (currentDs == 0) {
        realmQuery.or()
                .equalTo(Const.database.Lesson.DAY, calendar.get(Calendar.DAY_OF_WEEK) - 1);
    }
    realmQuery.endGroup();

    // Ergebnisse sortieren und erste Stunde bestimmen
    final RealmResults<LessonUser> results = realmQuery.findAllSorted(Const.database.Lesson.DAY, Sort.ASCENDING, Const.database.Lesson.BEGIN_TIME, Sort.ASCENDING);
    return results.size() > 0 ? results.first() : null;
}