Query builder support for NOT CQL syntax

patch by Bret McGuire; reviewed by Bret McGuire and Andy Tolbert for CASSANDRA-19930

Author: absurdfarce

query-builder/src/main/java/com/datastax/oss/driver/api/querybuilder/relation/ColumnRelationBuilder.java

@@ -46,4 +46,28 @@ default ResultT contains(@NonNull Term term) {
   default ResultT containsKey(@NonNull Term term) {
     return build(" CONTAINS KEY ", term);
   }
+
+  /**
+   * Builds a NOT CONTAINS relation for the column.
+   *
+   * <p>Note that NOT CONTAINS support is only available in Cassandra 5.1 or later. See <a
+   * href="https://issues.apache.org/jira/browse/CASSANDRA-18584">CASSANDRA-18584</a> for more
+   * information.
+   */
+  @NonNull
+  default ResultT notContains(@NonNull Term term) {
+    return build(" NOT CONTAINS ", term);
+  }
+
+  /**
+   * Builds a NOT CONTAINS KEY relation for the column.
+   *
+   * <p>Note that NOT CONTAINS KEY support is only available in Cassandra 5.1 or later. See <a
+   * href="https://issues.apache.org/jira/browse/CASSANDRA-18584">CASSANDRA-18584</a> for more
+   * information.
+   */
+  @NonNull
+  default ResultT notContainsKey(@NonNull Term term) {
+    return build(" NOT CONTAINS KEY ", term);
+  }
 }

query-builder/src/main/java/com/datastax/oss/driver/api/querybuilder/relation/InRelationBuilder.java

@@ -50,6 +50,38 @@ default ResultT in(@NonNull Term... alternatives) {
     return in(Arrays.asList(alternatives));
   }
 
+  /**
+   * Builds a NOT IN relation where the whole set of possible values is a bound variable, as in
+   * {@code NOT IN ?}.
+   *
+   * <p>Note that NOT IN support is only available in Cassandra 5.1 or later. See <a
+   * href="https://issues.apache.org/jira/browse/CASSANDRA-18584">CASSANDRA-18584</a> for more
+   * information.
+   */
+  @NonNull
+  default ResultT notIn(@NonNull BindMarker bindMarker) {
+    return build(" NOT IN ", bindMarker);
+  }
+
+  /**
+   * Builds an IN relation where the arguments are the possible values, as in {@code IN (term1,
+   * term2...)}.
+   *
+   * <p>Note that NOT IN support is only available in Cassandra 5.1 or later. See <a
+   * href="https://issues.apache.org/jira/browse/CASSANDRA-18584">CASSANDRA-18584</a> for more
+   * information.
+   */
+  @NonNull
+  default ResultT notIn(@NonNull Iterable<Term> alternatives) {
+    return build(" NOT IN ", QueryBuilder.tuple(alternatives));
+  }
+
+  /** Var-arg equivalent of {@link #notIn(Iterable)} . */
+  @NonNull
+  default ResultT notIn(@NonNull Term... alternatives) {
+    return notIn(Arrays.asList(alternatives));
+  }
+
   @NonNull
   ResultT build(@NonNull String operator, @Nullable Term rightOperand);
 }

query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/relation/RelationTest.java

@@ -19,10 +19,12 @@
 
 import static com.datastax.oss.driver.api.querybuilder.Assertions.assertThat;
 import static com.datastax.oss.driver.api.querybuilder.QueryBuilder.bindMarker;
+import static com.datastax.oss.driver.api.querybuilder.QueryBuilder.literal;
 import static com.datastax.oss.driver.api.querybuilder.QueryBuilder.raw;
 import static com.datastax.oss.driver.api.querybuilder.QueryBuilder.selectFrom;
 import static com.datastax.oss.driver.api.querybuilder.QueryBuilder.tuple;
 
+import org.assertj.core.util.Lists;
 import org.junit.Test;
 
 public class RelationTest {
@@ -42,13 +44,78 @@ public void should_generate_is_not_null_relation() {
   }
 
   @Test
-  public void should_generate_in_relation() {
+  public void should_generate_contains_relation() {
+    assertThat(selectFrom("foo").all().where(Relation.column("k").contains(literal(1))))
+        .hasCql("SELECT * FROM foo WHERE k CONTAINS 1");
+  }
+
+  @Test
+  public void should_generate_contains_key_relation() {
+    assertThat(selectFrom("foo").all().where(Relation.column("k").containsKey(literal(1))))
+        .hasCql("SELECT * FROM foo WHERE k CONTAINS KEY 1");
+  }
+
+  @Test
+  public void should_generate_not_contains_relation() {
+    assertThat(selectFrom("foo").all().where(Relation.column("k").notContains(literal(1))))
+        .hasCql("SELECT * FROM foo WHERE k NOT CONTAINS 1");
+  }
+
+  @Test
+  public void should_generate_not_contains_key_relation() {
+    assertThat(selectFrom("foo").all().where(Relation.column("k").notContainsKey(literal(1))))
+        .hasCql("SELECT * FROM foo WHERE k NOT CONTAINS KEY 1");
+  }
+
+  @Test
+  public void should_generate_in_relation_bind_markers() {
     assertThat(selectFrom("foo").all().where(Relation.column("k").in(bindMarker())))
         .hasCql("SELECT * FROM foo WHERE k IN ?");
     assertThat(selectFrom("foo").all().where(Relation.column("k").in(bindMarker(), bindMarker())))
         .hasCql("SELECT * FROM foo WHERE k IN (?,?)");
   }
 
+  @Test
+  public void should_generate_in_relation_terms() {
+    assertThat(
+            selectFrom("foo")
+                .all()
+                .where(
+                    Relation.column("k")
+                        .in(Lists.newArrayList(literal(1), literal(2), literal(3)))))
+        .hasCql("SELECT * FROM foo WHERE k IN (1,2,3)");
+    assertThat(
+            selectFrom("foo")
+                .all()
+                .where(Relation.column("k").in(literal(1), literal(2), literal(3))))
+        .hasCql("SELECT * FROM foo WHERE k IN (1,2,3)");
+  }
+
+  @Test
+  public void should_generate_not_in_relation_bind_markers() {
+    assertThat(selectFrom("foo").all().where(Relation.column("k").notIn(bindMarker())))
+        .hasCql("SELECT * FROM foo WHERE k NOT IN ?");
+    assertThat(
+            selectFrom("foo").all().where(Relation.column("k").notIn(bindMarker(), bindMarker())))
+        .hasCql("SELECT * FROM foo WHERE k NOT IN (?,?)");
+  }
+
+  @Test
+  public void should_generate_not_in_relation_terms() {
+    assertThat(
+            selectFrom("foo")
+                .all()
+                .where(
+                    Relation.column("k")
+                        .notIn(Lists.newArrayList(literal(1), literal(2), literal(3)))))
+        .hasCql("SELECT * FROM foo WHERE k NOT IN (1,2,3)");
+    assertThat(
+            selectFrom("foo")
+                .all()
+                .where(Relation.column("k").notIn(literal(1), literal(2), literal(3))))
+        .hasCql("SELECT * FROM foo WHERE k NOT IN (1,2,3)");
+  }
+
   @Test
   public void should_generate_token_relation() {
     assertThat(selectFrom("foo").all().where(Relation.token("k1", "k2").isEqualTo(bindMarker("t"))))