/** * 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; } }
public static void displayQuery(ObjectQuery query) { LOGGER.trace("object query:\n{}\n", query); System.out.println("object query:\n" + query + "\n"); if (query != null) { LOGGER.trace("object query debug dump:\n{}\n", query.debugDump()); System.out.println("object query debug dump:\n" + query.debugDump() + "\n"); } }
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; }
@NotNull private ObjectQuery replaceSimplifiedFilter(ObjectQuery query, ObjectFilter filter) { query = query.cloneEmpty(); query.setFilter(filter instanceof AllFilter ? null : filter); return query; }
public static void assertQueriesEquivalent(String message, ObjectQuery expected, ObjectQuery real) { if (!expected.equivalent(real)) { fail(message + ": expected:\n" + expected.debugDump() + "\nreal:\n" + real.debugDump()); } }
public <O extends Objectable> ObjectFilter createObjectFilter(Class<O> clazz, SearchFilterType filterType) throws SchemaException { ObjectQuery query = createObjectQueryInternal(clazz, filterType, null); if (query == null) { return null; } else { return query.getFilter(); } }
filter = query.getFilter(); if (query != null && query.getPaging() != null) { if (attributeQuery == null) { attributeQuery = queryFactory.createQuery(); attributeQuery.setPaging(query.getPaging()); if (query != null && query.isAllowPartialResults()) { if (attributeQuery == null) { attributeQuery = queryFactory.createQuery(); attributeQuery.setAllowPartialResults(true); && attributeQuery.getFilter() != null) { attributeQuery.getFilter().checkConsistence(true);
@Test public void test360Ref() throws Exception { final String TEST_NAME = "test360Ref"; displayTestTitle(TEST_NAME); // we test only parsing here, as there are more serialized forms used here ObjectQuery q1object = getPrismContext().queryFor(ShadowType.class) .item(ShadowType.F_RESOURCE_REF).ref("oid1") .or().item(ShadowType.F_RESOURCE_REF).ref("oid2", ResourceType.COMPLEX_TYPE) .or().item(ShadowType.F_RESOURCE_REF).ref("oid3") .or().item(ShadowType.F_RESOURCE_REF).ref("oid4", ResourceType.COMPLEX_TYPE) .build(); q1object.getFilter().checkConsistence(true); String q2xml = FileUtils.readFileToString(new File(TEST_DIR + "/" + TEST_NAME + ".xml")); displayQueryXml(q2xml); QueryType q2jaxb = toQueryType(q2xml); displayQueryType(q2jaxb); ObjectQuery q2object = toObjectQuery(ShadowType.class, q2jaxb); System.out.println("q1object:\n"+q1object.debugDump(1)); System.out.println("q2object:\n"+q2object.debugDump(1)); assertEquals("Reparsed query is not as original one (via toString)", q1object.toString(), q2object.toString()); // primitive way of comparing parsed queries if (!q1object.equivalent(q2object)) { AssertJUnit.fail("Reparsed query is not as original one (via equivalent):\nq1="+q1object+"\nq2="+q2object); } }
public QueryType createQueryType(ObjectQuery query) throws SchemaException { ObjectFilter filter = query.getFilter(); QueryType queryType = new QueryType(); if (filter != null) { queryType.setFilter(createSearchFilterType(filter)); } queryType.setPaging(PagingConvertor.createPagingType(query.getPaging())); return queryType; }
SecurityViolationException, ExpressionEvaluationException { ResourceShadowDiscriminator coordinates = ObjectQueryUtil.getCoordinates(query.getFilter(), prismContext); final ProvisioningContext ctx = ctxFactory.create(coordinates, null, result); ctx.assertDefinition(); query = query.clone(); ObjectPaging paging = prismContext.queryFactory().createPaging(); query.setPaging(paging); Collection<SelectorOptions<GetOperationOptions>> options = schemaHelper.getOperationOptionsBuilder() .item(ShadowType.F_ASSOCIATION).dontRetrieve()
protected void logQuery(ObjectQuery query) { if (!LOGGER.isTraceEnabled()) { return; } if (query != null) { if (query.getPaging() == null) { LOGGER.trace("Searching objects with null paging. Processed query:\n{}", query.debugDump(1)); } else { LOGGER.trace("Searching objects from {} to {} ordered {} by {}. Processed query:\n{}", query.getPaging().getOffset(), query.getPaging().getMaxSize(), query.getPaging().getDirection(), query.getPaging().getOrderBy(), query.debugDump(1)); } } else { LOGGER.trace("Searching objects with null paging and null (processed) 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); } }
query = prismContext.getQueryConverter().createObjectQuery(objectType, queryType); if (LOGGER.isTraceEnabled()) { LOGGER.trace("Using object query from the task: {}", query.debugDump()); LOGGER.trace("Deleting {}, raw={} using query:\n{}", objectType.getSimpleName(), optionRaw, query.debugDump()); query.setPaging(paging); query.setAllowPartialResults(true);
@Test public void testRefRelationNegative() throws Exception { PrismObject<UserType> user = PrismTestUtil.parseObject(PrismInternalTestUtil.USER_JACK_FILE_XML); ObjectFilter filter = getPrismContext().queryFor(UserType.class) .item(UserType.F_ACCOUNT_REF).ref(new QName("a-relation")) .buildFilter(); boolean match = ObjectQuery.match(user, filter, matchingRuleRegistry); AssertJUnit.assertFalse("filter matches object, but it should not", match); } }
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); } }
query.setPaging(paging);
protected <O extends ObjectType> SearchResultList<PrismObject<O>> assertSearch(Class<O> type, ObjectQuery query, Collection<SelectorOptions<GetOperationOptions>> options, int expectedResults) throws Exception { ObjectQuery originalQuery = query != null ? query.clone() : null; return assertSearch(type, query, options, new SearchAssertion<O>() { @Override public void assertObjects(String message, List<PrismObject<O>> objects) throws Exception { if (objects.size() > expectedResults) { failDeny(message, type, originalQuery, expectedResults, objects.size()); } else if (objects.size() < expectedResults) { failAllow(message, type, originalQuery, expectedResults, objects.size()); } } @Override public void assertCount(int count) throws Exception { if (count > expectedResults) { failDeny("count", type, originalQuery, expectedResults, count); } else if (count < expectedResults) { failAllow("count", type, originalQuery, expectedResults, count); } } }); }