Java Examples for javax.persistence.criteria.Expression

/**
	 * builds the typed query
	 * @return A JPA typed query
	 * @throws InvalidFieldException
	 * @throws AccessDeniedException
	 * @throws QuerySyntaxException
	 * @throws NotYetImplementedException
	 */
public TypedQuery<T> build() throws InvalidFieldException, AccessDeniedException, QuerySyntaxException, NotYetImplementedException {
    TypedQuery<T> q = null;
    Expression expr = qs.getExpression();
    if (expr != null) {
        Predicate p = process(expr);
        cq.where(p);
    }
    List<OrderByClause> orderByList = qs.getOrderByList();
    if (orderByList != null && orderByList.size() > 0) {
        List<Order> orderList = new ArrayList<Order>();
        for (OrderByClause orderBy : orderByList) {
            String fieldName = orderBy.getFieldName();
            javax.persistence.criteria.Expression<?> nameExpr = toNameExpression(fieldName);
            if (orderBy.isAscending()) {
                orderList.add(cb.asc(nameExpr));
            } else {
                orderList.add(cb.desc(nameExpr));
            }
        }
        cq.orderBy(orderList);
    }
    if (forceDistinct) {
        cq.distinct(true);
    }
    q = em.createQuery(cq);
    return q;
}

@Override
public Predicate isTrue(Expression<Boolean> expression) {
    if (CompoundPredicate.class.isInstance(expression)) {
        final CompoundPredicate predicate = (CompoundPredicate) expression;
        if (predicate.getExpressions().size() == 0) {
            return new BooleanLiteralPredicate(this, predicate.getOperator() == BooleanOperator.AND);
        }
        return predicate;
    } else if (Predicate.class.isInstance(expression)) {
        return (Predicate) expression;
    }
    return equal(expression, literal(Boolean.TRUE));
}

public static <E> Predicate stringPredicate(Expression<String> path, Object attrValue, final SearchParameters sp, final CriteriaBuilder builder) {
    if (sp.isCaseInsensitive()) {
        path = builder.lower(path);
        attrValue = ((String) attrValue).toLowerCase(Locale.ENGLISH);
    }
    switch(sp.getSearchMode()) {
        case EQUALS:
            return builder.equal(path, attrValue);
        case ENDING_LIKE:
            return builder.like(path, "%" + attrValue);
        case STARTING_LIKE:
            return builder.like(path, attrValue + "%");
        case ANYWHERE:
            return builder.like(path, "%" + attrValue + "%");
        case LIKE:
            // assume user
            return builder.like(path, (String) attrValue);
        // cards
        default:
            throw new IllegalStateException("expecting a search mode!");
    }
}

// predicates ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
public Predicate wrap(Expression<Boolean> expression) {
    if (Predicate.class.isInstance(expression)) {
        return ((Predicate) expression);
    } else if (PathImplementor.class.isInstance(expression)) {
        return new BooleanAssertionPredicate(this, expression, Boolean.TRUE);
    } else {
        return new BooleanExpressionPredicate(this, expression);
    }
}

@Test
@SuppressWarnings({ "unchecked", "rawtypes" })
public void testTranslate() {
    SimpleStringFilter filter = new SimpleStringFilter("firstName", "Thomas", false, false);
    Path path = mock(Path.class);
    Expression<String> upper = mock(Expression.class);
    CriteriaBuilder builder = mock(CriteriaBuilder.class);
    when(builder.upper(path)).thenReturn(upper);
    Root<PersistentEntity> root = mock(Root.class);
    when(root.get("firstName")).thenReturn(path);
    Predicate predicate = mock(Predicate.class);
    when(builder.like(path, "%Thomas%")).thenReturn(predicate);
    Predicate translate = translator.translate(filter, builder, root, null);
    assertEquals(predicate, translate);
}

public List<JpaOpsManagerFeed> findByName(String name) {
    LOG.debug("TestFeedSecuringRepository.findByName");
    CriteriaBuilder builder = entityManager.getCriteriaBuilder();
    CriteriaQuery<JpaOpsManagerFeed> query = builder.createQuery(JpaOpsManagerFeed.class);
    Root<JpaOpsManagerFeed> root = query.from(JpaOpsManagerFeed.class);
    Expression<Boolean> nameIsEqualToParam = builder.equal(root.get("name"), name);
    Specification<JpaOpsManagerFeed> spec = null;
    Specification<JpaOpsManagerFeed> secured = augmentor.augment(spec, JpaOpsManagerFeed.class, entityInformation);
    query.where(builder.and(nameIsEqualToParam, secured.toPredicate(root, query, builder)));
    return entityManager.createQuery(query).getResultList();
}

@Override
@Transactional
public List<Sentence> search(String sentence) {
    CriteriaQuery<Sentence> c = em.getCriteriaBuilder().createQuery(Sentence.class);
    Root<Sentence> roleRoot = c.from(Sentence.class);
    c.select(roleRoot);
    Expression<String> exp = roleRoot.get("sentence");
    Predicate r = em.getCriteriaBuilder().like(exp, "%" + sentence + "%");
    c.where(r);
    return em.createQuery(c).getResultList();
}

public static Specification<Conference> inProgressConferences() {
    return new Specification<Conference>() {

        @Override
        public Predicate toPredicate(Root<Conference> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
            Expression<Timestamp> currentTimestamp = cb.currentTimestamp();
            return cb.and(cb.greaterThan(root.get("endedDate").as(Date.class), currentTimestamp), cb.lessThan(root.get("startedDate").as(Date.class), currentTimestamp));
        }
    };
}

/**
     * Create an aggregate expression for finding the greatest of the values
     * (strings, dates, etc).
     *
     * @param x
     *            expression representing input value to greatest operation
     * @return greatest expression
     */
@Override
public <X extends Comparable<? super X>> Expression<X> greatest(Expression<X> x) {
    if (((InternalSelection) x).getCurrentNode() == null) {
        throw new IllegalArgumentException(ExceptionLocalization.buildMessage("OPERATOR_EXPRESSION_IS_CONJUNCTION"));
    }
    return new ExpressionImpl(this.metamodel, x.getJavaType(), ((InternalSelection) x).getCurrentNode().maximum());
}

private Integer oldestYear() {
    CriteriaBuilder criteriaBuilder = em.getCriteriaBuilder();
    CriteriaQuery<Integer> query = criteriaBuilder.createQuery(Integer.class);
    Root<Game> fromGames = query.from(Game.class);
    Expression<Integer> oldestYear = criteriaBuilder.min(fromGames.get(Game_.year));
    return em.createQuery(query.select(oldestYear)).getSingleResult();
}

/**
   * Return a list of T based on a property-value map, the prop-values are combined in the where clause using and.
   */
public List<T> findByProperties(Map<String, Object> filterBy) {
    final CriteriaBuilder builder = getEntityManager().getCriteriaBuilder();
    final CriteriaQuery<T> criteria = builder.createQuery(getEntityClass());
    final Root<T> root = criteria.from(getEntityClass());
    criteria.select(root);
    Expression<Boolean> rootExpression = null;
    for (String property : filterBy.keySet()) {
        Object value = filterBy.get(property);
        if (rootExpression == null) {
            rootExpression = builder.equal(root.get(property), value);
        } else {
            rootExpression = builder.and(rootExpression, builder.equal(root.get(property), value));
        }
    }
    criteria.where(rootExpression);
    return getEntityManager().createQuery(criteria).getResultList();
}

@Override
public final void attach() {
    super.attach();
    final EntityManager entityManager = ((AbstractSiteUI) getUI().getUI()).getSite().getSiteContext().getObject(EntityManager.class);
    final Company company = ((AbstractSiteUI) getUI().getUI()).getSite().getSiteContext().getObject(Company.class);
    final CriteriaBuilder queryBuilder = entityManager.getCriteriaBuilder();
    final CriteriaQuery<Repository> criteriaQuery = queryBuilder.createQuery(Repository.class);
    final Root<Repository> root = criteriaQuery.from(Repository.class);
    final Expression<Comparable> owner = root.get("owner");
    criteriaQuery.where(queryBuilder.equal(owner, company));
    criteriaQuery.orderBy(queryBuilder.asc(root.get("path")));
    final TypedQuery<Repository> typedQuery = entityManager.createQuery(criteriaQuery);
    for (final Repository group : typedQuery.getResultList()) {
        addItem(group);
    }
}

// other functions ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@Override
@SuppressWarnings("unchecked")
public <T> Expression<T> function(String name, Class<T> returnType, Expression<?>... arguments) {
    if (arguments == null || arguments.length == 0) {
        return function(name, returnType);
    }
    final SqmExpressableTypeBasic returnSqmType = consumerContext().getDomainMetamodel().resolveBasicType(returnType);
    return new GenericFunctionExpression(name, returnSqmType, returnType, this, (JpaExpression<?>[]) arguments);
}

@Override
public final void attach() {
    super.attach();
    final EntityManager entityManager = ((AbstractSiteUI) getUI().getUI()).getSite().getSiteContext().getObject(EntityManager.class);
    final Company company = ((AbstractSiteUI) getUI().getUI()).getSite().getSiteContext().getObject(Company.class);
    final CriteriaBuilder queryBuilder = entityManager.getCriteriaBuilder();
    final CriteriaQuery<User> criteriaQuery = queryBuilder.createQuery(User.class);
    final Root<User> root = criteriaQuery.from(User.class);
    final Expression<Comparable> owner = root.get("owner");
    criteriaQuery.where(queryBuilder.equal(owner, company));
    criteriaQuery.orderBy(queryBuilder.asc(root.get("owner")), queryBuilder.asc(root.get("lastName")), queryBuilder.asc(root.get("firstName")));
    final TypedQuery<User> companyQuery = entityManager.createQuery(criteriaQuery);
    for (final User user : companyQuery.getResultList()) {
        addItem(user);
    }
}

public static Specification<SkillLineAbilityEntity> isRaceMatchToRaceMask(final Races race) {
    return new Specification<SkillLineAbilityEntity>() {

        @Override
        public Predicate toPredicate(final Root<SkillLineAbilityEntity> root, final CriteriaQuery<?> query, final CriteriaBuilder cb) {
            final Expression<Integer> racemask = cb.literal(race.getMask());
            final Expression<Integer> raceFunction = cb.function("bitwise_and", Integer.class, root.<Integer>get("racemask"), racemask);
            return cb.or(cb.greaterThan(raceFunction, 0), cb.equal(root.get("racemask"), 0));
        }
    };
}

/*
     * Lookup entities having at least one String attribute matching the passed sp's pattern
     */
@SuppressWarnings("unchecked")
public <T> Predicate byPattern(Root<T> root, CriteriaBuilder builder, SearchParameters sp, Class<T> type) {
    if (!sp.hasSearchPattern()) {
        return null;
    }
    List<Predicate> predicates = newArrayList();
    EntityType<T> entity = em.getMetamodel().entity(type);
    String pattern = sp.getSearchPattern();
    for (SingularAttribute<? super T, ?> attr : entity.getSingularAttributes()) {
        if (attr.getPersistentAttributeType() == MANY_TO_ONE || attr.getPersistentAttributeType() == ONE_TO_ONE) {
            continue;
        }
        if (attr.getJavaType() == String.class) {
            predicates.add(jpaUtil.stringPredicate((Expression<String>) root.get(jpaUtil.attribute(entity, attr)), pattern, sp, builder));
        }
    }
    return jpaUtil.orPredicate(builder, predicates);
}

@Override
public List<Job> notassignedList() {
    CriteriaBuilder cb = entityManager.getCriteriaBuilder();
    CriteriaQuery<Job> cq = cb.createQuery(Job.class);
    Root<Job> job = cq.from(Job.class);
    Expression<Integer> schueler = job.get("schueler");
    cq.select(job).where(cb.isNull(schueler)).orderBy(cb.desc(job.get("erstelldatum")));
    Query query = entityManager.createQuery(cq);
    List<Job> jobListe = query.getResultList();
    return jobListe;
}

/**
	 * Constructs the order by fragment of the query.
	 * 
	 * @param cb
	 *            the criteria builder
	 * @param q
	 *            the query
	 * @param selections
	 *            the selections
	 * @param orderBy
	 *            the order by definitions
	 * 
	 * @since 2.0.0
	 */
private void constructOrder(CriteriaBuilderImpl cb, CriteriaQueryImpl<?> q, List<Selection<?>> selections, Tree orderBy) {
    final List<Order> orders = Lists.newArrayList();
    for (int i = 0; i < orderBy.getChildCount(); i++) {
        final Tree orderByItem = orderBy.getChild(i);
        final Tree orderItem = orderByItem.getChild(0);
        Order order = null;
        if (orderItem.getType() == JpqlParser.ID) {
            final String alias = orderItem.getText();
            for (final Selection<?> selection : selections) {
                if (alias.equals(selection.getAlias())) {
                    order = //
                    orderByItem.getChildCount() == 2 ? cb.desc((Expression<//
                    ?>) selection) : cb.asc((Expression<?>) selection);
                    break;
                }
            }
            if (order == null) {
                throw new PersistenceException("Alias is not bound: " + alias);
            }
        } else {
            order = //
            orderByItem.getChildCount() == 2 ? cb.desc(this.getExpression(cb, q, orderItem//
            , null)) : cb.asc(this.getExpression(cb, q, orderByItem.getChild(0), null));
        }
        orders.add(order);
    }
    q.orderBy(orders);
}

public List<Asset> search(Asset asset) {
    CriteriaBuilder cb = entityManager.getCriteriaBuilder();
    CriteriaQuery<Asset> createQuery = cb.createQuery(Asset.class);
    Root<Asset> assets = createQuery.from(Asset.class);
    createQuery.select(assets);
    Metamodel model = entityManager.getMetamodel();
    EntityType<Asset> Asset_ = model.entity(Asset.class);
    List<Predicate> predicates = new ArrayList<Predicate>();
    if (asset.getName() != null) {
        String name = "%" + asset.getName().toLowerCase() + "%";
        predicates.add(cb.isNotNull(assets.get("name")));
        predicates.add(cb.like(cb.lower(assets.get(Asset_.getDeclaredSingularAttribute("name", String.class))), name));
    }
    if (asset.getCode() != null) {
        String code = "%" + asset.getCode().toLowerCase() + "%";
        predicates.add(cb.isNotNull(assets.get("code")));
        predicates.add(cb.like(cb.lower(assets.get(Asset_.getDeclaredSingularAttribute("code", String.class))), code));
    }
    if (asset.getAssetCategory() != null) {
        predicates.add(cb.equal(assets.get("assetCategory"), asset.getAssetCategory()));
    }
    if (asset.getDepartment() != null) {
        predicates.add(cb.equal(assets.get("department"), asset.getDepartment()));
    }
    if (asset.getSearchStatus() != null) {
        Expression<Long> status = assets.get("status");
        predicates.add(status.in(asset.getSearchStatus()));
    }
    createQuery.where(predicates.toArray(new Predicate[] {}));
    TypedQuery<Asset> query = entityManager.createQuery(createQuery);
    List<Asset> resultList = query.getResultList();
    return resultList;
}

@Override
public Integer getBusinessObjectDataMaxVersion(BusinessObjectDataKey businessObjectDataKey) {
    // Create the criteria builder and the criteria.
    CriteriaBuilder builder = entityManager.getCriteriaBuilder();
    CriteriaQuery<Integer> criteria = builder.createQuery(Integer.class);
    // The criteria root is the business object data.
    Root<BusinessObjectDataEntity> businessObjectDataEntity = criteria.from(BusinessObjectDataEntity.class);
    // Join to the other tables we can filter on.
    Join<BusinessObjectDataEntity, BusinessObjectFormatEntity> businessObjectFormatEntity = businessObjectDataEntity.join(BusinessObjectDataEntity_.businessObjectFormat);
    Join<BusinessObjectFormatEntity, FileTypeEntity> fileTypeEntity = businessObjectFormatEntity.join(BusinessObjectFormatEntity_.fileType);
    Join<BusinessObjectFormatEntity, BusinessObjectDefinitionEntity> businessObjectDefinitionEntity = businessObjectFormatEntity.join(BusinessObjectFormatEntity_.businessObjectDefinition);
    Join<BusinessObjectDefinitionEntity, NamespaceEntity> namespaceEntity = businessObjectDefinitionEntity.join(BusinessObjectDefinitionEntity_.namespace);
    // Create the path.
    Expression<Integer> maxBusinessObjectDataVersion = builder.max(businessObjectDataEntity.get(BusinessObjectDataEntity_.version));
    // Create the standard restrictions (i.e. the standard where clauses).
    Predicate queryRestriction = builder.equal(builder.upper(namespaceEntity.get(NamespaceEntity_.code)), businessObjectDataKey.getNamespace().toUpperCase());
    queryRestriction = builder.and(queryRestriction, builder.equal(builder.upper(businessObjectDefinitionEntity.get(BusinessObjectDefinitionEntity_.name)), businessObjectDataKey.getBusinessObjectDefinitionName().toUpperCase()));
    queryRestriction = builder.and(queryRestriction, builder.equal(builder.upper(businessObjectFormatEntity.get(BusinessObjectFormatEntity_.usage)), businessObjectDataKey.getBusinessObjectFormatUsage().toUpperCase()));
    queryRestriction = builder.and(queryRestriction, builder.equal(builder.upper(fileTypeEntity.get(FileTypeEntity_.code)), businessObjectDataKey.getBusinessObjectFormatFileType().toUpperCase()));
    queryRestriction = builder.and(queryRestriction, builder.equal(businessObjectFormatEntity.get(BusinessObjectFormatEntity_.businessObjectFormatVersion), businessObjectDataKey.getBusinessObjectFormatVersion()));
    queryRestriction = builder.and(queryRestriction, builder.equal(businessObjectDataEntity.get(BusinessObjectDataEntity_.partitionValue), businessObjectDataKey.getPartitionValue()));
    for (int i = 0; i < BusinessObjectDataEntity.MAX_SUBPARTITIONS; i++) {
        queryRestriction = builder.and(queryRestriction, i < businessObjectDataKey.getSubPartitionValues().size() ? builder.equal(businessObjectDataEntity.get(BUSINESS_OBJECT_DATA_SUBPARTITIONS.get(i)), businessObjectDataKey.getSubPartitionValues().get(i)) : builder.isNull(businessObjectDataEntity.get(BUSINESS_OBJECT_DATA_SUBPARTITIONS.get(i))));
    }
    criteria.select(maxBusinessObjectDataVersion).where(queryRestriction);
    return entityManager.createQuery(criteria).getSingleResult();
}

/**
	 * Faz uma consulta ao banco pelos portos com os atributos iguais aos setados no parâmetro porto.
	 * @param porto uma instância de {@link Porto} com os atributos da consulta.
	 */
@Override
public List<Porto> filtrar(Porto porto) {
    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery<Porto> consulta = cb.createQuery(Porto.class);
    Root<Porto> portoRoot = consulta.from(Porto.class);
    ArrayList<Predicate> predicados = new ArrayList<Predicate>();
    if (porto != null) {
        //Cada atributo setado em porto é um filtro e portanto é colocado numa lista de predicados
        if (porto.getLocalizacao() != null && !porto.getLocalizacao().equals("")) {
            Expression<String> localizacao = portoRoot.get("localizacao");
            predicados.add(cb.like(cb.lower(localizacao), porto.getLocalizacao().toLowerCase() + "%"));
        }
        if (porto.getNome() != null && !porto.getNome().equals("")) {
            Expression<String> nome = portoRoot.get("nome");
            predicados.add(cb.like(cb.lower(nome), porto.getNome().toLowerCase() + "%"));
        }
    }
    //Executa a consulta com Porto como entidade raiz e satisfazendo as condições dos predicados
    consulta.select(portoRoot).where(predicados.toArray(new Predicate[] {}));
    consulta.orderBy(cb.asc((portoRoot.get("localizacao"))));
    return this.em.createQuery(consulta).getResultList();
}

/**
	 * Query specification to query the agent existing in the specified region.
	 *
	 * @param region region to query
	 * @return Specification of this query
	 */
public static Specification<AgentInfo> startWithRegion(final String region) {
    return new Specification<AgentInfo>() {

        @Override
        public Predicate toPredicate(Root<AgentInfo> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
            Expression<String> regionField = root.get("region").as(String.class);
            return cb.or(cb.like(regionField, region + "/_owned%", cb.literal('/')), cb.equal(regionField, region));
        }
    };
}

/**
	 * Method findContractByUniqueKey.
	 * 
	 * @param SECType
	 *            String
	 * @param symbol
	 *            String
	 * @param exchange
	 *            String
	 * @param currency
	 *            String
	 * @param expiryDate
	 *            Date
	 * @return Contract
	 */
private Contract findContractByUniqueKey(String SECType, String symbol, String exchange, String currency, ZonedDateTime expiryDate) {
    try {
        EntityManager entityManager = EntityManagerHelper.getEntityManager();
        CriteriaBuilder builder = entityManager.getCriteriaBuilder();
        CriteriaQuery<Contract> query = builder.createQuery(Contract.class);
        Root<Contract> from = query.from(Contract.class);
        query.select(from);
        List<Predicate> predicates = new ArrayList<Predicate>();
        if (null != SECType) {
            Predicate predicate = builder.equal(from.get("secType"), SECType);
            predicates.add(predicate);
        }
        if (null != symbol) {
            Predicate predicate = builder.equal(from.get("symbol"), symbol);
            predicates.add(predicate);
        }
        if (null != exchange) {
            Predicate predicate = builder.equal(from.get("exchange"), exchange);
            predicates.add(predicate);
        }
        if (null != currency) {
            Predicate predicate = builder.equal(from.get("currency"), currency);
            predicates.add(predicate);
        }
        if (null != expiryDate) {
            Integer yearExpiry = expiryDate.getYear();
            Expression<Integer> year = builder.function("year", Integer.class, from.get("expiry"));
            Predicate predicateYear = builder.equal(year, yearExpiry);
            predicates.add(predicateYear);
            Integer monthExpiry = expiryDate.getMonthValue();
            Expression<Integer> month = builder.function("month", Integer.class, from.get("expiry"));
            Predicate predicateMonth = builder.equal(month, new Integer(1 + monthExpiry.intValue()));
            predicates.add(predicateMonth);
        }
        query.where(predicates.toArray(new Predicate[] {}));
        TypedQuery<Contract> typedQuery = entityManager.createQuery(query);
        List<Contract> items = typedQuery.getResultList();
        if (items.size() > 0) {
            return items.get(0);
        }
        return null;
    } catch (Exception re) {
        throw re;
    }
}

// predicates ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
public Predicate wrap(Expression<Boolean> expression) {
    if (Predicate.class.isInstance(expression)) {
        return ((Predicate) expression);
    } else if (PathImplementor.class.isInstance(expression)) {
        return new BooleanAssertionPredicate(this, expression, Boolean.TRUE);
    } else {
        return new BooleanExpressionPredicate(this, expression);
    }
}

// predicates ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
public Predicate wrap(Expression<Boolean> expression) {
    if (Predicate.class.isInstance(expression)) {
        return ((Predicate) expression);
    } else if (PathImplementor.class.isInstance(expression)) {
        return new BooleanAssertionPredicate(this, expression, Boolean.TRUE);
    } else {
        return new BooleanExpressionPredicate(this, expression);
    }
}

protected List<String> supplyCategoryCompletion(AutoCompletionBinding.ISuggestionRequest request) {
    if (request.getUserText() == null || request.getUserText().isEmpty()) {
        return Collections.emptyList();
    } else {
        return PersistentWork.projection(Booking.class, true, MAX_AUTOCOMPLEITON_RESULTS,  b -> b.getCategory(), ( root,  query,  builder) -> {
            Path<String> categoryPath = root.get(BookingLoadingHint.KEY_CATEGORY);
            Expression<String> categoryPathLower = builder.lower(categoryPath);
            String pattern = request.getUserText().toLowerCase(Locale.ROOT).trim() + "%";
            query.where(builder.like(categoryPathLower, pattern));
            query.orderBy(builder.asc(categoryPath));
        });
    }
}

public <E> Predicate stringPredicate(Expression<String> path, Object attrValue, SearchMode searchMode, boolean caseSensitive, CriteriaBuilder builder) {
    if (!caseSensitive) {
        path = builder.lower(path);
        attrValue = ((String) attrValue).toLowerCase(Locale.FRANCE);
    }
    switch(searchMode) {
        case EQUALS:
            return builder.equal(path, attrValue);
        case ENDING_LIKE:
            return builder.like(path, "%" + attrValue);
        case STARTING_LIKE:
            return builder.like(path, attrValue + "%");
        case ANYWHERE:
            return builder.like(path, "%" + attrValue + "%");
        case LIKE:
            // assume user provide the wild cards
            return builder.like(path, (String) attrValue);
        default:
            throw new IllegalStateException("expecting a search mode!");
    }
}

@Override
public Predicate translate(Object filter, CriteriaBuilder cb, Root<?> root) {
    if (filter instanceof Container.Filter) {
    // ok continue
    } else {
        // not our job
        return null;
    }
    if (filter instanceof And) {
        final And and = (And) filter;
        final List<Container.Filter> filters = new ArrayList<>(and.getFilters());
        Predicate predicate = cb.and(translate(filters.remove(0), cb, root), translate(filters.remove(0), cb, root));
        while (filters.size() > 0) {
            predicate = cb.and(predicate, translate(filters.remove(0), cb, root));
        }
        return predicate;
    }
    if (filter instanceof Or) {
        final Or or = (Or) filter;
        final List<Container.Filter> filters = new ArrayList<>(or.getFilters());
        Predicate predicate = cb.or(translate(filters.remove(0), cb, root), translate(filters.remove(0), cb, root));
        while (filters.size() > 0) {
            predicate = cb.or(predicate, translate(filters.remove(0), cb, root));
        }
        return predicate;
    }
    if (filter instanceof Not) {
        final Not not = (Not) filter;
        return cb.not(translate(not.getFilter(), cb, root));
    }
    if (filter instanceof Between) {
        final Between between = (Between) filter;
        final Expression property = (Expression) getPropertyPath(root, between.getPropertyId());
        return cb.between(property, (Comparable) between.getStartValue(), (Comparable) between.getEndValue());
    }
    if (filter instanceof Compare) {
        final Compare compare = (Compare) filter;
        final Expression<Comparable> property = (Expression) getPropertyPath(root, compare.getPropertyId());
        switch(compare.getOperation()) {
            case EQUAL:
                return cb.equal(property, compare.getValue());
            case GREATER:
                return cb.greaterThan(property, (Comparable) compare.getValue());
            case GREATER_OR_EQUAL:
                return cb.greaterThanOrEqualTo(property, (Comparable) compare.getValue());
            case LESS:
                return cb.lessThan(property, (Comparable) compare.getValue());
            case LESS_OR_EQUAL:
                return cb.lessThanOrEqualTo(property, (Comparable) compare.getValue());
            default:
        }
    }
    if (filter instanceof IsNull) {
        final IsNull isNull = (IsNull) filter;
        return cb.isNull((Expression) getPropertyPath(root, isNull.getPropertyId()));
    }
    if (filter instanceof Like) {
        final Like like = (Like) filter;
        if (like.isCaseSensitive()) {
            return cb.like((Expression) getPropertyPath(root, like.getPropertyId()), like.getValue());
        } else {
            return cb.like(cb.lower((Expression) getPropertyPath(root, like.getPropertyId())), like.getValue().toLowerCase());
        }
    }
    if (filter instanceof SimpleStringFilter) {
        final SimpleStringFilter simpleStringFilter = (SimpleStringFilter) filter;
        final Expression<String> property = (Expression) getPropertyPath(root, simpleStringFilter.getPropertyId());
        return cb.like(property, String.format(SQL_LIKE_ARGUMENT, simpleStringFilter.getFilterString()));
    }
    return null;
}

@Override
public Integer getVersionOfOid(String oid) throws EDBException {
    synchronized (entityManager) {
        LOGGER.debug("loading version of model under the oid {}", oid);
        CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
        CriteriaQuery<Long> query = criteriaBuilder.createQuery(Long.class);
        Root<JPAObject> from = query.from(JPAObject.class);
        Expression<Long> maxExpression = criteriaBuilder.count(from.get("oid"));
        query.select(maxExpression);
        query.where(criteriaBuilder.equal(from.get("oid"), oid));
        TypedQuery<Long> typedQuery = entityManager.createQuery(query);
        try {
            return (int) typedQuery.getSingleResult().longValue();
        } catch (NoResultException ex) {
            LOGGER.debug("no model under the oid {}. Returning 0", oid);
            return 0;
        }
    }
}

private CriteriaQuery<Long> createCountCriteriaQuery() {
    CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
    CriteriaQuery<Long> criteriaQuery = criteriaBuilder.createQuery(Long.class);
    Root<T> root = criteriaQuery.from(entityClass);
    Expression<Boolean> filterCriteria = createFilterCriteria(criteriaBuilder, root);
    if (filterCriteria != null) {
        criteriaQuery.where(filterCriteria);
    }
    Expression<Long> count = criteriaBuilder.count(root);
    criteriaQuery.select(count);
    return criteriaQuery;
}

public static void sum(final BaseCriteria baseCriteria, final String... attributeNameArray) {
    for (final String attributeName : attributeNameArray) {
        final Path path = PathHelper.extractPath(baseCriteria, attributeName);
        final Expression sumPredicate = MultiSelectQueryPredicateCreator.sum(baseCriteria.getCriteriaBuilder(), path);
        baseCriteria.addMultiSelectOperationExpression(sumPredicate);
    }
}

@SuppressWarnings("unchecked")
private List<Predicate> createFilterList(Map<SingularAttribute<T, ?>, Object> filterAttributes, boolean enableLikeSearch, CriteriaBuilder queryBuilder, Root<T> rootQuery) {
    List<Predicate> predicateList = new ArrayList<Predicate>();
    if (filterAttributes != null) {
        Iterator<SingularAttribute<T, ?>> iter = filterAttributes.keySet().iterator();
        while (iter.hasNext()) {
            SingularAttribute<T, ?> key = iter.next();
            Object value = filterAttributes.get(key);
            if (enableLikeSearch) {
                String searchKey = value.toString();
                if (!value.toString().contains("%")) {
                    searchKey = "%" + value.toString() + "%";
                }
                Expression<String> lowerKey = queryBuilder.lower((Expression<String>) rootQuery.get(key));
                Predicate predicate = queryBuilder.like(lowerKey, searchKey.toLowerCase());
                predicateList.add(predicate);
            } else {
                Predicate predicate = queryBuilder.equal(rootQuery.get(key), value);
                predicateList.add(predicate);
            }
        }
    }
    return predicateList;
}

private CriteriaQuery<Long> createCountCriteriaQuery() {
    CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
    CriteriaQuery<Long> criteriaQuery = criteriaBuilder.createQuery(Long.class);
    Root<T> root = criteriaQuery.from(entityClass);
    Expression<Boolean> filterCriteria = createFilterCriteria(criteriaBuilder, root);
    if (filterCriteria != null) {
        criteriaQuery.where(filterCriteria);
    }
    Expression<Long> count = criteriaBuilder.count(root);
    criteriaQuery.select(count);
    return criteriaQuery;
}

// query logic ----------------------------------------------------------------------------------------------------------------
/**
     * This is the main ("highest"? "most abstract"?) method that is used to create a {@link CriteriaQuery} from a {@link QueryWhere} instance.
     *
     * @param query The (empty) {@link CriteriaQuery} that will be filled using the {@link QueryCriteria} and other information in the {@link QueryWhere} instance
     * @param queryWhere The {@link QueryWhere} instance, with abstract information that should be added to the {@link CriteriaQuery}
     * @param builder The {@link CriteriaBuilder}, helpful when creating {@link Predicate}s to add to the {@link CriteriaQuery}
     * @param queryType The {@link Class} indicating the main {@link Root} of the {@link CriteriaQuery}
     */
protected <R, T> void fillCriteriaQuery(CriteriaQuery<R> query, QueryWhere queryWhere, CriteriaBuilder builder, Class<T> queryType) {
    Predicate queryPredicate = createPredicateFromCriteriaList(query, builder, queryType, queryWhere.getCriteria(), queryWhere);
    if (queryPredicate != null) {
        query.where(queryPredicate);
    }
    if (queryWhere.getAscOrDesc() != null) {
        String orderByListId = queryWhere.getOrderByListId();
        assert orderByListId != null : "Ascending boolean is set but no order by list Id has been specified!";
        Expression orderByPath = getOrderByExpression(query, queryType, orderByListId);
        Order order;
        if (queryWhere.getAscOrDesc()) {
            order = builder.asc(orderByPath);
        } else {
            order = builder.desc(orderByPath);
        }
        query.orderBy(order);
    }
}

/**
     *
     * @param root
     * @param filter
     * @return
     */
protected Predicate getStringPredicate(Path<?> root, FieldFilter filter) {
    Expression<String> fieldValue;
    String compareValue = (String) filter.getValue();
    if (filter.getOptions().contains(FieldFilter.Option.CS_STRING)) {
        fieldValue = (Path<String>) root;
    } else {
        fieldValue = cb.lower((Path<String>) root);
        compareValue = compareValue.toLowerCase();
    }
    if (filter.getOptions().contains(FieldFilter.Option.PART_STRING)) {
        compareValue = "%" + compareValue + "%";
    } else if (filter.getOptions().contains(FieldFilter.Option.TAIL_STRING)) {
        compareValue = "%" + compareValue;
    } else if (filter.getOptions().contains(FieldFilter.Option.FULL_STRING)) {
    // do not touch
    } else // HEAD_STRING or empty (default)
    {
        compareValue = compareValue + "%";
    }
    return cb.like(fieldValue, compareValue);
}

/**
     * Create a row count CriteriaQuery from a CriteriaQuery
     *
     * @param em entity manager
     * @param criteria source criteria
     * @return row count CriteriaQuery
     */
public static <T> CriteriaQuery<Long> countCriteria(EntityManager em, CriteriaQuery<T> criteria) {
    CriteriaBuilder builder = em.getCriteriaBuilder();
    CriteriaQuery<Long> countCriteria = builder.createQuery(Long.class);
    copyCriteriaNoSelection(criteria, countCriteria, true);
    Root<T> root = findRoot(countCriteria, criteria.getResultType());
    Expression<Long> countExpression;
    if (criteria.isDistinct()) {
        countExpression = builder.countDistinct(root);
    } else {
        countExpression = builder.count(root);
    }
    countCriteria.select(countExpression);
    return countCriteria;
}

@Override
public List<BundleInfoJpa> apply(EntityManager em) {
    final CriteriaBuilder cb = em.getCriteriaBuilder();
    final CriteriaQuery<BundleInfoJpa> q = cb.createQuery(BundleInfoJpa.class);
    final Root<BundleInfoJpa> r = q.from(BundleInfoJpa.class);
    q.select(r);
    final Expression<String> symbolicNamePath = r.get("bundleSymbolicName");
    final Predicate[] likes = toArray(Predicate.class, mlist(prefixes).map(new Function<String, Predicate>() {

        @Override
        public Predicate apply(String prefix) {
            return cb.like(symbolicNamePath, prefix + "%");
        }
    }).value());
    q.where(cb.or(likes));
    q.orderBy(cb.asc(r.get("host")), cb.asc(symbolicNamePath));
    return em.createQuery(q).getResultList();
}

public void testExpressions() {
    String jpql = "SELECT o.quantity, o.totalCost*1.08, " + "a.zipCode FROM Customer c JOIN c.orders o JOIN c.address a " + "WHERE a.state = 'CA' AND a.county = 'Santa Clara'";
    CriteriaQuery<?> q = cb.createQuery();
    Root<Customer> cust = q.from(Customer.class);
    SetJoin<Customer, Order> order = cust.joinSet("orders");
    Join<Customer, Address> address = cust.join("address");
    q.where(cb.equal(address.get("state"), "CA"), cb.equal(address.get("county"), "Santa Clara"));
    Expression<Double> taxedCost = cb.prod(order.get(Order_.totalCost), 1.08);
    q.multiselect(order.get("quantity"), taxedCost, address.get("zipCode"));
    assertEquivalence(q, jpql);
}

// TODO : à refaire : il n'est pas possible de construire un filter ou un order stateless
/**
	 * @deprecated Utiliser QueryDSL
	 */
@Deprecated
protected <T> List<T> listEntity(Class<T> objectClass, Expression<Boolean> filter, Integer limit, Integer offset, Order... orders) {
    CriteriaBuilder builder = getEntityManager().getCriteriaBuilder();
    CriteriaQuery<T> criteria = builder.createQuery(objectClass);
    rootCriteriaQuery(builder, criteria, objectClass);
    if (filter != null) {
        filterCriteriaQuery(criteria, filter);
    }
    if (orders != null && orders.length > 0) {
        criteria.orderBy(orders);
    }
    TypedQuery<T> query = buildTypedQuery(criteria, limit, offset);
    List<T> entities = query.getResultList();
    if (orders == null || orders.length == 0) {
        sort(entities);
    }
    return entities;
}

public <T extends ResourceEntity> SearchResult<T> search(Class<T> clazz, ParseTree filterTree, int count, int startIndex, String sortBy, String sortOrder, FilterParser<T> filterParser) {
    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery<T> resourceQuery = cb.createQuery(clazz);
    Root<T> resourceRoot = resourceQuery.from(clazz);
    Subquery<Long> internalIdQuery = resourceQuery.subquery(Long.class);
    Root<T> internalIdRoot = internalIdQuery.from(clazz);
    internalIdQuery.select(internalIdRoot.get(ResourceEntity_.internalId));
    if (filterTree != null && filterTree.getChildCount() > 0) {
        Predicate predicate = filterParser.createPredicateAndJoin(filterTree, internalIdRoot);
        internalIdQuery.where(predicate);
    }
    resourceQuery.select(resourceRoot).where(cb.in(resourceRoot.get(ResourceEntity_.internalId)).value(internalIdQuery));
    // TODO: evaluate if a User-/GroupDao supplied default sortBy field is possible
    Expression<?> sortByField = resourceRoot.get(ResourceEntity_.id);
    if (sortBy != null && !sortBy.isEmpty()) {
        sortByField = filterParser.createSortByField(sortBy, resourceRoot);
    }
    // default order is ascending
    Order order = cb.asc(sortByField);
    if (sortOrder.equalsIgnoreCase("descending")) {
        order = cb.desc(sortByField);
    }
    resourceQuery.orderBy(order);
    TypedQuery<T> query = em.createQuery(resourceQuery);
    query.setFirstResult(startIndex);
    query.setMaxResults(count);
    List<T> results = query.getResultList();
    long totalResult = getTotalResults(clazz, internalIdQuery);
    return new SearchResult<>(results, totalResult);
}

@Override
public List<TaskStatusInfo> listTasks(String taskTypeFilter, List<TaskStatus> taskStatusFilter, int from, int size) {
    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery<TaskStatusInfo> queryList = cb.createQuery(TaskStatusInfo.class);
    Root<TaskStatusInfo> root = queryList.from(TaskStatusInfo.class);
    queryList.select(root);
    List<Predicate> filter = new ArrayList<>();
    if (taskStatusFilter != null && !taskStatusFilter.isEmpty()) {
        Expression<String> taskStatus = root.get("taskStatus");
        filter.add(taskStatus.in(taskStatusFilter));
    }
    if (taskTypeFilter != null && !taskTypeFilter.trim().isEmpty()) {
        filter.add(cb.equal(root.get("taskType"), taskTypeFilter));
    }
    if (filter.size() > 0) {
        queryList.where(filter.toArray(new Predicate[filter.size()]));
    }
    queryList.orderBy(cb.desc(root.get("taskCreatedAt")));
    TypedQuery<TaskStatusInfo> q = em.createQuery(queryList);
    if (from >= 0)
        q.setFirstResult(from);
    if (size > 0)
        q.setMaxResults(size);
    return q.getResultList();
}

private CriteriaQuery<Long> createCountCriteriaQuery() {
    CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
    CriteriaQuery<Long> criteriaQuery = criteriaBuilder.createQuery(Long.class);
    Root<T> root = criteriaQuery.from(entityClass);
    Expression<Boolean> filterCriteria = createFilterCriteria(criteriaBuilder, root);
    if (filterCriteria != null) {
        criteriaQuery.where(filterCriteria);
    }
    Expression<Long> count = criteriaBuilder.count(root);
    criteriaQuery.select(count);
    return criteriaQuery;
}

private Predicate similarity(CriteriaBuilder criteriaBuilder, Expression<String> nameExpression, String nameValue, Expression<String> firstNameExpression, String firstNameValue) {
    Expression<String> fullNameExpression;
    String fullnameValue;
    if (firstNameExpression != null && firstNameValue != null) {
        fullNameExpression = criteriaBuilder.concat(criteriaBuilder.concat(nameExpression, " "), firstNameExpression);
        fullnameValue = (nameValue + " " + firstNameValue).toLowerCase();
    } else {
        fullNameExpression = nameExpression;
        fullnameValue = nameValue != null ? nameValue.toLowerCase() : "";
    }
    return criteriaBuilder.greaterThanOrEqualTo(criteriaBuilder.function("similarity", Float.class, criteriaBuilder.lower(fullNameExpression), criteriaBuilder.literal(fullnameValue)), MIN_SIMILARITY_SCORE);
}

@Override
public Predicate toPredicate(Root<T> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
    Predicate predicate = cb.conjunction();
    Expression<Boolean> booleanExpression;
    Expression<String> stringExpression;
    // check for each searchable column whether a filter value exists
    for (Column column : input.getColumns()) {
        String filterValue = column.getSearch().getValue();
        boolean isColumnSearchable = column.getSearchable() && StringUtils.hasText(filterValue);
        if (!isColumnSearchable) {
            continue;
        }
        if (filterValue.contains(OR_SEPARATOR)) {
            // the filter contains multiple values, add a 'WHERE .. IN' clause
            boolean nullable = false;
            List<String> values = new ArrayList<String>();
            for (String value : filterValue.split(ESCAPED_OR_SEPARATOR)) {
                if (NULL.equals(value)) {
                    nullable = true;
                } else {
                    // to match a 'NULL' string
                    values.add(ESCAPED_NULL.equals(value) ? NULL : value);
                }
            }
            if (values.size() > 0 && isBoolean(values.get(0))) {
                Object[] booleanValues = new Boolean[values.size()];
                for (int i = 0; i < values.size(); i++) {
                    booleanValues[i] = Boolean.valueOf(values.get(i));
                }
                booleanExpression = getExpression(root, column.getData(), Boolean.class);
                Predicate in = booleanExpression.in(booleanValues);
                if (nullable) {
                    predicate = cb.and(predicate, cb.or(in, booleanExpression.isNull()));
                } else {
                    predicate = cb.and(predicate, in);
                }
            } else {
                stringExpression = getExpression(root, column.getData(), String.class);
                if (values.isEmpty()) {
                    if (nullable) {
                        predicate = cb.and(predicate, stringExpression.isNull());
                    }
                    continue;
                }
                Predicate in = stringExpression.in(values);
                if (nullable) {
                    predicate = cb.and(predicate, cb.or(in, stringExpression.isNull()));
                } else {
                    predicate = cb.and(predicate, in);
                }
            }
            continue;
        }
        // the filter contains only one value, add a 'WHERE .. LIKE' clause
        if (isBoolean(filterValue)) {
            booleanExpression = getExpression(root, column.getData(), Boolean.class);
            predicate = cb.and(predicate, cb.equal(booleanExpression, Boolean.valueOf(filterValue)));
            continue;
        }
        stringExpression = getExpression(root, column.getData(), String.class);
        if (NULL.equals(filterValue)) {
            predicate = cb.and(predicate, stringExpression.isNull());
            continue;
        }
        String likeFilterValue = getLikeFilterValue(ESCAPED_NULL.equals(filterValue) ? NULL : filterValue);
        predicate = cb.and(predicate, cb.like(cb.lower(stringExpression), likeFilterValue, ESCAPE_CHAR));
    }
    // check whether a global filter value exists
    String globalFilterValue = input.getSearch().getValue();
    if (StringUtils.hasText(globalFilterValue)) {
        Predicate matchOneColumnPredicate = cb.disjunction();
        // add a 'WHERE .. LIKE' clause on each searchable column
        for (Column column : input.getColumns()) {
            if (column.getSearchable()) {
                Expression<String> expression = getExpression(root, column.getData(), String.class);
                matchOneColumnPredicate = cb.or(matchOneColumnPredicate, cb.like(cb.lower(expression), getLikeFilterValue(globalFilterValue), ESCAPE_CHAR));
            }
        }
        predicate = cb.and(predicate, matchOneColumnPredicate);
    }
    // findAll method does a count query first, and then query for the actual data. Yet in the
    // count query, adding a JOIN FETCH results in the following error 'query specified join
    // fetching, but the owner of the fetched association was not present in the select list'
    // see https://jira.spring.io/browse/DATAJPA-105
    boolean isCountQuery = query.getResultType() == Long.class;
    if (isCountQuery) {
        return predicate;
    }
    // add JOIN FETCH when necessary
    for (Column column : input.getColumns()) {
        boolean isJoinable = column.getSearchable() && column.getData().contains(ATTRIBUTE_SEPARATOR);
        if (!isJoinable) {
            continue;
        }
        String[] values = column.getData().split(ESCAPED_ATTRIBUTE_SEPARATOR);
        PersistentAttributeType type = root.getModel().getAttribute(values[0]).getPersistentAttributeType();
        if (type != PersistentAttributeType.ONE_TO_ONE && type != PersistentAttributeType.MANY_TO_ONE) {
            continue;
        }
        Fetch<?, ?> fetch = null;
        for (int i = 0; i < values.length - 1; i++) {
            fetch = (fetch == null ? root : fetch).fetch(values[i], JoinType.LEFT);
        }
    }
    return predicate;
}

/**
	 * Creates a criteria API {@link javax.persistence.criteria.Order} from the given {@link Order}.
	 * 
	 * @param order the order to transform into a JPA {@link javax.persistence.criteria.Order}
	 * @param root the {@link Root} the {@link Order} expression is based on
	 * @param cb the {@link CriteriaBuilder} to build the {@link javax.persistence.criteria.Order} with
	 * @return
	 */
@SuppressWarnings("unchecked")
private static javax.persistence.criteria.Order toJpaOrder(Order order, Root<?> root, CriteriaBuilder cb) {
    PropertyPath property = PropertyPath.from(order.getProperty(), root.getJavaType());
    Expression<?> expression = toExpressionRecursively(root, property);
    if (order.isIgnoreCase() && String.class.equals(expression.getJavaType())) {
        Expression<String> lower = cb.lower((Expression<String>) expression);
        return order.isAscending() ? cb.asc(lower) : cb.desc(lower);
    } else {
        return order.isAscending() ? cb.asc(expression) : cb.desc(expression);
    }
}

@SuppressWarnings("unchecked")
private <V> Expression<?> castGet(final Attribute<K, V> attribute, Join<E, K> join) {
    if (attribute instanceof SingularAttribute) {
        return join.get((SingularAttribute<K, V>) attribute);
    } else if (attribute instanceof ListAttribute) {
        return join.get((ListAttribute<K, V>) attribute);
    } else if (attribute instanceof SetAttribute) {
        return join.get((SetAttribute<K, V>) attribute);
    } else {
        return null;
    }
}

/**
     * This method returns the query to get information of customers for various lookup cases
     */
private CriteriaQuery<ViewMajorCustomerDTO> getMajorCustomerQuery(CriteriaBuilder builder, FindType findType, String login, Long majorCustomerId) {
    CriteriaQuery<ViewMajorCustomerDTO> criteria = builder.createQuery(ViewMajorCustomerDTO.class);
    Root<MajorCustomer> majorCustomer = criteria.from(MajorCustomer.class);
    criteria.select(builder.construct(ViewMajorCustomerDTO.class, majorCustomer.get(MajorCustomer_.userId), majorCustomer.get(MajorCustomer_.login), majorCustomer.get(MajorCustomer_.name)));
    switch(findType) {
        case ALL:
            break;
        case BY_LOGIN:
            Path<String> loginPath = majorCustomer.get(MajorCustomer_.login);
            Expression<String> loginLower = builder.lower(loginPath);
            criteria.where(builder.equal(loginLower, login.toLowerCase()));
            break;
        case BY_ID:
            criteria.where(builder.equal(majorCustomer.get(MajorCustomer_.userId), majorCustomerId));
            break;
    }
    return criteria;
}

protected void addSorting(CriteriaBuilder criteriaBuilder, List<Order> sorts, FilterMapping filterMapping, Path path) {
    Expression exp = path;
    if (filterMapping.getNullsLast() != null && filterMapping.getNullsLast()) {
        Object largeValue = getAppropriateLargeSortingValue(path.getJavaType());
        if (largeValue != null) {
            exp = criteriaBuilder.coalesce(path, largeValue);
        }
    }
    if (SortDirection.ASCENDING == filterMapping.getSortDirection()) {
        sorts.add(criteriaBuilder.asc(exp));
    } else {
        sorts.add(criteriaBuilder.desc(exp));
    }
}

protected void addSorting(CriteriaBuilder criteriaBuilder, List<Order> sorts, FilterMapping filterMapping, Path path) {
    Expression exp = path;
    if (filterMapping.getNullsLast() != null && filterMapping.getNullsLast()) {
        Object largeValue = getAppropriateLargeSortingValue(path.getJavaType());
        if (largeValue != null) {
            exp = criteriaBuilder.coalesce(path, largeValue);
        }
    }
    if (SortDirection.ASCENDING == filterMapping.getSortDirection()) {
        sorts.add(criteriaBuilder.asc(exp));
    } else {
        sorts.add(criteriaBuilder.desc(exp));
    }
}

protected void addSorting(CriteriaBuilder criteriaBuilder, List<Order> sorts, FilterMapping filterMapping, Path path) {
    Expression exp = path;
    if (filterMapping.getNullsLast() != null && filterMapping.getNullsLast()) {
        Object largeValue = getAppropriateLargeSortingValue(path.getJavaType());
        if (largeValue != null) {
            exp = criteriaBuilder.coalesce(path, largeValue);
        }
    }
    if (SortDirection.ASCENDING == filterMapping.getSortDirection()) {
        sorts.add(criteriaBuilder.asc(exp));
    } else {
        sorts.add(criteriaBuilder.desc(exp));
    }
}

@SuppressWarnings({ "unchecked", "rawtypes" })
private Predicate doBuildPredicate(ConditionType ct, Path<?> path, Class<?> valueClazz, Object value) {
    Class<? extends Comparable> clazz = (Class<? extends Comparable>) valueClazz;
    Expression<? extends Comparable> exp = path.as(clazz);
    Predicate pred = null;
    switch(ct) {
        case GREATER_THAN:
            pred = builder.greaterThan(exp, clazz.cast(value));
            break;
        case EQUALS:
            if (clazz.equals(String.class)) {
                final String originalValue = value.toString();
                String theValue = SearchUtils.toSqlWildcardString(originalValue, isWildcardStringMatch());
                if (SearchUtils.containsWildcard(originalValue)) {
                    if (SearchUtils.containsEscapedChar(theValue)) {
                        pred = builder.like((Expression<String>) exp, theValue, '\\');
                    } else {
                        pred = builder.like((Expression<String>) exp, theValue);
                    }
                } else {
                    pred = builder.equal(exp, clazz.cast(value));
                }
            } else {
                pred = builder.equal(exp, clazz.cast(value));
            }
            break;
        case NOT_EQUALS:
            if (clazz.equals(String.class)) {
                final String originalValue = value.toString();
                String theValue = SearchUtils.toSqlWildcardString(originalValue, isWildcardStringMatch());
                if (SearchUtils.containsWildcard(originalValue)) {
                    if (SearchUtils.containsEscapedChar(theValue)) {
                        pred = builder.notLike((Expression<String>) exp, theValue, '\\');
                    } else {
                        pred = builder.notLike((Expression<String>) exp, theValue);
                    }
                } else {
                    pred = builder.notEqual(exp, clazz.cast(value));
                }
            } else {
                pred = builder.notEqual(exp, clazz.cast(value));
            }
            break;
        case LESS_THAN:
            pred = builder.lessThan(exp, clazz.cast(value));
            break;
        case LESS_OR_EQUALS:
            pred = builder.lessThanOrEqualTo(exp, clazz.cast(value));
            break;
        case GREATER_OR_EQUALS:
            pred = builder.greaterThanOrEqualTo(exp, clazz.cast(value));
            break;
        default:
            break;
    }
    return pred;
}

protected Predicate getPredicateForString(Expression<String> attr, String value) {
    if (queryConfig.isFilterCaseInsensitive()) {
        attr = this.cBuilder.lower(attr);
        value = value.toLowerCase();
    }
    if (queryConfig.isFilterLogicNegation())
        return this.cBuilder.notLike(attr, getComparison(value));
    else
        return this.cBuilder.like(attr, getComparison(value));
}

protected Predicate buildPredicateWithOperator(Path<T> tt, String name, String value) throws BadUsageException {
    CriteriaBuilder criteriaBuilder = getEntityManager().getCriteriaBuilder();
    Operator operator = Operator.fromString(name);
    // perform operation, default operation is equal
    if (operator == null) {
        Path<T> attribute = tt.get(name);
        Object valueObject = convertStringValueToObject(value, attribute.getJavaType());
        System.out.println("### bp RETURN " + name + "=" + value);
        return criteriaBuilder.equal(attribute, valueObject);
    } else {
        Class javaType = tt.getJavaType();
        if (!classCompatibleWithOperator(javaType, operator)) {
            throw new BadUsageException(ExceptionType.BAD_USAGE_OPERATOR, operator.getValue() + " operator incompatible with field");
        }
        Object valueObject = convertStringValueToObject(value, javaType);
        switch(operator) {
            case GT:
                return criteriaBuilder.greaterThan((Expression) tt, (Comparable) valueObject);
            case GTE:
                return criteriaBuilder.greaterThanOrEqualTo((Expression) tt, (Comparable) valueObject);
            case LT:
                return criteriaBuilder.lessThan((Expression) tt, (Comparable) valueObject);
            case LTE:
                return criteriaBuilder.lessThanOrEqualTo((Expression) tt, (Comparable) valueObject);
            case NE:
                return criteriaBuilder.notEqual(tt, valueObject);
            case EQ:
                return criteriaBuilder.equal(tt, valueObject);
            case EX:
                return criteriaBuilder.like((Expression) tt, value.replace('*', '%'));
            default:
                {
                    Path<T> attribute = tt.get(name);
                    valueObject = convertStringValueToObject(value, attribute.getJavaType());
                    return criteriaBuilder.equal(attribute, valueObject);
                }
        }
    }
}

private List<Order> toOrders(Sort sort, Root<T> root, CriteriaBuilder cb) {
    List<Order> orders = new ArrayList<Order>();
    if (sort == null) {
        return orders;
    }
    for (Property property : sort) {
        Expression<?> expression = root.get(property.getName());
        orders.add(property.isAscending() ? cb.asc(expression) : cb.desc(expression));
    }
    return orders;
}

@SuppressWarnings({ "rawtypes", "unchecked" })
public <X, Y> Predicate toPredicate(Filter filter, CriteriaBuilder cb, From<X, Y> root) {
    Compare compare = (Compare) filter;
    Expression propertyExpr = AdvancedFilterableSupport.getPropertyPath(root, compare.getPropertyId());
    if (Compare.Operation.EQUAL == compare.getOperation() && compare.getValue() == null) {
        // Make an IS NULL instead if "= null" is passed
        return convertFilter(new IsNull(compare.getPropertyId()), cb, root);
    }
    Expression valueExpr = cb.literal(compare.getValue());
    switch(compare.getOperation()) {
        case EQUAL:
            return cb.equal(propertyExpr, valueExpr);
        case GREATER:
            return cb.greaterThan(propertyExpr, valueExpr);
        case GREATER_OR_EQUAL:
            return cb.greaterThanOrEqualTo(propertyExpr, valueExpr);
        case LESS:
            return cb.lessThan(propertyExpr, valueExpr);
        case LESS_OR_EQUAL:
            return cb.lessThanOrEqualTo(propertyExpr, valueExpr);
        default:
            // Shouldn't happen
            return null;
    }
}

@SuppressWarnings({ "rawtypes", "unchecked" })
public <X, Y> Predicate toPredicate(ILFilter filter, CriteriaBuilder cb, From<X, Y> root) {
    LCompare compare = (LCompare) filter;
    Expression propertyExpr = LAdvancedFilterableSupport.getPropertyPath(root, compare.getPropertyId());
    if (LCompare.Operation.EQUAL == compare.getOperation() && compare.getValue() == null) {
        // Make an IS NULL instead if "= null" is passed
        return convertFilter(new LIsNull(compare.getPropertyId()), cb, root);
    }
    Expression valueExpr = cb.literal(compare.getValue());
    switch(compare.getOperation()) {
        case EQUAL:
            return cb.equal(propertyExpr, valueExpr);
        case GREATER:
            return cb.greaterThan(propertyExpr, valueExpr);
        case GREATER_OR_EQUAL:
            return cb.greaterThanOrEqualTo(propertyExpr, valueExpr);
        case LESS:
            return cb.lessThan(propertyExpr, valueExpr);
        case LESS_OR_EQUAL:
            return cb.lessThanOrEqualTo(propertyExpr, valueExpr);
        // Shouldn't happen
        default:
            return null;
    }
}

/**
	 * 
	 * @param path
	 * @param value
	 * @return
	 */
@SuppressWarnings("unchecked")
private Predicate preparePredicate(Path<?> path, String value) {
    // and 3.x has still problems
    if (path.getJavaType() != String.class) {
        throw new QueryConfigException("Path is not of type string.");
    }
    Expression<String> stringExpression = (getConfig().isIgnoreCase()) ? criteriaBuilder.upper((Path<String>) path) : (Path<String>) path;
    String stringValue = (getConfig().isIgnoreCase()) ? value.toString().toUpperCase() : value.toString();
    return (getConfig().isEnableLike()) ? criteriaBuilder.like(stringExpression, stringValue) : criteriaBuilder.equal(stringExpression, stringValue);
}

/**
	 * 
	 * @param path
	 * @param value
	 * @return
	 */
@SuppressWarnings("unchecked")
private Predicate preparePredicate(Path<?> path, String value) {
    // and 3.x has still problems
    if (path.getJavaType() != String.class) {
        throw new QueryConfigException("Path is not of type string.");
    }
    Expression<String> stringExpression = (getConfig().isIgnoreCase()) ? criteriaBuilder.upper((Path<String>) path) : (Path<String>) path;
    String stringValue = (getConfig().isIgnoreCase()) ? value.toString().toUpperCase() : value.toString();
    return (getConfig().isEnableLike()) ? criteriaBuilder.like(stringExpression, stringValue) : criteriaBuilder.equal(stringExpression, stringValue);
}

/**
    * criteri di default, comuni a tutti, ma specializzabili da ogni EJB tramite overriding
    */
@SuppressWarnings({ "unchecked", "rawtypes" })
protected Query getRestrictions(Search<T> search, boolean justCount) {
    if (search.getObj() != null) {
        Map<String, Object> params = new HashMap<String, Object>();
        String alias = "c";
        StringBuffer sb = new StringBuffer(getBaseList(search.getObj().getClass(), alias, justCount));
        String separator = " where ";
        applyRestrictions(search, alias, separator, sb, params);
        if (!justCount) {
            sb.append(getOrderBy(alias, search.getOrder()));
        }
        Query q = getEm().createQuery(sb.toString());
        for (String param : params.keySet()) {
            q.setParameter(param, params.get(param));
        }
        return q;
    } else {
        Class entityType = search.getObj().getClass();
        if (entityType == null) {
            entityType = getEntityType();
        }
        CriteriaBuilder criteriaBuilder = getEm().getCriteriaBuilder();
        CriteriaQuery<T> criteriaQuery = criteriaBuilder.createQuery(entityType);
        Root<T> rec = criteriaQuery.from(entityType);
        if (justCount) {
            criteriaQuery.select((Expression) criteriaBuilder.count(rec));
        } else {
            // comanda quello della search, se non inizializzato usiamo
            // quello
            // di default del repository
            String orderBy = search.getOrder();
            if (orderBy == null) {
                orderBy = getDefaultOrderBy();
            }
            Path path = rec.get(orderBy);
            Order order = null;
            if (path != null) {
                if (search.isOrderAsc()) {
                    order = criteriaBuilder.asc((Expression) rec.get(orderBy));
                } else {
                    order = criteriaBuilder.desc((Expression) rec.get(orderBy));
                }
            }
            if (order != null) {
                criteriaQuery.orderBy(order);
            }
        }
        return getEm().createQuery(criteriaQuery);
    }
}

/**
    * criteri di default, comuni a tutti, ma specializzabili da ogni EJB tramite overriding
    */
@SuppressWarnings({ "unchecked", "rawtypes" })
protected Query getRestrictions(Search<T> search, boolean justCount) {
    if (search.getObj() != null) {
        Map<String, Object> params = new HashMap<String, Object>();
        String alias = "c";
        StringBuffer sb = new StringBuffer(getBaseList(search.getObj().getClass(), alias, justCount));
        String separator = " where ";
        applyRestrictions(search, alias, separator, sb, params);
        if (!justCount) {
            sb.append(getOrderBy(alias, search.getOrder()));
        }
        Query q = getEm().createQuery(sb.toString());
        for (String param : params.keySet()) {
            q.setParameter(param, params.get(param));
        }
        return q;
    } else {
        Class entityType = search.getObj().getClass();
        if (entityType == null) {
            entityType = getEntityType();
        }
        CriteriaBuilder criteriaBuilder = getEm().getCriteriaBuilder();
        CriteriaQuery<T> criteriaQuery = criteriaBuilder.createQuery(entityType);
        Root<T> rec = criteriaQuery.from(entityType);
        if (justCount) {
            criteriaQuery.select((Expression) criteriaBuilder.count(rec));
        } else {
            // comanda quello della search, se non inizializzato usiamo
            // quello
            // di default del repository
            String orderBy = search.getOrder();
            if (orderBy == null) {
                orderBy = getDefaultOrderBy();
            }
            Path path = rec.get(orderBy);
            Order order = null;
            if (path != null) {
                if (search.isOrderAsc()) {
                    order = criteriaBuilder.asc((Expression) rec.get(orderBy));
                } else {
                    order = criteriaBuilder.desc((Expression) rec.get(orderBy));
                }
            }
            if (order != null) {
                criteriaQuery.orderBy(order);
            }
        }
        return getEm().createQuery(criteriaQuery);
    }
}

/**
	 * Create a row count CriteriaQuery from a CriteriaQuery
	 * @param em entity manager
	 * @param criteria source criteria
	 * @return row count CriteriaQuery
	 */
public static <T> CriteriaQuery<Long> countCriteria(EntityManager em, CriteriaQuery<T> criteria) {
    CriteriaBuilder builder = em.getCriteriaBuilder();
    CriteriaQuery<Long> countCriteria = builder.createQuery(Long.class);
    copyCriteriaWithoutSelectionAndOrder(criteria, countCriteria, false);
    Expression<Long> countExpression;
    if (criteria.isDistinct()) {
        countExpression = builder.countDistinct(findRoot(countCriteria, criteria.getResultType()));
    } else {
        countExpression = builder.count(findRoot(countCriteria, criteria.getResultType()));
    }
    return countCriteria.select(countExpression);
}

public int count(Class type) {
    CriteriaBuilder qb = em.getCriteriaBuilder();
    CriteriaQuery<Long> query = qb.createQuery(Long.class);
    Root entity = query.from(type);
    Expression<Long> count = qb.count(entity);
    query.select(count);
    Long size = em.createQuery(query).getSingleResult();
    return size.intValue();
}

private <T> Query createFinderQuery(final EntityManager entityManager, final String methodName, final Class<T> entityType, final Object[] args) {
    final List<String> conditions = parseMethodName(methodName);
    final EntityType<T> et = entityManager.getMetamodel().entity(entityType);
    final CriteriaBuilder cb = entityManager.getCriteriaBuilder();
    CriteriaQuery<Object> query = cb.createQuery();
    final Root<T> from = query.from(entityType);
    query = query.select(from);
    int i = 0;
    Predicate where = null;
    for (final String condition : conditions) {
        final SingularAttribute<? super T, ?> attribute = et.getSingularAttribute(condition);
        final Path<?> path = from.get(attribute);
        final Class<?> javaType = attribute.getType().getJavaType();
        final Predicate currentClause;
        if (javaType.equals(String.class)) {
            currentClause = cb.like((Expression<String>) path, (String) args[i++]);
        } else if (Number.class.isAssignableFrom(javaType) || javaType.isPrimitive()) {
            currentClause = cb.equal(path, args[i++]);
        } else {
            LOGGER.warning("field " + condition + " not found, ignoring");
            continue;
        }
        if (where == null) {
            where = currentClause;
        } else {
            where = cb.and(where, currentClause);
        }
    }
    if (where != null) {
        query = query.where(where);
    }
    // pagination
    final TypedQuery<?> emQuery = entityManager.createQuery(query);
    if (args != null && args.length == conditions.size() + 2 && isInt(args[args.length - 2].getClass()) && isInt(args[args.length - 1].getClass())) {
        final int first = (Integer) args[args.length - 2];
        final int max = (Integer) args[args.length - 1];
        emQuery.setFirstResult(first);
        emQuery.setMaxResults(max);
    }
    return emQuery;
}

/**
     * Test to make sure no member of predicates are added.
     */
@Test
@SuppressWarnings("unchecked")
public void testFindByClusterAndCommandCriteriaNoCriteria() {
    final Specification<ClusterEntity> spec = JpaClusterSpecs.findByClusterAndCommandCriteria(null, null);
    spec.toPredicate(this.root, this.cq, this.cb);
    Mockito.verify(this.cq, Mockito.times(1)).distinct(true);
    Mockito.verify(this.commands, Mockito.times(1)).get(CommandEntity_.status);
    Mockito.verify(this.cb, Mockito.times(1)).equal(this.commands.get(CommandEntity_.status), CommandStatus.ACTIVE);
    Mockito.verify(this.root, Mockito.times(1)).get(ClusterEntity_.status);
    Mockito.verify(this.cb, Mockito.times(1)).equal(this.root.get(ClusterEntity_.status), ClusterStatus.UP);
    Mockito.verify(this.cb, Mockito.never()).isMember(Mockito.any(String.class), Mockito.any(Expression.class));
}

// -------------Criteria Usage--------------------
// -----------------------------------------------
public VXLong getSearchCountUsingCriteria(SearchCriteria searchCriteria, List<SearchField> searchFieldList) {
    EntityManager em = getDao().getEntityManager();
    CriteriaBuilder criteriaBuilder = em.getCriteriaBuilder();
    CriteriaQuery<Long> criteria = criteriaBuilder.createQuery(Long.class);
    Root<T> from = criteria.from(tEntityClass);
    Expression<Long> countExpression = criteriaBuilder.count(from.get("id"));
    criteria.select(countExpression);
    Predicate resourceConditions = buildResourceSpecificConditions(criteriaBuilder, from, searchCriteria);
    Predicate userConditions = buildUserConditions(searchCriteria.getParamList(), searchFieldList, criteriaBuilder, from);
    if (resourceConditions != null) {
        criteria.where(criteriaBuilder.and(resourceConditions, userConditions));
    } else {
        criteria.where(criteriaBuilder.and(userConditions));
    }
    TypedQuery<Long> countQuery = em.createQuery(criteria);
    long count = getDao().executeCountQueryInSecurityContext(tEntityClass, countQuery);
    VXLong vXLong = new VXLong();
    vXLong.setValue(count);
    return vXLong;
}

/*
   * (non-Javadoc)
   * 
   * @see
   * com.google.developers.gdgfirenze.service.SensormixService#getSensors(java
   * .util.List, java.util.Date, java.util.Date)
   */
@Override
public List<Sensor> getSensors(List<String> sensorIds, Date from, Date to) {
    List<Sensor> sensors = new ArrayList<Sensor>();
    try {
        EntityManager em = entityManagerFactory.createEntityManager();
        CriteriaBuilder cb = em.getCriteriaBuilder();
        CriteriaQuery<JpaSensor> cq = cb.createQuery(JpaSensor.class);
        Root<JpaSensor> js = cq.from(JpaSensor.class);
        cq.select(js);
        cq.orderBy(cb.desc(js.get("lastSeen")));
        List<Predicate> criteria = new ArrayList<Predicate>();
        if (sensorIds != null && sensorIds.size() > 0) {
            Expression<String> p = js.get("id");
            criteria.add(p.in(sensorIds));
        }
        if (from != null) {
            ParameterExpression<Date> p = cb.parameter(Date.class, "fromDate");
            Path<Date> datePath = js.get("lastSeen");
            criteria.add(cb.greaterThanOrEqualTo(datePath, p));
        }
        if (to != null) {
            ParameterExpression<Date> p = cb.parameter(Date.class, "toDate");
            Path<Date> datePath = js.get("lastSeen");
            criteria.add(cb.lessThanOrEqualTo(datePath, p));
        }
        if (criteria.size() == 1) {
            cq.where(criteria.get(0));
        } else {
            cq.where(cb.and(criteria.toArray(new Predicate[0])));
        }
        TypedQuery<JpaSensor> q = em.createQuery(cq);
        if (from != null) {
            q.setParameter("fromDate", from);
        }
        if (to != null) {
            q.setParameter("toDate", to);
        }
        List<JpaSensor> ss = q.getResultList();
        for (Iterator<JpaSensor> i = ss.iterator(); i.hasNext(); ) {
            JpaSensor u = i.next();
            Sensor s = new Sensor();
            s.setId(u.getId());
            s.setName(u.getName());
            s.setDescription(u.getDescription());
            s.setLastSeen(u.getLastSeen());
            s.setLat(u.getLat());
            s.setLng(u.getLng());
            s.setType(u.getType());
            sensors.add(s);
        }
        em.close();
    } catch (Exception e) {
        logger.log(Level.SEVERE, "Error during sensors list retrieving", e);
    }
    return sensors;
}

/**
     * Create a Predicate from the RSQL AST comparison node.
     *
     * @param comparison	 RSQL AST comparison node.
     * @param startRoot      From that predicate expression paths depends on.
     * @param entity  		 The main entity of the query.
     * @param entityManager  JPA EntityManager.
     * @param misc      	 Facade with all necessary tools for predicate creation.
     * @return 				 Predicate a predicate representation of the Node.
     */
public static <T> Predicate createPredicate(ComparisonNode comparison, From startRoot, Class<T> entity, EntityManager entityManager, BuilderTools misc) {
    if (startRoot == null) {
        String msg = "From root node was undefined.";
        LOG.log(Level.SEVERE, msg);
        throw new IllegalArgumentException(msg);
    }
    LOG.log(Level.INFO, "Creating Predicate for comparison node: {0}", comparison);
    LOG.log(Level.INFO, "Property graph path : {0}", comparison.getSelector());
    Expression propertyPath = findPropertyPath(comparison.getSelector(), startRoot, entityManager, misc);
    LOG.log(Level.INFO, "Cast all arguments to type {0}.", propertyPath.getJavaType().getName());
    List<Object> castedArguments = misc.getArgumentParser().parse(comparison.getArguments(), propertyPath.getJavaType());
    try {
        // try to create a predicate
        return PredicateBuilder.createPredicate(propertyPath, comparison.getOperator(), castedArguments, entityManager);
    } catch (IllegalArgumentException e) {
        if (misc.getPredicateBuilder() != null) {
            return misc.getPredicateBuilder().createPredicate(comparison, startRoot, entity, entityManager, misc);
        }
        throw e;
    }
}

private static Predicate viewListCommonQueryOptions(CriteriaBuilder builder, Root<Run> rootQuery, RunsQueryParameters queryParameters) {
    User user = queryParameters.user;
    String owner = (queryParameters.runOwner != null) ? queryParameters.runOwner : queryParameters.userFilter;
    String moduleResourceUri = queryParameters.moduleResourceUri;
    String cloud = queryParameters.cloud;
    boolean activeOnly = queryParameters.activeOnly;
    Predicate where = null;
    if (!user.isSuper()) {
        where = andPredicate(builder, where, builder.equal(rootQuery.get("user_"), user.getName()));
    } else if (owner != null) {
        where = andPredicate(builder, where, builder.equal(rootQuery.get("user_"), owner));
    }
    if (moduleResourceUri != null && !"".equals(moduleResourceUri)) {
        where = andPredicate(builder, where, builder.equal(rootQuery.get("moduleResourceUri"), moduleResourceUri));
    }
    if (cloud != null && !"".equals(cloud)) {
        // TODO: Replace the 'like' by an 'equals'
        where = andPredicate(builder, where, builder.like(rootQuery.<String>get("cloudServiceNames"), "%" + cloud + "%"));
    }
    if (activeOnly) {
        Expression<String> exp = rootQuery.<String>get("state");
        Predicate predicate = exp.in(States.active());
        where = andPredicate(builder, where, predicate);
    }
    return where;
}

private void addPredicateNumber(String theResourceName, String theParamName, List<? extends IQueryParameterType> theList) {
    Join<ResourceTable, ResourceIndexedSearchParamNumber> join = myResourceTableRoot.join("myParamsNumber", JoinType.LEFT);
    if (theList.get(0).getMissing() != null) {
        addPredicateParamMissing(theResourceName, theParamName, theList.get(0).getMissing(), join);
        return;
    }
    List<Predicate> codePredicates = new ArrayList<Predicate>();
    for (IQueryParameterType nextOr : theList) {
        IQueryParameterType params = nextOr;
        if (params instanceof NumberParam) {
            NumberParam param = (NumberParam) params;
            BigDecimal value = param.getValue();
            if (value == null) {
                continue;
            }
            final Expression<BigDecimal> fromObj = join.get("myValue");
            ParamPrefixEnum prefix = ObjectUtils.defaultIfNull(param.getPrefix(), ParamPrefixEnum.EQUAL);
            String invalidMessageName = "invalidNumberPrefix";
            Predicate num = createPredicateNumeric(theResourceName, theParamName, join, myBuilder, params, prefix, value, fromObj, invalidMessageName);
            codePredicates.add(num);
        } else {
            throw new IllegalArgumentException("Invalid token type: " + params.getClass());
        }
    }
    myPredicates.add(myBuilder.or(toArray(codePredicates)));
}

@Override
public List<Expression<Boolean>> getExpressions() {
    // TODO Auto-generated method stub
    return null;
}

@Override
public Expression<Boolean> getWhere(CriteriaBuilder cb, Path<Object> path, Object val) {
    return cb.equal(path, val);
}

@Override
public <X> Expression<X> as(Class<X> arg0) {
    // TODO Auto-generated method stub
    return null;
}

private Predicate buildLikeQueryPart(Expression<String> expr, String word) {
    return builder.like(builder.lower(expr), buildLikeString(word));
}

public List<Expression<?>> getGroupList() {
    // TODO Auto-generated method stub
    return null;
}

@Override
public AdminEventQuery resourcePath(String resourcePath) {
    Expression<String> rPath = root.get("resourcePath");
    predicates.add(cb.like(rPath, resourcePath.replace('*', '%')));
    return this;
}

@Override
protected Predicate createPredicate(CriteriaBuilder builder, Path path, Expression... parameter) {
    return builder.equal(path, parameter[0]);
}

@Override
public Expression<Boolean> build(final CriteriaBuilder builder, final Path<E> root) {
    final javax.persistence.criteria.Predicate conjunction = builder.conjunction();
    for (final EntityRestriction<E> restriction : restrictions) {
        conjunction.getExpressions().add(restriction.build(builder, root));
    }
    return conjunction;
}