feat(datastore) add support for notContains query operator (#1145)

Author: richardmcclellan

aws-api-appsync/src/main/java/com/amplifyframework/core/model/query/predicate/GsonPredicateAdapters.java

@@ -64,6 +64,8 @@ public QueryOperator<?> deserialize(JsonElement json, Type type, JsonDeserializa
             switch (QueryOperator.Type.valueOf(operatorType)) {
                 case CONTAINS:
                     return context.deserialize(json, ContainsQueryOperator.class);
+                case NOT_CONTAINS:
+                    return context.deserialize(json, NotContainsQueryOperator.class);
                 case GREATER_OR_EQUAL:
                     return context.deserialize(json, GreaterOrEqualQueryOperator.class);
                 case LESS_OR_EQUAL:
@@ -93,6 +95,8 @@ public QueryOperator<?> deserialize(JsonElement json, Type type, JsonDeserializa
         public JsonElement serialize(QueryOperator<?> operator, Type type, JsonSerializationContext context) {
             if (operator instanceof ContainsQueryOperator) {
                 return context.serialize(operator, ContainsQueryOperator.class);
+            } else if (operator instanceof NotContainsQueryOperator) {
+                return context.serialize(operator, NotContainsQueryOperator.class);
             } else if (operator instanceof GreaterOrEqualQueryOperator) {
                 return context.serialize(operator, GreaterOrEqualQueryOperator.class);
             } else if (operator instanceof LessOrEqualQueryOperator) {

aws-api/src/main/java/com/amplifyframework/api/aws/AppSyncGraphQLRequestFactory.java

@@ -37,6 +37,7 @@
 import com.amplifyframework.core.model.query.predicate.GreaterThanQueryOperator;
 import com.amplifyframework.core.model.query.predicate.LessOrEqualQueryOperator;
 import com.amplifyframework.core.model.query.predicate.LessThanQueryOperator;
+import com.amplifyframework.core.model.query.predicate.NotContainsQueryOperator;
 import com.amplifyframework.core.model.query.predicate.NotEqualQueryOperator;
 import com.amplifyframework.core.model.query.predicate.QueryOperator;
 import com.amplifyframework.core.model.query.predicate.QueryPredicate;
@@ -336,6 +337,8 @@ private static Object appSyncOpValue(QueryOperator<?> qOp) {
                 return ((GreaterThanQueryOperator<?>) qOp).value();
             case CONTAINS:
                 return ((ContainsQueryOperator) qOp).value();
+            case NOT_CONTAINS:
+                return ((NotContainsQueryOperator) qOp).value();
             case BETWEEN:
                 BetweenQueryOperator<?> betweenOp = (BetweenQueryOperator<?>) qOp;
                 return Arrays.asList(betweenOp.start(), betweenOp.end());

aws-datastore/src/main/java/com/amplifyframework/datastore/appsync/AppSyncRequestFactory.java

@@ -38,6 +38,7 @@
 import com.amplifyframework.core.model.query.predicate.GreaterThanQueryOperator;
 import com.amplifyframework.core.model.query.predicate.LessOrEqualQueryOperator;
 import com.amplifyframework.core.model.query.predicate.LessThanQueryOperator;
+import com.amplifyframework.core.model.query.predicate.NotContainsQueryOperator;
 import com.amplifyframework.core.model.query.predicate.NotEqualQueryOperator;
 import com.amplifyframework.core.model.query.predicate.QueryOperator;
 import com.amplifyframework.core.model.query.predicate.QueryPredicate;
@@ -248,6 +249,8 @@ private static Object appSyncOpValue(QueryOperator<?> qOp) throws DataStoreExcep
                 return ((GreaterThanQueryOperator<?>) qOp).value();
             case CONTAINS:
                 return ((ContainsQueryOperator) qOp).value();
+            case NOT_CONTAINS:
+                return ((NotContainsQueryOperator) qOp).value();
             case BETWEEN:
                 BetweenQueryOperator<?> betweenOp = (BetweenQueryOperator<?>) qOp;
                 return Arrays.asList(betweenOp.start(), betweenOp.end());

aws-datastore/src/main/java/com/amplifyframework/datastore/storage/sqlite/adapter/SQLPredicate.java

@@ -23,6 +23,7 @@
 import com.amplifyframework.core.model.query.predicate.GreaterThanQueryOperator;
 import com.amplifyframework.core.model.query.predicate.LessOrEqualQueryOperator;
 import com.amplifyframework.core.model.query.predicate.LessThanQueryOperator;
+import com.amplifyframework.core.model.query.predicate.NotContainsQueryOperator;
 import com.amplifyframework.core.model.query.predicate.NotEqualQueryOperator;
 import com.amplifyframework.core.model.query.predicate.QueryOperator;
 import com.amplifyframework.core.model.query.predicate.QueryPredicate;
@@ -163,6 +164,19 @@ private StringBuilder parsePredicateOperation(QueryPredicateOperation<?> operati
                         .append(SqlKeyword.fromQueryOperator(QueryOperator.Type.GREATER_THAN))
                         .append(SqlKeyword.DELIMITER)
                         .append("0");
+
+            case NOT_CONTAINS:
+                NotContainsQueryOperator notContainsOp = (NotContainsQueryOperator) op;
+                addBinding(notContainsOp.value());
+                return builder.append("instr(")
+                        .append(column)
+                        .append(",")
+                        .append("?")
+                        .append(")")
+                        .append(SqlKeyword.DELIMITER)
+                        .append(SqlKeyword.fromQueryOperator(QueryOperator.Type.EQUAL))
+                        .append(SqlKeyword.DELIMITER)
+                        .append("0");
             case BEGINS_WITH:
                 BeginsWithQueryOperator beginsWithOp = (BeginsWithQueryOperator) op;
                 addBinding(beginsWithOp.value() + "%");

aws-datastore/src/test/java/com/amplifyframework/datastore/storage/sqlite/SQLPredicateTest.java

@@ -81,9 +81,37 @@ public void testContainsForStringList() throws DataStoreException {
         validateSQLExpressionForContains(sqlPredicate, "tags");
     }
 
+    /**
+     * Test notContains in the context of a String field.
+     * @throws DataStoreException Not thrown.
+     */
+    @Test
+    public void testNotContainsForStringField() throws DataStoreException {
+        QueryPredicate predicate = Where.matches(Blog.NAME.notContains("something")).getQueryPredicate();
+        SQLPredicate sqlPredicate = new SQLPredicate(predicate);
+        validateSQLExpressionForNotContains(sqlPredicate, "name");
+    }
+
+    /**
+     * Test notContains in the context of a list.
+     * @throws DataStoreException Not thrown.
+     */
+    @Test
+    public void testNotContainsForStringList() throws DataStoreException {
+        QueryPredicateOperation<String> predicate = Blog.TAGS.notContains("something");
+        SQLPredicate sqlPredicate = new SQLPredicate(predicate);
+        validateSQLExpressionForNotContains(sqlPredicate, "tags");
+    }
+
     private void validateSQLExpressionForContains(SQLPredicate sqlPredicate, String fieldName) {
         assertEquals(1, sqlPredicate.getBindings().size());
         assertEquals("something", sqlPredicate.getBindings().get(0));
         assertEquals("instr(" + fieldName + ",?) > 0", sqlPredicate.toString());
     }
+
+    private void validateSQLExpressionForNotContains(SQLPredicate sqlPredicate, String fieldName) {
+        assertEquals(1, sqlPredicate.getBindings().size());
+        assertEquals("something", sqlPredicate.getBindings().get(0));
+        assertEquals("instr(" + fieldName + ",?) = 0", sqlPredicate.toString());
+    }
 }

core/src/main/java/com/amplifyframework/core/model/query/predicate/NotContainsQueryOperator.java

@@ -0,0 +1,83 @@
+/*
+ * Copyright 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at
+ *
+ *  http://aws.amazon.com/apache2.0
+ *
+ * or in the "license" file accompanying this file. This file is distributed
+ * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied. See the License for the specific language governing
+ * permissions and limitations under the License.
+ */
+
+package com.amplifyframework.core.model.query.predicate;
+
+import androidx.core.util.ObjectsCompat;
+
+/**
+ * Represents a notContains condition with a target value for comparison.
+ */
+public final class NotContainsQueryOperator extends QueryOperator<String> {
+    private final String value;
+
+    /**
+     * Constructs a notContains condition.
+     * @param value the value to be used in the comparison
+     */
+    NotContainsQueryOperator(String value) {
+        super(Type.NOT_CONTAINS);
+        this.value = value;
+    }
+
+    /**
+     * Returns the value to be used in the comparison.
+     * @return the value to be used in the comparison
+     */
+    public Object value() {
+        return value;
+    }
+
+    /**
+     * Returns true if the provided field value does not contain
+     * the value associated with this operator.
+     * @param field the field value to operate on
+     * @return evaluated result of the operator
+     */
+    @Override
+    public boolean evaluate(String field) {
+        return !field.contains(value);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        } else if (obj == null || getClass() != obj.getClass()) {
+            return false;
+        } else {
+            NotContainsQueryOperator op = (NotContainsQueryOperator) obj;
+
+            return ObjectsCompat.equals(type(), op.type()) &&
+                    ObjectsCompat.equals(value(), op.value());
+        }
+    }
+
+    @Override
+    public int hashCode() {
+        return ObjectsCompat.hash(
+                type(),
+                value()
+        );
+    }
+
+    @Override
+    public String toString() {
+        return "NotContainsQueryOperator { " +
+                "type: " + type() +
+                ", value: " + value() +
+                " }";
+    }
+}

core/src/main/java/com/amplifyframework/core/model/query/predicate/QueryField.java

@@ -143,6 +143,15 @@ public QueryPredicateOperation<String> contains(String value) {
         return new QueryPredicateOperation<>(modelName, fieldName, new ContainsQueryOperator(value));
     }
 
+    /**
+     * Generates a new notContains comparison object to compare this field to the specified value.
+     * @param value the value to be compared
+     * @return an operation object representing the contains condition
+     */
+    public QueryPredicateOperation<String> notContains(String value) {
+        return new QueryPredicateOperation<>(modelName, fieldName, new NotContainsQueryOperator(value));
+    }
+
     /**
      * Generates a new sort object specifying a field that should be sorted in ascending order for a query.
      *

core/src/main/java/com/amplifyframework/core/model/query/predicate/QueryOperator.java

@@ -71,6 +71,10 @@ public enum Type {
          * Contains some value comparison.
          */
         CONTAINS,
+        /**
+         * Does not contain some value comparison.
+         */
+        NOT_CONTAINS,
         /**
          * Between two values comparison.
          */

core/src/test/java/com/amplifyframework/core/model/query/predicate/OperatorTest.java

@@ -203,5 +203,18 @@ public void testContainsOperator() {
         assertFalse(operator.evaluate("World"));
         assertFalse(operator.evaluate(""));
     }
+
+    /**
+     * Test the accuracy of notContains operator evaluation.
+     */
+    @Test
+    public void testNotContainsOperator() {
+        final NotContainsQueryOperator operator = new NotContainsQueryOperator("e");
+
+        assertFalse(operator.evaluate("Hello"));
+        assertFalse(operator.evaluate("e"));
+        assertTrue(operator.evaluate("World"));
+        assertTrue(operator.evaluate(""));
+    }
 }
 

core/src/test/java/com/amplifyframework/core/model/query/predicate/PredicateTest.java

@@ -78,6 +78,8 @@ public void testPredicateOperationEvaluation() {
         assertTrue(Person.FIRST_NAME.eq("Jane").evaluate(jane));
         assertTrue(Person.FIRST_NAME.beginsWith("J").evaluate(jane));
         assertTrue(Person.FIRST_NAME.contains("Jan").evaluate(jane));
+        assertTrue(Person.FIRST_NAME.notContains("D").evaluate(jane));
+        assertFalse(Person.FIRST_NAME.notContains("Jan").evaluate(jane));
         assertFalse(Person.LAST_NAME.eq("Jane").evaluate(jane));
     }