GopikaReghunath commented on code in PR #2328:
URL:
https://github.com/apache/incubator-kie-kogito-apps/pull/2328#discussion_r3503616755
##########
data-index/data-index-storage/data-index-storage-jpa-common/src/main/java/org/kie/kogito/index/jpa/storage/JPAQuery.java:
##########
@@ -156,17 +185,145 @@ protected final Predicate
buildPredicateFunction(AttributeFilter filter, Root<E>
return builder
.lessThanOrEqualTo(getAttributePath(root,
filter.getAttribute()), (Comparable) filter.getValue());
case OR:
- return builder.or(getRecursivePredicate(filter, root,
builder).toArray(new Predicate[] {}));
+ return buildGroupedPredicate(filter, root, builder,
criteriaQuery, false, false);
case AND:
- return builder.and(getRecursivePredicate(filter, root,
builder).toArray(new Predicate[] {}));
+ return buildGroupedPredicate(filter, root, builder,
criteriaQuery, true, false);
case NOT:
- return builder.not(filterPredicateFunction(root,
builder).apply((AttributeFilter<?>) filter.getValue()));
+ AttributeFilter<?> innerFilter = (AttributeFilter<?>)
filter.getValue();
+
+ // Handle NOT with AND/OR: Apply De Morgan's Law by negating
and flipping the operator
+ if (innerFilter.getCondition() == FilterCondition.AND ||
innerFilter.getCondition() == FilterCondition.OR) {
+ // NOT (A AND B) = NOT A OR NOT B, NOT (A OR B) = NOT A
AND NOT B
+ boolean flipToAnd = innerFilter.getCondition() ==
FilterCondition.OR;
+ return buildGroupedPredicate(innerFilter, root, builder,
criteriaQuery, flipToAnd, true);
+ }
+
+ if (innerFilter.getAttribute() != null &&
isCollectionAttribute(innerFilter.getAttribute()) &&
+ (innerFilter.getCondition() ==
FilterCondition.CONTAINS ||
+ innerFilter.getCondition() ==
FilterCondition.CONTAINS_ALL ||
+ innerFilter.getCondition() ==
FilterCondition.CONTAINS_ANY ||
+ innerFilter.getCondition() ==
FilterCondition.EQUAL)) {
+ return buildCollectionPredicate(innerFilter, root,
builder, criteriaQuery, true);
+ }
+
+ if (innerFilter.getAttribute() != null &&
isCollectionAttribute(innerFilter.getAttribute())) {
+ return buildNegatedCollectionPredicate(innerFilter, root,
builder, criteriaQuery);
+ }
+
+ return builder.not(filterPredicateFunction(root, builder,
criteriaQuery).apply(innerFilter));
default:
return null;
}
}
+ /**
+ * Builds predicates for AND/OR, grouping CONTAINS filters on same
collection into single EXISTS.
+ *
+ * @param isNegated if true, negates each predicate (for NOT operations
with De Morgan's Law)
+ */
+ private Predicate buildGroupedPredicate(AttributeFilter<?> filter, Root<E>
root,
+ CriteriaBuilder builder, CriteriaQuery<?> criteriaQuery, boolean
isAnd, boolean isNegated) {
+
+ List<AttributeFilter<?>> nestedFilters = (List<AttributeFilter<?>>)
filter.getValue();
+
+ java.util.Map<String, List<AttributeFilter<?>>> groups = new
java.util.HashMap<>();
+ List<Predicate> otherPredicates = new ArrayList<>();
+
+ for (AttributeFilter<?> f : nestedFilters) {
+ if (f.getAttribute() != null &&
isCollectionAttribute(f.getAttribute()) &&
+ (f.getCondition() == FilterCondition.CONTAINS ||
Review Comment:
comment addressed
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
