public ItemValueRestriction(InterpretationContext context, T filter, JpaEntityDefinition baseEntityDefinition, Restriction parent) { super(context, filter, filter.getFullPath(), filter.getDefinition(), baseEntityDefinition, parent); }
@Override public S_AtomicFilterExit item(ItemPath itemPath, ItemDefinition itemDefinition) { if (!expectingRightSide) { throw new IllegalStateException("Unexpected item() call"); } if (filter == null) { throw new IllegalStateException("item() call with no filter"); } ValueFilter newFilter = filter.clone(); newFilter.setRightHandSidePath(itemPath); newFilter.setRightHandSideDefinition(itemDefinition); return new R_AtomicFilter(this, newFilter); }
private void serializeMatchingRule(ValueFilter filter, MapXNodeImpl map) { if (filter.getMatchingRule() != null){ PrimitiveXNodeImpl<String> matchingNode = createPrimitiveXNode(filter.getMatchingRule().getLocalPart(), DOMUtil.XSD_STRING); map.put(ELEMENT_MATCHING, matchingNode); } }
@Override public S_AtomicFilterExit matching(QName matchingRuleName) { ValueFilter clone = filter.clone(); clone.setMatchingRule(matchingRuleName); return new R_AtomicFilter(this, clone); }
private <V extends PrismValue, D extends ItemDefinition> MapXNodeImpl serializeValueFilter(ValueFilter<V,D> filter, PrismSerializer<RootXNode> xnodeSerializer) throws SchemaException { MapXNodeImpl map = new MapXNodeImpl(); serializeMatchingRule(filter, map); serializePath(map, filter.getFullPath(), filter); List<V> values = filter.getValues(); if (values != null) { ListXNodeImpl valuesNode = new ListXNodeImpl(); val.setParent(filter); XNodeImpl valNode = (XNodeImpl) xnodeSerializer.definition(filter.getDefinition()).serialize(val).getSubnode(); if (filter instanceof RefFilter) { // TODO shouldn't we do this in all cases? valNode.setExplicitTypeDeclaration(true); if (filter.getRightHandSidePath() != null) { map.put(ELEMENT_RIGHT_HAND_SIDE_PATH, createPrimitiveXNode( new ItemPathType(filter.getRightHandSidePath()), ItemPathType.COMPLEX_TYPE)); ExpressionWrapper xexpression = filter.getExpression(); if (xexpression != null) { map.merge(PrismUtilInternal.serializeExpression(xexpression, xnodeSerializer));
ValueFilter valueFilter = (ValueFilter) filter; if (valueFilter.getValues() != null && !valueFilter.getValues().isEmpty()) { return valueFilter.clone(); ExpressionWrapper expressionWrapper = valueFilter.getExpression(); if (expressionMissing(expressionWrapper, filter, shortDesc)) { return valueFilter.clone(); new Object[] { shortDesc, expressionResult }); ValueFilter evaluatedFilter = valueFilter.clone(); evaluatedFilter.setValue(expressionResult); evaluatedFilter.setExpression(null); LOGGER.trace("Transformed filter to:\n{}", evaluatedFilter.debugDump());
private static <V extends PrismValue> V evaluateExpression(ExpressionVariables variables, PrismContext prismContext, ExpressionType expressionType, ObjectFilter filter, ExpressionFactory expressionFactory, String shortDesc, Task task, OperationResult parentResult) throws SchemaException, ObjectNotFoundException, ExpressionEvaluationException, CommunicationException, ConfigurationException, SecurityViolationException { // TODO refactor after new query engine is implemented ItemDefinition outputDefinition = null; if (filter instanceof ValueFilter) { outputDefinition = ((ValueFilter) filter).getDefinition(); } if (outputDefinition == null) { outputDefinition = prismContext.definitionFactory().createPropertyDefinition(ExpressionConstants.OUTPUT_ELEMENT_NAME, DOMUtil.XSD_STRING); } return (V) evaluateExpression(variables, outputDefinition, expressionType, expressionFactory, shortDesc, task, parentResult); // String expressionResult = // expressionHandler.evaluateExpression(currentShadow, valueExpression, // shortDesc, result); }
if (valueFilter.getParentPath().isEmpty()) { throw new UnsupportedOperationException("Empty path is not supported (filter: " + objectFilter+")"); if (valueFilter.getParentPath().equivalent(ShadowType.F_ATTRIBUTES)) { try { QName propName = valueFilter.getDefinition().getName(); String icfName = icfNameMapper.convertAttributeNameToConnId(propName, getInterpreter() .getObjectClassDefinition(), "(attribute in the filter)"); } else { Attribute attr = AttributeBuilder.build(icfName, convertedValues); if (valueFilter.getDefinition().isSingleValue()) { return FilterBuilder.equalTo(attr); } else { } else if (valueFilter.getParentPath().equivalent(ShadowType.F_ACTIVATION)) { QName propName = valueFilter.getDefinition().getName(); EqualFilter<T> eq = (EqualFilter<T>) objectFilter; List<PrismPropertyValue<T>> values = eq.getValues(); if (valueFilter.getDefinition().isSingleValue()) { return FilterBuilder.equalTo(attr); } else { throw new UnsupportedOperationException("Unsupported parent path "+valueFilter.getParentPath()+" in filter: " + objectFilter);
private static boolean containExpression(ObjectFilter filter){ if (filter == null){ return false; } if (filter instanceof InOidFilter && ((InOidFilter) filter).getExpression() != null) { return true; } if (filter instanceof FullTextFilter && ((FullTextFilter) filter).getExpression() != null) { return true; } if (filter instanceof ValueFilter && ((ValueFilter) filter).getExpression() != null) { return true; } return false; }
@Override public Condition interpret() throws QueryException { ItemPath path = getItemPath(); if (ItemPath.isEmpty(path)) { throw new QueryException("Null or empty path for ItemValueRestriction in " + filter.debugDump()); } HqlDataInstance dataInstance = getItemPathResolver().resolveItemPath(path, itemDefinition, getBaseHqlEntity(), false); setHqlDataInstance(dataInstance); Condition condition = interpretInternal(); return condition; }
public static boolean hasAllDefinitions(ObjectFilter filter) { final MutableBoolean hasAllDefinitions = new MutableBoolean(true); Visitor visitor = f -> { if (f instanceof ValueFilter) { ItemDefinition definition = ((ValueFilter<?,?>) f).getDefinition(); if (definition == null) { hasAllDefinitions.setValue(false); } } }; filter.accept(visitor); return hasAllDefinitions.booleanValue(); }
public static boolean hasExpressions(@Nullable ObjectFilter filter) { if (filter == null) { return false; } Holder<Boolean> result = new Holder<>(false); filter.accept(f -> { if (f instanceof ValueFilter) { ValueFilter<?, ?> vf = (ValueFilter<?, ?>) f; if (vf.getExpression() != null) { result.setValue(true); } } }); return result.getValue(); }
protected Condition createPropertyVsConstantCondition(String hqlPropertyPath, Object value, ValueFilter filter) throws QueryException { ItemRestrictionOperation operation = findOperationForFilter(filter); InterpretationContext context = getContext(); QueryInterpreter2 interpreter = context.getInterpreter(); Matcher matcher = interpreter.findMatcher(value); String matchingRule = filter.getMatchingRule() != null ? filter.getMatchingRule().getLocalPart() : null; // TODO treat null for multivalued properties (at least throw an exception!) return matcher.match(context.getHibernateQuery(), operation, hqlPropertyPath, value, matchingRule); }