feat: support $NOT, $AND, $OR nested filters (#47)

* feat: support , ,  nested filters

* feat: support , ,  nested filters. add README

Author: thunderz99

README.md

@@ -29,7 +29,7 @@ java-cosmos is a client for Azure CosmosDB 's SQL API (also called documentdb fo
 <dependency>
   <groupId>com.github.thunderz99</groupId>
   <artifactId>java-cosmos</artifactId>
-  <version>0.4.1</version>
+  <version>0.4.2</version>
 </dependency>
 
 ```
@@ -167,17 +167,24 @@ db.updatePartial("Container", user1.id, Map.of("lastName", "UpdatedPartially"),
       "tagIds ARRAY_CONTAINS", "T001", // see cosmosdb ARRAY_CONTAINS
       "tagIds ARRAY_CONTAINS_ANY", List.of("T001", "T002"), // see cosmosdb EXISTS
       "tags ARRAY_CONTAINS_ALL name", List.of("Java", "React"), // see cosmosdb EXISTS
-      "SUB_COND_OR", List.of( // add an OR sub condition
+      "$OR", List.of( // add an OR sub condition
         Condition.filter("position", "leader"),  // subquery's fields/order/offset/limit will be ignored
         Condition.filter("organization.id", "executive_committee")
       ),
-      "SUB_COND_OR 2", List.of( // add another OR sub condition (name it SUB_COND_OR xxx in order to avoid the same key to a previous SUB_COND_OR )
+      "$OR 2", List.of( // add another OR sub condition (name it $OR xxx in order to avoid the same key to a previous $OR )
         Condition.filter("position", "leader"),  // subquery's fields/order/offset/limit will be ignored
         Condition.filter("organization.id", "executive_committee")
       ),
-      "SUB_COND_AND", List.of(
+      "$AND", List.of(
         Condition.filter("tagIds ARRAY_CONTAINS_ALL", List.of("T001", "T002")).not() // A negative condition. see cosmosdb NOT
         Condition.filter("city", "Tokyo")
+      ),
+      "$NOT", Map.of("lastName CONTAINS", "Willington"), // A negative query using $NOT
+      "$NOT 2", Map.of("$OR 3",  // A nested filter using $NOT and $OR
+        List.of(
+          Map.of("lastName", ""),  // note they will do the same thing using Condition.filter or Map.of
+          Map.of("age >=", 20)
+        )
       )
     )
     .fields("id", "lastName", "age", "organization.name") // select certain fields
@@ -251,12 +258,12 @@ db.updatePartial("Container", user1.id, Map.of("lastName", "UpdatedPartially"),
     var params =  new SqlParameterCollection(new SqlParameter("@state", "%NY%"));
 
     var cond = Condition.filter(
-      "SUB_COND_AND", 
+      "$AND", 
       List.of(
         Condition.filter("gender", "female"), 
         Condition.rawSql("c.state LIKE @state", params)
       ),
-      "SUB_COND_AND another", // name it SUB_COND_OR xxx in order to avoid the same key to a previous SUB_COND_AND
+      "$AND another", // name it $OR xxx in order to avoid the same key to a previous $AND
       List.of(
         Condition.filter("age > ", "22"), 
         Condition.rawSql("c.address != \"\" ")
@@ -268,3 +275,81 @@ db.updatePartial("Container", user1.id, Map.of("lastName", "UpdatedPartially"),
 
 ```
 
+
+
+### Queries using json as a filter
+
+Support the following operators in order to implement nested filter queries using JSON, especially for a rest api.
+
+
+#### $NOT example
+
+```
+
+var queryJson="""
+{
+  "$NOT":
+    {
+      "address.state": "WA"
+    },
+  "$NOT 2":  {
+      "id": "AndersenFamily"
+    }
+}
+"""
+
+var cond = new Condition(JsonUtil.toMap(queryJson)).sort("id", "ASC");
+var items = db.find(conName, cond, partition);
+
+```
+
+#### $OR example
+
+```
+{
+  "$OR": [
+    {
+      "address.state": "WA"
+    },
+    {
+      "id": "WakefieldFamily"
+    }
+  ]
+}
+```
+
+#### $AND example
+
+```
+{
+  "$AND": {
+    "address.state": "WA",
+    "lastName": "Andersen"
+  }
+}
+```
+
+#### nested example
+
+```
+{
+  "$AND" : [
+    {
+      "$OR": [
+        {
+          "address.state": "WA"
+        },
+        {
+          "id": "WakefieldFamily"
+        }
+      ]
+    },
+    {
+      "$NOT": {
+        "creationDate =": 1431620472
+      }
+    }
+  ]
+}
+
+```

pom.xml

@@ -4,7 +4,7 @@
     <groupId>com.github.thunderz99</groupId>
     <artifactId>java-cosmos</artifactId>
     <packaging>jar</packaging>
-    <version>0.4.1</version>
+    <version>0.4.2</version>
     <name>${project.groupId}:${project.artifactId}$</name>
     <description>A lightweight Azure CosmosDB client for Java</description>
     <url>https://github.com/thunderz99/java-cosmos</url>

src/main/java/io/github/thunderz99/cosmos/condition/Condition.java

@@ -23,27 +23,36 @@
  */
 public class Condition {
 
-	private static Logger log = LoggerFactory.getLogger(Condition.class);
+    private static Logger log = LoggerFactory.getLogger(Condition.class);
 
-	/**
-	 * Default constructor
-	 */
-	public Condition() {
-	}
+    /**
+     * Default constructor
+     */
+    public Condition() {
+    }
 
-	public Map<String, Object> filter = new LinkedHashMap<>();
+    /**
+     * A constructor accepting a map as filter
+     *
+     * @param filter
+     */
+    public Condition(Map<String, Object> filter) {
+        this.filter = filter;
+    }
 
-	public List<String> sort = List.of();
+    public Map<String, Object> filter = new LinkedHashMap<>();
 
-	public Set<String> fields = new LinkedHashSet<>();
+    public List<String> sort = List.of();
 
-	public int offset = 0;
-	public int limit = 100;
+    public Set<String> fields = new LinkedHashSet<>();
 
-	/**
-	 * whether this query is cross-partition or not (default to false)
-	 */
-	public boolean crossPartition = false;
+    public int offset = 0;
+    public int limit = 100;
+
+    /**
+     * whether this query is cross-partition or not (default to false)
+     */
+    public boolean crossPartition = false;
 
     /**
      * whether this query is a negative query. (default to false)
@@ -346,23 +355,30 @@ FilterQuery generateFilterQuery(String selectPart, List<SqlParameter> params,
 
             var subFilterQueryToAdd = "";
 
-            if (entry.getKey().startsWith(SubConditionType.SUB_COND_AND.name())) {
+            if (entry.getKey().startsWith(SubConditionType.AND)) {
                 // sub query AND
-				var subQueries = extractSubQueries(entry.getValue());
-				subFilterQueryToAdd = generateFilterQuery4List(subQueries, "AND", params, conditionIndex, paramIndex);
-
-			} else if (entry.getKey().startsWith(SubConditionType.SUB_COND_OR.name())) {
-				// sub query OR
-				var subQueries = extractSubQueries(entry.getValue());
-				subFilterQueryToAdd = generateFilterQuery4List(subQueries, "OR", params, conditionIndex, paramIndex);
-
-			} else {
-				// normal expression
-				var exp = parse(entry.getKey(), entry.getValue());
-				var expQuerySpec = exp.toQuerySpec(paramIndex);
-				subFilterQueryToAdd = expQuerySpec.getQueryText();
-				params.addAll(expQuerySpec.getParameters());
-			}
+                var subQueries = extractSubQueries(entry.getValue());
+                subFilterQueryToAdd = generateFilterQuery4List(subQueries, "AND", params, conditionIndex, paramIndex);
+
+            } else if (entry.getKey().startsWith(SubConditionType.OR)) {
+                // sub query OR
+                var subQueries = extractSubQueries(entry.getValue());
+                subFilterQueryToAdd = generateFilterQuery4List(subQueries, "OR", params, conditionIndex, paramIndex);
+
+            } else if (entry.getKey().startsWith(SubConditionType.NOT)) {
+                // sub query NOT
+                var subQueries = extractSubQueries(entry.getValue());
+                var subQueryWithNot = Condition.filter(SubConditionType.AND, subQueries).not();
+                // recursively generate the filterQuery with negative flag true
+                var filterQueryWithNot = subQueryWithNot.generateFilterQuery("", params, conditionIndex, paramIndex);
+                subFilterQueryToAdd = " " + removeConnectPart(filterQueryWithNot.queryText.toString());
+            } else {
+                // normal expression
+                var exp = parse(entry.getKey(), entry.getValue());
+                var expQuerySpec = exp.toQuerySpec(paramIndex);
+                subFilterQueryToAdd = expQuerySpec.getQueryText();
+                params.addAll(expQuerySpec.getParameters());
+            }
 
 			if (StringUtils.isNotEmpty(subFilterQueryToAdd)) {
 				queryTexts.add(subFilterQueryToAdd);
@@ -384,32 +400,57 @@ FilterQuery generateFilterQuery(String selectPart, List<SqlParameter> params,
 		return new FilterQuery(queryText, params, conditionIndex, paramIndex);
 	}
 
-	/**
-	 * add negative NOT operator for queryText, if not empty
-	 *
-	 * @param queryText
-	 * @param negative
-	 * @return
-	 */
-	static String processNegativeQuery(String queryText, boolean negative) {
-		return negative && StringUtils.isNotEmpty(queryText) ?
-				" NOT(" + queryText + ")" : queryText;
-	}
+    /**
+     * add negative NOT operator for queryText, if not empty
+     *
+     * @param queryText
+     * @param negative
+     * @return
+     */
+    static String processNegativeQuery(String queryText, boolean negative) {
+        return negative && StringUtils.isNotEmpty(queryText) ?
+                " NOT(" + queryText + ")" : queryText;
+    }
 
-	/**
-	 * extract subQueries for SUB_COND_AND / SUB_COND_OR 's filter value
-	 *
-	 * @param value
-	 */
-	static List<Condition> extractSubQueries(Object value) {
-		if (value == null) {
-			return List.of();
-		}
+    /**
+     * extract subQuery for SUB_COND_AND / SUB_COND_OR 's filter value, single condition only.
+     *
+     * @param value
+     */
+    static Condition extractSubQuery(Object value) {
+        if (value == null) {
+            return null;
+        }
 
         if (value instanceof Condition) {
-            return List.of((Condition) value);
+            // single condition
+            return (Condition) value;
+        } else if (value instanceof Map<?, ?>) {
+            // single condition in the form of map
+            return new Condition(JsonUtil.toMap(value));
+        } else if (value instanceof Collection<?>) {
+            throw new IllegalArgumentException("Cannot convert input to a single condition. Ensure the input is a single value(not a collection)." + value);
+        }
+        throw new IllegalArgumentException("Invalid input. expect a condition or a map. " + value);
+    }
+
+    /**
+     * extract subQueries for SUB_COND_AND / SUB_COND_OR 's filter value
+     *
+     * @param value
+     */
+    static List<Condition> extractSubQueries(Object value) {
+        if (value == null) {
+            return List.of();
+        }
+
+        if (value instanceof Condition || value instanceof Map<?, ?>) {
+            // single condition
+            return List.of(extractSubQuery(value));
         } else if (value instanceof List<?>) {
-            return (List<Condition>) value;
+            // multi condition
+            var listValue = (List<Object>) value;
+            return listValue.stream().map(v -> extractSubQuery(v)).filter(Objects::nonNull).collect(Collectors.toList());
         }
 
         return List.of();
@@ -665,17 +706,6 @@ public static Condition rawSql(String queryText) {
 		return cond;
 	}
 
-	/**
-	 * sub query 's OR / RAW operator
-	 *
-	 * <p>
-	 * TODO SUB_COND_NOT operator
-	 * </p>
-	 */
-	public enum SubConditionType {
-		SUB_COND_AND, SUB_COND_OR
-	}
-
 	/**
 	 * Instead of c.key, return c["key"] or c["key1"]["key2"] for query. In order for cosmosdb reserved words
 	 *

src/main/java/io/github/thunderz99/cosmos/condition/SubConditionType.java

@@ -0,0 +1,12 @@
+package io.github.thunderz99.cosmos.condition;
+
+/**
+ * sub query 's OR / AND / NOT operator
+ */
+public class SubConditionType {
+
+    public static final String AND = "$AND";
+    public static final String OR = "$OR";
+    public static final String NOT = "$NOT";
+
+}