Merge branch 'v6' into v6-weaviate-object

Author: bevzzz

src/it/java/io/weaviate/containers/Weaviate.java

@@ -197,6 +197,11 @@ public Builder withApiKeys(String... apiKeys) {
       return this;
     }
 
+    public Builder withGrpcMaxMessageSize(int bytes) {
+      environment.put("GRPC_MAX_MESSAGE_SIZE", String.valueOf(bytes));
+      return this;
+    }
+
     public Builder enableTelemetry(boolean enable) {
       environment.put("DISABLE_TELEMETRY", Boolean.toString(!enable));
       return this;

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

@@ -48,9 +48,12 @@ public void test_aliasLifecycle() throws IOException {
         .returns(nsColsonBaker, Alias::collection);
 
     // Act: delete Bono alias
-    client.alias.delete("Bono");
+    var deleted = client.alias.delete("Bono");
+    Assertions.assertThat(deleted).as("object was deleted").isTrue();
 
-    // Assert
+    // Act: delete non-existent alias
+    deleted = client.alias.delete("Bono");
+    Assertions.assertThat(deleted).as("object wasn't deleted").isFalse();
     var paulHewsonAliases = client.alias.list(all -> all.collection(nsPaulHewson));
     Assertions.assertThat(paulHewsonAliases)
         .as("no aliases once Bono is deleted")

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

@@ -79,9 +79,16 @@ public void testCreateGetDelete() throws IOException {
               .as("lastUpdateTimeUnix").isNotNull();
         });
 
-    artists.data.delete(id);
+    var deleted = artists.data.deleteById(id);
+    Assertions.assertThat(deleted)
+        .as("object was deleted").isTrue();
     Assertions.assertThat(artists.data.exists(id))
         .as("object not exists after deletion").isFalse();
+
+    deleted = artists.data.deleteById(id);
+    // TODO: Change to isFalse() after fixed in Weaviate server
+    Assertions.assertThat(deleted)
+        .as("object wasn't deleted").isTrue();
   }
 
   @Test

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

@@ -206,30 +206,54 @@ public void test_users_db() throws IOException {
         .extracting(Role::name)
         .doesNotContain(roleName);
 
-    client.users.db.activate(userId);
+    var deactivated = client.users.db.deactivate(userId);
+    Assertions.assertThat(deactivated)
+        .as("user was deactivated")
+        .isTrue();
+    Assertions.assertThat(client.users.db.byName(userId)).get()
+        .as("user is deactivated")
+        .returns(false, DbUser::active);
+
+    deactivated = client.users.db.deactivate(userId);
+    Assertions.assertThat(deactivated)
+        .as("user was already deactivated")
+        .isFalse();
+
+    var activated = client.users.db.activate(userId);
+    Assertions.assertThat(activated)
+        .as("user was activated")
+        .isTrue();
     Assertions.assertThat(client.users.db.byName(userId)).get()
         .as("user is activated")
         .returns(true, DbUser::active);
 
+    activated = client.users.db.activate(userId);
+    Assertions.assertThat(activated)
+        .as("user was already active")
+        .isFalse();
+
     apiKey = client.users.db.rotateKey(userId);
     assertValidApiKey(apiKey);
 
-    client.users.db.deactivate(userId);
-    Assertions.assertThat(client.users.db.byName(userId)).get()
-        .as("user is deactivated")
-        .returns(false, DbUser::active);
-
     var all = client.users.db.list(users -> users.includeLastUsedAt(true));
     Assertions.assertThat(all)
         .as("list users include lastUsedTime ")
         .allMatch(user -> user.lastUsedAt() != null)
         .extracting(DbUser::id)
         .contains(userId, ADMIN_USER);
 
-    client.users.db.delete(userId);
+    var deleted = client.users.db.delete(userId);
+    Assertions.assertThat(deleted)
+        .as("user was deleted")
+        .isTrue();
     Assertions.assertThat(client.users.db.byName(userId))
         .as("user is deleted")
         .isEmpty();
+
+    deleted = client.users.db.delete(userId);
+    Assertions.assertThat(deleted)
+        .as("user was already deleted")
+        .isFalse();
   }
 
   @Test

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

@@ -1,6 +1,7 @@
 package io.weaviate.integration;
 
 import java.io.IOException;
+import java.time.OffsetDateTime;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;
@@ -13,6 +14,7 @@
 import org.assertj.core.api.InstanceOfAssertFactories;
 import org.junit.BeforeClass;
 import org.junit.ClassRule;
+import org.junit.Ignore;
 import org.junit.Test;
 import org.junit.rules.TestRule;
 
@@ -29,14 +31,14 @@
 import io.weaviate.client6.v1.api.collections.generate.GenerativeObject;
 import io.weaviate.client6.v1.api.collections.generate.TaskOutput;
 import io.weaviate.client6.v1.api.collections.generative.DummyGenerative;
+import io.weaviate.client6.v1.api.collections.query.Filter;
 import io.weaviate.client6.v1.api.collections.query.GroupBy;
 import io.weaviate.client6.v1.api.collections.query.Metadata;
 import io.weaviate.client6.v1.api.collections.query.QueryMetadata;
 import io.weaviate.client6.v1.api.collections.query.QueryResponseGroup;
 import io.weaviate.client6.v1.api.collections.query.ReadWeaviateObject;
 import io.weaviate.client6.v1.api.collections.query.SortBy;
 import io.weaviate.client6.v1.api.collections.query.Target;
-import io.weaviate.client6.v1.api.collections.query.Filter;
 import io.weaviate.client6.v1.api.collections.vectorindex.Hnsw;
 import io.weaviate.client6.v1.api.collections.vectorindex.MultiVector;
 import io.weaviate.containers.Container;
@@ -671,4 +673,97 @@ public void testGenerative_bm25_groupBy() throws IOException {
         .extracting(TaskOutput::text, InstanceOfAssertFactories.STRING)
         .isNotBlank();
   }
+
+  @Test
+  public void test_filterIsNull() throws IOException {
+    // Arrange
+    var nsNulls = ns("Nulls");
+
+    var nulls = client.collections.create(nsNulls,
+        c -> c
+            .invertedIndex(idx -> idx.indexNulls(true))
+            .properties(Property.text("never")));
+
+    var inserted = nulls.data.insertMany(Map.of(), Map.of("never", "notNull"));
+    Assertions.assertThat(inserted.errors()).isEmpty();
+
+    // Act
+    var isNull = nulls.query.fetchObjects(q -> q.filters(Filter.property("never").isNull()));
+    var isNotNull = nulls.query.fetchObjects(q -> q.filters(Filter.property("never").isNotNull()));
+
+    // Assert
+    var isNull_1 = Assertions.assertThat(isNull.objects())
+        .as("objects WHERE never IS NULL")
+        .hasSize(1).first().actual();
+    var isNotNull_1 = Assertions.assertThat(isNotNull.objects())
+        .as("objects WHERE never IS NOT NULL")
+        .hasSize(1).first().actual();
+    Assertions.assertThat(isNull_1).isNotEqualTo(isNotNull_1);
+  }
+
+  @Test
+  public void test_filterCreateUpdateTime() throws IOException {
+    // Arrange
+    var now = OffsetDateTime.now().minusHours(1);
+    var nsCounter = ns("Counter");
+
+    var counter = client.collections.create(nsCounter,
+        c -> c
+            .invertedIndex(idx -> idx.indexTimestamps(true))
+            .properties(Property.integer("count")));
+
+    counter.data.insert(Map.of("count", 0));
+
+    // Act
+    var beforeNow = counter.query.fetchObjects(q -> q.filters(Filter.createdAt().lt(now)));
+    var afterNow = counter.query.fetchObjects(q -> q.filters(Filter.createdAt().gt(now)));
+
+    // Assert
+    Assertions.assertThat(beforeNow.objects()).isEmpty();
+    Assertions.assertThat(afterNow.objects()).hasSize(1);
+  }
+
+  @Test
+  public void teset_filterPropertyLength() throws IOException {
+    // Arrange
+    var nsStrings = ns("Strings");
+
+    var strings = client.collections.create(nsStrings, c -> c
+        .invertedIndex(idx -> idx.indexPropertyLength(true))
+        .properties(Property.text("letters")));
+    strings.data.insertMany(Map.of("letters", "abc"), Map.of("letters", "abcd"), Map.of("letters", "a"));
+
+    // Act
+    var got = strings.query.fetchObjects(q -> q.filters(Filter.propertyLen("letters").gte(3)));
+
+    // Assertions
+    Assertions.assertThat(got.objects()).hasSize(2);
+  }
+  
+  /**
+   * Ensure the client respects server's configuration for max gRPC size:
+   * we create a server with 1-byte message size and try to send a large payload
+   * there. If the channel is configured correctly, it will refuse to send it.
+   */
+  @Test
+  @Ignore("Exception thrown by gRPC transport causes a deadlock")
+  public void test_maxGrpcMessageSize() throws Exception {
+    var w = Weaviate.custom().withGrpcMaxMessageSize(1).build();
+    var nsHugeVectors = ns("HugeVectors");
+
+    try (final var _client = w.getClient()) {
+      var huge = _client.collections.create(nsHugeVectors, c -> c
+          .vectorConfig(VectorConfig.selfProvided()));
+
+      final var vector = randomVector(5000, -.01f, .01f);
+      final WeaviateObject<Map<String, Object>, Reference, ObjectMetadata> hugeObject = WeaviateObject.of(obj -> obj
+          .metadata(ObjectMetadata.of(m -> m
+              .vectors(Vectors.of(vector)))));
+
+      Assertions.assertThatThrownBy(() -> {
+        // insertMany to route this request through gRPC.
+        huge.data.insertMany(hugeObject);
+      }).isInstanceOf(io.grpc.StatusRuntimeException.class);
+    }
+  }
 }

src/main/java/io/weaviate/client6/v1/api/alias/DeleteAliasRequest.java

@@ -2,11 +2,11 @@
 
 import java.util.Collections;
 
+import io.weaviate.client6.v1.internal.rest.BooleanEndpoint;
 import io.weaviate.client6.v1.internal.rest.Endpoint;
-import io.weaviate.client6.v1.internal.rest.SimpleEndpoint;
 
 public record DeleteAliasRequest(String alias) {
-  public final static Endpoint<DeleteAliasRequest, Void> _ENDPOINT = SimpleEndpoint.sideEffect(
+  public final static Endpoint<DeleteAliasRequest, Boolean> _ENDPOINT = BooleanEndpoint.noBody(
       __ -> "DELETE",
       request -> "/aliases/" + request.alias,
       __ -> Collections.emptyMap());

src/main/java/io/weaviate/client6/v1/api/alias/WeaviateAliasClient.java

@@ -117,8 +117,11 @@ public void update(String alias, String newTargetCollection) throws IOException
    * @throws IOException          in case the request was not sent successfully
    *                              due to a malformed request, a networking error
    *                              or the server being unavailable.
+   * 
+   * @return {@code true} if the alias was deleted, {@code false} if there was no
+   *         alias to delete.
    */
-  public void delete(String alias) throws IOException {
-    this.restTransport.performRequest(new DeleteAliasRequest(alias), DeleteAliasRequest._ENDPOINT);
+  public boolean delete(String alias) throws IOException {
+    return this.restTransport.performRequest(new DeleteAliasRequest(alias), DeleteAliasRequest._ENDPOINT);
   }
 }

src/main/java/io/weaviate/client6/v1/api/alias/WeaviateAliasClientAsync.java

@@ -94,7 +94,7 @@ public CompletableFuture<Void> update(String alias, String newTargetCollection)
    *
    * @return A future holding the server's response.
    */
-  public CompletableFuture<Void> delete(String alias) {
+  public CompletableFuture<Boolean> delete(String alias) {
     return this.restTransport.performRequestAsync(new DeleteAliasRequest(alias), DeleteAliasRequest._ENDPOINT);
   }
 }

src/main/java/io/weaviate/client6/v1/api/collections/data/DeleteObjectRequest.java

@@ -2,15 +2,15 @@
 
 import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults;
 import io.weaviate.client6.v1.internal.orm.CollectionDescriptor;
+import io.weaviate.client6.v1.internal.rest.BooleanEndpoint;
 import io.weaviate.client6.v1.internal.rest.Endpoint;
-import io.weaviate.client6.v1.internal.rest.SimpleEndpoint;
 
 public record DeleteObjectRequest(String uuid) {
 
-  public static final Endpoint<DeleteObjectRequest, Void> endpoint(
+  public static final Endpoint<DeleteObjectRequest, Boolean> endpoint(
       CollectionDescriptor<?> collection,
       CollectionHandleDefaults defaults) {
-    return SimpleEndpoint.sideEffect(
+    return BooleanEndpoint.noBody(
         request -> "DELETE",
         request -> "/objects/" + collection.collectionName() + "/" + request.uuid,
         request -> defaults.queryParameters());

src/main/java/io/weaviate/client6/v1/api/collections/data/WeaviateDataClient.java

@@ -98,8 +98,15 @@ public void replace(
         ReplaceObjectRequest.endpoint(collection, defaults));
   }
 
-  public void delete(String uuid) throws IOException {
-    this.restTransport.performRequest(new DeleteObjectRequest(uuid),
+  /**
+   * Delete an object by its UUID.
+   *
+   * @param uuid The UUID of the object to delete.
+   * @return {@code true} if the object was deleted, {@code false} if there was no object to delete.
+   * @throws IOException in case the request was not sent successfully.
+   */
+  public boolean deleteById(String uuid) throws IOException {
+    return this.restTransport.performRequest(new DeleteObjectRequest(uuid),
         DeleteObjectRequest.endpoint(collection, defaults));
   }