private void interpretQueryFilter(InterpretationContext context, ObjectQuery query) throws QueryException { if (query != null && query.getFilter() != null) { Condition c = interpretFilter(context, query.getFilter(), null); context.getHibernateQuery().addCondition(c); } }
/** * Loads the list of resources assumed to implement the given concept. The concept must be a named * concept and cannot be mapped to rdfs:Resource. */ public synchronized <T> Result<T> getObjects(final Class<T> concept, Resource... resources) throws RepositoryException, QueryEvaluationException { try { int size = resources.length; ObjectQuery query = getObjectQuery(concept, size); if (size == 1) { query.setBinding(ObjectFactory.VAR_PREFIX, resources[0]); } else if (size > 1) { for (int i = 0; i < size; i++) { query.setBinding(ObjectFactory.VAR_PREFIX + i, resources[i]); } } final List<Resource> list = new ArrayList<Resource>(size); list.addAll(Arrays.asList(resources)); CloseableIteration<T, QueryEvaluationException> iter; final Result<T> result = query.evaluate(concept); iter = new LookAheadIteration<T, QueryEvaluationException>() { @Override protected T getNextElement() throws QueryEvaluationException { T next = result.next(); if (next != null) { list.remove(((RDFObject) next).getResource()); return next; } if (!list.isEmpty()) return (T) cache(of.createObject(list.remove(0))); return null; } }; return new ResultImpl<T>(iter); } catch (MalformedQueryException e) { throw new AssertionError(e); } }
private ObjectQuery createQuery() { AccountContentSearchDto dto = searchModel.getObject(); if (StringUtils.isEmpty(dto.getSearchText())) { return null; } try { ObjectQuery query = null; List<ObjectFilter> conditions = new ArrayList<>(); ObjectClassComplexTypeDefinition def = getAccountDefinition(); if (dto.isIdentifiers()) { List<ResourceAttributeDefinition> identifiers = new ArrayList<>(); if (def.getIdentifiers() != null) { identifiers.addAll(def.getIdentifiers()); } // TODO set matching rule instead fo null for (ResourceAttributeDefinition attrDef : identifiers) { conditions.add( EqualFilter.createEqual( new ItemPath(ShadowType.F_ATTRIBUTES, attrDef.getName()), attrDef, dto.getSearchText())); } } if (dto.isName()) { List<ResourceAttributeDefinition> secondaryIdentifiers = new ArrayList<>(); if (def.getNamingAttribute() != null) { secondaryIdentifiers.add(def.getNamingAttribute()); } else if (def.getSecondaryIdentifiers() != null) { secondaryIdentifiers.addAll(def.getSecondaryIdentifiers()); } for (ResourceAttributeDefinition attrDef : secondaryIdentifiers) { conditions.add( SubstringFilter.createSubstring( new ItemPath(ShadowType.F_ATTRIBUTES, attrDef.getName()), attrDef, dto.getSearchText())); } } if (!conditions.isEmpty()) { if (conditions.size() > 1) { query = ObjectQuery.createObjectQuery(OrFilter.createOr(conditions)); } else { query = ObjectQuery.createObjectQuery(conditions.get(0)); } } return query; } catch (Exception ex) { error(getString("pageUsers.message.queryError") + " " + ex.getMessage()); LoggingUtils.logException(LOGGER, "Couldn't create query filter.", ex); } return null; }
private ObjectQuery getAssociationsSearchQuery( PrismContext prismContext, PrismObject resource, QName objectClass, ShadowKindType kind, String intent) { try { ObjectFilter andFilter = AndFilter.createAnd( EqualFilter.createEqual( ShadowType.F_OBJECT_CLASS, ShadowType.class, prismContext, objectClass), EqualFilter.createEqual(ShadowType.F_KIND, ShadowType.class, prismContext, kind), // EqualFilter.createEqual(ShadowType.F_INTENT, ShadowType.class, // prismContext, intent), RefFilter.createReferenceEqual( new ItemPath(ShadowType.F_RESOURCE_REF), ShadowType.class, prismContext, resource.getOid())); ObjectQuery query = ObjectQuery.createObjectQuery(andFilter); return query; } catch (SchemaException ex) { LoggingUtils.logUnexpectedException(LOGGER, "Unable to create associations search query", ex); return null; } }
private ObjectQuery createQuery() { ReportOutputSearchDto dto = searchModel.getObject(); try { List<ObjectFilter> ands = new ArrayList<>(); if (StringUtils.isNotEmpty(dto.getText())) { PolyStringNormalizer normalizer = getPrismContext().getDefaultPolyStringNormalizer(); String normalizedString = normalizer.normalize(dto.getText()); SubstringFilter substring = SubstringFilter.createSubstring( ReportOutputType.F_NAME, ReportOutputType.class, getPrismContext(), PolyStringNormMatchingRule.NAME, normalizedString); ands.add(substring); } String oid = dto.getReportTypeMap().get(dto.getReportType()); if (StringUtils.isNotEmpty(oid)) { RefFilter ref = RefFilter.createReferenceEqual( ReportOutputType.F_REPORT_REF, ReportOutputType.class, getPrismContext(), oid); ands.add(ref); } switch (ands.size()) { case 0: return null; case 1: return ObjectQuery.createObjectQuery(ands.get(0)); default: AndFilter and = AndFilter.createAnd(ands); return ObjectQuery.createObjectQuery(and); } } catch (Exception e) { error(getString("pageCreatedReports.message.queryError") + " " + e.getMessage()); LoggingUtils.logException(LOGGER, "Couldn't create query filter.", e); return null; } }
private void interpretPagingAndSorting( InterpretationContext context, ObjectQuery query, boolean countingObjects) throws QueryException { RootHibernateQuery hibernateQuery = context.getHibernateQuery(); String rootAlias = hibernateQuery.getPrimaryEntityAlias(); if (query != null && query.getPaging() instanceof ObjectPagingAfterOid) { ObjectPagingAfterOid paging = (ObjectPagingAfterOid) query.getPaging(); if (paging.getOidGreaterThan() != null) { Condition c = hibernateQuery.createSimpleComparisonCondition( rootAlias + ".oid", paging.getOidGreaterThan(), ">"); hibernateQuery.addCondition(c); } } if (!countingObjects && query != null && query.getPaging() != null) { if (query.getPaging() instanceof ObjectPagingAfterOid) { updatePagingAndSortingByOid( hibernateQuery, (ObjectPagingAfterOid) query.getPaging()); // very special case - ascending ordering by OID (nothing more) } else { updatePagingAndSorting(context, query.getPaging()); } } }