Example usage for org.hibernate.criterion Restrictions isNotNull

List of usage examples for org.hibernate.criterion Restrictions isNotNull

  1. HOME
  2. Java
  3. org.hibernate
  4. org.hibernate.criterion.*
  5. Restrictions
  6. isNotNull

Introduction

In this page you can find the example usage for org.hibernate.criterion Restrictions isNotNull.

Prototype

public static Criterion isNotNull(String propertyName)

Source Link

Document

Apply an "is not null" constraint to the named property

Usage

From source file:org.osiam.resources.helper.SingularFilterChain.java

License:Apache License

@Override
public Criterion buildCriterion() {
    switch (constraint) {
    case CONTAINS:
        return Restrictions.like(key, "%" + value + "%");
    case STARTS_WITH:
        return Restrictions.like(key, value + "%");
    case EQUALS:/*  w  w  w.  j av a 2 s  .  co  m*/
        return Restrictions.eq(key, value);
    case GREATER_EQUALS:
        return Restrictions.ge(key, value);
    case GREATER_THAN:
        return Restrictions.gt(key, value);
    case LESS_EQUALS:
        return Restrictions.le(key, value);
    case LESS_THAN:
        return Restrictions.lt(key, value);
    case PRESENT:
        return Restrictions.isNotNull(key);
    default:
        throw new IllegalArgumentException("Unknown constraint.");
    }
}

From source file:org.picketlink.idm.impl.store.hibernate.HibernateIdentityStoreImpl.java

License:Open Source License

public Criteria prepareResolveRelationshipsCriteria(IdentityStoreInvocationContext ctx, IdentityObject identity,
        IdentityObjectRelationshipType type, boolean parent, boolean named, String name,
        IdentityObjectSearchCriteria searchCriteria) throws IdentityException {
    HibernateIdentityObject hio = safeGet(ctx, identity);

    Criteria criteria = getHibernateSession(ctx).createCriteria(HibernateIdentityObjectRelationship.class);
    criteria.setCacheable(true);/*  www. j  av  a  2 s  . c o m*/

    if (type != null) {
        HibernateIdentityObjectRelationshipType hibernateType = getHibernateIdentityObjectRelationshipType(ctx,
                type);

        criteria.add(Restrictions.eq("type", hibernateType));
    }

    if (name != null) {
        criteria.add(Restrictions.eq("name.name", name));
    } else if (named) {
        criteria.add(Restrictions.isNotNull("name"));
    } else {
        criteria.add(Restrictions.isNull("name"));
    }

    if (parent) {
        criteria.add(Restrictions.eq("fromIdentityObject", hio));
    } else {
        criteria.add(Restrictions.eq("toIdentityObject", hio));
    }

    criteria.setFetchMode("fromIdentityObject", FetchMode.JOIN);
    criteria.setFetchMode("toIdentityObject", FetchMode.JOIN);

    if (searchCriteria != null && searchCriteria.isPaged() && !searchCriteria.isFiltered()) {
        if (searchCriteria.getMaxResults() > 0) {
            criteria.setMaxResults(searchCriteria.getMaxResults());
        }
        criteria.setFirstResult(searchCriteria.getFirstResult());
    }

    if (searchCriteria != null && searchCriteria.isSorted()) {
        if (parent) {
            criteria.createAlias("toIdentityObject", "io");
            if (searchCriteria.isAscending()) {
                criteria.addOrder(Order.asc("io.name"));
            } else {
                criteria.addOrder(Order.desc("io.name"));
            }
        } else {
            criteria.createAlias("fromIdentityObject", "io");
            if (searchCriteria.isAscending()) {
                criteria.addOrder(Order.asc("io.name"));
            } else {
                criteria.addOrder(Order.desc("io.name"));
            }
        }
    }

    return criteria;
}

From source file:org.projectforge.address.AddressDao.java

License:Open Source License

/**
 * Get the birthdays of address entries.
 * @param fromDate Search for birthdays from given date (ignoring the year).
 * @param toDate Search for birthdays until given date (ignoring the year).
 * @param max Maximum number of result entries.
 * @param all If false, only the birthdays of favorites will be returned.
 * @return The entries are ordered by date of year and name.
 *//*w ww  . j ava  2  s.  co m*/
public Set<BirthdayAddress> getBirthdays(final Date fromDate, final Date toDate, final int max,
        final boolean all) {
    final QueryFilter filter = new QueryFilter();
    filter.add(Restrictions.isNotNull("birthday"));
    final List<AddressDO> list = getList(filter);
    // Uses not Collections.sort because every comparison needs Calendar.getDayOfYear().
    final Set<BirthdayAddress> set = new TreeSet<BirthdayAddress>();
    final Set<Integer> favorites = getFavorites();
    final DateHolder from = new DateHolder(fromDate);
    final DateHolder to = new DateHolder(toDate);
    DateHolder dh;
    final int fromMonth = from.getMonth();
    final int fromDayOfMonth = from.getDayOfMonth();
    final int toMonth = to.getMonth();
    final int toDayOfMonth = to.getDayOfMonth();
    for (final AddressDO address : list) {
        if (all == false && favorites.contains(address.getId()) == false) {
            // Address is not a favorite address, so ignore it.
            continue;
        }
        dh = new DateHolder(address.getBirthday());
        final int month = dh.getMonth();
        final int dayOfMonth = dh.getDayOfMonth();
        if (DateHelper.dateOfYearBetween(month, dayOfMonth, fromMonth, fromDayOfMonth, toMonth,
                toDayOfMonth) == false) {
            continue;
        }
        final BirthdayAddress ba = new BirthdayAddress(address);
        if (favorites.contains(address.getId()) == true) {
            ba.setFavorite(true);
        }
        set.add(ba);
    }
    return set;
}

From source file:org.projectforge.business.teamcal.event.TeamEventDao.java

License:Open Source License

/**
 * This method also returns recurrence events outside the time period of the given filter but affecting the
 * time-period (e. g. older recurrence events without end date or end date inside or after the given time period). If
 * calculateRecurrenceEvents is true, only the recurrence events inside the given time-period are returned, if false
 * only the origin recurrence event (may-be outside the given time-period) is returned.
 *
 * @param filter//  w w w  .j a va 2 s .  c om
 * @param calculateRecurrenceEvents If true, recurrence events inside the given time-period are calculated.
 * @return list of team events (same as {@link #getList(BaseSearchFilter)} but with all calculated and matching
 * recurrence events (if calculateRecurrenceEvents is true). Origin events are of type {@link TeamEventDO},
 * calculated events of type {@link TeamEvent}.
 */
public List<TeamEvent> getEventList(final TeamEventFilter filter, final boolean calculateRecurrenceEvents) {
    final List<TeamEvent> result = new ArrayList<TeamEvent>();
    List<TeamEventDO> list = getList(filter);
    if (CollectionUtils.isNotEmpty(list) == true) {
        for (final TeamEventDO eventDO : list) {
            if (eventDO.hasRecurrence() == true) {
                // Added later.
                continue;
            }
            result.add(eventDO);
        }
    }
    final TeamEventFilter teamEventFilter = filter.clone().setOnlyRecurrence(true);
    final QueryFilter qFilter = buildQueryFilter(teamEventFilter);
    qFilter.add(Restrictions.isNotNull("recurrenceRule"));
    list = getList(qFilter);
    list = selectUnique(list);
    // add all abo events
    final List<TeamEventDO> recurrenceEvents = teamEventExternalSubscriptionCache
            .getRecurrenceEvents(teamEventFilter);
    if (recurrenceEvents != null && recurrenceEvents.size() > 0) {
        list.addAll(recurrenceEvents);
    }
    final TimeZone timeZone = ThreadLocalUserContext.getTimeZone();
    if (list != null) {
        for (final TeamEventDO eventDO : list) {
            if (eventDO.hasRecurrence() == false) {
                log.warn("Shouldn't occur! Please contact developer.");
                // This event was handled above.
                continue;
            }
            if (calculateRecurrenceEvents == false) {
                result.add(eventDO);
                continue;
            }
            final Collection<TeamEvent> events = TeamEventUtils.getRecurrenceEvents(
                    teamEventFilter.getStartDate(), teamEventFilter.getEndDate(), eventDO, timeZone);
            if (events == null) {
                continue;
            }
            for (final TeamEvent event : events) {
                if (matches(event.getStartDate(), event.getEndDate(), event.isAllDay(),
                        teamEventFilter) == false) {
                    continue;
                }
                result.add(event);
            }
        }
    }
    return result;
}

From source file:org.projectforge.plugins.teamcal.event.TeamEventDao.java

License:Open Source License

/**
 * @param filter//from  w  w  w. j a v a2 s . c o  m
 * @return list of team events (same as {@link #getList(BaseSearchFilter)} but with all calculated and matching recurrence events.
 */
public List<TeamEvent> getEventList(final TeamEventFilter filter) {
    final List<TeamEvent> result = new ArrayList<TeamEvent>();
    List<TeamEventDO> list = getList(filter);
    if (CollectionUtils.isNotEmpty(list) == true) {
        for (final TeamEventDO eventDO : list) {
            if (eventDO.hasRecurrence() == true) {
                // Added later.
                continue;
            }
            result.add(eventDO);
        }
    }
    final TeamEventFilter teamEventFilter = filter.clone().setOnlyRecurrence(true);
    final QueryFilter qFilter = buildQueryFilter(teamEventFilter);
    qFilter.add(Restrictions.isNotNull("recurrenceRule"));
    list = getList(qFilter);
    list = selectUnique(list);
    final TimeZone timeZone = PFUserContext.getTimeZone();
    if (list != null) {
        for (final TeamEventDO eventDO : list) {
            if (eventDO.hasRecurrence() == false) {
                log.warn("Shouldn't occur! Please contact developer.");
                // This event was handled above.
                continue;
            }
            final Collection<TeamEvent> events = TeamEventUtils.getRecurrenceEvents(
                    teamEventFilter.getStartDate(), teamEventFilter.getEndDate(), eventDO, timeZone);
            if (events == null) {
                continue;
            }
            for (final TeamEvent event : events) {
                if (matches(event.getStartDate(), event.getEndDate(), event.isAllDay(),
                        teamEventFilter) == false) {
                    continue;
                }
                result.add(event);
            }
        }
    }
    return result;
}

From source file:org.rebioma.server.services.OccurrenceDbImpl.java

License:Apache License

/**
 * Adds a {@link Set} of search {@link OccurrenceFilter} to the
 * {@link Criteria}// w w w .  ja v  a 2s.com
 * 
 * @param criteria {@link Criteria} to be added with filters
 * @param user an id of a user in db.
 * @param searchFilters a filters that use for find Occurrences.
 * @param resultFilter the {@link ResultFilter} to determine what public
 *          filter is added.
 * @param tryCount TODO
 * @return {@link Set} of string filters was added to criteria.
 */
private Set<String> addCreterionByFilters(Criteria criteria, User user, Set<OccurrenceFilter> searchFilters,
        ResultFilter resultFilter, int tryCount) {
    Set<String> queryFilters = new HashSet<String>();
    // if (userId != null) {

    // }
    // Adds restrictions for each query filter:
    boolean isMyOccurrence = false;
    String ownerField = getOccurrencePropertyName("ownerEmail");
    List<Criterion> disjunctionCriterions = new ArrayList<Criterion>();
    for (OccurrenceFilter filter : searchFilters) {
        if ((filter.getOperator() != Operator.IS_EMPTY && filter.getOperator() != Operator.IS_NOT_EMPTY)
                && filter.value instanceof String && ((String) filter.value).equals("")) {
            continue;
        }
        if (filter.column.equalsIgnoreCase(ownerField)) {
            isMyOccurrence = true;
        }
        String queryFilter = null;
        Criterion criterion = null;
        // if filter column is "quickSearch" then this is a simple search
        if (filter.column.equalsIgnoreCase(filter.getPropertyName("quickSearch"))) {
            Criterion acceptedSpeciesCri = null;
            Criterion verbatimSpeciesCri = null;
            Criterion scientificNameCri = null;
            String acceptedSpecies = filter.getPropertyName("acceptedSpecies");
            String verbatimSpecies = filter.getPropertyName("verbatimSpecies");
            String scientificName = filter.getPropertyName("scientificName");
            if (tryCount == 1) {
                acceptedSpeciesCri = Restrictions.ilike(acceptedSpecies, filter.getValue().toString(),
                        MatchMode.START);
                verbatimSpeciesCri = Restrictions.ilike(verbatimSpecies, filter.getValue().toString(),
                        MatchMode.START);
                scientificNameCri = Restrictions.ilike(scientificName, filter.getValue().toString(),
                        MatchMode.START);
                queryFilter = acceptedSpecies + " like '" + filter.getValue() + "%' or " + verbatimSpecies
                        + " like '" + filter.getValue() + "%' or " + scientificName + " like '"
                        + filter.getValue() + "%'";
            } else if (tryCount == 2) {
                acceptedSpeciesCri = Restrictions.ilike(acceptedSpecies, filter.getValue().toString(),
                        MatchMode.ANYWHERE);
                verbatimSpeciesCri = Restrictions.ilike(verbatimSpecies, filter.getValue().toString(),
                        MatchMode.ANYWHERE);
                scientificNameCri = Restrictions.ilike(scientificName, filter.getValue().toString(),
                        MatchMode.ANYWHERE);
                queryFilter = acceptedSpecies + " like '%" + filter.getValue() + "%' or " + verbatimSpecies
                        + " like '%" + filter.getValue() + "%' or " + scientificName + " like '%"
                        + filter.getValue() + "%'";
            }
            criterion = Restrictions.or(scientificNameCri,
                    Restrictions.or(acceptedSpeciesCri, verbatimSpeciesCri));
        } else {
            Operator op = filter.getOperator();
            String value;
            switch (op) {
            case CONTAIN:
                value = (String) filter.getValue();
                criterion = Restrictions.ilike(filter.column, value, MatchMode.ANYWHERE);
                break;
            case EQUAL:
                criterion = null;
                if (filter.column.equals(filter.getPropertyName("sex"))) {
                    value = (String) filter.getValue();
                    if (value.equalsIgnoreCase("unknown")) {
                        Object[] filters = getComplexCriterion(
                                new String[] { "male", "female", "hermaphroditic" }, filter.column, "!=");
                        criterion = (Criterion) filters[0];
                        queryFilter = filters[1].toString();
                        // criterion = Restrictions.or(Restrictions., rhs)
                    } else {
                        criterion = Restrictions.eq(filter.column, value);
                    }
                } else if (filter.column.equals(filter.getPropertyName("BasisOfRecord"))) {
                    value = (String) filter.getValue();
                    if (value.equalsIgnoreCase("Non-standardSpecimen")) {
                        Object[] filters = getComplexCriterion(VALID_BASIS_OF_RECORDS, filter.column, "!=");
                        criterion = (Criterion) filters[0];
                        queryFilter = filters[1].toString();
                    } else {
                        criterion = Restrictions.eq(filter.column, value);
                    }
                } else {
                    // {wd} on utilise "upper()" si type column = String 
                    if (StringUtil.isType(Occurrence.class, filter.column, String.class))
                        criterion = Restrictions.sqlRestriction("upper({alias}."
                                + StringUtil.columnName(Occurrence.class, filter.column) + ") = upper(?)",
                                filter.getValue(), Hibernate.STRING);
                    else
                        criterion = Restrictions.eq(filter.column, filter.getValue());
                }
                break;
            case NOT_CONTAIN:
                value = (String) filter.getValue();
                criterion = Restrictions.not(Restrictions.ilike(filter.column, value, MatchMode.ANYWHERE));
                break;
            case NOT_EQUAL:
                criterion = null;
                if (filter.column.equals(filter.getPropertyName("sex"))) {
                    value = (String) filter.getValue();
                    if (value.equalsIgnoreCase("unknown")) {
                        Object[] filters = getComplexCriterion(
                                new String[] { "male", "female", "hermaphroditic" }, filter.column, "=");
                        criterion = (Criterion) filters[0];
                        queryFilter = filters[1].toString();
                        // criterion = Restrictions.or(Restrictions., rhs)
                    } else {
                        criterion = Restrictions.ne(filter.column, value);
                    }
                } else if (filter.column.equals(filter.getPropertyName("BasisOfRecord"))) {
                    value = (String) filter.getValue();
                    if (value.equalsIgnoreCase("Non-standardSpecimen")) {
                        Object[] filters = getComplexCriterion(VALID_BASIS_OF_RECORDS, filter.column, "=");
                        criterion = (Criterion) filters[0];
                        queryFilter = filters[1].toString();
                    } else {
                        criterion = Restrictions.ne(filter.column, value);
                    }
                } else {
                    criterion = Restrictions.ne(filter.column, filter.getValue());
                }
                break;
            case START_WITH:
                value = (String) filter.getValue();
                criterion = Restrictions.ilike(filter.column, value, MatchMode.START);
                break;
            case NOT_START_WITH:
                value = (String) filter.getValue();
                criterion = Restrictions.not(Restrictions.ilike(filter.column, value, MatchMode.START));
                break;
            case LESS:
                criterion = Restrictions.lt(filter.column, filter.getValue());
                break;
            case GREATER:
                criterion = Restrictions.gt(filter.column, filter.getValue());
                break;
            case LESS_EQUAL:
                criterion = Restrictions.le(filter.column, filter.getValue());
                break;
            case GREATER_EQUAL:
                criterion = Restrictions.ge(filter.column, filter.getValue());
                break;
            case IN:
                if (filter.getValue() instanceof Collection<?>) {
                    criterion = Restrictions.in(filter.column, (Collection<?>) filter.getValue());
                    //{WD
                } else if (StringUtil.isType(Occurrence.class, filter.column, Integer.class)) {
                    Object values[] = filter.getIntegerValues();
                    criterion = Restrictions.in(filter.column, values);
                    //}
                } else {
                    String values[] = filter.getCollectionValues();
                    criterion = Restrictions.in(filter.column, values);
                }
                break;
            case NOT_IN:
                //{WD
                if (StringUtil.isType(Occurrence.class, filter.column, Integer.class)) {
                    Object arryValues[] = filter.getIntegerValues();
                    criterion = Restrictions.not(Restrictions.in(filter.column, arryValues));
                    //}
                } else {
                    String arryValues[] = filter.getCollectionValues();
                    criterion = Restrictions.not(Restrictions.in(filter.column, arryValues));
                }
                break;
            case IS_EMPTY:
                if (StringUtil.isString(Occurrence.class, filter.column)) {
                    // System.out.println(filter.column + "null and empty");
                    criterion = Restrictions.or(Restrictions.isNull(filter.column),
                            Restrictions.eq(filter.column, ""));
                } else {
                    // System.out.println(filter.column + "null");
                    criterion = Restrictions.isNull(filter.column);
                }
                // System.out.println(criterion);
                break;
            case IS_NOT_EMPTY:
                criterion = Restrictions.and(Restrictions.isNotNull(filter.column),
                        Restrictions.ne(filter.column, ""));
                System.out.println(criterion);
                break;
            }
        }

        if (criterion != null) {
            if (queryFilter == null) {
                queryFilter = filter.toString();
            }
            queryFilters.add(queryFilter);
            if (filter.isDisjunction()) {
                disjunctionCriterions.add(criterion);
            } else {
                criteria.add(criterion);
            }

        }
    }
    Set<String> filtersString = new HashSet<String>();
    Criterion publicCriterion = getPublicCriterion(user, resultFilter, isMyOccurrence, filtersString);
    if (publicCriterion != null) {
        criteria.add(publicCriterion);
        queryFilters.addAll(filtersString);
    }
    Criterion disjunctionCriterion = null;
    for (Criterion c : disjunctionCriterions) {
        if (disjunctionCriterion == null) {
            disjunctionCriterion = Restrictions.disjunction().add(c);
        } else {
            disjunctionCriterion = Restrictions.or(disjunctionCriterion, c);
        }
    }
    if (disjunctionCriterion != null) {
        criteria.add(disjunctionCriterion);
    }
    return queryFilters;
}

From source file:org.redis.shop.dao.impl.VechileDaoImpl.java

public List<Vechile> vechile_search(Map<String, Object> map, Pager pager) {
    Criteria criteria = getSession().createCriteria(Vechile.class);
    if (map.get("state") != null) {
        criteria.add(Restrictions.eq("state", map.get("state")));
    }//w w  w. ja  va  2  s.  c o  m
    if (map.get("vechileNum") != null) {
        criteria.add(Restrictions.eq("vechileNum", map.get("vechileNum")));
    }
    if (map.get("license") != null) {
        criteria.add(Restrictions.eq("license", map.get("license")));
    }
    if (map.get("type") != null) {
        if (map.get("siteId") != null) {
            criteria.createAlias("site", "s");
            criteria.add(Restrictions.eq("s.siteId", map.get("siteId")));
        } else if (map.get("type").equals("site") && map.get("region") != null) {
            criteria.createAlias("site", "s");
            criteria.add(Restrictions.eq("s.region", map.get("region")));
        }

        if (map.get("centerId") != null) {
            criteria.createAlias("center", "ct");
            criteria.add(Restrictions.eq("ct.centerId", map.get("centerId")));
        } else if (map.get("type").equals("center") && map.get("region") != null) {
            criteria.createAlias("center", "c");
            criteria.add(Restrictions.eq("c.region", map.get("region")));
        }
        if (map.get("type").equals("site") && map.get("region") == null) {
            criteria.add(Restrictions.isNotNull("site"));
        } else if (map.get("type").equals("center") && map.get("region") == null) {
            criteria.add(Restrictions.isNotNull("center"));
        }
    }
    return criteria.setFirstResult(pager.getPageSize() * (pager.getPageNumber() - 1))
            .setMaxResults(pager.getPageSize()).list();
}

From source file:org.redis.shop.dao.impl.VechileDaoImpl.java

public Integer vechile_search_count(Map<String, Object> map) {
    Criteria criteria = getSession().createCriteria(Vechile.class);
    if (map.get("state") != null) {
        criteria.add(Restrictions.eq("state", map.get("state")));
    }//w  ww. j  ava  2s .  co  m
    if (map.get("vechileNum") != null) {
        criteria.add(Restrictions.eq("vechileNum", map.get("vechileNum")));
    }
    if (map.get("license") != null) {
        criteria.add(Restrictions.eq("license", map.get("license")));
    }
    if (map.get("type") != null) {
        if (map.get("siteId") != null) {
            criteria.createAlias("site", "s");
            criteria.add(Restrictions.eq("s.siteId", map.get("siteId")));
        } else if (map.get("type").equals("site") && map.get("region") != null) {
            criteria.createAlias("site", "s");
            criteria.add(Restrictions.eq("s.region", map.get("region")));
        }

        if (map.get("centerId") != null) {
            criteria.createAlias("center", "ct");
            criteria.add(Restrictions.eq("ct.centerId", map.get("centerId")));
        } else if (map.get("type").equals("center") && map.get("region") != null) {
            criteria.createAlias("center", "c");
            criteria.add(Restrictions.eq("c.region", map.get("region")));
        }
        if (map.get("type").equals("site") && map.get("region") == null) {
            criteria.add(Restrictions.isNotNull("site"));
        } else if (map.get("type").equals("center") && map.get("region") == null) {
            criteria.add(Restrictions.isNotNull("center"));
        }
    }
    return Integer.parseInt(((Long) criteria.setProjection(Projections.rowCount()).uniqueResult()) + "");
}

From source file:org.sakaiproject.assignment.impl.persistence.AssignmentRepositoryImpl.java

License:Educational Community License

@Override
public long countAssignmentSubmissions(String assignmentId, Boolean graded, Boolean hasSubmissionDate,
        Boolean userSubmission, List<String> userIds) {
    Criteria criteria = sessionFactory.getCurrentSession().createCriteria(AssignmentSubmission.class)
            .setProjection(Projections.countDistinct("id")).add(Restrictions.eq("assignment.id", assignmentId))
            .add(Restrictions.eq("submitted", Boolean.TRUE)).createAlias("submitters", "s");

    if (graded != null) {
        criteria.add(Restrictions.eq("graded", graded));
    }//w  w w .ja v  a2  s  . c  o m
    if (hasSubmissionDate != null) {
        criteria.add(hasSubmissionDate ? Restrictions.isNotNull("dateSubmitted")
                : Restrictions.isNull("dateSubmitted"));
    }
    if (userSubmission != null) {
        criteria.add(Restrictions.eq("userSubmission", userSubmission));
    }
    if (userIds != null) {
        if (userIds.isEmpty()) {
            return 0; // if we have an empty list then we return always return 0
        } else {
            criteria.add(HibernateCriterionUtils.CriterionInRestrictionSplitter("s.submitter", userIds));
        }
    }
    return ((Number) criteria.uniqueResult()).longValue();
}

From source file:org.sakaiproject.config.impl.HibernateConfigItemDaoImpl.java

License:Educational Community License

@SuppressWarnings("unchecked")
@Override/*from   w  ww.  j a v a 2 s.  c o m*/
public List<HibernateConfigItem> findPollOnByNode(String node, Date onOrAfter, Date before) {
    Criteria criteria = getSession().createCriteria(HibernateConfigItem.class)
            .add(Restrictions.eq("node", node));
    if (onOrAfter == null && before == null) {
        criteria.add(Restrictions.isNotNull("pollOn"));
    } else {
        if (onOrAfter != null) {
            criteria.add(Restrictions.ge("pollOn", onOrAfter));
        }
        if (before != null) {
            criteria.add(Restrictions.lt("pollOn", before));
        }
    }
    return criteria.list();
}