@Override public <T extends Comparable<?>> Path<T> createComparablePath( Class<T> type, PathMetadata<?> metadata) { return new ComparablePath<T>(type, metadata); }
/** * {@inheritDoc} */ @Override public <T, E extends Comparable<?>> OrderSpecifier<?> createOrderSpecifier( PathBuilder<T> entityPath, String fieldName, Class<E> fieldType, Order order) { OrderSpecifier<?> orderBy = null; // Get the OrderSpecifier if (order == Order.ASC) { orderBy = entityPath.getComparable(fieldName, fieldType).asc(); } else if (order == Order.DESC) { orderBy = entityPath.getComparable(fieldName, fieldType).desc(); } return orderBy; }
public static <T> List<T> findCustom(EntityManager em, Class<T> entityClass,Map<String,?> filters, String sort) { EntityPath<T> entityPath = new EntityPathBase<T>(entityClass, "entity"); BooleanBuilder builder = new BooleanBuilder(); for (Map.Entry<String, ?> entry : filters.entrySet()) { SimplePath<Object> property = new SimplePath<Object>(entry.getValue().getClass(), entityPath, entry.getKey()); builder.and(property.eq(entry.getValue())); } ComparablePath<?> sortProperty = new ComparablePath(Comparable.class, entityPath, sort); return new JPAQuery(em).from(entityPath).where(builder.getValue()).orderBy(sortProperty.asc()).list(entityPath); }
/** * @param <A> * @param path * @return */ @SuppressWarnings("unchecked") public <A extends Comparable<?>> ComparablePath<A> get(ComparablePath<A> path) { ComparablePath<A> newPath = getComparable(toString(path), (Class<A>)path.getType()); return addMetadataOf(newPath, path); }
assertEquals(literals.date, session.from($(l)).where($(l.getDate()).eq(literals.date)).uniqueResult($(l.getDate()))); assertEquals(literals.date2, session.from($(l)).where($(l.getDate2()).eq(literals.date2)).uniqueResult($(l.getDate2()))); assertEquals(literals.dateTime.getMillis(), session.from($(l)).where($(l.getDateTime()).eq(literals.dateTime)).uniqueResult($(l.getDateTime())).getMillis()); assertEquals(literals.localDate, session.from($(l)).where($(l.getLocalDate()).eq(literals.localDate)).uniqueResult($(l.getLocalDate()))); assertEquals(literals.localTime, session.from($(l)).where($(l.getLocalTime()).eq(literals.localTime)).uniqueResult($(l.getLocalTime()))); assertEquals(literals.time, session.from($(l)).where($(l.getTime()).eq(literals.time)).uniqueResult($(l.getTime()))); assertEquals(literals.timestamp, session.from($(l)).where($(l.getTimestamp()).eq(literals.timestamp)).uniqueResult($(l.getTimestamp()))); assertEquals(1, session.from($(l)).where($(l.getDateTime()).eq(literals.dateTime)).count()); assertEquals(1, session.from($(l)).where($(l.getLocalDate()).eq(literals.localDate)).count()); assertEquals(1, session.from($(l)).where($(l.getLocalTime()).eq(literals.localTime)).count()); assertEquals(1, session.from($(l)).where($(l.getTime()).eq(literals.time)).count()); assertEquals(1, session.from($(l)).where($(l.getTimestamp()).eq(literals.timestamp)).count());
@SuppressWarnings("unchecked") public static <D extends Comparable<?>> ComparablePath<D> var(D arg) { return new ComparablePath<D>((Class)arg.getClass(), "var"+arg); }
/** * Create an order-by-element in a Query instance * * @param entityPath Full path to entity and associations. For example: * {@code Pet} , {@code Pet.owner} * @param fieldName Property name in the given entity path. For example: * {@code weight} in {@code Pet} entity, {@code age} in * {@code Pet.owner} entity. * @param fieldType Property value {@code Class}. Must implements * {@link Comparable} * @param order ascending or descending order * @return */ public static <T, E extends Comparable<?>> OrderSpecifier<?> createOrderSpecifier( PathBuilder<T> entityPath, String fieldName, Class<E> fieldType, Order order) { OrderSpecifier<?> orderBy = null; // Get the OrderSpecifier if (order == Order.ASC) { orderBy = entityPath.getComparable(fieldName, fieldType).asc(); } else if (order == Order.DESC) { orderBy = entityPath.getComparable(fieldName, fieldType).desc(); } return orderBy; }
/** * Create a new Path expression * * @param type * @param variable * @return */ public static <T extends Comparable<?>> ComparablePath<T> comparablePath(Class<T> type, String variable) { return new ComparablePath<T>(type, PathMetadataFactory.forVariable(variable)); }
/** * Create a new Path expression * * @param type * @param parent * @param property * @return */ public static <T extends Comparable<?>> ComparablePath<T> comparablePath(Class<T> type, Path<?> parent, String property) { return new ComparablePath<T>(type, PathMetadataFactory.forProperty(parent, property)); }
/** * Create a new Comparable typed path * * @param <A> * @param property * @param type * @return */ @SuppressWarnings("unchecked") protected <A extends Comparable> ComparablePath<A> createComparable(String property, Class<? super A> type) { return add(new ComparablePath<A>((Class) type, forProperty(property))); }