@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 clazz * @return */ @SuppressWarnings("unchecked") public <T> PathBuilder<T> create(Class<T> clazz) { PathBuilder<T> rv = (PathBuilder<T>) paths.get(clazz); if (rv == null) { rv = new PathBuilder<T>(clazz, CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_CAMEL, clazz.getSimpleName())); paths.put(clazz, rv); } return rv; }
/** * {@inheritDoc} */ @Override public <T, E extends Comparable<?>> SearchResults<T> findByCriteria( Class<T> entityClass, Map<String, List<String>> filterByAssociations, Map<String, List<String>> orderByAssociations, DatatablesCriterias datatablesCriterias, BooleanBuilder basePredicate, boolean distinct, Object[] rowsOnTopIds) throws IllegalArgumentException { Assert.notNull(entityClass); // Query DSL builder PathBuilder<T> entity = new PathBuilder<T>(entityClass, "entity"); return findByCriteria(entity, filterByAssociations, orderByAssociations, datatablesCriterias, basePredicate, distinct, rowsOnTopIds); }
/** * {@inheritDoc} */ @Override public <T, E extends Comparable<?>> SearchResults<T> findByCriteria( Class<T> entityClass, Map<String, List<String>> filterByAssociations, Map<String, List<String>> orderByAssociations, DatatablesCriterias datatablesCriterias, BooleanBuilder basePredicate, boolean distinct) throws IllegalArgumentException { Assert.notNull(entityClass); // Query DSL builder PathBuilder<T> entity = new PathBuilder<T>(entityClass, "entity"); return findByCriteria(entity, filterByAssociations, orderByAssociations, datatablesCriterias, basePredicate, distinct, null); }
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); }
/** * Get a PathBuilder instance for the given property * * @param property property name * @return */ @SuppressWarnings("unchecked") public PathBuilder<Object> get(String property) { PathBuilder<Object> path = (PathBuilder) properties.get(property); if (path == null) { Class<?> vtype = validate(property, Object.class); path = new PathBuilder<Object>(vtype, forProperty(property), validator); properties.put(property, path); } return path; }
/** * Get a PathBuilder for the given property with the given type * * @param <A> * @param property property name * @param type * @return */ @SuppressWarnings("unchecked") public <A> PathBuilder<A> get(String property, Class<A> type) { PathBuilder<A> path = (PathBuilder<A>) properties.get(property); if (path == null || !type.isAssignableFrom(path.getType())) { Class<? extends A> vtype = validate(property, type); path = new PathBuilder<A>(vtype, forProperty(property), validator); properties.put(property, path); } return path; }
public static PathBuilder<?> join(JPACommonQuery<?> 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; }
/** * Create a new BeanGridDataSource instance with filter conditions * * @param sessionFactory * @param entity * root entity of the query * @param defaultOrder * default order for queries, if no order is specified * @param caseSensitive * case sensitive ordering * @param conditions * filter conditions */ @SuppressWarnings("unchecked") public BeanGridDataSource(SessionFactory sessionFactory, EntityPath<T> entity, OrderSpecifier<?> defaultOrder, boolean caseSensitive, @Nullable Predicate conditions) { this.sessionFactory = Assert.notNull(sessionFactory, "sessionFactory"); this.entityType = (Class<T>) Assert.notNull(entity.getType(), "entity has no type"); this.entityPath = new PathBuilder<T>(entity.getType(), entity.getMetadata()); this.defaultOrder = Assert.notNull(defaultOrder, "defaultOrder"); this.conditions = conditions; this.caseSensitive = caseSensitive; }
@Test public void QueryAll() { System.out.println("Query all notes"); PathBuilder<Note> note = new PathBuilder<Note>(Note.class, "note"); List<Note> notes = session.from(note).list(note); assertEquals(2, notes.size()); }
@Test public void Query_For_Notes() { System.out.println("Query all notes"); PathBuilder<Note> note = new PathBuilder<Note>(Note.class, "note"); List<Note> notes = session.from(note).list(note); assertEquals(2, notes.size()); }
@Test(expected = IllegalArgumentException.class) public void FindUnknown2() { // launchpad bug : #576846 PathBuilder<SessionTest> entity = new PathBuilder<SessionTest>(SessionTest.class, "var"); session.from(entity).list(entity); }
default Iterable<CollectorItem> findAllByOptionNameValue(String optionName, String optionValue) { PathBuilder<CollectorItem> path = new PathBuilder<>(CollectorItem.class, "collectorItem"); BooleanBuilder builder = new BooleanBuilder(); builder.and(path.get("options", Map.class).get(optionName, String.class).eq(optionValue)); return findAll(builder.getValue()); }
@SuppressWarnings("unchecked") @Test public void PackageLess_Path() { JPASubQuery query = new JPASubQuery(); PathBuilder builder = new PathBuilder(PackagelessEntityTest.class,"entity"); query.from(builder); assertEquals("select entity\nfrom PackagelessEntityTest entity", query.toString()); }
default List<Component> findByCollectorTypeAndItemIdIn(CollectorType collectorType, List<ObjectId> collectorItemIds) { BooleanBuilder builder = new BooleanBuilder(); PathBuilder<Component> path = new PathBuilder<>(Component.class, "components"); builder.and(path.get("collectorItems", Map.class).get(collectorType.toString(),List.class).get("id", ObjectId.class).in(collectorItemIds)); return (List<Component>) findAll(builder.getValue()); } }
public static void orderBy(JPACommonQuery<?> query, EntityPath<?> entity, List<String> order) { PathBuilder<?> builder = new PathBuilder(entity.getType(), entity.getMetadata()); Map<String, PathBuilder<?>> joins = Maps.newHashMap(); for (String entry : order) { String[] tokens = DOT.split(entry); if (tokens.length > 1) { String[] parent = new String[tokens.length - 1]; System.arraycopy(tokens, 0, parent, 0, tokens.length - 1); PathBuilder<?> parentAlias = join(query, builder, joins, StringUtils.join(parent, ".")); query.orderBy(parentAlias.getString(tokens[tokens.length - 1]).asc()); } else { query.orderBy(builder.getString(tokens[0]).asc()); } } }
default Iterable<CollectorItem> findAllByOptionNameValueAndCollectorIdsIn(String optionName, String optionValue, List<ObjectId> collectorIds) { PathBuilder<CollectorItem> path = new PathBuilder<>(CollectorItem.class, "collectorItem"); BooleanBuilder builder = new BooleanBuilder(); builder.and(path.get("collectorId", ObjectId.class).in(collectorIds)); builder.and(path.get("options", Map.class).get(optionName, String.class).eq(optionValue)); return findAll(builder.getValue()); } }
@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 FunctionCall() { //select tab.col from Table tab join TableValuedFunction('parameter') func on tab.col not like func.col QSurvey table = new QSurvey("SURVEY"); RelationalFunctionCall<String> func = RelationalFunctionCall.create(String.class, "TableValuedFunction", "parameter"); PathBuilder<String> funcAlias = new PathBuilder<String>(String.class, "tokFunc"); SQLSubQuery sq = new SQLSubQuery(); SubQueryExpression<?> expr = sq.from(table) .join(func, funcAlias).on(table.name.like(funcAlias.getString("prop")).not()).list(table.name); Configuration conf = new Configuration(new SQLServerTemplates()); SQLSerializer serializer = new NativeSQLSerializer(conf, true); serializer.serialize(expr.getMetadata(), false); assertEquals("select SURVEY.NAME\n" + "from SURVEY SURVEY\n" + "join TableValuedFunction(?1) as tokFunc\n" + "on not (SURVEY.NAME like tokFunc.prop escape '\\')", serializer.toString()); }