Java Examples for org.hibernate.criterion.Criterion

@SuppressWarnings("rawtypes")
public static org.hibernate.criterion.Criterion in(String propertyName, Collection<?> values) {
    org.hibernate.criterion.Criterion criterion = null;
    @SuppressWarnings("unchecked") List<?> l = new ArrayList(values);
    int listSize = l.size();
    for (int i = 0; i < l.size(); i += MAX) {
        List<?> subList;
        if (listSize > i + MAX) {
            subList = l.subList(i, (i + MAX));
        } else {
            subList = l.subList(i, listSize);
        }
        if (criterion != null) {
            criterion = Restrictions.or(criterion, Restrictions.in(propertyName, subList));
        } else {
            criterion = Restrictions.in(propertyName, subList);
        }
    }
    return criterion;
}

@SuppressWarnings("rawtypes")
public static org.hibernate.criterion.Criterion in(String propertyName, Collection<?> values) {
    org.hibernate.criterion.Criterion criterion = null;
    @SuppressWarnings("unchecked") List<?> l = new ArrayList(values);
    int listSize = l.size();
    for (int i = 0; i < l.size(); i += MAX) {
        List<?> subList;
        if (listSize > i + MAX) {
            subList = l.subList(i, (i + MAX));
        } else {
            subList = l.subList(i, listSize);
        }
        if (criterion != null) {
            criterion = Restrictions.or(criterion, Restrictions.in(propertyName, subList));
        } else {
            criterion = Restrictions.in(propertyName, subList);
        }
    }
    return criterion;
}

public Object doInHibernate(Session session) throws HibernateException, SQLException {
    Criteria criteria = session.createCriteria(entityClass);
    if (isConnectToActivityInstance(q)) {
        criteria.createAlias("activityInstance", "activityInstance");
    }
    List<? extends org.fireflow.client.query.Criterion> fireCriterions = q.getAllCriterions();
    if (fireCriterions != null && fireCriterions.size() > 0) {
        for (org.fireflow.client.query.Criterion fireCriterion : fireCriterions) {
            org.hibernate.criterion.Criterion hibernateCriterion = PersisterUtils.fireCriterion2HibernateCriterion(fireCriterion);
            criteria.add(hibernateCriterion);
        }
    }
    List<org.fireflow.client.query.Order> fireOrders = q.getAllOrders();
    if (fireOrders != null && fireOrders.size() > 0) {
        for (org.fireflow.client.query.Order fireOrder : fireOrders) {
            org.hibernate.criterion.Order hibernateOrder = PersisterUtils.fireOrder2HibernateOrder(fireOrder);
            criteria.addOrder(hibernateOrder);
        }
    }
    if (q.getPageNumber() > 0) {
        int pageSize = q.DEFAULT_PAGE_SIZE;
        if (q.getPageSize() > 0) {
            pageSize = q.getPageSize();
        }
        int first = (q.getPageNumber() - 1) * pageSize;
        //从0开始计数；
        criteria.setFirstResult(//从0开始计数；
        first);
        criteria.setMaxResults(pageSize);
    }
    return criteria.list();
}

/**
	 * Gets a new task from the task repository
	 * based on specified criterion
	 */
@Override
public DocumentDTO getNewTask(Long crisisID, Criterion criterion) {
    Criterion newCriterion = null;
    try {
        if (criterion != null) {
            newCriterion = Restrictions.conjunction().add(criterion).add(Restrictions.eq("collection.id", crisisID)).add(Restrictions.eq("hasHumanLabels", false));
        } else {
            newCriterion = Restrictions.conjunction().add(Restrictions.eq("collection.id", crisisID)).add(Restrictions.eq("hasHumanLabels", false));
        }
        Document document = remoteDocumentEJB.getByCriteria(newCriterion);
        //logger.debug("New task: " + document);
        if (document != null && !isTaskAssigned(document)) {
            logger.info("New task: " + document.getDocumentId());
            return new DocumentDTO(document);
        }
    } catch (Exception e) {
        logger.error("Error in getting new Task for crisisID: " + crisisID);
    }
    return null;
}

public List<PalletModel> findChang(int statusId, int warehouse, int conveyorLine, int location, String keyItemDescription, int combine, int foil) {
    log.debug("findChang(). statusId {}, warehouse {}, conveyorLine {}, location {}, keyItemDescription {}, combine {}, foil {}", statusId, warehouse, conveyorLine, location, keyItemDescription, combine, foil);
    List<PalletModel> palletModelList = Utils.getEmptyList();
    try {
        Criteria criteria = getSession().createCriteria(PalletModel.class, "p");
        if (!Utils.isZero(warehouse)) {
            criteria.add(Restrictions.eq("msWarehouseModel.id", warehouse));
        }
        if (!Utils.isZero(conveyorLine)) {
            criteria.add(Restrictions.eq("msWorkingAreaModel.id", conveyorLine));
        }
        if (!Utils.isZero(location)) {
            criteria.add(Restrictions.eq("msLocationModel.id", location));
        }
        if (combine == 1 && statusId == 1) {
            criteria.add(Restrictions.eq("isCombine", combine));
        }
        if (foil != 0 && statusId == 1) {
            criteria.add(Restrictions.eq("isFoil", foil));
        }
        if (!Utils.isNull(keyItemDescription) && !"".equalsIgnoreCase(keyItemDescription)) {
            criteria.createAlias("p.msItemModel", "c");
            Criterion itemDes = Restrictions.like("c.dSGThaiItemDescription", "%" + keyItemDescription.trim() + "%");
            criteria.createAlias("p.msLocationModel", "d");
            Criterion locationBarcode = Restrictions.like("d.locationBarcode", "%" + keyItemDescription.trim() + "%");
            criteria.add(Restrictions.or(itemDes, locationBarcode));
        }
        if (statusId == 0) {
            criteria.add(Restrictions.eq("status", 2));
        } else if (statusId == 2) {
            criteria.add(Restrictions.lt("status", 3));
        } else if (statusId == 3) {
            criteria.add(Restrictions.eq("qty", 0));
        }
        criteria.add(Restrictions.ne("status", 6));
        criteria.add(Restrictions.eq("isValid", 1));
        criteria.addOrder(Order.desc("updateDate"));
        palletModelList = Utils.safetyList(criteria.list());
        log.debug("findOnloadPallet Size : {}", palletModelList.size());
        return palletModelList;
    } catch (Exception e) {
        log.debug("Exception : {}", e);
        return palletModelList;
    }
}

@Test
public void salvaDisciplinaRetornaErroQuandoJahExisteUmaComOMesmoNome() {
    when(disciplina.getNome()).thenReturn("Lab XP");
    when(session.createCriteria(Disciplina.class)).thenReturn(criteria);
    when(criteria.list()).thenReturn(Arrays.asList(disciplina));
    when(criteria.add(any(Criterion.class))).thenReturn(criteria);
    DisciplinaDao dao = new DisciplinaDao(session);
    dao.salvaDisciplina(disciplina);
    verify(session, never()).save(anyObject());
}

private Criterion translate(String propertyName, Query exp) throws QueryTranslatorException {
    if (exp instanceof Word) {
        String value = "%" + ((Word) exp).getValue() + "%";
        return Restrictions.like(propertyName, value);
    } else if (exp instanceof SQLLike) {
        String value = ((SQLLike) exp).getValue();
        return Restrictions.like(propertyName, value);
    } else if (exp instanceof Or) {
        Criterion left = translate(propertyName, ((Or) exp).getLeft());
        Criterion right = translate(propertyName, ((Or) exp).getRight());
        return Restrictions.or(left, right);
    }
    throw new QueryTranslatorException("Unknown query type: " + propertyName + ", " + exp.getClass());
}

@SuppressWarnings("checkstyle:indentation")
private Criterion addAttributeFilterSubquery(String key, Collection<String> values) {
    // key = this.sanitizeMatchesFilter(key);
    // Find all pools which have the given attribute (and values) on a product, unless the pool
    // defines that same attribute
    DetachedCriteria poolAttrSubquery = DetachedCriteria.forClass(Pool.class, "PoolI").createAlias("PoolI.attributes", "attrib").setProjection(Projections.id()).add(Property.forName("Pool.id").eqProperty("PoolI.id")).add(Restrictions.eq("attrib.indices", key));
    // Impl note:
    // The SQL restriction below uses some Hibernate magic value to get the pool ID from the
    // outer-most query. We can't use {alias} here, since we're basing the subquery on Product
    // instead of Pool to save ourselves an unnecessary join. Similarly, we use an SQL
    // restriction here because we can query the information we need, hitting only one table
    // with direct SQL, whereas the matching criteria query would end up requiring a minimum of
    // one join to get from pool to pool attributes.
    DetachedCriteria prodAttrSubquery = DetachedCriteria.forClass(Product.class, "ProdI").createAlias("ProdI.attributes", "attrib").setProjection(Projections.id()).add(Property.forName("Product.uuid").eqProperty("ProdI.uuid")).add(Restrictions.eq("attrib.indices", key)).add(Restrictions.sqlRestriction("NOT EXISTS (SELECT poolattr.pool_id FROM cp_pool_attribute poolattr " + "WHERE poolattr.pool_id = this_.id AND poolattr.name = ?)", key, StringType.INSTANCE));
    if (values != null && !values.isEmpty()) {
        Disjunction poolAttrValueDisjunction = Restrictions.disjunction();
        Disjunction prodAttrValueDisjunction = Restrictions.disjunction();
        for (String attrValue : values) {
            if (attrValue == null || attrValue.isEmpty()) {
                poolAttrValueDisjunction.add(Restrictions.isNull("attrib.elements")).add(Restrictions.eq("attrib.elements", ""));
                prodAttrValueDisjunction.add(Restrictions.isNull("attrib.elements")).add(Restrictions.eq("attrib.elements", ""));
            } else {
                attrValue = this.sanitizeMatchesFilter(attrValue);
                poolAttrValueDisjunction.add(CPRestrictions.ilike("attrib.elements", attrValue, '!'));
                prodAttrValueDisjunction.add(CPRestrictions.ilike("attrib.elements", attrValue, '!'));
            }
        }
        poolAttrSubquery.add(poolAttrValueDisjunction);
        prodAttrSubquery.add(prodAttrValueDisjunction);
    }
    return Restrictions.or(Subqueries.exists(poolAttrSubquery), Subqueries.exists(prodAttrSubquery));
}

public Collection<CommandesEntity> findByCriterions(ClientsEntity clientsEntity, Order order, Criterion simpleExpression, Date date) {
    Criteria crit = getSession().createCriteria(getPersistentClass());
    if (order != null) {
        crit.addOrder(order);
    }
    if (simpleExpression != null) {
        crit.add(simpleExpression);
    }
    if (clientsEntity != null) {
        crit.add(Restrictions.eq("clientsByClientId.clientId", clientsEntity.getClientId()));
    } else {
        if (date != null) {
            Calendar cal = new GregorianCalendar();
            cal.setTime(date);
            int mois = cal.get(Calendar.MONTH) + 1;
            String moisString = (mois > 9) ? mois + "" : "0" + mois;
            crit.add(Restrictions.sqlRestriction("Command_date LIKE '" + cal.get(Calendar.YEAR) + "-" + moisString + "%'"));
        }
    }
    return new LinkedHashSet(crit.list());
}

/**
	 * 根�Criterion��数组创建DetachedCriteria对象
	 * 
	 * @param persistentClass orm实体class
	 * @param orderBy 排åº?表达å¼?，规则为:属性å??称_排åº?规则,如:property_asc或property_desc,å?¯ä»¥æ”¯æŒ?多个属性排åº?，用逗å?·åˆ†å‰²,如:"property1_asc,proerty2_desc",也å?¯ä»¥"property"ä¸?加排åº?规则时默认是desc
	 * @param criterions ��长度的Criterion数组 
	 * 
	 * @return @return {@link DetachedCriteria}
	 */
protected DetachedCriteria createDetachedCriteria(Class<?> persistentClass, String orderBy, Criterion... criterions) {
    DetachedCriteria criteria = DetachedCriteria.forClass(persistentClass);
    for (Criterion criterion : criterions) {
        criteria.add(criterion);
    }
    ;
    CriteriaImpl criteriaImpl = ReflectionUtils.getFieldValue(criteria, "impl");
    setOrderToCriteria(criteriaImpl, orderBy);
    return criteria;
}

public List<Expedient> findAmbEntornLikeIdentificador(Long entornId, String text) {
    Criterion[] criteris = new Criterion[2];
    criteris[0] = Restrictions.ilike("titol", "%" + text + "%");
    criteris[1] = Restrictions.ilike("numero", "%" + text + "%");
    return findOrderedByCriteria(new String[] { "numero", "titol" }, true, Restrictions.eq("entorn.id", entornId), Restrictions.or(Restrictions.ilike("titol", "%" + text + "%"), Restrictions.ilike("numero", "%" + text + "%")));
}

/**
	 * 根�订�编�查询订�
	 * 
	 * @param orderid
	 */
public void findOrderInfoByorderid(String orderid) {
    int currentPage = page;
    int lineSize = rp;
    Criterion criterion = Restrictions.eq("orderid", orderid);
    Order order = Order.desc("createtime");
    total = this.orderTService.count(OrderT.class, criterion).intValue();
    List<OrderT> list = this.orderTService.findByCriteriaByPage(OrderT.class, criterion, order, currentPage, lineSize);
    this.processOrderList(list);
}

/**
   * Lists all algorithms from the database that implement a certain interface, or all if algorithm
   * class is null.
   *
   * @param algorithmClass the implemented algorithm interface.
   * @return the algorithms
   * @throws de.metanome.backend.results_db.EntityStorageException if algorithms could not be listed
   */
@SuppressWarnings("unchecked")
protected List<Algorithm> listAlgorithms(Class<?>... algorithmClass) throws EntityStorageException {
    // Cannot directly use array, as some interfaces might not be relevant for query.
    ArrayList<Criterion> criteria = new ArrayList<>(algorithmClass.length);
    Set<Class<?>> interfaces = new HashSet<>(Arrays.asList(algorithmClass));
    if (interfaces.contains(InclusionDependencyAlgorithm.class)) {
        criteria.add(Restrictions.eq("ind", true));
    }
    if (interfaces.contains(FunctionalDependencyAlgorithm.class)) {
        criteria.add(Restrictions.eq("fd", true));
    }
    if (interfaces.contains(UniqueColumnCombinationsAlgorithm.class)) {
        criteria.add(Restrictions.eq("ucc", true));
    }
    if (interfaces.contains(ConditionalUniqueColumnCombinationAlgorithm.class)) {
        criteria.add(Restrictions.eq("cucc", true));
    }
    if (interfaces.contains(OrderDependencyAlgorithm.class)) {
        criteria.add(Restrictions.eq("od", true));
    }
    if (interfaces.contains(MultivaluedDependencyAlgorithm.class)) {
        criteria.add(Restrictions.eq("mvd", true));
    }
    if (interfaces.contains(BasicStatisticsAlgorithm.class)) {
        criteria.add(Restrictions.eq("basicStat", true));
    }
    return (List<Algorithm>) HibernateUtil.queryCriteria(Algorithm.class, criteria.toArray(new Criterion[criteria.size()]));
}

/**
     * Return a single {@link IpPoolManagement}
     * 
     * @param vlan {@link VLANNetwork} oject which the Ip should belong to.
     * @param ipId identifier of the Ip.
     * @return the found object.
     */
public IpPoolManagement findIp(final VLANNetwork vlan, final Integer ipId) {
    Criteria criteria = getSession().createCriteria(IpPoolManagement.class);
    Criterion vlanEqual = Restrictions.eq(IpPoolManagement.VLAN_NETWORK_PROPERTY, vlan);
    Criterion ipEqual = Restrictions.eq(PersistentEntity.ID_PROPERTY, ipId);
    criteria.add(vlanEqual).add(ipEqual);
    return (IpPoolManagement) criteria.uniqueResult();
}

/**
     * Looks in cache for the necessary DTOs and returns them if found. Otherwise, makes a database call, puts them in
     * cache, and returns them.
     * 
     * @param ids
     *            the list of ids that should be found.
     * @return list of DTO objects.
     */
@SuppressWarnings("unchecked")
public List<OrganizationModelView> execute(final List<Long> ids) {
    if (ids == null || ids.size() == 0) {
        return new ArrayList<OrganizationModelView>();
    }
    Criteria criteria = getHibernateSession().createCriteria(Organization.class);
    ProjectionList fields = Projections.projectionList();
    fields.add(getColumn("id"));
    fields.add(Projections.property("parentOrganization.id").as("parentOrganizationId"));
    fields.add(getColumn("description"));
    fields.add(getColumn("name"));
    fields.add(getColumn("shortName"));
    fields.add(getColumn("childOrganizationCount"));
    fields.add(getColumn("descendantGroupCount"));
    fields.add(getColumn("descendantEmployeeCount"));
    fields.add(Projections.property("employeeFollowerCount").as("followersCount"));
    fields.add(getColumn("updatesCount"));
    fields.add(getColumn("overview"));
    fields.add(Projections.property("stream.id").as("streamId"));
    fields.add(getColumn("bannerId"));
    fields.add(getColumn("url"));
    fields.add(getColumn("allUsersCanCreateGroups"));
    fields.add(getColumn("avatarId"));
    fields.add(getColumn("avatarCropSize"));
    fields.add(getColumn("avatarCropX"));
    fields.add(getColumn("avatarCropY"));
    criteria.setProjection(fields);
    criteria.createAlias("streamScope", "stream");
    // Creates the necessary "OR" clauses to get all uncached items
    Criterion restriction = null;
    for (Long orgId : ids) {
        if (restriction == null) {
            restriction = Restrictions.eq("this.id", orgId);
        } else {
            restriction = Restrictions.or(Restrictions.eq("this.id", orgId), restriction);
        }
    }
    criteria.add(restriction);
    ModelViewResultTransformer<OrganizationModelView> //
    resultTransformer = new ModelViewResultTransformer<OrganizationModelView>(new OrganizationModelViewFactory());
    criteria.setResultTransformer(resultTransformer);
    return criteria.list();
}

/**
     * {@inheritDoc}
     */
@SuppressWarnings("unchecked")
@Override
public List<Task> findByCriteria(TaskSearchCriteria criteria) {
    Session session = (Session) getEntityManager().getDelegate();
    Criteria baseCriteria = session.createCriteria(Task.class);
    if (!StringUtils.isEmpty(criteria.getVdc())) {
        baseCriteria.add(Restrictions.eq("vdc", criteria.getVdc()));
    }
    if (criteria.getStates() != null && !criteria.getStates().isEmpty()) {
        Criterion statusCr = null;
        for (TaskStates states : criteria.getStates()) {
            statusCr = addStatus(statusCr, states);
        }
        baseCriteria.add(statusCr);
    }
    if (criteria.getFromDate() != null) {
        baseCriteria.add(Restrictions.ge("startTime", criteria.getFromDate()));
    }
    if (criteria.getToDate() != null) {
        baseCriteria.add(Restrictions.le("startTime", criteria.getToDate()));
    }
    if (!StringUtils.isEmpty(criteria.getResource())) {
        baseCriteria.add(Restrictions.eq("result.href", criteria.getResource()));
    }
    if (!StringUtils.isEmpty(criteria.getOwner())) {
        baseCriteria.add(Restrictions.eq("owner.href", criteria.getOwner()));
    }
    return setOptionalPagination(criteria, baseCriteria).list();
}

@Test
public void within() throws SQLException {
    if (!isSupportedByDialect(SpatialFunction.within)) {
        return;
    }
    Map<Integer, Boolean> dbexpected = expectationsFactory.getWithin(expectationsFactory.getTestPolygon());
    Criterion spatialCriterion = SpatialRestrictions.within("geom", expectationsFactory.getTestPolygon());
    retrieveAndCompare(dbexpected, spatialCriterion);
}

protected QueryExpression getExpression(GraphQuery query, ItemSelector selector) {
    // OffspringItemSelector
    // RelationItemSelector
    // Convert the selector to an expression.
    QueryExpression queryExpr = new QueryExpression();
    // Find Template...
    ICi template = selector.fetchTemplate();
    if (selector.hasTemplate()) {
        if (template == null) {
            ItemExpression item = new ItemExpression();
            item.setAlias(selector.getTemplateAlias());
            List<ICi> cis = msvc.queryCrtiteria(item.getCriteria(), new PageInfo());
            if (cis.size() != 1) {
                throw new IllegalArgumentException("ItemSelector's template '" + selector.getTemplateAlias() + "' not found!");
            }
            template = cis.get(0);
            selector.bindTemplate(template);
        }
    }
    DetachedCriteria resultCrit = null;
    if (selector instanceof ItemOffspringSelector) {
        OffspringExpression expr = new OffspringExpression();
        // Lookup for alias.
        if (template != null) {
            expr.setTemplatePath(template.getTemplatePath());
            expr.setTemplateID(template.getId().asLong());
        }
        expr.setMatchTemplate(((ItemOffspringSelector) selector).getMatchTemplate());
        expr.setLimitToChild(((ItemOffspringSelector) selector).isLimitToChild());
        resultCrit = expr.getCriteria();
    } else if (selector instanceof ItemAliasSelector) {
        // Validate...
        if (((ItemAliasSelector) selector).getAlias() == null && ((ItemAliasSelector) selector).getAliases() == null) {
            queryExpr.empty = true;
            return (queryExpr);
        }
        if (((ItemAliasSelector) selector).getAlias() == null) {
            if (((ItemAliasSelector) selector).getAliases().size() == 0) {
                queryExpr.empty = true;
                return (queryExpr);
            }
        }
        ItemExpression aliasExpr = new ItemExpression();
        aliasExpr.setAlias(((ItemAliasSelector) selector).getAlias());
        aliasExpr.setAliases(((ItemAliasSelector) selector).getAliases());
        resultCrit = aliasExpr.getCriteria();
    } else if (selector instanceof ItemRFCSelector) {
        RFCExpression rfcExpr = new RFCExpression();
        rfcExpr.setType(selector.getTemplateAlias());
        rfcExpr.setTxId(((ItemRFCSelector) selector).getTxId());
        resultCrit = rfcExpr.getCriteria();
    } else if (selector instanceof ItemTransactionSelector) {
        TransactionExpression transactionExpr = new TransactionExpression();
        transactionExpr.setTxid(((ItemTransactionSelector) selector).getTxId());
        resultCrit = transactionExpr.getCriteria();
    } else if (selector instanceof ItemRelationSelector) {
        RelationExpression expr = new RelationExpression();
        ItemRelationSelector rel = (ItemRelationSelector) selector;
        if (rel.getSourceRange() != null) {
            if (rel.getSourceRange().size() == 0) {
                log.info("RelationSelector[" + rel.getId() + "] SourceRange Empty!");
                queryExpr.empty = true;
                return (queryExpr);
            }
            expr.setSourceIds(rel.getSourceRange());
        } else {
            ItemSelector sourceSel = query.findSelector(rel.getSource());
            if (sourceSel == null) {
                throw new IllegalArgumentException("RelationSelector[" + rel.getId() + "] source id[" + rel.getSource() + "] not found.");
            }
            QueryExpression sExpr = getExpression(query, sourceSel);
            if (sExpr.empty) {
                queryExpr.empty = sExpr.empty;
                return (queryExpr);
            }
            expr.setSource(sExpr.criteria);
        }
        if (rel.getTargetRange() != null) {
            if (rel.getTargetRange().size() == 0) {
                log.info("RelationSelector[" + rel.getId() + "] TargetRange Empty!");
                queryExpr.empty = true;
                return (queryExpr);
            }
            expr.setTargetIds(rel.getTargetRange());
        } else {
            ItemSelector targetSel = query.findSelector(rel.getTarget());
            if (targetSel == null) {
                throw new IllegalArgumentException("RelationSelector[" + rel.getId() + "] target id[" + rel.getTarget() + "] not found.");
            }
            QueryExpression tExpr = getExpression(query, targetSel);
            if (tExpr.empty) {
                queryExpr.empty = tExpr.empty;
                return (queryExpr);
            }
            expr.setTarget(tExpr.criteria);
        }
        resultCrit = expr.getCriteria();
    } else {
        throw new IllegalArgumentException("ItemSelector type [" + selector.getClass().getName() + "] is not supported!");
    }
    ItemConstraint constraint = selector.fetchConstraint();
    if (constraint != null) {
        Criterion crit = getConstraint2(query, constraint);
        if (crit == null) {
            queryExpr.empty = true;
        } else {
            resultCrit.add(crit);
        }
    }
    queryExpr.criteria = resultCrit;
    return (queryExpr);
}

/**
         * Delegate given expression instance to 
         * {@link #createCriterion(LogicalExpression)} or 
         * {@link #createCriterion(ComparisonExpression)} according to its type.
         * 
         * @param expression Instance of {@link LogicalExpression} or 
         *                   {@link ComparisonExpression}.
         * @return Criterion
         * @throws RSQLException
         * @throws IllegalArgumentException If cannot be cast to 
         *         {@link LogicalExpression} nor {@link ComparisonExpression}.
         */
private Criterion createCriterion(Expression expression) throws RSQLException, IllegalArgumentException {
    LOG.trace("Creating criterion for: {}", expression);
    if (expression.isLogical()) {
        return createCriterion((LogicalExpression) expression);
    }
    if (expression.isComparison()) {
        return createCriterion((ComparisonExpression) expression);
    }
    throw new IllegalArgumentException("Unknown expression type: " + expression.getClass());
}

@SuppressWarnings("all")
protected List<T> findByCriteria(Criterion... criterion) {
    List<T> result = new LinkedList<T>();
    Criteria crit = getSession().createCriteria(getPersistentClass());
    crit.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);
    for (Criterion c : criterion) {
        crit.add(c);
    }
    for (Object o : crit.list()) {
        result.add((T) o);
    }
    return result;
}

/* (non-Javadoc)
     * @see com.axxx.dps.apv.persistence.GenericEntityDao#list(java.lang.Class, org.hibernate.criterion.Criterion, org.hibernate.criterion.Order, java.lang.Integer, java.lang.Integer)
     */
@Override
@SuppressWarnings("unchecked")
public List<T> list(Class<? extends T> objectClass, Criterion filter, Order order, Integer limit, Integer offset) {
    List<T> entities = new LinkedList<T>();
    try {
        Criteria criteria = buildCriteria(objectClass, null, filter, order, limit, offset);
        entities = criteria.list();
        if (order == null) {
            Collections.sort(entities);
        }
        return entities;
    } catch (DataAccessException e) {
        return entities;
    }
}

private List<Notification> getNotificationsWithCriterion(SurveillanceSet set, String severity, Criterion... criterions) {
    OnmsCriteria criteria = new OnmsCriteria(OnmsNotification.class, "notification");
    OnmsCriteria nodeCriteria = criteria.createCriteria("node");
    addCriteriaForSurveillanceSet(nodeCriteria, set);
    nodeCriteria.add(Restrictions.ne("type", "D"));
    for (Criterion criterion : criterions) {
        criteria.add(criterion);
    }
    criteria.addOrder(Order.desc("notification.pageTime"));
    List<OnmsNotification> notifications = m_notificationDao.findMatching(criteria);
    return convertOnmsNotificationsToNotifications(notifications, severity);
}

@Override
public Criterion getAssignmentCriterion() {
    switch(getAssignments()) {
        case 1:
            return Restrictions.eq("assignee.username", ((HeadsUpSession) org.apache.wicket.Session.get()).getUser().getUsername());
        case 2:
            return Restrictions.isNotNull("assignee");
        case 3:
            return Restrictions.isNull("assignee");
    }
    return null;
}

/**
	 * 针对内建数�类型和日期类型添加查询�件 因为很多从页�回传的""字符串在转化�数字时为0,所以这里忽略0
	 * 
	 * @param name
	 * @param value
	 * @param criterions
	 */
private static void addPrimativeCriterion(String name, Object value, List criterions, boolean ignoreZero) {
    Criterion criterion = null;
    if (value instanceof Number) {
        if (ignoreZero) {
            if (0 != ((Number) value).intValue()) {
                criterion = eqCriterion(name, value);
            }
        } else {
            criterion = eqCriterion(name, value);
        }
    }
    if ((value instanceof Character) || (value instanceof Boolean)) {
        criterion = eqCriterion(name, value);
    }
    if ((value instanceof Date)) {
        criterion = eqCriterion(name, value);
    }
    if (null != criterion) {
        criterions.add(criterion);
    }
}

@Test
public void testIlikeRendering() {
    SessionFactory sf = new Configuration().addAnnotatedClass(IrrelevantEntity.class).setProperty(AvailableSettings.DIALECT, IlikeSupportingDialect.class.getName()).buildSessionFactory();
    final Criteria criteria = sf.openSession().createCriteria(IrrelevantEntity.class);
    final CriteriaQueryTranslator translator = new CriteriaQueryTranslator((SessionFactoryImplementor) sf, (CriteriaImpl) criteria, IrrelevantEntity.class.getName(), "a");
    final Criterion ilikeExpression = Restrictions.ilike("name", "abc");
    final String ilikeExpressionSqlFragment = ilikeExpression.toSqlString(criteria, translator);
    assertEquals("a.name insensitiveLike ?", ilikeExpressionSqlFragment);
}

/**
     *
     * @param filter
     * @param pageRequest
     * @return
     */
@Override
public Page<Movement> listByFilter(MovementFilter filter, PageRequest pageRequest) {
    final Criteria criteria = this.createCriteria();
    final List<Criterion> criterions = new ArrayList<>();
    criteria.createAlias("contact", "co", JoinType.LEFT_OUTER_JOIN);
    criteria.createAlias("apportionments", "ap");
    criteria.createAlias("ap.movementClass", "mc");
    criteria.createAlias("ap.costCenter", "cc");
    criteria.createAlias("financialPeriod", "fp");
    // montramos os criterios de filtragem geral
    if (filter.hasCriteria()) {
        criterions.add(Restrictions.eq("code", filter.getCriteria()));
        criterions.add(Restrictions.ilike("description", "%" + filter.getCriteria() + "%"));
        criterions.add(Restrictions.ilike("mc.name", "%" + filter.getCriteria() + "%"));
        criterions.add(Restrictions.ilike("cc.name", "%" + filter.getCriteria() + "%"));
        criterions.add(Restrictions.ilike("co.name", "%" + filter.getCriteria() + "%"));
        // se conseguir castar para bigdecimal trata como um filtro
        try {
            criterions.add(Restrictions.eq("value", filter.criteriaToBigDecimal()));
        } catch (ParseException ex) {
        }
    }
    criteria.add(Restrictions.or(criterions.toArray(new Criterion[] {})));
    criteria.add(Restrictions.and(filter.getCustomFilters()));
    // projetamos para pegar o total de paginas possiveis
    criteria.setProjection(Projections.count("id"));
    final Long totalRows = (Long) criteria.uniqueResult();
    // limpamos a projection para que a criteria seja reusada
    criteria.setProjection(null);
    criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);
    // paginamos
    criteria.setFirstResult(pageRequest.getFirstResult());
    criteria.setMaxResults(pageRequest.getPageSize());
    // aplica o multisort dos campos
    if (pageRequest.isMultiSort()) {
        pageRequest.getMultiSortFields().stream().forEach( field -> {
            if (field.getDirection() == SortDirection.ASC) {
                criteria.addOrder(Order.asc(field.getSortField()));
            } else if (field.getDirection() == SortDirection.DESC) {
                criteria.addOrder(Order.desc(field.getSortField()));
            }
        });
    } else if (pageRequest.getSortDirection() == SortDirection.ASC) {
        criteria.addOrder(Order.asc(pageRequest.getSortField()));
    } else if (pageRequest.getSortDirection() == SortDirection.DESC) {
        criteria.addOrder(Order.desc(pageRequest.getSortField()));
    }
    // montamos o resultado paginado
    return new Page<>(criteria.list(), totalRows);
}

private static Criteria givenCriteria() {
    Criteria criteria = mock(Criteria.class);
    when(criteria.add(any(Criterion.class))).thenReturn(criteria);
    when(criteria.setResultTransformer(any(ResultTransformer.class))).thenReturn(criteria);
    when(criteria.setCacheable(anyBoolean())).thenReturn(criteria);
    return criteria;
}

/**
     * Get the entity ids from their pointer values.
     *
     * @param inPointerValues
     *            the values of the pointers to look up ids for
     * @return a Map of pointer values to Long entity ids
     */
@Override
public List<Long> execute(final List<PointerType> inPointerValues) {
    if (inPointerValues == null || inPointerValues.isEmpty()) {
        return new ArrayList<Long>();
    }
    Criteria criteria = getHibernateSession().createCriteria(entityClass);
    ProjectionList fields = Projections.projectionList();
    fields.add(Projections.property(pointerFieldName).as("key"));
    fields.add(Projections.property("id").as("itemId"));
    criteria.setProjection(fields);
    // Creates the necessary "OR" clauses to get all uncached item pointers
    Criterion restriction = null;
    for (PointerType pointer : inPointerValues) {
        if (restriction == null) {
            restriction = Restrictions.eq(pointerFieldName, pointer);
        } else {
            restriction = Restrictions.or(Restrictions.eq(pointerFieldName, pointer), restriction);
        }
    }
    criteria.add(restriction);
    // Build the list of results
    // Insure a 1-to-1 correspondence to the input pointers (same order and nulls for missing values)
    // Note: results is a list of Object arrays. Each array contains the fields for the given row in the same order
    // as they were added to the ProjectionList above.
    List<Object[]> dbResults = criteria.list();
    Map<PointerType, Long> dbIndex = new HashMap<PointerType, Long>();
    for (Object[] row : dbResults) {
        dbIndex.put((PointerType) row[0], (Long) row[1]);
    }
    List<Long> results = new ArrayList<Long>(inPointerValues.size());
    for (PointerType key : inPointerValues) {
        // Note: this automatically handles nulls for unknown elements
        results.add(dbIndex.get(key));
    }
    return results;
}

/** @see ReminderDao#getPendingReminders() */
public Collection<Reminder> getPendingReminders() {
    DetachedCriteria criteria = super.getCriterion();
    Criterion notSent = Restrictions.ne(Field.STATUS.getFieldName(), Reminder.Status.SENT);
    Criterion isNull = Restrictions.isNull(Field.STATUS.getFieldName());
    criteria.add(Restrictions.or(notSent, isNull));
    return super.getList(criteria);
}

protected Criterion getCompareCriterion(String fieldid, String fieldProperty, List<Object> values) {
    Object value_0 = values.get(0);
    switch(getFilterOperation(fieldid)) {
        case LIKE:
            if (value_0 instanceof String) {
                return Restrictions.ilike(fieldProperty, "%" + value_0 + "%");
            } else {
                return Restrictions.eq(fieldProperty, value_0);
            }
        case BETWEEN:
            return Restrictions.between(fieldProperty, value_0, values.get(1));
        case GE:
            return Restrictions.ge(fieldProperty, value_0);
        case GT:
            return Restrictions.gt(fieldProperty, value_0);
        case LE:
            return Restrictions.le(fieldProperty, value_0);
        case LT:
            return Restrictions.lt(fieldProperty, value_0);
        case NE:
            return Restrictions.not(Restrictions.eq(fieldProperty, value_0));
        default:
            return Restrictions.eq(fieldProperty, value_0);
    }
}

protected Criteria createCriteria(PMContext ctx, Entity entity, EntityFilter filter) throws PMException {
    Criteria c;
    DB db = getDb(ctx);
    try {
        c = db.session().createCriteria(Class.forName(entity.getClazz()));
    } catch (ClassNotFoundException e) {
        ctx.getErrors().add(new PMMessage(ENTITY, "class.not.found"));
        throw new PMException();
    }
    String order = null;
    try {
        order = (ctx.getString(PM_LIST_ORDER) != null) ? entity.getFieldById(ctx.getString(PM_LIST_ORDER)).getProperty() : null;
    } catch (Exception e) {
    }
    boolean asc = (ctx.get(PM_LIST_ASC) == null) ? true : (Boolean) ctx.get(PM_LIST_ASC);
    //This is a temporary patch until i found how to sort propertys
    if (order != null && order.contains(".")) {
        order = order.substring(0, order.indexOf("."));
    }
    if (order != null && order.compareTo("") != 0) {
        if (asc) {
            c.addOrder(Order.asc(order));
        } else {
            c.addOrder(Order.desc(order));
        }
    }
    if (entity.getListfilter() != null) {
        c.add((Criterion) entity.getListfilter().getListFilter(ctx));
    }
    if (filter != null) {
        c = ((DBEntityFilter) filter).applyFilters(c);
    }
    //Weak entities must filter the parent
    if (entity.isWeak()) {
        if (ctx.getEntityContainer().getOwner() != null && ctx.getEntityContainer().getOwner().getSelected() != null) {
            final Object instance = ctx.getEntityContainer().getOwner().getSelected().getInstance();
            final String localProperty = entity.getOwner().getLocalProperty();
            c.add(Restrictions.eq(localProperty, instance));
        }
    }
    return c;
}

@Override
public Object getItem(PMContext ctx, String property, String value) throws PMException {
    try {
        /*
             * To avoid the use of SQL restriction that use column name we introspect
             * the property type and parse it. It work for some basics for now
             * until we find a better way.
             *
             * If we get an error or the type is not a Long, Integer, Boolean nor String,
             * we try the old way.
             */
        final Session db = getDb(ctx);
        final Class<?> clazz = Class.forName(getEntity().getClazz());
        final Criteria c = db.createCriteria(clazz);
        c.setMaxResults(1);
        Criterion criterion = null;
        try {
            final Field f = clazz.getDeclaredField(property);
            final Class<?> declaringClass = f.getType();
            if (declaringClass.equals(Long.class)) {
                criterion = Restrictions.eq(property, Long.parseLong(value));
            } else if (declaringClass.equals(Integer.class)) {
                criterion = Restrictions.eq(property, Integer.parseInt(value));
            } else if (declaringClass.equals(String.class)) {
                criterion = Restrictions.eq(property, value);
            } else if (declaringClass.equals(Boolean.class)) {
                criterion = Restrictions.eq(property, Boolean.parseBoolean(value));
            }
        } catch (NoSuchFieldException e) {
            criterion = Restrictions.sqlRestriction(property + "=" + value);
        }
        if (criterion == null) {
            criterion = Restrictions.sqlRestriction(property + "=" + value);
        }
        c.add(criterion);
        return c.uniqueResult();
    } catch (Exception e) {
        throw new PMException(e);
    }
}

@Override
public ProfileFilter findLatestDeprecated(String endpointProfileSchemaId, String serverProfileSchemaId, String groupId) {
    LOG.debug("Searching latest deprecated profile filter by endpoint profile schema id [{}], " + "server profile schema id [{}] and group id [{}] ", endpointProfileSchemaId, serverProfileSchemaId, groupId);
    ProfileFilter filter = null;
    if (isNotBlank(groupId)) {
        Criteria criteria = getCriteria();
        criteria.createAlias(ENDPOINT_PROFILE_SCHEMA_PROPERTY, ENDPOINT_PROFILE_SCHEMA_ALIAS, JoinType.LEFT_OUTER_JOIN);
        criteria.createAlias(SERVER_PROFILE_SCHEMA_PROPERTY, SERVER_PROFILE_SCHEMA_ALIAS, JoinType.LEFT_OUTER_JOIN);
        criteria.createAlias(ENDPOINT_GROUP_PROPERTY, ENDPOINT_GROUP_ALIAS);
        Criterion crit = Restrictions.and(Restrictions.eq(ENDPOINT_GROUP_REFERENCE, Long.valueOf(groupId)), buildEqIdCriterion(ENDPOINT_PROFILE_SCHEMA_REFERENCE, endpointProfileSchemaId), buildEqIdCriterion(SERVER_PROFILE_SCHEMA_REFERENCE, serverProfileSchemaId), Restrictions.eq(STATUS_PROPERTY, UpdateStatus.DEPRECATED));
        filter = (ProfileFilter) criteria.add(crit).addOrder(Order.desc(SEQUENCE_NUMBER_PROPERTY)).setMaxResults(FIRST).uniqueResult();
    }
    if (LOG.isTraceEnabled()) {
        LOG.trace("[{},{},{}] Search result: {}.", endpointProfileSchemaId, serverProfileSchemaId, groupId, filter);
    } else {
        LOG.debug("[{},{},{}] Search result: {}.", endpointProfileSchemaId, serverProfileSchemaId, groupId, filter != null);
    }
    return filter;
}

/**
	 * @see org.openmrs.api.db.ConceptDAO#getDrugsByIngredient(org.openmrs.Concept)
	 */
@Override
@SuppressWarnings("unchecked")
public List<Drug> getDrugsByIngredient(Concept ingredient) {
    Criteria searchDrugCriteria = sessionFactory.getCurrentSession().createCriteria(Drug.class, "drug");
    Criterion rhs = Restrictions.eq("drug.concept", ingredient);
    searchDrugCriteria.createAlias("ingredients", "ingredients");
    Criterion lhs = Restrictions.eq("ingredients.ingredient", ingredient);
    searchDrugCriteria.add(Restrictions.or(lhs, rhs));
    return (List<Drug>) searchDrugCriteria.list();
}

/**
	 * Create the criteria for finding other stock items that are allowed to merge
	 * with this one. Two items may merge if they only differ in comment,
	 * unitcount and acquisition/liquidation date (but they need to be in the same
	 * state of acquisition/liquidation).
	 * 
	 * @return Hibernate criterias
	 */
public List<Criterion> allowedToMergeWith() {
    Vector<Criterion> ret = new Vector<Criterion>();
    ret.add(Restrictions.ne("id", id));
    ret.add(Restrictions.eq("buyPrice", buyPrice));
    ret.add(Restrictions.eq("sellPrice", sellPrice));
    if (name == null) {
        // This should never happen
        ret.add(Restrictions.isNull("name"));
    } else {
        ret.add(Restrictions.eq("name.id", name.getId()));
    }
    if (variant == null) {
        ret.add(Restrictions.isNull("variant"));
    } else {
        ret.add(Restrictions.eq("variant.id", variant.getId()));
    }
    if (acquired == null) {
        ret.add(Restrictions.isNull("acquired"));
    } else {
        ret.add(Restrictions.isNotNull("acquired"));
    }
    if (liquidated == null) {
        ret.add(Restrictions.isNull("liquidated"));
    } else {
        ret.add(Restrictions.isNotNull("liquidated"));
    }
    return ret;
}

/**
	 * Get a List<VMI> considering the ACL permissions for each VMI.
	 * @param user The User that performs the query.
	 * @return The List<VMI>
	 * @throws DaoException
	 */
public List<VMI> getListCheckingACL(User user) throws DaoException {
    try {
        Criteria criteria = getSessionFactory().getCurrentSession().createCriteria(clazz);
        criteria.createAlias("acl", "acl");
        if (!user.isAdmin()) {
            Criterion aclOwner = Restrictions.and(Restrictions.eq("acl.listPerm", "owner"), Restrictions.eq("owner", user.getUserName()));
            if (user.getAcl().getListPerm().equalsIgnoreCase("all")) {
                Criterion aclAll = Restrictions.eq("acl.listPerm", "all");
                criteria.add(Restrictions.or(aclAll, aclOwner));
            } else {
                criteria.add(aclOwner);
            }
        }
        log.debug("Performing query with criteria: " + criteria);
        return criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY).list();
    } catch (Exception e) {
        throw new DaoException(e);
    }
}

/**
     *
     * @param filter
     * @param pageRequest
     * @return
     */
@Override
public Page<Movement> listByFilter(MovementFilter filter, PageRequest pageRequest) {
    final Criteria criteria = this.createCriteria();
    final List<Criterion> criterions = new ArrayList<>();
    criteria.createAlias("contact", "co", JoinType.LEFT_OUTER_JOIN);
    criteria.createAlias("apportionments", "ap");
    criteria.createAlias("ap.movementClass", "mc");
    criteria.createAlias("ap.costCenter", "cc");
    criteria.createAlias("financialPeriod", "fp");
    // montramos os criterios de filtragem geral
    if (filter.hasCriteria()) {
        criterions.add(Restrictions.eq("code", filter.getCriteria()));
        criterions.add(Restrictions.ilike("description", "%" + filter.getCriteria() + "%"));
        criterions.add(Restrictions.ilike("mc.name", "%" + filter.getCriteria() + "%"));
        criterions.add(Restrictions.ilike("cc.name", "%" + filter.getCriteria() + "%"));
        criterions.add(Restrictions.ilike("co.name", "%" + filter.getCriteria() + "%"));
        // se conseguir castar para bigdecimal trata como um filtro
        try {
            criterions.add(Restrictions.eq("value", filter.criteriaToBigDecimal()));
        } catch (ParseException ex) {
        }
    }
    criteria.add(Restrictions.or(criterions.toArray(new Criterion[] {})));
    criteria.add(Restrictions.and(filter.getCustomFilters()));
    // projetamos para pegar o total de paginas possiveis
    criteria.setProjection(Projections.count("id"));
    final Long totalRows = (Long) criteria.uniqueResult();
    // limpamos a projection para que a criteria seja reusada
    criteria.setProjection(null);
    criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);
    // paginamos
    criteria.setFirstResult(pageRequest.getFirstResult());
    criteria.setMaxResults(pageRequest.getPageSize());
    // aplica o multisort dos campos
    if (pageRequest.isMultiSort()) {
        pageRequest.getMultiSortFields().stream().forEach( field -> {
            if (field.getDirection() == SortDirection.ASC) {
                criteria.addOrder(Order.asc(field.getSortField()));
            } else if (field.getDirection() == SortDirection.DESC) {
                criteria.addOrder(Order.desc(field.getSortField()));
            }
        });
    } else if (pageRequest.getSortDirection() == SortDirection.ASC) {
        criteria.addOrder(Order.asc(pageRequest.getSortField()));
    } else if (pageRequest.getSortDirection() == SortDirection.DESC) {
        criteria.addOrder(Order.desc(pageRequest.getSortField()));
    }
    // montamos o resultado paginado
    return new Page<>(criteria.list(), totalRows);
}

private <T extends SyncParameters> List<T> fetchResults(Class<T> clazz, @Nullable SyncToken syncToken, @Nullable Criterion restriction, boolean includeVoided, int maxResults) {
    Session session = sessionFactory.getCurrentSession();
    Criteria criteria = session.createCriteria(clazz);
    if (syncToken != null) {
        // (a, b) > (x, y) is equivalent to (a > x) OR ((a = x) AND (b > y)). See
        // http://dev.mysql.com/doc/refman/5.7/en/comparison-operators.html#operator_greater-than
        criteria.add(sqlRestriction(// {alias} is substituted for the table alias that hibernate uses for the type.
        "({alias}.date_updated, {alias}.uuid) > (?, ?)", new Object[] { syncToken.greaterThanOrEqualToTimestamp, // is 'smaller' than every other string in terms of sort order.
        syncToken.greaterThanUuid == null ? "" : syncToken.greaterThanUuid }, new Type[] { StandardBasicTypes.TIMESTAMP, StandardBasicTypes.STRING }));
    }
    Criteria subCriteria = criteria.createCriteria("item");
    if (restriction != null) {
        subCriteria.add(restriction);
    }
    if (!includeVoided) {
        subCriteria.add(eq("voided", false));
    }
    criteria.addOrder(asc("dateUpdated")).addOrder(asc("uuid"));
    if (maxResults > 0) {
        criteria.setMaxResults(maxResults);
    }
    //noinspection unchecked
    return criteria.list();
}

@SuppressWarnings("unchecked")
@Action(value = "/ajaxCommon-categoryByRateUsageAndStructClass")
public String categoryByRateUsageAndStructClass() {
    LOGGER.debug("Entered into categoryByRateUsageAndStructClass method, Usage Factor: " + usageFactor + ", Structure Classification: " + structFactor);
    PropertyUsage propUsage = (PropertyUsage) getPersistenceService().find("from PropertyUsage pu where pu.usageName=?", usageFactor);
    StructureClassification structureClass = (StructureClassification) getPersistenceService().find("from StructureClassification sc where sc.typeName=?", structFactor);
    if (propUsage != null && structureClass != null && revisedRate != null) {
        Criterion usgId = null;
        Criterion classId = null;
        Criterion catAmt = null;
        Conjunction conjunction = Restrictions.conjunction();
        usgId = Restrictions.eq("propUsage", propUsage);
        classId = Restrictions.eq("structureClass", structureClass);
        catAmt = Restrictions.eq("categoryAmount", revisedRate);
        conjunction.add(usgId);
        conjunction.add(classId);
        conjunction.add(catAmt);
        Criterion criterion = conjunction;
        categoryList = categoryDAO.getCategoryByRateUsageAndStructClass(criterion);
    }
    addDropdownData("categoryList", categoryList);
    LOGGER.debug("Exiting from categoryByRateUsageAndStructClass method");
    if (categoryList == null) {
        LOGGER.debug("categoryByRateUsageAndStructClass: categoryList is NULL \n Exiting from categoryByRateUsageAndStructClass");
        return FAILURE;
    } else {
        LOGGER.debug("categoryByRateUsageAndStructClass: categoryList:" + categoryList + "\nExiting from categoryByRateUsageAndStructClass");
        return CATEGORY;
    }
}

public String toSqlString(Criteria c, CriteriaQuery q) {
    String initial_hql = query.getQueryString();
    //  default query selects whole GlycanSequence objects, which
    //  aren't needed if the Criterion we're returning is just 
    //  going to be used in a subselect.
    int i = initial_hql.indexOf("from ");
    assert i != -1 : initial_hql;
    //  so, narrow the select clause:
    // String hql = "select gs.id " + initial_hql.substring( i );
    String hql = "select gs.glycan_sequence_id " + initial_hql.substring(i);
    //  translate to SQL
    //translateHql2Sql( hql );
    String subquery_expr_sql = hql;
    String sql = propertyName + " in (" + subquery_expr_sql + ")";
    return sql;
}

/**
	 * Augments the supplied criteria with that required to match a keyword.
	 * @param criteria
	 * @param keyword 
	 */
private void addKeywordMatchCriteria(DetachedCriteria criteria, Keyword keyword) {
    String keywordString = keyword.getKeyword();
    // FIXME this should be case-insensitive
    Criterion matchKeyword = Restrictions.or(// This should match the keyword exactly, case insensitive
    Restrictions.ilike(Field.MESSAGE_CONTENT.getFieldName(), keywordString), Restrictions.ilike(Field.MESSAGE_CONTENT.getFieldName(), keywordString + ' '));
    criteria.add(matchKeyword);
}

public void dereferenceGroup(Group group) {
    DetachedCriteria criteria = super.getCriterion();
    Criterion equals = Restrictions.eq(Form.FIELD_PERMITTED, group);
    Criterion like = Restrictions.like("permittedGroup.path", group.getPath() + Group.PATH_SEPARATOR, MatchMode.START);
    criteria.add(Restrictions.or(equals, like));
    List<Form> forms = getList(criteria);
    for (Form formWithDereferencedGroup : forms) {
        System.err.println("Delete form: " + formWithDereferencedGroup.getName());
        formWithDereferencedGroup.setPermittedGroup(null);
        try {
            this.update(formWithDereferencedGroup);
        } catch (DuplicateKeyException e) {
            throw new RuntimeException("There was a problem removing the deleted group from its attached form.");
        }
    }
}

public void dereferenceGroup(Group group) {
    DetachedCriteria criteria = super.getCriterion();
    Criterion equals = Restrictions.eq(Form.FIELD_PERMITTED, group);
    Criterion like = Restrictions.like("permittedGroup.path", group.getPath() + Group.PATH_SEPARATOR, MatchMode.START);
    criteria.add(Restrictions.or(equals, like));
    List<Form> forms = getList(criteria);
    for (Form formWithDereferencedGroup : forms) {
        formWithDereferencedGroup.setPermittedGroup(null);
        try {
            this.update(formWithDereferencedGroup);
        } catch (DuplicateKeyException e) {
            throw new RuntimeException("There was a problem removing the deleted group from its attached form.");
        }
    }
}

@SuppressWarnings("unchecked")
public List<T> findByCriteria(Criterion... criterion) throws DAOException {
    try {
        Criteria crit = getSession().createCriteria(getPersistentClass());
        for (Criterion c : criterion) {
            crit.add(c);
        }
        return crit.list();
    } catch (HibernateException ex) {
        LOGGER.trace(ex.getMessage());
        throw new DAOException(ex);
    }
}

@SuppressWarnings("unchecked")
@Override
public List<EntityType> findAllWithCriteria(Order order, Criterion... criteriaArray) {
    getEntityManager().clear();
    Session session = (Session) getEntityManager().getDelegate();
    Criteria criteria = session.createCriteria(getEntityClass());
    criteria.addOrder(order);
    for (Criterion criterion : criteriaArray) {
        criteria.add(criterion);
    }
    return criteria.list();
}

@POST
@Path("/searchaccount")
@Produces(MediaType.TEXT_PLAIN)
public String searchAccount(@FormParam("searchText") String searchText, @FormParam("authtoken") String authtoken) {
    if (!new LoginService().validate(authtoken))
        return "[]";
    User currentUser = LoginService.getUserByToken(authtoken);
    if (currentUser == null) {
        return "[]";
    }
    String[] parts = searchText.split(" ");
    Transaction tx = HibernateSupport.getSession().beginTransaction();
    Criterion cemail = Restrictions.like("email", "%" + searchText + "%");
    Criterion cfirstname = Restrictions.like("firstName", "%" + searchText + "%");
    Criterion clastname = Restrictions.like("lastName", "%" + searchText + "%");
    Criterion caccountname = Restrictions.like("accountName", "%" + searchText + "%");
    Criterion notCurrentUser = Restrictions.ne("email", currentUser.getEmail());
    Disjunction or = Restrictions.disjunction();
    or.add(cemail);
    or.add(cfirstname);
    or.add(clastname);
    or.add(caccountname);
    if (parts.length > 1) {
        for (int i = 0; i < parts.length; i++) {
            cemail = Restrictions.like("email", "%" + parts[i] + "%");
            cfirstname = Restrictions.like("firstName", "%" + parts[i] + "%");
            clastname = Restrictions.like("lastName", "%" + parts[i] + "%");
            caccountname = Restrictions.like("accountName", "%" + parts[i] + "%");
            or.add(cemail);
            or.add(cfirstname);
            or.add(clastname);
            or.add(caccountname);
        }
    }
    Criterion andCombined = Restrictions.and(or, notCurrentUser);
    Criteria criteria = HibernateSupport.getSession().createCriteria(User.class);
    criteria.add(andCombined);
    criteria.setProjection(Projections.projectionList().add(Projections.property("firstName"), "firstName").add(Projections.property("lastName"), "lastName").add(Projections.property("accountName"), "accountName").add(Projections.property("email"), "email")).setResultTransformer(Transformers.aliasToBean(User.class));
    List res = criteria.list();
    JSONArray array = new JSONArray(res.toArray());
    tx.commit();
    return array.toString();
}

/**
     * Creates and Criterion up to 4 Criterion
     * @param size
     * @param criterion
     * @return
     */
private Criterion logicalExpressionBuilder(int size, Criterion[] criterion) {
    LogicalExpression andExp = null;
    switch(size) {
        case 1:
            return criterion[0];
        case 2:
            andExp = Restrictions.and(criterion[0], criterion[1]);
            break;
        case 3:
            andExp = Restrictions.and(criterion[0], Restrictions.and(criterion[1], criterion[2]));
            break;
        case 4:
            andExp = Restrictions.and(Restrictions.and(criterion[0], criterion[1]), Restrictions.and(criterion[2], criterion[3]));
            break;
        default:
            throw new IllegalArgumentException("You can only split on max 4 words");
    }
    return andExp;
}

/**
     * Convenicence method for subclasses to find domain objects that match the list of Criterion's in the given order
     *
     * @param criterionList List of {@link Criterion}'s
     * @param orderList List of {@link Order}'s
     * @return Sorted list of domain objects
     */
@SuppressWarnings("unchecked")
protected List<T> findByCriteriaOrdered(List<Criterion> criterionList, List<Order> orderList) {
    Criteria crit = portalSessionFactory.getCurrentSession().createCriteria(getPersistentClass());
    for (Criterion c : criterionList) {
        crit.add(c);
    }
    for (Order order : orderList) {
        crit.addOrder(order);
    }
    crit.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);
    return crit.list();
}

protected Criterion createCriterion(String field, Object value, ComparisonType comparisonType) {
    ComparisonType comparison = comparisonType == null ? ComparisonType.EQUAL : comparisonType;
    Criterion result;
    switch(comparison) {
        case EQUAL:
            result = Restrictions.eq(field, value);
            break;
        case NOT_EQUAL:
            result = Restrictions.ne(field, value);
            break;
        case IS_NULL:
            result = Restrictions.isNull(field);
            break;
        case IS_NOT_NULL:
            result = Restrictions.isNotNull(field);
            break;
        default:
            throw new IllegalArgumentException();
    }
    return result;
}

@Before
public void superInit() {
    pluginStateResolver = Mockito.mock(PluginStateResolver.class);
    given(pluginStateResolver.isEnabled(Mockito.anyString())).willReturn(true);
    given(pluginStateResolver.isEnabled(Mockito.any(Plugin.class))).willReturn(true);
    given(pluginStateResolver.isEnabledOrEnabling(Mockito.anyString())).willReturn(true);
    given(pluginStateResolver.isEnabledOrEnabling(Mockito.any(Plugin.class))).willReturn(true);
    PluginUtilsService pluginUtilsService = new PluginUtilsService(pluginStateResolver);
    pluginUtilsService.init();
    validationService = new ValidationServiceImpl();
    entityService = new EntityServiceImpl();
    ReflectionTestUtils.setField(entityService, "hibernateService", hibernateService);
    priorityService = new PriorityServiceImpl();
    ReflectionTestUtils.setField(priorityService, "entityService", entityService);
    ReflectionTestUtils.setField(priorityService, "hibernateService", hibernateService);
    dataAccessService = new DataAccessServiceImpl();
    ReflectionTestUtils.setField(dataAccessService, "entityService", entityService);
    ReflectionTestUtils.setField(dataAccessService, "priorityService", priorityService);
    ReflectionTestUtils.setField(dataAccessService, "validationService", validationService);
    ReflectionTestUtils.setField(dataAccessService, "hibernateService", hibernateService);
    AnnotationTransactionAspect.aspectOf();
    SearchRestrictions restrictions = new SearchRestrictions();
    ReflectionTestUtils.setField(restrictions, "dataAccessService", dataAccessService);
    buildParentDataDefinition();
    buildTreeDataDefinition();
    buildDataDefinition();
    given(hibernateService.getCurrentSession()).willReturn(session);
    given(session.createCriteria(any(Class.class))).willReturn(criteria);
    given(criteria.add(any(Criterion.class))).willReturn(criteria);
    given(criteria.setProjection(any(Projection.class))).willReturn(criteria);
    given(criteria.setFirstResult(anyInt())).willReturn(criteria);
    given(criteria.setMaxResults(anyInt())).willReturn(criteria);
    given(criteria.addOrder(any(Order.class))).willReturn(criteria);
}

/**
     * Create a new <tt>Criterion</tt> using the specified filter.
     * 
     * @param filter
     *            the filter
     * 
     * @return the <tt>Criterion</tt>
     * 
     * @throws UnsupportedTimeException
     *             if the value and property combination is not applicable for
     *             this restriction
     * @throws UnsupportedValueReferenceException
     *             if the {@link TemporalFilter#getValueReference() value
     *             reference} can not be decoded
     * @throws UnsupportedOperatorException
     *             if no restriction definition for the {@link TimeOperator} is
     *             found
     */
public static Criterion filter(TemporalFilter filter) throws UnsupportedTimeException, UnsupportedValueReferenceException, UnsupportedOperatorException {
    TimePrimitiveFieldDescriptor property = getFields(filter.getValueReference());
    Time value = filter.getTime();
    switch(filter.getOperator()) {
        case TM_Before:
            return before(property, value);
        case TM_After:
            return after(property, value);
        case TM_Begins:
            return begins(property, value);
        case TM_Ends:
            return ends(property, value);
        case TM_EndedBy:
            return endedBy(property, value);
        case TM_BegunBy:
            return begunBy(property, value);
        case TM_During:
            return during(property, value);
        case TM_Equals:
            return tEquals(property, value);
        case TM_Contains:
            return contains(property, value);
        case TM_Overlaps:
            return overlaps(property, value);
        case TM_Meets:
            return meets(property, value);
        case TM_MetBy:
            return metBy(property, value);
        case TM_OverlappedBy:
            return overlappedBy(property, value);
        default:
            throw new UnsupportedOperatorException(filter.getOperator());
    }
}

/**
	 * 按Criteria分页查询.
	 * 
	 * @param page 分页�数.
	 * @param criterions 数���的Criterion.
	 * 
	 * @return 分页查询结果.附带结果列表�所有查询输入�数.
	 */
@SuppressWarnings("unchecked")
public Page<T> findPage(final Page<T> page, final Criterion... criterions) {
    Assert.notNull(page, "page�能为空");
    Criteria c = createCriteria(criterions);
    if (page.isAutoCount()) {
        long totalCount = countCriteriaResult(c);
        page.setTotalCount(totalCount);
    }
    setPageParameterToCriteria(c, page);
    List result = c.list();
    page.setResult(result);
    return page;
}

/**
	 * 按Criteria分页查询.
	 * 
	 * @param page 分页�数.
	 * @param criterions 数���的Criterion.
	 * 
	 * @return 分页查询结果.附带结果列表�所有查询输入�数.
	 */
@SuppressWarnings({ "unchecked", "rawtypes" })
public Page<T> findPage(final Page<T> page, final Criterion... criterions) {
    Assert.notNull(page, "page�能为空");
    /**
		 *	ä¿?存查询æ?¡ä»¶ä¸­å¯¹è±¡åˆ«å??，以å…?é‡?å¤?添加导致Hibernate报异常.
		 */
    Set<String> aliases = new HashSet<String>();
    Criteria c = createCriteria(criterions);
    if (page.isAutoCount()) {
        long totalCount = countCriteriaResult(c);
        page.setTotalCount(totalCount);
    }
    setPageParameterToCriteria(c, page, aliases);
    List result = c.list();
    page.setResult(result);
    return page;
}

private Criterion createCriterion(String propertyName, SearchFilterPredicate predicate) {
    switch(predicate.getOperator()) {
        case eq:
            return Restrictions.eq(propertyName, predicate.getLowValue());
        case ne:
            return Restrictions.ne(propertyName, predicate.getLowValue());
        case gt:
            return Restrictions.gt(propertyName, predicate.getLowValue());
        case ge:
            return Restrictions.ge(propertyName, predicate.getLowValue());
        case lt:
            return Restrictions.lt(propertyName, predicate.getLowValue());
        case le:
            return Restrictions.le(propertyName, predicate.getLowValue());
        default:
            throw new IllegalArgumentException("Search filtering for operator '" + predicate.getOperator() + "' is not yet supported");
    }
}

@Transactional
@RequestMapping(value = "/pages/{pageNumber}", method = RequestMethod.GET)
public List<UserDTO> getUsersPaging(@PathVariable Integer pageNumber, @RequestParam Integer size, @RequestParam(required = false) String name, @RequestParam(required = false) String surname, @RequestParam(required = false) String phone, @RequestParam(required = false) String email, @RequestParam(required = false) boolean isReversed, @RequestParam(required = false) String sortParam) {
    this.size = 0;
    List<User> users = new ArrayList<>();
    Session session = sessionFactory.openSession();
    Criteria criteria = session.createCriteria(User.class);
    Criterion nameCriterion, surnameCriterion, phoneCriterion, emailCriterion;
    List<User> userList = new ArrayList<>();
    if (name != null) {
        nameCriterion = userSearch.searchByName(name);
        criteria.add(nameCriterion);
    }
    if (surname != null) {
        surnameCriterion = userSearch.searchBySurname(surname);
        criteria.add(surnameCriterion);
    }
    if (phone != null) {
        phoneCriterion = userSearch.searchByPhone(phone);
        criteria.add(phoneCriterion);
    }
    if (email != null) {
        emailCriterion = userSearch.searchByEmail(email);
        criteria.add(emailCriterion);
    }
    criteria.setMaxResults(size);
    criteria.setFirstResult(pageNumber);
    if (sortParam != null) {
        Sort sort = new Sort(new SortField(sortParam, SortField.Type.STRING));
        if (isReversed) {
            criteria.addOrder(Order.desc(sortParam));
        } else
            criteria.addOrder(Order.asc(sortParam));
    }
    this.size = criteria.list().size();
    if (this.size < size) {
        this.size = 1;
    } else
        this.size = this.size / size;
    users = criteria.list();
    session.close();
    if (name == null && surname == null && email == null && phone == null) {
        Page<User> page = userService.getUsers(pageNumber, size, sortParam, isReversed);
        users = page.getContent();
        this.size = page.getTotalPages();
    }
    List<UserDTO> userDTOs = new ArrayList<>();
    for (User user : users) {
        userDTOs.add(new UserDTO(user));
    }
    return userDTOs;
}

/**
     * Creates a criterion on the size of a collection.
     * <p>
     * For example: <code>
     * createSizeCriterion(GREATER, "offers", 12)
     * </code> Will select elements which has more than 12 offers associated
     * with.
     * </p>
     * 
     * @param cmp the comparator
     * @param element the element name. It must be a collection (a mapped
     *            association).
     * @param nb the number on which we compare the size of the collection
     * @return the criterion
     */
protected final Criterion createSizeCriterion(final Comparator cmp, final String element, final int nb) {
    switch(cmp) {
        case EQUAL:
            return Restrictions.sizeEq(element, nb);
        case LESS:
            return Restrictions.sizeLt(element, nb);
        case LESS_EQUAL:
            return Restrictions.sizeLe(element, nb);
        case GREATER:
            return Restrictions.sizeGt(element, nb);
        case GREATER_EQUAL:
            return Restrictions.sizeGe(element, nb);
        default:
            return Restrictions.sizeEq(element, nb);
    }
}

/**
   * Construct a criterion from a filter pattern.
   *
   * A Pattern is constructed from the given filter, as per AWS:
   *
   *  Filters support the following wildcards:
   *
   *    *: Matches zero or more characters
   *    ?: Matches exactly one character
   *
   *   Your search can include the literal values of the wildcard characters; you just need to escape
   *   them with a backslash before the character. For example, a value of \*amazon\?\\ searches for
   *   the literal string *amazon?\.
   *
   * Wildcards are translated for use with 'like':
   *
   *   % : Matches zero or more characters
   *   _: Matches exactly one character
   *
   * In both cases wildcards can be escaped (to allow literal values) with a backslash (\).
   *
   * Translation of wildcards for direct DB filtering must support literal values from each grammar.
   */
private Criterion buildRestriction(final String property, final Object persistentValue) {
    final Object valueObject;
    if (persistentValue instanceof String) {
        final String value = persistentValue.toString();
        final StringBuilder likeValueBuilder = new StringBuilder();
        translateWildcards(value, likeValueBuilder, "_", "%", SyntaxEscape.Like);
        final String likeValue = likeValueBuilder.toString();
        if (!value.equals(likeValue)) {
            // even if no regex, may contain \ escapes that must be removed
            return Restrictions.like(property, likeValue);
        }
        valueObject = persistentValue;
    } else {
        valueObject = persistentValue;
    }
    if (persistentValue instanceof Collection) {
        if (((Collection) persistentValue).isEmpty()) {
            // always false
            return Restrictions.not(Restrictions.conjunction());
        } else {
            return Restrictions.in(property, (Collection) persistentValue);
        }
    } else {
        return Restrictions.eq(property, valueObject);
    }
}

private Criteria createCriteria(Session session) {
    Criteria result = session.createCriteria(persistentClass);
    aliases.addToCriteria(result);
    for (Criterion restriction : restrictions) {
        result.add(restriction);
    }
    if (fetchJoinPaths != null) {
        for (String associationPath : fetchJoinPaths) {
            result.setFetchMode(associationPath, FetchMode.JOIN);
        }
    }
    return result;
}

@Override
public List<T> findByCriteria(Criterion... criterion) throws GPDAOException {
    try {
        Criteria criteria = getSession().createCriteria(persistentClass);
        Arrays.stream(criterion).forEach( c -> criteria.add(c));
        return criteria.list();
    } catch (HibernateException ex) {
        logger.error("HibernateException : " + ex);
        throw new GPDAOException(ex);
    }
}

protected List<T> findAllByCriteriaAndOrder(Order order, Criterion... criterions) {
    List<T> ts = null;
    try {
        Session session = this.getCurrentSession();
        Transaction transaction = session.beginTransaction();
        Criteria criteria = createCriteria(session, criterions);
        if (order != null) {
            criteria.addOrder(order);
        }
        ts = criteria.list();
        transaction.commit();
    } catch (Exception e) {
        LOG.error("Error while findAllByCriteria Entities and Order them. M: " + e.getMessage() + " C: " + e.getCause(), e);
    }
    return ts;
}

/**
     * 分页查询函数，根�entityClass和page�数进行查询.
     * 
     * @param <T>
     *            实体类型
     * @param entityClass
     *            实体类型
     * @param page
     *            分页里包�的���数
     * @param criterions
     *            �件
     * @return �总记录数和当�页数�的Page对象.
     */
@Transactional(readOnly = true)
public <T> Page pagedQuery(Class<T> entityClass, Page page, Criterion... criterions) {
    Criteria criteria = createCriteria(entityClass, criterions);
    if (page.isOrderEnabled()) {
        criteria = createCriteria(entityClass, criterions);
        for (int i = 0; i < page.getOrderBys().size(); i++) {
            String orderBy = page.getOrderBys().get(i);
            String order = page.getOrders().get(i);
            if ("ASC".equals(page.getOrders().get(i))) {
                criteria.addOrder(Order.asc(orderBy));
            } else {
                criteria.addOrder(Order.desc(orderBy));
            }
        }
    }
    Page resultPage = this.pagedQuery(criteria, page.getPageNo(), page.getPageSize());
    resultPage.setOrderBys(page.getOrderBys());
    resultPage.setOrders(page.getOrders());
    return resultPage;
}

@PrincipalSearch
public List<MusicianContact> searchMusicianContacts(MusicianAddressBook addressBook, PrincipalSearchCriteria crit) {
    if (crit.getCuType().equals(PrincipalSearchCriteria.CU_TYPE_INDIVIDUAL)) {
        Criteria c = SessionManager.session().createCriteria(MusicianContact.class);
        Junction combine;
        if (crit.getTest().equals(PrincipalSearchCriteria.TestType.ALL)) {
            combine = Restrictions.disjunction();
        } else {
            combine = Restrictions.conjunction();
        }
        for (PrincipalSearchCriteria.SearchItem searchItem : crit.getSearchItems()) {
            Criterion r = newCriterion(searchItem);
            if (r != null) {
                combine.add(r);
            }
        }
        c.add(combine);
    }
    return null;
}

@PrincipalSearch
public List<MusicianContact> searchMusicianContacts(MusicianAddressBook addressBook, PrincipalSearchCriteria crit) {
    if (crit.getCuType().equals(PrincipalSearchCriteria.CU_TYPE_INDIVIDUAL)) {
        Criteria c = SessionManager.session().createCriteria(MusicianContact.class);
        Junction combine;
        if (crit.getTest().equals(PrincipalSearchCriteria.TestType.ALL)) {
            combine = Restrictions.disjunction();
        } else {
            combine = Restrictions.conjunction();
        }
        for (PrincipalSearchCriteria.SearchItem searchItem : crit.getSearchItems()) {
            Criterion r = newCriterion(searchItem);
            if (r != null) {
                combine.add(r);
            }
        }
        c.add(combine);
    }
    return null;
}

private void buildCriteria(final Criteria criteria) {
    for (final Object obj : filterSettings) {
        if (obj instanceof Criterion) {
            criteria.add((Criterion) obj);
        } else if (obj instanceof Order) {
            criteria.addOrder((Order) obj);
        } else if (obj instanceof Alias) {
            final Alias alias = (Alias) obj;
            criteria.createAlias(alias.arg0, alias.arg1, alias.joinType);
        } else if (obj instanceof QueryFilter) {
            final QueryFilter filter = (QueryFilter) obj;
            Criteria subCriteria;
            if (StringUtils.isEmpty(filter.getAlias()) == true) {
                subCriteria = criteria.createCriteria(filter.getName());
            } else {
                subCriteria = criteria.createCriteria(filter.getName(), filter.getAlias());
            }
            filter.buildCriteria(subCriteria);
        }
    }
    if (associationPath != null) {
        criteria.setFetchMode(associationPath, fetchMode);
    }
    if (maxResults > 0) {
        criteria.setMaxResults(maxResults);
    }
}

@Override
public List<String> findClusterByStatus(EnumSet<ClusterStatus> statusSet) {
    List<String> clusterNames = new ArrayList<String>();
    if (statusSet != null && statusSet.size() > 0) {
        List<Criterion> criterionList = new ArrayList<Criterion>();
        for (ClusterStatus status : statusSet) {
            criterionList.add(Restrictions.eq("status", status));
        }
        Criterion finalCriterion = Restrictions.or(criterionList.toArray(new Criterion[criterionList.size()]));
        List<ClusterEntity> clusterList = findByCriteria(finalCriterion);
        if (clusterList != null) {
            for (ClusterEntity cluster : clusterList) {
                clusterNames.add(cluster.getName());
            }
        }
    }
    return clusterNames;
}

private static Criterion walkConjunction(WhereConjunction whereConjunction, WhereOperandTransformer transformer) {
    if ((whereConjunction == null) || whereConjunction.isEmpty()) {
        return null;
    }
    LinkedList<Criterion> criterionList = new LinkedList<>();
    for (WhereCriterion whereCriterion : whereConjunction.getCriteria()) {
        switch(whereCriterion.getCriterionType()) {
            case CONJUNCTION:
                Criterion walkedCriterion;
                if ((walkedCriterion = walkConjunction((WhereConjunction) whereCriterion, transformer)) != null) {
                    criterionList.add(walkedCriterion);
                }
                break;
            case FIELD:
                criterionList.add(walkField((WhereField) whereCriterion, transformer));
                break;
            default:
                throw new UnknownSwitchCaseException(whereCriterion.getCriterionType().name());
        }
    }
    if (criterionList.isEmpty()) {
        return null;
    } else {
        Criterion[] criteria;
        criteria = new Criterion[criterionList.size()];
        criterionList.toArray(criteria);
        switch(whereConjunction.getConjunctionType()) {
            case AND:
                return Restrictions.and(criteria);
            case OR:
                return Restrictions.or(criteria);
            default:
                throw new UnknownSwitchCaseException(whereConjunction.getConjunctionType().name());
        }
    }
}

public Criteria toCriteria(SearchCriteria<?> sp, Session session, boolean sort, boolean paginate) {
    final Criteria criteria = session.createCriteria(sp.getType());
    criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);
    //If paginate is specified, then paginate
    if (paginate && sp.getFirstResult() >= 0 && sp.getMaxResults() > 0) {
        criteria.setFirstResult(sp.getFirstResult());
        criteria.setMaxResults(sp.getMaxResults());
    }
    Context context = new Context();
    loadPropertyValues(sp.getEntity(), null, session, context);
    ICondition condition = sp.getCondition();
    if (condition == null) {
        List<ICondition> conditions = new ArrayList<ICondition>();
        for (String propertyName : context.getValueMap().keySet()) {
            conditions.add(Condition.eq(propertyName));
        }
        condition = Condition.and(conditions.toArray(new ICondition[] {}));
    }
    if (condition != null) {
        Criterion c = applyCondition(criteria, condition, sp.getSearchType(), context);
        if (c != null) {
            criteria.add(c);
        }
    }
    if (sort) {
        Map<String, Boolean> sorting = sp.getOrder();
        if (sorting == null || sorting.size() == 0) {
            DefaultOrder annotation = sp.getType().getAnnotation(DefaultOrder.class);
            if (annotation != null) {
                String colAlias = getPropertyName(criteria, annotation.column(), context);
                criteria.addOrder(annotation.ascending() ? Order.asc(colAlias) : Order.desc(colAlias));
            }
        } else {
            for (String col : sorting.keySet()) {
                boolean order = sorting.get(col);
                String colAlias = getPropertyName(criteria, col, context);
                criteria.addOrder(order ? Order.asc(colAlias) : Order.desc(colAlias));
            }
        }
    }
    return criteria;
}

/**
    * Helper method that simplifies data loopups based on a criterion.
    *
    * @param criterion
    * @return
    */
@SuppressWarnings("unchecked")
protected List<T> findByCriterion(Criterion criterion) {
    Criteria criteria = getCurrentSession().createCriteria(_class);
    if (criterion != null) {
        criteria.add(criterion);
    }
    // Return distinct root entities. If not set, we can get duplicate rows.
    criteria.setResultTransformer(CriteriaSpecification.DISTINCT_ROOT_ENTITY);
    return criteria.list();
}

@Override
@SuppressWarnings("unchecked")
public List<Password> findPasswordByFuzzySearch(String query, User user, boolean activeOnly, Collection<Tag> tags, Match tagMatch) {
    //kludge to not use ilike on text column if MSSQL
    boolean isMSSQL = ((SessionFactoryImpl) getSessionFactory()).getDialect().toString().contains("SQLServer");
    Criteria crit = getSession().createCriteria(getPersistentClass());
    crit.setFetchMode("tags", FetchMode.JOIN);
    crit.add(Restrictions.or(Restrictions.or(Restrictions.ilike("name", query, MatchMode.ANYWHERE), Restrictions.ilike("username", query, MatchMode.ANYWHERE)), isMSSQL ? Restrictions.like("notes", query, MatchMode.ANYWHERE) : Restrictions.ilike("notes", query, MatchMode.ANYWHERE)));
    if (activeOnly) {
        crit.add(Restrictions.eq("active", true));
    }
    Criterion tagsCriterion = null;
    for (Tag tag : tags) {
        Criterion tc = Restrictions.sqlRestriction("? in (select tag_id from password_tags where password_id = {alias}.id)", tag.getId(), StandardBasicTypes.LONG);
        if (null == tagsCriterion) {
            tagsCriterion = tc;
        } else {
            tagsCriterion = tagMatch.equals(Match.AND) ? Restrictions.and(tagsCriterion, tc) : Restrictions.or(tagsCriterion, tc);
        }
    }
    if (tagsCriterion != null)
        crit.add(tagsCriterion);
    crit.createAlias("permissions", "pm");
    crit.add(Restrictions.in("pm.accessLevel", new String[] { AccessLevel.READ.name(), AccessLevel.WRITE.name(), AccessLevel.GRANT.name() }));
    if (!authorizer.isAuthorized(user, Function.BYPASS_PASSWORD_PERMISSIONS.name())) {
        DetachedCriteria groupQuery = DetachedCriteria.forClass(Group.class);
        groupQuery.setProjection(Projections.id());
        groupQuery.createCriteria("users", "u").add(Restrictions.eq("u.id", user.getId()));
        crit.add(Restrictions.or(Restrictions.eq("pm.subject", user), Subqueries.propertyIn("pm.subject", groupQuery)));
    }
    crit.addOrder(Order.asc("name"));
    crit.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);
    return crit.list();
}

protected void appendPropertyCondition(String propertyName, Object propertyValue, Criteria criteria, CriteriaQuery cq, StringBuffer buf) throws HibernateException {
    Criterion criterion;
    if (propertyValue != null) {
        boolean isString = propertyValue instanceof String;
        SimpleExpression se = isLikeEnabled && isString ? Restrictions.like(propertyName, propertyValue) : Restrictions.eq(propertyName, propertyValue);
        criterion = isIgnoreCaseEnabled && isString ? se.ignoreCase() : se;
    } else {
        criterion = Restrictions.isNull(propertyName);
    }
    String critCondition = criterion.toSqlString(criteria, cq);
    if (buf.length() > 1 && critCondition.trim().length() > 0)
        buf.append(" and ");
    buf.append(critCondition);
}

/*
     * (non-Javadoc)
     * @see com.abiquo.networking.InetManager#requestIPAddressVM(java.lang.String, java.lang.String)
     */
@Override
public IPAddress requestIPAddressVM(Integer dataCenterId, String virtualMachineId) {
    IPAddress reqAddress = null;
    VirtualMachineIPHB reqVM = null;
    // check the correct parameters
    if (dataCenterId == null || virtualMachineId == null) {
        return null;
    }
    // Check if datacenter exists
    DatacentersIPHB reqDatacenter = (DatacentersIPHB) datacentersDAO.findById(dataCenterId);
    if (reqDatacenter == null) {
        return null;
    }
    // Check if virtual machine exists
    reqVM = (VirtualMachineIPHB) virtualMachineDAO.findById(virtualMachineId);
    if (reqVM != null) {
        // Check if virtual machine belongs to the given datacenter
        if (reqVM.getDatacenterId().compareTo(reqDatacenter.getId()) == 0) {
            reqAddress = IPAddress.newIPAddress(reqVM.getVirtualIP());
        }
    // else will return null
    } else {
        // getting all the virtual machines filtering by datacenter Id
        Criterion filter = Restrictions.like("datacenterId", dataCenterId);
        List<VirtualMachineIPHB> listVM = virtualMachineDAO.findByCriteria(filter);
        // check if all the nodes of the datacenter are busy
        if (listVM.size() == reqDatacenter.getNumNodes()) {
            System.out.println("No more virtual machines available in this Datacenter!");
            return null;
        }
        // first, we set the list of IP's
        List<String> listIP = new ArrayList<String>();
        for (int i = 0; i < listVM.size(); i++) {
            listIP.add(listVM.get(i).getVirtualIP());
        }
        // initialize the variables to assign new IP
        boolean registeredIP = true;
        Integer numberIPs = reqDatacenter.getNumNodes();
        IPAddress nextIP = IPAddress.newIPAddress(reqDatacenter.getFirstIP()).nextIPAddress();
        while (numberIPs > 0 && registeredIP) {
            if (!listIP.contains(nextIP.toString())) {
                reqAddress = nextIP;
                // set the entity to store
                reqVM = new VirtualMachineIPHB();
                reqVM.setId(virtualMachineId);
                reqVM.setDatacenterId(dataCenterId);
                reqVM.setVirtualIP(reqAddress.toString());
                // store it
                virtualMachineDAO.makePersistent(reqVM);
                // set the variable to exit the bucle
                registeredIP = false;
            } else {
                nextIP = nextIP.nextIPAddress();
                numberIPs--;
            }
        }
    }
    return reqAddress;
}

@Override
public void outADuringExpr(ADuringExpr node) {
    PTimespanLiteral timespan = node.getTimeSpan();
    Criterion greaterThan;
    Criterion lowerThan;
    if (timespan instanceof AFromToTimespanLiteral) {
        AFromToTimespanLiteral fromToTimespan = (AFromToTimespanLiteral) timespan;
        greaterThan = Restrictions.gt(node.getAttr().toString().trim(), parseDate(fromToTimespan.getFrom().getText().trim()));
        lowerThan = Restrictions.lt(node.getAttr().toString().trim(), parseDate(fromToTimespan.getTo().getText().trim()));
    } else if (timespan instanceof AFromDurationTimespanLiteral) {
        AFromDurationTimespanLiteral fromDurationTimespan = (AFromDurationTimespanLiteral) timespan;
        Date fromDate = parseDate(fromDurationTimespan.getFrom().getText().trim());
        Duration duration = (Duration) translatedLiterals.get(fromDurationTimespan.getDuration());
        // Calculate to 'to' date
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(fromDate);
        calendar.add(Calendar.YEAR, duration.getYears());
        calendar.add(Calendar.MONTH, duration.getMonths());
        calendar.add(Calendar.DATE, duration.getDays());
        calendar.add(Calendar.HOUR, duration.getHours());
        calendar.add(Calendar.MINUTE, duration.getMinutes());
        calendar.add(Calendar.SECOND, duration.getSeconds());
        Date toDate = calendar.getTime();
        greaterThan = Restrictions.gt(node.getAttr().toString().trim(), fromDate);
        lowerThan = Restrictions.lt(node.getAttr().toString().trim(), toDate);
    } else {
        // if (timespan instanceof ADurationToTimespanLiteral)
        greaterThan = null;
        lowerThan = null;
    }
    Criterion combined = Restrictions.and(greaterThan, lowerThan);
    translatedExpressions.put(node, combined);
}

private static void populateHibernateDetachedCriteria(AbstractHibernateQuery query, org.hibernate.criterion.DetachedCriteria detachedCriteria, QueryableCriteria<?> queryableCriteria) {
    List<org.grails.datastore.mapping.query.Query.Criterion> criteriaList = queryableCriteria.getCriteria();
    for (org.grails.datastore.mapping.query.Query.Criterion criterion : criteriaList) {
        Criterion hibernateCriterion = HibernateQuery.HIBERNATE_CRITERION_ADAPTER.toHibernateCriterion(query, criterion, null);
        if (hibernateCriterion != null) {
            detachedCriteria.add(hibernateCriterion);
        }
    }
    List<org.grails.datastore.mapping.query.Query.Projection> projections = queryableCriteria.getProjections();
    ProjectionList projectionList = Projections.projectionList();
    for (org.grails.datastore.mapping.query.Query.Projection projection : projections) {
        Projection hibernateProjection = new HibernateProjectionAdapter(projection).toHibernateProjection();
        if (hibernateProjection != null) {
            projectionList.add(hibernateProjection);
        }
    }
    detachedCriteria.setProjection(projectionList);
}

@Test
public void testPaginatedQueryWithoutCriterionWithLimit() {
    int numberOfElements = 283;
    String identifier = "testPaginatedQueryWithoutCriterionWithLimit";
    generateDataTest(identifier, numberOfElements);
    //
    DataField[] structure = dataField.toArray(new DataField[] {});
    HibernateStorage storage = HibernateStorage.newInstance(dbInfo, identifier, dataField.toArray(new DataField[] {}), false);
    assertNotNull(storage);
    //
    int[] pageSizes = new int[] { 1, 11, numberOfElements / 2, numberOfElements / 3, numberOfElements / 3 - 1, numberOfElements / 3 + 1, numberOfElements - 1, numberOfElements + 1, numberOfElements * 2 };
    //
    for (int pageSize : pageSizes) {
        System.out.println("testPaginatedQueryWithoutCriterionWithLimit ASC with pageSize: " + pageSize);
        // Set the limit to a fixed number: 1
        checkQueryResult(storage.getStreamElements(pageSize, Order.asc("timed"), new Criterion[] {}, 1), 1, 1);
        // Set the limit to a fixed number: 11
        checkQueryResult(storage.getStreamElements(pageSize, Order.asc("timed"), new Criterion[] {}, 11), 1, 11);
        // Set the limit to numberOfElements/10+1
        checkQueryResult(storage.getStreamElements(pageSize, Order.asc("timed"), new Criterion[] {}, numberOfElements / 10 + 1), 1, numberOfElements / 10 + 1);
        // Set the limit to numberOfElements/10-1
        checkQueryResult(storage.getStreamElements(pageSize, Order.asc("timed"), new Criterion[] {}, numberOfElements / 10 - 1), 1, numberOfElements / 10 - 1);
        // Set the limit to 0
        checkQueryResult(storage.getStreamElements(pageSize, Order.asc("timed"), new Criterion[] {}, 0), -1, -1);
    }
    //
    for (int pageSize : pageSizes) {
        System.out.println("testPaginatedQueryWithoutCriterionWithLimit DESC with pageSize: " + pageSize);
        // Set the limit to a fixed number: 1
        checkQueryResult(storage.getStreamElements(pageSize, Order.desc("timed"), new Criterion[] {}, 1), numberOfElements, numberOfElements);
        // Set the limit to a fixed number: 11
        checkQueryResult(storage.getStreamElements(pageSize, Order.desc("timed"), new Criterion[] {}, 11), numberOfElements, numberOfElements - 10);
        // Set the limit to numberOfElements/10+1
        checkQueryResult(storage.getStreamElements(pageSize, Order.desc("timed"), new Criterion[] {}, numberOfElements / 10 + 1), numberOfElements, numberOfElements - (numberOfElements / 10 + 1) + 1);
        // Set the limit to numberOfElements/10-1
        checkQueryResult(storage.getStreamElements(pageSize, Order.desc("timed"), new Criterion[] {}, numberOfElements / 10 - 1), numberOfElements, numberOfElements - (numberOfElements / 10 - 1) + 1);
        // Set the limit to 0
        checkQueryResult(storage.getStreamElements(pageSize, Order.desc("timed"), new Criterion[] {}, 0), -1, -1);
    }
}

/**
	 * Returns a {@link Criterion} for fetching all the given entity infos. If needed, this criterion will contain a
	 * {@link Disjunction} for fetching the infos in chunks of {@link CriteriaObjectInitializer#MAX_IN_CLAUSE} elements.
	 */
private Criterion getIdListCriterion(List<EntityInfo> entityInfos, ObjectInitializationContext objectInitializationContext) {
    DocumentBuilderIndexedEntity documentBuilder = getDocumentBuilder(entityInfos.iterator().next().getClazz(), objectInitializationContext.getExtendedSearchIntegrator());
    String idName = documentBuilder.getIdPropertyName();
    Disjunction disjunction = Restrictions.disjunction();
    int maxResults = entityInfos.size();
    int loop = maxResults / MAX_IN_CLAUSE;
    boolean exact = maxResults % MAX_IN_CLAUSE == 0;
    if (!exact) {
        loop++;
    }
    for (int index = 0; index < loop; index++) {
        int max = Math.min(index * MAX_IN_CLAUSE + MAX_IN_CLAUSE, maxResults);
        List<Serializable> ids = new ArrayList<>(max - index * MAX_IN_CLAUSE);
        for (int entityInfoIndex = index * MAX_IN_CLAUSE; entityInfoIndex < max; entityInfoIndex++) {
            ids.add(entityInfos.get(entityInfoIndex).getId());
        }
        disjunction.add(Restrictions.in(idName, ids));
    }
    return disjunction;
}

public List<Concept> searchInvestigation(String text) throws DAOException {
    Criteria criteria = sessionFactory.getCurrentSession().createCriteria(Concept.class);
    ConceptClass cct = Context.getConceptService().getConceptClassByName("Test");
    ConceptClass ccl = Context.getConceptService().getConceptClassByName("LabSet");
    criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);
    criteria.add(Expression.eq("retired", false));
    Criterion lhs = Restrictions.eq("conceptClass", cct);
    Criterion rhs = Restrictions.eq("conceptClass", ccl);
    LogicalExpression orExp = Restrictions.or(lhs, rhs);
    criteria.add(orExp);
    if (StringUtils.isNotBlank(text)) {
        criteria.createAlias("names", "names");
        criteria.add(Expression.like("names.name", text, MatchMode.ANYWHERE));
    }
    return criteria.list();
}

@SuppressWarnings("ConstantConditions")
private boolean completeCriteria(EnhancedDetachedCriteria rootCriteria, DetachedCriteria currentCriteria, String path, IQueryComponent aQueryComponent, Map<String, Object> context) {
    boolean abort = false;
    IComponentDescriptor<?> componentDescriptor = aQueryComponent.getQueryDescriptor();
    if (aQueryComponent instanceof ComparableQueryStructure) {
        completeCriteria(currentCriteria, createComparableQueryStructureRestriction(path, (ComparableQueryStructure) aQueryComponent, componentDescriptor, aQueryComponent, context));
    } else {
        String translationsPath = AbstractComponentDescriptor.getComponentTranslationsDescriptorTemplate().getName();
        String translationsAlias = currentCriteria.getAlias() + "_" + componentDescriptor.getComponentContract().getSimpleName() + "_" + translationsPath;
        if (componentDescriptor.isTranslatable()) {
            rootCriteria.getSubCriteriaFor(currentCriteria, translationsPath, translationsAlias, JoinType.LEFT_OUTER_JOIN);
        }
        for (Map.Entry<String, Object> property : aQueryComponent.entrySet()) {
            String propertyName = property.getKey();
            Object propertyValue = property.getValue();
            IPropertyDescriptor propertyDescriptor = componentDescriptor.getPropertyDescriptor(propertyName);
            if (propertyDescriptor != null) {
                boolean isEntityRef = false;
                if (componentDescriptor.isEntity() && aQueryComponent.containsKey(IEntity.ID)) {
                    isEntityRef = true;
                }
                if ((!PropertyViewDescriptorHelper.isComputed(componentDescriptor, propertyName) || (propertyDescriptor instanceof IStringPropertyDescriptor && ((IStringPropertyDescriptor) propertyDescriptor).isTranslatable())) && (!isEntityRef || IEntity.ID.equals(propertyName))) {
                    String prefixedProperty = PropertyHelper.toJavaBeanPropertyName(propertyName);
                    if (path != null) {
                        prefixedProperty = path + "." + prefixedProperty;
                    }
                    if (propertyValue instanceof IEntity) {
                        if (!((IEntity) propertyValue).isPersistent()) {
                            abort = true;
                        } else {
                            completeCriteria(currentCriteria, Restrictions.eq(prefixedProperty, propertyValue));
                        }
                    } else if (propertyValue instanceof Boolean && (isTriStateBooleanSupported() || (Boolean) propertyValue)) {
                        completeCriteria(currentCriteria, Restrictions.eq(prefixedProperty, propertyValue));
                    } else if (IEntity.ID.equalsIgnoreCase(propertyName)) {
                        completeCriteria(currentCriteria, createIdRestriction(propertyDescriptor, prefixedProperty, propertyValue, componentDescriptor, aQueryComponent, context));
                    } else if (propertyValue instanceof String) {
                        completeCriteriaWithTranslations(currentCriteria, translationsPath, translationsAlias, property, propertyDescriptor, prefixedProperty, getBackendController(context).getLocale(), componentDescriptor, aQueryComponent, context);
                    } else if (propertyValue instanceof Number || propertyValue instanceof Date) {
                        completeCriteria(currentCriteria, Restrictions.eq(prefixedProperty, propertyValue));
                    } else if (propertyValue instanceof EnumQueryStructure) {
                        completeCriteria(currentCriteria, createEnumQueryStructureRestriction(prefixedProperty, ((EnumQueryStructure) propertyValue)));
                    } else if (propertyValue instanceof IQueryComponent) {
                        IQueryComponent joinedComponent = ((IQueryComponent) propertyValue);
                        if (!isQueryComponentEmpty(joinedComponent, propertyDescriptor)) {
                            if (joinedComponent.isInlineComponent()) /* || path != null */
                            {
                                // the joined component is an inline component so we must use
                                // dot nested properties. Same applies if we are in a nested
                                // path i.e. already on an inline component.
                                abort = abort || completeCriteria(rootCriteria, currentCriteria, prefixedProperty, (IQueryComponent) propertyValue, context);
                            } else {
                                // the joined component is an entity so we must use
                                // nested criteria; unless the autoComplete property
                                // is a special char.
                                boolean digDeeper = true;
                                String autoCompleteProperty = joinedComponent.getQueryDescriptor().getAutoCompleteProperty();
                                if (autoCompleteProperty != null) {
                                    String val = (String) joinedComponent.get(autoCompleteProperty);
                                    if (val != null) {
                                        boolean negate = false;
                                        if (val.startsWith(IQueryComponent.NOT_VAL)) {
                                            val = val.substring(1);
                                            negate = true;
                                        }
                                        if (IQueryComponent.NULL_VAL.equals(val)) {
                                            Criterion crit = Restrictions.isNull(prefixedProperty);
                                            if (negate) {
                                                crit = Restrictions.not(crit);
                                            // there might be other restrictions
                                            // digDeeper = false;
                                            } else {
                                                digDeeper = true;
                                            }
                                            completeCriteria(currentCriteria, crit);
                                        }
                                    }
                                }
                                if (digDeeper) {
                                    DetachedCriteria joinCriteria;
                                    if (isUseAliasesForJoins()) {
                                        joinCriteria = rootCriteria.getSubCriteriaFor(currentCriteria, prefixedProperty, prefixedProperty, JoinType.INNER_JOIN);
                                    } else {
                                        joinCriteria = rootCriteria.getSubCriteriaFor(currentCriteria, prefixedProperty, JoinType.INNER_JOIN);
                                    }
                                    abort = abort || completeCriteria(rootCriteria, joinCriteria, null, joinedComponent, context);
                                }
                            }
                        }
                    } else if (propertyValue != null) {
                        // Unknown property type. Assume equals.
                        completeCriteria(currentCriteria, Restrictions.eq(prefixedProperty, propertyValue));
                    }
                }
            }
        }
    }
    return abort;
}

/*
	 * (non-Javadoc)
	 * 
	 * @see br.gov.serpro.ouvidoria.dao.Dao#find(java.lang.Object)
	 */
public List find(Object[] criteria) throws DaoException {
    if (criteria == null || criteria.length == 0) {
        throw new DaoException("Critério de busca não pode ser nulo.");
    }
    Session session = HibernateSessionFactory.getFactory().getSession();
    try {
        Criteria crit = session.createCriteria(this.clazz);
        for (int i = 0; i < criteria.length; i++) {
            crit.add((Criterion) criteria[i]);
        }
        List list = crit.list();
        return list;
    } catch (HibernateException e) {
        String errorMessage = e.getMessage();
        if (e.getCause() != null && e.getCause().getMessage() != null) {
            errorMessage = e.getCause().getMessage();
        }
        throw new DaoException("DAO FIND ERROR: " + errorMessage, e);
    }
}

/** {@inheritDoc} */
public List<Effort> getTimeEffortsMonthlyView(Integer year, Integer month, TiTAUser user) {
    Calendar start = Calendar.getInstance();
    Calendar end = Calendar.getInstance();
    start.set(year, month, 1);
    end.set(year, month, start.getActualMaximum(Calendar.DAY_OF_MONTH));
    return findByCriteriaOrdered(new Criterion[] { Restrictions.between("date", start.getTime(), end.getTime()), Restrictions.eq("deleted", false), Restrictions.eq("user", user) }, new Order[] { Property.forName("date").asc() }, new String[] {});
}

@SuppressWarnings({ "unchecked" })
public List<Address> searchAddress(Class entityClass, Criterion criterion, List<Order> orders) throws Throwable {
    Session session = ((HibernateSession) manager).getHibernateSession();
    Criteria criteria = session.createCriteria(entityClass);
    if (orders.size() > 0) {
        criteria.setMaxResults(1);
        Iterator<Order> ordIt = orders.iterator();
        while (ordIt.hasNext() == true) {
            criteria.addOrder(ordIt.next());
        }
    } else {
        criteria.addOrder(Order.asc("lastname"));
    }
    criteria.add(criterion).setFetchMode("renewal", FetchMode.SELECT).setFetchMode("specializations", FetchMode.SELECT).setFetchMode("formations", FetchMode.SELECT).setFetchMode("committeemembers", FetchMode.SELECT);
    return criteria.list();
}

// crit is cast as Object because it can be either a Criteria or a DetachedCriteria
// and these two classes do not share any useful interfaces.
private Criterion toCriterion(CriteriaWrapper crit, Predicate pred, String contextAlias) {
    if (pred instanceof AndOrPredicate) {
        return createCriterion(crit, (AndOrPredicate) pred, contextAlias);
    } else if (pred instanceof AnyAllPredicate) {
        return createCriterion(crit, (AnyAllPredicate) pred, contextAlias);
    } else if (pred instanceof BinaryPredicate) {
        return createCriterion(crit, (BinaryPredicate) pred, contextAlias);
    } else if (pred instanceof UnaryPredicate) {
        return createCriterion(crit, (UnaryPredicate) pred, contextAlias);
    } else {
        throw new RuntimeException("Unable to recognize predicate: " + pred.getOperator().getName());
    }
}

/* Binary Operators. */
@Override
public Object visitBinary(BinaryExpression binary_expression, BinaryOperator operator, Object left_side, Object right_side) {
    Criterion criterion;
    switch(operator) {
        case EQ:
        case NE:
        case GT:
        case GE:
        case LT:
        case LE:
            {
                criterion = getCriterionComparative(operator, left_side, right_side);
                break;
            }
        case AND:
        case OR:
            {
                Criterion left = (Criterion) left_side;
                Criterion right = (Criterion) right_side;
                criterion = getCriterionLogical(operator, left, right);
                break;
            }
        default:
            // Other operators are not supported for SQL Statements
            throw new UnsupportedOperationException("Unsupported operator: " + operator.toUriLiteral());
    }
    // return the binary statement
    return criterion;
}

private Criterion getQueryByMonth(Calendar gc) {
    Criterion cr = null;
    gc.add(Calendar.YEAR, 1);
    gc.set(Calendar.DAY_OF_MONTH, 1);
    Date fechaI = gc.getTime();
    gc.set(Calendar.DAY_OF_MONTH, gc.getMaximum(Calendar.DAY_OF_MONTH));
    Date fechaF = gc.getTime();
    cr = Restrictions.between("fechaNacimiento", fechaI, fechaF);
    Calendar tmp = (Calendar) gc.clone();
    tmp.clear();
    tmp.setTime(new Date());
    tmp.add(Calendar.YEAR, -17);
    if (gc.compareTo(tmp) <= 0) {
        return Restrictions.or(cr, getQueryByMonth(gc));
    } else {
        return cr;
    }
}

/**
	 * 按Criteria分页查询.
	 * 
	 * @param page
	 *            分页�数.
	 * @param criterions
	 *            数���的Criterion.
	 * 
	 * @return 分页查询结果.附带结果列表�所有查询输入�数.
	 */
@SuppressWarnings("unchecked")
public Page<T> findCriterionPage(final Page<T> page, final Criterion... criterions) {
    Assert.notNull(page, "page�能为空");
    Criteria c = createCriteria(criterions);
    if (page.isAutoCount()) {
        long totalCount = countCriteriaResult(c);
        page.setTotalCount(totalCount);
    }
    setPageParameterToCriteria(c, page);
    List result = c.list();
    page.setResult(result);
    return page;
}

public static Criterion notNullOrLikeOrEqual(String path, Class type, Object value, boolean useLike, boolean caseSensitive) {
    if (null == value) {
        return Restrictions.isNull(path);
    } else if (useLike && String.class.isAssignableFrom(type)) {
        if (caseSensitive) {
            return Restrictions.like(path, value);
        } else {
            return Restrictions.ilike(path, value);
        }
    } else {
        return Restrictions.eq(path, value);
    }
}

private void addBooleanFilters(boolean onlyNew, boolean findReplies, boolean onlyFlagged, boolean onlyFeatured, boolean findEmails, boolean sortByLastReply, Criteria criteria) {
    if (!findReplies) {
        criteria.add(Restrictions.isNull("parent"));
    }
    if (!findEmails) {
        criteria.add(Restrictions.eq("emailed", false));
    }
    if (sortByLastReply) {
        criteria.addOrder(Order.desc("lastReply"));
    } else if (onlyNew) {
        SimpleExpression mainDate = Restrictions.gt("date", currentUser.getLastLogin());
        criteria.add(mainDate);
        criteria.addOrder(Order.asc("date"));
    } else {
        criteria.addOrder(Order.desc("date"));
    }
    if (onlyFlagged) {
        Set<PostModel> flaggedPosts2 = currentUser.getFlaggedPosts();
        if (flaggedPosts2.isEmpty()) {
            criteria.add(Restrictions.eq("id", 0));
        } else {
            Vector<Integer> flaggedIDs = new Vector<Integer>();
            for (PostModel p : flaggedPosts2) {
                flaggedIDs.add(p.getId());
            }
            Criterion flaggedSelf = Restrictions.in("id", flaggedIDs);
            Criterion flaggedParent = Restrictions.in("parent", flaggedPosts2);
            criteria.add(Restrictions.or(flaggedSelf, flaggedParent));
        }
    }
    if (onlyFeatured) {
        criteria.add(Restrictions.eq("featured", true));
    }
}

/**
	 * Retrieves entities of the database by a given filter, sort-object
	 * and paging-object
	 *
	 * @param hibernateSortObject
	 * @param hibernateFilter
	 * @param hibernatePagingObject
	 * @param hibernateAdditionalFilter
	 * @return
	 * @throws ShogunDatabaseAccessException
	 *
	 */
@SuppressWarnings("unchecked")
public List<Object> getDataByFilter(HibernateSortObject hibernateSortObject, HibernateFilter hibernateFilter, Set<String> fields, Set<String> ignoreFields, HibernatePagingObject hibernatePagingObject, HibernateFilter hibernateAdditionalFilter) throws ShogunDatabaseAccessException {
    boolean isPlainModelRequest = (fields == null && ignoreFields == null);
    Class<?> clazz = hibernateSortObject.getMainClass();
    Criteria criteria = this.sessionFactory.getCurrentSession().createCriteria(clazz);
    // Fields
    if (fields != null) {
        ProjectionList pl = Projections.projectionList();
        for (Iterator<String> iterator = fields.iterator(); iterator.hasNext(); ) {
            String field = iterator.next();
            pl.add(Projections.property(field));
        }
        criteria.setProjection(Projections.distinct(pl));
    }
    // Ignore Fields
    // -> get all fields of the class and remove the ignorefields, works like a blacklist
    Set<String> cleanedFieldNames = new HashSet<String>();
    if (ignoreFields != null) {
        ProjectionList pl = Projections.projectionList();
        List<Field> allFields = getAllFields(new ArrayList<Field>(), clazz);
        for (Iterator<Field> iterator = allFields.iterator(); iterator.hasNext(); ) {
            Field field = (Field) iterator.next();
            if (!ignoreFields.contains(field.getName())) {
                cleanedFieldNames.add(field.getName());
            }
        }
        for (Iterator<String> iterator = cleanedFieldNames.iterator(); iterator.hasNext(); ) {
            String cleanField = iterator.next();
            pl.add(Projections.property(cleanField), cleanField);
        }
        criteria.setProjection(Projections.distinct(pl));
    }
    // PAGING
    if (hibernatePagingObject != null) {
        criteria.setFirstResult(hibernatePagingObject.getStart());
        criteria.setMaxResults(hibernatePagingObject.getLimit());
    }
    // SORT
    List<HibernateSortItem> hibernateSortItems = hibernateSortObject.getSortItems();
    for (HibernateSortItem hibernateSortItem : hibernateSortItems) {
        criteria.addOrder(hibernateSortItem.createHibernateOrder());
    }
    /*
		 * Check additional filters:
		 * These are being sent from a client and represent AND conditions to be
		 * applied globally.
		 * The use-case that lead us to implement the additionalFilter is
		 * the requirement that users are allowed to have both a AND and an OR
		 * filter (e.g. in the frontend for EigeneLayer).
		 * Usually one would implement this requirement with nested logical
		 * filters
		 */
    if (hibernateAdditionalFilter != null) {
        Conjunction afConjunction = Restrictions.conjunction();
        Criterion afCriterion = null;
        try {
            HibernateFilterItem hfi = (HibernateFilterItem) hibernateAdditionalFilter.getFilterItem(0);
            afCriterion = hfi.makeCriterion(clazz);
            afConjunction.add(afCriterion);
        } catch (Exception e) {
            e.printStackTrace();
            throw new ShogunDatabaseAccessException("Error creating a criterion for additionalFilter.", e);
        }
        criteria.add(afConjunction);
    }
    // FILTER
    int filterItemCount = hibernateFilter.getFilterItemCount();
    if (filterItemCount > 0) {
        // OR connected filter items
        if (hibernateFilter.getLogicalOperator().equals(LogicalOperator.OR)) {
            try {
                Disjunction dis = Restrictions.disjunction();
                for (int i = 0; i < filterItemCount; i++) {
                    HibernateFilterItem hfi = (HibernateFilterItem) hibernateFilter.getFilterItem(i);
                    if (hfi.getFieldName() != null && hfi.getFieldName().contains(".")) {
                        String ownFieldName = hfi.getFieldName().split("\\.")[0];
                        criteria.createCriteria(ownFieldName, ownFieldName);
                        // todo move outside
                        Criterion criterion = hfi.makeCriterion(clazz);
                        if (criterion != null) {
                            dis.add(criterion);
                        }
                    } else {
                        Criterion criterion = hfi.makeCriterion(clazz);
                        if (criterion != null) {
                            dis.add(criterion);
                        }
                    }
                }
                criteria.add(dis);
            } catch (Exception e) {
                throw new ShogunDatabaseAccessException("(getDataByFilter)" + " Error while adding an OR connected filter: " + e.getMessage(), e);
            }
        } else {
            // AND connected filter items
            try {
                Conjunction conjunction = Restrictions.conjunction();
                for (int i = 0; i < filterItemCount; i++) {
                    HibernateFilterItem hfi = (HibernateFilterItem) hibernateFilter.getFilterItem(i);
                    if (hfi.getFieldName() != null && hfi.getFieldName().contains(".")) {
                        String ownFieldName = hfi.getFieldName().split("\\.")[0];
                        criteria.createCriteria(ownFieldName, ownFieldName);
                        // todo move outside
                        Criterion criterion = hfi.makeCriterion(clazz);
                        if (criterion != null) {
                            conjunction.add(criterion);
                        }
                    } else {
                        Criterion criterion = hfi.makeCriterion(clazz);
                        if (criterion != null) {
                            conjunction.add(criterion);
                        }
                    }
                }
                criteria.add(conjunction);
            } catch (Exception e) {
                throw new ShogunDatabaseAccessException("(getDataByFilter)" + " Error while adding an AND connected filter", e);
            }
        }
    }
    // Ok we're done creating the criteria.
    //		System.out.println("Querying for " + clazz.getSimpleName() + " with this SQL:");
    //		String niceSql = (new BasicFormatterImpl()).format(this.toSql(criteria));
    //		System.out.println(niceSql);
    // next we need to know whether we are being filtered with fields
    // because we then do NOT get a List of instances of BaseModelInterface.
    List<Object> list = null;
    if (isPlainModelRequest == false) {
        if (fields == null && cleanedFieldNames.size() > 0) {
            fields = cleanedFieldNames;
        }
        // we dont really know what criteria.list() will return, can be List<Object> or List<Object[]>
        // will be determined later
        List<Object> rawListOfResults = criteria.list();
        List<Object> saneResultList = new ArrayList<Object>();
        for (Object rawRow : rawListOfResults) {
            Map<String, Object> newRowMap = new HashMap<String, Object>();
            int fieldIdx = 0;
            for (Iterator<String> fieldIter = fields.iterator(); fieldIter.hasNext(); ) {
                String fieldName = fieldIter.next();
                Object fieldVal = null;
                if (rawRow != null) {
                    if (rawRow.getClass().isArray()) {
                        Object[] objArr = (Object[]) rawRow;
                        fieldVal = objArr[fieldIdx];
                    } else {
                        fieldVal = rawRow;
                    }
                }
                // store the pair in the newRowMap.
                newRowMap.put(fieldName, fieldVal);
                fieldIdx++;
            }
            // OK, one result row has been trasformed, store it back
            saneResultList.add(newRowMap);
        }
        // now overwrite the list we'll rerturn to the caller.
        list = saneResultList;
    } else {
        // We are NOT filtered, we can rely on the serialization process
        // that takes instances of ou models and transforms them
        // to (possibly huge) JSON structures.
        // Please beware that we can only setResultTransformer here,
        // otherwise we'd loose all but the first filtered field.
        // this ensures that no cartesian product is returned when
        // having sub objects, e.g. User <-> Modules
        criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);
        // we need to set the fetch mode for all sets in our class, as most
        // of them are defined to be fetched lazily:
        criteria = this.setEagerFetchModeForCollections(criteria, clazz);
        list = criteria.list();
    }
    return list;
}

private Criterion getCriterion(String element, QueryParameter queryParamemter) {
    OperatorType operator = getOperator(queryParamemter);
    Object parameter = getValue(queryParamemter);
    switch(operator) {
        case OPERATOR_EQUAL:
            {
                return Expression.eq(element, parameter);
            }
        case OPERATOR_LESSER:
            {
                return Expression.lt(element, parameter);
            }
        case OPERATOR_LESSER_EQUAL:
            {
                return Expression.le(element, parameter);
            }
        case OPERATOR_GREATER:
            {
                return Expression.gt(element, parameter);
            }
        case OPERATOR_GREATER_EQUAL:
            {
                return Expression.ge(element, parameter);
            }
        case OPERATOR_NOT_EQUAL:
            {
                return Expression.ne(element, parameter);
            }
        case OPERATOR_IS_NULL:
            {
                return Expression.isNull(element);
            }
        case OPERATOR_IS_NOT_NULL:
            {
                return Expression.isNotNull(element);
            }
        case OPERATOR_IS_EMPTY:
            {
                return Expression.isEmpty(element);
            }
        case OPERATOR_IS_NOT_EMPTY:
            {
                return Expression.isNotEmpty(element);
            }
        case OPERATOR_STRING_LIKE:
            {
                MatchMode hibernateMatchMode;
                com.smartitengineering.dao.common.queryparam.MatchMode matchMode = getMatchMode(queryParamemter);
                if (matchMode == null) {
                    matchMode = com.smartitengineering.dao.common.queryparam.MatchMode.EXACT;
                }
                switch(matchMode) {
                    case END:
                        hibernateMatchMode = MatchMode.END;
                        break;
                    case EXACT:
                        hibernateMatchMode = MatchMode.EXACT;
                        break;
                    case START:
                        hibernateMatchMode = MatchMode.START;
                        break;
                    default:
                    case ANYWHERE:
                        hibernateMatchMode = MatchMode.ANYWHERE;
                        break;
                }
                return Expression.like(element, parameter.toString(), hibernateMatchMode);
            }
        case OPERATOR_BETWEEN:
            {
                parameter = getFirstParameter(queryParamemter);
                Object parameter2 = getSecondParameter(queryParamemter);
                return Expression.between(element, parameter, parameter2);
            }
        case OPERATOR_IS_IN:
            {
                Collection inCollectin = QueryParameterCastHelper.MULTI_OPERAND_PARAM_HELPER.cast(queryParamemter).getValues();
                return Restrictions.in(element, inCollectin);
            }
        case OPERATOR_IS_NOT_IN:
            {
                Collection inCollectin = QueryParameterCastHelper.MULTI_OPERAND_PARAM_HELPER.cast(queryParamemter).getValues();
                return Restrictions.not(Restrictions.in(element, inCollectin));
            }
    }
    return null;
}

@Override
public void unregisterServiceList(List<Service> servicesList) throws ServiceRegistrationException {
    Session session = null;
    RegistryEntry tmpRegistryEntry = null;
    Transaction t = null;
    try {
        session = sessionFactory.openSession();
        t = session.beginTransaction();
        for (Service service : servicesList) {
            tmpRegistryEntry = new RegistryEntry(service.getServiceIdentifier(), service.getServiceEndpoint(), service.getServiceName(), service.getServiceDescription(), service.getAuthorSignature(), service.getPrivacyPolicy(), service.getSecurityPolicy(), service.getServiceCategory(), service.getServiceType(), service.getServiceLocation(), service.getContextSource(), service.getServiceInstance(), service.getServiceStatus());
            // tmpRegistryEntry = (RegistryEntry)
            // session.get(RegistryEntry.class,tmpRegistryEntry.getServiceIdentifier());
            Object obj = session.load(RegistryEntry.class, tmpRegistryEntry.getServiceIdentifier());
            // Delete the corresponding entry for service shared in CIS
            // sorry for criterion name ;)
            Criterion a = Restrictions.eq("serviceResourceIdentifier.identifier", service.getServiceIdentifier().getIdentifier().toString());
            Criterion b = Restrictions.eq("serviceResourceIdentifier.instanceId", service.getServiceIdentifier().getServiceInstanceIdentifier());
            List<ServiceSharedInCISDAO> serviceSharedInCISList = (List<ServiceSharedInCISDAO>) session.createCriteria(ServiceSharedInCISDAO.class).add(Restrictions.and(a, b)).list();
            for (ServiceSharedInCISDAO serviceSharedInCISDAO : serviceSharedInCISList) {
                session.delete(serviceSharedInCISDAO);
            }
            session.delete(obj);
        }
        t.commit();
    } catch (Exception e) {
        if (t != null)
            t.rollback();
        e.printStackTrace();
        throw new ServiceRegistrationException(e);
    } finally {
        if (session != null) {
            session.close();
        }
    }
}

/**
	 * 按Criterion分页查询.
	 * @param page 分页�数.包括pageSize�firstResult�orderBy�asc�autoCount.
	 *             其中firstResult�直接指定,也�以指定pageNo.
	 *             autoCount指定是�动�获�总结果数.
	 *             
	 * @param criterion 数���的Criterion.
	 * @return 分页查询结果.附带结果列表�所有查询时的�数.
	 */
public Page<T> findByCriteria(Page page, Criterion... criterion) {
    Assert.notNull(page);
    Criteria c = createCriteria(criterion);
    if (page.isAutoCount()) {
        page.setTotalCount(countQueryResult(page, c));
    }
    if (page.isOrderBySetted()) {
        if (page.getOrder().endsWith("asc")) {
            c.addOrder(Order.asc(page.getOrderBy()));
        } else {
            c.addOrder(Order.desc(page.getOrderBy()));
        }
    }
    //hibernate的firstResult的��从0开始
    c.setFirstResult(page.getFirst() - 1);
    c.setMaxResults(page.getPageSize());
    page.setResult(c.list());
    return page;
}

/**
	 * @return a Criteria object with restrictions accordingly to current filters.
	 */
@Override
public Criteria getBaseCriteria() {
    Criteria criteria = sessionFactory.getCurrentSession().createCriteria(entityType);
    ArrayList<Subcriteria> subcriterias = new ArrayList<Subcriteria>();
    if (filters != null) {
        for (ContainerFilter f : filters) {
            StringContainerFilter filter = (StringContainerFilter) f;
            String propertyString = filter.getPropertyId().toString();
            String[] properties = propertyString.split("\\.");
            String property = properties[properties.length - 1];
            Type propertyType = getClassMetadata().getPropertyType(properties[0]);
            if (properties.length > 1) {
                for (int i = 0; i < properties.length - 1; i++) {
                    boolean subcriteriaFound = false;
                    for (Subcriteria sc : subcriterias) {
                        if (sc.getPath().equals(properties[i])) {
                            criteria = sc;
                            subcriteriaFound = true;
                            break;
                        }
                    }
                    if (!subcriteriaFound) {
                        criteria = criteria.createCriteria(properties[i]);
                        subcriterias.add((Subcriteria) criteria);
                    }
                    propertyType = sessionFactory.getCurrentSession().getSessionFactory().getClassMetadata(propertyType.getReturnedClass()).getPropertyType(properties[i + 1]);
                }
            }
            Class<?> returnedClass = propertyType.getReturnedClass();
            if (propertyType.isCollectionType()) {
                try {
                    Field field = entityType.getDeclaredField(property);
                    ParameterizedType parameterizedType = (ParameterizedType) field.getGenericType();
                    returnedClass = (Class<?>) parameterizedType.getActualTypeArguments()[0];
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }
            if (propertyType.isAssociationType()) {
                CrudTable crudTableAnnotation = (CrudTable) returnedClass.getAnnotation(CrudTable.class);
                if (crudTableAnnotation != null) {
                    boolean subcriteriaFound = false;
                    for (Subcriteria sc : subcriterias) {
                        if (sc.getPath().equals(property)) {
                            criteria = sc;
                            subcriteriaFound = true;
                            break;
                        }
                    }
                    if (!subcriteriaFound) {
                        criteria = criteria.createCriteria(property);
                        subcriterias.add((Subcriteria) criteria);
                    }
                    property = crudTableAnnotation.filteringPropertyName();
                    propertyType = sessionFactory.getCurrentSession().getSessionFactory().getClassMetadata(returnedClass).getPropertyType(property);
                } else {
                    throw new RuntimeException("Entity class " + getClassMetadata().getEntityName() + " doesn't declare a filtering property name (no CrudTable annotation present).");
                }
            }
            StringContainerFilter sf = new StringContainerFilter(property, filter.filterString, filter.filterString2, filter.ignoreCase, filter.onlyMatchPrefix);
            Criterion criterion = getCustomRestriction(sf, propertyType.getReturnedClass());
            if (criterion != null) {
                criteria.add(criterion);
            }
            while (criteria.getClass().equals(Subcriteria.class)) {
                criteria = ((Subcriteria) criteria).getParent();
            }
        }
    }
    return criteria;
}

/**
	 * Este método avalia cada parâmetro informado num filtro para ser adicionado
	 * como uma condicional de busca usando o padrão Criteria Queries do hibernate
	 */
public static Criterion avaliarParametrosQueryCriteriaExpression(Session session, FiltroParametro filtroParametro) throws HibernateException {
    Criterion retorno = null;
    // Chama o método de geração de acordo com o tipo do parâmetro
    if (filtroParametro instanceof Intervalo) {
        Intervalo intervalo = ((Intervalo) filtroParametro);
        // Monta a condicional para a query
        retorno = Expression.between(intervalo.getNomeAtributo(), intervalo.getIntervaloInicial(), intervalo.getIntervaloFinal());
    } else if (filtroParametro instanceof ParametroSimples) {
        ParametroSimples parametroSimples = ((ParametroSimples) filtroParametro);
        // Monta a condicional para a query
        retorno = Expression.eq(parametroSimples.getNomeAtributo(), parametroSimples.getValor());
    } else if (filtroParametro instanceof ComparacaoTexto) {
        ComparacaoTexto comparacaoTexto = ((ComparacaoTexto) filtroParametro);
        // Monta a condicional para a query
        retorno = Expression.like(comparacaoTexto.getNomeAtributo(), comparacaoTexto.getValor()).ignoreCase();
    } else if (filtroParametro instanceof ParametroNaoNulo) {
        ParametroNaoNulo parametroNaoNulo = (ParametroNaoNulo) filtroParametro;
        // Monta a condicional para a query
        retorno = Expression.isNotNull(parametroNaoNulo.getNomeAtributo());
    } else if (filtroParametro instanceof ParametroNulo) {
        ParametroNulo parametroNulo = (ParametroNulo) filtroParametro;
        // Monta a condicional para a query
        retorno = Expression.isNull(parametroNulo.getNomeAtributo());
    } else if (filtroParametro instanceof ConectorAnd) {
        ConectorAnd conectorAnd = (ConectorAnd) filtroParametro;
        // Obtém os parâmetros
        FiltroParametro filtro1 = conectorAnd.getFiltro1();
        FiltroParametro filtro2 = conectorAnd.getFiltro2();
        // Monta a condicional para a query
        retorno = Expression.and(avaliarParametrosQueryCriteriaExpression(session, filtro1), avaliarParametrosQueryCriteriaExpression(session, filtro2));
    } else if (filtroParametro instanceof ConectorOr) {
        ConectorOr conectorOr = (ConectorOr) filtroParametro;
        // Obtém os parâmetros
        FiltroParametro filtro1 = conectorOr.getFiltro1();
        FiltroParametro filtro2 = conectorOr.getFiltro2();
        // Monta a condicional para a query
        retorno = Expression.or(avaliarParametrosQueryCriteriaExpression(session, filtro1), avaliarParametrosQueryCriteriaExpression(session, filtro2));
    }
    return retorno;
}

/**
	 * 按Criterion分页查询.
	 * @param page 分页�数.包括pageSize�firstResult�orderBy�asc�autoCount.
	 *             其中firstResult�直接指定,也�以指定pageNo.
	 *             autoCount指定是�动�获�总结果数.
	 *             
	 * @param criterion 数���的Criterion.
	 * @return 分页查询结果.附带结果列表�所有查询时的�数.
	 */
public Page<T> findByCriteria(Page page, Criterion... criterion) {
    Assert.notNull(page);
    Criteria c = createCriteria(criterion);
    if (page.isAutoCount()) {
        page.setTotalCount(countQueryResult(page, c));
    }
    if (page.isOrderBySetted()) {
        if (page.getOrder().endsWith("asc")) {
            c.addOrder(Order.asc(page.getOrderBy()));
        } else {
            c.addOrder(Order.desc(page.getOrderBy()));
        }
    }
    //hibernate的firstResult的��从0开始
    c.setFirstResult(page.getFirst() - 1);
    c.setMaxResults(page.getPageSize());
    page.setResult(c.list());
    return page;
}

//-------------------------------------------------------------
// Methods - Private
//-------------------------------------------------------------
private Criteria buildCriteria(QueryModel queryModel) {
    Criteria criteria = getCurrentSession().createCriteria(persistentClass);
    if (queryModel.getConditions() != null) {
        for (Condition condition : queryModel.getConditions()) {
            criteria.add((Criterion) condition.getConstraint());
        }
    }
    for (Map.Entry<String, List<Condition>> associationCriteriaEntry : queryModel.getAssociationConditions().entrySet()) {
        Criteria associationCriteria = criteria.createCriteria(associationCriteriaEntry.getKey());
        criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);
        for (Condition condition : associationCriteriaEntry.getValue()) {
            associationCriteria.add((Criterion) condition.getConstraint());
        }
    }
    if (queryModel.getProjection() != null) {
        ProjectionList projectionList = Projections.projectionList();
        projectionList.add((org.hibernate.criterion.Projection) queryModel.getProjection().getDetails());
        criteria.setProjection(projectionList);
    }
    return criteria;
}

public int size() {
    if (size == null) {
        try {
            size = (Long) DB.exec(( db) -> {
                Criteria crit = getBaseCriteria(db);
                if (searchRestrictions != null && searchRestrictions.size() > 0) {
                    for (Criterion c : searchRestrictions) {
                        crit.add(c);
                    }
                }
                if (restrictions != null && restrictions.size() > 0) {
                    for (Criterion c : restrictions) {
                        crit.add(c);
                    }
                }
                crit = crit.setProjection(Projections.projectionList().add(Projections.rowCount()).add(Projections.groupProperty("id")));
                return (long) crit.list().size();
            });
        } catch (Exception e) {
            QI.getQI().getLog().error(e);
            return 0;
        }
    }
    return (int) size.longValue();
}

private boolean matchFilterCriterion(OrderElement orderElement, List<Criterion> criterions) {
    if ((criterions != null) && (!criterions.isEmpty())) {
        List<OrderElement> orderElements = new ArrayList<>();
        orderElements.add(orderElement);
        List<Task> tasks = this.getFilteredTask(orderElements, criterions);
        return !tasks.isEmpty();
    }
    return true;
}

@Override
public CommandEvaluator<List, Session> compile(final Query node) {
    init();
    final OrderByEvaluator<Collection<Order>, Object> orderEvaluator = (node.getOrder() != null) ? compileOrderBy(node.getOrder()) : null;
    final CommandEvaluator<Criterion, Object> selectionEvaluator = node.getChilds().size() == 0 ? null : compileEvaluator(node.getChilds().iterator().next());
    final boolean joinCorrelationSet = propertyInQuery;
    final boolean sortByStatus = orderByStatus;
    final boolean sortByStatusDesc = orderByStatusDesc;
    final Limit limit = node.getLimit();
    return new CommandEvaluator<List, Session>() {

        public List evaluate(Session session) {
            Criteria criteria = session.createCriteria(HProcessInstance.class).createAlias("process", "process");
            if (joinCorrelationSet) {
                criteria = criteria.createAlias("correlationSets", "property");
            }
            if (selectionEvaluator != null) {
                criteria.add(selectionEvaluator.evaluate(null));
            }
            if (orderEvaluator != null) {
                Collection<Order> orders = orderEvaluator.evaluate(null);
                for (Order order : orders) {
                    criteria.addOrder(order);
                }
            }
            // setting limit
            if (limit != null) {
                criteria.setMaxResults(limit.getNumber());
            }
            List result = criteria.list();
            //check whether ordering by status
            if (sortByStatus) {
                Collections.sort(result, sortByStatusDesc ? StateComparator.DESC : StateComparator.ASC);
            }
            return result;
        }

        ;
    };
}

/**
     * Gets a list of all events available for a particular calendar with the optional categories.
     * @return List of Event
     * @throws Exception
     */
public Set getEventList(String[] calendarIds, String categoryAttribute, String[] categoryNames, String includedLanguages, java.util.Calendar startCalendar, java.util.Calendar endCalendar, String freeText, Integer numberOfItems, Session session) throws Exception {
    List result = null;
    String calendarSQL = null;
    if (calendarIds != null && calendarIds.length > 0) {
        calendarSQL = "(";
        for (int i = 0; i < calendarIds.length; i++) {
            String calendarIdString = calendarIds[i];
            try {
                Integer calendarId = new Integer(calendarIdString);
            } catch (Exception e) {
                log.warn("An invalid calendarId was given:" + e.getMessage());
                return null;
            }
            if (i > 0)
                calendarSQL += ",";
            calendarSQL += calendarIdString;
        }
        calendarSQL += ")";
    } else {
        return null;
    }
    Object[] calendarIdArray = new Object[calendarIds.length];
    for (int i = 0; i < calendarIds.length; i++) calendarIdArray[i] = new Long(calendarIds[i]);
    Set set = new LinkedHashSet();
    if (calendarIdArray.length > 0) {
        Criteria criteria = session.createCriteria(Event.class);
        criteria.add(Expression.eq("stateId", Event.STATE_PUBLISHED));
        Criteria versionsCriteria = criteria.createAlias("versions", "v");
        if (startCalendar != null && endCalendar != null) {
            if (startCalendar.get(java.util.Calendar.YEAR) == endCalendar.get(java.util.Calendar.YEAR) && startCalendar.get(java.util.Calendar.DAY_OF_YEAR) == endCalendar.get(java.util.Calendar.DAY_OF_YEAR)) {
                startCalendar.set(java.util.Calendar.HOUR_OF_DAY, 23);
                endCalendar.set(java.util.Calendar.HOUR_OF_DAY, 1);
                criteria.add(Expression.and(Expression.le("startDateTime", startCalendar), Expression.ge("endDateTime", endCalendar)));
            } else
                criteria.add(Expression.or(Expression.and(Expression.ge("startDateTime", startCalendar), Expression.le("startDateTime", endCalendar)), Expression.and(Expression.ge("endDateTime", endCalendar), Expression.le("endDateTime", endCalendar))));
        } else {
            criteria.add(Expression.gt("endDateTime", java.util.Calendar.getInstance()));
        }
        criteria.add(Expression.eq("stateId", Event.STATE_PUBLISHED));
        criteria.addOrder(Order.asc("startDateTime"));
        criteria.createCriteria("calendars").add(Expression.in("id", calendarIdArray));
        Criteria eventCategoriesCriteria = null;
        log.info("categoryAttribute:" + categoryAttribute);
        if (categoryAttribute != null && !categoryAttribute.equalsIgnoreCase("")) {
            log.info("categoryAttribute:" + categoryAttribute);
            eventCategoriesCriteria = criteria.createCriteria("eventCategories");
            eventCategoriesCriteria.createCriteria("eventTypeCategoryAttribute").add(Expression.eq("internalName", categoryAttribute));
        }
        Criteria languageVersionCriteria = null;
        log.info("includedLanguages:" + includedLanguages);
        if (includedLanguages != null && !includedLanguages.equalsIgnoreCase("") && !includedLanguages.equalsIgnoreCase("*")) {
            //languageVersionCriteria = criteria.createCriteria("versions");
            versionsCriteria.createCriteria("v.language").add(Expression.eq("isoCode", includedLanguages));
        }
        if (categoryNames != null && categoryNames.length > 0 && !categoryNames[0].equalsIgnoreCase("")) {
            log.info("categoryNames[0]:" + categoryNames[0]);
            if (eventCategoriesCriteria == null)
                eventCategoriesCriteria = criteria.createCriteria("eventCategories");
            eventCategoriesCriteria.createCriteria("category").add(Expression.in("internalName", categoryNames));
        }
        if (freeText != null && !freeText.equals("")) {
            Criterion nameRestriction = Restrictions.like("name", "%" + freeText + "%");
            Criterion organizerNameRestriction = Restrictions.like("organizerName", "%" + freeText + "%");
            Junction d1 = Restrictions.disjunction().add(Restrictions.like("v.name", "%" + freeText + "%")).add(Restrictions.like("v.description", "%" + freeText + "%")).add(Restrictions.like("v.lecturer", "%" + freeText + "%")).add(Restrictions.like("v.longDescription", "%" + freeText + "%")).add(Restrictions.like("v.shortDescription", "%" + freeText + "%")).add(Restrictions.like("v.organizerName", "%" + freeText + "%")).add(Restrictions.like("v.customLocation", "%" + freeText + "%")).add(Restrictions.like("v.eventUrl", "%" + freeText + "%")).add(Restrictions.like("v.alternativeLocation", "%" + freeText + "%")).add(Restrictions.like("name", "%" + freeText + "%")).add(Restrictions.like("description", "%" + freeText + "%")).add(Restrictions.like("contactName", "%" + freeText + "%")).add(Restrictions.like("lecturer", "%" + freeText + "%")).add(Restrictions.like("longDescription", "%" + freeText + "%")).add(Restrictions.like("contactEmail", "%" + freeText + "%")).add(Restrictions.like("shortDescription", "%" + freeText + "%")).add(Restrictions.like("organizerName", "%" + freeText + "%")).add(Restrictions.like("contactPhone", "%" + freeText + "%")).add(Restrictions.like("price", "%" + freeText + "%")).add(Restrictions.like("customLocation", "%" + freeText + "%")).add(Restrictions.like("eventUrl", "%" + freeText + "%")).add(Restrictions.like("alternativeLocation", "%" + freeText + "%"));
            criteria.add(d1);
        }
        if (numberOfItems != null)
            criteria.setMaxResults(numberOfItems);
        result = criteria.list();
        log.info("result:" + result.size());
        set.addAll(result);
    }
    return set;
}

@Override
public CommandEvaluator<List, Session> compile(final Query node) {
    init();
    final OrderByEvaluator<Collection<Order>, Object> orderEvaluator = (node.getOrder() != null) ? compileOrderBy(node.getOrder()) : null;
    final CommandEvaluator<Criterion, Object> selectionEvaluator = node.getChilds().size() == 0 ? null : compileEvaluator(node.getChilds().iterator().next());
    final boolean joinCorrelationSet = propertyInQuery;
    final boolean sortByStatus = orderByStatus;
    final boolean sortByStatusDesc = orderByStatusDesc;
    final Limit limit = node.getLimit();
    return new CommandEvaluator<List, Session>() {

        public List evaluate(Session session) {
            Criteria criteria = session.createCriteria(HProcessInstance.class).createAlias("process", "process");
            if (joinCorrelationSet) {
                criteria = criteria.createAlias("correlationSets", "property");
            }
            if (selectionEvaluator != null) {
                criteria.add(selectionEvaluator.evaluate(null));
            }
            if (orderEvaluator != null) {
                Collection<Order> orders = orderEvaluator.evaluate(null);
                for (Order order : orders) {
                    criteria.addOrder(order);
                }
            }
            // setting limit
            if (limit != null) {
                criteria.setMaxResults(limit.getNumber());
            }
            List result = criteria.list();
            //check whether ordering by status
            if (sortByStatus) {
                Collections.sort(result, sortByStatusDesc ? StateComparator.DESC : StateComparator.ASC);
            }
            return result;
        }

        ;
    };
}

@SuppressWarnings("unchecked")
public static List<BasicRule> getAllOtherBasicRules(String userID) {
    Session session = getSessionFactory().getCurrentSession();
    session.beginTransaction();
    Criteria crit = session.createCriteria(BasicRule.class);
    Criterion restriction = Restrictions.not(Restrictions.eq(OWNER_ID, Integer.valueOf(userID)));
    List<BasicRule> rules = crit.add(restriction).list();
    session.getTransaction().commit();
    return rules;
}

public List getListForConfiguration(Session session, Class type, Criterion cr) throws Throwable {
    List<Computer> result = null;
    try {
        type.getMethod("getConfiguration", (Class[]) null);
        result = session.createCriteria(type).add(Restrictions.eq("configuration", config)).add(cr).list();
    } catch (NoSuchMethodException nsme) {
        result = session.createCriteria(type).add(Restrictions.eq("ConfigurationId", configId)).add(cr).list();
    }
    return result;
}