@NotNull private ObjectQuery replaceSimplifiedFilter(ObjectQuery query, ObjectFilter filter) { query = query.cloneEmpty(); query.setFilter(filter instanceof AllFilter ? null : filter); return query; }
private ObjectQuery updateObjectQuery(ObjectQuery origQuery, ObjectFilter updatedFilter) { if (origQuery != null) { origQuery.setFilter(updatedFilter); return origQuery; } else if (updatedFilter == null) { return null; } else { return getPrismContext().queryFactory().createQuery(updatedFilter); } }
public static ObjectQuery evaluateQueryExpressions(ObjectQuery origQuery, ExpressionVariables variables, ExpressionFactory expressionFactory, PrismContext prismContext, String shortDesc, Task task, OperationResult result) throws SchemaException, ObjectNotFoundException, ExpressionEvaluationException, CommunicationException, ConfigurationException, SecurityViolationException { if (origQuery == null) { return null; } ObjectQuery query = origQuery.clone(); ObjectFilter evaluatedFilter = evaluateFilterExpressionsInternal(query.getFilter(), variables, expressionFactory, prismContext, shortDesc, task, result); query.setFilter(evaluatedFilter); return query; }
private ObjectQuery addFilter(ObjectQuery query, ObjectFilter additionalFilter) { ObjectQuery newQuery; QueryFactory queryFactory = prismContext.queryFactory(); if (query == null) { newQuery = queryFactory.createQuery(additionalFilter); } else { newQuery = query.clone(); if (query.getFilter() == null) { newQuery.setFilter(additionalFilter); } else { newQuery.setFilter(queryFactory.createAnd(query.getFilter(), additionalFilter)); } } return newQuery; }
/** * Both ObjectType and AssignmentHolderType are mapped to RObject. So when searching for AssignmentHolderType it is not sufficient to * query this table. This method hacks this situation a bit by introducing explicit type filter for AssignmentHolderType. */ private ObjectQuery refineAssignmentHolderQuery(Class<? extends Containerable> type, ObjectQuery query) { if (!type.equals(AssignmentHolderType.class)) { return query; } if (query == null) { query = prismContext.queryFactory().createQuery(); } query.setFilter(prismContext.queryFactory().createType(AssignmentHolderType.COMPLEX_TYPE, query.getFilter())); return query; } }
@Override protected ObjectQuery createQuery(AbstractScannerResultHandler<ShadowType> handler, TaskRunResult runResult, Task task, OperationResult opResult) throws SchemaException { ObjectQuery query = getPrismContext().queryFactory().createQuery(); ObjectFilter filter = prismContext.queryFor(ShadowType.class) .exists(ShadowType.F_PENDING_OPERATION) .buildFilter(); query.setFilter(filter); return query; }
public ObjectQuery narrowQueryForWorkBucket(Task workerTask, ObjectQuery query, Class<? extends ObjectType> type, Function<ItemPath, ItemDefinition<?>> itemDefinitionProvider, WorkBucketType workBucket, OperationResult result) throws SchemaException, ObjectNotFoundException { Context ctx = createContext(workerTask.getOid(), () -> true, result); TaskWorkManagementType config = ctx.getWorkStateConfiguration(); AbstractWorkSegmentationType bucketsConfig = TaskWorkStateTypeUtil.getWorkSegmentationConfiguration(config); WorkBucketContentHandler handler = handlerFactory.getHandler(workBucket.getContent()); List<ObjectFilter> conjunctionMembers = new ArrayList<>( handler.createSpecificFilters(workBucket, bucketsConfig, type, itemDefinitionProvider)); if (conjunctionMembers.isEmpty()) { return query; } ObjectFilter existingFilter = query != null ? query.getFilter() : null; if (existingFilter != null) { conjunctionMembers.add(existingFilter); } ObjectFilter updatedFilter; if (conjunctionMembers.isEmpty()) { updatedFilter = null; } else if (conjunctionMembers.size() == 1) { updatedFilter = conjunctionMembers.get(0); } else { updatedFilter = prismContext.queryFactory().createAnd(conjunctionMembers); } ObjectQuery updatedQuery = query != null ? query.clone() : prismContext.queryFactory().createQuery(); updatedQuery.setFilter(updatedFilter); // TODO update sorting criteria return updatedQuery; }
ObjectQuery query = prismContext.queryFactory().createQuery(); if (searchFilter != null) { query.setFilter(getQueryConverter().parseFilter(searchFilter, objectClass));
@Override protected ObjectQuery createQuery(PropagationResultHandler handler, TaskRunResult runResult, Task coordinatorTask, OperationResult opResult) { ObjectQuery query = prismContext.queryFactory().createQuery(); ObjectFilter filter = prismContext.queryFor(ShadowType.class) .item(ShadowType.F_RESOURCE_REF).ref(handler.getResource().getOid()) .and() .exists(ShadowType.F_PENDING_OPERATION) .buildFilter(); query.setFilter(filter); return query; }
private <O extends Containerable> ObjectQuery createObjectQueryInternal(PrismContainerDefinition<O> objDef, SearchFilterType filterType, PagingType pagingType) throws SchemaException { try { ObjectQuery query = ObjectQueryImpl.createObjectQuery(); if (filterType != null && filterType.containsFilterClause()) { MapXNodeImpl rootFilter = (MapXNodeImpl) filterType.getFilterClauseXNode(); ObjectFilter filter = parseFilter(rootFilter, objDef); query.setFilter(filter); } if (pagingType != null) { ObjectPaging paging = PagingConvertor.createObjectPaging(pagingType, prismContext); query.setPaging(paging); } return query; } catch (SchemaException ex) { throw new SchemaException("Failed to convert query. Reason: " + ex.getMessage(), ex); } }
@Test public void test0331InOidEmptyTest() throws Exception { ObjectQuery query = prismContext.queryFor(ObjectType.class) .id(new String[0]).build(); query.setFilter(ObjectQueryUtil.simplify(query.getFilter(), prismContext)); assertTrue("Wrongly reduced InOid filter: " + query.getFilter(), query.getFilter() instanceof NoneFilter); }
@Test public void test0333LongInOidEmptyTest() throws Exception { ObjectQuery query = prismContext.queryFor(ObjectType.class) .id(new long[0]).build(); query.setFilter(ObjectQueryUtil.simplify(query.getFilter(), prismContext)); assertTrue("Wrongly reduced InOid filter: " + query.getFilter(), query.getFilter() instanceof NoneFilter); }
@Test public void test0334LongOwnerInOidEmptyTest() throws Exception { ObjectQuery query = prismContext.queryFor(ObjectType.class) .ownerId(new long[0]).build(); query.setFilter(ObjectQueryUtil.simplify(query.getFilter(), prismContext)); assertTrue("Wrongly reduced InOid filter: " + query.getFilter(), query.getFilter() instanceof NoneFilter); }
@Test public void test0332OwnerInOidEmptyTest() throws Exception { ObjectQuery query = prismContext.queryFor(ObjectType.class) .ownerId(new String[0]).build(); query.setFilter(ObjectQueryUtil.simplify(query.getFilter(), prismContext)); assertTrue("Wrongly reduced InOid filter: " + query.getFilter(), query.getFilter() instanceof NoneFilter); }
@Override protected ObjectQuery extendQuery(ObjectQuery query, ExpressionEvaluationContext params) throws SchemaException, ExpressionEvaluationException { RefinedObjectClassDefinition rAssocTargetDef = (RefinedObjectClassDefinition) params.getVariables().get(ExpressionConstants.VAR_ASSOCIATION_TARGET_OBJECT_CLASS_DEFINITION); if (rAssocTargetDef == null) { throw new ExpressionEvaluationException("No association target object class definition variable in "+ params.getContextDescription()+"; the expression may be used in a wrong place. It is only supposed to create an association."); } ObjectFilter resourceFilter = ObjectQueryUtil.createResourceFilter(rAssocTargetDef.getResourceOid(), getPrismContext()); ObjectFilter objectClassFilter = ObjectQueryUtil.createObjectClassFilter(rAssocTargetDef.getObjectClassDefinition().getTypeName(), getPrismContext()); ObjectFilter extendedFilter = getPrismContext().queryFactory().createAnd(resourceFilter, objectClassFilter, query.getFilter()); query.setFilter(extendedFilter); return query; }
@Override protected boolean handleObject(PrismObject<ResourceType> resource, Task workerTask, OperationResult taskResult) throws CommonException { LOGGER.trace("Propagating provisioning operations on {}", resource); ObjectQuery query = resource.getPrismContext().queryFactory().createQuery(); ObjectFilter filter = resource.getPrismContext().queryFor(ShadowType.class) .item(ShadowType.F_RESOURCE_REF).ref(resource.getOid()) .and() .exists(ShadowType.F_PENDING_OPERATION) .buildFilter(); query.setFilter(filter); ResultHandler<ShadowType> handler = (shadow, result) -> { propagateShadowOperations(resource, shadow, workerTask, result); return true; }; repositoryService.searchObjectsIterative(ShadowType.class, query, handler, null, true, taskResult); LOGGER.trace("Propagation of {} done", resource); return true; }
@Test(expectedExceptions = UnsupportedOperationException.class) public void test0089QueryExistsAssignmentAll() throws Exception { Session session = open(); try { ObjectQuery query = prismContext.queryFor(UserType.class) .exists(F_ASSIGNMENT).all() .asc(F_NAME) .build(); query.setFilter(ObjectQueryUtil.simplify(query.getFilter(), prismContext)); String real = getInterpretedQuery2(session, UserType.class, query); // this doesn't work as expected ... maybe inner join would be better! Until implemented, we should throw UOO String expected = "select\n" + " u.oid, u.fullObject,\n" + " u.stringsCount,\n" + " u.longsCount,\n" + " u.datesCount,\n" + " u.referencesCount,\n" + " u.polysCount,\n" + " u.booleansCount\n" + "from\n" + " RUser u\n" + " left join u.assignments a with a.assignmentOwner = :assignmentOwner\n" + "order by u.name.orig asc\n"; assertEqualsIgnoreWhitespace(expected, real); } finally { close(session); } }
filter = ObjectQueryUtil.simplify(query.getFilter(), prismContext); query = query.cloneEmpty(); query.setFilter(filter);
@Override protected ObjectQuery createQuery(AbstractScannerResultHandler<FocusType> handler, TaskRunResult runResult, Task coordinatorTask, OperationResult opResult) throws SchemaException { initProcessedOids(coordinatorTask); TimeValidityPolicyConstraintType validityConstraintType = getValidityPolicyConstraint(coordinatorTask); Duration activateOn = getActivateOn(validityConstraintType); Integer partition = getPartition(coordinatorTask); ObjectQuery query = getPrismContext().queryFactory().createQuery(); ObjectFilter filter; XMLGregorianCalendar lastScanTimestamp = handler.getLastScanTimestamp(); XMLGregorianCalendar thisScanTimestamp = handler.getThisScanTimestamp(); if (activateOn != null) { ItemPathType itemPathType = validityConstraintType.getItem(); ItemPath path = itemPathType.getItemPath(); if (path == null) { throw new SchemaException("No path defined in the validity constraint."); } thisScanTimestamp.add(activateOn.negate()); if (lastScanTimestamp != null) { lastScanTimestamp.add(activateOn.negate()); } filter = createFilterFor(getType(coordinatorTask), path, lastScanTimestamp, thisScanTimestamp); } else { filter = createBasicFilter(lastScanTimestamp, thisScanTimestamp, partition); } query.setFilter(filter); return query; }
.maxSize(10) .build(); query.setFilter(ObjectQueryUtil.simplify(query.getFilter(), prismContext)); // necessary to remove "not oid()" clause String real = getInterpretedQuery2(session, AccessCertificationCampaignType.class, query); String expected = "select\n"