How to use

ExistsFilter

in

com.evolveum.midpoint.prism.query

private MapXNodeImpl serializeExistsFilter(ExistsFilter filter, PrismSerializer<RootXNode> xnodeSerializer) throws SchemaException{
  MapXNodeImpl content = new MapXNodeImpl();
  serializePath(content, filter.getFullPath(), filter);
  if (filter.getFilter() != null){
    content.put(ELEMENT_FILTER, serializeFilter(filter.getFilter(), xnodeSerializer));
  }
  return createFilter(CLAUSE_EXISTS, content);
}

  return simplifiedFilter;
} else if (filter instanceof ExistsFilter) {
  ObjectFilter subFilter = ((ExistsFilter) filter).getFilter();
  ObjectFilter simplifiedSubfilter = simplify(subFilter, prismContext);
  if (simplifiedSubfilter instanceof AllFilter) {
    return FilterCreationUtil.createNone(prismContext);
  ExistsFilter simplifiedFilter = ((ExistsFilter) filter).cloneEmpty();
  simplifiedFilter.setFilter(simplifiedSubfilter);
  return simplifiedFilter;
} else if (filter instanceof UndefinedFilter || filter instanceof AllFilter) {

@Override
public Condition interpret() throws QueryException {
  HqlDataInstance dataInstance = getItemPathResolver()
      .resolveItemPath(filter.getFullPath(), filter.getDefinition(), getBaseHqlEntity(), false);
  boolean isAll = filter.getFilter() == null || filter.getFilter() instanceof AllFilter;
  JpaDataNodeDefinition jpaDefinition = dataInstance.getJpaDefinition();
  if (!isAll) {
    if (!(jpaDefinition instanceof JpaEntityDefinition)) {	// partially checked already (for non-null-ness)
       throw new QueryException("ExistsRestriction with non-empty subfilter points to non-entity node: " + jpaDefinition);
    }
    setHqlDataInstance(dataInstance);
    QueryInterpreter2 interpreter = context.getInterpreter();
    return interpreter.interpretFilter(context, filter.getFilter(), this);
  } else if (jpaDefinition instanceof JpaPropertyDefinition && (((JpaPropertyDefinition) jpaDefinition).isCount())) {
    RootHibernateQuery hibernateQuery = context.getHibernateQuery();
    return hibernateQuery.createSimpleComparisonCondition(dataInstance.getHqlPath(), 0, ">");
  } else {
    // TODO support exists also for other properties (single valued or multi valued)
    throw new UnsupportedOperationException("Exists filter with 'all' subfilter is currently not supported");
  }
}

public ExistsRestriction(InterpretationContext context, ExistsFilter filter, JpaEntityDefinition baseEntityDefinition,
             Restriction parent) {
  super(context, filter, filter.getFullPath(), null, baseEntityDefinition, parent);
}

} else if (filter instanceof ExistsFilter) {
  ExistsFilter existsFilter = (ExistsFilter) filter;
  ItemPath path = existsFilter.getFullPath();
  ItemDefinition definition = existsFilter.getDefinition();
  ProperDataSearchResult<JpaDataNodeDefinition> searchResult = resolver.findProperDataDefinition(
      baseEntityDefinition, path, definition, JpaDataNodeDefinition.class, context.getPrismContext());

  ExistsFilter evaluatedFilter = ((ExistsFilter) filter).cloneEmpty();
  ObjectFilter evaluatedSubFilter = evaluateFilterExpressionsInternal(((ExistsFilter) filter).getFilter(), variables,
      expressionFactory, prismContext, shortDesc, task, result);
  evaluatedFilter.setFilter(evaluatedSubFilter);
  return evaluatedFilter;
} else if (filter instanceof TypeFilter) {

@Test
public void test500ExistsAll() throws Exception {
  System.out.println("===[ test500ExistsAll ]===");
  // GIVEN
  PrismContext prismContext = PrismTestUtil.getPrismContext();
  // WHEN
  ObjectFilter filter = prismContext.queryFor(UserType.class)
      .exists(UserType.F_ASSIGNMENT).all()
      .buildFilter();
  System.out.println("Original filter:\n" + filter.debugDump());
  // THEN
  ObjectFilter simplified = ObjectQueryUtil.simplify(filter, prismContext);
  System.out.println("Simplified filter:\n" + DebugUtil.debugDump(simplified));
  assertTrue("Wrong simplified filter: " + simplified, simplified instanceof ExistsFilter);
  ExistsFilter existsSimplified = (ExistsFilter) simplified;
  assertEquals("Wrong simplified filter path", UserType.F_ASSIGNMENT, existsSimplified.getFullPath());
  assertTrue("Wrong simplified filter subfilter: " + existsSimplified.getFilter(), ObjectQueryUtil.isAll(existsSimplified.getFilter()));
}

@Test
public void test520ExistsUndefined() throws Exception {
  System.out.println("===[ test520ExistsUndefined ]===");
  // GIVEN
  PrismContext prismContext = PrismTestUtil.getPrismContext();
  // WHEN
  ObjectFilter filter = prismContext.queryFor(UserType.class)
      .exists(UserType.F_ASSIGNMENT).undefined()
      .buildFilter();
  System.out.println("Original filter:\n" + filter.debugDump());
  // THEN
  ObjectFilter simplified = ObjectQueryUtil.simplify(filter, prismContext);
  System.out.println("Simplified filter:\n" + DebugUtil.debugDump(simplified));
  assertTrue("Wrong simplified filter: " + simplified, simplified instanceof ExistsFilter);
  ExistsFilter existsSimplified = (ExistsFilter) simplified;
  assertEquals("Wrong simplified filter path", UserType.F_ASSIGNMENT, existsSimplified.getFullPath());
  assertTrue("Wrong simplified filter subfilter: " + existsSimplified.getFilter(), ObjectQueryUtil.isAll(existsSimplified.getFilter()));
}