/** * Deprecated! * * @param associationPath The association path * @param alias The alias to apply to that association path * @param joinType The type of join to use * * @return {@code this}, for method chaining * * @deprecated use {@link #createAlias(String, String, JoinType)} */ @Deprecated public DetachedCriteria createAlias(String associationPath, String alias, int joinType) { return createAlias( associationPath, alias, JoinType.parse( joinType ) ); }
/** * Deprecated! * * @param associationPath The association path * @param alias The alias to apply to that association path * @param joinType The type of join to use * @param withClause An additional restriction on the join * * @return {@code this}, for method chaining * * @deprecated use {@link #createAlias(String, String, JoinType, Criterion)} */ @Deprecated public DetachedCriteria createAlias(String associationPath, String alias, int joinType, Criterion withClause) { return createAlias( associationPath, alias, JoinType.parse( joinType ), withClause ); }
public static DetachedCriteria getCriteriaWithAlias(DetachedCriteria criteria, String columnName) { if (columnName.indexOf(".") == -1) return criteria; String[] nameArr = columnName.split("[.]"); for (int index = 0; index < nameArr.length - 1; index++) { String str = nameArr[index]; if (index > 0 && !isExistAlias((DetachedCriteria) criteria, "" + nameArr[index - 1] + "." + str + "")) { criteria.createAlias("" + nameArr[index - 1] + "." + str + "", "" + str + "", DetachedCriteria.LEFT_JOIN); } if (index == 0 && !isExistAlias((DetachedCriteria) criteria, str)) { criteria.createAlias("" + str + "", "" + str + "", DetachedCriteria.LEFT_JOIN); } } return criteria; }
/** * @see org.openmrs.api.db.LocationDAO#getLocationsHavingAllTags(java.util.List) */ @Override public List<Location> getLocationsHavingAllTags(List<LocationTag> tags) { tags.removeAll(Collections.singleton(null)); DetachedCriteria numberOfMatchingTags = DetachedCriteria.forClass(Location.class, "alias").createAlias("alias.tags", "locationTag").add(Restrictions.in("locationTag.locationTagId", getLocationTagIds(tags))).setProjection( Projections.rowCount()).add(Restrictions.eqProperty("alias.locationId", "outer.locationId")); return sessionFactory.getCurrentSession().createCriteria(Location.class, "outer").add( Restrictions.eq("retired", false)).add(Subqueries.eq(Long.valueOf(tags.size()), numberOfMatchingTags)).list(); }
Criteria criteria = db.getSession().createCriteria(Vendor.class, "vendor"); DetachedCriteria dc = DetachedCriteria.forClass(Vendor.class, "vendor2"); dc.createAlias("vendor2.models", "model"); dc.add(Restrictions.eq("model.deprecated", 0)); dc.add(Restrictions.eqProperty("vendor2.id", "vendor.id")); dc.setProjection(Projections.id()); criteria.add(Subqueries.notExists(dc));
/** * Adds attribute value criteria to the given criteria query * * @param criteria the criteria * @param serializedAttributeValues the serialized attribute values * @param <AT> the attribute type */ public static <AT extends AttributeType> void addAttributeCriteria(Criteria criteria, Map<AT, String> serializedAttributeValues) { Conjunction conjunction = Restrictions.conjunction(); int a = 0; for (Map.Entry<AT, String> entry : serializedAttributeValues.entrySet()) { String alias = "attributes" + (a++); DetachedCriteria detachedCriteria = DetachedCriteria.forClass(Location.class).setProjection(Projections.id()); detachedCriteria.createAlias("attributes", alias); detachedCriteria.add(Restrictions.eq(alias + ".attributeType", entry.getKey())); detachedCriteria.add(Restrictions.eq(alias + ".valueReference", entry.getValue())); detachedCriteria.add(Restrictions.eq(alias + ".voided", false)); conjunction.add(Property.forName("id").in(detachedCriteria)); } criteria.add(conjunction); }
/** * @deprecated use {@link #createAlias(String, String, JoinType, Criterion)} */ @Deprecated public DetachedCriteria createAlias(String associationPath, String alias, int joinType, Criterion withClause) throws HibernateException { return createAlias( associationPath, alias, JoinType.parse( joinType ), withClause ); } /**
/** * @deprecated use {@link #createAlias(String, String, JoinType)} */ @Deprecated public DetachedCriteria createAlias(String associationPath, String alias, int joinType) throws HibernateException { return createAlias( associationPath, alias, JoinType.parse( joinType ) ); } /**
DetachedCriteria criteria = DetachedCriteria.forClass(Log.class); criteria.createAlias("employee", "e"); if (StringUtils.isNotBlank(c.getName())) { criteria.add(Restrictions.ilike("e.name", c.getName(), MatchMode.ANYWHERE)); } if (StringUtils.isNotBlank(c.getAgency())) { criteria.createAlias("e.agency", "a"); // <=========== criteria.add(Restrictions.ilike("a.name", c.getAgency(), MatchMode.ANYWHERE)); }
/** * @deprecated use {@link #createAlias(String, String, JoinType)} */ @Deprecated public DetachedCriteria createAlias(String associationPath, String alias, int joinType) throws HibernateException { return createAlias( associationPath, alias, JoinType.parse( joinType ) ); } /**
/** * @deprecated use {@link #createAlias(String, String, JoinType, Criterion)} */ @Deprecated public DetachedCriteria createAlias(String associationPath, String alias, int joinType, Criterion withClause) throws HibernateException { return createAlias( associationPath, alias, JoinType.parse( joinType ), withClause ); } /**
DetachedCriteria subquery = DetachedCriteria .forClass(Family.class, "family") .add(Expression.eq("family.id", family.getId())); subquery.createAlias("members", "members") .add(Restrictions.eqProperty("members.id", "m.id")) .add(Expression.eq("members.DOB",Date)); subquery.setProjection(Property.forName("members.id")); Criteria crit = session.createCriteria(Member.class, "m") .add(Subqueries.propertyIn("m.id", subquery)); results = crit.list();
DetachedCriteria excludedGroups = DetachedCriteria.forClass(Group.class); excludedGroups.createAlias("userCollection", "u"); excludedGroups.add(Restrictions.isNotNull("u.birthDate")); excludedGroups.setProjection(Projections.id()); Criteria c = session.createCriteria(Group.class); c.add(Subqueries.propertyNotIn("id", excludedGroups));
Criteria criteria = getSession().createCriteria(A.class, "a1"); criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY); DetachedCriteria detachedCriteria = DetachedCriteria.forClass(B.class, "b"); detachedCriteria.createAlias("b.a", "a2"); detachedCriteria.add(Restrictions.eqProperty("a1.id", "a2.id")); detachedCriteria.add(Restrictions.in("name", new String[]{"name 1","name 2"})) criteria.add(Subqueries.exists(detachedCriteria)); return criteria.list();
Criteria c = session.createCriteria(User.class, "user"); DetachedCriteria roleOfUserWithName = DetachedCriteria.forClass(Role.class, "role"); roleOfUserWithName.createAlias("role.users", "userOfTheRole"); roleOfUserWithName.add(Restrictions.eqProperty("userOfTheRole.id", "user.id")); roleOfUserWithName.add(Restrictions.eq("role.name", roleName); roleOfUserWithName.setProjection(Projections.id()); c.add(Subqueries.notExists(roleOfUserWithName));
protected void copyOrdersAndTheirSubcriteriaFromCriteriaToAnother(Criteria executable, DetachedCriteria criteria){ Map<Subcriteria, Order> aliasToOrderMap = getSortSubcriteriaFromCriteria(executable); for(Subcriteria subcriteria : aliasToOrderMap.keySet()){ criteria.createAlias(subcriteria.getPath(), subcriteria.getAlias(), subcriteria.getJoinType()); } for(Order order : aliasToOrderMap.values()){ criteria.addOrder(order); } }
private DetachedCriteria createSeriesSubQueryViaExplicitJoin(String alias, DbQuery query) { return DetachedCriteria.forClass(SeriesEntity.class) .add(Restrictions.eq("published", Boolean.TRUE)) .createAlias(alias, "ref") .setProjection(Projections.property("ref.pkid")); }
@Override public void restrictPaginationByArrayed(Criteria criteria, boolean isArrayed, Consumer<String> errorHandler) { DetachedCriteria subquery = DetachedCriteria.forClass(Array.class) .createAlias("samples", "sample") .setProjection(Projections.property("sample.id")); if (isArrayed) { criteria.add(Property.forName("id").in(subquery)); } else { criteria.add(Property.forName("id").notIn(subquery)); } }
DetachedCriteria dc = getDetachedCriteria(); dc.createAlias("userLoginStatus", "uls"); dc.add(Projections.property("firstName")); dc.add(Projections.property("lastName")); dc.add(Projections.property("userType")); dc.addOrder(Order.asc("firstName")); return getAll(dc, pageSetting);
private Criteria getBasicMapCriteria() { DetachedCriteria detachedCriteria = DetachedCriteria.forClass(StatisticsCounter.class) .createAlias("scanRepeatFindingMap", "mapAlias") .add(Restrictions.isNotNull("scanRepeatFindingMap")) .setProjection(property("mapAlias.id")); return sessionFactory.getCurrentSession() .createCriteria(ScanRepeatFindingMap.class) .add(Property.forName("id").notIn(detachedCriteria)); }