Merge pull request #2123 from beyonnex-io/bugfix/rql-exists-in-nested-array

fix ExistsThingPredicateVisitor did not flatten arrays correctly

Author: thjaeckle

rql/query/src/main/java/org/eclipse/ditto/rql/query/things/ExistsThingPredicateVisitor.java

@@ -23,6 +23,7 @@
 import org.eclipse.ditto.placeholders.PlaceholderResolver;
 import org.eclipse.ditto.rql.query.expression.ExistsFieldExpression;
 import org.eclipse.ditto.rql.query.expression.visitors.ExistsFieldExpressionVisitor;
+import org.eclipse.ditto.things.model.Feature;
 import org.eclipse.ditto.things.model.Thing;
 
 /**
@@ -85,7 +86,8 @@ public static Predicate<Thing> apply(final ExistsFieldExpression expression,
 
     @Override
     public Predicate<Thing> visitAttribute(final String key) {
-        return thing -> thing.getAttributes().map(attributes -> attributes.getValue(key).isPresent())
+        return thing -> thing.getAttributes()
+                .map(attributes -> attributes.getValueFlatteningArrays(key).isPresent())
                 .orElse(false);
     }
 
@@ -124,15 +126,17 @@ public Predicate<Thing> visitFeatureDesiredProperties(final CharSequence feature
     public Predicate<Thing> visitFeatureIdProperty(final String featureId, final String property) {
         return thing -> thing.getFeatures()
                 .flatMap(features -> features.getFeature(featureId))
-                .map(feature -> feature.getProperty(property).isPresent())
+                .flatMap(Feature::getProperties)
+                .map(feature -> feature.getValueFlatteningArrays(property).isPresent())
                 .orElse(false);
     }
 
     @Override
     public Predicate<Thing> visitFeatureIdDesiredProperty(final CharSequence featureId, final CharSequence property) {
         return thing -> thing.getFeatures()
                 .flatMap(features -> features.getFeature(featureId.toString()))
-                .map(feature -> feature.getDesiredProperty(property).isPresent())
+                .flatMap(Feature::getDesiredProperties)
+                .map(feature -> feature.getValueFlatteningArrays(property).isPresent())
                 .orElse(false);
     }
 

rql/query/src/test/java/org/eclipse/ditto/rql/query/things/ThingPredicatePredicateVisitorTest.java

@@ -35,8 +35,8 @@ public final class ThingPredicatePredicateVisitorTest {
 
     private static final String KNOWN_PLACEHOLDER_VALUE = "baZingA";
 
-    private final static ThingPredicatePredicateVisitor sut = ThingPredicatePredicateVisitor.getInstance();
-    private final static ThingPredicatePredicateVisitor sutWithPlaceholderResolver =
+    private static final ThingPredicatePredicateVisitor sut = ThingPredicatePredicateVisitor.getInstance();
+    private static final ThingPredicatePredicateVisitor sutWithPlaceholderResolver =
             ThingPredicatePredicateVisitor.createInstance(PlaceholderFactory.newPlaceholderResolver(
                     new ThingPredicateTestPlaceholder(), KNOWN_PLACEHOLDER_VALUE));
 

rql/query/src/test/java/org/eclipse/ditto/rql/query/things/ThingPredicateVisitorTest.java

@@ -22,6 +22,8 @@
 import org.eclipse.ditto.base.model.entity.metadata.Metadata;
 import org.eclipse.ditto.base.model.exceptions.InvalidRqlExpressionException;
 import org.eclipse.ditto.base.model.headers.DittoHeaders;
+import org.eclipse.ditto.json.JsonArray;
+import org.eclipse.ditto.json.JsonObject;
 import org.eclipse.ditto.json.JsonPointer;
 import org.eclipse.ditto.json.JsonValue;
 import org.eclipse.ditto.placeholders.PlaceholderFactory;
@@ -70,6 +72,23 @@ public final class ThingPredicateVisitorTest {
             .setAttribute(JsonPointer.of("aDouble"), JsonValue.of(MATCHING_THING_DOUBLE))
             .setAttribute(JsonPointer.of("aBoolean"), JsonValue.of(MATCHING_THING_BOOLEAN))
             .setAttribute(JsonPointer.of("aString"), JsonValue.of(MATCHING_THING_STRING))
+            .setAttribute(JsonPointer.of("anArrayOfObjects"), JsonArray.newBuilder()
+                    .add(JsonObject.newBuilder()
+                            .set("anInteger", MATCHING_THING_INTEGER)
+                            .set("aBoolean", MATCHING_THING_BOOLEAN)
+                            .set("anArrayOfObjects", JsonArray.newBuilder()
+                                    .add(
+                                            JsonObject.newBuilder()
+                                                    .set("anInteger", MATCHING_THING_INTEGER)
+                                                    .set("aBoolean", MATCHING_THING_BOOLEAN)
+                                                    .build()
+                                    )
+                                    .build()
+                            )
+                            .build()
+                    )
+                    .build()
+            )
             .setFeature("foo", FeatureProperties.newBuilder()
                     .set(JsonPointer.of("anInteger"), JsonValue.of(MATCHING_THING_INTEGER))
                     .set(JsonPointer.of("aLong"), JsonValue.of(MATCHING_THING_LONG))
@@ -453,6 +472,67 @@ public void testFilterAttributeExists() {
                 .isFalse();
     }
 
+    @Test
+    public void testFilterAttributeNestedInArrayExists() {
+        final Predicate<Thing> thingPredicate = createPredicate("exists(attributes/anArrayOfObjects/aBoolean)");
+        assertThat(thingPredicate.test(MATCHING_THING))
+                .as("Filtering 'exists(attributes/anArrayOfObjects/aBoolean)' should be true")
+                .isTrue();
+
+        final Predicate<Thing> negativePredicate = createPredicate("exists(attributes/anArrayOfObjects/missing)");
+        assertThat(negativePredicate.test(MATCHING_THING))
+                .as("Filtering 'exists(attributes/anArrayOfObjects/missing)' should be false")
+                .isFalse();
+    }
+
+    @Test
+    public void testFilterAttributeNestedInArrayNestedExists() {
+        final Predicate<Thing> thingPredicate = createPredicate("exists(attributes/anArrayOfObjects/anArrayOfObjects/aBoolean)");
+        assertThat(thingPredicate.test(MATCHING_THING))
+                .as("Filtering 'exists(attributes/anArrayOfObjects/anArrayOfObjects/aBoolean)' should be true")
+                .isTrue();
+
+        final Predicate<Thing> negativePredicate = createPredicate("exists(attributes/anArrayOfObjects/anArrayOfObjects/missing)");
+        assertThat(negativePredicate.test(MATCHING_THING))
+                .as("Filtering 'exists(attributes/anArrayOfObjects/anArrayOfObjects/missing)' should be false")
+                .isFalse();
+    }
+
+    @Test
+    public void testFilterArrayAttributeWithNestedIntegerGe() {
+        final String filter = "ge(attributes/anArrayOfObjects/anInteger," + (MATCHING_THING_INTEGER - 1) + ")";
+        final Predicate<Thing> thingPredicate = createPredicate(filter);
+        assertThat(thingPredicate.test(MATCHING_THING))
+                .as("Filtering '" + filter + "' should be true")
+                .isTrue();
+    }
+
+    @Test
+    public void testFilterArrayAttributeWithArrayNestedIntegerGe() {
+        final String filter =
+                "ge(attributes/anArrayOfObjects/anArrayOfObjects/anInteger," + (MATCHING_THING_INTEGER - 1) + ")";
+        final Predicate<Thing> thingPredicate = createPredicate(filter);
+        assertThat(thingPredicate.test(MATCHING_THING))
+                .as("Filtering '" + filter + "' should be true")
+                .isTrue();
+    }
+
+    @Test
+    public void testFilterArrayAttributeWithNestedBooleanEq() {
+        final Predicate<Thing> thingPredicate = createPredicate("eq(attributes/anArrayOfObjects/aBoolean,true)");
+        assertThat(thingPredicate.test(MATCHING_THING))
+                .as("Filtering 'exists(attributes/anArrayOfObjects/aBoolean)' should be true")
+                .isTrue();
+    }
+
+    @Test
+    public void testFilterArrayAttributeWithArrayNestedBooleanEq() {
+        final Predicate<Thing> thingPredicate = createPredicate("eq(attributes/anArrayOfObjects/anArrayOfObjects/aBoolean,true)");
+        assertThat(thingPredicate.test(MATCHING_THING))
+                .as("Filtering 'exists(attributes/anArrayOfObjects/anArrayOfObjects/aBoolean)' should be true")
+                .isTrue();
+    }
+
     @Test
     public void testFilterFeatureExists() {
         final Predicate<Thing> thingPredicate = createPredicate("exists(features/foo)");