Polishing.

Reformat code. Rename conflicts method to overrides to indicate actual semantics and use type hierarchy for checks. Replace spaces with tab indents.
Extend test.

See #1525
Original pull request: #1596

Author: mp911de

spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/query/Update.java

@@ -27,13 +27,14 @@
 import org.springframework.data.cassandra.core.query.Update.AddToOp.Mode;
 import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
+import org.springframework.util.ObjectUtils;
 import org.springframework.util.StringUtils;
 
 import com.datastax.oss.driver.api.core.CqlIdentifier;
 
 /**
- * Update object representing a set of update operations. {@link Update} objects can be created in a fluent
- * style. Each construction operation creates a new immutable {@link Update} object.
+ * Update object representing a set of update operations. {@link Update} objects can be created in a fluent style. Each
+ * construction operation creates a new immutable {@link Update} object.
  *
  * <pre class="code">
  * Update update = Update.empty().set("foo", "bar").addTo("baz").prependAll(listOfValues);
@@ -68,7 +69,7 @@ public static Update of(Iterable<AssignmentOp> assignmentOps) {
 
 		Assert.notNull(assignmentOps, "Update operations must not be null");
 
-		List<AssignmentOp> updateOperations = new ArrayList<>();
+		List<AssignmentOp> updateOperations = new ArrayList<>(assignmentOps instanceof Collection<?> c ? c.size() : 16);
 
 		assignmentOps.forEach(updateOperations::add);
 
@@ -220,50 +221,24 @@ public Collection<AssignmentOp> getUpdateOperations() {
 
 	private Update add(AssignmentOp assignmentOp) {
 
-        List<AssignmentOp> list = new ArrayList<>(this.updateOperations.size() + 1);
+		List<AssignmentOp> list = new ArrayList<>(this.updateOperations.size() + 1);
 
-        for (AssignmentOp existing : this.updateOperations) {
-            if (!conflicts(existing, assignmentOp)) {
-                list.add(existing);
-            }
-        }
-
-        list.add(assignmentOp);
-
-        return new Update(list);
-    }
-
-    /**
-     * Determine whether two assignment operations conflict and should not co-exist in a single {@link Update}.
-     * Conflicts are defined as whole-column operations on the same column or element-level operations targeting
-     * the same element (same map key or same list index) on the same column. In case of conflict, last-wins semantics
-     * apply and the incoming operation replaces the existing one.
-     */
-	private static boolean conflicts(AssignmentOp existing, AssignmentOp incoming) {
-
-		if (!existing.getColumnName().equals(incoming.getColumnName())) {
-			return false;
-		}
-
-		if (existing instanceof SetAtKeyOp e && incoming instanceof SetAtKeyOp i) {
-			return equalsNullSafe(e.getKey(), i.getKey());
+		for (AssignmentOp existing : this.updateOperations) {
+			if (!assignmentOp.overrides(existing)) {
+				list.add(existing);
+			}
 		}
 
-		if (existing instanceof SetAtIndexOp e && incoming instanceof SetAtIndexOp i) {
-			return e.getIndex() == i.getIndex();
-		}
+		list.add(assignmentOp);
 
-		return true;
+		return new Update(list);
 	}
 
-	private static boolean equalsNullSafe(@Nullable Object a, @Nullable Object b) {
-		return a == b || (a != null && a.equals(b));
-	}
 
 	@Override
-    public String toString() {
-        return StringUtils.collectionToDelimitedString(updateOperations, ", ");
-    }
+	public String toString() {
+		return StringUtils.collectionToDelimitedString(updateOperations, ", ");
+	}
 
 	/**
 	 * Builder to add a single element/multiple elements to a collection associated with a {@link ColumnName}.
@@ -574,6 +549,15 @@ public ColumnName getColumnName() {
 		public CqlIdentifier toCqlIdentifier() {
 			return this.columnName.getCqlIdentifier().orElseGet(() -> CqlIdentifier.fromCql(this.columnName.toCql()));
 		}
+
+		/**
+		 * Determine whether the {@code other} assignment overrides this assignment.
+		 *
+		 * @since 4.5.3
+		 */
+		boolean overrides(AssignmentOp other) {
+			return ObjectUtils.nullSafeEquals(this.columnName, other.columnName);
+		}
 	}
 
 	/**
@@ -680,6 +664,20 @@ public int getIndex() {
 			return index;
 		}
 
+		@Override
+		boolean overrides(AssignmentOp other) {
+
+			if (super.overrides(other)) {
+				if (other instanceof SetAtIndexOp i) {
+					return getIndex() == i.getIndex();
+				} else {
+					return true;
+				}
+			}
+
+			return false;
+		}
+
 		@Override
 		public String toString() {
 			return String.format("%s[%d] = %s", getColumnName(), index, serializeToCqlSafely(getValue()));
@@ -713,6 +711,20 @@ public Object getValue() {
 			return value;
 		}
 
+		@Override
+		boolean overrides(AssignmentOp other) {
+
+			if (super.overrides(other)) {
+				if (other instanceof SetAtKeyOp i) {
+					return ObjectUtils.nullSafeEquals(getKey(), i.getKey());
+				} else {
+					return true;
+				}
+			}
+
+			return false;
+		}
+
 		@Override
 		public String toString() {
 			return String.format("%s[%s] = %s", getColumnName(), serializeToCqlSafely(key), serializeToCqlSafely(getValue()));
@@ -762,6 +774,11 @@ public Object getValue() {
 			return value;
 		}
 
+		@Override
+		boolean overrides(AssignmentOp other) {
+			return false;
+		}
+
 		@Override
 		public String toString() {
 			return String.format("%s = %s - %s", getColumnName(), getColumnName(), serializeToCqlSafely(getValue()));

spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/CassandraTemplateIntegrationTests.java

@@ -783,7 +783,7 @@ void shouldSaveAndReadNullEmbeddedUDTCorrectly() {
 		assertThat(target).isEqualTo(entity);
 	}
 
-	@Test // DATACASS-829
+	@Test // DATACASS-829, GH-1525
 	void shouldPartiallyUpdateListOfMappedUdt() {
 
 		WithMappedUdtList entity = new WithMappedUdtList();
@@ -792,12 +792,14 @@ void shouldPartiallyUpdateListOfMappedUdt() {
 
 		template.insert(entity);
 
-		Update update = Update.empty().set("mappedUdts").atIndex(1).to(new MappedUdt("replacement"));
+		Update update = Update.empty().set("mappedUdts").atIndex(1).to(new MappedUdt("replacement")).set("mappedUdts")
+				.atIndex(2).to(new MappedUdt("replacement2"));
 
 		template.update(Query.query(where("id").is("id-1")), update, WithMappedUdtList.class);
 
 		WithMappedUdtList updated = template.selectOne(Query.query(where("id").is("id-1")), WithMappedUdtList.class);
-		assertThat(updated.getMappedUdts()).extracting(MappedUdt::name).containsExactly("one", "replacement", "three");
+		assertThat(updated.getMappedUdts()).extracting(MappedUdt::name).containsExactly("one", "replacement",
+				"replacement2");
 	}
 
 	@UserDefinedType

spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/query/UpdateUnitTests.java

@@ -92,6 +92,15 @@ void shouldRemoveFromList() {
 		assertThat(update).hasToString("foo = foo - ['bar']");
 	}
 
+	@Test // DATACASS-343
+	void multipleRemovalsAreRetained() {
+
+		Update update = Update.empty().remove("foo", "bar").remove("foo", "baz");
+
+		assertThat(update.getUpdateOperations()).hasSize(2);
+		assertThat(update).hasToString("foo = foo - ['bar'], foo = foo - ['baz']");
+	}
+
 	@Test // DATACASS-343
 	void shouldClearCollection() {
 
@@ -185,10 +194,11 @@ void shouldAllowMultipleSetAtIndexOperationsOnSameColumn() {
 	@Test // GH-1525
 	void shouldUseLastWinsForDuplicateSetAtIndexOnSameIndex() {
 
-		Update update = Update.empty().set("foo").atIndex(1).to("A").set("foo").atIndex(1).to("B");
+		Update update = Update.empty().set("foo").atIndex(1).to("A").set("bar").atIndex(1).to("B").set("foo").atIndex(1)
+				.to("B");
 
-		assertThat(update.getUpdateOperations()).hasSize(1);
-		assertThat(update).hasToString("foo[1] = 'B'");
+		assertThat(update.getUpdateOperations()).hasSize(2);
+		assertThat(update).hasToString("bar[1] = 'B', foo[1] = 'B'");
 	}
 
 	@Test // GH-1525