Refine search
Criterion prepareCriterionForAttribute(String value, Boolean voided, MatchMode matchMode) { if (voided == null || !voided) { return Restrictions.conjunction().add(Restrictions.eq("attributeType.searchable", true)).add( Restrictions.eq("attribute.voided", false)).add(Restrictions.ilike("attribute.value", value, matchMode)); } else { return Restrictions.conjunction().add(Restrictions.eq("attributeType.searchable", true)).add( Restrictions.ilike("attribute.value", value, matchMode)); } }
public TypedValue[] getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery) throws HibernateException { return conjunction.getTypedValues(criteria, criteriaQuery); }
.add( Restrictions.eq( "integer", f.getInteger() ) ) .add( Restrictions.eqProperty("integer", "integer") ) .add( Restrictions.like( "string", f.getString().toUpperCase(Locale.ROOT) ).ignoreCase() ) .add( Restrictions.in( "boolean", f.getBoolean(), f.getBoolean() ) ) .setFetchMode("foo", FetchMode.JOIN) Restrictions.disjunction() .add( Restrictions.eq( "integer", f.getInteger() ) ) .add( Restrictions.like( "string", f.getString() ) ) .add( Restrictions.eq( "boolean", f.getBoolean() ) ) .add( Restrictions.isNotNull("boolean") )
protected Criteria partnersByAcCriteria( String ac ) { if ( ac == null ) { throw new NullPointerException( "ac" ); } return getSession().createCriteria( InteractorImpl.class ) .add( Restrictions.idEq( ac ) ) .createAlias( "activeInstances", "comp" ) .createAlias( "comp.interaction", "int" ) .createAlias( "int.components", "intcomp" ) .createAlias( "intcomp.interactor", "prot" ) .add( Restrictions.disjunction() .add( Restrictions.ne( "prot.ac", ac ) ) .add( Restrictions.eq( "comp.stoichiometry", 2f ) ) ); }
} else if (objectArray.length > 1) { if (Restriction.NOT_EQUALS == search.getRestrictions()[i].comparison) { junction.add( Restrictions.not( Restrictions.in(property, objectArray) ) ); } else { junction.add(Restrictions.in(property, objectArray)); switch (search.getRestrictions()[i].comparison) { case Restriction.EQUALS: junction.add(Restrictions.eq(property, value)); break; case Restriction.GREATER: junction.add(Restrictions.gt(property, value)); break; case Restriction.LESS: junction.add(Restrictions.lt(property, value)); break; case Restriction.LIKE: junction.add(Restrictions.like(property, value)); break; case Restriction.NULL: junction.add(Restrictions.isNull( property )); break; case Restriction.NOT_NULL: junction.add(Restrictions.isNotNull( property )); break; case Restriction.NOT_EQUALS: junction.add(Restrictions.ne(property, value)); break;
queryStructureRestriction.add(Restrictions.eq(path, compareValue)); break; case ComparableQueryStructureDescriptor.GT: queryStructureRestriction.add(Restrictions.gt(path, compareValue)); break; case ComparableQueryStructureDescriptor.GE: queryStructureRestriction.add(Restrictions.ge(path, compareValue)); break; case ComparableQueryStructureDescriptor.LT: queryStructureRestriction.add(Restrictions.lt(path, compareValue)); break; case ComparableQueryStructureDescriptor.LE: queryStructureRestriction.add(Restrictions.le(path, compareValue)); break; case ComparableQueryStructureDescriptor.NU: queryStructureRestriction.add(Restrictions.isNull(path)); break; case ComparableQueryStructureDescriptor.NN: queryStructureRestriction.add(Restrictions.isNotNull(path)); break; case ComparableQueryStructureDescriptor.BE: if (infValue != null && supValue != null) { queryStructureRestriction.add(Restrictions.between(path, infValue, supValue)); } else if (infValue != null) { queryStructureRestriction.add(Restrictions.ge(path, infValue)); } else { queryStructureRestriction.add(Restrictions.le(path, supValue));
private Criterion getCriterionForNoExactName(String name, boolean includeVoided) { MatchMode matchMode = getMatchMode(); Criterion criterion = Restrictions.conjunction().add( Restrictions.disjunction().add( Restrictions.conjunction().add(Restrictions.isNotNull("name.givenName")).add( Restrictions.like("name.givenName", name, matchMode))).add( Restrictions.conjunction().add(Restrictions.isNotNull("name.middleName")).add( Restrictions.like("name.middleName", name, matchMode))).add( Restrictions.conjunction().add(Restrictions.isNotNull("name.familyName")).add( Restrictions.like("name.familyName", name, matchMode))).add( Restrictions.conjunction().add(Restrictions.isNotNull("name.familyName2")).add( Restrictions.like("name.familyName2", name, matchMode)))).add( Restrictions.disjunction().add(Restrictions.isNull("name.givenName")).add( Restrictions.ne("name.givenName", name))).add( Restrictions.disjunction().add(Restrictions.isNull("name.middleName")).add( Restrictions.ne("name.middleName", name))).add( Restrictions.disjunction().add(Restrictions.isNull("name.familyName")).add( Restrictions.ne("name.familyName", name))).add( Restrictions.disjunction().add(Restrictions.isNull("name.familyName2")).add( Restrictions.ne("name.familyName2", name))); if (!includeVoided) { return Restrictions.conjunction().add(Restrictions.eq("name.voided", false)).add(criterion); } return criterion; }
criteria.add(Restrictions.eq("personA", fromPerson)); criteria.add(Restrictions.eq("personB", toPerson)); criteria.add(Restrictions.eq("relationshipType", relType)); criteria.add(Restrictions.disjunction().add( Restrictions.and(Restrictions.le("startDate", startEffectiveDate), Restrictions.ge("endDate", startEffectiveDate))).add( Restrictions.and(Restrictions.le("startDate", startEffectiveDate), Restrictions.isNull("endDate"))).add( Restrictions.and(Restrictions.isNull("startDate"), Restrictions.ge("endDate", startEffectiveDate))).add( Restrictions.and(Restrictions.isNull("startDate"), Restrictions.isNull("endDate")))); criteria.add(Restrictions.disjunction().add( Restrictions.and(Restrictions.le("startDate", endEffectiveDate), Restrictions .ge("endDate", endEffectiveDate))).add( Restrictions.and(Restrictions.le("startDate", endEffectiveDate), Restrictions.isNull("endDate"))).add( Restrictions.and(Restrictions.isNull("startDate"), Restrictions.ge("endDate", endEffectiveDate))).add( Restrictions.and(Restrictions.isNull("startDate"), Restrictions.isNull("endDate"))));
queryFilter.add(Restrictions.eq("year", myFilter.getFromYear())); queryFilter.add(Restrictions.between("month", 0, 11)); } else if (myFilter.getToYear() > 0) { if (myFilter.getFromYear() == myFilter.getToYear()) { queryFilter.add(Restrictions.eq("year", myFilter.getFromYear())); queryFilter.add(Restrictions.between("month", myFilter.getFromMonth(), myFilter.getToMonth())); } else { Restrictions.and(Restrictions.eq("year", myFilter.getFromYear()), Restrictions.ge("month", myFilter.getFromMonth()))) .add( Restrictions.and(Restrictions.eq("year", myFilter.getToYear()), Restrictions.le("month", myFilter.getToMonth()))) .add( Restrictions.and(Restrictions.gt("year", myFilter.getFromYear()), Restrictions.lt("year", myFilter.getToYear()))));
/** * Provides a Hibernate criteria object for searching patients by name, identifier or searchable attribute. * * The visibility of this method is "default" as this method should NOT be called directly by classes other * than org.openmrs.api.db.hibernate.HibernatePatientDAO. * * Instead of calling this method consider using {@link org.openmrs.api.PatientService} or * {@link org.openmrs.api.db.PatientDAO}. * * @param query defines search parameters * @param includeVoided true/false whether or not to included voided patients * @return criteria for searching by name OR identifier OR searchable attributes */ Criteria prepareCriteria(String query, boolean includeVoided) { addAliasForName(criteria, true); personSearchCriteria.addAliasForAttribute(criteria); addAliasForIdentifiers(criteria); criteria.add(Restrictions.disjunction().add(prepareCriterionForName(query, includeVoided)).add( prepareCriterionForAttribute(query, includeVoided)).add( prepareCriterionForIdentifier(query, new ArrayList<>(), false, includeVoided))); if (!includeVoided) { criteria.add(Restrictions.eq("voided", false)); } criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY); log.debug(criteria.toString()); return criteria; }
Junction translationRestriction = Restrictions.conjunction(); translationRestriction.add(createStringRestriction( ((ICollectionPropertyDescriptor<IPropertyTranslation>) componentDescriptor.getPropertyDescriptor( translationsPath)).getCollectionDescriptor().getElementDescriptor() queryComponent, context)); String languagePath = translationsAlias + "." + IPropertyTranslation.LANGUAGE; translationRestriction.add(Restrictions.eq(languagePath, locale.getLanguage())); translationRestriction.add( Restrictions.eq(translationsAlias + "." + IPropertyTranslation.PROPERTY_NAME, barePropertyName)); Junction disjunction = Restrictions.disjunction(); disjunction.add(translationRestriction); if (nlsOrRawValue != null) { Junction rawValueRestriction = Restrictions.conjunction(); rawValueRestriction.add(Restrictions.disjunction().add(Restrictions.isNull(languagePath)) .add(Restrictions.ne(languagePath, locale.getLanguage()))); String rawPropertyName = barePropertyName + IComponentDescriptor.RAW_SUFFIX; rawValueRestriction.add( createStringRestriction(componentDescriptor.getPropertyDescriptor(rawPropertyName), rawPropertyName, nlsOrRawValue, componentDescriptor, queryComponent, context)); disjunction.add(rawValueRestriction);
@Transactional @Override public UserData findUser(String username, String webId) { DetachedCriteria criteria = createCriteria(); criteria.add(Restrictions.eq(UserData.USERNAME, username)); criteria.add(Restrictions.disjunction().add(Restrictions.eq(UserData.WEB_ID, webId)). add(Restrictions.isNull(UserData.WEB_ID))); return findUniqueResultByCriteria(criteria); }
private void addCriterion( org.hibernate.criterion.Junction criteria, org.hisp.dhis.query.Criterion criterion ) { if ( Restriction.class.isInstance( criterion ) ) { Restriction restriction = (Restriction) criterion; Criterion hibernateCriterion = getHibernateCriterion( restriction ); if ( hibernateCriterion != null ) { criteria.add( hibernateCriterion ); } } else if ( Junction.class.isInstance( criterion ) ) { org.hibernate.criterion.Junction junction = null; if ( Disjunction.class.isInstance( criterion ) ) { junction = Restrictions.disjunction(); } else if ( Conjunction.class.isInstance( criterion ) ) { junction = Restrictions.conjunction(); } criteria.add( junction ); for ( org.hisp.dhis.query.Criterion c : ((Junction) criterion).getCriterions() ) { addJunction( junction, c ); } } }
queryStructureRestriction = Restrictions.disjunction(); if (!inListValues.isEmpty()) { queryStructureRestriction.add(Restrictions.in(path, inListValues)); queryStructureRestriction.add(Restrictions.isNull(path));
private void addRestriction( Junction junction, String property, QueryPhrase value, boolean ignoreCase ) { if ( isValueValid( value ) ) { // classify the terms of the phrase in excluded / included List<QueryTerm> exclusionTerms = new ArrayList<QueryTerm>(); List<QueryTerm> inclusionTerms = new ArrayList<QueryTerm>(); for ( QueryTerm term : value.getTerms() ) { if ( term.hasModifier( QueryModifier.EXCLUDE ) ) { exclusionTerms.add( term ); } else { inclusionTerms.add( term ); } } Junction propertyCriterion; if ( inclusionTerms.isEmpty() || exclusionTerms.isEmpty() ) { propertyCriterion = Restrictions.conjunction(); } else { propertyCriterion = Restrictions.conjunction(); } junction.add( propertyCriterion ); if ( !inclusionTerms.isEmpty() ) { Criterion inclusionCriterion = termDisjunction( property, inclusionTerms, ignoreCase ); propertyCriterion.add( inclusionCriterion ); } if ( !exclusionTerms.isEmpty() ) { Criterion exclusionCriterion = Restrictions.not( termDisjunction( property, exclusionTerms, ignoreCase ) ); propertyCriterion.add( exclusionCriterion ); } } }
criterion = Restrictions.disjunction(); } else { criterion = Restrictions.conjunction(); disjunction.add(build(propertyName,value)); criterion.add(Restrictions.or(disjunction.toArray(new Criterion[disjunction.size()]))); } else { criterion.add(build(filter.getSinglePropertyName(),value));