/** * Create a new variable path * * @param arg alias * @param <D> * @return expression */ @SuppressWarnings("unchecked") public static <D> EntityPathBase<D> var(D arg) { String var = "var" + arg.getClass().getSimpleName() + "_" + arg.toString().replace(' ', '_'); return new PathBuilder<D>((Class) arg.getClass(), var); }
/** * Create a new PathBuilder instance for the given type * * @param type type of expression * @return new PathBuilder instance */ @SuppressWarnings("unchecked") public <T> PathBuilder<T> create(Class<T> type) { PathBuilder<T> rv = (PathBuilder<T>) paths.get(type); if (rv == null) { rv = new PathBuilder<T>(type, variableName(type)); paths.put(type, rv); } return rv; }
/** * Create a PathBuilder instance for the given property * * @param property property name * @return property path */ @SuppressWarnings("unchecked") public PathBuilder<Object> get(String property) { SimpleEntry<String, Class<?>> entry = new SimpleEntry<String, Class<?>>(property, Object.class); PathBuilder<Object> path = (PathBuilder<Object>) properties.get(entry); PathBuilder<?> existingPath = null; if (path == null) { Class<?> vtype = validate(property, Object.class); path = new PathBuilder<Object>(vtype, forProperty(property), validator); existingPath = properties.putIfAbsent(entry, path); } return existingPath == null ? path : (PathBuilder<Object>) existingPath; }
protected static <E> PathBuilder<E> pathBuilderFor(EntityPath<E> path) { return new PathBuilder<>(path.getType(), path.getMetadata()); }
/** * Creates a new {@link QuerydslJpaPredicateExecutor} from the given domain class and {@link EntityManager} and uses * the given {@link EntityPathResolver} to translate the domain class into an {@link EntityPath}. * * @param entityInformation must not be {@literal null}. * @param entityManager must not be {@literal null}. * @param resolver must not be {@literal null}. * @param metadata maybe {@literal null}. */ public QuerydslJpaPredicateExecutor(JpaEntityInformation<T, ?> entityInformation, EntityManager entityManager, EntityPathResolver resolver, @Nullable CrudMethodMetadata metadata) { this.entityInformation = entityInformation; this.metadata = metadata; this.path = resolver.createPath(entityInformation.getJavaType()); this.querydsl = new Querydsl(entityManager, new PathBuilder<T>(path.getType(), path.getMetadata())); this.entityManager = entityManager; }
@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; }
/** * Creates a new {@link QuerydslJpaRepository} from the given domain class and {@link EntityManager} and uses the * given {@link EntityPathResolver} to translate the domain class into an {@link EntityPath}. * * @param entityInformation must not be {@literal null}. * @param entityManager must not be {@literal null}. * @param resolver must not be {@literal null}. */ public QuerydslJpaRepository(JpaEntityInformation<T, ID> entityInformation, EntityManager entityManager, EntityPathResolver resolver) { super(entityInformation, entityManager); this.path = resolver.createPath(entityInformation.getJavaType()); this.builder = new PathBuilder<T>(path.getType(), path.getMetadata()); this.querydsl = new Querydsl(entityManager, builder); this.entityManager = entityManager; }
@Test public void fieldsClassOfTExpressionOfQArray() { PathBuilder<Entity> entity = new PathBuilder<Entity>(Entity.class, "entity"); QBean<Entity> beanProjection = Projections.fields(Entity.class, entity.getNumber("cId", Integer.class), entity.getNumber("eId", Integer.class)); assertEquals(Entity.class, beanProjection.newInstance(1, 2).getClass()); }
@Test public void beanClassOfTExpressionOfQArray() { PathBuilder<Entity> entity = new PathBuilder<Entity>(Entity.class, "entity"); QBean<Entity> beanProjection = Projections.bean(Entity.class, entity.getNumber("cId", Integer.class), entity.getNumber("eId", Integer.class)); assertEquals(Entity.class, beanProjection.newInstance(1, 2).getClass()); }
@Test public void field_access() { PathBuilder<Entity> entity = new PathBuilder<Entity>(Entity.class, "entity"); QBean<Entity> beanProjection = new QBean<Entity>(Entity.class, true, entity.getNumber("cId",Integer.class), entity.getNumber("eId", Integer.class)); Entity bean = beanProjection.newInstance(1,2); assertEquals(Integer.valueOf(1), bean.getcId()); assertEquals(Integer.valueOf(2), bean.geteId()); }
@Test public void property_access() { PathBuilder<Entity> entity = new PathBuilder<Entity>(Entity.class, "entity"); QBean<Entity> beanProjection = new QBean<Entity>(Entity.class, entity.getNumber("cId",Integer.class), entity.getNumber("eId", Integer.class)); Entity bean = beanProjection.newInstance(1,2); assertEquals(Integer.valueOf(1), bean.getcId()); assertEquals(Integer.valueOf(2), bean.geteId()); }
@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)); }
@Test public void getMap() { PathBuilder<User> entityPath = new PathBuilder<User>(User.class, "entity"); entityPath.getMap("map", String.class, String.class, StringPath.class).get("").lower(); entityPath.getMap("map", String.class, String.class).get(""); }
@Test public void getArray() { PathBuilder<User> entityPath = new PathBuilder<User>(User.class, "entity"); ArrayPath<String[], String> array = entityPath.getArray("array", String[].class); assertEquals(String[].class, array.getType()); assertEquals(String.class, array.getElementType()); }
@Test public void getList() { PathBuilder<User> entityPath = new PathBuilder<User>(User.class, "entity"); entityPath.getList("list", String.class, StringPath.class).get(0).lower(); entityPath.getList("list", String.class).get(0); }
@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 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()); }
@Test public void various() { PathBuilder<User> entity = new PathBuilder<User>(User.class, "entity"); entity.getBoolean("boolean"); entity.getCollection("col", User.class); entity.getComparable("comparable", Comparable.class); entity.getDate("date", Date.class); entity.getDateTime("dateTime", Date.class); entity.getList("list", User.class); entity.getMap("map", String.class, User.class); entity.getNumber("number", Integer.class); entity.getSet("set", User.class); entity.getSimple("simple", Object.class); entity.getString("string"); entity.getTime("time", Time.class); }
@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 test() { DummySerializer serializer = new DummySerializer(new JavaTemplates()); StringPath strPath = Expressions.stringPath("str"); // path serializer.handle(strPath); // operation serializer.handle(strPath.isNotNull()); // long path serializer.handle(new PathBuilder<Object>(Object.class,"p").getList("l",Map.class).get(0)); // constant serializer.handle(ConstantImpl.create("")); // custom serializer.handle(ExpressionUtils.template(Object.class, "xxx", ConstantImpl.create(""))); }