Examples of javax.persistence.criteria.Predicate

javax.persistence.criteria.Predicate
Criteria predicate. @since JPA 2.0

        ParameterExpression<Date> maxDate = cb.parameter(Date.class, "maxDate");


        Subquery<Integer> sq = q.subquery(Integer.class);
        Root<Employee> e2 = sq.from(Employee.class);
        sq.select(cb.max(e2.get(Employee_.empId)));
        Predicate p1 = cb.equal(e.get(Employee_.empId), empid); 
        Predicate p2 = cb.equal(d.get(Dependent_.id).get(DependentId_.empid), sq);
        Predicate p3 = cb.greaterThan(d.get(Dependent_.id).get(DependentId_.effDate), minDate);
        Predicate p4 = cb.lessThan(d.get(Dependent_.id).get(DependentId_.effDate), maxDate);
        
        q.where(cb.and(cb.and(cb.and(p1, p2), p3), p4));
        assertEquivalence(new QueryDecorator() {
            public void decorate(Query q) {
                q.setParameter("empid",   101L);

View Full Code Here

            for (SearchCondition<T> condition : sc.getSearchConditions()) {
                condition.accept(this);
            }
            List<Predicate> predsList = predStack.pop();
            Predicate[] preds = predsList.toArray(new Predicate[predsList.size()]);
            Predicate newPred;
            if (sc instanceof OrSearchCondition) {
                newPred = builder.or(preds);
            } else {
                newPred = builder.and(preds);
            }

View Full Code Here

        
        name = super.getRealPropertyName(name);
        
        Path<?> path = getPath(root, name);
        
        Predicate pred = null;
        switch (ct) {
        case GREATER_THAN:
            pred = builder.greaterThan(path.as(clazz), clazz.cast(value));
            break;
        case EQUALS:

View Full Code Here

        q.select(book);
        
        // Builds the predicates conditionally for the filled-in input fields 
        List<Predicate> predicates = new ArrayList<Predicate>();
        if (!isEmpty(title)) {
            Predicate matchTitle = cb.like(book.get(Book_.title), title);
            predicates.add(matchTitle);
        }
        if (!isEmpty(author)) {
            Predicate matchAuthor = cb.like(book.join(Book_.authors).get(Author_.name), "%"+author+"%");
            predicates.add(matchAuthor);
        }
        // for price fields, also the comparison operation changes based on whether
        // minimum or maximum price or both have been filled. 
        if (minPrice != null && maxPrice != null) {
            Predicate matchPrice = cb.between(book.get(Book_.price), minPrice, maxPrice);
            predicates.add(matchPrice);
        } else if (minPrice != null && maxPrice == null) {
            Predicate matchPrice = cb.ge(book.get(Book_.price), minPrice);
            predicates.add(matchPrice);
        } else if (minPrice == null && maxPrice != null) {
            Predicate matchPrice = cb.le(book.get(Book_.price), maxPrice);
            predicates.add(matchPrice);
        }
        // Sets the evaluation criteria     
        if (!predicates.isEmpty())
            q.where(predicates.toArray(new Predicate[predicates.size()]));

View Full Code Here

  public void testComplicatedNotOr() {
    CriteriaQuery<Order> orderCriteria = builder.createQuery( Order.class );
    Root<Order> orderRoot = orderCriteria.from( Order.class );


    orderCriteria.select( orderRoot );
    Predicate p1 = builder.equal( orderRoot.get( "id" ), "order-1" );
    Predicate p2 = builder.equal( orderRoot.get( "id" ), "order-2" );
    orderCriteria.where( builder.not( builder.or( p1, p2 ) ) );


    List<Order> orders = em.createQuery( orderCriteria ).getResultList();
    assertTrue( orders.size() == 1 );
    Order order = orders.get( 0 );

View Full Code Here

  public void testNotMultipleOr() {
    CriteriaQuery<Order> orderCriteria = builder.createQuery( Order.class );
    Root<Order> orderRoot = orderCriteria.from( Order.class );


    orderCriteria.select( orderRoot );
    Predicate p1 = builder.equal( orderRoot.get( "id" ), "order-1" );
    Predicate p2 = builder.equal( orderRoot.get( "id" ), "order-2" );
    Predicate p3 = builder.equal( orderRoot.get( "id" ), "order-3" );
    orderCriteria.where( builder.not( builder.or( p1, p2, p3 ) ) );


    List<Order> orders = em.createQuery( orderCriteria ).getResultList();
    assertTrue( orders.size() == 0 );
  }

View Full Code Here

  public void testComplicatedNotAnd() {
    CriteriaQuery<Order> orderCriteria = builder.createQuery( Order.class );
    Root<Order> orderRoot = orderCriteria.from( Order.class );


    orderCriteria.select( orderRoot );
    Predicate p1 = builder.equal( orderRoot.get( "id" ), "order-1" );
    Predicate p2 = builder.equal( orderRoot.get( "id" ), "order-2" );
    orderCriteria.where( builder.not( builder.and( p1, p2 ) ) );


    List<Order> orders = em.createQuery( orderCriteria ).getResultList();
    assertTrue( orders.size() == 3 );
  }

View Full Code Here

  public void testCharArray() {
    CriteriaQuery<Order> orderCriteria = builder.createQuery( Order.class );
    Root<Order> orderRoot = orderCriteria.from( Order.class );
    
    orderCriteria.select( orderRoot );
    Predicate p = builder.equal( orderRoot.get( "domen" ), new char[]{'r','u'} );
    orderCriteria.where( p );


    List<Order> orders = em.createQuery( orderCriteria ).getResultList();
    assertTrue( orders.size() == 1 );
  }

View Full Code Here

  public void testByteArray() {
    CriteriaQuery<Order> orderCriteria = builder.createQuery( Order.class );
    Root<Order> orderRoot = orderCriteria.from( Order.class );
    
    orderCriteria.select( orderRoot );
    Predicate p = builder.equal( orderRoot.get( "number" ), new byte[]{'1','2'} );
    orderCriteria.where( p );


    List<Order> orders = em.createQuery( orderCriteria ).getResultList();
    assertTrue( orders.size() == 0 );
  }

View Full Code Here

    Long longValue = 999999999L;
    Path<Double> doublePath = orderRoot.get( Order_.totalPrice );
    Path<Integer> integerPath = orderRoot.get( Order_.customer ).get( Customer_.age );


    orderCriteria.select( orderRoot );
    Predicate p = builder.ge(
        builder.quot( integerPath, doublePath ),
        longValue
    );
    orderCriteria.where( p );

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of javax.persistence.criteria.Predicate

br.gov.frameworkdemoiselle.template.JPACrud

com.adaptrex.core.persistence.jpa.JPAStoreData

com.astech.repository.support.ByRangeSpecifications

com.darkhonor.rage.libs.dataaccess.SectionDAO

com.github.dactiv.orm.core.spring.data.jpa.restriction.PredicateMultipleValueSupport

com.github.dactiv.orm.core.spring.data.jpa.restriction.PredicateSingleValueSupport

com.github.dactiv.orm.core.spring.data.jpa.specification.support.PropertySpecification

com.impetus.kundera.persistence.CriteriaQueryTranslator

com.insacosa.dataModels_JPA.JPADataModel

com.insacosa.interfaces.Inmoble_Impl

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.