@SuppressWarnings("unchecked") public Predicate on(RelationalPath<E> entity) { BooleanBuilder builder = new BooleanBuilder(); for (int i = 0; i < localColumns.size(); i++) { Expression<Object> local = (Expression<Object>)localColumns.get(i); Expression<?> foreign = new PathImpl(local.getType(), entity, foreignColumns.get(i)); builder.and(ExpressionUtils.eq(local,foreign)); } return builder.getValue(); }
protected void aggregateFilters() { if (!blocks.isEmpty()) { if (filters.getValue() == null) { super.where(new GroupBlock(blocks)); } else { super.where(new GroupBlock(blocks, filters.getValue())); } } blocks = new ArrayList<Block>(); filters = new BooleanBuilder(); }
public static GroupBlock group(Collection<Predicate> predicates) { List<Block> blocks = new ArrayList<Block>(); BooleanBuilder filters = new BooleanBuilder(); handle(predicates, blocks, filters); if (filters.getValue() == null) { return new GroupBlock(blocks); } else { return new GroupBlock(blocks, filters.getValue()); } }
public static Predicate hasTaxidAndModification(final Integer taxid, final String modId) { BooleanBuilder booleanBuilder = new BooleanBuilder(); booleanBuilder.and(hasTaxid(taxid)); booleanBuilder.and(hasModification(modId)); return booleanBuilder.getValue(); }
public static Predicate isSymbolicPeptideHasTaxidAndTissue (final Integer taxid, final String cvTerm){ BooleanBuilder booleanBuilder = new BooleanBuilder(); booleanBuilder.and(isSymbolicPeptide()); booleanBuilder.and(hasTaxidAndTissue(taxid,cvTerm)); return booleanBuilder.getValue(); }
public static Predicate hasTissueAndModification(final String cvTerm, final String modId) { BooleanBuilder booleanBuilder = new BooleanBuilder(); booleanBuilder.and(hasTissue(cvTerm)); booleanBuilder.and(hasModification(modId)); return booleanBuilder.getValue(); }
public static GraphBlock graph(Expression<UID> context, Collection<Predicate> predicates) { List<Block> blocks = new ArrayList<Block>(); BooleanBuilder filters = new BooleanBuilder(); handle(predicates, blocks, filters); if (filters.getValue() == null) { return new GraphBlock(convert(UID.class, context), blocks); } else { return new GraphBlock(convert(UID.class, context), blocks, filters.getValue()); } }
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()); }
public static Predicate hasTaxidAndTissueAndModification(final Integer taxid, final String cvTerm, final String modId) { BooleanBuilder booleanBuilder = new BooleanBuilder(); booleanBuilder.and(hasTaxid(taxid)); booleanBuilder.and(hasTissue(cvTerm)); booleanBuilder.and(hasModification(modId)); return booleanBuilder.getValue(); } }
private List<XDSFolder> getFolders() { JPAQuery query = new JPAQuery(getSession().getEntityManager()); BooleanBuilder builder = new BooleanBuilder(); addPatientIdMatch(builder, getQueryParam(XDSConstants.QRY_PATIENT_ID)); addStatusMatch(builder, QXDSFolder.xDSFolder.status, getQueryParam(XDSConstants.QRY_FOLDER_STATUS)); List<XDSFolder> folders = query.from(QXDSFolder.xDSFolder) .innerJoin(QXDSFolder.xDSFolder.patient, QXADPatient.xADPatient) .innerJoin(QXADPatient.xADPatient.issuerOfPatientID, QXADIssuer.xADIssuer) .where(builder) .list(QXDSFolder.xDSFolder); log.info("#### Found Folders:"+folders); return folders; }
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 = new SimplePath<Object>(entry.getValue().getClass(), entityPath, entry.getKey()); builder.and(property.eq(entry.getValue())); } ComparablePath<?> sortProperty = new ComparablePath(Comparable.class, entityPath, sort); return new JPAQuery(em).from(entityPath).where(builder.getValue()).orderBy(sortProperty.asc()).list(entityPath); }
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()); } }
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 BooleanBuilder1() { BooleanBuilder bb1 = new BooleanBuilder(); bb1.and(cat.eq(cat)); BooleanBuilder bb2 = new BooleanBuilder(); bb2.or(cat.eq(cat)); bb2.or(cat.eq(cat)); assertToString("cat = cat and (cat = cat or cat = cat)", bb1.and(bb2)); }
@Test public void BooleanBuilder2() { BooleanBuilder bb1 = new BooleanBuilder(); bb1.and(cat.eq(cat)); BooleanBuilder bb2 = new BooleanBuilder(); bb2.or(cat.eq(cat)); bb2.or(cat.eq(cat)); assertToString("cat = cat and (cat = cat or cat = cat)", bb1.and(bb2.getValue())); }
@Test public void BooleanBuilder_With_Null_In_Having() { assertEquals("select cat\nfrom Cat cat\ngroup by cat.name", sub().from(cat).groupBy(cat.name).having(new BooleanBuilder()).toString()); }
@Test public void Clone() { QCat cat = QCat.cat; BooleanBuilder emptyBooleanBuilder = new BooleanBuilder(); HibernateQuery hq = new HibernateQuery().from(cat).where(cat.name.isNull().and(emptyBooleanBuilder)); HibernateQuery hq2 = hq.clone(); assertNotNull(hq2); }
@Test public void test2() { BeanQuery query = session.from($(n)); BooleanBuilder filter = new BooleanBuilder(); filter.and($(n.getTypes()).contains(NoteType.TYPE1)); filter.and($(n.getTypes()).contains(NoteType.TYPE2)); assertEquals(0, query.where(filter).list($(n)).size()); }
@Test public void test4() { BeanQuery query = session.from($(n)); BooleanBuilder filter = new BooleanBuilder(); filter.or($(n.getType()).eq(NoteType.TYPE1)); filter.or($(n.getType()).eq(NoteType.TYPE2)); assertEquals(1, query.where(filter).list($(n)).size()); } }
@Test public void test() throws IOException { Note note = new Note(); note.lemma = "a"; session.save(note); Note noteVar = Alias.alias(Note.class); BooleanBuilder builder = new BooleanBuilder(); builder.or($(noteVar.getLemma()).eq("a")); builder.or($(noteVar.getTerm().getMeaning()).eq("a")); assertFalse(session.from($(noteVar)).where(builder.getValue()).list($(noteVar)).isEmpty()); } }