/** * Creates an IN restriction for this property based on the given list of literals * * @param values The literal values * * @return The IN restriction * * @see Restrictions#in(String, Object[]) */ public Criterion in(Object... values) { return Restrictions.in( getPropertyName(), values ); }
/** * Creates an IN restriction for this property based on the given list of literals * * @param values The literal values * * @return The IN restriction * * @see Restrictions#in(String, Collection) */ public Criterion in(Collection values) { return Restrictions.in( getPropertyName(), values ); }
@Override public List<Topic> findTopicsByIds(List<String> ids) { List<Topic> topics = Collections.emptyList(); LOG.debug("Searching topics by ids [{}]", ids); if (ids != null && !ids.isEmpty()) { List<Long> lids = toLongIds(ids); if (!lids.isEmpty()) { topics = findListByCriterion(in(ID_PROPERTY, lids)); } } if (LOG.isTraceEnabled()) { LOG.trace("[{}] Search result: {}.", ids, Arrays.toString(topics.toArray())); } else { LOG.debug("[{}] Search result: {}.", ids, topics.size()); } return topics; }
@Override public List<ApplicationEventFamilyMap> findByIds(List<String> ids) { List<ApplicationEventFamilyMap> applicationEventFamilyMaps = Collections.emptyList(); String idsArray = ""; if (ids != null && !ids.isEmpty()) { idsArray = Arrays.toString(ids.toArray()); LOG.debug("Searching application event family maps by ids {} ", idsArray); applicationEventFamilyMaps = findListByCriterion(Restrictions.in( ID_PROPERTY, toLongIds(ids))); } if (LOG.isTraceEnabled()) { LOG.trace("{} Search result: {}.", idsArray, Arrays.toString( applicationEventFamilyMaps.toArray())); } else { LOG.debug("{} Search result: {}.", idsArray, applicationEventFamilyMaps.size()); } return applicationEventFamilyMaps; }
@Override public List<User> findByTenantIdAndAuthorities(String id, String... authorities) { if (authorities != null) { if (LOG.isTraceEnabled()) { LOG.trace("Searching user by tenant id [{}] and authorities [{}]", id, Arrays.toString(authorities)); } else { LOG.debug("Searching user by tenant id [{}] and authorities [{}]", id, authorities.length); } } List<User> users = findListByCriterionWithAlias(TENANT_PROPERTY, TENANT_ALIAS, Restrictions.and( Restrictions.eq(TENANT_REFERENCE, Long.valueOf(id)), Restrictions.in(AUTHORITY_PROPERTY, KaaAuthorityDto.parseList(authorities)))); if (LOG.isTraceEnabled()) { LOG.trace("[{}] Search result: {}.", id, Arrays.toString(users.toArray())); } else { LOG.debug("[{}] Search result: {}.", id, users.size()); } return users; }
@Override public List<EndpointProfileSchema> findVacantSchemas(String appId, List<String> usedSchemaIds) { LOG.debug("Searching vacant schemas by application id [{}] and used schema ids [{}] ", appId, usedSchemaIds); List<EndpointProfileSchema> schemas = Collections.emptyList(); if (isNotBlank(appId)) { Criteria criteria = getCriteria().createAlias(APPLICATION_PROPERTY, APPLICATION_ALIAS) .add(Restrictions.eq(APPLICATION_REFERENCE, Long.valueOf(appId))); if (usedSchemaIds != null && !usedSchemaIds.isEmpty()) { criteria.add(Restrictions.not(Restrictions.in(ID_PROPERTY, toLongIds(usedSchemaIds)))); } schemas = findListByCriteria(criteria); } if (LOG.isTraceEnabled()) { LOG.trace("[{}] Search result: {}.", appId, Arrays.toString(schemas.toArray())); } else { LOG.debug("[{}] Search result: {}.", appId, schemas.size()); } return schemas; }
private DetachedCriteria buildPMRDetachedQuery(List<Long> pipelineIds) { DetachedCriteria criteria = DetachedCriteria.forClass(PipelineMaterialRevision.class); criteria.add(Restrictions.in("pipelineId", pipelineIds)); criteria.setResultTransformer(CriteriaSpecification.DISTINCT_ROOT_ENTITY); return criteria; }
@Override public List<ConfigurationSchema> findVacantSchemas(String appId, List<String> usedSchemaIds) { LOG.debug("Searching vacant schemas by application id [{}] ", appId); List<ConfigurationSchema> schemas = Collections.emptyList(); if (isNotBlank(appId)) { List<Long> lids = toLongIds(usedSchemaIds); if (lids.isEmpty()) { schemas = findListByCriterionWithAlias(APPLICATION_PROPERTY, APPLICATION_ALIAS, Restrictions.eq(APPLICATION_REFERENCE, Long.valueOf(appId))); } else { schemas = findListByCriterionWithAlias(APPLICATION_PROPERTY, APPLICATION_ALIAS, Restrictions.and( Restrictions.eq(APPLICATION_REFERENCE, Long.valueOf(appId)), Restrictions.not(Restrictions.in(ID_PROPERTY, lids)))); } } if (LOG.isTraceEnabled()) { LOG.trace("[{}] Search result: {}.", appId, Arrays.toString(schemas.toArray())); } else { LOG.debug("[{}] Search result: {}.", appId, schemas.size()); } return schemas; }
private void checkAndRemoveDuplicates(MaterialInstance materialInstance, List<Modification> newChanges, ArrayList<Modification> list) { if (!new SystemEnvironment().get(SystemEnvironment.CHECK_AND_REMOVE_DUPLICATE_MODIFICATIONS)) { return; } DetachedCriteria criteria = DetachedCriteria.forClass(Modification.class); criteria.setProjection(Projections.projectionList().add(Projections.property("revision"))); criteria.add(Restrictions.eq("materialInstance.id", materialInstance.getId())); ArrayList<String> revisions = new ArrayList<>(); for (Modification modification : newChanges) { revisions.add(modification.getRevision()); } criteria.add(Restrictions.in("revision", revisions)); List<String> matchingRevisionsFromDb = (List<String>) getHibernateTemplate().findByCriteria(criteria); if (!matchingRevisionsFromDb.isEmpty()) { for (final String revision : matchingRevisionsFromDb) { Modification modification = list.stream().filter(item -> item.getRevision().equals(revision)).findFirst().orElse(null); list.remove(modification); } } if (!newChanges.isEmpty() && list.isEmpty()) { LOGGER.debug("All modifications already exist in db [{}]", revisions); } if (!matchingRevisionsFromDb.isEmpty()) { LOGGER.info("Saving revisions for material [{}] after removing the following duplicates {}", materialInstance.toOldMaterial(null, null, null).getLongDescription(), matchingRevisionsFromDb); } }
Restrictions.in( "address", mark.getAddress(), joe.getAddress() ) ).list();
.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) .setFetchMode("baz", FetchMode.SELECT) .add( Restrictions.eq( "integer", f.getInteger() ) ) .add( Restrictions.like( "string", f.getString() ) ) .add( Restrictions.in( "boolean", f.getBoolean(), f.getBoolean() ) ) .add( Restrictions.isNotNull("foo") ) .setFetchMode( "foo", FetchMode.JOIN )
Restrictions.in( "address", new Address[] { mark.getAddress(), joe.getAddress() } ) ).list();
@Override public DetachedCriteria getCriteria(DetachedCriteria criteria, String key, Object value) throws QueryException { criteria.add(Restrictions.in(key, (List) value)); return criteria; }
@Override public DetachedCriteria getCriteria(DetachedCriteria criteria, String key, Object value) throws QueryException { criteria.add(Restrictions.not(Restrictions.in(key, (List) value))); 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(); }
public List<User> getUserListByUserIds(List userIds) { DetachedCriteria criteria = DetachedCriteria.forClass(User.class); criteria.add(Restrictions.in("id", userIds)); List<User> userList = this.findByCriteria(criteria); return userList; }
@Override public <E> List<E> findAll(Class<E> entityClazz, String[] columnsToSelect, Object... arg1) { // TODO: Vivek correct it. unfortunately i need to open a new session // for each finder to avoid lazy loading. Session s = getSession(); EntityMetadata entityMetadata = KunderaMetadataManager.getEntityMetadata(kunderaMetadata, getPersistenceUnit(), entityClazz); Object[] pKeys = getDataType(entityMetadata, arg1); String id = ((AbstractAttribute) entityMetadata.getIdAttribute()).getJPAColumnName(); Criteria c = s.createCriteria(entityClazz); c.add(Restrictions.in(id, pKeys)); return c.list(); }
@Override public List<MessageGroup> getGroupListByIds(String groupIds) { DetachedCriteria criteria = DetachedCriteria.forClass(MessageGroup.class); String[] groupArr = groupIds.split(","); criteria.add(Restrictions.in("groupId", groupArr)); criteria.addOrder(Order.desc("sort")); return this.findByCriteria(criteria); }
@Override public List<String> findChiefs(String startUserId, String groupId) { List<String> userIds = identityPageService.getUserIdsByGroupIds(groupId); User user = this.get(User.class, startUserId); DetachedCriteria criteria = DetachedCriteria.forClass(User.class); criteria.add(Restrictions.in("id", userIds)); criteria.add(Restrictions.eq("deptId", user.getDeptId())); List<String> retIds = new ArrayList<>(); List<User> users = this.findByCriteria(criteria); for (User user1 : users) { retIds.add(user1.getId()); } return retIds; }
public Result delete(String ids) { DetachedCriteria criteria = DetachedCriteria.forClass(UserRole.class); criteria.add(Restrictions.in("id", ids.split(","))); List<UserRole> urlist = this.findByCriteria(criteria); for (UserRole userRole : urlist) { this.deleteAuthInRedis(userRole.getUser().getId()); } this.batchDelete(urlist); return new Result(); }