@Override public <T> Path<T> createSimplePath(Class<T> type, PathMetadata metadata) { return Expressions.path(type, metadata); } @Override
@Override public SimplePath<E> get(@Nonnegative int index) { PathMetadata md = PathMetadataFactory.forArrayAccess(pathMixin, index); return Expressions.path(componentType, md); }
@Override public SimplePath<E> get(Expression<Integer> index) { PathMetadata md = PathMetadataFactory.forArrayAccess(pathMixin, index); return Expressions.path(componentType, md); }
@Test public void visitOperationOfQVoid() { validator.visit((Operation) Expressions.path(Object.class, "path").isNull(), known); }
args.put(PathMetadata.class, PathMetadataFactory.forVariable("obj")); args.put(PathInits.class, PathInits.DEFAULT); args.put(Predicate.class, Expressions.path(Object.class, "obj").isNull()); args.put(QueryMetadata.class, new DefaultQueryMetadata()); args.put(String.class, "obj");
@Test public void pathClassOfTString() { assertEquals("variable", Expressions.path(String.class, "variable").toString()); }
@Test public void datePathClassOfTPathOfQString() { assertEquals("variable.property", Expressions.datePath(Date.class, Expressions.path(Object.class, "variable"), "property").toString()); }
@Test public void dateTimePathClassOfTPathOfQString() { assertEquals("variable.property", Expressions.dateTimePath(Date.class, Expressions.path(Object.class, "variable"), "property").toString()); }
@Test public void timePathClassOfTPathOfQString() { assertEquals("variable.property", Expressions.timePath(Date.class, Expressions.path(Object.class, "variable"), "property").toString()); }
@Test public void booleanPathPathOfQString() { assertEquals("variable.property", Expressions.booleanPath(Expressions.path(Object.class, "variable"), "property").toString()); }
@Test public void comparablePathClassOfTPathOfQString() { assertEquals("variable.property", Expressions.comparablePath(String.class, Expressions.path(Object.class, "variable"), "property").toString()); }
@Test public void numberPathClassOfTPathOfQString() { assertEquals("variable.property", Expressions.numberPath(Integer.class, Expressions.path(Object.class, "variable"), "property").toString()); }
@Test public void stringPathPathOfQString() { assertEquals("variable.property", Expressions.stringPath(Expressions.path(Object.class, "variable"), "property").toString()); }
/** * Creates an {@link Expression} for the given {@link Order} property. * * @param order must not be {@literal null}. * @return */ private Expression<?> buildOrderPropertyPathFrom(Order order) { Assert.notNull(order, "Order must not be null!"); PropertyPath path = PropertyPath.from(order.getProperty(), builder.getType()); Expression<?> sortPropertyExpression = builder; while (path != null) { if (!path.hasNext() && order.isIgnoreCase()) { // if order is ignore-case we have to treat the last path segment as a String. sortPropertyExpression = Expressions.stringPath((Path<?>) sortPropertyExpression, path.getSegment()).lower(); } else { sortPropertyExpression = Expressions.path(path.getType(), (Path<?>) sortPropertyExpression, path.getSegment()); } path = path.next(); } return sortPropertyExpression; } }
@Test public void roundtrip() throws Exception { Path<?> path = ExpressionUtils.path(Object.class, "entity"); SimplePath<?> path2 = Expressions.path(Object.class, "entity"); assertEquals(path, serialize(path)); assertEquals(path2, serialize(path2)); assertEquals(path2.isNull(), serialize(path2.isNull())); assertEquals(path.hashCode(), serialize(path).hashCode()); assertEquals(path2.hashCode(), serialize(path2).hashCode()); assertEquals(path2.isNull().hashCode(), serialize(path2.isNull()).hashCode()); }
@Override public <T> Path<T> createSimplePath(Class<T> type, PathMetadata metadata) { return Expressions.path(type, metadata); } @Override
@Override public SimplePath<E> get(Expression<Integer> index) { PathMetadata md = PathMetadataFactory.forArrayAccess(pathMixin, index); return Expressions.path(componentType, md); }
@SuppressWarnings("unchecked") 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 = Expressions.path((Class) entry.getValue().getClass(), entityPath, entry.getKey()); builder.and(property.eq(entry.getValue())); } ComparablePath<?> sortProperty = Expressions.comparablePath(Comparable.class, entityPath, sort); return new JPAQuery<Void>(em).from(entityPath).where(builder.getValue()) .orderBy(sortProperty.asc()).select(entityPath).fetch(); }
@Test public void join_to_function_with_alias() { SQLQuery<?> query = query(); query.from(survey).join(SQLExpressions.relationalFunctionCall(Survey.class, "functionCall"), Expressions.path(Survey.class, "fc")); query.where(survey.name.isNotNull()); assertEquals("from SURVEY SURVEY\njoin functionCall() as fc\nwhere SURVEY.NAME is not null", query.toString()); }