@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 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 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()); }
/** * Create a new Boolean typed path * * @param path existing path * @return property path */ public BooleanPath get(BooleanPath path) { BooleanPath newPath = getBoolean(toString(path)); return addMetadataOf(newPath, path); }
/** * Create a new String typed path * * @param path existing path * @return property path */ public StringPath get(StringPath path) { StringPath newPath = getString(toString(path)); return addMetadataOf(newPath, path); }
/** * Create a new Comparable typed path * * @param <A> * @param path existing path * @return property path */ @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); }
/** * 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); }
public Projection( Class<T> targetClass ) { PathBuilder<T> entity = new PathBuilder<T>( targetClass, "entity" ); Field[] fields = targetClass.getFields(); Expression[] fieldExpressions = new Expression[fields.length]; for ( int i = 0; i < fields.length; i++ ) { fieldExpressions[i] = entity.getString( fields[i].getName() ); } bean = Projections.fields( targetClass, fieldExpressions ); }
@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()); }
/** * 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; }
@Test public void leftJoinWithoutCodeGeneration() { SQLQuery<?> sqlQuery = queryForMYSQLTemplate(); PathBuilder<Object> customerPath = new PathBuilder<Object>(Object.class, "customer"); PathBuilder<Object> deptPath = new PathBuilder<Object>(Object.class, "department"); Path<Object> deptAliasPath = new PathBuilder<Object>(Object.class, "d"); sqlQuery = sqlQuery.from(customerPath.as("c")); NumberPath<Long> idPath = Expressions.numberPath(Long.class, deptAliasPath, "id"); sqlQuery = sqlQuery.leftJoin(deptPath, deptAliasPath).select(idPath); assertEquals("select d.id from customer as c left join department as d", sqlQuery.toString()); }
@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)); }
@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 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 dynamicQuery2() { PathBuilder<Object> userPath = new PathBuilder<Object>(Object.class, "user"); NumberPath<Long> idPath = userPath.getNumber("id", Long.class); StringPath usernamePath = userPath.getString("username"); Expression<?> sq = select(idPath, usernamePath) .from(userPath).where(idPath.eq(1L)); SQLSerializer serializer = new SQLSerializer(Configuration.DEFAULT); serializer.handle(sq); //USER is a reserved word in ANSI SQL 2008 assertEquals("(select \"user\".id, \"user\".username\n" + "from \"user\"\n" + "where \"user\".id = ?)", serializer.toString()); }
@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 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 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); }
@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()); }
@Before public void setUp() { entity = new PathBuilderFactory().create(Entity.class); name = entity.getString("name"); name2 = entity.getString("name2"); age = entity.getNumber("age", Integer.class); married = entity.getBoolean("married"); }