Add containsKeyValue query condition and setParameters overload.

Author: greenrobot-team

objectbox-java/src/main/java/io/objectbox/Property.java

@@ -31,6 +31,7 @@
 import io.objectbox.query.PropertyQueryConditionImpl.StringArrayCondition;
 import io.objectbox.query.PropertyQueryConditionImpl.StringCondition;
 import io.objectbox.query.PropertyQueryConditionImpl.StringCondition.Operation;
+import io.objectbox.query.PropertyQueryConditionImpl.StringStringCondition;
 import io.objectbox.query.QueryBuilder.StringOrder;
 
 import javax.annotation.Nullable;
@@ -463,6 +464,25 @@ private void checkIsStringArray() {
         }
     }
 
+    /**
+     * For a String-key map property, matches if at least one key and value combination equals the given values
+     * using {@link StringOrder#CASE_SENSITIVE StringOrder#CASE_SENSITIVE}.
+     *
+     * @see #containsKeyValue(String, String, StringOrder)
+     */
+    public PropertyQueryCondition<ENTITY> containsKeyValue(String key, String value) {
+        return new StringStringCondition<>(this, StringStringCondition.Operation.CONTAINS_KEY_VALUE,
+                key, value, StringOrder.CASE_SENSITIVE);
+    }
+
+    /**
+     * @see #containsKeyValue(String, String)
+     */
+    public PropertyQueryCondition<ENTITY> containsKeyValue(String key, String value, StringOrder order) {
+        return new StringStringCondition<>(this, StringStringCondition.Operation.CONTAINS_KEY_VALUE,
+                key, value, order);
+    }
+
     /**
      * Creates a starts with condition using {@link StringOrder#CASE_SENSITIVE StringOrder#CASE_SENSITIVE}.
      *

objectbox-java/src/main/java/io/objectbox/query/PropertyQueryConditionImpl.java

@@ -343,6 +343,34 @@ void applyCondition(QueryBuilder<T> builder) {
         }
     }
 
+    public static class StringStringCondition<T> extends PropertyQueryConditionImpl<T> {
+        private final Operation op;
+        private final String leftValue;
+        private final String rightValue;
+        private final StringOrder order;
+
+        public enum Operation {
+            CONTAINS_KEY_VALUE
+        }
+
+        public StringStringCondition(Property<T> property, Operation op, String leftValue, String rightValue, StringOrder order) {
+            super(property);
+            this.op = op;
+            this.leftValue = leftValue;
+            this.rightValue = rightValue;
+            this.order = order;
+        }
+
+        @Override
+        void applyCondition(QueryBuilder<T> builder) {
+            if (op == Operation.CONTAINS_KEY_VALUE) {
+                builder.containsKeyValue(property, leftValue, rightValue, order);
+            } else {
+                throw new UnsupportedOperationException(op + " is not supported with two String values");
+            }
+        }
+    }
+
     public static class StringArrayCondition<T> extends PropertyQueryConditionImpl<T> {
         private final Operation op;
         private final String[] value;

objectbox-java/src/main/java/io/objectbox/query/Query.java

@@ -74,6 +74,9 @@ public class Query<T> implements Closeable {
     native void nativeSetParameter(long handle, int entityId, int propertyId, @Nullable String parameterAlias,
                                    String value);
 
+    private native void nativeSetParameters(long handle, int entityId, int propertyId, @Nullable String parameterAlias,
+                                            String value, String value2);
+
     native void nativeSetParameter(long handle, int entityId, int propertyId, @Nullable String parameterAlias,
                                    long value);
 
@@ -564,6 +567,24 @@ public Query<T> setParameters(String alias, String[] values) {
         return this;
     }
 
+    /**
+     * Sets a parameter previously given to the {@link QueryBuilder} to new values.
+     */
+    public Query<T> setParameters(Property<?> property, String key, String value) {
+        nativeSetParameters(handle, property.getEntityId(), property.getId(), null, key, value);
+        return this;
+    }
+
+    /**
+     * Sets a parameter previously given to the {@link QueryBuilder} to new values.
+     *
+     * @param alias as defined using {@link QueryBuilder#parameterAlias(String)}.
+     */
+    public Query<T> setParameters(String alias, String key, String value) {
+        nativeSetParameters(handle, 0, 0, alias, key, value);
+        return this;
+    }
+
     /**
      * Sets a parameter previously given to the {@link QueryBuilder} to new values.
      */

objectbox-java/src/main/java/io/objectbox/query/QueryBuilder.java

@@ -184,6 +184,8 @@ private native long nativeLink(long handle, long storeHandle, int relationOwnerE
 
     private native long nativeContainsElement(long handle, int propertyId, String value, boolean caseSensitive);
 
+    private native long nativeContainsKeyValue(long handle, int propertyId, String key, String value, boolean caseSensitive);
+
     private native long nativeStartsWith(long handle, int propertyId, String value, boolean caseSensitive);
 
     private native long nativeEndsWith(long handle, int propertyId, String value, boolean caseSensitive);
@@ -780,6 +782,15 @@ public QueryBuilder<T> containsElement(Property<T> property, String value, Strin
         return this;
     }
 
+    /**
+     * For a String-key map property, matches if at least one key and value combination equals the given values.
+     */
+    public QueryBuilder<T> containsKeyValue(Property<T> property, String key, String value, StringOrder order) {
+        verifyHandle();
+        checkCombineCondition(nativeContainsKeyValue(handle, property.getId(), key, value, order == StringOrder.CASE_SENSITIVE));
+        return this;
+    }
+
     public QueryBuilder<T> startsWith(Property<T> property, String value, StringOrder order) {
         verifyHandle();
         checkCombineCondition(nativeStartsWith(handle, property.getId(), value, order == StringOrder.CASE_SENSITIVE));