v6: Filters and fetchObjects query

src/it/java/io/weaviate/integration/DataITest.java

@@ -13,6 +13,7 @@
 import io.weaviate.client6.v1.api.collections.Property;
 import io.weaviate.client6.v1.api.collections.Vectors;
 import io.weaviate.client6.v1.api.collections.WeaviateObject;
+import io.weaviate.client6.v1.api.collections.query.Metadata;
 import io.weaviate.client6.v1.api.collections.vectorindex.Hnsw;
 import io.weaviate.client6.v1.api.collections.vectorizers.NoneVectorizer;
 import io.weaviate.containers.Container;
@@ -40,7 +41,7 @@ public void testCreateGetDelete() throws IOException {
 
     var object = artists.query.byId(id, query -> query
         .returnProperties("name")
-        .includeVector(true));
+        .returnMetadata(Metadata.ID, Metadata.VECTOR));
 
     Assertions.assertThat(object)
         .as("object exists after insert").get()

src/it/java/io/weaviate/integration/ReferencesITest.java

@@ -16,7 +16,7 @@
 import io.weaviate.client6.v1.api.collections.ReferenceProperty;
 import io.weaviate.client6.v1.api.collections.WeaviateObject;
 import io.weaviate.client6.v1.api.collections.data.Reference;
-import io.weaviate.client6.v1.api.collections.query.MetadataField;
+import io.weaviate.client6.v1.api.collections.query.Metadata;
 import io.weaviate.client6.v1.api.collections.query.QueryReference;
 import io.weaviate.containers.Container;
 
@@ -95,9 +95,9 @@ public void testReferences() throws IOException {
     var gotAlex = artists.query.byId(alex.metadata().uuid(),
         opt -> opt.returnReferences(
             QueryReference.multi("hasAwards", nsOscar,
-                ref -> ref.returnMetadata(MetadataField.ID)),
+                ref -> ref.returnMetadata(Metadata.ID)),
             QueryReference.multi("hasAwards", nsGrammy,
-                ref -> ref.returnMetadata(MetadataField.ID))));
+                ref -> ref.returnMetadata(Metadata.ID))));
 
     Assertions.assertThat(gotAlex).get()
         .as("Artists: fetch by id including hasAwards references")
@@ -166,7 +166,7 @@ public void testNestedReferences() throws IOException {
                     .returnReferences(
                         QueryReference.single("presentedBy", r -> r.returnProperties("ceo")))
                     // Grammy ID
-                    .returnMetadata(MetadataField.ID))));
+                    .returnMetadata(Metadata.ID))));
 
     Assertions.assertThat(gotAlex).get()
         .as("Artists: fetch by id including nested references")

src/it/java/io/weaviate/integration/SearchITest.java

@@ -21,8 +21,9 @@
 import io.weaviate.client6.v1.api.collections.WeaviateObject;
 import io.weaviate.client6.v1.api.collections.data.Reference;
 import io.weaviate.client6.v1.api.collections.query.GroupBy;
-import io.weaviate.client6.v1.api.collections.query.MetadataField;
+import io.weaviate.client6.v1.api.collections.query.Metadata;
 import io.weaviate.client6.v1.api.collections.query.QueryResponseGroup;
+import io.weaviate.client6.v1.api.collections.query.Where;
 import io.weaviate.client6.v1.api.collections.vectorindex.Hnsw;
 import io.weaviate.client6.v1.api.collections.vectorizers.Img2VecNeuralVectorizer;
 import io.weaviate.client6.v1.api.collections.vectorizers.NoneVectorizer;
@@ -68,7 +69,7 @@ public void testNearVector() {
         opt -> opt
             .distance(2f)
             .limit(3)
-            .returnMetadata(MetadataField.DISTANCE));
+            .returnMetadata(Metadata.DISTANCE));
 
     Assertions.assertThat(result.objects()).hasSize(3);
     float maxDistance = Collections.max(result.objects(),
@@ -220,4 +221,38 @@ public void testNearImage() throws IOException {
         .extracting(WeaviateObject::properties, InstanceOfAssertFactories.MAP)
         .extractingByKey("breed").isEqualTo("ragdoll");
   }
+
+  @Test
+  public void testFetchObjectsWithFilters() throws IOException {
+    var nsHats = ns("Hats");
+
+    client.collections.create(nsHats,
+        collection -> collection
+            .properties(
+                Property.text("colour"),
+                Property.integer("size")));
+
+    var hats = client.collections.use(nsHats);
+
+    /* blackHat */ hats.data.insert(Map.of("colour", "black", "size", 6));
+    var redHat = hats.data.insert(Map.of("colour", "red", "size", 5));
+    var greenHat = hats.data.insert(Map.of("colour", "green", "size", 1));
+    var hugeHat = hats.data.insert(Map.of("colour", "orange", "size", 40));
+
+    var got = hats.query.fetchObjects(
+        query -> query.where(
+            Where.or(
+                Where.property("colour").eq("orange"),
+                Where.and(
+                    Where.property("size").gte(1),
+                    Where.property("size").lt(6)))));
+
+    Assertions.assertThat(got.objects())
+        .extracting(hat -> hat.metadata().uuid())
+        .containsOnly(
+            redHat.metadata().uuid(),
+            greenHat.metadata().uuid(),
+            hugeHat.metadata().uuid());
+
+  }
 }

src/main/java/io/weaviate/client6/v1/api/collections/aggregate/AggregateRequest.java

@@ -60,7 +60,7 @@ static <T> Rpc<AggregateRequest, WeaviateProtoAggregate.AggregateRequest, Aggreg
           } else if (groupBy.hasText()) {
             groupedBy = new GroupedBy<String>(property, groupBy.getText());
           } else {
-            assert false : "branch not covered";
+            assert false : "(aggregate) branch not covered";
           }
 
           var properties = unmarshalAggregation(result.getAggregations());

src/main/java/io/weaviate/client6/v1/api/collections/query/AbstractQueryClient.java

@@ -37,6 +37,25 @@ protected final <T> Optional<T> optionalFirst(List<T> objects) {
     return objects.isEmpty() ? Optional.empty() : Optional.ofNullable(objects.get(0));
   }
 
+  // Object queries -----------------------------------------------------------
+
+  public ResponseT fetchObjects(Function<FetchObjects.Builder, ObjectBuilder<FetchObjects>> fn) {
+    return fetchObjects(FetchObjects.of(fn));
+  }
+
+  public ResponseT fetchObjects(FetchObjects query) {
+    return performRequest(query);
+  }
+
+  public GroupedResponseT fetchObjects(Function<FetchObjects.Builder, ObjectBuilder<FetchObjects>> fn,
+      GroupBy groupBy) {
+    return fetchObjects(FetchObjects.of(fn), groupBy);
+  }
+
+  public GroupedResponseT fetchObjects(FetchObjects query, GroupBy groupBy) {
+    return performRequest(query, groupBy);
+  }
+
   // NearVector queries -------------------------------------------------------
 
   public ResponseT nearVector(Float[] vector) {

src/main/java/io/weaviate/client6/v1/api/collections/query/BaseQueryOptions.java

@@ -7,14 +7,16 @@
 import org.apache.commons.lang3.StringUtils;
 
 import io.weaviate.client6.v1.internal.ObjectBuilder;
+import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase;
 import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet;
 
 public record BaseQueryOptions(
     Integer limit,
     Integer offset,
     Integer autocut,
     String after,
-    String consistencyLevel,
+    ConsistencyLevel consistencyLevel,
+    Where where,
     List<String> returnProperties,
     List<QueryReference> returnReferences,
     List<Metadata> returnMetadata) {
@@ -26,6 +28,7 @@ private <T extends Object> BaseQueryOptions(Builder<? extends Builder<?, T>, T>
         builder.autocut,
         builder.after,
         builder.consistencyLevel,
+        builder.where,
         builder.returnProperties,
         builder.returnReferences,
         builder.returnMetadata);
@@ -38,7 +41,8 @@ public static abstract class Builder<SELF extends Builder<SELF, T>, T extends Ob
     private Integer offset;
     private Integer autocut;
     private String after;
-    private String consistencyLevel;
+    private ConsistencyLevel consistencyLevel;
+    private Where where;
     private List<String> returnProperties = new ArrayList<>();
     private List<QueryReference> returnReferences = new ArrayList<>();
     private List<Metadata> returnMetadata = new ArrayList<>();
@@ -63,6 +67,16 @@ public final SELF after(String after) {
       return (SELF) this;
     }
 
+    public final SELF consistencyLevel(ConsistencyLevel consistencyLevel) {
+      this.consistencyLevel = consistencyLevel;
+      return (SELF) this;
+    }
+
+    public final SELF where(Where where) {
+      this.where = where;
+      return (SELF) this;
+    }
+
     public final SELF returnProperties(String... properties) {
       this.returnProperties = Arrays.asList(properties);
       return (SELF) this;
@@ -106,20 +120,30 @@ final void appendTo(WeaviateProtoSearchGet.SearchRequest.Builder req) {
       req.setAutocut(autocut);
     }
 
-    if (StringUtils.isNotBlank(consistencyLevel)) {
-      req.setConsistencyLevelValue(Integer.valueOf(consistencyLevel));
+    if (consistencyLevel != null) {
+      consistencyLevel.appendTo(req);
+    }
+
+    if (where != null) {
+      var filter = WeaviateProtoBase.Filters.newBuilder();
+      where.appendTo(filter);
+      req.setFilters(filter);
     }
 
-    if (!returnMetadata.isEmpty()) {
-      var metadata = WeaviateProtoSearchGet.MetadataRequest.newBuilder();
+    var metadata = WeaviateProtoSearchGet.MetadataRequest.newBuilder();
+    if (returnMetadata.isEmpty()) {
+      Metadata.ID.appendTo(metadata);
+    } else {
       returnMetadata.forEach(m -> m.appendTo(metadata));
-      req.setMetadata(metadata);
     }
+    req.setMetadata(metadata);
 
     if (!returnProperties.isEmpty() || !returnReferences.isEmpty()) {
       var properties = WeaviateProtoSearchGet.PropertiesRequest.newBuilder();
 
-      if (!returnProperties.isEmpty()) {
+      if (returnProperties.isEmpty()) {
+        properties.setReturnAllNonrefProperties(true);
+      } else {
         properties.addAllNonRefProperties(returnProperties);
       }
 

src/main/java/io/weaviate/client6/v1/api/collections/query/ById.java

@@ -1,19 +1,19 @@
 package io.weaviate.client6.v1.api.collections.query;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 import java.util.function.Function;
 
 import io.weaviate.client6.v1.internal.ObjectBuilder;
 import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase;
-import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.Operator;
 import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet;
 
 public record ById(
     String uuid,
-    boolean includeVector,
-    List<String> includeVectors,
-    BaseQueryOptions common) implements SearchOperator {
+    List<String> returnProperties,
+    List<QueryReference> returnReferences,
+    List<Metadata> returnMetadata) implements SearchOperator {
 
   private static final String ID_PROPERTY = "_id";
 
@@ -26,49 +26,77 @@ public static ById of(String uuid, Function<Builder, ObjectBuilder<ById>> fn) {
   }
 
   public ById(Builder builder) {
-    this(builder.uuid, builder.includeVector, builder.includeVectors, builder.baseOptions());
+    this(builder.uuid,
+        builder.returnProperties,
+        builder.returnReferences,
+        builder.returnMetadata);
   }
 
-  public static class Builder extends BaseQueryOptions.Builder<Builder, ById> {
+  public static class Builder implements ObjectBuilder<ById> {
     // Required query parameters.
     private final String uuid;
 
-    private boolean includeVector = false;
-    private List<String> includeVectors = new ArrayList<>();
+    private List<String> returnProperties = new ArrayList<>();
+    private List<QueryReference> returnReferences = new ArrayList<>();
+    private List<Metadata> returnMetadata = new ArrayList<>();
 
     public Builder(String uuid) {
       this.uuid = uuid;
     }
 
-    public final Builder includeVector(boolean include) {
-      this.includeVector = include;
+    public final Builder returnProperties(String... properties) {
+      this.returnProperties = Arrays.asList(properties);
+      return this;
+    }
+
+    public final Builder returnReferences(QueryReference... references) {
+      this.returnReferences = Arrays.asList(references);
+      return this;
+    }
+
+    public final Builder returnMetadata(Metadata... metadata) {
+      this.returnMetadata = Arrays.asList(metadata);
       return this;
     }
 
     @Override
-    public final ById build() {
+    public ById build() {
       return new ById(this);
     }
   }
 
   @Override
   public void appendTo(WeaviateProtoSearchGet.SearchRequest.Builder req) {
-    common.appendTo(req);
-
-    // Always request UUID back in this request.
-    var metadata = WeaviateProtoSearchGet.MetadataRequest.newBuilder()
-        .setUuid(true);
-    if (includeVector) {
-      metadata.setVector(true);
-    } else if (!includeVectors.isEmpty()) {
-      metadata.addAllVectors(includeVectors);
+    var where = Where.property(ID_PROPERTY).eq(uuid);
+    var filter = WeaviateProtoBase.Filters.newBuilder();
+    where.appendTo(filter);
+    req.setFilters(filter);
+
+    var metadata = WeaviateProtoSearchGet.MetadataRequest.newBuilder();
+    if (returnMetadata.isEmpty()) {
+      Metadata.ID.appendTo(metadata);
+    } else {
+      returnMetadata.forEach(m -> m.appendTo(metadata));
     }
     req.setMetadata(metadata);
 
-    req.setFilters(WeaviateProtoBase.Filters.newBuilder()
-        .setTarget(WeaviateProtoBase.FilterTarget.newBuilder()
-            .setProperty(ID_PROPERTY))
-        .setValueText(uuid)
-        .setOperator(Operator.OPERATOR_EQUAL));
+    if (!returnProperties.isEmpty() || !returnReferences.isEmpty()) {
+      var properties = WeaviateProtoSearchGet.PropertiesRequest.newBuilder();
+
+      if (returnProperties.isEmpty()) {
+        properties.setReturnAllNonrefProperties(true);
+      } else {
+        properties.addAllNonRefProperties(returnProperties);
+      }
+
+      if (!returnReferences.isEmpty()) {
+        returnReferences.forEach(r -> {
+          var ref = WeaviateProtoSearchGet.RefPropertiesRequest.newBuilder();
+          r.appendTo(ref);
+          properties.addRefProperties(ref);
+        });
+      }
+      req.setProperties(properties);
+    }
   }
 }

src/main/java/io/weaviate/client6/v1/api/collections/query/ConsistencyLevel.java

@@ -0,0 +1,20 @@
+package io.weaviate.client6.v1.api.collections.query;
+
+import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase;
+import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet;
+
+public enum ConsistencyLevel {
+  ONE(WeaviateProtoBase.ConsistencyLevel.CONSISTENCY_LEVEL_ONE),
+  QUORUM(WeaviateProtoBase.ConsistencyLevel.CONSISTENCY_LEVEL_ONE),
+  ALL(WeaviateProtoBase.ConsistencyLevel.CONSISTENCY_LEVEL_ONE);
+
+  private final WeaviateProtoBase.ConsistencyLevel consistencyLevel;
+
+  ConsistencyLevel(WeaviateProtoBase.ConsistencyLevel consistencyLevel) {
+    this.consistencyLevel = consistencyLevel;
+  }
+
+  final void appendTo(WeaviateProtoSearchGet.SearchRequest.Builder req) {
+    req.setConsistencyLevel(consistencyLevel);
+  }
+}