@Test public void calling_get_with_the_same_name_and_different_types_returns_correct_type() { PathBuilder<User> entity = new PathBuilder<User>(User.class, "entity"); String pathName = "some_path"; assertEquals(Object.class, entity.get(pathName).getType()); assertEquals(Integer.class, entity.get(pathName, Integer.class).getType()); assertEquals(User.class, entity.get(pathName, User.class).getType()); }
/** * Transforms a plain {@link Order} into a Querydsl specific {@link OrderSpecifier}. * * @param order * @return */ @SuppressWarnings({ "rawtypes", "unchecked" }) protected OrderSpecifier<?> toOrder(Order order) { Expression<Object> property = builder.get(order.getProperty()); return new OrderSpecifier( order.isAscending() ? com.querydsl.core.types.Order.ASC : com.querydsl.core.types.Order.DESC, property); }
@Test public void getEnum() { PathBuilder<User> entityPath = new PathBuilder<User>(User.class, "entity"); EnumPath<Gender> enumPath = entityPath.getEnum("gender", Gender.class); assertNotNull(enumPath.ordinal()); assertEquals(enumPath, entityPath.get(enumPath)); }
@Override public Predicate createPredicate(PathBuilder<?> pathBuilder, String attributeName) { StringOperation path = Expressions.stringOperation(Ops.STRING_CAST, pathBuilder.get(attributeName)); BooleanPath booleanPath = pathBuilder.getBoolean(attributeName); if (values.isEmpty()) { return addNullCase ? path.isNull() : null; } else if (isBasicFilter()) { return super.createPredicate(pathBuilder, attributeName); } BooleanExpression predicate = isBooleanComparison ? booleanPath.in(booleanValues) : path.in(values); if (addNullCase) predicate = predicate.or(path.isNull()); return predicate; }
@SuppressWarnings("unchecked") private <T> BooleanBuilder getByExample(T entity) { PathBuilder<T> entityPath = new PathBuilder<T>((Class<T>) entity.getClass(), "entity"); BooleanBuilder conditions = new BooleanBuilder(); Map<String, Object> beanMap = new BeanMap(entity); for (Map.Entry<String, Object> entry : beanMap.entrySet()) { if (!entry.getKey().equals("class")) { if (entry.getValue() != null) { conditions.and(entityPath.get(entry.getKey()).eq(entry.getValue())); } } } return conditions; }
@Test public void calling_get_with_the_same_name_and_different_types_returns_specific_type_when_validating() { PathBuilder<User> entity = new PathBuilder<User>(User.class, "entity", PathBuilderValidator.FIELDS); String pathName = "username"; assertEquals(String.class, entity.get(pathName).getType()); assertEquals(String.class, entity.get(pathName, Comparable.class).getType()); assertEquals(String.class, entity.get(pathName, Object.class).getType()); }
@Test public void get() { PathBuilder<User> entity = new PathBuilder<User>(User.class, "entity"); NumberPath<Integer> intPath = new NumberPath<Integer>(Integer.class, "int"); StringPath strPath = new StringPath("str"); BooleanPath booleanPath = new BooleanPath("boolean"); assertEquals("entity.int", entity.get(intPath).toString()); assertEquals("entity.str", entity.get(strPath).toString()); assertEquals("entity.boolean", entity.get(booleanPath).toString()); assertEquals("entity.int", entity.get(entity.get(intPath)).toString()); }
@Test public void create_withSuffix() { PathBuilderFactory factory = new PathBuilderFactory("_"); PathBuilder<Object> pathBuilder = factory.create(Object.class); assertEquals("object_", pathBuilder.toString()); assertEquals(Object.class, pathBuilder.getType()); pathBuilder.get("prop", Object.class); pathBuilder.get("prop", String.class); pathBuilder.get("prop", Object.class); }
/** * Transforms a plain {@link Order} into a Querydsl specific {@link OrderSpecifier}. * * @param order * @return */ @SuppressWarnings({ "rawtypes", "unchecked" }) private OrderSpecifier<?> toOrder(Order order) { Expression<Object> property = builder.get(order.getProperty()); return new OrderSpecifier( order.isAscending() ? com.querydsl.core.types.Order.ASC : com.querydsl.core.types.Order.DESC, property); } }
@Test public void create() { PathBuilderFactory factory = new PathBuilderFactory(""); PathBuilder<Object> pathBuilder = factory.create(Object.class); assertEquals("object", pathBuilder.toString()); assertEquals(Object.class, pathBuilder.getType()); pathBuilder.get("prop", Object.class); pathBuilder.get("prop", String.class); pathBuilder.get("prop", Object.class); }
@Override public com.querydsl.core.types.Predicate createPredicate(PathBuilder<?> pathBuilder, String attributeName) { StringOperation path = Expressions.stringOperation(Ops.STRING_CAST, pathBuilder.get(attributeName)); return path.lower().like(escapedRawValue, '~'); } }
@SuppressWarnings("unchecked") public static PathBuilder<?> join(JPQLQuery<?> query, PathBuilder<?> builder, Map<String, PathBuilder<?>> joins, String path) { PathBuilder<?> rv = joins.get(path); if (rv == null) { if (path.contains(".")) { String[] tokens = DOT.split(path); String[] parent = new String[tokens.length - 1]; System.arraycopy(tokens, 0, parent, 0, tokens.length - 1); String parentKey = StringUtils.join(parent, "."); builder = join(query, builder, joins, parentKey); rv = new PathBuilder(Object.class, StringUtils.join(tokens, "_")); query.leftJoin((EntityPath) builder.get(tokens[tokens.length - 1]), rv); } else { rv = new PathBuilder(Object.class, path); query.leftJoin((EntityPath) builder.get(path), rv); } joins.put(path, rv); } return rv; }
private void initPredicatesRecursively(Node<Filter> node, PathBuilder<?> pathBuilder) { if (node.isLeaf()) { boolean hasColumnFilter = node.getData() != null; if (hasColumnFilter) { Filter columnFilter = node.getData(); columnPredicates.add(columnFilter.createPredicate(pathBuilder, node.getName())); } else if (hasGlobalFilter) { Filter globalFilter = tree.getData(); globalPredicates.add(globalFilter.createPredicate(pathBuilder, node.getName())); } } for (Node<Filter> child : node.getChildren()) { initPredicatesRecursively(child, child.isLeaf() ? pathBuilder : pathBuilder.get(child.getName())); } }
@Test public void with_tuple() { PathBuilder<Survey> survey = new PathBuilder<Survey>(Survey.class, "SURVEY"); QSurvey survey2 = new QSurvey("survey2"); SQLQuery<?> q = new SQLQuery<Void>(); q.with(survey, survey.get(survey2.id), survey.get(survey2.name)).as( select(survey2.id, survey2.name).from(survey2)); assertEquals("with SURVEY (ID, NAME) as (select survey2.ID, survey2.NAME\n" + "from SURVEY survey2)\n\n" + "from dual", q.toString()); }
@Test public void complex_subQuery() { // alias for the salary NumberPath<BigDecimal> sal = Expressions.numberPath(BigDecimal.class, "sal"); // alias for the subquery PathBuilder<BigDecimal> sq = new PathBuilder<BigDecimal>(BigDecimal.class, "sq"); // query execution query().from( query().from(employee) .select(employee.salary.add(employee.salary).add(employee.salary).as(sal)).as(sq) ).select(sq.get(sal).avg(), sq.get(sal).min(), sq.get(sal).max()).fetch(); }
@Test public void keyword_after_dot() { SQLQuery<?> query = new SQLQuery<Void>(MySQLTemplates.DEFAULT); PathBuilder<Survey> surveyBuilder = new PathBuilder<Survey>(Survey.class, "survey"); query.from(surveyBuilder).where(surveyBuilder.get("not").isNotNull()); assertFalse(query.toString().contains("`")); }
@Test public void qBeanUsage() { PathBuilder<Object[]> sq = new PathBuilder<Object[]>(Object[].class, "sq"); List<Survey> surveys = query().from( query().from(survey).select(survey.all()).as("sq")) .select(Projections.bean(Survey.class, Collections.singletonMap("name", sq.get(survey.name)))).fetch(); assertFalse(surveys.isEmpty()); }
@Test public void path_column2() { PathBuilder<Entity> entity = new PathBuilder<Entity>(Entity.class,"entity"); Configuration conf = new Configuration(new MySQLTemplates()); NativeSQLSerializer serializer = new NativeSQLSerializer(conf, true); serializer.handle(entity.get("firstName")); assertEquals("entity.first_name", serializer.toString()); }
@Test public void path_column() { PathBuilder<Entity> entity = new PathBuilder<Entity>(Entity.class,"entity"); Configuration conf = new Configuration(new MySQLTemplates()); NativeSQLSerializer serializer = new NativeSQLSerializer(conf, true); serializer.handle(entity.get("name")); assertEquals("entity.name", serializer.toString()); }
@Test public void complex_subQuery() { // create sub queries List<SubQueryExpression<Tuple>> sq = new ArrayList<SubQueryExpression<Tuple>>(); String[] strs = new String[]{"a","b","c"}; for (String str : strs) { Expression<Boolean> alias = Expressions.cases().when(survey.name.eq(str)).then(true).otherwise(false); sq.add(select(survey.name, alias).from(survey).distinct()); } // master query PathBuilder<Tuple> subAlias = new PathBuilder<Tuple>(Tuple.class, "sub"); SubQueryExpression<?> master = selectOne() .from(union(sq).as(subAlias)) .groupBy(subAlias.get("prop1")); SQLSerializer serializer = new SQLSerializer(Configuration.DEFAULT); serializer.serialize(master.getMetadata(), false); System.err.println(serializer); }