DATACASS-594 Polishing

Author: mipo256

spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/cql/CassandraAccessor.java

@@ -85,7 +85,7 @@ public class CassandraAccessor implements InitializingBean {
 	 */
 	private @Nullable ConsistencyLevel serialConsistencyLevel;
 
-	private @Nullable SessionFactory sessionFactory;
+	private SessionFactory sessionFactory;
 
 	/**
 	 * Ensures the Cassandra {@link CqlSession} and exception translator has been propertly set.
@@ -314,7 +314,6 @@ public void setSessionFactory(SessionFactory sessionFactory) {
 	 * @since 2.0
 	 * @see SessionFactory
 	 */
-	@Nullable
 	public SessionFactory getSessionFactory() {
 		return this.sessionFactory;
 	}
@@ -361,11 +360,10 @@ protected Statement<?> applyStatementSettings(Statement<?> statement) {
 		}
 
 		if (keyspace != null) {
-			if (statementToUse instanceof BatchStatement) {
-				statementToUse = ((BatchStatement) statementToUse).setKeyspace(keyspace);
-			}
-			if (statementToUse instanceof SimpleStatement) {
-				statementToUse = ((SimpleStatement) statementToUse).setKeyspace(keyspace);
+			if (statementToUse instanceof BatchStatement bs) {
+				statementToUse = bs.setKeyspace(keyspace);
+			} else if (statementToUse instanceof SimpleStatement ss) {
+				statementToUse = ss.setKeyspace(keyspace);
 			}
 		}
 

spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/cql/CqlTemplate.java

@@ -620,7 +620,7 @@ private CqlSession getCurrentSession() {
 
 		SessionFactory sessionFactory = getSessionFactory();
 
-		Assert.state(sessionFactory != null, "SessionFactory is null");
+		Assert.notNull(sessionFactory, "SessionFactory is null");
 
 		return sessionFactory.getSession();
 	}

spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/cql/util/AbstractCollectionTerm.java

@@ -0,0 +1,62 @@
+package org.springframework.data.cassandra.core.cql.util;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Optional;
+
+import org.jetbrains.annotations.NotNull;
+import org.springframework.lang.NonNull;
+
+import com.datastax.oss.driver.api.querybuilder.term.Term;
+import com.datastax.oss.driver.internal.querybuilder.CqlHelper;
+
+/**
+ * Represents an abstract collection like {@link Term} such as Set, List, Tuple in CQL
+ *
+ * @author Mikhail Polivakha
+ */
+public abstract class AbstractCollectionTerm implements Term {
+
+    @NonNull
+    private final Collection<? extends Term> components;
+
+    /**
+     * @return EnclosingLiterals that are used to render the collection of terms
+     */
+    public abstract EnclosingLiterals enclosingLiterals();
+
+    public AbstractCollectionTerm(Collection<? extends Term> components) {
+        this.components = Optional.ofNullable(components).orElse(Collections.emptySet());
+    }
+
+    @Override
+    public boolean isIdempotent() {
+        return components.stream().allMatch(Term::isIdempotent);
+    }
+
+    @Override
+    public void appendTo(@NotNull StringBuilder builder) {
+        EnclosingLiterals literals = this.enclosingLiterals();
+
+        if (components.isEmpty()) {
+            builder.append(literals.prefix).append(literals.postfix);
+        } else {
+            CqlHelper.append(components, builder, literals.prefix, ",", literals.postfix);
+        }
+    }
+
+    protected static class EnclosingLiterals {
+
+        private final String prefix;
+        private final String postfix;
+
+        protected EnclosingLiterals(String prefix, String postfix) {
+            this.prefix = prefix;
+            this.postfix = postfix;
+        }
+
+        protected static EnclosingLiterals of(String prefix, String postfix) {
+            return new EnclosingLiterals(prefix, postfix);
+        }
+    }
+}

spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/cql/util/ListTerm.java

@@ -0,0 +1,17 @@
+package org.springframework.data.cassandra.core.cql.util;
+
+import java.util.Collection;
+
+import com.datastax.oss.driver.api.querybuilder.term.Term;
+
+public class ListTerm extends AbstractCollectionTerm {
+
+    public ListTerm(Collection<? extends Term> components) {
+        super(components);
+    }
+
+    @Override
+    public EnclosingLiterals enclosingLiterals() {
+        return EnclosingLiterals.of("[", "]");
+    }
+}

spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/cql/util/SetTerm.java

@@ -0,0 +1,17 @@
+package org.springframework.data.cassandra.core.cql.util;
+
+import java.util.Collection;
+
+import com.datastax.oss.driver.api.querybuilder.term.Term;
+
+public class SetTerm extends AbstractCollectionTerm {
+
+    public SetTerm(Collection<? extends Term> components) {
+        super(components);
+    }
+
+    @Override
+    public EnclosingLiterals enclosingLiterals() {
+        return EnclosingLiterals.of("{", "}");
+    }
+}

spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/cql/util/StatementBuilder.java

@@ -25,6 +25,7 @@
 import java.util.function.Function;
 import java.util.function.Supplier;
 import java.util.function.UnaryOperator;
+import java.util.stream.Collectors;
 
 import org.springframework.lang.NonNull;
 import org.springframework.lang.Nullable;
@@ -42,7 +43,7 @@
 /**
  * Functional builder for Cassandra {@link BuildableQuery statements}. Statements are built by applying
  * {@link UnaryOperator builder functions} that get applied when {@link #build() building} the actual
- * {@link SimpleStatement statement}. The {@code StatementBuilder} provides a mutable container for statement creation
+ * {@link SimpleStatement statement}. The {@link StatementBuilder} provides a mutable container for statement creation
  * allowing a functional declaration of actions that are necessary to build a statement. This class helps building CQL
  * statements as a {@link BuildableQuery} classes are typically immutable and require return value tracking across
  * methods that want to apply modifications to a statement.
@@ -289,13 +290,13 @@ public <T> T ifBoundOrInline(Function<Bindings, T> bindingFunction, Supplier<T>
 
 	private SimpleStatement build(SimpleStatementBuilder builder) {
 
-		SimpleStatement statmentToUse = onBuild(builder).build();
+		SimpleStatement statementToUse = onBuild(builder).build();
 
 		for (UnaryOperator<SimpleStatement> operator : onBuilt) {
-			statmentToUse = operator.apply(statmentToUse);
+			statementToUse = operator.apply(statementToUse);
 		}
 
-		return statmentToUse;
+		return statementToUse;
 	}
 
 	private SimpleStatementBuilder onBuild(SimpleStatementBuilder statementBuilder) {
@@ -308,26 +309,13 @@ private SimpleStatementBuilder onBuild(SimpleStatementBuilder statementBuilder)
 	@SuppressWarnings("unchecked")
 	private static Term toLiteralTerms(@Nullable Object value, CodecRegistry codecRegistry) {
 
-		if (value instanceof List) {
+		if (value instanceof Collection<?> c) {
 
-			List<Term> terms = new ArrayList<>();
+			List<Term> mappedTerms = c.stream()
+			.map(o -> toLiteralTerms(o, codecRegistry))
+			.toList();
 
-			for (Object o : (List<Object>) value) {
-				terms.add(toLiteralTerms(o, codecRegistry));
-			}
-
-			return new ListTerm(terms);
-		}
-
-		if (value instanceof Set) {
-
-			List<Term> terms = new ArrayList<>();
-
-			for (Object o : (Set<Object>) value) {
-				terms.add(toLiteralTerms(o, codecRegistry));
-			}
-
-			return new SetTerm(terms);
+			return c instanceof Set ? new SetTerm(mappedTerms) : new ListTerm(mappedTerms);
 		}
 
 		if (value instanceof Map) {
@@ -387,66 +375,6 @@ public enum ParameterHandling {
 		BY_NAME
 	}
 
-	static class ListTerm implements Term {
-
-		private final Collection<? extends Term> components;
-
-		public ListTerm(@NonNull Collection<? extends Term> components) {
-			this.components = components;
-		}
-
-		@Override
-		public void appendTo(@NonNull StringBuilder builder) {
-
-			if (components.isEmpty()) {
-				builder.append("[]");
-				return;
-			}
-
-			CqlHelper.append(components, builder, "[", ",", "]");
-		}
-
-		@Override
-		public boolean isIdempotent() {
-			for (Term component : components) {
-				if (!component.isIdempotent()) {
-					return false;
-				}
-			}
-			return true;
-		}
-	}
-
-	static class SetTerm implements Term {
-
-		private final Collection<? extends Term> components;
-
-		public SetTerm(@NonNull Collection<? extends Term> components) {
-			this.components = components;
-		}
-
-		@Override
-		public void appendTo(@NonNull StringBuilder builder) {
-
-			if (components.isEmpty()) {
-				builder.append("{}");
-				return;
-			}
-
-			CqlHelper.append(components, builder, "{", ",", "}");
-		}
-
-		@Override
-		public boolean isIdempotent() {
-			for (Term component : components) {
-				if (!component.isIdempotent()) {
-					return false;
-				}
-			}
-			return true;
-		}
-	}
-
 	static class MapTerm implements Term {
 
 		private final Map<? extends Term, ? extends Term> components;

spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/cql/util/TermFactory.java

@@ -20,11 +20,12 @@
 
 import org.springframework.lang.Nullable;
 
+import com.datastax.oss.driver.api.querybuilder.BindMarker;
 import com.datastax.oss.driver.api.querybuilder.term.Term;
 
 /**
  * Factory for {@link Term} objects encapsulating a binding {@code value}. Classes implementing this factory interface
- * may return inline terms to render values as part of the query string, or bind markers to supply parameters on
+ * may return inline {@link Term terms} to render values as part of the query string, or {@link BindMarker bind markers} to supply parameters on
  * statement creation/parameter binding.
  * <p>
  * A {@link TermFactory} is typically used with {@link StatementBuilder}.