ReferenceRestriction and other Restriction review, minor code cleanup

repo/repo-sql-impl/src/main/java/com/evolveum/midpoint/repo/sql/query/QueryInterpreter.java

@@ -387,7 +387,7 @@ private void addOrdering(InterpretationContext context, ObjectOrdering ordering)
         }
 
         JpaEntityDefinition baseEntityDefinition = result.getEntityDefinition();
-        JpaPropertyDefinition orderByDefinition = (JpaPropertyDefinition) targetDefinition;
+        JpaPropertyDefinition<?> orderByDefinition = (JpaPropertyDefinition<?>) targetDefinition;
         String hqlPropertyPath = context.getItemPathResolver()
                 .resolveItemPath(orderByPath, null, context.getPrimaryEntityAlias(), baseEntityDefinition, true)
                 .getHqlPath();

repo/repo-sql-impl/src/main/java/com/evolveum/midpoint/repo/sql/query/resolution/ItemPathResolver.java

@@ -1,10 +1,9 @@
 /*
- * Copyright (c) 2010-2020 Evolveum and contributors
+ * Copyright (C) 2010-2022 Evolveum and contributors
  *
  * This work is dual-licensed under the Apache License 2.0
  * and European Union Public License. See LICENSE file for details.
  */
-
 package com.evolveum.midpoint.repo.sql.query.resolution;
 
 import java.lang.reflect.InvocationTargetException;
@@ -22,12 +21,12 @@
 import com.evolveum.midpoint.repo.sql.data.common.dictionary.ExtItemDictionary;
 import com.evolveum.midpoint.repo.sql.query.InterpretationContext;
 import com.evolveum.midpoint.repo.sql.query.QueryDefinitionRegistry;
-import com.evolveum.midpoint.repo.sqlbase.QueryException;
 import com.evolveum.midpoint.repo.sql.query.definition.*;
-import com.evolveum.midpoint.repo.sql.query.hqm.JoinSpecification;
 import com.evolveum.midpoint.repo.sql.query.hqm.HibernateQuery;
+import com.evolveum.midpoint.repo.sql.query.hqm.JoinSpecification;
 import com.evolveum.midpoint.repo.sql.query.hqm.condition.AndCondition;
 import com.evolveum.midpoint.repo.sql.query.hqm.condition.Condition;
+import com.evolveum.midpoint.repo.sqlbase.QueryException;
 import com.evolveum.midpoint.util.logging.Trace;
 import com.evolveum.midpoint.util.logging.TraceManager;
 
@@ -51,16 +50,15 @@ public ItemPathResolver(InterpretationContext interpretationContext) {
      * @param itemDefinition Definition for the (final) item pointed to. Optional - necessary only for extension items.
      * @param reuseMultivaluedJoins Creation of new joins for multivalued properties is forbidden.
      */
-    public HqlDataInstance resolveItemPath(ItemPath relativePath, ItemDefinition itemDefinition,
+    public HqlDataInstance<?> resolveItemPath(ItemPath relativePath, ItemDefinition<?> itemDefinition,
             String currentHqlPath, JpaEntityDefinition baseEntityDefinition,
             boolean reuseMultivaluedJoins) throws QueryException {
         HqlDataInstance<?> baseDataInstance = new HqlDataInstance<>(currentHqlPath, baseEntityDefinition, null);
         return resolveItemPath(relativePath, itemDefinition, baseDataInstance, reuseMultivaluedJoins);
     }
 
-    public HqlDataInstance resolveItemPath(ItemPath relativePath, ItemDefinition itemDefinition,
-            HqlDataInstance baseDataInstance,
-            boolean singletonOnly) throws QueryException {
+    public HqlDataInstance<?> resolveItemPath(ItemPath relativePath, ItemDefinition<?> itemDefinition,
+            HqlDataInstance<?> baseDataInstance, boolean singletonOnly) throws QueryException {
 
         ItemPathResolutionState currentState = new ItemPathResolutionState(relativePath, baseDataInstance, this);
 
@@ -219,7 +217,7 @@ private Object createQueryParamValue(VirtualQueryParam param) throws QueryExcept
      */
     public <T extends JpaDataNodeDefinition<T>>
     ProperDataSearchResult<T> findProperDataDefinition(JpaEntityDefinition baseEntityDefinition,
-            ItemPath path, ItemDefinition itemDefinition,
+            ItemPath path, ItemDefinition<?> itemDefinition,
             Class<T> clazz, PrismContext prismContext) throws QueryException {
         QueryDefinitionRegistry registry = QueryDefinitionRegistry.getInstance();
         ProperDataSearchResult<T> candidateResult = null;

repo/repo-sql-impl/src/main/java/com/evolveum/midpoint/repo/sql/query/restriction/ItemValueRestriction.java

@@ -40,31 +40,30 @@ public abstract class ItemValueRestriction<T extends ValueFilter> extends ItemRe
 
     @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);
+        HqlDataInstance<?> dataInstance = getItemPathResolver().resolveItemPath(path, itemDefinition, getBaseHqlEntity(), false);
         setHqlDataInstance(dataInstance);
 
         return interpretInternal();
     }
 
     public abstract Condition interpretInternal() throws QueryException;
 
-    Condition createPropertyVsConstantCondition(String hqlPropertyPath, Object value, ValueFilter filter) throws QueryException {
+    <V> Condition createPropertyVsConstantCondition(
+            String hqlPropertyPath, V value, ValueFilter<?, ?> filter) throws QueryException {
         ItemRestrictionOperation operation = findOperationForFilter(filter);
 
         InterpretationContext context = getContext();
         QueryInterpreter interpreter = context.getInterpreter();
-        Matcher matcher = interpreter.findMatcher(value);
+        Matcher<V> matcher = interpreter.findMatcher(value);
         String matchingRule = filter.getMatchingRule() != null ? filter.getMatchingRule().getLocalPart() : null;
 
         // TODO treat null for multivalued properties (at least throw an exception!)
-        //noinspection unchecked
-        return matcher.
-                match(context.getHibernateQuery(), operation, hqlPropertyPath, value, matchingRule);
+        return matcher.match(
+                context.getHibernateQuery(), operation, hqlPropertyPath, value, matchingRule);
     }
 
     ItemRestrictionOperation findOperationForFilter(ValueFilter filter) throws QueryException {

repo/repo-sql-impl/src/main/java/com/evolveum/midpoint/repo/sql/query/restriction/PropertyRestriction.java

@@ -19,7 +19,6 @@
 import com.evolveum.midpoint.prism.query.ValueFilter;
 import com.evolveum.midpoint.repo.sql.data.common.enums.SchemaEnum;
 import com.evolveum.midpoint.repo.sql.query.InterpretationContext;
-import com.evolveum.midpoint.repo.sqlbase.QueryException;
 import com.evolveum.midpoint.repo.sql.query.definition.JpaEntityDefinition;
 import com.evolveum.midpoint.repo.sql.query.definition.JpaLinkDefinition;
 import com.evolveum.midpoint.repo.sql.query.definition.JpaPropertyDefinition;
@@ -28,6 +27,7 @@
 import com.evolveum.midpoint.repo.sql.query.hqm.condition.ConstantCondition;
 import com.evolveum.midpoint.repo.sql.query.resolution.HqlDataInstance;
 import com.evolveum.midpoint.repo.sql.util.RUtil;
+import com.evolveum.midpoint.repo.sqlbase.QueryException;
 import com.evolveum.midpoint.util.exception.SchemaException;
 import com.evolveum.midpoint.util.logging.Trace;
 import com.evolveum.midpoint.util.logging.TraceManager;
@@ -75,7 +75,7 @@ public Condition interpretInternal() throws QueryException {
     }
 
     Condition createPropertyVsPropertyCondition(String leftPropertyValuePath) throws QueryException {
-        HqlDataInstance rightItem = getItemPathResolver().resolveItemPath(filter.getRightHandSidePath(),
+        HqlDataInstance<?> rightItem = getItemPathResolver().resolveItemPath(filter.getRightHandSidePath(),
                 filter.getRightHandSideDefinition(), getBaseHqlEntityForChildren(), true);
         String rightHqlPath = rightItem.getHqlPath();
         HibernateQuery hibernateQuery = context.getHibernateQuery();
@@ -179,12 +179,12 @@ private Enum getRepoEnumValue(Enum<?> schemaValue, Class<?> repoType) throws Que
 
         if (SchemaEnum.class.isAssignableFrom(repoType)) {
             //noinspection unchecked
-            return (Enum) RUtil.getRepoEnumValue(schemaValue, (Class<? extends SchemaEnum>) repoType);
+            return (Enum<?>) RUtil.getRepoEnumValue(schemaValue, (Class<? extends SchemaEnum>) repoType);
         }
 
         Object[] constants = repoType.getEnumConstants();
         for (Object constant : constants) {
-            Enum e = (Enum) constant;
+            Enum<?> e = (Enum<?>) constant;
             if (e.name().equals(schemaValue.name())) {
                 return e;
             }
@@ -193,5 +193,4 @@ private Enum getRepoEnumValue(Enum<?> schemaValue, Class<?> repoType) throws Que
         throw new QueryException("Unknown enum value '" + schemaValue + "', which is type of '"
                 + schemaValue.getClass() + "'.");
     }
-
 }

repo/repo-sql-impl/src/main/java/com/evolveum/midpoint/repo/sql/query/restriction/ReferenceRestriction.java

@@ -1,10 +1,9 @@
 /*
- * Copyright (c) 2010-2017 Evolveum and contributors
+ * Copyright (C) 2010-2022 Evolveum and contributors
  *
  * This work is dual-licensed under the Apache License 2.0
  * and European Union Public License. See LICENSE file for details.
  */
-
 package com.evolveum.midpoint.repo.sql.query.restriction;
 
 import java.util.*;
@@ -16,10 +15,10 @@
 
 import com.evolveum.midpoint.prism.PrismConstants;
 import com.evolveum.midpoint.prism.PrismReferenceValue;
+import com.evolveum.midpoint.prism.query.ObjectFilter;
 import com.evolveum.midpoint.prism.query.RefFilter;
 import com.evolveum.midpoint.repo.sql.data.common.RObjectReference;
 import com.evolveum.midpoint.repo.sql.data.common.any.ROExtReference;
-import com.evolveum.midpoint.repo.sqlbase.QueryException;
 import com.evolveum.midpoint.repo.sql.query.InterpretationContext;
 import com.evolveum.midpoint.repo.sql.query.definition.JpaAnyReferenceDefinition;
 import com.evolveum.midpoint.repo.sql.query.definition.JpaEntityDefinition;
@@ -31,6 +30,7 @@
 import com.evolveum.midpoint.repo.sql.query.hqm.condition.OrCondition;
 import com.evolveum.midpoint.repo.sql.util.ClassMapper;
 import com.evolveum.midpoint.repo.sql.util.RUtil;
+import com.evolveum.midpoint.repo.sqlbase.QueryException;
 import com.evolveum.midpoint.util.MiscUtil;
 import com.evolveum.midpoint.util.QNameUtil;
 import com.evolveum.midpoint.util.exception.SchemaException;
@@ -45,25 +45,29 @@ public class ReferenceRestriction extends ItemValueRestriction<RefFilter> {
     private static final Trace LOGGER = TraceManager.getTrace(ReferenceRestriction.class);
 
     // Definition of the item being queried.
-    @NotNull private final JpaLinkDefinition<JpaReferenceDefinition> linkDefinition;
+    @NotNull private final JpaLinkDefinition<JpaReferenceDefinition<?>> linkDefinition;
 
     public ReferenceRestriction(InterpretationContext context, RefFilter filter, JpaEntityDefinition baseEntityDefinition,
-            Restriction parent, @NotNull JpaLinkDefinition<JpaReferenceDefinition> linkDefinition) {
+            Restriction<?> parent, @NotNull JpaLinkDefinition<JpaReferenceDefinition<?>> linkDefinition) {
         super(context, filter, baseEntityDefinition, parent);
         this.linkDefinition = linkDefinition;
     }
 
     @Override
     public Condition interpretInternal() throws QueryException {
-
         String hqlPath = hqlDataInstance.getHqlPath();
         LOGGER.trace("interpretInternal starting with hqlPath = {}", hqlPath);
 
         HibernateQuery hibernateQuery = context.getHibernateQuery();
 
+        ObjectFilter targetFilter = filter.getFilter();
         List<PrismReferenceValue> values = filter.getValues();
         if (CollectionUtils.isEmpty(values)) {
-            return hibernateQuery.createIsNull(hqlDataInstance.getHqlPath());
+            if (targetFilter == null) {
+                return hibernateQuery.createIsNull(hqlDataInstance.getHqlPath());
+            } else {
+                // TODO here or lower after some join?
+            }
         }
         Set<String> oids = new HashSet<>();
         Set<QName> relations = new HashSet<>();