Replace a document after applying a non-vector sort

[clun]

The replaceOne operation seems not compatible with sort operations (vector, vectorize or field)

• https://docs.datastax.com/en/astra-db-serverless/api-reference/document-methods/replace-one.html#example-sort
• https://docs.datastax.com/en/astra-db-serverless/api-reference/document-methods/replace-one.html#example-vector
• https://docs.datastax.com/en/astra-db-serverless/api-reference/document-methods/replace-one.html#example-vectorize

[clun]

ReplaceOne - sort by field

void should_replaceOne_withSortByField() {
        collectionSimple.deleteAll();
        collectionSimple.insertMany(List.of(
                new Document().id(1).append("rank", 3).append("status", "active").append("value", "A"),
                new Document().id(2).append("rank", 1).append("status", "active").append("value", "B"),
                new Document().id(3).append("rank", 2).append("status", "active").append("value", "C")));

        // Replace the document with the lowest rank (ascending sort => rank=1, id=2)
        CollectionUpdateResult res = collectionSimple.replaceOne(
                Filters.eq("status", "active"),
                new Document().append("status", "replaced").append("value", "X"),
                new CollectionReplaceOneOptions().sort(Sort.ascending("rank")));
        assertThat(res.getMatchedCount()).isEqualTo(1);
        assertThat(res.getModifiedCount()).isEqualTo(1);
        assertThat(res.getDocument().get("value")).isEqualTo("X");

        // Verify document 2 was replaced (lowest rank)
        Optional<Document> doc2 = collectionSimple.findById(2);
        assertThat(doc2).isPresent();
        assertThat(doc2.get().getString("status")).isEqualTo("replaced");

        // Documents 1 and 3 should be untouched
        Optional<Document> doc1 = collectionSimple.findById(1);
        assertThat(doc1).isPresent();
        assertThat(doc1.get().getString("status")).isEqualTo("active");
    }

ReplaceOne - sort by vector

void should_replaceOne_withVectorSort() {

        collectionVector.deleteAll();
        collectionVector.insertMany(List.of(
                new Document().id("rp1").vector(VECTOR_BEEF)
                        .put("name", "Beef").put("version", 1),
                new Document().id("rp2").vector(VECTOR_FISH)
                        .put("name", "Fish").put("version", 1),
                new Document().id("rp3").vector(VECTOR_VEGAN)
                        .put("name", "Vegan").put("version", 1)));

        // Replace the document most similar to VECTOR_FISH
        CollectionUpdateResult res = collectionVector.replaceOne(
                null, // no filter
                new Document().id("rp2").vector(VECTOR_FISH)
                        .put("name", "Premium Fish").put("version", 2),
                new CollectionReplaceOneOptions()
                        .sort(Sort.vector(VECTOR_FISH)));
        assertThat(res.getMatchedCount()).isEqualTo(1);
        assertThat(res.getModifiedCount()).isEqualTo(1);

        // Verify rp2 was replaced (most similar to VECTOR_FISH)
        Optional<Document> doc = collectionVector.findById("rp2");
        assertThat(doc).isPresent();
        assertThat(doc.get().getString("name")).isEqualTo("Premium Fish");
        assertThat(doc.get().getInteger("version")).isEqualTo(2);
    }

ReplaceOne - sort by vectorize

void should_replaceOne_withVectorizeSort() {
        if (skipIfNoRerankingKey()) return;

        Collection<Document> col = getDatabase().getCollection(COLLECTION_FIND_RERANK);
        col.deleteAll();

        // Insert documents with vectorize content
        col.insertMany(List.of(
                new Document().id("rp1").put("quote", "The stars shine bright in the night sky").vectorize("The stars shine bright in the night sky"),
                new Document().id("rp2").put("quote", "Mathematics is the queen of sciences").vectorize("Mathematics is the queen of sciences"),
                new Document().id("rp3").put("quote", "Music soothes the soul").vectorize("Music soothes the soul")),
                new CollectionInsertManyOptions().chunkSize(3));

        // Replace the document most similar to a math query using vectorize sort
        CollectionUpdateResult res = col.replaceOne(
                null,
                new Document().id("rp2").put("quote", "Math is beautiful").vectorize("Math is beautiful"),
                new CollectionReplaceOneOptions().sort(Sort.vectorize("Mathematics and numbers")));
        assertThat(res.getMatchedCount()).isEqualTo(1);
        assertThat(res.getModifiedCount()).isEqualTo(1);

        // Verify the math document was replaced
        Optional<Document> doc = col.findById("rp2");
        assertThat(doc).isPresent();
        assertThat(doc.get().getString("quote")).isEqualTo("Math is beautiful");
    }