JSON Mapping to Query [DATACASS-36]

[spring-projects-issues]

David Webb opened DATACASS-36 and commented

Create overload convenience methods for Passing in JSON String.

This JSON String can be mapped to a Object<T> to generate the appropriate query operation

---

No further details from DATACASS-36

[patpatpat123]

Add JSON support to CassandraTemplate — resolves GH-212 (DATACASS-36)

PART 1 of 2 — report (sections 1–7) + main source files (8.1–8.7: StatementFactory,
sync/async/reactive interfaces and templates). Kotlin extensions, tests and documentation
(8.8–8.16) are in Part 2.

Issue: #212
Target version: 5.2 (main, 5.2.0-SNAPSHOT)
Change size: 16 files, +932 / −6 lines
Author's note: This document is self-contained. Section 8 contains the complete content of every changed file — copy each block over the file at the given path and your IDE's git diff will show exactly this change set.

---

1. The issue

GH-212 (originally JIRA DATACASS-36, filed 2013) asks:

Add convenience method overloads that accept Strings of JSON as the parameters, and map those to typed objects to generate the appropriate query operation.

The use case: an application already holds a JSON payload (e.g. from a REST request) and wants to persist or query it without materializing an entity object first.

2. Design decision — native CQL JSON, not client-side Jackson

Two implementation strategies were considered:

	A. Native INSERT JSON / SELECT JSON (chosen)	B. Client-side Jackson (JSON → entity → existing insert)
Mapping performed by	Cassandra server, per the CQL JSON spec	Jackson ObjectMapper in Spring
JSON keys map to	column names	entity property names
Cassandra type fidelity	Full — server parses every CQL type (UDT, tuple, duration, date, blob, vector…)	Broken for driver types (UdtValue, TupleValue, CqlDuration…) without custom Jackson modules
New dependency	none	Jackson (optional dep + "whose ObjectMapper?" configuration question)
Spring Data mapping metadata (@Column, naming strategy)	not applied to payload (only table/keyspace resolution)	applied
CQL emitted	INSERT INTO t JSON ? / SELECT JSON … FROM t	ordinary column-list statements

Rationale for A: it is the only approach that is correct for the entire Cassandra type system, adds zero dependencies, and directly maps onto a first-class CQL feature (available since Cassandra 2.2). The issue was filed in 2013 — before Cassandra 2.2 introduced native JSON — which is why it talks about client-side mapping to typed objects; the native feature supersedes that mechanism while fulfilling the same use case.

3. New API surface

Identical across the three programming models (@since 5.2):

CassandraOperations (sync)	AsyncCassandraOperations	ReactiveCassandraOperations
WriteResult insertJson(String json, Class<?> entityClass)	CompletableFuture<WriteResult> insertJson(…)	Mono<WriteResult> insertJson(…)
WriteResult insertJson(String json, Class<?> entityClass, InsertOptions options)	CompletableFuture<WriteResult> insertJson(…, InsertOptions)	Mono<WriteResult> insertJson(…, InsertOptions)
List<String> selectJson(Query query, Class<?> entityClass)	CompletableFuture<List<String>> selectJson(…)	Flux<String> selectJson(…)
@Nullable String selectOneJson(Query query, Class<?> entityClass)	CompletableFuture<@Nullable String> selectOneJson(…)	Mono<String> selectOneJson(…)

Supporting pieces:

• StatementFactory.insertJson(String, WriteOptions, CassandraPersistentEntity<?>, CqlIdentifier) → StatementBuilder<JsonInsert>
• StatementFactory.selectJson(Query, CassandraPersistentEntity<?>[, CqlIdentifier]) → StatementBuilder<Select>
• Kotlin reified extensions: template.insertJson<Person>(json), template.selectJson<Person>(query), template.selectOneJson<Person>(query)
• Reference documentation section "Working with JSON" in template.adoc

Statement rendering (asserted by the new unit tests)

insertJson(json, Person.class)                          INSERT INTO person JSON ? DEFAULT UNSET
  + InsertOptions.withInsertNulls()                     INSERT INTO person JSON ? DEFAULT NULL
  + InsertOptions.withIfNotExists()                     INSERT INTO person JSON ? DEFAULT UNSET IF NOT EXISTS
  + WriteOptions ttl(10) timestamp(1234)                INSERT INTO person JSON ? DEFAULT UNSET USING TIMESTAMP ? AND TTL ?
  + keyspace provider                                   INSERT INTO ks_person.person JSON ? DEFAULT UNSET

selectJson(Query.empty(), Group.class)                  SELECT JSON * FROM group
  + columns("age") + where("foo").is("bar")             SELECT JSON age FROM group WHERE foo=?
  + limit(10)                                           SELECT JSON * FROM group WHERE foo=? LIMIT ?

4. Decision points for the reviewer

These are the judgment calls embedded in this change — each is reversible independently:

1. Server-side vs client-side mapping (Section 2). Consequence to accept: JSON keys are column names, so @Column/naming-strategy renames do not apply to the payload. Documented in javadoc + reference docs.
2. Method naming insertJson/selectJson/selectOneJson instead of overloading insert(...)/select(...). Chosen because (a) <T> T insert(T entity) makes a String overload ambiguous and error-prone, (b) the semantics differ (no callbacks, column-name keys), (c) the names mirror the CQL keywords and are discoverable.
3. Always emit an explicit DEFAULT clause: DEFAULT UNSET by default, DEFAULT NULL when InsertOptions.isInsertNulls(). Raw CQL INSERT JSON defaults to DEFAULT NULL (omitted columns become tombstones), which contradicts template.insert(entity) semantics where null/absent properties are skipped unless withInsertNulls(). Aligning JSON inserts with entity-insert semantics was judged least surprising for Spring Data users. Cost: requires Cassandra 3.10+ (DEFAULT UNSET, CASSANDRA-11424); integration tests are version-gated accordingly. Alternative: omit the clause and inherit native DEFAULT NULL behavior — one-line change in StatementFactory.insertJson if preferred.
4. Return types: insertJson returns WriteResult (not T/EntityWriteResult — there is no entity instance); selectJson returns raw JSON String rows (single [json] column, mapped via SingleColumnRowMapper).
5. No lifecycle events / entity callbacks for JSON operations (BeforeSave, BeforeConvert, …) since no entity instance exists. Documented. Alternative: emit statement-based events like the delete path does — deliberately not done to avoid firing entity-typed listeners with String sources.
6. selectOneJson mirrors each template's existing selectOne(Query) behavior: sync/async take the first row of the result; reactive applies query.limit(1) — exactly like the pre-existing selectOne implementations in each class.
7. Prepared-statement friendliness: the JSON payload and TTL/timestamp flow through TermFactory bind markers, so the query text is stable (INSERT INTO t JSON ?) and does not pollute the prepared-statement cache. Inline rendering (used e.g. by CQL logging) still produces the literal form.
8. Scope: imperative/async/reactive template API only. Deliberately excluded, possible follow-ups: fluent API (template.insert(Person.class).json(...)), CassandraBatchOperations, repository @Query JSON projection.

5. Implementation notes

• StatementFactory.insertJson follows the exact pattern of the existing entity insert(...): StatementBuilder stub + bind function + CqlStatementOptionsAccessor + addInsertOptions (reusing TTL/timestamp/ifNotExists handling), then QueryOptionsUtil.addQueryOptions on build. The (JsonInsert) cast after addInsertOptions is safe: the driver's DefaultInsert implements InsertInto, RegularInsert, JsonInsert (same trick the existing code uses for RegularInsert and (Select) selectFrom(...)).
• SELECT JSON support threads a boolean json flag through the private createSelect/createSelectAndOrder/getSelect chain; existing callers are untouched via delegating overloads, so count()/exists()/entity select() behavior is unchanged.
• Row mapping for SELECT JSON uses the existing SingleColumnRowMapper.newInstance(String.class) (the result set always has exactly one [json] column; the mapper also guards column count).
• No changes to converters, mapping context, repositories, AOT hints, or observability — JSON statements travel the same execution paths as every other statement.

6. Verification status

Check	Result	How
Main sources compile (all 7 changed Java files + transitive closure)	✅	javac (JDK 25) against the module's dependency jars
StatementFactoryUnitTests	✅ 80/80 (9 new)	standalone JUnit Platform launcher
CassandraTemplateUnitTests	✅ 38/38 (5 new)	same, with Mockito
AsyncCassandraTemplateUnitTests + ReactiveCassandraTemplateUnitTests	✅ 62/62 (8 new)	same
CassandraTemplateIntegrationTests (6 new, version-gated ≥ 3.10)	⚠️ written, not executed	requires Docker/Testcontainers — please run in CI
Kotlin extensions	⚠️ not compiled locally	no local Kotlin toolchain; 12 one-line reified wrappers mirroring the existing ones
Full Maven build (error-prone, checkstyle, javadoc, nullability)	⚠️ not run locally	local machine has no working Maven/JDK toolchain for this build — please rely on CI

7. New tests inventory (all tagged // GH-212)

• StatementFactoryUnitTests (9): shouldCreateInsertJson, insertJsonShouldRenderBindMarkers, shouldCreateInsertJsonWithInsertNulls, shouldCreateInsertJsonIfNotExists, insertJsonWithOptionsShouldRenderBindMarkers, shouldConsiderKeyspaceForInsertJson, shouldMapSelectJsonQuery, shouldMapSelectJsonQueryWithColumnsAndCriteria, selectJsonShouldRenderBindMarkers
• CassandraTemplateUnitTests (5): insertJsonShouldInsertJson, insertJsonShouldApplyInsertOptions, insertJsonShouldConsiderInsertNulls, selectJsonShouldReturnJson, selectOneJsonShouldReturnJson
• AsyncCassandraTemplateUnitTests (4) and ReactiveCassandraTemplateUnitTests (4): insert/insert-with-options/select/selectOne variants
• CassandraTemplateIntegrationTests (6): round-trip insert, LWT IF NOT EXISTS not-applied, DEFAULT UNSET preserves unlisted columns, DEFAULT NULL tombstones them, SELECT JSON list/single, column-restricted SELECT JSON

8. Changed files — complete contents (copy-paste ready)

Replace each file below wholesale with the block content. Paths are relative to the repository root.

---

8.1 spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/StatementFactory.java

+112/−6 — new insertJson(...) and selectJson(...) builders; boolean json flag threaded through private createSelect/createSelectAndOrder/getSelect (existing callers unchanged via delegating overloads); new imports JsonInsert, SelectFrom.

/*
 * Copyright 2017-present the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.springframework.data.cassandra.core;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;

import org.jspecify.annotations.Nullable;

import org.springframework.data.cassandra.core.convert.CassandraConverter;
import org.springframework.data.cassandra.core.convert.QueryMapper;
import org.springframework.data.cassandra.core.convert.UpdateMapper;
import org.springframework.data.cassandra.core.convert.Where;
import org.springframework.data.cassandra.core.cql.QueryOptions;
import org.springframework.data.cassandra.core.cql.QueryOptionsUtil;
import org.springframework.data.cassandra.core.cql.QueryOptionsUtil.CqlStatementOptionsAccessor;
import org.springframework.data.cassandra.core.cql.WriteOptions;
import org.springframework.data.cassandra.core.cql.util.StatementBuilder;
import org.springframework.data.cassandra.core.cql.util.TermFactory;
import org.springframework.data.cassandra.core.mapping.BasicCassandraPersistentEntity;
import org.springframework.data.cassandra.core.mapping.CassandraPersistentEntity;
import org.springframework.data.cassandra.core.mapping.CassandraPersistentProperty;
import org.springframework.data.cassandra.core.mapping.PersistentPropertyTranslator;
import org.springframework.data.cassandra.core.query.ColumnName;
import org.springframework.data.cassandra.core.query.Columns;
import org.springframework.data.cassandra.core.query.Columns.ColumnSelector;
import org.springframework.data.cassandra.core.query.Columns.FunctionCall;
import org.springframework.data.cassandra.core.query.Columns.Selector;
import org.springframework.data.cassandra.core.query.CriteriaDefinition;
import org.springframework.data.cassandra.core.query.CriteriaDefinition.Predicate;
import org.springframework.data.cassandra.core.query.Filter;
import org.springframework.data.cassandra.core.query.Query;
import org.springframework.data.cassandra.core.query.Update;
import org.springframework.data.cassandra.core.query.Update.AddToMapOp;
import org.springframework.data.cassandra.core.query.Update.AddToOp;
import org.springframework.data.cassandra.core.query.Update.AddToOp.Mode;
import org.springframework.data.cassandra.core.query.Update.AssignmentOp;
import org.springframework.data.cassandra.core.query.Update.IncrOp;
import org.springframework.data.cassandra.core.query.Update.RemoveOp;
import org.springframework.data.cassandra.core.query.Update.SetAtIndexOp;
import org.springframework.data.cassandra.core.query.Update.SetAtKeyOp;
import org.springframework.data.cassandra.core.query.Update.SetOp;
import org.springframework.data.cassandra.core.query.VectorSort;
import org.springframework.data.convert.EntityWriter;
import org.springframework.data.domain.Sort;
import org.springframework.data.mapping.context.MappingContext;
import org.springframework.data.projection.EntityProjection;
import org.springframework.data.projection.EntityProjectionIntrospector;
import org.springframework.data.util.Predicates;
import org.springframework.data.util.ProxyUtils;
import org.springframework.util.Assert;
import org.springframework.util.ClassUtils;
import org.springframework.util.ConcurrentLruCache;

import com.datastax.oss.driver.api.core.CqlIdentifier;
import com.datastax.oss.driver.api.core.CqlSession;
import com.datastax.oss.driver.api.core.cql.ResultSet;
import com.datastax.oss.driver.api.core.data.CqlVector;
import com.datastax.oss.driver.api.core.metadata.schema.ClusteringOrder;
import com.datastax.oss.driver.api.querybuilder.BindMarker;
import com.datastax.oss.driver.api.querybuilder.QueryBuilder;
import com.datastax.oss.driver.api.querybuilder.condition.Condition;
import com.datastax.oss.driver.api.querybuilder.condition.ConditionBuilder;
import com.datastax.oss.driver.api.querybuilder.delete.Delete;
import com.datastax.oss.driver.api.querybuilder.delete.DeleteSelection;
import com.datastax.oss.driver.api.querybuilder.insert.Insert;
import com.datastax.oss.driver.api.querybuilder.insert.JsonInsert;
import com.datastax.oss.driver.api.querybuilder.insert.RegularInsert;
import com.datastax.oss.driver.api.querybuilder.relation.ColumnRelationBuilder;
import com.datastax.oss.driver.api.querybuilder.relation.Relation;
import com.datastax.oss.driver.api.querybuilder.select.Select;
import com.datastax.oss.driver.api.querybuilder.select.SelectFrom;
import com.datastax.oss.driver.api.querybuilder.term.Term;
import com.datastax.oss.driver.api.querybuilder.update.Assignment;
import com.datastax.oss.driver.api.querybuilder.update.OngoingAssignment;
import com.datastax.oss.driver.api.querybuilder.update.UpdateStart;
import com.datastax.oss.driver.api.querybuilder.update.UpdateWithAssignments;

/**
 * Factory to render {@link com.datastax.oss.driver.api.core.cql.Statement} objects from {@link Query} and
 * {@link Update} objects.
 *
 * @author Mark Paluch
 * @author John Blum
 * @author Sam Lightfoot
 * @see com.datastax.oss.driver.api.core.cql.Statement
 * @see org.springframework.data.cassandra.core.query.Query
 * @see org.springframework.data.cassandra.core.query.Update
 * @since 2.0
 */
public class StatementFactory {

	private final CassandraConverter cassandraConverter;

	private final QueryMapper queryMapper;

	private final UpdateMapper updateMapper;

	private final EntityProjectionIntrospector introspector;

	private final ConcurrentLruCache<Class<?>, EntityProjection<?, ?>> nonProjectingCache;

	private final ConcurrentLruCache<ProjectionKey, EntityProjection<?, ?>> projectingCache;

	private KeyspaceProvider keyspaceProvider = KeyspaceProviders.ENTITY_KEYSPACE;

	private ProjectionFunction projectionFunction = ProjectionFunction.projecting();

	/**
	 * Create {@link StatementFactory} given {@link CassandraConverter}.
	 *
	 * @param converter must not be {@literal null}.
	 * @since 3.0
	 */
	public StatementFactory(CassandraConverter converter) {
		this(new UpdateMapper(converter));
	}

	/**
	 * Create {@code StatementFactory} given {@link UpdateMapper}.
	 *
	 * @param updateMapper must not be {@literal null}.
	 */
	public StatementFactory(UpdateMapper updateMapper) {
		this(updateMapper, updateMapper);
	}

	/**
	 * Create {@code StatementFactory} given {@link QueryMapper} and {@link UpdateMapper}.
	 *
	 * @param queryMapper must not be {@literal null}.
	 * @param updateMapper must not be {@literal null}.
	 */
	public StatementFactory(QueryMapper queryMapper, UpdateMapper updateMapper) {

		Assert.notNull(queryMapper, "QueryMapper must not be null");
		Assert.notNull(updateMapper, "UpdateMapper must not be null");

		this.cassandraConverter = queryMapper.getConverter();
		this.queryMapper = queryMapper;
		this.updateMapper = updateMapper;

		this.introspector = EntityProjectionIntrospector.create(this.cassandraConverter.getProjectionFactory(),
				EntityProjectionIntrospector.ProjectionPredicate.typeHierarchy()
						.and(((target, underlyingType) -> !this.cassandraConverter.getCustomConversions().isSimpleType(target))),
				this.cassandraConverter.getMappingContext());

		this.nonProjectingCache = new ConcurrentLruCache<>(128, EntityProjection::nonProjecting);
		this.projectingCache = new ConcurrentLruCache<>(128,
				key -> introspector.introspect(key.returnType(), key.domainType()));
	}

	/**
	 * Cache key for the projection introspection cache.
	 *
	 * @param domainType
	 * @param returnType
	 * @since 5.0
	 */
	record ProjectionKey(Class<?> domainType, Class<?> returnType) {
	}

	/**
	 * Return the {@link QueryMapper} used to map {@link Query} to CQL-specific data types.
	 *
	 * @return the {@link QueryMapper} used to map {@link Query} to CQL-specific data types.
	 * @see QueryMapper
	 */
	protected QueryMapper getQueryMapper() {
		return this.queryMapper;
	}

	/**
	 * Return the {@link UpdateMapper} used to map {@link Update} to CQL-specific data types.
	 *
	 * @return the {@link UpdateMapper} used to map {@link Update} to CQL-specific data types.
	 * @see UpdateMapper
	 */
	protected UpdateMapper getUpdateMapper() {
		return this.updateMapper;
	}

	/**
	 * Return a non-projecting {@link EntityProjection} for the given domain class.
	 *
	 * @param domainClass underlying domain class.
	 * @return non-projecting {@link EntityProjection}.
	 * @since 5.0
	 */
	@SuppressWarnings("unchecked")
	<D> EntityProjection<D, D> getEntityProjection(Class<D> domainClass) {
		return (EntityProjection<D, D>) nonProjectingCache.get(domainClass);
	}

	/**
	 * Return a {@link EntityProjection} for the given domain class and return type.
	 *
	 * @param domainClass underlying domain class.
	 * @param returnType returned (or projection) type.
	 * @return the {@link EntityProjection}.
	 * @since 5.0
	 */
	@SuppressWarnings("unchecked")
	<M, D> EntityProjection<M, D> getEntityProjection(Class<D> domainClass, Class<M> returnType) {

		if (returnType.equals(domainClass)) {
			return (EntityProjection<M, D>) nonProjectingCache.get(returnType);
		}

		return (EntityProjection<M, D>) projectingCache.get(new ProjectionKey(domainClass, returnType));
	}

	/**
	 * Set the {@link KeyspaceProvider} to determine the {@link CqlIdentifier keyspace} for a
	 * {@link CassandraPersistentEntity entity}-related statement.
	 *
	 * @param keyspaceProvider the keyspace provider to use, must not be {@literal null}.
	 * @since 4.4
	 */
	public void setKeyspaceProvider(KeyspaceProvider keyspaceProvider) {

		Assert.notNull(keyspaceProvider, "KeyspaceProvider must not be null");

		this.keyspaceProvider = keyspaceProvider;
	}

	/**
	 * @return the configured projection function.
	 * @since 5.0
	 */
	public ProjectionFunction getProjectionFunction() {
		return projectionFunction;
	}

	/**
	 * Set the default {@link ProjectionFunction} to determine {@link Columns} for a {@link Select} statement if the query
	 * did not specify any columns.
	 *
	 * @param projectionFunction the projection function to use, must not be {@literal null}.
	 * @since 5.0
	 */
	public void setProjectionFunction(ProjectionFunction projectionFunction) {

		Assert.notNull(projectionFunction, "ProjectionFunction must not be null");

		this.projectionFunction = projectionFunction;
	}

	/**
	 * Create a {@literal COUNT} statement by mapping {@link Query} to {@link Select}.
	 *
	 * @param query user-defined count {@link Query} to execute; must not be {@literal null}.
	 * @param entity {@link CassandraPersistentEntity entity} to count; must not be {@literal null}.
	 * @return the select builder.
	 * @since 2.1
	 */
	public StatementBuilder<Select> count(Query query, CassandraPersistentEntity<?> entity) {

		Assert.notNull(query, "Query must not be null");
		Assert.notNull(entity, "CassandraPersistentEntity must not be null");

		return count(query, entity, entity.getTableName());
	}

	/**
	 * Create a {@literal COUNT} statement by mapping {@link Query} to {@link Select}.
	 *
	 * @param query user-defined count {@link Query} to execute; must not be {@literal null}.
	 * @param entity {@link CassandraPersistentEntity entity} to count; must not be {@literal null}.
	 * @param tableName must not be {@literal null}.
	 * @return the select builder.
	 * @since 2.1
	 */
	public StatementBuilder<Select> count(Query query, CassandraPersistentEntity<?> entity, CqlIdentifier tableName) {

		Filter filter = getQueryMapper().getMappedObject(query, entity);
		List<Selector> selectors = Collections.singletonList(FunctionCall.from("COUNT", 1L));

		return createSelect(query, entity, filter, selectors, tableName);
	}

	/**
	 * Create a {@literal SELECT} statement by mapping {@link Query} to {@link Select} to run an exists query limiting
	 * results to one.
	 *
	 * @param query must not be {@literal null}.
	 * @param projection must not be {@literal null}.
	 * @param entity must not be {@literal null}.
	 * @param tableName must not be {@literal null}.
	 * @return the select builder.
	 * @since 5.0
	 */
	public StatementBuilder<Select> selectExists(Query query, EntityProjection<?, ?> projection,
			CassandraPersistentEntity<?> entity, CqlIdentifier tableName) {
		return select(query.limit(1), projection, entity, tableName, ProjectionFunction.primaryKey());
	}

	/**
	 * Create an {@literal SELECT} statement by mapping {@code id} to {@literal SELECT … WHERE}. This method supports
	 * composite primary keys as part of the entity class itself or as separate primary key class.
	 *
	 * @param id must not be {@literal null}.
	 * @param entity must not be {@literal null}.
	 * @param tableName must not be {@literal null}.
	 * @return the select builder.
	 */
	public StatementBuilder<Select> selectExists(Object id, CassandraPersistentEntity<?> entity,
			CqlIdentifier tableName) {
		return selectOneById(id, entity, tableName, ProjectionFunction.primaryKey());
	}

	/**
	 * Create an {@literal SELECT} statement by mapping {@code id} to {@literal SELECT … WHERE}. This method supports
	 * composite primary keys as part of the entity class itself or as separate primary key class.
	 *
	 * @param id must not be {@literal null}.
	 * @param entity must not be {@literal null}.
	 * @param tableName must not be {@literal null}.
	 * @return the select builder.
	 */
	public StatementBuilder<Select> selectOneById(Object id, CassandraPersistentEntity<?> entity,
			CqlIdentifier tableName) {
		return selectOneById(id, entity, tableName, ProjectionFunction.empty());
	}

	/**
	 * Create an {@literal SELECT} statement by mapping {@code id} to {@literal SELECT … WHERE}. This method supports
	 * composite primary keys as part of the entity class itself or as separate primary key class.
	 *
	 * @param id must not be {@literal null}.
	 * @param entity must not be {@literal null}.
	 * @param tableName must not be {@literal null}.
	 * @return the select builder.
	 */
	private StatementBuilder<Select> selectOneById(Object id, CassandraPersistentEntity<?> entity,
			CqlIdentifier tableName, ProjectionFunction projectionFunction) {

		Where where = new Where();

		Columns columns = computeColumnsForProjection(getEntityProjection(entity.getType()), Columns.empty(),
				projectionFunction);
		List<Selector> selectors = getQueryMapper().getMappedSelectors(columns, entity);

		cassandraConverter.write(id, where, entity);

		StatementBuilder<Select> builder = StatementBuilder.of((Select) QueryBuilder.selectFrom(tableName),
				cassandraConverter.getCodecRegistry());

		builder.bind((statement, factory) -> getSelect(selectors, entity, tableName, factory).limit(1));
		return builder.bind((statement, factory) -> statement.where(toRelations(where, factory)));
	}

	/**
	 * Create a {@literal SELECT} statement by mapping {@link Query} to {@link Select}.
	 *
	 * @param query must not be {@literal null}.
	 * @param entity must not be {@literal null}.
	 * @return the select builder.
	 */
	public StatementBuilder<Select> select(Query query, CassandraPersistentEntity<?> entity) {

		Assert.notNull(query, "Query must not be null");
		Assert.notNull(entity, "CassandraPersistentEntity must not be null");

		return select(query, entity, entity.getTableName());
	}

	/**
	 * Create a {@literal SELECT} statement by mapping {@link Query} to {@link Select}.
	 *
	 * @param query must not be {@literal null}.
	 * @param entity must not be {@literal null}.
	 * @param tableName must not be {@literal null}.
	 * @return the select builder.
	 * @since 2.1
	 */
	public StatementBuilder<Select> select(Query query, CassandraPersistentEntity<?> entity, CqlIdentifier tableName) {
		return select(query, getEntityProjection(entity.getType()), entity, tableName, ProjectionFunction.empty());
	}

	/**
	 * Create a {@literal SELECT} statement by mapping {@link Query} to {@link Select} considering projections.
	 *
	 * @param query must not be {@literal null}.
	 * @param projection must not be {@literal null}.
	 * @param entity must not be {@literal null}.
	 * @param tableName must not be {@literal null}.
	 * @return the select builder.
	 * @since 5.0
	 */
	public StatementBuilder<Select> select(Query query, EntityProjection<?, ?> projection,
			CassandraPersistentEntity<?> entity, CqlIdentifier tableName) {
		return select(query, projection, entity, tableName, ProjectionFunction.empty());
	}

	private StatementBuilder<Select> select(Query query, EntityProjection<?, ?> projection,
			CassandraPersistentEntity<?> entity, CqlIdentifier tableName, ProjectionFunction projectionFunction) {

		Assert.notNull(query, "Query must not be null");
		Assert.notNull(entity, "CassandraPersistentEntity must not be null");
		Assert.notNull(tableName, "Table name must not be null");
		Assert.notNull(projectionFunction, "ProjectionFunction must not be null");

		Columns columns = computeColumnsForProjection(projection, query.getColumns(), projectionFunction);

		return doSelect(query.columns(columns), entity, tableName);
	}

	private StatementBuilder<Select> doSelect(Query query, CassandraPersistentEntity<?> entity, CqlIdentifier tableName) {

		Assert.notNull(query, "Query must not be null");
		Assert.notNull(entity, "CassandraPersistentEntity must not be null");
		Assert.notNull(entity, "Table name must not be null");

		Filter filter = getQueryMapper().getMappedObject(query, entity);
		List<Selector> selectors = getQueryMapper().getMappedSelectors(query.getColumns(), entity);

		return createSelect(query, entity, filter, selectors, tableName);
	}

	/**
	 * Create a {@literal SELECT JSON} statement by mapping {@link Query} to {@link Select}. The returned statement yields
	 * rows containing a single column holding the JSON representation of the selected row as defined by the Cassandra
	 * {@code SELECT JSON} semantics.
	 *
	 * @param query must not be {@literal null}.
	 * @param entity must not be {@literal null}.
	 * @return the select builder.
	 * @since 5.2
	 */
	public StatementBuilder<Select> selectJson(Query query, CassandraPersistentEntity<?> entity) {

		Assert.notNull(entity, "CassandraPersistentEntity must not be null");

		return selectJson(query, entity, entity.getTableName());
	}

	/**
	 * Create a {@literal SELECT JSON} statement by mapping {@link Query} to {@link Select}. The returned statement yields
	 * rows containing a single column holding the JSON representation of the selected row as defined by the Cassandra
	 * {@code SELECT JSON} semantics.
	 *
	 * @param query must not be {@literal null}.
	 * @param entity must not be {@literal null}.
	 * @param tableName must not be {@literal null}.
	 * @return the select builder.
	 * @since 5.2
	 */
	public StatementBuilder<Select> selectJson(Query query, CassandraPersistentEntity<?> entity,
			CqlIdentifier tableName) {

		Assert.notNull(query, "Query must not be null");
		Assert.notNull(entity, "CassandraPersistentEntity must not be null");
		Assert.notNull(tableName, "Table name must not be null");

		Filter filter = getQueryMapper().getMappedObject(query, entity);
		List<Selector> selectors = getQueryMapper().getMappedSelectors(query.getColumns(), entity);

		return createSelect(true, query, entity, filter, selectors, tableName);
	}

	/**
	 * Creates a Query Object for an insert.
	 *
	 * @param objectToInsert the object to save, must not be {@literal null}.
	 * @param options optional {@link WriteOptions} to apply to the {@link Insert} statement, may be {@literal null}.
	 * @return the select builder.
	 * @since 3.0
	 */
	public StatementBuilder<RegularInsert> insert(Object objectToInsert, WriteOptions options) {

		Assert.notNull(objectToInsert, "Object to builder must not be null");
		Assert.notNull(options, "WriteOptions must not be null");

		CassandraPersistentEntity<?> entity = cassandraConverter.getMappingContext()
				.getRequiredPersistentEntity(objectToInsert.getClass());
		return insert(objectToInsert, options, entity, entity.getTableName());
	}

	/**
	 * Creates a Query Object for an insert.
	 *
	 * @param tableName the table name, must not be empty and not {@literal null}.
	 * @param objectToInsert the object to save, must not be {@literal null}.
	 * @param options optional {@link WriteOptions} to apply to the {@link Insert} statement, may be {@literal null}.
	 * @param entity the {@link CassandraPersistentEntity} to write insert values.
	 * @return the select builder.
	 */
	public StatementBuilder<RegularInsert> insert(Object objectToInsert, WriteOptions options,
			CassandraPersistentEntity<?> entity, CqlIdentifier tableName) {

		Assert.notNull(tableName, "TableName must not be null");
		Assert.notNull(objectToInsert, "Object to insert must not be null");
		Assert.notNull(entity, "CassandraPersistentEntity must not be null");

		boolean insertNulls;

		if (options instanceof InsertOptions insertOptions) {
			insertNulls = insertOptions.isInsertNulls();
		} else {
			insertNulls = false;
		}

		Map<CqlIdentifier, Object> object = new LinkedHashMap<>();
		cassandraConverter.write(objectToInsert, object, entity);

		StatementBuilder<RegularInsert> builder = StatementBuilder
				.of(QueryBuilder.insertInto(getKeyspace(entity, tableName), tableName).valuesByIds(Collections.emptyMap()),
						cassandraConverter.getCodecRegistry())
				.bind((statement, factory) -> {

					Map<CqlIdentifier, Term> values = createTerms(insertNulls, object, factory);
					CqlStatementOptionsAccessor<Insert> accessor = factory.ifBoundOrInline(
							bindings -> CqlStatementOptionsAccessor.ofInsert(bindings, statement),
							() -> CqlStatementOptionsAccessor.ofInsert(statement));
					RegularInsert afterOptions = (RegularInsert) addInsertOptions(accessor, options);

					return afterOptions.valuesByIds(values);
				});

		builder.transform(statement -> QueryOptionsUtil.addQueryOptions(statement, options));

		return builder;
	}

	private static Map<CqlIdentifier, Term> createTerms(boolean insertNulls, Map<CqlIdentifier, Object> object,
			TermFactory factory) {

		Map<CqlIdentifier, Term> values = new LinkedHashMap<>(object.size());

		object.forEach((cqlIdentifier, o) -> {

			if (o == null && !insertNulls) {
				return;
			}
			values.put(cqlIdentifier, factory.create(o));
		});
		return values;
	}

	/**
	 * Create an {@literal INSERT JSON} statement to insert the given {@code json} payload. The JSON keys are expected to
	 * map to column names as defined by the Cassandra {@code INSERT JSON} semantics. Columns omitted from the JSON
	 * payload are left unset ({@code DEFAULT UNSET}) unless {@link InsertOptions#isInsertNulls()} is set, in which case
	 * omitted columns are inserted as {@code null} ({@code DEFAULT NULL}).
	 *
	 * @param json the JSON payload, must not be {@literal null} or empty.
	 * @param options {@link WriteOptions} to apply to the {@link Insert} statement, must not be {@literal null}.
	 * @param entity the {@link CassandraPersistentEntity} used to resolve the keyspace, must not be {@literal null}.
	 * @param tableName the table name, must not be {@literal null}.
	 * @return the insert builder.
	 * @since 5.2
	 */
	public StatementBuilder<JsonInsert> insertJson(String json, WriteOptions options,
			CassandraPersistentEntity<?> entity, CqlIdentifier tableName) {

		Assert.hasText(json, "JSON must not be empty");
		Assert.notNull(options, "WriteOptions must not be null");
		Assert.notNull(entity, "CassandraPersistentEntity must not be null");
		Assert.notNull(tableName, "TableName must not be null");

		boolean insertNulls = options instanceof InsertOptions insertOptions && insertOptions.isInsertNulls();

		CqlIdentifier keyspace = getKeyspace(entity, tableName);

		StatementBuilder<JsonInsert> builder = StatementBuilder
				.of(QueryBuilder.insertInto(keyspace, tableName).json(json), cassandraConverter.getCodecRegistry())
				.bind((statement, factory) -> {

					JsonInsert insert = factory.ifBoundOrInline(
							bindings -> QueryBuilder.insertInto(keyspace, tableName).json(bindings.bind(json)),
							() -> QueryBuilder.insertInto(keyspace, tableName).json(json));

					JsonInsert insertToUse = insertNulls ? insert.defaultNull() : insert.defaultUnset();

					CqlStatementOptionsAccessor<Insert> accessor = factory.ifBoundOrInline(
							bindings -> CqlStatementOptionsAccessor.ofInsert(bindings, insertToUse),
							() -> CqlStatementOptionsAccessor.ofInsert(insertToUse));

					return (JsonInsert) addInsertOptions(accessor, options);
				});

		builder.transform(statement -> QueryOptionsUtil.addQueryOptions(statement, options));

		return builder;
	}

	/**
	 * Create an {@literal UPDATE} statement by mapping {@link Query} to {@link Update}.
	 *
	 * @param query must not be {@literal null}.
	 * @param entity must not be {@literal null}.
	 * @return the update builder.
	 */
	public StatementBuilder<com.datastax.oss.driver.api.querybuilder.update.Update> update(Query query, Update update,
			CassandraPersistentEntity<?> entity) {

		Assert.notNull(query, "Query must not be null");
		Assert.notNull(update, "Update must not be null");
		Assert.notNull(entity, "CassandraPersistentEntity must not be null");

		return update(query, update, entity, entity.getTableName());
	}

	/**
	 * Create an {@literal UPDATE} statement by mapping {@link Query} to {@link Update}.
	 *
	 * @param query must not be {@literal null}.
	 * @param update must not be {@literal null}.
	 * @param entity must not be {@literal null}.
	 * @param tableName must not be {@literal null}.
	 * @return the update builder.
	 * @since 2.1
	 */
	StatementBuilder<com.datastax.oss.driver.api.querybuilder.update.Update> update(Query query, Update update,
			CassandraPersistentEntity<?> entity, CqlIdentifier tableName) {

		Assert.notNull(query, "Query must not be null");
		Assert.notNull(update, "Update must not be null");
		Assert.notNull(entity, "CassandraPersistentEntity must not be null");
		Assert.notNull(tableName, "Table name must not be null");

		Filter filter = getQueryMapper().getMappedObject(query, entity);

		Update mappedUpdate = getUpdateMapper().getMappedObject(update, entity);

		StatementBuilder<com.datastax.oss.driver.api.querybuilder.update.Update> builder = update(entity, tableName,
				mappedUpdate, filter,
				query.getQueryOptions().filter(WriteOptions.class::isInstance).map(WriteOptions.class::cast));

		query.getQueryOptions().filter(UpdateOptions.class::isInstance).map(UpdateOptions.class::cast)
				.map(UpdateOptions::getIfCondition)
				.ifPresent(criteriaDefinitions -> applyUpdateIfCondition(builder, criteriaDefinitions));

		query.getQueryOptions().ifPresent(
				options -> builder.transform(statementBuilder -> QueryOptionsUtil.addQueryOptions(statementBuilder, options)));

		return builder;
	}

	/**
	 * Create an {@literal UPDATE} statement by mapping {@code objectToUpdate} to {@link Update} considering
	 * {@link UpdateOptions}.
	 *
	 * @param objectToUpdate must not be {@literal null}.
	 * @param options must not be {@literal null}.
	 * @return the update builder.
	 * @since 3.0
	 */
	public StatementBuilder<com.datastax.oss.driver.api.querybuilder.update.Update> update(Object objectToUpdate,
			WriteOptions options) {

		Assert.notNull(objectToUpdate, "Object to builder must not be null");
		Assert.notNull(options, "WriteOptions must not be null");

		CassandraPersistentEntity<?> entity = cassandraConverter.getMappingContext()
				.getRequiredPersistentEntity(objectToUpdate.getClass());

		return update(objectToUpdate, options, entity, entity.getTableName());
	}

	/**
	 * Create an {@literal UPDATE} statement by mapping {@code objectToUpdate} to {@link Update} considering
	 * {@link UpdateOptions}.
	 *
	 * @param objectToUpdate must not be {@literal null}.
	 * @param options must not be {@literal null}.
	 * @param entity must not be {@literal null}.
	 * @param tableName must not be {@literal null}.
	 * @return the update builder.
	 */
	public StatementBuilder<com.datastax.oss.driver.api.querybuilder.update.Update> update(Object objectToUpdate,
			WriteOptions options, CassandraPersistentEntity<?> entity, CqlIdentifier tableName) {

		Assert.notNull(tableName, "TableName must not be null");
		Assert.notNull(objectToUpdate, "Object to builder must not be null");
		Assert.notNull(options, "WriteOptions must not be null");
		Assert.notNull(entity, "CassandraPersistentEntity must not be null");

		Where where = new Where();
		cassandraConverter.write(objectToUpdate, where, entity);

		Map<CqlIdentifier, Object> object = new LinkedHashMap<>();
		cassandraConverter.write(objectToUpdate, object, entity);
		where.forEach((cqlIdentifier, o) -> object.remove(cqlIdentifier));

		StatementBuilder<com.datastax.oss.driver.api.querybuilder.update.Update> builder = StatementBuilder
				.of(QueryBuilder.update(getKeyspace(entity, tableName), tableName).set().where(),
						cassandraConverter.getCodecRegistry())
				.bind((statement, factory) -> {

					CqlStatementOptionsAccessor<UpdateStart> accessor = factory.ifBoundOrInline(
							bindings -> CqlStatementOptionsAccessor.ofUpdate(bindings, (UpdateStart) statement),
							() -> CqlStatementOptionsAccessor.ofUpdate((UpdateStart) statement));
					com.datastax.oss.driver.api.querybuilder.update.Update statementToUse = addUpdateOptions(accessor, options);

					return ((UpdateWithAssignments) statementToUse).set(toAssignments(object, factory))
							.where(toRelations(where, factory));
				});

		Optional.of(options).filter(UpdateOptions.class::isInstance).map(UpdateOptions.class::cast)
				.map(UpdateOptions::getIfCondition)
				.ifPresent(criteriaDefinitions -> applyUpdateIfCondition(builder, criteriaDefinitions));

		builder.transform(statement -> QueryOptionsUtil.addQueryOptions(statement, options));

		return builder;
	}

	/**
	 * Create an {@literal DELETE} statement by mapping {@code id} to {@literal SELECT … WHERE} considering
	 * {@link UpdateOptions}.
	 *
	 * @param id must not be {@literal null}.
	 * @param entity must not be {@literal null}.
	 * @param tableName must not be {@literal null}.
	 * @return the delete builder.
	 */
	public StatementBuilder<Delete> deleteById(Object id, CassandraPersistentEntity<?> entity, CqlIdentifier tableName) {

		Where where = new Where();

		cassandraConverter.write(id, where, entity);

		return StatementBuilder
				.of(QueryBuilder.deleteFrom(getKeyspace(entity, tableName), tableName).where(),
						cassandraConverter.getCodecRegistry())
				.bind((statement, factory) -> statement.where(toRelations(where, factory)));
	}

	/**
	 * Create a {@literal DELETE} statement by mapping {@link Query} to {@link Delete}.
	 *
	 * @param query must not be {@literal null}.
	 * @param entity must not be {@literal null}.
	 * @return the delete builder.
	 */
	public StatementBuilder<Delete> delete(Query query, CassandraPersistentEntity<?> entity) {

		Assert.notNull(query, "Query must not be null");
		Assert.notNull(entity, "CassandraPersistentEntity must not be null");

		return delete(query, entity, entity.getTableName());
	}

	/**
	 * Create a {@literal DELETE} statement by mapping {@link Query} to {@link Delete}.
	 *
	 * @param query must not be {@literal null}.
	 * @param entity must not be {@literal null}.
	 * @param tableName must not be {@literal null}.
	 * @return the delete builder.
	 * @see 2.1
	 */
	public StatementBuilder<Delete> delete(Query query, CassandraPersistentEntity<?> entity, CqlIdentifier tableName) {

		Assert.notNull(query, "Query must not be null");
		Assert.notNull(entity, "CassandraPersistentEntity must not be null");
		Assert.notNull(tableName, "Table name must not be null");

		Filter filter = getQueryMapper().getMappedObject(query, entity);
		List<CqlIdentifier> columnNames = getQueryMapper().getMappedColumnNames(query.getColumns(), entity);

		StatementBuilder<Delete> builder = delete(columnNames, entity, tableName, filter,
				query.getQueryOptions().filter(WriteOptions.class::isInstance).map(WriteOptions.class::cast));

		query.getQueryOptions().filter(DeleteOptions.class::isInstance).map(DeleteOptions.class::cast)
				.map(DeleteOptions::getIfCondition)
				.ifPresent(criteriaDefinitions -> applyDeleteIfCondition(builder, criteriaDefinitions));

		query.getQueryOptions()
				.ifPresent(options -> builder.transform(statement -> QueryOptionsUtil.addQueryOptions(statement, options)));

		return builder;
	}

	/**
	 * Create an {@literal DELETE} statement by mapping {@code entity} to {@link Delete DELETE … WHERE} considering
	 * {@link WriteOptions}.
	 *
	 * @param entity must not be {@literal null}.
	 * @param options must not be {@literal null}.
	 * @param entityWriter must not be {@literal null}.
	 * @param tableName must not be {@literal null}.
	 * @return the delete builder.
	 */
	public StatementBuilder<Delete> delete(Object entity, QueryOptions options, EntityWriter<Object, Object> entityWriter,
			CqlIdentifier tableName) {

		Assert.notNull(tableName, "TableName must not be null");
		Assert.notNull(entity, "Object to builder must not be null");
		Assert.notNull(entityWriter, "EntityWriter must not be null");

		Where where = new Where();
		entityWriter.write(entity, where);
		BasicCassandraPersistentEntity<?> persistentEntity = cassandraConverter.getMappingContext()
				.getRequiredPersistentEntity(ProxyUtils.getUserClass(entity.getClass()));

		StatementBuilder<Delete> builder = StatementBuilder
				.of(QueryBuilder.deleteFrom(getKeyspace(persistentEntity, tableName), tableName).where(),
						cassandraConverter.getCodecRegistry())
				.bind((statement, factory) -> {

					Delete statementToUse;
					if (options instanceof WriteOptions wo) {

						CqlStatementOptionsAccessor<DeleteSelection> accessor = factory.ifBoundOrInline(
								bindings -> CqlStatementOptionsAccessor.ofDelete(bindings, (DeleteSelection) statement),
								() -> CqlStatementOptionsAccessor.ofDelete((DeleteSelection) statement));
						statementToUse = addDeleteOptions(accessor, wo);
					} else {
						statementToUse = statement;
					}

					return statementToUse.where(toRelations(where, factory));
				});

		Optional.of(options).filter(DeleteOptions.class::isInstance).map(DeleteOptions.class::cast)
				.map(DeleteOptions::getIfCondition)
				.ifPresent(criteriaDefinitions -> applyDeleteIfCondition(builder, criteriaDefinitions));

		builder.transform(statement -> QueryOptionsUtil.addQueryOptions(statement, options));

		return builder;
	}

	/**
	 * Compute the {@link Columns} to include type if the given {@link Columns} is empty.
	 *
	 * @param columns must not be {@literal null}.
	 * @param projectionFunction must not be {@literal null}.
	 * @return {@link Columns} with columns to be included.
	 */
	private Columns computeColumnsForProjection(EntityProjection<?, ?> projection, Columns columns,
			ProjectionFunction projectionFunction) {

		if (columns.isEmpty()) {
			return projectionFunction.otherwise(getProjectionFunction()).computeProjection(projection,
					this.cassandraConverter.getMappingContext());
		}

		return columns;
	}

	private StatementBuilder<Select> createSelect(Query query, CassandraPersistentEntity<?> entity, Filter filter,
			List<Selector> selectors, CqlIdentifier tableName) {
		return createSelect(false, query, entity, filter, selectors, tableName);
	}

	private StatementBuilder<Select> createSelect(boolean json, Query query, CassandraPersistentEntity<?> entity,
			Filter filter, List<Selector> selectors, CqlIdentifier tableName) {

		Sort sort = Optional.of(query.getSort()).map(querySort -> getQueryMapper().getMappedSort(querySort, entity))
				.orElse(Sort.unsorted());

		StatementBuilder<Select> select = createSelectAndOrder(json, selectors, entity, tableName, filter, sort);

		if (query.isAllowFiltering()) {
			select.apply(Select::allowFiltering);
		}

		select.onBuild(statementBuilder -> query.getPagingState().ifPresent(statementBuilder::setPagingState));

		if (query.getLimit() > 0) {

			int limit = Math.toIntExact(query.getLimit());
			select.bind((statement, factory) -> factory.ifBoundOrInline(bindings -> statement.limit(bindings.bind(limit)),
					() -> statement.limit(limit)));
		}

		query.getQueryOptions()
				.ifPresent(it -> select.transform(statement -> QueryOptionsUtil.addQueryOptions(statement, it)));

		return select;
	}

	private @Nullable CqlIdentifier getKeyspace(CassandraPersistentEntity<?> entity, CqlIdentifier tableName) {
		return keyspaceProvider.getKeyspace(entity, tableName);
	}

	private StatementBuilder<Select> createSelectAndOrder(boolean json, List<Selector> selectors,
			CassandraPersistentEntity<?> entity, CqlIdentifier from, Filter filter, Sort sort) {

		StatementBuilder<Select> builder = StatementBuilder
				.of((Select) QueryBuilder.selectFrom(getKeyspace(entity, from), from), cassandraConverter.getCodecRegistry());

		builder.bind((statement, factory) -> getSelect(json, selectors, entity, from, factory));
		builder.bind((statement, factory) -> {
			return statement.where(getRelations(filter, factory));
		});

		if (sort.isSorted()) {

			builder.bind((statement, factory) -> {

				Select statementToUse = statement;

				if (sort instanceof VectorSort vs) {

					for (Sort.Order order : sort) {

						Object vector = vs.getVector();
						statementToUse = statementToUse.orderByAnnOf(order.getProperty(), (CqlVector<?>) vector);
					}
				} else {

					for (Sort.Order order : sort) {
						statementToUse = statementToUse.orderBy(order.getProperty(),
								order.isAscending() ? ClusteringOrder.ASC : ClusteringOrder.DESC);
					}
				}

				return statementToUse;
			});
		}

		return builder;
	}

	private Select getSelect(List<Selector> selectors, CassandraPersistentEntity<?> entity, CqlIdentifier from,
			TermFactory factory) {
		return getSelect(false, selectors, entity, from, factory);
	}

	private Select getSelect(boolean json, List<Selector> selectors, CassandraPersistentEntity<?> entity,
			CqlIdentifier from, TermFactory factory) {

		SelectFrom selectFrom = QueryBuilder.selectFrom(getKeyspace(entity, from), from);

		if (json) {
			selectFrom = selectFrom.json();
		}

		if (selectors.isEmpty()) {
			return selectFrom.all();
		}

		List<com.datastax.oss.driver.api.querybuilder.select.Selector> mappedSelectors = new ArrayList<>(selectors.size());
		for (Selector selector : selectors) {
			com.datastax.oss.driver.api.querybuilder.select.Selector orElseGet = selector.getAlias()
					.map(it -> getSelection(selector, factory).as(it)).orElseGet(() -> getSelection(selector, factory));
			mappedSelectors.add(orElseGet);
		}

		return selectFrom.selectors(mappedSelectors);
	}

	private static List<Relation> getRelations(Filter filter, TermFactory factory) {

		List<Relation> relations = new ArrayList<>();

		for (CriteriaDefinition criteriaDefinition : filter) {
			relations.add(toClause(criteriaDefinition, factory));
		}

		return relations;
	}

	private com.datastax.oss.driver.api.querybuilder.select.Selector getSelection(Selector selector,
			TermFactory factory) {

		if (selector instanceof FunctionCall) {

			com.datastax.oss.driver.api.querybuilder.select.Selector[] arguments = ((FunctionCall) selector).getParameters()
					.stream().map(param -> {

						if (param == null) {
							return new SimpleSelector("null");
						}

						if (param instanceof ColumnSelector column) {
							return com.datastax.oss.driver.api.querybuilder.select.Selector.column(column.getCqlIdentifier());
						}

						if (param instanceof ColumnName column) {

							CqlIdentifier cqlIdentifier = column.getCqlIdentifier()
									.or(() -> column.getColumnName().map(CqlIdentifier::fromCql)).get();
							return com.datastax.oss.driver.api.querybuilder.select.Selector.column(cqlIdentifier);
						}

						Term term = getTerm(factory, param);

						if (term instanceof com.datastax.oss.driver.api.querybuilder.select.Selector) {
							return (com.datastax.oss.driver.api.querybuilder.select.Selector) term;
						}

						StringBuilder builder = new StringBuilder();
						term.appendTo(builder);

						return QueryBuilder.raw(builder.toString());

					}).toArray(com.datastax.oss.driver.api.querybuilder.select.Selector[]::new);

			return com.datastax.oss.driver.api.querybuilder.select.Selector.function(selector.getExpression(), arguments);
		}

		return com.datastax.oss.driver.api.querybuilder.select.Selector
				.column(CqlIdentifier.fromInternal(selector.getExpression()));
	}

	private Term getTerm(TermFactory factory, Object param) {

		if (param instanceof Term) {
			return (Term) param;
		}

		if (param instanceof CqlVector<?> vector) {
			return QueryBuilder.raw(vector.toString());
		}

		try {
			Double.parseDouble(param.toString());
			return QueryBuilder.raw(param.toString());
		} catch (NumberFormatException e) {
			return factory.create(param);
		}
	}

	private StatementBuilder<com.datastax.oss.driver.api.querybuilder.update.Update> update(
			CassandraPersistentEntity<?> entity, CqlIdentifier table, Update mappedUpdate, Filter filter,
			Optional<WriteOptions> optionalOptions) {

		UpdateStart updateStart = QueryBuilder.update(getKeyspace(entity, table), table);

		return StatementBuilder
				.of((com.datastax.oss.driver.api.querybuilder.update.Update) updateStart, cassandraConverter.getCodecRegistry())
				.bind((statement, factory) -> {

					com.datastax.oss.driver.api.querybuilder.update.Update statementToUse;
					WriteOptions options = optionalOptions.orElse(null);
					if (options != null) {
						CqlStatementOptionsAccessor<UpdateStart> accessor = factory.ifBoundOrInline(
								bindings -> CqlStatementOptionsAccessor.ofUpdate(bindings, (UpdateStart) statement),
								() -> CqlStatementOptionsAccessor.ofUpdate((UpdateStart) statement));
						statementToUse = addUpdateOptions(accessor, options);
					} else {
						statementToUse = statement;
					}

					List<Assignment> assignments = mappedUpdate.getUpdateOperations().stream()
							.map(assignmentOp -> getAssignment(assignmentOp, factory)).collect(Collectors.toList());

					return (com.datastax.oss.driver.api.querybuilder.update.Update) ((OngoingAssignment) statementToUse)
							.set(assignments);

				}).bind((statement, factory) -> {
					return statement.where(getRelations(filter, factory));
				});
	}

	static Iterable<Relation> toRelations(Where where, TermFactory factory) {

		List<Relation> relations = new ArrayList<>();

		where.forEach((cqlIdentifier, termValue) -> relations
				.add(Relation.column(cqlIdentifier).isEqualTo(factory.create(termValue))));

		return relations;
	}

	static Iterable<Assignment> toAssignments(Map<CqlIdentifier, Object> object, TermFactory factory) {

		List<Assignment> assignments = new ArrayList<>();

		object.forEach(
				(cqlIdentifier, termValue) -> assignments.add(Assignment.setColumn(cqlIdentifier, factory.create(termValue))));

		return assignments;
	}

	private static void applyUpdateIfCondition(
			StatementBuilder<com.datastax.oss.driver.api.querybuilder.update.Update> update, Filter criteriaDefinitions) {

		update.bind((statement, factory) -> {

			List<Condition> conditions = criteriaDefinitions.stream().map(it -> toCondition(it, factory))
					.collect(Collectors.toList());

			return statement.if_(conditions);
		});
	}

	private static void applyDeleteIfCondition(
			StatementBuilder<com.datastax.oss.driver.api.querybuilder.delete.Delete> delete, Filter criteriaDefinitions) {
		delete.bind((statement, factory) -> {

			List<Condition> conditions = criteriaDefinitions.stream().map(it -> toCondition(it, factory))
					.collect(Collectors.toList());
			return statement.if_(conditions);
		});
	}

	private static Assignment getAssignment(AssignmentOp assignmentOp, TermFactory termFactory) {

		if (assignmentOp instanceof SetOp) {
			return getAssignment((SetOp) assignmentOp, termFactory);
		}

		if (assignmentOp instanceof RemoveOp) {
			return getAssignment((RemoveOp) assignmentOp, termFactory);
		}

		if (assignmentOp instanceof IncrOp) {
			return getAssignment((IncrOp) assignmentOp, termFactory);
		}

		if (assignmentOp instanceof AddToOp) {
			return getAssignment((AddToOp) assignmentOp, termFactory);
		}

		if (assignmentOp instanceof AddToMapOp) {
			return getAssignment((AddToMapOp) assignmentOp, termFactory);
		}

		throw new IllegalArgumentException(String.format("UpdateOp %s not supported", assignmentOp));
	}

	private static Assignment getAssignment(IncrOp incrOp, TermFactory termFactory) {

		return incrOp.getValue().longValue() > 0
				? Assignment.increment(incrOp.toCqlIdentifier(), termFactory.create(Math.abs(incrOp.getValue().longValue())))
				: Assignment.decrement(incrOp.toCqlIdentifier(), termFactory.create(Math.abs(incrOp.getValue().longValue())));
	}

	private static Assignment getAssignment(SetOp updateOp, TermFactory termFactory) {

		if (updateOp instanceof SetAtIndexOp) {

			return Assignment.setListValue(updateOp.toCqlIdentifier(),
					termFactory.create(((SetAtIndexOp) updateOp).getIndex()), termFactory.create(updateOp.getValue()));
		}

		if (updateOp instanceof SetAtKeyOp) {
			SetAtKeyOp op = (SetAtKeyOp) updateOp;
			return Assignment.setMapValue(op.toCqlIdentifier(), termFactory.create(op.getKey()),
					termFactory.create(op.getValue()));
		}

		return Assignment.setColumn(updateOp.toCqlIdentifier(), termFactory.create(updateOp.getValue()));
	}

	@SuppressWarnings("unchecked")
	private static Assignment getAssignment(RemoveOp removeOp, TermFactory termFactory) {

		if (removeOp.getValue() instanceof Set) {

			Collection<Object> collection = (Collection<Object>) removeOp.getValue();

			return new RemoveCollectionElementsAssignment(removeOp.toCqlIdentifier(), termFactory.create(collection));
		}

		if (removeOp.getValue() instanceof List) {

			Collection<Object> collection = (Collection<Object>) removeOp.getValue();

			return new RemoveCollectionElementsAssignment(removeOp.toCqlIdentifier(), termFactory.create(collection));
		}

		return Assignment.remove(removeOp.toCqlIdentifier(), termFactory.create(removeOp.getValue()));
	}

	private static Assignment getAssignment(AddToOp updateOp, TermFactory termFactory) {

		if (updateOp.getValue() instanceof Set) {
			return Assignment.append(updateOp.toCqlIdentifier(), termFactory.create(updateOp.getValue()));
		}

		return Mode.PREPEND.equals(updateOp.getMode())
				? Assignment.prepend(updateOp.toCqlIdentifier(), termFactory.create(updateOp.getValue()))
				: Assignment.append(updateOp.getColumnName().toCql(), termFactory.create(updateOp.getValue()));
	}

	private static Assignment getAssignment(AddToMapOp updateOp, TermFactory termFactory) {
		return Assignment.append(updateOp.toCqlIdentifier(), termFactory.create(updateOp.getValue()));
	}

	private StatementBuilder<Delete> delete(List<CqlIdentifier> columnNames, CassandraPersistentEntity<?> entity,
			CqlIdentifier from, Filter filter, Optional<WriteOptions> optionsOptional) {

		DeleteSelection select = QueryBuilder.deleteFrom(getKeyspace(entity, from), from);

		for (CqlIdentifier columnName : columnNames) {
			select = select.column(columnName);
		}

		return StatementBuilder.of(select.where(), cassandraConverter.getCodecRegistry()).bind((statement, factory) -> {

			WriteOptions options = optionsOptional.orElse(null);
			Delete statementToUse;
			if (options != null) {
				CqlStatementOptionsAccessor<DeleteSelection> accessor = factory.ifBoundOrInline(
						bindings -> CqlStatementOptionsAccessor.ofDelete(bindings, (DeleteSelection) statement),
						() -> CqlStatementOptionsAccessor.ofDelete((DeleteSelection) statement));
				statementToUse = addDeleteOptions(accessor, options);
			} else {
				statementToUse = statement;
			}

			return statementToUse.where(getRelations(filter, factory));
		});
	}

	/**
	 * Add common {@link WriteOptions} options to {@link Insert} CQL statements.
	 *
	 * @param insert {@link Insert} CQL statement, must not be {@literal null}.
	 * @param writeOptions write options (e.g. consistency level) to add to the CQL statement.
	 * @return the given {@link Insert}.
	 * @since 2.1
	 */
	static Insert addInsertOptions(CqlStatementOptionsAccessor<Insert> insert, WriteOptions writeOptions) {

		Assert.notNull(insert, "Insert must not be null");

		Insert insertToUse = QueryOptionsUtil.addWriteOptions(insert, writeOptions);

		if (writeOptions instanceof InsertOptions insertOptions) {

			if (insertOptions.isIfNotExists()) {
				insertToUse = insertToUse.ifNotExists();
			}
		}

		return insertToUse;
	}

	/**
	 * Add common {@link WriteOptions} options to {@link com.datastax.oss.driver.api.querybuilder.update.Update} CQL
	 * statements.
	 *
	 * @param update {@link com.datastax.oss.driver.api.querybuilder.update.Update} CQL statement, must not be
	 *          {@literal null}.
	 * @param writeOptions write options (e.g. consistency level) to add to the CQL statement.
	 * @return the given {@link com.datastax.oss.driver.api.querybuilder.update.Update}.
	 * @see QueryOptionsUtil#addWriteOptions(com.datastax.oss.driver.api.querybuilder.update.Update, WriteOptions)
	 * @since 2.1
	 */
	static com.datastax.oss.driver.api.querybuilder.update.Update addUpdateOptions(
			CqlStatementOptionsAccessor<UpdateStart> update, WriteOptions writeOptions) {

		Assert.notNull(update, "Update must not be null");

		com.datastax.oss.driver.api.querybuilder.update.Update updateToUse = (com.datastax.oss.driver.api.querybuilder.update.Update) QueryOptionsUtil
				.addWriteOptions(update, writeOptions);

		if (writeOptions instanceof UpdateOptions updateOptions) {

			if (updateOptions.isIfExists()) {
				updateToUse = updateToUse.ifExists();
			}
		}

		return updateToUse;
	}

	/**
	 * Add common {@link WriteOptions} options to {@link Delete} CQL statements.
	 *
	 * @param delete {@link Delete} CQL statement, must not be {@literal null}.
	 * @param writeOptions write options (e.g. consistency level) to add to the CQL statement.
	 * @return the given {@link Delete}.
	 * @since 2.1
	 */
	static Delete addDeleteOptions(CqlStatementOptionsAccessor<DeleteSelection> delete, WriteOptions writeOptions) {

		Assert.notNull(delete, "Delete must not be null");

		Delete deleteToUse = (Delete) QueryOptionsUtil.addWriteOptions(delete, writeOptions);

		if (writeOptions instanceof DeleteOptions deleteOptions) {

			if (deleteOptions.isIfExists()) {
				deleteToUse = deleteToUse.where().ifExists();
			}
		}

		return deleteToUse;
	}

	private static Relation toClause(CriteriaDefinition criteriaDefinition, TermFactory factory) {

		CqlIdentifier columnName = criteriaDefinition.getColumnName().getCqlIdentifier()
				.orElseGet(() -> CqlIdentifier.fromInternal(criteriaDefinition.getColumnName().toCql()));

		Predicate predicate = criteriaDefinition.getPredicate();

		CriteriaDefinition.Operators predicateOperator = CriteriaDefinition.Operators
				.from(predicate.getOperator().toString()).orElseThrow(
						() -> new IllegalArgumentException(String.format("Unknown operator [%s]", predicate.getOperator())));

		ColumnRelationBuilder<Relation> column = Relation.column(columnName);
		Object value = predicate.getValue();

		switch (predicateOperator) {

			case EQ:
				return column.isEqualTo(factory.create(value));

			case NE:
				return column.isNotEqualTo(factory.create(value));

			case GT:
				return column.isGreaterThan(factory.create(value));

			case GTE:
				return column.isGreaterThanOrEqualTo(factory.create(value));

			case LT:
				return column.isLessThan(factory.create(value));

			case LTE:
				return column.isLessThanOrEqualTo(factory.create(value));

			case IN:

				if (isCollectionLike(value)) {

					if (factory.canBindCollection()) {
						Term term = factory.create(value);
						return term instanceof BindMarker ? column.in((BindMarker) term) : column.in(term);
					}

					return column.in(toLiterals(value));
				}

				return column.in(factory.create(value));

			case LIKE:
				return column.like(factory.create(value));

			case IS_NOT_NULL:
				return column.isNotNull();

			case CONTAINS:

				Assert.state(value != null, () -> String.format("CONTAINS value for column %s is null", columnName));

				return column.contains(factory.create(value));

			case CONTAINS_KEY:

				Assert.state(value != null, () -> String.format("CONTAINS KEY value for column %s is null", columnName));

				return column.containsKey(factory.create(value));
		}

		throw new IllegalArgumentException(
				String.format("Criteria %s %s %s not supported", columnName, predicate.getOperator(), value));
	}

	private static Condition toCondition(CriteriaDefinition criteriaDefinition, TermFactory factory) {

		String columnName = criteriaDefinition.getColumnName().toCql();

		Predicate predicate = criteriaDefinition.getPredicate();

		CriteriaDefinition.Operators predicateOperator = CriteriaDefinition.Operators
				.from(predicate.getOperator().toString()).orElseThrow(
						() -> new IllegalArgumentException(String.format("Unknown operator [%s]", predicate.getOperator())));

		ConditionBuilder<Condition> column = Condition.column(columnName);
		Object value = predicate.getValue();

		switch (predicateOperator) {

			case EQ:
				return column.isEqualTo(factory.create(value));

			case NE:
				return column.isNotEqualTo(factory.create(value));

			case GT:
				return column.isGreaterThan(factory.create(value));

			case GTE:
				return column.isGreaterThanOrEqualTo(factory.create(value));

			case LT:
				return column.isLessThan(factory.create(value));

			case LTE:
				return column.isLessThanOrEqualTo(factory.create(value));

			case IN:

				if (isCollectionLike(value)) {

					if (factory.canBindCollection()) {
						Term term = factory.create(value);
						return term instanceof BindMarker ? column.in((BindMarker) term) : column.in(term);
					}

					return column.in(toLiterals(value));
				}

				return column.in(factory.create(value));
		}

		throw new IllegalArgumentException(
				String.format("Criteria %s %s %s not supported for IF Conditions", columnName, predicate.getOperator(), value));
	}

	static List<Term> toLiterals(@Nullable Object arrayOrList) {
		return toLiterals(arrayOrList, QueryBuilder::literal);
	}

	static List<Term> toLiterals(@Nullable Object arrayOrList, Function<Object, Term> termFactory) {

		if (arrayOrList instanceof List) {

			List<?> list = (List<?>) arrayOrList;
			List<Term> literals = new ArrayList<>(list.size());
			for (Object o : list) {
				literals.add(termFactory.apply(o));
			}

			return literals;
		}

		if (arrayOrList != null && arrayOrList.getClass().isArray()) {

			Object[] array = (Object[]) arrayOrList;
			List<Term> literals = new ArrayList<>(array.length);
			for (Object o : array) {
				literals.add(termFactory.apply(o));
			}

			return literals;
		}

		return Collections.emptyList();
	}

	private static boolean isCollectionLike(@Nullable Object value) {
		return value instanceof List || (value != null && value.getClass().isArray());
	}

	static class SimpleSelector implements com.datastax.oss.driver.api.querybuilder.select.Selector {

		private final String selector;

		SimpleSelector(String selector) {
			this.selector = selector;
		}


		@Override
		public com.datastax.oss.driver.api.querybuilder.select.Selector as(CqlIdentifier alias) {
			throw new UnsupportedOperationException();
		}

		@Override
		public @Nullable CqlIdentifier getAlias() {
			return null;
		}

		@Override
		public void appendTo(StringBuilder builder) {
			builder.append(selector);
		}
	}

	private static class RemoveCollectionElementsAssignment implements Assignment {

		private final CqlIdentifier columnId;
		private final Term value;

		protected RemoveCollectionElementsAssignment(CqlIdentifier columnId, Term value) {
			this.columnId = columnId;
			this.value = value;
		}

		@Override
		public void appendTo(StringBuilder builder) {
			builder.append(String.format("%1$s=%1$s-%2$s", columnId.asCql(true), buildRightOperand()));
		}

		private String buildRightOperand() {
			StringBuilder builder = new StringBuilder();
			value.appendTo(builder);
			return builder.toString();
		}

		@Override
		public boolean isIdempotent() {
			return value.isIdempotent();
		}

		public Term getValue() {
			return value;
		}

	}

	/**
	 * Strategy interface to determine a {@link CqlIdentifier keyspace} for a given {@link CassandraPersistentEntity} and
	 * {@code tableName}. Classes implementing this interface can choose to return a keyspace or {@code null} to use the
	 * default keyspace.
	 *
	 * @since 4.4
	 */
	@FunctionalInterface
	public interface KeyspaceProvider {

		/**
		 * Use the current {@link CqlSession#getKeyspace() session keyspace}.
		 *
		 * @since 5.0
		 */
		static KeyspaceProvider session() {
			return KeyspaceProviders.SESSION_KEYSPACE;
		}

		/**
		 * Use the keyspace that is associated with the {@link CassandraPersistentEntity#getKeyspace() entity}.
		 *
		 * @since 5.0
		 */
		static KeyspaceProvider entity() {
			return KeyspaceProviders.SESSION_KEYSPACE;
		}

		/**
		 * Determine a {@link CqlIdentifier keyspace} for a given {@link CassandraPersistentEntity} and {@code tableName}.
		 *
		 * @param entity the persistent entity for which the operation is applied.
		 * @param tableName the table of the operation.
		 * @return a {@link CqlIdentifier keyspace} to use a dedicated keyspace for a
		 *         {@link com.datastax.oss.driver.api.core.cql.Statement} or {@code null} to use the default session
		 *         keyspace.
		 */
		@Nullable
		CqlIdentifier getKeyspace(CassandraPersistentEntity<?> entity, CqlIdentifier tableName);

	}

	/**
	 * Implementations of {@link KeyspaceProvider}.
	 */
	enum KeyspaceProviders implements KeyspaceProvider {

		/**
		 * Derive the keyspace from the given {@link CassandraPersistentEntity}.
		 */
		ENTITY_KEYSPACE {

			@Override
			public @Nullable CqlIdentifier getKeyspace(CassandraPersistentEntity<?> entity, CqlIdentifier tableName) {
				return entity.getKeyspace();
			}

		},

		/**
		 * Use the session's keyspace.
		 */
		SESSION_KEYSPACE {

			@Override
			public @Nullable CqlIdentifier getKeyspace(CassandraPersistentEntity<?> entity, CqlIdentifier tableName) {
				return null;
			}

		}

	}

	/**
	 * Strategy interface to compute {@link Columns column projection} to be selected for a query based on a given
	 * {@link EntityProjection}. A projection function can be composed into a higher-order function using
	 * {@link #otherwise(ProjectionFunction)} to form a chain of functions that are tried in sequence until one produces a
	 * non-empty {@link Columns} object.
	 *
	 * @since 5.0
	 */
	public interface ProjectionFunction {

		/**
		 * Compute {@link Columns} to be selected for a given {@link EntityProjection}. If the function cannot compute
		 * columns it should return an empty {@link Columns#empty() Columns} object.
		 *
		 * @param projection the projection to compute columns for.
		 * @param context the mapping context.
		 * @return the computed {@link Columns} or an empty {@link Columns#empty() Columns} object.
		 */
		Columns computeProjection(EntityProjection<?, ?> projection,
				MappingContext<? extends CassandraPersistentEntity<?>, ? extends CassandraPersistentProperty> context);

		/**
		 * Compose this projection function with a {@code fallback} function that is invoked when this function returns an
		 * empty {@link Columns} object.
		 *
		 * @param fallback the fallback function.
		 * @return the composed ProjectionFunction.
		 */
		default ProjectionFunction otherwise(ProjectionFunction fallback) {

			return (projection, mappingContext) -> {
				Columns columns = computeProjection(projection, mappingContext);
				return columns.isEmpty() ? fallback.computeProjection(projection, mappingContext) : columns;
			};
		}

		/**
		 * Empty projection function that returns {@link Columns#empty()}.
		 *
		 * @return a projection function that returns {@link Columns#empty()}.
		 */
		static ProjectionFunction empty() {
			return ProjectionFunctions.EMPTY;
		}

		/**
		 * Projection function that selects the primary key.
		 *
		 * @return a projection function that selects the primary key.
		 */
		static ProjectionFunction primaryKey() {
			return ProjectionFunctions.PRIMARY_KEY;
		}

		/**
		 * Projection function that selects mapped properties only.
		 *
		 * @return a projection function that selects mapped properties only.
		 */
		static ProjectionFunction mappedProperties() {
			return ProjectionFunctions.MAPPED_PROPERTIES;
		}

		/**
		 * Projection function that computes columns to be selected for DTO and closed interface projections.
		 *
		 * @return a projection function that derives columns from DTO and interface projections.
		 */
		static ProjectionFunction projecting() {
			return ProjectionFunctions.PROJECTION;
		}

	}

	/**
	 * Collection of projection functions.
	 *
	 * @since 5.0
	 */
	private enum ProjectionFunctions implements ProjectionFunction {

		/**
		 * No-op projection function.
		 */
		EMPTY {

			@Override
			public Columns computeProjection(EntityProjection<?, ?> projection,
					MappingContext<? extends CassandraPersistentEntity<?>, ? extends CassandraPersistentProperty> context) {
				return Columns.empty();
			}

			@Override
			public ProjectionFunction otherwise(ProjectionFunction fallback) {
				return fallback;
			}
		},

		/**
		 * Mapped properties only (no interface/DTO projections).
		 */
		MAPPED_PROPERTIES {

			@Override
			public Columns computeProjection(EntityProjection<?, ?> projection,
					MappingContext<? extends CassandraPersistentEntity<?>, ? extends CassandraPersistentProperty> context) {

				CassandraPersistentEntity<?> entity = context.getRequiredPersistentEntity(projection.getActualDomainType());

				List<String> properties = new ArrayList<>();

				for (CassandraPersistentProperty property : entity) {
					properties.add(property.getName());
				}

				return Columns.from(properties.toArray(new String[0]));
			}
		},

		/**
		 * Select the primary key.
		 */
		PRIMARY_KEY {

			@Override
			public Columns computeProjection(EntityProjection<?, ?> projection,
					MappingContext<? extends CassandraPersistentEntity<?>, ? extends CassandraPersistentProperty> context) {

				CassandraPersistentEntity<?> entity = context.getRequiredPersistentEntity(projection.getActualDomainType());

				List<String> primaryKeyColumns = new ArrayList<>();

				for (CassandraPersistentProperty property : entity) {
					if (property.isIdProperty()) {
						primaryKeyColumns.add(property.getName());
					}
				}

				return Columns.from(primaryKeyColumns.toArray(new String[0]));
			}
		},

		/**
		 * Compute the projection for DTO and closed interface projections.
		 */
		PROJECTION {

			@Override
			public Columns computeProjection(EntityProjection<?, ?> projection,
					MappingContext<? extends CassandraPersistentEntity<?>, ? extends CassandraPersistentProperty> context) {

				if (!projection.isProjection()) {
					return Columns.empty();
				}

				if (ClassUtils.isAssignable(projection.getDomainType().getType(), projection.getMappedType().getType())
						|| ClassUtils.isAssignable(Map.class, projection.getMappedType().getType()) //
						|| ClassUtils.isAssignable(ResultSet.class, projection.getMappedType().getType())) {
					return Columns.empty();
				}

				Columns columns = Columns.empty();

				if (projection.isClosedProjection()) {

					for (EntityProjection.PropertyProjection<?, ?> propertyProjection : projection) {
						columns = columns.include(propertyProjection.getPropertyPath().toDotPath());
					}
				} else {

					CassandraPersistentEntity<?> mapped = context.getRequiredPersistentEntity(projection.getMappedType());

					// DTO projections use merged metadata between domain type and result type
					PersistentPropertyTranslator translator = PersistentPropertyTranslator.create(
							context.getRequiredPersistentEntity(projection.getActualDomainType()),
							Predicates.negate(CassandraPersistentProperty::hasExplicitColumnName));

					for (CassandraPersistentProperty property : mapped) {
						columns = columns.include(translator.translate(property).getRequiredColumnName());
					}
				}

				return columns;
			}
		};
	}

}

---

8.2 spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/CassandraOperations.java

+62 — interface: selectJson, selectOneJson (Query section) and insertJson ×2 (entity section), full javadoc.

/*
 * Copyright 2016-present the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License")
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.springframework.data.cassandra.core;

import java.util.Iterator;
import java.util.List;
import java.util.stream.Stream;

import org.jspecify.annotations.Nullable;

import org.springframework.dao.DataAccessException;
import org.springframework.data.cassandra.core.convert.CassandraConverter;
import org.springframework.data.cassandra.core.cql.CqlOperations;
import org.springframework.data.cassandra.core.cql.QueryOptions;
import org.springframework.data.cassandra.core.cql.WriteOptions;
import org.springframework.data.cassandra.core.query.CassandraPageRequest;
import org.springframework.data.cassandra.core.query.Query;
import org.springframework.data.cassandra.core.query.Update;
import org.springframework.data.domain.Slice;

import com.datastax.oss.driver.api.core.CqlIdentifier;
import com.datastax.oss.driver.api.core.cql.BatchType;
import com.datastax.oss.driver.api.core.cql.ResultSet;
import com.datastax.oss.driver.api.core.cql.Statement;

/**
 * Interface specifying a basic set of Cassandra operations. Implemented by {@link CassandraTemplate}. Not often used
 * directly, but a useful option to enhance testability, as it can easily be mocked or stubbed.
 *
 * @author Alex Shvid
 * @author David Webb
 * @author Matthew Adams
 * @author Mark Paluch
 * @author Sam Lightfoot
 * @see CassandraTemplate
 * @see CqlOperations
 * @see Statement
 * @see InsertOptions
 * @see UpdateOptions
 */
public interface CassandraOperations extends FluentCassandraOperations {

	/**
	 * Returns a new {@link CassandraBatchOperations} using {@link BatchType#LOGGED}. Each
	 * {@link CassandraBatchOperations} instance can be executed only once, so you need to obtain new
	 * {@link CassandraBatchOperations} instances for each batch.
	 *
	 * @return a new {@link CassandraBatchOperations} associated with the given entity class.
	 * @see #batchOps(BatchType)
	 */
	default CassandraBatchOperations batchOps() {
		return batchOps(BatchType.LOGGED);
	}

	/**
	 * Returns a new {@link CassandraBatchOperations}. Each {@link CassandraBatchOperations} instance can be executed only
	 * once, so you need to obtain new {@link CassandraBatchOperations} instances for each batch.
	 *
	 * @param batchType must not be {@literal null}.
	 * @return a new {@link ReactiveCassandraBatchOperations} associated with the given entity class.
	 * @since 3.2.6
	 */
	CassandraBatchOperations batchOps(BatchType batchType);

	/**
	 * Expose the underlying {@link CqlOperations} to allow CQL operations.
	 *
	 * @return the underlying {@link CqlOperations}.
	 * @see CqlOperations
	 */
	CqlOperations getCqlOperations();

	/**
	 * Returns the underlying {@link CassandraConverter}.
	 *
	 * @return the underlying {@link CassandraConverter}.
	 */
	CassandraConverter getConverter();

	/**
	 * The table name used for the specified class by this template.
	 *
	 * @param entityClass the entity type must not be {@literal null}.
	 * @return the {@link CqlIdentifier}
	 */
	CqlIdentifier getTableName(Class<?> entityClass);

	// -------------------------------------------------------------------------
	// Methods dealing with static CQL
	// -------------------------------------------------------------------------

	/**
	 * Execute a {@code SELECT} query and convert the resulting items to a {@link List} of entities.
	 *
	 * @param cql must not be {@literal null}.
	 * @param entityClass the entity type must not be {@literal null}.
	 * @return the converted results
	 * @throws DataAccessException if there is any problem executing the query.
	 */
	<T> List<T> select(String cql, Class<T> entityClass) throws DataAccessException;

	/**
	 * Execute a {@code SELECT} query and convert the resulting items to a {@link Iterator} of entities.
	 * <p>
	 * Returns a {@link Iterator} that wraps the Cassandra {@link ResultSet}.
	 *
	 * @param <T> element return type.
	 * @param cql query to execute. Must not be empty or {@literal null}.
	 * @param entityClass Class type of the elements in the {@link Iterator} stream. Must not be {@literal null}.
	 * @return an {@link Iterator} (stream) over the elements in the query result set.
	 * @throws DataAccessException if there is any problem executing the query.
	 * @since 1.5
	 */
	<T> Stream<T> stream(String cql, Class<T> entityClass) throws DataAccessException;

	/**
	 * Execute a {@code SELECT} query and convert the resulting item to an entity.
	 *
	 * @param cql must not be {@literal null}.
	 * @param entityClass the entity type must not be {@literal null}.
	 * @return the converted object or {@literal null}.
	 * @throws DataAccessException if there is any problem executing the query.
	 */
	<T> @Nullable T selectOne(String cql, Class<T> entityClass) throws DataAccessException;

	// -------------------------------------------------------------------------
	// Methods dealing with com.datastax.oss.driver.api.core.cql.Statement
	// -------------------------------------------------------------------------

	/**
	 * Execute the given Cassandra {@link Statement}. Any errors that result from executing this command will be converted
	 * into Spring's DAO exception hierarchy.
	 *
	 * @param statement a Cassandra {@link Statement}, must not be {@literal null}.
	 * @return the {@link ResultSet}.
	 * @throws DataAccessException if there is any problem executing the query.
	 * @since 3.2
	 */
	ResultSet execute(Statement<?> statement) throws DataAccessException;

	/**
	 * Execute a {@code SELECT} query and convert the resulting items to a {@link List} of entities.
	 *
	 * @param statement must not be {@literal null}.
	 * @param entityClass the entity type must not be {@literal null}.
	 * @return the converted results
	 * @throws DataAccessException if there is any problem executing the query.
	 */
	<T> List<T> select(Statement<?> statement, Class<T> entityClass) throws DataAccessException;

	/**
	 * Execute a {@code SELECT} query with paging and convert the result set to a {@link Slice} of entities. A sliced
	 * query translates the effective {@link Statement#getPageSize()} to the page size.
	 *
	 * @param statement the CQL statement, must not be {@literal null}.
	 * @param entityClass the entity type must not be {@literal null}.
	 * @return the converted results
	 * @throws DataAccessException if there is any problem executing the query.
	 * @since 2.0
	 */
	<T> Slice<T> slice(Statement<?> statement, Class<T> entityClass) throws DataAccessException;

	/**
	 * Execute a {@code SELECT} query and convert the resulting items to a {@link Iterator} of entities.
	 * <p>
	 * Returns a {@link Iterator} that wraps the Cassandra {@link ResultSet}.
	 *
	 * @param <T> element return type.
	 * @param statement query to execute. Must not be empty or {@literal null}.
	 * @param entityClass Class type of the elements in the {@link Iterator} stream. Must not be {@literal null}.
	 * @return an {@link Iterator} (stream) over the elements in the query result set.
	 * @throws DataAccessException if there is any problem executing the query.
	 * @since 1.5
	 */
	<T> Stream<T> stream(Statement<?> statement, Class<T> entityClass) throws DataAccessException;

	/**
	 * Execute a {@code SELECT} query and convert the resulting item to an entity.
	 *
	 * @param statement must not be {@literal null}.
	 * @param entityClass the entity type must not be {@literal null}.
	 * @return the converted object or {@literal null}.
	 * @throws DataAccessException if there is any problem executing the query.
	 */
	<T> @Nullable T selectOne(Statement<?> statement, Class<T> entityClass) throws DataAccessException;

	// -------------------------------------------------------------------------
	// Methods dealing with org.springframework.data.cassandra.core.query.Query
	// -------------------------------------------------------------------------

	/**
	 * Execute a {@code SELECT} query and convert the resulting items to a {@link List} of entities.
	 *
	 * @param query must not be {@literal null}.
	 * @param entityClass the entity type must not be {@literal null}.
	 * @return the converted results
	 * @throws DataAccessException if there is any problem executing the query.
	 * @since 2.0
	 */
	<T> List<T> select(Query query, Class<T> entityClass) throws DataAccessException;

	/**
	 * Execute a {@code SELECT} query with paging and convert the result set to a {@link Slice} of entities.
	 *
	 * @param query the query object used to create a CQL statement, must not be {@literal null}.
	 * @param entityClass the entity type must not be {@literal null}.
	 * @return the converted results
	 * @throws DataAccessException if there is any problem executing the query.
	 * @since 2.0
	 * @see CassandraPageRequest
	 */
	<T> Slice<T> slice(Query query, Class<T> entityClass) throws DataAccessException;

	/**
	 * Execute a {@code SELECT} query and convert the resulting items to a {@link Iterator} of entities.
	 * <p>
	 * Returns a {@link Iterator} that wraps the Cassandra {@link ResultSet}.
	 *
	 * @param <T> element return type.
	 * @param query query to execute. Must not be empty or {@literal null}.
	 * @param entityClass Class type of the elements in the {@link Iterator} stream. Must not be {@literal null}.
	 * @return an {@link Iterator} (stream) over the elements in the query result set.
	 * @throws DataAccessException if there is any problem executing the query.
	 * @since 2.0
	 */
	<T> Stream<T> stream(Query query, Class<T> entityClass) throws DataAccessException;

	/**
	 * Execute a {@code SELECT} query and convert the resulting item to an entity.
	 *
	 * @param query must not be {@literal null}.
	 * @param entityClass the entity type must not be {@literal null}.
	 * @return the converted object or {@literal null}.
	 * @throws DataAccessException if there is any problem executing the query.
	 * @since 2.0
	 */
	<T> @Nullable T selectOne(Query query, Class<T> entityClass) throws DataAccessException;

	/**
	 * Execute a {@code SELECT JSON} query and return the resulting rows as their JSON representation. Each returned
	 * {@link String} contains a JSON-encoded row in which the keys correspond to column names as defined by the
	 * Cassandra {@code SELECT JSON} semantics.
	 *
	 * @param query must not be {@literal null}.
	 * @param entityClass the entity type used to resolve the table name, must not be {@literal null}.
	 * @return a {@link List} of JSON-encoded rows.
	 * @throws DataAccessException if there is any problem executing the query.
	 * @since 5.2
	 */
	List<String> selectJson(Query query, Class<?> entityClass) throws DataAccessException;

	/**
	 * Execute a {@code SELECT JSON} query and return the resulting row as its JSON representation. The returned
	 * {@link String} contains a JSON-encoded row in which the keys correspond to column names as defined by the
	 * Cassandra {@code SELECT JSON} semantics.
	 *
	 * @param query must not be {@literal null}.
	 * @param entityClass the entity type used to resolve the table name, must not be {@literal null}.
	 * @return the JSON-encoded row or {@literal null}.
	 * @throws DataAccessException if there is any problem executing the query.
	 * @since 5.2
	 */
	@Nullable String selectOneJson(Query query, Class<?> entityClass) throws DataAccessException;

	/**
	 * Update the queried entities and return {@literal true} if the update was applied.
	 *
	 * @param query must not be {@literal null}.
	 * @param update must not be {@literal null}.
	 * @param entityClass the entity type must not be {@literal null}.
	 * @throws DataAccessException if there is any problem executing the query.
	 */
	boolean update(Query query, Update update, Class<?> entityClass) throws DataAccessException;

	/**
	 * Remove entities (rows)/columns from the table by {@link Query}.
	 *
	 * @param query must not be {@literal null}.
	 * @param entityClass the entity type must not be {@literal null}.
	 * @throws DataAccessException if there is any problem executing the query.
	 */
	boolean delete(Query query, Class<?> entityClass) throws DataAccessException;

	// -------------------------------------------------------------------------
	// Methods dealing with entities
	// -------------------------------------------------------------------------

	/**
	 * Returns the number of rows for the given entity class.
	 *
	 * @param entityClass {@link Class type} of the entity; must not be {@literal null}.
	 * @return the number of existing entities.
	 * @throws DataAccessException if any problem occurs while executing the query.
	 */
	long count(Class<?> entityClass) throws DataAccessException;

	/**
	 * Returns the number of rows for the given entity class applying {@link Query}. This overridden method allows users
	 * to further refine the selection criteria using a {@link Query} predicate to determine how many entities of the
	 * given {@link Class type} match the criteria.
	 *
	 * @param query user-defined count {@link Query} to execute; must not be {@literal null}.
	 * @param entityClass {@link Class type} of the entity; must not be {@literal null}.
	 * @return the number of existing entities.
	 * @throws DataAccessException if any problem occurs while executing the query.
	 * @since 2.1
	 */
	long count(Query query, Class<?> entityClass) throws DataAccessException;

	/**
	 * Determine whether a row of {@code entityClass} with the given {@code id} exists.
	 *
	 * @param id Id value. For single primary keys it's the plain value. For composite primary keys either, it's an
	 *          instance of either {@link org.springframework.data.cassandra.core.mapping.PrimaryKeyClass} or
	 *          {@link org.springframework.data.cassandra.core.mapping.MapId}. Must not be {@literal null}.
	 * @param entityClass {@link Class type} of the entity; must not be {@literal null}.
	 * @return {@literal true} if the object exists.
	 * @throws DataAccessException if any problem occurs while executing the query.
	 */
	boolean exists(Object id, Class<?> entityClass) throws DataAccessException;

	/**
	 * Determine whether the result for {@code entityClass} {@link Query} yields at least one row.
	 *
	 * @param query user-defined exists {@link Query} to execute; must not be {@literal null}.
	 * @param entityClass {@link Class type} of the entity; must not be {@literal null}.
	 * @return {@literal true} if the object exists.
	 * @throws DataAccessException if any problem occurs while executing the query.
	 * @since 2.1
	 */
	boolean exists(Query query, Class<?> entityClass) throws DataAccessException;

	/**
	 * Execute the Select by {@code id} for the given {@code entityClass}.
	 *
	 * @param id the Id value. For single primary keys it's the plain value. For composite primary keys either the
	 *          {@link org.springframework.data.cassandra.core.mapping.PrimaryKeyClass} or
	 *          {@link org.springframework.data.cassandra.core.mapping.MapId}. Must not be {@literal null}.
	 * @param entityClass the entity type must not be {@literal null}.
	 * @return the converted object or {@literal null}.
	 * @throws DataAccessException if there is any problem executing the query.
	 */
	<T> @Nullable T selectOneById(Object id, Class<T> entityClass) throws DataAccessException;

	/**
	 * Insert the given entity and return the entity if the insert was applied.
	 *
	 * @param entity The entity to insert, must not be {@literal null}.
	 * @return the inserted entity.
	 * @throws DataAccessException if there is any problem executing the query.
	 */
	<T> T insert(T entity) throws DataAccessException;

	/**
	 * Insert the given entity applying {@link WriteOptions} and return the entity if the insert was applied.
	 *
	 * @param entity The entity to insert, must not be {@literal null}.
	 * @param options must not be {@literal null}.
	 * @return the {@link EntityWriteResult} for this operation.
	 * @throws DataAccessException if there is any problem executing the query.
	 * @see InsertOptions#empty()
	 */
	<T> EntityWriteResult<T> insert(T entity, InsertOptions options) throws DataAccessException;

	/**
	 * Insert the given JSON payload into the table of {@code entityClass} using an {@code INSERT JSON} statement. The
	 * JSON keys are expected to map to column names as defined by the Cassandra {@code INSERT JSON} semantics. Columns
	 * omitted from the JSON payload are left unset ({@code DEFAULT UNSET}).
	 * <p>
	 * Note that mapping between the JSON payload and the table happens within Cassandra so entity lifecycle events and
	 * callbacks are not invoked.
	 *
	 * @param json the JSON payload to insert, must not be {@literal null} or empty.
	 * @param entityClass the entity type used to resolve the table name, must not be {@literal null}.
	 * @return the {@link WriteResult} for this operation.
	 * @throws DataAccessException if there is any problem executing the query.
	 * @since 5.2
	 */
	WriteResult insertJson(String json, Class<?> entityClass) throws DataAccessException;

	/**
	 * Insert the given JSON payload into the table of {@code entityClass} using an {@code INSERT JSON} statement
	 * applying {@link InsertOptions}. The JSON keys are expected to map to column names as defined by the Cassandra
	 * {@code INSERT JSON} semantics. Columns omitted from the JSON payload are left unset ({@code DEFAULT UNSET}) unless
	 * {@link InsertOptions#isInsertNulls()} is set, in which case omitted columns are inserted as {@code null}
	 * ({@code DEFAULT NULL}).
	 * <p>
	 * Note that mapping between the JSON payload and the table happens within Cassandra so entity lifecycle events and
	 * callbacks are not invoked.
	 *
	 * @param json the JSON payload to insert, must not be {@literal null} or empty.
	 * @param entityClass the entity type used to resolve the table name, must not be {@literal null}.
	 * @param options must not be {@literal null}.
	 * @return the {@link WriteResult} for this operation.
	 * @throws DataAccessException if there is any problem executing the query.
	 * @see InsertOptions#empty()
	 * @since 5.2
	 */
	WriteResult insertJson(String json, Class<?> entityClass, InsertOptions options) throws DataAccessException;

	/**
	 * Update the given entity and return the entity if the update was applied.
	 *
	 * @param entity The entity to update, must not be {@literal null}.
	 * @return the updated entity.
	 * @throws DataAccessException if there is any problem executing the query.
	 */
	<T> T update(T entity) throws DataAccessException;

	/**
	 * Update the given entity applying {@link WriteOptions} and return the entity if the update was applied.
	 *
	 * @param entity The entity to update, must not be {@literal null}.
	 * @param options must not be {@literal null}.
	 * @return the {@link EntityWriteResult} for this operation.
	 * @throws DataAccessException if there is any problem executing the query.
	 * @see UpdateOptions#empty()
	 */
	<T> EntityWriteResult<T> update(T entity, UpdateOptions options) throws DataAccessException;

	/**
	 * Delete the given entity and return the entity if the delete statement was applied.
	 *
	 * @param entity must not be {@literal null}.
	 * @throws DataAccessException if there is any problem executing the query.
	 */
	void delete(Object entity) throws DataAccessException;

	/**
	 * Delete the given entity applying {@link QueryOptions} and return the entity if the delete statement was applied.
	 *
	 * @param entity must not be {@literal null}.
	 * @param options must not be {@literal null}.
	 * @return the {@link WriteResult} for this operation.
	 * @throws DataAccessException if there is any problem executing the query.
	 * @see QueryOptions#empty()
	 */
	WriteResult delete(Object entity, QueryOptions options) throws DataAccessException;

	/**
	 * Delete the given entity applying {@link DeleteOptions} and return the entity if the delete statement was applied.
	 *
	 * @param entity must not be {@literal null}.
	 * @param options must not be {@literal null}.
	 * @return the {@link WriteResult} for this operation.
	 * @throws DataAccessException if there is any problem executing the query.
	 * @see DeleteOptions#empty()
	 * @since 2.2
	 */
	default WriteResult delete(Object entity, DeleteOptions options) throws DataAccessException {
		return delete(entity, (QueryOptions) options);
	}

	/**
	 * Remove the given object from the table by id.
	 *
	 * @param id the Id value. For single primary keys it's the plain value. For composite primary keys either the
	 *          {@link org.springframework.data.cassandra.core.mapping.PrimaryKeyClass} or
	 *          {@link org.springframework.data.cassandra.core.mapping.MapId}. Must not be {@literal null}.
	 * @param entityClass the entity type must not be {@literal null}.
	 * @throws DataAccessException if there is any problem executing the query.
	 */
	boolean deleteById(Object id, Class<?> entityClass) throws DataAccessException;

	/**
	 * Execute a {@code TRUNCATE} query to remove all entities of a given class.
	 *
	 * @param entityClass the entity type must not be {@literal null}.
	 * @throws DataAccessException if there is any problem executing the query.
	 */
	void truncate(Class<?> entityClass) throws DataAccessException;

}

---

8.3 spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/CassandraTemplate.java

+38 — implementations: selectJson/selectOneJson via SingleColumnRowMapper(String), insertJson via doExecute → WriteResult; import JsonInsert.

/*
 * Copyright 2016-present the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.springframework.data.cassandra.core;

import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Stream;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.jspecify.annotations.Nullable;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.ApplicationEventPublisherAware;
import org.springframework.dao.DataAccessException;
import org.springframework.dao.support.DataAccessUtils;
import org.springframework.data.cassandra.SessionFactory;
import org.springframework.data.cassandra.core.EntityOperations.AdaptibleEntity;
import org.springframework.data.cassandra.core.convert.CassandraConverter;
import org.springframework.data.cassandra.core.convert.MappingCassandraConverter;
import org.springframework.data.cassandra.core.cql.*;
import org.springframework.data.cassandra.core.cql.session.DefaultSessionFactory;
import org.springframework.data.cassandra.core.cql.util.StatementBuilder;
import org.springframework.data.cassandra.core.mapping.CassandraPersistentEntity;
import org.springframework.data.cassandra.core.mapping.SimpleUserTypeResolver;
import org.springframework.data.cassandra.core.mapping.UserTypeResolver;
import org.springframework.data.cassandra.core.mapping.event.AfterDeleteEvent;
import org.springframework.data.cassandra.core.mapping.event.AfterLoadEvent;
import org.springframework.data.cassandra.core.mapping.event.AfterSaveEvent;
import org.springframework.data.cassandra.core.mapping.event.BeforeConvertCallback;
import org.springframework.data.cassandra.core.mapping.event.BeforeDeleteEvent;
import org.springframework.data.cassandra.core.mapping.event.BeforeSaveCallback;
import org.springframework.data.cassandra.core.mapping.event.BeforeSaveEvent;
import org.springframework.data.cassandra.core.mapping.event.CassandraMappingEvent;
import org.springframework.data.cassandra.core.query.Query;
import org.springframework.data.domain.Slice;
import org.springframework.data.mapping.callback.EntityCallbacks;
import org.springframework.util.Assert;

import com.datastax.oss.driver.api.core.CqlIdentifier;
import com.datastax.oss.driver.api.core.CqlSession;
import com.datastax.oss.driver.api.core.DriverException;
import com.datastax.oss.driver.api.core.config.DefaultDriverOption;
import com.datastax.oss.driver.api.core.context.DriverContext;
import com.datastax.oss.driver.api.core.cql.BatchType;
import com.datastax.oss.driver.api.core.cql.BoundStatement;
import com.datastax.oss.driver.api.core.cql.PreparedStatement;
import com.datastax.oss.driver.api.core.cql.ResultSet;
import com.datastax.oss.driver.api.core.cql.SimpleStatement;
import com.datastax.oss.driver.api.core.cql.Statement;
import com.datastax.oss.driver.api.querybuilder.QueryBuilder;
import com.datastax.oss.driver.api.querybuilder.delete.Delete;
import com.datastax.oss.driver.api.querybuilder.insert.Insert;
import com.datastax.oss.driver.api.querybuilder.insert.JsonInsert;
import com.datastax.oss.driver.api.querybuilder.insert.RegularInsert;
import com.datastax.oss.driver.api.querybuilder.select.Select;
import com.datastax.oss.driver.api.querybuilder.truncate.Truncate;
import com.datastax.oss.driver.api.querybuilder.update.Update;

/**
 * Primary implementation of {@link CassandraOperations}. It simplifies the use of Cassandra usage and helps to avoid
 * common errors. It executes core Cassandra workflow. This class executes CQL queries or updates, initiating iteration
 * over {@link ResultSet} and catching Cassandra exceptions and translating them to the generic, more informative
 * exception hierarchy defined in the {@code org.springframework.dao} package.
 * <p>
 * Can be used within a service implementation via direct instantiation with a {@link CqlSession} reference, or get
 * prepared in an application context and given to services as bean reference.
 * <p>
 * This class supports the use of prepared statements when enabling {@link #setUsePreparedStatements(boolean)}. All
 * statements created by methods of this class (such as {@link #select(Query, Class)} or
 * {@link #update(Query, org.springframework.data.cassandra.core.query.Update, Class)} will be executed as prepared
 * statements. Also, statements accepted by methods (such as {@link #select(String, Class)} or
 * {@link #select(Statement, Class) and others}) will be prepared prior to execution. Note that {@link Statement}
 * objects passed to methods must be {@link SimpleStatement} so that these can be prepared.
 * <p>
 * Note: The {@link CqlSession} should always be configured as a bean in the application context, in the first case
 * given to the service directly, in the second case to the prepared template.
 *
 * @author Mark Paluch
 * @author John Blum
 * @author Lukasz Antoniak
 * @author Sam Lightfoot
 * @see org.springframework.data.cassandra.core.CassandraOperations
 * @since 2.0
 */
public class CassandraTemplate implements CassandraOperations, ApplicationEventPublisherAware, ApplicationContextAware {

	private final Log log = LogFactory.getLog(getClass());

	private final CqlOperations cqlOperations;

	private final EntityLifecycleEventDelegate eventDelegate;

	private final CassandraConverter converter;

	private final StatementFactory statementFactory;

	private final EntityOperations entityOperations;

	private final QueryOperations queryOperations;

	private @Nullable EntityCallbacks entityCallbacks;

	private boolean usePreparedStatements = true;

	/**
	 * Creates an instance of {@link CassandraTemplate} initialized with the given {@link CqlSession} and a default
	 * {@link MappingCassandraConverter}.
	 *
	 * @param session {@link CqlSession} used to interact with Cassandra; must not be {@literal null}.
	 * @see CassandraConverter
	 * @see CqlSession
	 */
	public CassandraTemplate(CqlSession session) {
		this(session, createConverter(session));
	}

	/**
	 * Creates an instance of {@link CassandraTemplate} initialized with the given {@link CqlSession} and
	 * {@link CassandraConverter}.
	 *
	 * @param session {@link CqlSession} used to interact with Cassandra; must not be {@literal null}.
	 * @param converter {@link CassandraConverter} used to convert between Java and Cassandra types; must not be
	 *          {@literal null}.
	 * @see CassandraConverter
	 * @see CqlSession
	 */
	public CassandraTemplate(CqlSession session, CassandraConverter converter) {
		this(new DefaultSessionFactory(session), converter);
	}

	/**
	 * Creates an instance of {@link CassandraTemplate} initialized with the given {@link SessionFactory} and
	 * {@link CassandraConverter}.
	 *
	 * @param sessionFactory {@link SessionFactory} used to interact with Cassandra; must not be {@literal null}.
	 * @param converter {@link CassandraConverter} used to convert between Java and Cassandra types; must not be
	 *          {@literal null}.
	 * @see CassandraConverter
	 * @see SessionFactory
	 */
	public CassandraTemplate(SessionFactory sessionFactory, CassandraConverter converter) {
		this(new CqlTemplate(sessionFactory), converter);
	}

	/**
	 * Creates an instance of {@link CassandraTemplate} initialized with the given {@link CqlOperations} and
	 * {@link CassandraConverter}.
	 *
	 * @param cqlOperations {@link CqlOperations} used to interact with Cassandra; must not be {@literal null}.
	 * @param converter {@link CassandraConverter} used to convert between Java and Cassandra types; must not be
	 *          {@literal null}.
	 * @see CassandraConverter
	 * @see CqlSession
	 */
	public CassandraTemplate(CqlOperations cqlOperations, CassandraConverter converter) {

		Assert.notNull(cqlOperations, "CqlOperations must not be null");
		Assert.notNull(converter, "CassandraConverter must not be null");

		this.converter = converter;
		this.eventDelegate = new EntityLifecycleEventDelegate();
		this.cqlOperations = cqlOperations;
		this.statementFactory = new StatementFactory(converter);
		this.entityOperations = new EntityOperations(converter);
		this.queryOperations = new QueryOperations(converter, this.statementFactory, this.eventDelegate);
	}

	@Override
	public CassandraBatchOperations batchOps(BatchType batchType) {
		return new CassandraBatchTemplate(this, batchType);
	}

	@Override
	public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
		this.eventDelegate.setPublisher(applicationEventPublisher);
	}

	@Override
	public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {

		if (entityCallbacks == null) {
			setEntityCallbacks(EntityCallbacks.create(applicationContext));
		}
	}

	/**
	 * Configure {@link EntityCallbacks} to pre-/post-process entities during persistence operations.
	 *
	 * @param entityCallbacks
	 */
	public void setEntityCallbacks(@Nullable EntityCallbacks entityCallbacks) {
		this.entityCallbacks = entityCallbacks;
	}

	/**
	 * Configure whether lifecycle events such as {@link AfterLoadEvent}, {@link BeforeSaveEvent}, etc. should be
	 * published or whether emission should be suppressed. Enabled by default.
	 *
	 * @param enabled {@code true} to enable entity lifecycle events; {@code false} to disable entity lifecycle events.
	 * @since 4.0
	 * @see CassandraMappingEvent
	 */
	public void setEntityLifecycleEventsEnabled(boolean enabled) {
		this.eventDelegate.setEventsEnabled(enabled);
	}

	@Override
	public CqlOperations getCqlOperations() {
		return this.cqlOperations;
	}

	@Override
	public CassandraConverter getConverter() {
		return this.converter;
	}

	/**
	 * Returns the {@link StatementFactory} used by this template to construct and run Cassandra CQL statements.
	 *
	 * @return the {@link StatementFactory} used by this template to construct and run Cassandra CQL statements.
	 * @see org.springframework.data.cassandra.core.StatementFactory
	 * @since 2.1
	 */
	public StatementFactory getStatementFactory() {
		return this.statementFactory;
	}

	/**
	 * Returns whether this instance is configured to use {@link PreparedStatement prepared statements}. If enabled
	 * (default), then all persistence methods (such as {@link #select}, {@link #update}, and others) will make use of
	 * prepared statements. Note that methods accepting a {@link Statement} must be called with {@link SimpleStatement}
	 * instances to participate in statement preparation.
	 *
	 * @return {@literal true} if prepared statements usage is enabled; {@literal false} otherwise.
	 * @since 3.2
	 */
	public boolean isUsePreparedStatements() {
		return usePreparedStatements;
	}

	/**
	 * Enable/disable {@link PreparedStatement prepared statements} usage. If enabled (default), then all persistence
	 * methods (such as {@link #select}, {@link #update}, and others) will make use of prepared statements. Note that
	 * methods accepting a {@link Statement} must be called with {@link SimpleStatement} instances to participate in
	 * statement preparation.
	 *
	 * @param usePreparedStatements whether to use prepared statements.
	 * @since 3.2
	 */
	public void setUsePreparedStatements(boolean usePreparedStatements) {
		this.usePreparedStatements = usePreparedStatements;
	}

	@Override
	public CqlIdentifier getTableName(Class<?> entityClass) {
		return queryOperations.getTableName(entityClass);
	}

	// -------------------------------------------------------------------------
	// Methods dealing with static CQL
	// -------------------------------------------------------------------------

	@Override
	public <T> List<T> select(String cql, Class<T> entityClass) {

		Assert.hasText(cql, "CQL must not be empty");

		return select(SimpleStatement.newInstance(cql), entityClass);
	}

	@Override
	public <T> @Nullable T selectOne(String cql, Class<T> entityClass) {

		Assert.hasText(cql, "CQL must not be empty");
		Assert.notNull(entityClass, "Entity type must not be null");

		return selectOne(SimpleStatement.newInstance(cql), entityClass);
	}

	@Override
	public <T> Stream<T> stream(String cql, Class<T> entityClass) throws DataAccessException {

		Assert.hasText(cql, "CQL must not be empty");
		Assert.notNull(entityClass, "Entity type must not be null");

		return stream(SimpleStatement.newInstance(cql), entityClass);
	}

	// -------------------------------------------------------------------------
	// Methods dealing with com.datastax.oss.driver.api.core.cql.Statement
	// -------------------------------------------------------------------------

	@Override
	public ResultSet execute(Statement<?> statement) {

		Assert.notNull(statement, "Statement must not be null");

		return doQueryForResultSet(statement);
	}

	@Override
	public <T> List<T> select(Statement<?> statement, Class<T> entityClass) {

		Assert.notNull(statement, "Statement must not be null");
		Assert.notNull(entityClass, "Entity type must not be null");

		RowMapper<T> rowMapper = queryOperations.getRowMapper(entityClass, statement);
		return doQuery(statement, rowMapper);
	}

	@Override
	public <T> @Nullable T selectOne(Statement<?> statement, Class<T> entityClass) {

		List<T> result = select(statement, entityClass);
		return result.isEmpty() ? null : result.get(0);
	}

	@Override
	public <T> Slice<T> slice(Statement<?> statement, Class<T> entityClass) {

		Assert.notNull(statement, "Statement must not be null");
		Assert.notNull(entityClass, "Entity type must not be null");

		RowMapper<T> rowMapper = queryOperations.getRowMapper(entityClass, statement);
		return doSlice(statement, rowMapper);
	}

	@Override
	public <T> Stream<T> stream(Statement<?> statement, Class<T> entityClass) throws DataAccessException {

		Assert.notNull(statement, "Statement must not be null");
		Assert.notNull(entityClass, "Entity type must not be null");

		RowMapper<T> rowMapper = queryOperations.getRowMapper(entityClass, statement);
		return doStream(statement, rowMapper);
	}

	// -------------------------------------------------------------------------
	// Methods dealing with org.springframework.data.cassandra.core.query.Query
	// -------------------------------------------------------------------------

	@Override
	public <T> List<T> select(Query query, Class<T> entityClass) throws DataAccessException {

		Assert.notNull(query, "Query must not be null");
		Assert.notNull(entityClass, "Entity type must not be null");

		return queryOperations.select(entityClass).matching(query).select(this::doQuery);
	}

	ResultSet doSelectResultSet(Query query, Class<?> entityClass, CqlIdentifier tableName) {

		CassandraPersistentEntity<?> entity = getRequiredPersistentEntity(entityClass);

		StatementBuilder<Select> select = getStatementFactory().select(query, entity, tableName);
		SimpleStatement statement = select.build();

		return queryForResultSet(statement);
	}

	ResultSet queryForResultSet(Statement<?> statement) {

		if (PreparedStatementDelegate.canPrepare(isUsePreparedStatements(), statement, log)) {

			PreparedStatementHandler statementHandler = createPreparedStatementHandler(statement);
			return getCqlOperations().query(statementHandler, statementHandler, resultSet -> resultSet);
		}

		return getCqlOperations().queryForResultSet(statement);
	}

	@Override
	public <T> @Nullable T selectOne(Query query, Class<T> entityClass) throws DataAccessException {

		List<T> result = select(query, entityClass);
		return result.isEmpty() ? null : result.get(0);
	}

	@Override
	public List<String> selectJson(Query query, Class<?> entityClass) throws DataAccessException {

		Assert.notNull(query, "Query must not be null");
		Assert.notNull(entityClass, "Entity type must not be null");

		StatementBuilder<Select> select = getStatementFactory().selectJson(query,
				getRequiredPersistentEntity(entityClass), getTableName(entityClass));

		return doQuery(select.build(), SingleColumnRowMapper.newInstance(String.class));
	}

	@Override
	public @Nullable String selectOneJson(Query query, Class<?> entityClass) throws DataAccessException {

		List<String> result = selectJson(query, entityClass);
		return result.isEmpty() ? null : result.get(0);
	}

	@Override
	public <T> Slice<T> slice(Query query, Class<T> entityClass) throws DataAccessException {

		Assert.notNull(query, "Query must not be null");
		Assert.notNull(entityClass, "Entity type must not be null");

		return queryOperations.select(entityClass).matching(query).select(this::doSlice);
	}

	@Override
	public <T> Stream<T> stream(Query query, Class<T> entityClass) throws DataAccessException {

		Assert.notNull(query, "Query must not be null");
		Assert.notNull(entityClass, "Entity type must not be null");

		return queryOperations.select(entityClass).matching(query).select(this::doStream);
	}

	@Override
	public boolean update(Query query, org.springframework.data.cassandra.core.query.Update update, Class<?> entityClass)
			throws DataAccessException {

		Assert.notNull(query, "Query must not be null");
		Assert.notNull(update, "Update must not be null");
		Assert.notNull(entityClass, "Entity type must not be null");

		StatementBuilder<Update> updateStatement = getStatementFactory().update(query, update,
				getRequiredPersistentEntity(entityClass));

		return doExecute(updateStatement.build()).wasApplied();
	}

	WriteResult doUpdate(Query query, org.springframework.data.cassandra.core.query.Update update, Class<?> entityClass,
			CqlIdentifier tableName) {

		StatementBuilder<Update> updateStatement = getStatementFactory().update(query, update,
				getRequiredPersistentEntity(entityClass), tableName);

		return doExecute(updateStatement.build());
	}

	@Override
	public boolean delete(Query query, Class<?> entityClass) throws DataAccessException {

		Assert.notNull(query, "Query must not be null");
		Assert.notNull(entityClass, "Entity type must not be null");

		WriteResult result = doDelete(query, entityClass, getTableName(entityClass));

		return result.wasApplied();
	}

	WriteResult doDelete(Query query, Class<?> entityClass, CqlIdentifier tableName) {

		StatementBuilder<Delete> delete = getStatementFactory().delete(query, getRequiredPersistentEntity(entityClass),
				tableName);
		SimpleStatement statement = delete.build();

		maybeEmitEvent(() -> new BeforeDeleteEvent<>(statement, entityClass, tableName));

		WriteResult writeResult = doExecute(statement);

		maybeEmitEvent(() -> new AfterDeleteEvent<>(statement, entityClass, tableName));

		return writeResult;
	}

	// -------------------------------------------------------------------------
	// Methods dealing with entities
	// -------------------------------------------------------------------------

	@Override
	public long count(Class<?> entityClass) {

		Assert.notNull(entityClass, "Entity type must not be null");

		return count(Query.empty(), entityClass);
	}

	@Override
	public long count(Query query, Class<?> entityClass) throws DataAccessException {

		Assert.notNull(query, "Query must not be null");
		Assert.notNull(entityClass, "Entity type must not be null");

		return doCount(query, entityClass, getTableName(entityClass));
	}

	long doCount(Query query, Class<?> entityClass, CqlIdentifier tableName) {

		StatementBuilder<Select> countStatement = getStatementFactory().count(query,
				getRequiredPersistentEntity(entityClass), tableName);

		return doQueryForRequiredObject(countStatement.build(), Long.class);
	}

	@Override
	public boolean exists(Object id, Class<?> entityClass) {

		Assert.notNull(id, "Id must not be null");
		Assert.notNull(entityClass, "Entity type must not be null");

		return queryOperations.select(entityClass).matchingId(id)
				.exists((statement) -> doExecute(statement, rs -> rs.one() != null));
	}

	@Override
	public boolean exists(Query query, Class<?> entityClass) throws DataAccessException {

		Assert.notNull(query, "Query must not be null");
		Assert.notNull(entityClass, "Entity type must not be null");

		return doExists(query, entityClass, getTableName(entityClass));
	}

	boolean doExists(Query query, Class<?> entityClass, CqlIdentifier tableName) {

		return queryOperations.select(entityClass, tableName).matching(query)
				.exists((statement) -> doExecute(statement, rs -> rs.one() != null));
	}

	@Override
	public <T> @Nullable T selectOneById(Object id, Class<T> entityClass) {

		Assert.notNull(id, "Id must not be null");
		Assert.notNull(entityClass, "Entity type must not be null");

		List<T> select = queryOperations.select(entityClass).matchingId(id).select(this::doQuery);

		return DataAccessUtils.singleResult(select);
	}

	@Override
	public <T> T insert(T entity) {
		return insert(entity, InsertOptions.empty()).getEntity();
	}

	@Override
	public <T> EntityWriteResult<T> insert(T entity, InsertOptions options) {

		Assert.notNull(entity, "Entity must not be null");
		Assert.notNull(options, "InsertOptions must not be null");

		return doInsert(entity, options, getTableName(entity.getClass()));
	}

	<T> EntityWriteResult<T> doInsert(T entity, WriteOptions options, CqlIdentifier tableName) {

		AdaptibleEntity<T> source = entityOperations.forEntity(maybeCallBeforeConvert(entity, tableName),
				getConverter().getConversionService());

		T entityToUse = source.isVersionedEntity() ? source.initializeVersionProperty() : source.getBean();

		StatementBuilder<RegularInsert> builder = getStatementFactory().insert(entityToUse, options,
				source.getPersistentEntity(), tableName);

		if (source.isVersionedEntity()) {

			builder.apply(Insert::ifNotExists);
			return doInsertVersioned(builder.build(), entityToUse, source, tableName);
		}

		return doInsert(builder.build(), entityToUse, tableName);
	}

	private <T> EntityWriteResult<T> doInsertVersioned(SimpleStatement insert, T entity, AdaptibleEntity<T> source,
			CqlIdentifier tableName) {

		return executeSave(entity, tableName, insert, result -> {

			if (!result.wasApplied()) {
				throw OptimisticLockingUtils.insertFailed(source);
			}
		});
	}

	private <T> EntityWriteResult<T> doInsert(SimpleStatement insert, T entity, CqlIdentifier tableName) {
		return executeSave(entity, tableName, insert);
	}

	@Override
	public WriteResult insertJson(String json, Class<?> entityClass) {
		return insertJson(json, entityClass, InsertOptions.empty());
	}

	@Override
	public WriteResult insertJson(String json, Class<?> entityClass, InsertOptions options) {

		Assert.hasText(json, "JSON must not be empty");
		Assert.notNull(entityClass, "Entity type must not be null");
		Assert.notNull(options, "InsertOptions must not be null");

		StatementBuilder<JsonInsert> builder = getStatementFactory().insertJson(json, options,
				getRequiredPersistentEntity(entityClass), getTableName(entityClass));

		return doExecute(builder.build());
	}

	@Override
	public <T> T update(T entity) {
		return update(entity, UpdateOptions.empty()).getEntity();
	}

	@Override
	public <T> EntityWriteResult<T> update(T entity, UpdateOptions options) {

		Assert.notNull(entity, "Entity must not be null");
		Assert.notNull(options, "UpdateOptions must not be null");

		AdaptibleEntity<T> source = entityOperations.forEntity(entity, getConverter().getConversionService());
		CassandraPersistentEntity<?> persistentEntity = getRequiredPersistentEntity(entity.getClass());
		CqlIdentifier tableName = persistentEntity.getTableName();

		T entityToUpdate = maybeCallBeforeConvert(entity, tableName);

		return source.isVersionedEntity() ? doUpdateVersioned(entityToUpdate, options, tableName, persistentEntity)
				: doUpdate(entityToUpdate, options, tableName, persistentEntity);
	}

	private <T> EntityWriteResult<T> doUpdateVersioned(T entity, UpdateOptions options, CqlIdentifier tableName,
			CassandraPersistentEntity<?> persistentEntity) {

		AdaptibleEntity<T> source = entityOperations.forEntity(entity, getConverter().getConversionService());

		Number previousVersion = source.getVersion();
		T toSave = source.incrementVersion();

		StatementBuilder<Update> builder = getStatementFactory().update(toSave, options, persistentEntity, tableName);
		SimpleStatement update = source.appendVersionCondition(builder, previousVersion).build();

		return executeSave(toSave, tableName, update, result -> {

			if (!result.wasApplied()) {
				throw OptimisticLockingUtils.updateFailed(source);
			}
		});
	}

	private <T> EntityWriteResult<T> doUpdate(T entity, UpdateOptions options, CqlIdentifier tableName,
			CassandraPersistentEntity<?> persistentEntity) {

		StatementBuilder<Update> builder = getStatementFactory().update(entity, options, persistentEntity, tableName);

		return executeSave(entity, tableName, builder.build());
	}

	@Override
	public void delete(Object entity) {
		delete(entity, QueryOptions.empty());
	}

	@Override
	public WriteResult delete(Object entity, QueryOptions options) {

		Assert.notNull(entity, "Entity must not be null");
		Assert.notNull(options, "QueryOptions must not be null");

		AdaptibleEntity<Object> source = entityOperations.forEntity(entity, getConverter().getConversionService());
		CassandraPersistentEntity<?> persistentEntity = getRequiredPersistentEntity(entity.getClass());
		CqlIdentifier tableName = persistentEntity.getTableName();

		StatementBuilder<Delete> builder = getStatementFactory().delete(entity, options, getConverter(), tableName);

		return source.isVersionedEntity()
				? doDeleteVersioned(source.appendVersionCondition(builder).build(), entity, source, tableName)
				: doDelete(builder.build(), entity, tableName);
	}

	private WriteResult doDeleteVersioned(SimpleStatement statement, Object entity, AdaptibleEntity<Object> source,
			CqlIdentifier tableName) {

		return executeDelete(entity, tableName, statement, result -> {

			if (!result.wasApplied()) {
				throw OptimisticLockingUtils.deleteFailed(source);
			}
		});
	}

	private WriteResult doDelete(SimpleStatement delete, Object entity, CqlIdentifier tableName) {
		return executeDelete(entity, tableName, delete, result -> {});
	}

	@Override
	public boolean deleteById(Object id, Class<?> entityClass) {

		Assert.notNull(id, "Id must not be null");
		Assert.notNull(entityClass, "Entity type must not be null");

		CassandraPersistentEntity<?> entity = getRequiredPersistentEntity(entityClass);
		CqlIdentifier tableName = entity.getTableName();

		StatementBuilder<Delete> delete = getStatementFactory().deleteById(id, entity, tableName);
		SimpleStatement statement = delete.build();

		maybeEmitEvent(() -> new BeforeDeleteEvent<>(statement, entityClass, tableName));

		boolean result = doExecute(statement).wasApplied();

		maybeEmitEvent(() -> new AfterDeleteEvent<>(statement, entityClass, tableName));

		return result;
	}

	@Override
	public void truncate(Class<?> entityClass) {

		Assert.notNull(entityClass, "Entity type must not be null");

		CassandraPersistentEntity<?> entity = getRequiredPersistentEntity(entityClass);
		CqlIdentifier tableName = entity.getTableName();

		Truncate truncate = QueryBuilder.truncate(entity.getKeyspace(), tableName);
		SimpleStatement statement = truncate.build();

		maybeEmitEvent(() -> new BeforeDeleteEvent<>(statement, entityClass, tableName));

		doExecute(statement);

		maybeEmitEvent(() -> new AfterDeleteEvent<>(statement, entityClass, tableName));
	}

	// -------------------------------------------------------------------------
	// Fluent API entry points
	// -------------------------------------------------------------------------

	@Override
	public <T> ExecutableSelect<T> query(Class<T> domainType) {
		return new ExecutableSelectOperationSupport(this, this.queryOperations).query(domainType);
	}

	@Override
	public UntypedSelect query(String cql) {
		return new ExecutableSelectOperationSupport(this, this.queryOperations).query(cql);
	}

	@Override
	public UntypedSelect query(Statement<?> statement) {
		return new ExecutableSelectOperationSupport(this, this.queryOperations).query(statement);
	}

	@Override
	public <T> ExecutableInsert<T> insert(Class<T> domainType) {
		return new ExecutableInsertOperationSupport(this).insert(domainType);
	}

	@Override
	public ExecutableUpdate update(Class<?> domainType) {
		return new ExecutableUpdateOperationSupport(this).update(domainType);
	}

	@Override
	public ExecutableDelete delete(Class<?> domainType) {
		return new ExecutableDeleteOperationSupport(this).delete(domainType);
	}

	// -------------------------------------------------------------------------
	// Implementation hooks and utility methods
	// -------------------------------------------------------------------------

	/**
	 * Create a new statement-based {@link PreparedStatementHandler} using the statement passed in.
	 * <p>
	 * This method allows for the creation to be overridden by subclasses.
	 *
	 * @param statement the statement to be prepared.
	 * @return the new {@link PreparedStatementHandler} to use.
	 * @since 3.3.3
	 */
	protected PreparedStatementHandler createPreparedStatementHandler(Statement<?> statement) {
		return new PreparedStatementHandler(statement);
	}

	protected <E extends CassandraMappingEvent<T>, T> void maybeEmitEvent(Supplier<E> event) {
		this.eventDelegate.publishEvent(event);
	}

	protected <T> T maybeCallBeforeConvert(T object, CqlIdentifier tableName) {

		if (null != entityCallbacks) {
			return entityCallbacks.callback(BeforeConvertCallback.class, object, tableName);
		}

		return object;
	}

	protected <T> T maybeCallBeforeSave(T object, CqlIdentifier tableName, Statement<?> statement) {

		if (null != entityCallbacks) {
			return entityCallbacks.callback(BeforeSaveCallback.class, object, tableName, statement);
		}

		return object;
	}

	<T> List<T> doQuery(Statement<?> statement, RowMapper<T> rowMapper) {

		if (PreparedStatementDelegate.canPrepare(isUsePreparedStatements(), statement, log)) {

			PreparedStatementHandler statementHandler = createPreparedStatementHandler(statement);
			return getCqlOperations().query(statementHandler, statementHandler, rowMapper);
		}

		return getCqlOperations().query(statement, rowMapper);
	}

	<T> Slice<T> doSlice(Statement<?> statement, RowMapper<T> mapper) {

		ResultSet resultSet = doQueryForResultSet(statement);
		return EntityQueryUtils.readSlice(resultSet, mapper, 0, getEffectivePageSize(statement));
	}

	<T> Stream<T> doStream(Statement<?> statement, RowMapper<T> rowMapper) {

		if (PreparedStatementDelegate.canPrepare(isUsePreparedStatements(), statement, log)) {

			PreparedStatementHandler statementHandler = createPreparedStatementHandler(statement);
			return getCqlOperations().queryForStream(statementHandler, statementHandler, rowMapper);
		}

		return getCqlOperations().queryForStream(statement, rowMapper);
	}

	private <T> EntityWriteResult<T> executeSave(T entity, CqlIdentifier tableName, SimpleStatement statement) {
		return executeSave(entity, tableName, statement, ignore -> {});
	}

	private <T> EntityWriteResult<T> executeSave(T entity, CqlIdentifier tableName, SimpleStatement statement,
			Consumer<WriteResult> resultConsumer) {

		maybeEmitEvent(() -> new BeforeSaveEvent<>(entity, tableName, statement));
		T entityToSave = maybeCallBeforeSave(entity, tableName, statement);

		WriteResult result = doExecute(statement);
		resultConsumer.accept(result);

		maybeEmitEvent(() -> new AfterSaveEvent<>(entityToSave, tableName));

		return EntityWriteResult.of(result, entityToSave);
	}

	private WriteResult executeDelete(Object entity, CqlIdentifier tableName, SimpleStatement statement,
			Consumer<WriteResult> resultConsumer) {

		maybeEmitEvent(() -> new BeforeDeleteEvent<>(statement, entity.getClass(), tableName));

		WriteResult result = doExecute(statement);

		resultConsumer.accept(result);

		maybeEmitEvent(() -> new AfterDeleteEvent<>(statement, entity.getClass(), tableName));

		return result;
	}

	private <T> T doQueryForRequiredObject(Statement<?> statement, Class<T> resultType) {
		return DataAccessUtils.requiredSingleResult(doQuery(statement, SingleColumnRowMapper.newInstance(resultType)));
	}

	private WriteResult doExecute(SimpleStatement statement) {
		return doExecute(statement, WriteResult::of);
	}

	private ResultSet doQueryForResultSet(Statement<?> statement) {
		return doExecute(statement, Function.identity());
	}

	private <T> T doExecute(Statement<?> statement, Function<ResultSet, T> mappingFunction) {

		if (PreparedStatementDelegate.canPrepare(isUsePreparedStatements(), statement, log)) {

			PreparedStatementHandler statementHandler = createPreparedStatementHandler(statement);
			return getCqlOperations().query(statementHandler, statementHandler, mappingFunction::apply);
		}

		return mappingFunction.apply(getCqlOperations().queryForResultSet(statement));
	}

	private CassandraPersistentEntity<?> getRequiredPersistentEntity(Class<?> entityType) {
		return queryOperations.getRequiredPersistentEntity(entityType);
	}

	/**
	 * Create a new {@link MappingCassandraConverter} given the {@link CqlSession}.
	 *
	 * @param session the session to be used for
	 *          {@link com.datastax.oss.driver.api.core.type.codec.registry.CodecRegistry} and user type resolution.
	 * @return a new and initialized {@link MappingCassandraConverter}.
	 */
	static MappingCassandraConverter createConverter(CqlSession session) {
		return createConverter(new SimpleUserTypeResolver(session), session.getContext());
	}

	/**
	 * Create a new {@link MappingCassandraConverter}.
	 *
	 * @param userTypeResolver the user type resolver to be used.
	 * @param context the driver context to be used for codec registry access.
	 * @return a new and initialized {@link MappingCassandraConverter}.
	 */
	static MappingCassandraConverter createConverter(UserTypeResolver userTypeResolver, DriverContext context) {

		MappingCassandraConverter converter = new MappingCassandraConverter();
		converter.setUserTypeResolver(userTypeResolver);
		converter.setCodecRegistry(context.getCodecRegistry());

		converter.afterPropertiesSet();

		return converter;
	}

	static int getConfiguredPageSize(CqlSession session) {
		return getConfiguredPageSize(session.getContext());
	}

	static int getConfiguredPageSize(DriverContext context) {
		return context.getConfig().getDefaultProfile().getInt(DefaultDriverOption.REQUEST_PAGE_SIZE, 5000);
	}

	@SuppressWarnings("ConstantConditions")
	private int getEffectivePageSize(Statement<?> statement) {

		if (statement.getPageSize() > 0) {
			return statement.getPageSize();
		}

		if (getCqlOperations() instanceof CassandraAccessor accessor) {

			if (accessor.getPageSize() != -1) {
				return accessor.getPageSize();
			}
		}

		class GetConfiguredPageSize implements SessionCallback<Integer>, CqlProvider {
			@Override
			public Integer doInSession(CqlSession session) {
				return getConfiguredPageSize(session);
			}

			@Override
			public String getCql() {
				return QueryExtractorDelegate.getCql(statement);
			}
		}

		return getCqlOperations().execute(new GetConfiguredPageSize());
	}

	/**
	 * Utility class to prepare a {@link SimpleStatement} and bind values associated with the statement to a
	 * {@link BoundStatement}.
	 *
	 * @since 3.2
	 */
	public static class PreparedStatementHandler
			implements PreparedStatementCreator, PreparedStatementBinder, CqlProvider {

		private final SimpleStatement statement;

		public PreparedStatementHandler(Statement<?> statement) {
			this.statement = PreparedStatementDelegate.getStatementForPrepare(statement);
		}

		@Override
		public PreparedStatement createPreparedStatement(CqlSession session) throws DriverException {

			// Note that prepared statement settings like the keyspace are gone because using the prepare method with a
			// statement object causes cache pollution
			return session.prepare(statement.getQuery());
		}

		@Override
		public BoundStatement bindValues(PreparedStatement ps) throws DriverException {
			return PreparedStatementDelegate.bind(statement, ps);
		}

		@Override
		public String getCql() {
			return statement.getQuery();
		}

	}

}

---

8.4 spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/AsyncCassandraOperations.java

+63 — interface: same four methods with CompletableFuture return types.

/*
 * Copyright 2016-present the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License")
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.springframework.data.cassandra.core;

import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.function.Consumer;

import org.jspecify.annotations.Nullable;

import org.springframework.dao.DataAccessException;
import org.springframework.data.cassandra.core.convert.CassandraConverter;
import org.springframework.data.cassandra.core.cql.AsyncCqlOperations;
import org.springframework.data.cassandra.core.cql.QueryOptions;
import org.springframework.data.cassandra.core.cql.WriteOptions;
import org.springframework.data.cassandra.core.query.CassandraPageRequest;
import org.springframework.data.cassandra.core.query.Query;
import org.springframework.data.cassandra.core.query.Update;
import org.springframework.data.domain.Slice;

import com.datastax.oss.driver.api.core.cql.AsyncResultSet;
import com.datastax.oss.driver.api.core.cql.Statement;

/**
 * Interface specifying a basic set of asynchronous Cassandra operations. Implemented by {@link AsyncCassandraTemplate}.
 * Not often used directly, but a useful option to enhance testability, as it can easily be mocked or stubbed.
 *
 * @author Mark Paluch
 * @author John Blum
 * @since 2.0
 * @see AsyncCassandraTemplate
 * @see AsyncCqlOperations
 * @see Statement
 * @see InsertOptions
 * @see UpdateOptions
 */
public interface AsyncCassandraOperations {

	/**
	 * Expose the underlying {@link AsyncCqlOperations} to allow asynchronous CQL operations.
	 *
	 * @return the underlying {@link AsyncCqlOperations}.
	 * @see AsyncCqlOperations
	 */
	AsyncCqlOperations getAsyncCqlOperations();

	/**
	 * Returns the underlying {@link CassandraConverter}.
	 *
	 * @return the underlying {@link CassandraConverter}.
	 */
	CassandraConverter getConverter();

	// -------------------------------------------------------------------------
	// Methods dealing with static CQL
	// -------------------------------------------------------------------------

	/**
	 * Execute a {@code SELECT} query and convert the resulting items to a {@link List} of entities.
	 *
	 * @param cql must not be {@literal null}.
	 * @param entityClass The entity type must not be {@literal null}.
	 * @return the converted results
	 * @throws DataAccessException if there is any problem executing the query.
	 */
	<T> CompletableFuture<List<T>> select(String cql, Class<T> entityClass) throws DataAccessException;

	/**
	 * Execute a {@code SELECT} query and convert the resulting items notifying {@link Consumer} for each entity.
	 *
	 * @param cql must not be {@literal null}.
	 * @param entityConsumer object that will be notified on each entity, one object at a time, must not be
	 *          {@literal null}.
	 * @param entityClass The entity type must not be {@literal null}.
	 * @return the completion handle
	 * @throws DataAccessException if there is any problem executing the query.
	 */
	<T> CompletableFuture<Void> select(String cql, Consumer<T> entityConsumer, Class<T> entityClass)
			throws DataAccessException;

	/**
	 * Execute a {@code SELECT} query and convert the resulting item to an entity.
	 *
	 * @param cql must not be {@literal null}.
	 * @param entityClass The entity type must not be {@literal null}.
	 * @return the converted object or {@literal null}.
	 * @throws DataAccessException if there is any problem executing the query.
	 */
	<T> CompletableFuture<@Nullable T> selectOne(String cql, Class<T> entityClass) throws DataAccessException;

	// -------------------------------------------------------------------------
	// Methods dealing with com.datastax.oss.driver.api.core.cql.Statement
	// -------------------------------------------------------------------------

	/**
	 * Execute the given Cassandra {@link Statement}. Any errors that result from executing this command will be converted
	 * into Spring's DAO exception hierarchy.
	 *
	 * @param statement a Cassandra {@link Statement}, must not be {@literal null}.
	 * @return the {@link AsyncResultSet}.
	 * @throws DataAccessException if there is any problem executing the query.
	 * @since 3.2
	 */
	CompletableFuture<AsyncResultSet> execute(Statement<?> statement) throws DataAccessException;

	/**
	 * Execute a {@code SELECT} query and convert the resulting items to a {@link List} of entities.
	 *
	 * @param statement must not be {@literal null}.
	 * @param entityClass The entity type must not be {@literal null}.
	 * @return the converted results
	 * @throws DataAccessException if there is any problem executing the query.
	 */
	<T> CompletableFuture<List<T>> select(Statement<?> statement, Class<T> entityClass) throws DataAccessException;

	/**
	 * Execute a {@code SELECT} query with paging and convert the result set to a {@link Slice} of entities. A sliced
	 * query translates the effective {@link Statement#getPageSize() fetch size} to the page size.
	 *
	 * @param statement the CQL statement, must not be {@literal null}.
	 * @param entityClass The entity type must not be {@literal null}.
	 * @return the converted results
	 * @throws DataAccessException if there is any problem executing the query.
	 * @see CassandraPageRequest
	 */
	<T> CompletableFuture<Slice<T>> slice(Statement<?> statement, Class<T> entityClass) throws DataAccessException;

	/**
	 * Execute a {@code SELECT} query and convert the resulting items notifying {@link Consumer} for each entity.
	 *
	 * @param statement must not be {@literal null}.
	 * @param entityConsumer object that will be notified on each entity, one object at a time, must not be
	 *          {@literal null}.
	 * @param entityClass The entity type must not be {@literal null}.
	 * @return the completion handle
	 * @throws DataAccessException if there is any problem executing the query.
	 */
	<T> CompletableFuture<Void> select(Statement<?> statement, Consumer<T> entityConsumer, Class<T> entityClass)
			throws DataAccessException;

	/**
	 * Execute a {@code SELECT} query and convert the resulting item to an entity.
	 *
	 * @param statement must not be {@literal null}.
	 * @param entityClass The entity type must not be {@literal null}.
	 * @return the converted object or {@literal null}.
	 * @throws DataAccessException if there is any problem executing the query.
	 */
	<T> CompletableFuture<@Nullable T> selectOne(Statement<?> statement, Class<T> entityClass) throws DataAccessException;

	// -------------------------------------------------------------------------
	// Methods dealing with org.springframework.data.cassandra.core.query.Query
	// -------------------------------------------------------------------------

	/**
	 * Execute a {@code SELECT} query and convert the resulting items to a {@link List} of entities.
	 *
	 * @param query must not be {@literal null}.
	 * @param entityClass The entity type must not be {@literal null}.
	 * @return the converted results
	 * @throws DataAccessException if there is any problem executing the query.
	 */
	<T> CompletableFuture<List<T>> select(Query query, Class<T> entityClass) throws DataAccessException;

	/**
	 * Execute a {@code SELECT} query with paging and convert the result set to a {@link Slice} of entities.
	 *
	 * @param query the query object used to create a CQL statement, must not be {@literal null}.
	 * @param entityClass The entity type must not be {@literal null}.
	 * @return the converted results
	 * @throws DataAccessException if there is any problem executing the query.
	 * @see CassandraPageRequest
	 */
	<T> CompletableFuture<Slice<T>> slice(Query query, Class<T> entityClass) throws DataAccessException;

	/**
	 * Execute a {@code SELECT} query and convert the resulting items notifying {@link Consumer} for each entity.
	 *
	 * @param query must not be {@literal null}.
	 * @param entityConsumer object that will be notified on each entity, one object at a time, must not be
	 *          {@literal null}.
	 * @param entityClass The entity type must not be {@literal null}.
	 * @return the completion handle
	 * @throws DataAccessException if there is any problem executing the query.
	 */
	<T> CompletableFuture<Void> select(Query query, Consumer<T> entityConsumer, Class<T> entityClass)
			throws DataAccessException;

	/**
	 * Execute a {@code SELECT} query and convert the resulting item to an entity.
	 *
	 * @param query must not be {@literal null}.
	 * @param entityClass The entity type must not be {@literal null}.
	 * @return the converted object or {@literal null}.
	 * @throws DataAccessException if there is any problem executing the query.
	 */
	<T> CompletableFuture<@Nullable T> selectOne(Query query, Class<T> entityClass) throws DataAccessException;

	/**
	 * Execute a {@code SELECT JSON} query and return the resulting rows as their JSON representation. Each returned
	 * {@link String} contains a JSON-encoded row in which the keys correspond to column names as defined by the
	 * Cassandra {@code SELECT JSON} semantics.
	 *
	 * @param query must not be {@literal null}.
	 * @param entityClass the entity type used to resolve the table name, must not be {@literal null}.
	 * @return a {@link List} of JSON-encoded rows.
	 * @throws DataAccessException if there is any problem executing the query.
	 * @since 5.2
	 */
	CompletableFuture<List<String>> selectJson(Query query, Class<?> entityClass) throws DataAccessException;

	/**
	 * Execute a {@code SELECT JSON} query and return the resulting row as its JSON representation. The returned
	 * {@link String} contains a JSON-encoded row in which the keys correspond to column names as defined by the
	 * Cassandra {@code SELECT JSON} semantics.
	 *
	 * @param query must not be {@literal null}.
	 * @param entityClass the entity type used to resolve the table name, must not be {@literal null}.
	 * @return the JSON-encoded row or {@literal null}.
	 * @throws DataAccessException if there is any problem executing the query.
	 * @since 5.2
	 */
	CompletableFuture<@Nullable String> selectOneJson(Query query, Class<?> entityClass) throws DataAccessException;

	/**
	 * Update the queried entities and return {@literal true} if the update was applied.
	 *
	 * @param query must not be {@literal null}.
	 * @param update must not be {@literal null}.
	 * @param entityClass The entity type must not be {@literal null}.
	 * @throws DataAccessException if there is any problem executing the query.
	 */
	CompletableFuture<Boolean> update(Query query, Update update, Class<?> entityClass) throws DataAccessException;

	/**
	 * Remove entities (rows)/columns from the table by {@link Query}.
	 *
	 * @param query must not be {@literal null}.
	 * @param entityClass The entity type must not be {@literal null}.
	 * @return {@literal true} if the deletion was applied.
	 * @throws DataAccessException if there is any problem executing the query.
	 */
	CompletableFuture<Boolean> delete(Query query, Class<?> entityClass) throws DataAccessException;

	// -------------------------------------------------------------------------
	// Methods dealing with entities
	// -------------------------------------------------------------------------

	/**
	 * Returns the number of rows for the given entity class.
	 *
	 * @param entityClass {@link Class type} of the entity; must not be {@literal null}.
	 * @return the number of existing entities.
	 * @throws DataAccessException if any problem occurs while executing the query.
	 */
	CompletableFuture<Long> count(Class<?> entityClass) throws DataAccessException;

	/**
	 * Returns the number of rows for the given entity class applying {@link Query}. This overridden method allows users
	 * to further refine the selection criteria using a {@link Query} predicate to determine how many entities of the
	 * given {@link Class type} match the criteria.
	 *
	 * @param query user-provided count {@link Query} to execute; must not be {@literal null}.
	 * @param entityClass {@link Class type} of the entity; must not be {@literal null}.
	 * @return the number of existing entities.
	 * @throws DataAccessException if any problem occurs while executing the query.
	 * @since 2.1
	 */
	CompletableFuture<Long> count(Query query, Class<?> entityClass) throws DataAccessException;

	/**
	 * Determine whether a row of {@code entityClass} with the given {@code id} exists.
	 *
	 * @param id Id value. For single primary keys it's the plain value. For composite primary keys either, it's an
	 *          instance of either {@link org.springframework.data.cassandra.core.mapping.PrimaryKeyClass} or
	 *          {@link org.springframework.data.cassandra.core.mapping.MapId}. Must not be {@literal null}.
	 * @param entityClass {@link Class type} of the entity; must not be {@literal null}.
	 * @return {@literal true} if the object exists.
	 * @throws DataAccessException if any problem occurs while executing the query.
	 */
	CompletableFuture<Boolean> exists(Object id, Class<?> entityClass) throws DataAccessException;

	/**
	 * Determine whether the result for {@code entityClass} {@link Query} yields at least one row.
	 *
	 * @param query user-provided exists {@link Query} to execute; must not be {@literal null}.
	 * @param entityClass {@link Class type} of the entity; must not be {@literal null}.
	 * @return {@literal true} if the object exists.
	 * @throws DataAccessException if any problem occurs while executing the query.
	 * @since 2.1
	 */
	CompletableFuture<Boolean> exists(Query query, Class<?> entityClass) throws DataAccessException;

	/**
	 * Execute the Select by {@code id} for the given {@code entityClass}.
	 *
	 * @param id the Id value. For single primary keys it's the plain value. For composite primary keys either the
	 *          {@link org.springframework.data.cassandra.core.mapping.PrimaryKeyClass} or
	 *          {@link org.springframework.data.cassandra.core.mapping.MapId}. Must not be {@literal null}.
	 * @param entityClass The entity type must not be {@literal null}.
	 * @return the converted object or {@literal null}.
	 * @throws DataAccessException if there is any problem executing the query.
	 */
	<T> CompletableFuture<@Nullable T> selectOneById(Object id, Class<T> entityClass) throws DataAccessException;

	/**
	 * Insert the given entity and return the entity if the insert was applied.
	 *
	 * @param entity The entity to insert, must not be {@literal null}.
	 * @return the inserted entity.
	 * @throws DataAccessException if there is any problem executing the query.
	 */
	<T> CompletableFuture<@Nullable T> insert(T entity) throws DataAccessException;

	/**
	 * Insert the given entity applying {@link WriteOptions} and return the entity if the insert was applied.
	 *
	 * @param entity The entity to insert, must not be {@literal null}.
	 * @param options must not be {@literal null}.
	 * @return the {@link EntityWriteResult} for this operation.
	 * @throws DataAccessException if there is any problem executing the query.
	 * @see InsertOptions#empty()
	 */
	<T> CompletableFuture<EntityWriteResult<T>> insert(T entity, InsertOptions options) throws DataAccessException;

	/**
	 * Insert the given JSON payload into the table of {@code entityClass} using an {@code INSERT JSON} statement. The
	 * JSON keys are expected to map to column names as defined by the Cassandra {@code INSERT JSON} semantics. Columns
	 * omitted from the JSON payload are left unset ({@code DEFAULT UNSET}).
	 * <p>
	 * Note that mapping between the JSON payload and the table happens within Cassandra so entity lifecycle events and
	 * callbacks are not invoked.
	 *
	 * @param json the JSON payload to insert, must not be {@literal null} or empty.
	 * @param entityClass the entity type used to resolve the table name, must not be {@literal null}.
	 * @return the {@link WriteResult} for this operation.
	 * @throws DataAccessException if there is any problem executing the query.
	 * @since 5.2
	 */
	CompletableFuture<WriteResult> insertJson(String json, Class<?> entityClass) throws DataAccessException;

	/**
	 * Insert the given JSON payload into the table of {@code entityClass} using an {@code INSERT JSON} statement
	 * applying {@link InsertOptions}. The JSON keys are expected to map to column names as defined by the Cassandra
	 * {@code INSERT JSON} semantics. Columns omitted from the JSON payload are left unset ({@code DEFAULT UNSET}) unless
	 * {@link InsertOptions#isInsertNulls()} is set, in which case omitted columns are inserted as {@code null}
	 * ({@code DEFAULT NULL}).
	 * <p>
	 * Note that mapping between the JSON payload and the table happens within Cassandra so entity lifecycle events and
	 * callbacks are not invoked.
	 *
	 * @param json the JSON payload to insert, must not be {@literal null} or empty.
	 * @param entityClass the entity type used to resolve the table name, must not be {@literal null}.
	 * @param options must not be {@literal null}.
	 * @return the {@link WriteResult} for this operation.
	 * @throws DataAccessException if there is any problem executing the query.
	 * @see InsertOptions#empty()
	 * @since 5.2
	 */
	CompletableFuture<WriteResult> insertJson(String json, Class<?> entityClass, InsertOptions options)
			throws DataAccessException;

	/**
	 * Update the given entity and return the entity if the update was applied.
	 *
	 * @param entity The entity to update, must not be {@literal null}.
	 * @return the updated entity.
	 * @throws DataAccessException if there is any problem executing the query.
	 */
	<T> CompletableFuture<T> update(T entity) throws DataAccessException;

	/**
	 * Update the given entity applying {@link WriteOptions} and return the entity if the update was applied.
	 *
	 * @param entity The entity to update, must not be {@literal null}.
	 * @param options must not be {@literal null}.
	 * @return the {@link EntityWriteResult} for this operation.
	 * @throws DataAccessException if there is any problem executing the query.
	 * @see UpdateOptions#empty()
	 */
	<T> CompletableFuture<EntityWriteResult<T>> update(T entity, UpdateOptions options) throws DataAccessException;

	/**
	 * Delete the given entity and return the entity if the delete statement was applied.
	 *
	 * @param entity must not be {@literal null}.
	 * @return the deleted entity.
	 * @throws DataAccessException if there is any problem executing the query.
	 */
	<T> CompletableFuture<T> delete(T entity) throws DataAccessException;

	/**
	 * Delete the given entity applying {@link QueryOptions} and return the entity if the delete statement was applied.
	 *
	 * @param entity must not be {@literal null}.
	 * @param options must not be {@literal null}.
	 * @return the {@link WriteResult} for this operation.
	 * @throws DataAccessException if there is any problem executing the query.
	 * @see QueryOptions#empty()
	 */
	CompletableFuture<WriteResult> delete(Object entity, QueryOptions options) throws DataAccessException;

	/**
	 * Delete the given entity applying {@link DeleteOptions} and return the entity if the delete statement was applied.
	 *
	 * @param entity must not be {@literal null}.
	 * @param options must not be {@literal null}.
	 * @return the {@link WriteResult} for this operation.
	 * @throws DataAccessException if there is any problem executing the query.
	 * @see DeleteOptions#empty()
	 * @since 2.2
	 */
	default CompletableFuture<WriteResult> delete(Object entity, DeleteOptions options) throws DataAccessException {
		return delete(entity, (QueryOptions) options);
	}

	/**
	 * Remove the given object from the table by id.
	 *
	 * @param id the Id value. For single primary keys it's the plain value. For composite primary keys either the
	 *          {@link org.springframework.data.cassandra.core.mapping.PrimaryKeyClass} or
	 *          {@link org.springframework.data.cassandra.core.mapping.MapId}. Must not be {@literal null}.
	 * @param entityClass The entity type must not be {@literal null}.
	 * @return {@literal true} if the deletion was applied.
	 * @throws DataAccessException if there is any problem executing the query.
	 */
	CompletableFuture<Boolean> deleteById(Object id, Class<?> entityClass) throws DataAccessException;

	/**
	 * Execute a {@code TRUNCATE} query to remove all entities of a given class.
	 *
	 * @param entityClass The entity type must not be {@literal null}.
	 * @throws DataAccessException if there is any problem executing the query.
	 */
	CompletableFuture<Void> truncate(Class<?> entityClass) throws DataAccessException;

}

---

8.5 spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/AsyncCassandraTemplate.java

+38 — implementations: selectJson via query(statement, rowMapper), insertJson via doQueryForResultSet → WriteResult from AsyncResultSet; import JsonInsert.

/*
 * Copyright 2016-present the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.springframework.data.cassandra.core;

import java.util.Collections;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import java.util.stream.StreamSupport;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.jspecify.annotations.Nullable;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.ApplicationEventPublisherAware;
import org.springframework.dao.DataAccessException;
import org.springframework.dao.support.DataAccessUtils;
import org.springframework.data.cassandra.SessionFactory;
import org.springframework.data.cassandra.core.EntityOperations.AdaptibleEntity;
import org.springframework.data.cassandra.core.convert.CassandraConverter;
import org.springframework.data.cassandra.core.convert.MappingCassandraConverter;
import org.springframework.data.cassandra.core.cql.*;
import org.springframework.data.cassandra.core.cql.session.DefaultSessionFactory;
import org.springframework.data.cassandra.core.cql.util.StatementBuilder;
import org.springframework.data.cassandra.core.mapping.CassandraPersistentEntity;
import org.springframework.data.cassandra.core.mapping.event.AfterDeleteEvent;
import org.springframework.data.cassandra.core.mapping.event.AfterLoadEvent;
import org.springframework.data.cassandra.core.mapping.event.AfterSaveEvent;
import org.springframework.data.cassandra.core.mapping.event.BeforeConvertCallback;
import org.springframework.data.cassandra.core.mapping.event.BeforeDeleteEvent;
import org.springframework.data.cassandra.core.mapping.event.BeforeSaveCallback;
import org.springframework.data.cassandra.core.mapping.event.BeforeSaveEvent;
import org.springframework.data.cassandra.core.mapping.event.CassandraMappingEvent;
import org.springframework.data.cassandra.core.query.Query;
import org.springframework.data.domain.Slice;
import org.springframework.data.mapping.callback.EntityCallbacks;
import org.springframework.data.util.Streamable;
import org.springframework.util.Assert;

import com.datastax.oss.driver.api.core.CqlIdentifier;
import com.datastax.oss.driver.api.core.CqlSession;
import com.datastax.oss.driver.api.core.DriverException;
import com.datastax.oss.driver.api.core.cql.AsyncResultSet;
import com.datastax.oss.driver.api.core.cql.BoundStatement;
import com.datastax.oss.driver.api.core.cql.PreparedStatement;
import com.datastax.oss.driver.api.core.cql.ResultSet;
import com.datastax.oss.driver.api.core.cql.Row;
import com.datastax.oss.driver.api.core.cql.SimpleStatement;
import com.datastax.oss.driver.api.core.cql.Statement;
import com.datastax.oss.driver.api.querybuilder.QueryBuilder;
import com.datastax.oss.driver.api.querybuilder.delete.Delete;
import com.datastax.oss.driver.api.querybuilder.insert.Insert;
import com.datastax.oss.driver.api.querybuilder.insert.JsonInsert;
import com.datastax.oss.driver.api.querybuilder.insert.RegularInsert;
import com.datastax.oss.driver.api.querybuilder.truncate.Truncate;
import com.datastax.oss.driver.api.querybuilder.update.Update;

/**
 * Primary implementation of {@link AsyncCassandraOperations}. It simplifies the use of asynchronous Cassandra usage and
 * helps to avoid common errors. It executes core Cassandra workflow. This class executes CQL queries or updates,
 * initiating iteration over {@link ResultSet} and catching Cassandra exceptions and translating them to the generic,
 * more informative exception hierarchy defined in the {@code org.springframework.dao} package.
 * <p>
 * Can be used within a service implementation via direct instantiation with a {@link CqlSession} reference, or get
 * prepared in an application context and given to services as bean reference.
 * <p>
 * This class supports the use of prepared statements when enabling {@link #setUsePreparedStatements(boolean)}. All
 * statements created by methods of this class (such as {@link #select(Query, Class)} or
 * {@link #update(Query, org.springframework.data.cassandra.core.query.Update, Class)} will be executed as prepared
 * statements. Also, statements accepted by methods (such as {@link #select(String, Class)} or
 * {@link #select(Statement, Class) and others}) will be prepared prior to execution. Note that {@link Statement}
 * objects passed to methods must be {@link SimpleStatement} so that these can be prepared.
 * <p>
 * Note: The {@link CqlSession} should always be configured as a bean in the application context, in the first case
 * given to the service directly, in the second case to the prepared template.
 *
 * @author Mark Paluch
 * @author John Blum
 * @see org.springframework.data.cassandra.core.AsyncCassandraOperations
 * @since 2.0
 */
public class AsyncCassandraTemplate
		implements AsyncCassandraOperations, ApplicationEventPublisherAware, ApplicationContextAware {

	private final Log log = LogFactory.getLog(getClass());

	private final AsyncCqlOperations cqlOperations;

	private final EntityLifecycleEventDelegate eventDelegate;

	private final CassandraConverter converter;

	private final StatementFactory statementFactory;

	private final EntityOperations entityOperations;

	private final QueryOperations queryOperations;

	private @Nullable EntityCallbacks entityCallbacks;

	private boolean usePreparedStatements = true;

	/**
	 * Creates an instance of {@link AsyncCassandraTemplate} initialized with the given {@link CqlSession} and a default
	 * {@link MappingCassandraConverter}.
	 *
	 * @param session {@link CqlSession} used to interact with Cassandra; must not be {@literal null}.
	 * @see CassandraConverter
	 * @see CqlSession
	 */
	public AsyncCassandraTemplate(CqlSession session) {
		this(session, CassandraTemplate.createConverter(session));
	}

	/**
	 * Creates an instance of {@link AsyncCassandraTemplate} initialized with the given {@link CqlSession} and
	 * {@link CassandraConverter}.
	 *
	 * @param session {@link CqlSession} used to interact with Cassandra; must not be {@literal null}.
	 * @param converter {@link CassandraConverter} used to convert between Java and Cassandra types; must not be
	 *          {@literal null}.
	 * @see CassandraConverter
	 * @see CqlSession
	 */
	public AsyncCassandraTemplate(CqlSession session, CassandraConverter converter) {
		this(new DefaultSessionFactory(session), converter);
	}

	/**
	 * Creates an instance of {@link AsyncCassandraTemplate} initialized with the given {@link SessionFactory} and
	 * {@link CassandraConverter}.
	 *
	 * @param sessionFactory {@link SessionFactory} used to interact with Cassandra; must not be {@literal null}.
	 * @param converter {@link CassandraConverter} used to convert between Java and Cassandra types; must not be
	 *          {@literal null}.
	 * @see CassandraConverter
	 * @see CqlSession
	 */
	public AsyncCassandraTemplate(SessionFactory sessionFactory, CassandraConverter converter) {
		this(new AsyncCqlTemplate(sessionFactory), converter);
	}

	/**
	 * Creates an instance of {@link AsyncCassandraTemplate} initialized with the given {@link AsyncCqlTemplate} and
	 * {@link CassandraConverter}.
	 *
	 * @param asyncCqlTemplate {@link AsyncCqlTemplate} used to interact with Cassandra; must not be {@literal null}.
	 * @param converter {@link CassandraConverter} used to convert between Java and Cassandra types; must not be
	 *          {@literal null}.
	 * @see CassandraConverter
	 * @see CqlSession
	 */
	public AsyncCassandraTemplate(AsyncCqlTemplate asyncCqlTemplate, CassandraConverter converter) {

		Assert.notNull(asyncCqlTemplate, "AsyncCqlTemplate must not be null");
		Assert.notNull(converter, "CassandraConverter must not be null");

		this.converter = converter;
		this.eventDelegate = new EntityLifecycleEventDelegate();
		this.cqlOperations = asyncCqlTemplate;
		this.statementFactory = new StatementFactory(converter);
		this.entityOperations = new EntityOperations(converter);
		this.queryOperations = new QueryOperations(converter, this.statementFactory, this.eventDelegate);
	}

	@Override
	public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
		this.eventDelegate.setPublisher(applicationEventPublisher);
	}

	@Override
	public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {

		if (entityCallbacks == null) {
			setEntityCallbacks(EntityCallbacks.create(applicationContext));
		}
	}

	/**
	 * Configure {@link EntityCallbacks} to pre-/post-process entities during persistence operations.
	 *
	 * @param entityCallbacks
	 */
	public void setEntityCallbacks(@Nullable EntityCallbacks entityCallbacks) {
		this.entityCallbacks = entityCallbacks;
	}

	/**
	 * Configure whether lifecycle events such as {@link AfterLoadEvent}, {@link BeforeSaveEvent}, etc. should be
	 * published or whether emission should be suppressed. Enabled by default.
	 *
	 * @param enabled {@code true} to enable entity lifecycle events; {@code false} to disable entity lifecycle events.
	 * @since 4.0
	 * @see CassandraMappingEvent
	 */
	public void setEntityLifecycleEventsEnabled(boolean enabled) {
		this.eventDelegate.setEventsEnabled(enabled);
	}

	@Override
	public AsyncCqlOperations getAsyncCqlOperations() {
		return this.cqlOperations;
	}

	@Override
	public CassandraConverter getConverter() {
		return this.converter;
	}

	/**
	 * Returns the {@link StatementFactory} used by this template to construct and run Cassandra CQL statements.
	 *
	 * @return the {@link StatementFactory} used by this template to construct and run Cassandra CQL statements.
	 * @see StatementFactory
	 * @since 2.1
	 */
	public StatementFactory getStatementFactory() {
		return this.statementFactory;
	}

	/**
	 * Returns whether this instance is configured to use {@link PreparedStatement prepared statements}. If enabled
	 * (default), then all persistence methods (such as {@link #select}, {@link #update}, and others) will make use of
	 * prepared statements. Note that methods accepting a {@link Statement} must be called with {@link SimpleStatement}
	 * instances to participate in statement preparation.
	 *
	 * @return {@literal true} if prepared statements usage is enabled; {@literal false} otherwise.
	 * @since 3.2
	 */
	public boolean isUsePreparedStatements() {
		return usePreparedStatements;
	}

	/**
	 * Enable/disable {@link PreparedStatement prepared statements} usage. If enabled (default), then all persistence
	 * methods (such as {@link #select}, {@link #update}, and others) will make use of prepared statements. Note that
	 * methods accepting a {@link Statement} must be called with {@link SimpleStatement} instances to participate in
	 * statement preparation.
	 *
	 * @param usePreparedStatements whether to use prepared statements.
	 * @since 3.2
	 */
	public void setUsePreparedStatements(boolean usePreparedStatements) {
		this.usePreparedStatements = usePreparedStatements;
	}

	// -------------------------------------------------------------------------
	// Methods dealing with static CQL
	// -------------------------------------------------------------------------

	@Override
	public <T> CompletableFuture<List<T>> select(String cql, Class<T> entityClass) {

		Assert.hasText(cql, "CQL must not be empty");

		return select(SimpleStatement.newInstance(cql), entityClass);
	}

	@Override
	public <T> CompletableFuture<Void> select(String cql, Consumer<T> entityConsumer, Class<T> entityClass)
			throws DataAccessException {

		Assert.hasText(cql, "CQL must not be empty");
		Assert.notNull(entityConsumer, "Entity Consumer must not be null");
		Assert.notNull(entityClass, "Entity type must not be null");

		return select(SimpleStatement.newInstance(cql), entityConsumer, entityClass);
	}

	@Override
	public <T> CompletableFuture<T> selectOne(String cql, Class<T> entityClass) {

		Assert.hasText(cql, "CQL must not be empty");
		Assert.notNull(entityClass, "Entity type must not be null");

		return selectOne(SimpleStatement.newInstance(cql), entityClass);
	}

	// -------------------------------------------------------------------------
	// Methods dealing with com.datastax.oss.driver.api.core.cql.Statement
	// -------------------------------------------------------------------------

	@Override
	public CompletableFuture<AsyncResultSet> execute(Statement<?> statement) throws DataAccessException {

		Assert.notNull(statement, "Statement must not be null");

		return doQueryForResultSet(statement);
	}

	@Override
	public <T> CompletableFuture<List<T>> select(Statement<?> statement, Class<T> entityClass) {

		Assert.notNull(statement, "Statement must not be null");
		Assert.notNull(entityClass, "Entity type must not be null");

		RowMapper<T> mapper = queryOperations.getRowMapper(entityClass, statement);
		return query(statement, mapper);
	}

	@Override
	public <T> CompletableFuture<Void> select(Statement<?> statement, Consumer<T> entityConsumer, Class<T> entityClass)
			throws DataAccessException {

		Assert.notNull(statement, "Statement must not be null");
		Assert.notNull(entityConsumer, "Entity Consumer must not be empty");
		Assert.notNull(entityClass, "Entity type must not be null");

		Function<Row, T> mapper = queryOperations.getMapper(entityClass, statement);

		return query(statement, row -> {
			entityConsumer.accept(mapper.apply(row));
		});
	}

	@Override
	public <T> CompletableFuture<T> selectOne(Statement<?> statement, Class<T> entityClass) {
		return select(statement, entityClass).thenApply(list -> list.isEmpty() ? null : list.get(0));
	}

	@Override
	public <T> CompletableFuture<Slice<T>> slice(Statement<?> statement, Class<T> entityClass) {

		Assert.notNull(statement, "Statement must not be null");
		Assert.notNull(entityClass, "Entity type must not be null");

		CompletableFuture<AsyncResultSet> resultSet = doQueryForResultSet(statement);

		RowMapper<T> mapper = queryOperations.getRowMapper(entityClass, statement);

		return resultSet.thenApply(
				rs -> EntityQueryUtils.readSlice(rs, mapper, 0, getEffectivePageSize(statement)));
	}

	// -------------------------------------------------------------------------
	// Methods dealing with org.springframework.data.cassandra.core.query.Query
	// -------------------------------------------------------------------------

	@Override
	public <T> CompletableFuture<List<T>> select(Query query, Class<T> entityClass) throws DataAccessException {

		Assert.notNull(query, "Query must not be null");
		Assert.notNull(entityClass, "Entity type must not be null");

		return select(getStatementFactory().select(query, getRequiredPersistentEntity(entityClass)).build(), entityClass);
	}

	@Override
	public <T> CompletableFuture<Void> select(Query query, Consumer<T> entityConsumer, Class<T> entityClass)
			throws DataAccessException {

		Assert.notNull(query, "Query must not be null");
		Assert.notNull(entityConsumer, "Entity Consumer must not be empty");
		Assert.notNull(entityClass, "Entity type must not be null");

		return select(getStatementFactory().select(query, getRequiredPersistentEntity(entityClass)).build(), entityConsumer,
				entityClass);
	}

	@Override
	public <T> CompletableFuture<T> selectOne(Query query, Class<T> entityClass) throws DataAccessException {

		Assert.notNull(query, "Query must not be null");
		Assert.notNull(entityClass, "Entity type must not be null");

		return selectOne(getStatementFactory().select(query, getRequiredPersistentEntity(entityClass)).build(),
				entityClass);
	}

	@Override
	public CompletableFuture<List<String>> selectJson(Query query, Class<?> entityClass) throws DataAccessException {

		Assert.notNull(query, "Query must not be null");
		Assert.notNull(entityClass, "Entity type must not be null");

		StatementBuilder<com.datastax.oss.driver.api.querybuilder.select.Select> select = getStatementFactory()
				.selectJson(query, getRequiredPersistentEntity(entityClass), getTableName(entityClass));

		return query(select.build(), SingleColumnRowMapper.newInstance(String.class));
	}

	@Override
	public CompletableFuture<String> selectOneJson(Query query, Class<?> entityClass) throws DataAccessException {
		return selectJson(query, entityClass).thenApply(result -> result.isEmpty() ? null : result.get(0));
	}

	@Override
	public <T> CompletableFuture<Slice<T>> slice(Query query, Class<T> entityClass) throws DataAccessException {

		Assert.notNull(query, "Query must not be null");
		Assert.notNull(entityClass, "Entity type must not be null");

		return slice(getStatementFactory().select(query, getRequiredPersistentEntity(entityClass)).build(), entityClass);
	}

	@Override
	public CompletableFuture<Boolean> update(Query query, org.springframework.data.cassandra.core.query.Update update,
			Class<?> entityClass) throws DataAccessException {

		Assert.notNull(query, "Query must not be null");
		Assert.notNull(update, "Update must not be null");
		Assert.notNull(entityClass, "Entity type must not be null");

		return doExecute(getStatementFactory().update(query, update, getRequiredPersistentEntity(entityClass)).build(),
				AsyncResultSet::wasApplied);
	}

	@Override
	public CompletableFuture<Boolean> delete(Query query, Class<?> entityClass) throws DataAccessException {

		Assert.notNull(query, "Query must not be null");
		Assert.notNull(entityClass, "Entity type must not be null");

		return doDelete(query, entityClass, getTableName(entityClass));
	}

	private CompletableFuture<Boolean> doDelete(Query query, Class<?> entityClass, CqlIdentifier tableName) {

		StatementBuilder<Delete> builder = getStatementFactory().delete(query, getRequiredPersistentEntity(entityClass),
				tableName);
		SimpleStatement delete = builder.build();

		maybeEmitEvent(() -> new BeforeDeleteEvent<>(delete, entityClass, tableName));

		CompletableFuture<Boolean> future = doExecute(delete, AsyncResultSet::wasApplied);

		future.thenAccept(success -> maybeEmitEvent(() -> new AfterDeleteEvent<>(delete, entityClass, tableName)));

		return future;
	}

	// -------------------------------------------------------------------------
	// Methods dealing with entities
	// -------------------------------------------------------------------------

	@Override
	public CompletableFuture<Long> count(Class<?> entityClass) {

		Assert.notNull(entityClass, "Entity type must not be null");

		return doCount(Query.empty(), entityClass, getTableName(entityClass));
	}

	@Override
	public CompletableFuture<Long> count(Query query, Class<?> entityClass) throws DataAccessException {

		Assert.notNull(query, "Query must not be null");
		Assert.notNull(entityClass, "Entity type must not be null");

		return doCount(query, entityClass, getTableName(entityClass));
	}

	CompletableFuture<Long> doCount(Query query, Class<?> entityClass, CqlIdentifier tableName) {

		StatementBuilder<com.datastax.oss.driver.api.querybuilder.select.Select> countStatement = getStatementFactory()
				.count(query, getRequiredPersistentEntity(entityClass), tableName);

		SimpleStatement statement = countStatement.build();

		CompletableFuture<@Nullable Long> result = doExecute(statement, it -> {

			SingleColumnRowMapper<@Nullable Long> mapper = SingleColumnRowMapper.newInstance(Long.class);

			Row row = DataAccessUtils.requiredUniqueResult(Streamable.of(it.currentPage()).toList());
			return mapper.mapRow(row, 0);
		});

		return result.thenApply(it -> it != null ? it : 0L);
	}

	@Override
	public CompletableFuture<Boolean> exists(Object id, Class<?> entityClass) {

		Assert.notNull(id, "Id must not be null");
		Assert.notNull(entityClass, "Entity type must not be null");

		return queryOperations.select(entityClass).matchingId(id)
				.exists((statement) -> doExecute(statement, resultSet -> resultSet.one() != null));
	}

	@Override
	public CompletableFuture<Boolean> exists(Query query, Class<?> entityClass) throws DataAccessException {

		Assert.notNull(query, "Query must not be null");
		Assert.notNull(entityClass, "Entity type must not be null");

		return queryOperations.select(entityClass).matching(query)
				.exists((statement) -> doExecute(statement, resultSet -> resultSet.one() != null));
	}

	@Override
	public <T> CompletableFuture<T> selectOneById(Object id, Class<T> entityClass) {

		Assert.notNull(id, "Id must not be null");
		Assert.notNull(entityClass, "Entity type must not be null");

		return queryOperations.select(entityClass).matchingId(id).select((statement, rowMapper) -> {
			return query(statement, rowMapper).thenApply(it -> it.isEmpty() ? null : it.get(0));
		});
	}

	@Override
	public <T> CompletableFuture<T> insert(T entity) {
		return insert(entity, InsertOptions.empty()).thenApply(EntityWriteResult::getEntity);
	}

	@Override
	public <T> CompletableFuture<EntityWriteResult<T>> insert(T entity, InsertOptions options) {

		Assert.notNull(entity, "Entity must not be null");
		Assert.notNull(options, "InsertOptions must not be null");

		return doInsert(entity, options, getTableName(entity.getClass()));
	}

	private <T> CompletableFuture<EntityWriteResult<T>> doInsert(T entity, WriteOptions options,
			CqlIdentifier tableName) {

		AdaptibleEntity<T> source = entityOperations.forEntity(maybeCallBeforeConvert(entity, tableName),
				getConverter().getConversionService());
		CassandraPersistentEntity<?> persistentEntity = getRequiredPersistentEntity(entity.getClass());

		T entityToUse = source.isVersionedEntity() ? source.initializeVersionProperty() : source.getBean();

		StatementBuilder<RegularInsert> builder = getStatementFactory().insert(entityToUse, options, persistentEntity,
				tableName);

		if (source.isVersionedEntity()) {

			builder.apply(Insert::ifNotExists);
			return doInsertVersioned(builder.build(), entityToUse, source, tableName);
		}

		return doInsert(builder.build(), entityToUse, source, tableName);
	}

	private <T> CompletableFuture<EntityWriteResult<T>> doInsertVersioned(SimpleStatement insert, T entity,
			AdaptibleEntity<T> source, CqlIdentifier tableName) {

		return executeSave(entity, tableName, insert, result -> {

			if (!result.wasApplied()) {
				throw OptimisticLockingUtils.insertFailed(source);
			}
		});
	}

	@SuppressWarnings("unused")
	private <T> CompletableFuture<EntityWriteResult<T>> doInsert(SimpleStatement insert, T entity,
			AdaptibleEntity<T> source, CqlIdentifier tableName) {

		return executeSave(entity, tableName, insert);
	}

	@Override
	public CompletableFuture<WriteResult> insertJson(String json, Class<?> entityClass) {
		return insertJson(json, entityClass, InsertOptions.empty());
	}

	@Override
	public CompletableFuture<WriteResult> insertJson(String json, Class<?> entityClass, InsertOptions options) {

		Assert.hasText(json, "JSON must not be empty");
		Assert.notNull(entityClass, "Entity type must not be null");
		Assert.notNull(options, "InsertOptions must not be null");

		StatementBuilder<JsonInsert> builder = getStatementFactory().insertJson(json, options,
				getRequiredPersistentEntity(entityClass), getTableName(entityClass));

		return doQueryForResultSet(builder.build())
				.thenApply(resultSet -> new WriteResult(Collections.singletonList(resultSet.getExecutionInfo()),
						resultSet.wasApplied(), getFirstPage(resultSet)));
	}

	@Override
	public <T> CompletableFuture<T> update(T entity) {
		return update(entity, UpdateOptions.empty()).thenApply(EntityWriteResult::getEntity);
	}

	@Override
	public <T> CompletableFuture<EntityWriteResult<T>> update(T entity, UpdateOptions options) {

		Assert.notNull(entity, "Entity must not be null");
		Assert.notNull(options, "UpdateOptions must not be null");

		AdaptibleEntity<T> source = entityOperations.forEntity(entity, getConverter().getConversionService());
		CassandraPersistentEntity<?> persistentEntity = getRequiredPersistentEntity(entity.getClass());
		CqlIdentifier tableName = persistentEntity.getTableName();

		T entityToUpdate = maybeCallBeforeConvert(entity, tableName);

		return source.isVersionedEntity() ? doUpdateVersioned(entityToUpdate, options, tableName, persistentEntity)
				: doUpdate(entityToUpdate, options, tableName, persistentEntity);
	}

	private <T> CompletableFuture<EntityWriteResult<T>> doUpdateVersioned(T entity, UpdateOptions options,
			CqlIdentifier tableName, CassandraPersistentEntity<?> persistentEntity) {

		AdaptibleEntity<T> source = entityOperations.forEntity(entity, getConverter().getConversionService());
		Number previousVersion = source.getVersion();
		T toSave = source.incrementVersion();

		StatementBuilder<Update> update = getStatementFactory().update(toSave, options, persistentEntity, tableName);
		source.appendVersionCondition(update, previousVersion);

		return executeSave(toSave, tableName, update.build(), result -> {

			if (!result.wasApplied()) {
				throw OptimisticLockingUtils.updateFailed(source);
			}
		});
	}

	private <T> CompletableFuture<EntityWriteResult<T>> doUpdate(T entity, UpdateOptions options, CqlIdentifier tableName,
			CassandraPersistentEntity<?> persistentEntity) {

		StatementBuilder<Update> update = getStatementFactory().update(entity, options, persistentEntity, tableName);

		return executeSave(entity, tableName, update.build());
	}

	@Override
	public <T> CompletableFuture<T> delete(T entity) {
		return delete(entity, QueryOptions.empty()).thenApply(writeResult -> entity);
	}

	@Override
	public CompletableFuture<WriteResult> delete(Object entity, QueryOptions options) {

		Assert.notNull(entity, "Entity must not be null");
		Assert.notNull(options, "QueryOptions must not be null");

		AdaptibleEntity<Object> source = entityOperations.forEntity(entity, getConverter().getConversionService());
		CassandraPersistentEntity<?> persistentEntity = getRequiredPersistentEntity(entity.getClass());
		CqlIdentifier tableName = persistentEntity.getTableName();

		return source.isVersionedEntity() ? doDeleteVersioned(entity, options, source, tableName)
				: doDelete(entity, options, tableName);
	}

	private CompletableFuture<WriteResult> doDeleteVersioned(Object entity, QueryOptions options,
			AdaptibleEntity<Object> source, CqlIdentifier tableName) {

		StatementBuilder<Delete> delete = getStatementFactory().delete(entity, options, getConverter(), tableName);

		return executeDelete(entity, tableName, source.appendVersionCondition(delete).build(), result -> {

			if (!result.wasApplied()) {
				throw OptimisticLockingUtils.deleteFailed(source);
			}
		});
	}

	private CompletableFuture<WriteResult> doDelete(Object entity, QueryOptions options, CqlIdentifier tableName) {

		StatementBuilder<Delete> delete = getStatementFactory().delete(entity, options, getConverter(), tableName);

		return executeDelete(entity, tableName, delete.build(), result -> {});
	}

	@Override
	public CompletableFuture<Boolean> deleteById(Object id, Class<?> entityClass) {

		Assert.notNull(id, "Id must not be null");
		Assert.notNull(entityClass, "Entity type must not be null");

		CassandraPersistentEntity<?> entity = getRequiredPersistentEntity(entityClass);
		CqlIdentifier tableName = entity.getTableName();

		StatementBuilder<Delete> builder = getStatementFactory().deleteById(id, entity, tableName);
		SimpleStatement delete = builder.build();

		maybeEmitEvent(() -> new BeforeDeleteEvent<>(delete, entityClass, tableName));

		CompletableFuture<Boolean> future = doExecute(delete, AsyncResultSet::wasApplied);
		future.thenAccept(success -> maybeEmitEvent(() -> new AfterDeleteEvent<>(delete, entityClass, tableName)));

		return future;
	}

	@Override
	public CompletableFuture<Void> truncate(Class<?> entityClass) {

		Assert.notNull(entityClass, "Entity type must not be null");

		CassandraPersistentEntity<?> entity = getRequiredPersistentEntity(entityClass);
		CqlIdentifier tableName = entity.getTableName();

		Truncate truncate = QueryBuilder.truncate(entity.getKeyspace(), tableName);
		SimpleStatement statement = truncate.build();

		maybeEmitEvent(() -> new BeforeDeleteEvent<>(statement, entityClass, tableName));

		CompletableFuture<Boolean> future = doExecute(statement, AsyncResultSet::wasApplied);
		future.thenAccept(success -> maybeEmitEvent(() -> new AfterDeleteEvent<>(statement, entityClass, tableName)));

		return future.thenApply(aBoolean -> null);
	}

	// -------------------------------------------------------------------------
	// Implementation hooks and utility methods
	// -------------------------------------------------------------------------

	/**
	 * Create a new statement-based {@link AsyncPreparedStatementHandler} using the statement passed in.
	 * <p>
	 * This method allows for the creation to be overridden by subclasses.
	 *
	 * @param statement the statement to be prepared.
	 * @return the new {@link PreparedStatementHandler} to use.
	 * @since 3.3.3
	 */
	protected AsyncPreparedStatementHandler createPreparedStatementHandler(Statement<?> statement) {
		return new PreparedStatementHandler(statement);
	}

	protected <E extends CassandraMappingEvent<T>, T> void maybeEmitEvent(Supplier<E> event) {
		this.eventDelegate.publishEvent(event);
	}

	protected <T> T maybeCallBeforeConvert(T object, CqlIdentifier tableName) {

		if (null != entityCallbacks) {
			return entityCallbacks.callback(BeforeConvertCallback.class, object, tableName);
		}

		return object;
	}

	protected <T> T maybeCallBeforeSave(T object, CqlIdentifier tableName, Statement<?> statement) {

		if (null != entityCallbacks) {
			return entityCallbacks.callback(BeforeSaveCallback.class, object, tableName, statement);
		}

		return object;
	}

	private <T> CompletableFuture<EntityWriteResult<T>> executeSave(T entity, CqlIdentifier tableName,
			SimpleStatement statement) {

		return executeSave(entity, tableName, statement, ignore -> {});
	}

	private <T> CompletableFuture<EntityWriteResult<T>> executeSave(T entity, CqlIdentifier tableName,
			SimpleStatement statement, Consumer<WriteResult> beforeAfterSaveEvent) {

		maybeEmitEvent(() -> new BeforeSaveEvent<>(entity, tableName, statement));
		T entityToSave = maybeCallBeforeSave(entity, tableName, statement);

		CompletableFuture<AsyncResultSet> result = doQueryForResultSet(statement);

		return result.thenApply(resultSet -> {

			EntityWriteResult<T> writeResult = new EntityWriteResult<>(
					Collections.singletonList(resultSet.getExecutionInfo()), resultSet.wasApplied(), getFirstPage(resultSet),
					entityToSave);

			beforeAfterSaveEvent.accept(writeResult);

			maybeEmitEvent(() -> new AfterSaveEvent<>(entityToSave, tableName));

			return writeResult;
		});
	}

	private CompletableFuture<WriteResult> executeDelete(Object entity, CqlIdentifier tableName,
			SimpleStatement statement, Consumer<WriteResult> resultConsumer) {

		maybeEmitEvent(() -> new BeforeDeleteEvent<>(statement, entity.getClass(), tableName));

		CompletableFuture<AsyncResultSet> result = doQueryForResultSet(statement);

		return result.thenApply(resultSet -> {

			WriteResult writeResult = new WriteResult(Collections.singletonList(resultSet.getExecutionInfo()),
					resultSet.wasApplied(), getFirstPage(resultSet));

			resultConsumer.accept(writeResult);

			maybeEmitEvent(() -> new AfterDeleteEvent<>(statement, entity.getClass(), tableName));

			return writeResult;
		});
	}

	<T> CompletableFuture<List<T>> query(Statement<?> statement, RowMapper<T> rowMapper) {

		if (PreparedStatementDelegate.canPrepare(isUsePreparedStatements(), statement, log)) {

			AsyncPreparedStatementHandler statementHandler = createPreparedStatementHandler(statement);
			return getAsyncCqlOperations().query(statementHandler, statementHandler, rowMapper);
		}

		return getAsyncCqlOperations().query(statement, rowMapper);
	}

	CompletableFuture<Void> query(Statement<?> statement, RowCallbackHandler callbackHandler) {

		if (PreparedStatementDelegate.canPrepare(isUsePreparedStatements(), statement, log)) {

			AsyncPreparedStatementHandler statementHandler = createPreparedStatementHandler(statement);
			return getAsyncCqlOperations().query(statementHandler, statementHandler, callbackHandler);
		}

		return getAsyncCqlOperations().query(statement, callbackHandler);
	}

	private CompletableFuture<AsyncResultSet> doQueryForResultSet(Statement<?> statement) {
		return doExecute(statement, Function.identity());
	}

	private <T extends @Nullable Object> CompletableFuture<T> doExecute(Statement<?> statement,
			Function<AsyncResultSet, T> mappingFunction) {

		if (PreparedStatementDelegate.canPrepare(isUsePreparedStatements(), statement, log)) {

			AsyncPreparedStatementHandler statementHandler = createPreparedStatementHandler(statement);

			return getAsyncCqlOperations().query(statementHandler, statementHandler,
					(AsyncResultSetExtractor<T>) resultSet -> CompletableFuture
							.completedFuture(mappingFunction.apply(resultSet)));
		}

		return getAsyncCqlOperations().queryForResultSet(statement).thenApply(mappingFunction);
	}

	private CqlIdentifier getTableName(Class<?> entityClass) {
		return queryOperations.getTableName(entityClass);
	}

	private CassandraPersistentEntity<?> getRequiredPersistentEntity(Class<?> entityType) {
		return queryOperations.getRequiredPersistentEntity(entityType);
	}

	private int getEffectivePageSize(Statement<?> statement) {

		if (statement.getPageSize() > 0) {
			return statement.getPageSize();
		}

		if (getAsyncCqlOperations() instanceof CassandraAccessor accessor) {

			if (accessor.getPageSize() != -1) {
				return accessor.getPageSize();
			}
		}

		class GetConfiguredPageSize implements AsyncSessionCallback<Integer>, CqlProvider {
			@Override
			public CompletableFuture<Integer> doInSession(CqlSession session) {
				return CompletableFuture.completedFuture(CassandraTemplate.getConfiguredPageSize(session));
			}

			@Override
			public String getCql() {
				return QueryExtractorDelegate.getCql(statement);
			}
		}

		return getAsyncCqlOperations().execute(new GetConfiguredPageSize()).join();
	}

	private static List<Row> getFirstPage(AsyncResultSet resultSet) {
		return StreamSupport.stream(resultSet.currentPage().spliterator(), false).collect(Collectors.toList());
	}

	/**
	 * General callback interface used to create and bind prepared CQL statements.
	 * <p>
	 * This interface prepares the CQL statement and sets values on a {@link PreparedStatement} as union-type comprised
	 * from {@link AsyncPreparedStatementCreator}, {@link PreparedStatementBinder}, and {@link CqlProvider}.
	 *
	 * @since 3.3.3
	 */
	public interface AsyncPreparedStatementHandler
			extends AsyncPreparedStatementCreator, PreparedStatementBinder, CqlProvider {

	}

	/**
	 * Utility class to prepare a {@link SimpleStatement} and bind values associated with the statement to a
	 * {@link BoundStatement}.
	 *
	 * @since 3.2
	 */
	static class PreparedStatementHandler implements AsyncPreparedStatementHandler {

		private final SimpleStatement statement;

		public PreparedStatementHandler(Statement<?> statement) {
			this.statement = PreparedStatementDelegate.getStatementForPrepare(statement);
		}

		@Override
		public CompletableFuture<PreparedStatement> createPreparedStatement(CqlSession session) throws DriverException {
			return doPrepare(session).toCompletableFuture();
		}

		/**
		 * Invokes the statement preparation.
		 *
		 * @param session
		 * @return
		 */
		protected CompletionStage<PreparedStatement> doPrepare(CqlSession session) {
			return session.prepareAsync(statement.getQuery());
		}

		@Override
		public BoundStatement bindValues(PreparedStatement ps) throws DriverException {
			return PreparedStatementDelegate.bind(statement, ps);
		}

		@Override
		public String getCql() {
			return statement.getQuery();
		}

	}
}

---

8.6 spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/ReactiveCassandraOperations.java

+62 — interface: same four methods with Flux/Mono return types.

/*
 * Copyright 2016-present the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.springframework.data.cassandra.core;

import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

import org.springframework.dao.DataAccessException;
import org.springframework.data.cassandra.ReactiveResultSet;
import org.springframework.data.cassandra.core.convert.CassandraConverter;
import org.springframework.data.cassandra.core.cql.QueryOptions;
import org.springframework.data.cassandra.core.cql.ReactiveCqlOperations;
import org.springframework.data.cassandra.core.cql.WriteOptions;
import org.springframework.data.cassandra.core.query.CassandraPageRequest;
import org.springframework.data.cassandra.core.query.Query;
import org.springframework.data.cassandra.core.query.Update;
import org.springframework.data.domain.Slice;

import com.datastax.oss.driver.api.core.cql.BatchType;
import com.datastax.oss.driver.api.core.cql.Statement;

/**
 * Interface specifying a basic set of reactive Cassandra operations. Implemented by {@link ReactiveCassandraTemplate}.
 * Not often used directly, but a useful option to enhance testability, as it can easily be mocked or stubbed.
 *
 * @author Mark Paluch
 * @author Hleb Albau
 * @author Oleh Dokuka
 * @author Sam Lightfoot
 * @since 2.0
 * @see ReactiveCassandraTemplate
 * @see ReactiveCqlOperations
 * @see Statement
 * @see InsertOptions
 * @see UpdateOptions
 * @see Flux
 * @see Mono
 */
public interface ReactiveCassandraOperations extends ReactiveFluentCassandraOperations {

	/**
	 * Returns a new {@link ReactiveCassandraBatchOperations} using {@link BatchType#LOGGED}. Each
	 * {@link ReactiveCassandraBatchOperations} instance can be executed only once, so you need to obtain new
	 * {@link ReactiveCassandraBatchOperations} instances for each batch.
	 *
	 * @return a new {@link ReactiveCassandraBatchOperations} associated with the given entity class.
	 * @since 2.1
	 * @see #batchOps(BatchType)
	 */
	default ReactiveCassandraBatchOperations batchOps() {
		return batchOps(BatchType.LOGGED);
	}

	/**
	 * Returns a new {@link ReactiveCassandraBatchOperations}. Each {@link ReactiveCassandraBatchOperations} instance can
	 * be executed only once, so you need to obtain new {@link ReactiveCassandraBatchOperations} instances for each batch.
	 *
	 * @param batchType must not be {@literal null}.
	 * @return a new {@link ReactiveCassandraBatchOperations} associated with the given entity class.
	 * @since 3.2.6
	 */
	ReactiveCassandraBatchOperations batchOps(BatchType batchType);

	/**
	 * Expose the underlying {@link ReactiveCqlOperations} to allow CQL operations.
	 *
	 * @return the underlying {@link ReactiveCqlOperations}.
	 * @see ReactiveCqlOperations
	 */
	ReactiveCqlOperations getReactiveCqlOperations();

	/**
	 * Returns the underlying {@link CassandraConverter}.
	 *
	 * @return the underlying {@link CassandraConverter}.
	 */
	CassandraConverter getConverter();

	// -------------------------------------------------------------------------
	// Methods dealing with static CQL
	// -------------------------------------------------------------------------

	/**
	 * Execute a {@code SELECT} query and convert the resulting items to a stream of entities.
	 *
	 * @param cql must not be {@literal null}.
	 * @param entityClass The entity type must not be {@literal null}.
	 * @return the converted results
	 * @throws DataAccessException if there is any problem issuing the execution.
	 */
	<T> Flux<T> select(String cql, Class<T> entityClass) throws DataAccessException;

	/**
	 * Execute a {@code SELECT} query and convert the resulting item to an entity.
	 *
	 * @param cql must not be {@literal null}.
	 * @param entityClass The entity type must not be {@literal null}.
	 * @return the result object returned by the action or {@link Mono#empty()}
	 * @throws DataAccessException if there is any problem issuing the execution.
	 */
	<T> Mono<T> selectOne(String cql, Class<T> entityClass) throws DataAccessException;

	// -------------------------------------------------------------------------
	// Methods dealing with com.datastax.oss.driver.api.core.cql.Statement
	// -------------------------------------------------------------------------

	/**
	 * Execute a {@code SELECT} query and convert the resulting items to a stream of entities.
	 *
	 * @param statement must not be {@literal null}.
	 * @param entityClass The entity type must not be {@literal null}.
	 * @return the result objects returned by the action.
	 * @throws DataAccessException if there is any problem issuing the execution.
	 */
	<T> Flux<T> select(Statement<?> statement, Class<T> entityClass) throws DataAccessException;

	/**
	 * Execute a {@code SELECT} query with paging and convert the result set to a {@link Slice} of entities. A sliced
	 * query translates the effective {@link Statement#getPageSize() fetch size} to the page size.
	 *
	 * @param statement the CQL statement, must not be {@literal null}.
	 * @param entityClass The entity type must not be {@literal null}.
	 * @return the result object returned by the action or {@link Mono#just(Object)} of an empty {@link Slice}.
	 * @throws DataAccessException if there is any problem executing the query.
	 * @since 2.1
	 */
	<T> Mono<Slice<T>> slice(Statement<?> statement, Class<T> entityClass) throws DataAccessException;

	/**
	 * Execute a {@code SELECT} query and convert the resulting item to an entity.
	 *
	 * @param statement must not be {@literal null}.
	 * @param entityClass The entity type must not be {@literal null}.
	 * @return the result object returned by the action or {@link Mono#empty()}
	 * @throws DataAccessException if there is any problem issuing the execution.
	 */
	<T> Mono<T> selectOne(Statement<?> statement, Class<T> entityClass) throws DataAccessException;

	// -------------------------------------------------------------------------
	// Methods dealing with org.springframework.data.cassandra.core.query.Query
	// -------------------------------------------------------------------------

	/**
	 * Execute the given Cassandra {@link Statement}. Any errors that result from executing this command will be converted
	 * into Spring's DAO exception hierarchy.
	 *
	 * @param statement a Cassandra {@link Statement}, must not be {@literal null}.
	 * @return the {@link ReactiveResultSet}.
	 * @throws DataAccessException if there is any problem issuing the execution.
	 * @since 3.2
	 */
	Mono<ReactiveResultSet> execute(Statement<?> statement) throws DataAccessException;

	/**
	 * Execute a {@code SELECT} query and convert the resulting items to a stream of entities.
	 *
	 * @param query must not be {@literal null}.
	 * @param entityClass The entity type must not be {@literal null}.
	 * @return the result objects returned by the action.
	 * @throws DataAccessException if there is any problem issuing the execution.
	 */
	<T> Flux<T> select(Query query, Class<T> entityClass) throws DataAccessException;

	/**
	 * Execute a {@code SELECT} query with paging and convert the result set to a {@link Slice} of entities.
	 *
	 * @param query the query object used to create a CQL statement, must not be {@literal null}.
	 * @param entityClass The entity type must not be {@literal null}.
	 * @return the result object returned by the action or {@link Mono#just(Object)} of an empty {@link Slice}.
	 * @throws DataAccessException if there is any problem executing the query.
	 * @since 2.1
	 * @see CassandraPageRequest
	 */
	<T> Mono<Slice<T>> slice(Query query, Class<T> entityClass) throws DataAccessException;

	/**
	 * Execute a {@code SELECT} query and convert the resulting item to an entity.
	 *
	 * @param query must not be {@literal null}.
	 * @param entityClass The entity type must not be {@literal null}.
	 * @return the result object returned by the action or {@link Mono#empty()}.
	 * @throws DataAccessException if there is any problem issuing the execution.
	 */
	<T> Mono<T> selectOne(Query query, Class<T> entityClass) throws DataAccessException;

	/**
	 * Execute a {@code SELECT JSON} query and return the resulting rows as their JSON representation. Each returned
	 * {@link String} contains a JSON-encoded row in which the keys correspond to column names as defined by the
	 * Cassandra {@code SELECT JSON} semantics.
	 *
	 * @param query must not be {@literal null}.
	 * @param entityClass the entity type used to resolve the table name, must not be {@literal null}.
	 * @return a stream of JSON-encoded rows.
	 * @throws DataAccessException if there is any problem issuing the execution.
	 * @since 5.2
	 */
	Flux<String> selectJson(Query query, Class<?> entityClass) throws DataAccessException;

	/**
	 * Execute a {@code SELECT JSON} query and return the resulting row as its JSON representation. The returned
	 * {@link String} contains a JSON-encoded row in which the keys correspond to column names as defined by the
	 * Cassandra {@code SELECT JSON} semantics.
	 *
	 * @param query must not be {@literal null}.
	 * @param entityClass the entity type used to resolve the table name, must not be {@literal null}.
	 * @return the JSON-encoded row or {@link Mono#empty()}.
	 * @throws DataAccessException if there is any problem issuing the execution.
	 * @since 5.2
	 */
	Mono<String> selectOneJson(Query query, Class<?> entityClass) throws DataAccessException;

	/**
	 * Update the queried entities and return {@literal true} if the update was applied.
	 *
	 * @param query must not be {@literal null}.
	 * @param update must not be {@literal null}.
	 * @param entityClass The entity type must not be {@literal null}.
	 * @throws DataAccessException if there is any problem executing the query.
	 */
	Mono<Boolean> update(Query query, Update update, Class<?> entityClass) throws DataAccessException;

	/**
	 * Remove entities (rows)/columns from the table by {@link Query}.
	 *
	 * @param query must not be {@literal null}.
	 * @param entityClass The entity type must not be {@literal null}.
	 * @return {@literal true} if the deletion was applied.
	 * @throws DataAccessException if there is any problem issuing the execution.
	 */
	Mono<Boolean> delete(Query query, Class<?> entityClass) throws DataAccessException;

	// -------------------------------------------------------------------------
	// Methods dealing with entities
	// -------------------------------------------------------------------------

	/**
	 * Returns the number of rows for the given entity class.
	 *
	 * @param entityClass {@link Class type} of the entity; must not be {@literal null}.
	 * @return the number of existing entities.
	 * @throws DataAccessException if any problem occurs while executing the query.
	 */
	Mono<Long> count(Class<?> entityClass) throws DataAccessException;

	/**
	 * Returns the number of rows for the given entity class applying {@link Query}. This overridden method allows users
	 * to further refine the selection criteria using a {@link Query} predicate to determine how many entities of the
	 * given {@link Class type} match the criteria.
	 *
	 * @param query user-defined count {@link Query} to execute; must not be {@literal null}.
	 * @param entityClass {@link Class type} of the entity; must not be {@literal null}.
	 * @return the number of existing entities.
	 * @throws DataAccessException if any problem occurs while executing the query.
	 * @since 2.1
	 */
	Mono<Long> count(Query query, Class<?> entityClass) throws DataAccessException;

	/**
	 * Determine whether a row of {@code entityClass} with the given {@code id} exists.
	 *
	 * @param id Id value. For single primary keys it's the plain value. For composite primary keys either, it's an
	 *          instance of either {@link org.springframework.data.cassandra.core.mapping.PrimaryKeyClass} or
	 *          {@link org.springframework.data.cassandra.core.mapping.MapId}. Must not be {@literal null}.
	 * @param entityClass {@link Class type} of the entity; must not be {@literal null}.
	 * @return {@literal true} if the object exists.
	 * @throws DataAccessException if any problem occurs while executing the query.
	 */
	Mono<Boolean> exists(Object id, Class<?> entityClass) throws DataAccessException;

	/**
	 * Determine whether the result for {@code entityClass} {@link Query} yields at least one row.
	 *
	 * @param query user-defined exists {@link Query} to execute; must not be {@literal null}.
	 * @param entityClass {@link Class type} of the entity; must not be {@literal null}.
	 * @return {@literal true} if the object exists.
	 * @throws DataAccessException if any problem occurs while executing the query.
	 * @since 2.1
	 */
	Mono<Boolean> exists(Query query, Class<?> entityClass) throws DataAccessException;

	/**
	 * Execute the Select by {@code id} for the given {@code entityClass}.
	 *
	 * @param id the Id value. For single primary keys it's the plain value. For composite primary keys either the
	 *          {@link org.springframework.data.cassandra.core.mapping.PrimaryKeyClass} or
	 *          {@link org.springframework.data.cassandra.core.mapping.MapId}. Must not be {@literal null}.
	 * @param entityClass The entity type must not be {@literal null}.
	 * @return the result object returned by the action or {@link Mono#empty()}
	 * @throws DataAccessException if there is any problem issuing the execution.
	 */
	<T> Mono<T> selectOneById(Object id, Class<T> entityClass) throws DataAccessException;

	/**
	 * Insert the given entity and emit the entity if the insert was applied.
	 *
	 * @param entity The entity to insert, must not be {@literal null}.
	 * @return the inserted entity.
	 * @throws DataAccessException if there is any problem issuing the execution.
	 */
	<T> Mono<T> insert(T entity) throws DataAccessException;

	/**
	 * Insert the given entity applying {@link WriteOptions} and emit the entity if the insert was applied.
	 *
	 * @param entity The entity to insert, must not be {@literal null}.
	 * @param options must not be {@literal null}.
	 * @return the {@link EntityWriteResult} for this operation.
	 * @throws DataAccessException if there is any problem issuing the execution.
	 * @see InsertOptions#empty()
	 */
	<T> Mono<EntityWriteResult<T>> insert(T entity, InsertOptions options) throws DataAccessException;

	/**
	 * Insert the given JSON payload into the table of {@code entityClass} using an {@code INSERT JSON} statement. The
	 * JSON keys are expected to map to column names as defined by the Cassandra {@code INSERT JSON} semantics. Columns
	 * omitted from the JSON payload are left unset ({@code DEFAULT UNSET}).
	 * <p>
	 * Note that mapping between the JSON payload and the table happens within Cassandra so entity lifecycle events and
	 * callbacks are not invoked.
	 *
	 * @param json the JSON payload to insert, must not be {@literal null} or empty.
	 * @param entityClass the entity type used to resolve the table name, must not be {@literal null}.
	 * @return the {@link WriteResult} for this operation.
	 * @throws DataAccessException if there is any problem issuing the execution.
	 * @since 5.2
	 */
	Mono<WriteResult> insertJson(String json, Class<?> entityClass) throws DataAccessException;

	/**
	 * Insert the given JSON payload into the table of {@code entityClass} using an {@code INSERT JSON} statement
	 * applying {@link InsertOptions}. The JSON keys are expected to map to column names as defined by the Cassandra
	 * {@code INSERT JSON} semantics. Columns omitted from the JSON payload are left unset ({@code DEFAULT UNSET}) unless
	 * {@link InsertOptions#isInsertNulls()} is set, in which case omitted columns are inserted as {@code null}
	 * ({@code DEFAULT NULL}).
	 * <p>
	 * Note that mapping between the JSON payload and the table happens within Cassandra so entity lifecycle events and
	 * callbacks are not invoked.
	 *
	 * @param json the JSON payload to insert, must not be {@literal null} or empty.
	 * @param entityClass the entity type used to resolve the table name, must not be {@literal null}.
	 * @param options must not be {@literal null}.
	 * @return the {@link WriteResult} for this operation.
	 * @throws DataAccessException if there is any problem issuing the execution.
	 * @see InsertOptions#empty()
	 * @since 5.2
	 */
	Mono<WriteResult> insertJson(String json, Class<?> entityClass, InsertOptions options) throws DataAccessException;

	/**
	 * Update the given entity and emit the entity if the update was applied.
	 *
	 * @param entity The entity to update, must not be {@literal null}.
	 * @return the updated entity.
	 * @throws DataAccessException if there is any problem issuing the execution.
	 */
	<T> Mono<T> update(T entity) throws DataAccessException;

	/**
	 * Update the given entity applying {@link WriteOptions} and emit the entity if the update was applied.
	 *
	 * @param entity The entity to update, must not be {@literal null}.
	 * @param options must not be {@literal null}.
	 * @return the {@link EntityWriteResult} for this operation.
	 * @throws DataAccessException if there is any problem issuing the execution.
	 * @see UpdateOptions#empty()
	 */
	<T> Mono<EntityWriteResult<T>> update(T entity, UpdateOptions options) throws DataAccessException;

	/**
	 * Delete the given entity and emit the entity if the delete statement was applied.
	 *
	 * @param entity must not be {@literal null}.
	 * @return the deleted entity.
	 * @throws DataAccessException if there is any problem issuing the execution.
	 */
	<T> Mono<T> delete(T entity) throws DataAccessException;

	/**
	 * Delete the given entity applying {@link QueryOptions} and emit the entity if the delete statement was applied.
	 *
	 * @param entity must not be {@literal null}.
	 * @param options must not be {@literal null}.
	 * @return the {@link WriteResult} for this operation.
	 * @throws DataAccessException if there is any problem issuing the execution.
	 * @see QueryOptions#empty()
	 */
	Mono<WriteResult> delete(Object entity, QueryOptions options) throws DataAccessException;

	/**
	 * Delete the given entity applying {@link QueryOptions} and emit the entity if the delete statement was applied.
	 *
	 * @param entity must not be {@literal null}.
	 * @param options must not be {@literal null}.
	 * @return the {@link WriteResult} for this operation.
	 * @throws DataAccessException if there is any problem issuing the execution.
	 * @see DeleteOptions#empty()
	 * @since 2.2
	 */
	default Mono<WriteResult> delete(Object entity, DeleteOptions options) throws DataAccessException {
		return delete(entity, (QueryOptions) options);
	}

	/**
	 * Remove the given object from the table by id.
	 *
	 * @param id the Id value. For single primary keys it's the plain value. For composite primary keys either the
	 *          {@link org.springframework.data.cassandra.core.mapping.PrimaryKeyClass} or
	 *          {@link org.springframework.data.cassandra.core.mapping.MapId}. Must not be {@literal null}.
	 * @param entityClass The entity type must not be {@literal null}.
	 * @return {@literal true} if the deletion was applied.
	 * @throws DataAccessException if there is any problem issuing the execution.
	 */
	Mono<Boolean> deleteById(Object id, Class<?> entityClass) throws DataAccessException;

	/**
	 * Execute a {@code TRUNCATE} query to remove all entities of a given class.
	 *
	 * @param entityClass The entity type must not be {@literal null}.
	 * @throws DataAccessException if there is any problem issuing the execution.
	 */
	Mono<Void> truncate(Class<?> entityClass) throws DataAccessException;
}

---

8.7 spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/ReactiveCassandraTemplate.java

+40 — implementations: selectJson via doQuery, selectOneJson applies query.limit(1) (mirrors existing selectOne), insertJson via doExecuteAndFlatMap(…, toWriteResult); import JsonInsert.

/*
 * Copyright 2016-present the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.springframework.data.cassandra.core;

import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import reactor.core.publisher.SynchronousSink;

import java.util.Collections;
import java.util.function.BiConsumer;
import java.util.function.Function;
import java.util.function.Supplier;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.jspecify.annotations.Nullable;
import org.reactivestreams.Publisher;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.ApplicationEventPublisherAware;
import org.springframework.dao.DataAccessException;
import org.springframework.dao.support.DataAccessUtils;
import org.springframework.data.cassandra.ReactiveResultSet;
import org.springframework.data.cassandra.ReactiveSession;
import org.springframework.data.cassandra.ReactiveSessionFactory;
import org.springframework.data.cassandra.core.EntityOperations.AdaptibleEntity;
import org.springframework.data.cassandra.core.convert.CassandraConverter;
import org.springframework.data.cassandra.core.convert.MappingCassandraConverter;
import org.springframework.data.cassandra.core.cql.*;
import org.springframework.data.cassandra.core.cql.session.DefaultReactiveSessionFactory;
import org.springframework.data.cassandra.core.cql.util.StatementBuilder;
import org.springframework.data.cassandra.core.mapping.CassandraPersistentEntity;
import org.springframework.data.cassandra.core.mapping.SimpleUserTypeResolver;
import org.springframework.data.cassandra.core.mapping.event.AfterDeleteEvent;
import org.springframework.data.cassandra.core.mapping.event.AfterLoadEvent;
import org.springframework.data.cassandra.core.mapping.event.AfterSaveEvent;
import org.springframework.data.cassandra.core.mapping.event.BeforeDeleteEvent;
import org.springframework.data.cassandra.core.mapping.event.BeforeSaveEvent;
import org.springframework.data.cassandra.core.mapping.event.CassandraMappingEvent;
import org.springframework.data.cassandra.core.mapping.event.ReactiveBeforeConvertCallback;
import org.springframework.data.cassandra.core.mapping.event.ReactiveBeforeSaveCallback;
import org.springframework.data.cassandra.core.query.Query;
import org.springframework.data.domain.Slice;
import org.springframework.data.domain.SliceImpl;
import org.springframework.data.mapping.callback.EntityCallbacks;
import org.springframework.data.mapping.callback.ReactiveEntityCallbacks;
import org.springframework.util.Assert;

import com.datastax.oss.driver.api.core.CqlIdentifier;
import com.datastax.oss.driver.api.core.DriverException;
import com.datastax.oss.driver.api.core.cql.BatchType;
import com.datastax.oss.driver.api.core.cql.BoundStatement;
import com.datastax.oss.driver.api.core.cql.PreparedStatement;
import com.datastax.oss.driver.api.core.cql.SimpleStatement;
import com.datastax.oss.driver.api.core.cql.Statement;
import com.datastax.oss.driver.api.querybuilder.QueryBuilder;
import com.datastax.oss.driver.api.querybuilder.delete.Delete;
import com.datastax.oss.driver.api.querybuilder.insert.Insert;
import com.datastax.oss.driver.api.querybuilder.insert.JsonInsert;
import com.datastax.oss.driver.api.querybuilder.insert.RegularInsert;
import com.datastax.oss.driver.api.querybuilder.select.Select;
import com.datastax.oss.driver.api.querybuilder.truncate.Truncate;
import com.datastax.oss.driver.api.querybuilder.update.Update;

/**
 * Primary implementation of {@link ReactiveCassandraOperations}. It simplifies the use of Reactive Cassandra usage and
 * helps to avoid common errors. It executes core Cassandra workflow. This class executes CQL queries or updates,
 * initiating iteration over {@link ReactiveResultSet} and catching Cassandra exceptions and translating them to the
 * generic, more informative exception hierarchy defined in the {@code org.springframework.dao} package.
 * <p>
 * Can be used within a service implementation via direct instantiation with a {@link ReactiveSessionFactory} reference,
 * or get prepared in an application context and given to services as bean reference.
 * <p>
 * This class supports the use of prepared statements when enabling {@link #setUsePreparedStatements(boolean)}. All
 * statements created by methods of this class (such as {@link #select(Query, Class)} or
 * {@link #update(Query, org.springframework.data.cassandra.core.query.Update, Class)} will be executed as prepared
 * statements. Also, statements accepted by methods (such as {@link #select(String, Class)} or
 * {@link #select(Statement, Class) and others}) will be prepared prior to execution. Note that {@link Statement}
 * objects passed to methods must be {@link SimpleStatement} so that these can be prepared.
 * <p>
 * Note: The {@link ReactiveSessionFactory} should always be configured as a bean in the application context, in the
 * first case given to the service directly, in the second case to the prepared template.
 *
 * @author Mark Paluch
 * @author John Blum
 * @author Lukasz Antoniak
 * @author Hleb Albau
 * @author Sam Lightfoot
 * @since 2.0
 */
public class ReactiveCassandraTemplate
		implements ReactiveCassandraOperations, ApplicationEventPublisherAware, ApplicationContextAware {

	private final Log log = LogFactory.getLog(getClass());

	private final ReactiveCqlOperations cqlOperations;

	private final EntityLifecycleEventDelegate eventDelegate;

	private final CassandraConverter converter;

	private final StatementFactory statementFactory;

	private final EntityOperations entityOperations;

	private final QueryOperations queryOperations;

	private @Nullable ReactiveEntityCallbacks entityCallbacks;

	private boolean usePreparedStatements = true;

	/**
	 * Creates an instance of {@link ReactiveCassandraTemplate} initialized with the given {@link ReactiveSession} and a
	 * default {@link MappingCassandraConverter}.
	 *
	 * @param session {@link ReactiveSession} used to interact with Cassandra; must not be {@literal null}.
	 * @see CassandraConverter
	 * @see ReactiveSession
	 */
	public ReactiveCassandraTemplate(ReactiveSession session) {
		this(session, CassandraTemplate.createConverter(
				new SimpleUserTypeResolver(session::getMetadata, session.getKeyspace().orElse(CqlIdentifier.fromCql("system"))),
				session.getContext()));
	}

	/**
	 * Create an instance of {@link CassandraTemplate} initialized with the given {@link ReactiveSession} and
	 * {@link CassandraConverter}.
	 *
	 * @param session {@link ReactiveSession} used to interact with Cassandra; must not be {@literal null}.
	 * @param converter {@link CassandraConverter} used to convert between Java and Cassandra types; must not be
	 *          {@literal null}.
	 * @see org.springframework.data.cassandra.core.convert.CassandraConverter
	 * @see ReactiveSession
	 */
	public ReactiveCassandraTemplate(ReactiveSession session, CassandraConverter converter) {
		this(new DefaultReactiveSessionFactory(session), converter);
	}

	/**
	 * Create an instance of {@link ReactiveCassandraTemplate} initialized with the given {@link ReactiveSessionFactory}
	 * and {@link CassandraConverter}.
	 *
	 * @param sessionFactory {@link ReactiveSessionFactory} used to interact with Cassandra; must not be {@literal null}.
	 * @param converter {@link CassandraConverter} used to convert between Java and Cassandra types; must not be
	 *          {@literal null}.
	 * @see org.springframework.data.cassandra.core.convert.CassandraConverter
	 * @see ReactiveSession
	 */
	public ReactiveCassandraTemplate(ReactiveSessionFactory sessionFactory, CassandraConverter converter) {
		this(new ReactiveCqlTemplate(sessionFactory), converter);
	}

	/**
	 * Create an instance of {@link ReactiveCassandraTemplate} initialized with the given {@link ReactiveCqlOperations}
	 * and {@link CassandraConverter}.
	 *
	 * @param reactiveCqlOperations {@link ReactiveCqlOperations} used to interact with Cassandra; must not be
	 *          {@literal null}.
	 * @param converter {@link CassandraConverter} used to convert between Java and Cassandra types; must not be
	 *          {@literal null}.
	 * @see org.springframework.data.cassandra.core.convert.CassandraConverter
	 * @see ReactiveSession
	 */
	public ReactiveCassandraTemplate(ReactiveCqlOperations reactiveCqlOperations, CassandraConverter converter) {

		Assert.notNull(reactiveCqlOperations, "ReactiveCqlOperations must not be null");
		Assert.notNull(converter, "CassandraConverter must not be null");

		this.converter = converter;
		this.eventDelegate = new EntityLifecycleEventDelegate();
		this.cqlOperations = reactiveCqlOperations;
		this.statementFactory = new StatementFactory(converter);
		this.entityOperations = new EntityOperations(converter);
		this.queryOperations = new QueryOperations(converter, this.statementFactory, this.eventDelegate);
	}

	@Override
	public ReactiveCassandraBatchOperations batchOps(BatchType batchType) {
		return new ReactiveCassandraBatchTemplate(this, batchType);
	}

	@Override
	public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
		this.eventDelegate.setPublisher(applicationEventPublisher);
	}

	@Override
	public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {

		if (entityCallbacks == null) {
			setEntityCallbacks(ReactiveEntityCallbacks.create(applicationContext));
		}
	}

	/**
	 * Configure {@link EntityCallbacks} to pre-/post-process entities during persistence operations.
	 *
	 * @param entityCallbacks
	 */
	public void setEntityCallbacks(@Nullable ReactiveEntityCallbacks entityCallbacks) {
		this.entityCallbacks = entityCallbacks;
	}

	/**
	 * Configure whether lifecycle events such as {@link AfterLoadEvent}, {@link BeforeSaveEvent}, etc. should be
	 * published or whether emission should be suppressed. Enabled by default.
	 *
	 * @param enabled {@code true} to enable entity lifecycle events; {@code false} to disable entity lifecycle events.
	 * @since 4.0
	 * @see CassandraMappingEvent
	 */
	public void setEntityLifecycleEventsEnabled(boolean enabled) {
		this.eventDelegate.setEventsEnabled(enabled);
	}

	@Override
	public ReactiveCqlOperations getReactiveCqlOperations() {
		return this.cqlOperations;
	}

	@Override
	public CassandraConverter getConverter() {
		return this.converter;
	}

	/**
	 * Returns the {@link StatementFactory} used by this template to construct and run Cassandra CQL statements.
	 *
	 * @return the {@link StatementFactory} used by this template to construct and run Cassandra CQL statements.
	 * @see org.springframework.data.cassandra.core.StatementFactory
	 * @since 2.1
	 */
	public StatementFactory getStatementFactory() {
		return this.statementFactory;
	}

	/**
	 * Returns whether this instance is configured to use {@link PreparedStatement prepared statements}. If enabled
	 * (default), then all persistence methods (such as {@link #select}, {@link #update}, and others) will make use of
	 * prepared statements. Note that methods accepting a {@link Statement} must be called with {@link SimpleStatement}
	 * instances to participate in statement preparation.
	 *
	 * @return {@literal true} if prepared statements usage is enabled; {@literal false} otherwise.
	 * @since 3.2
	 */
	public boolean isUsePreparedStatements() {
		return usePreparedStatements;
	}

	/**
	 * Enable/disable {@link PreparedStatement prepared statements} usage. If enabled (default), then all persistence
	 * methods (such as {@link #select}, {@link #update}, and others) will make use of prepared statements. Note that
	 * methods accepting a {@link Statement} must be called with {@link SimpleStatement} instances to participate in
	 * statement preparation.
	 *
	 * @param usePreparedStatements whether to use prepared statements.
	 * @since 3.2
	 */
	public void setUsePreparedStatements(boolean usePreparedStatements) {
		this.usePreparedStatements = usePreparedStatements;
	}

	// -------------------------------------------------------------------------
	// Methods dealing with static CQL
	// -------------------------------------------------------------------------

	@Override
	public <T> Flux<T> select(String cql, Class<T> entityClass) {

		Assert.hasText(cql, "CQL must not be empty");

		return select(SimpleStatement.newInstance(cql), entityClass);
	}

	@Override
	public <T> Mono<T> selectOne(String cql, Class<T> entityClass) {
		return select(cql, entityClass).next();
	}

	// -------------------------------------------------------------------------
	// Methods dealing with com.datastax.oss.driver.api.core.cql.Statement
	// -------------------------------------------------------------------------

	@Override
	public Mono<ReactiveResultSet> execute(Statement<?> statement) throws DataAccessException {

		Assert.notNull(statement, "Statement must not be null");

		return execute(statement, Function.identity());
	}

	@Override
	public <T> Flux<T> select(Statement<?> statement, Class<T> entityClass) {

		Assert.notNull(statement, "Statement must not be null");
		Assert.notNull(entityClass, "Entity type must not be null");

		RowMapper<T> mapper = queryOperations.getRowMapper(entityClass, statement);
		return doQuery(statement, mapper);
	}

	@Override
	public <T> Mono<T> selectOne(Statement<?> statement, Class<T> entityClass) {
		return select(statement, entityClass).next();
	}

	@Override
	public <T> Mono<Slice<T>> slice(Statement<?> statement, Class<T> entityClass) {

		Assert.notNull(statement, "Statement must not be null");
		Assert.notNull(entityClass, "Entity type must not be null");

		RowMapper<T> mapper = queryOperations.getRowMapper(entityClass, statement);
		return doSlice(statement, mapper);
	}

	// -------------------------------------------------------------------------
	// Methods dealing with org.springframework.data.cassandra.core.query.Query
	// -------------------------------------------------------------------------

	@Override
	public <T> Flux<T> select(Query query, Class<T> entityClass) throws DataAccessException {

		Assert.notNull(query, "Query must not be null");
		Assert.notNull(entityClass, "Entity type must not be null");

		return select(query, entityClass, getTableName(entityClass), entityClass, QueryResultConverter.entity());
	}

	<T, R> Flux<R> select(Query query, Class<?> entityClass, CqlIdentifier tableName, Class<T> returnType,
			QueryResultConverter<? super T, ? extends R> mappingFunction) {

		return queryOperations.select(entityClass, tableName).<T, R> project(returnType, mappingFunction).matching(query)
				.select(this::doQuery);
	}

	@Override
	public <T> Mono<T> selectOne(Query query, Class<T> entityClass) throws DataAccessException {

		Assert.notNull(query, "Query must not be null");
		Assert.notNull(entityClass, "Entity type must not be null");

		return select(query.limit(1), entityClass).next();
	}

	@Override
	public Flux<String> selectJson(Query query, Class<?> entityClass) throws DataAccessException {

		Assert.notNull(query, "Query must not be null");
		Assert.notNull(entityClass, "Entity type must not be null");

		StatementBuilder<Select> select = getStatementFactory().selectJson(query,
				getRequiredPersistentEntity(entityClass), getTableName(entityClass));

		return doQuery(select.build(), SingleColumnRowMapper.newInstance(String.class));
	}

	@Override
	public Mono<String> selectOneJson(Query query, Class<?> entityClass) throws DataAccessException {

		Assert.notNull(query, "Query must not be null");
		Assert.notNull(entityClass, "Entity type must not be null");

		return selectJson(query.limit(1), entityClass).next();
	}

	@Override
	public <T> Mono<Slice<T>> slice(Query query, Class<T> entityClass) throws DataAccessException {

		Assert.notNull(query, "Query must not be null");
		Assert.notNull(entityClass, "Entity type must not be null");

		return queryOperations.select(entityClass).matching(query).select(this::doSlice);
	}

	@Override
	public Mono<Boolean> update(Query query, org.springframework.data.cassandra.core.query.Update update,
			Class<?> entityClass) throws DataAccessException {

		Assert.notNull(query, "Query must not be null");
		Assert.notNull(update, "Update must not be null");
		Assert.notNull(entityClass, "Entity type must not be null");

		return doUpdate(query, update, entityClass, getTableName(entityClass)).map(WriteResult::wasApplied);
	}

	Mono<WriteResult> doUpdate(Query query, org.springframework.data.cassandra.core.query.Update update,
			Class<?> entityClass, CqlIdentifier tableName) {

		StatementBuilder<Update> statement = getStatementFactory().update(query, update,
				getRequiredPersistentEntity(entityClass), tableName);

		return doExecuteAndFlatMap(statement.build(), ReactiveCassandraTemplate::toWriteResult);
	}

	@Override
	public Mono<Boolean> delete(Query query, Class<?> entityClass) throws DataAccessException {

		Assert.notNull(query, "Query must not be null");
		Assert.notNull(entityClass, "Entity type must not be null");

		return doDelete(query, entityClass, getTableName(entityClass)).map(WriteResult::wasApplied);
	}

	Mono<WriteResult> doDelete(Query query, Class<?> entityClass, CqlIdentifier tableName) {

		StatementBuilder<Delete> builder = getStatementFactory().delete(query, getRequiredPersistentEntity(entityClass),
				tableName);

		SimpleStatement delete = builder.build();

		Mono<WriteResult> writeResult = doExecuteAndFlatMap(delete, ReactiveCassandraTemplate::toWriteResult)
				.doOnSubscribe(it -> maybeEmitEvent(() -> new BeforeDeleteEvent<>(delete, entityClass, tableName)));

		return writeResult.doOnNext(it -> maybeEmitEvent(() -> new AfterDeleteEvent<>(delete, entityClass, tableName)));
	}

	// -------------------------------------------------------------------------
	// Methods dealing with entities
	// -------------------------------------------------------------------------

	@Override
	public Mono<Long> count(Class<?> entityClass) {

		Assert.notNull(entityClass, "Entity type must not be null");

		return doCount(Query.empty(), entityClass, getTableName(entityClass));
	}

	@Override
	public Mono<Long> count(Query query, Class<?> entityClass) throws DataAccessException {

		Assert.notNull(query, "Query must not be null");
		Assert.notNull(entityClass, "Entity type must not be null");

		return doCount(query, entityClass, getTableName(entityClass));
	}

	Mono<Long> doCount(Query query, Class<?> entityClass, CqlIdentifier tableName) {

		StatementBuilder<Select> count = getStatementFactory().count(query, getRequiredPersistentEntity(entityClass),
				tableName);

		SingleColumnRowMapper<Long> mapper = SingleColumnRowMapper.newInstance(Long.class);

		Mono<Long> mono = doExecuteAndFlatMap(count.build(), rs -> rs.rows() //
				.map(it -> mapper.mapRow(it, 0)) //
				.buffer() //
				.map(DataAccessUtils::nullableSingleResult).next());

		return mono.switchIfEmpty(Mono.just(0L));
	}

	@Override
	public Mono<Boolean> exists(Object id, Class<?> entityClass) {

		Assert.notNull(id, "Id must not be null");
		Assert.notNull(entityClass, "Entity type must not be null");

		return doExists(queryOperations.select(entityClass).matchingId(id));
	}

	@Override
	public Mono<Boolean> exists(Query query, Class<?> entityClass) throws DataAccessException {

		Assert.notNull(query, "Query must not be null");
		Assert.notNull(entityClass, "Entity type must not be null");

		return doExists(query, entityClass, getTableName(entityClass));
	}

	Mono<Boolean> doExists(Query query, Class<?> entityClass, CqlIdentifier tableName) {
		return doExists(queryOperations.select(entityClass, tableName).matching(query));
	}

	private Mono<Boolean> doExists(QueryOperations.TerminalExists exists) {

		return exists.exists(statement -> execute(statement, ReactiveResultSet::rows)).flatMapMany(Function.identity())
				.hasElements();
	}

	@Override
	public <T> Mono<T> selectOneById(Object id, Class<T> entityClass) {

		Assert.notNull(id, "Id must not be null");
		Assert.notNull(entityClass, "Entity type must not be null");

		return queryOperations.select(entityClass).matchingId(id).select(this::doQuery).next();
	}

	@Override
	public <T> Mono<T> insert(T entity) {
		return insert(entity, InsertOptions.empty()).map(EntityWriteResult::getEntity);
	}

	@Override
	public <T> Mono<EntityWriteResult<T>> insert(T entity, InsertOptions options) {

		Assert.notNull(entity, "Entity must not be null");
		Assert.notNull(options, "InsertOptions must not be null");

		return doInsert(entity, options, getTableName(entity.getClass()));
	}

	<T> Mono<EntityWriteResult<T>> doInsert(T entity, WriteOptions options, CqlIdentifier tableName) {

		return maybeCallBeforeConvert(entity, tableName).flatMap(entityToInsert -> {

			AdaptibleEntity<T> source = this.entityOperations.forEntity(entityToInsert,
					getConverter().getConversionService());
			CassandraPersistentEntity<?> persistentEntity = getRequiredPersistentEntity(entityToInsert.getClass());

			T entityToUse = source.isVersionedEntity() ? source.initializeVersionProperty() : entityToInsert;

			StatementBuilder<RegularInsert> builder = getStatementFactory().insert(entityToUse, options, persistentEntity,
					tableName);

			if (source.isVersionedEntity()) {
				builder.apply(Insert::ifNotExists);
				return doInsertVersioned(builder.build(), entityToUse, source, tableName);
			}

			return doInsert(builder.build(), entityToUse, tableName);
		});
	}

	private <T> Mono<EntityWriteResult<T>> doInsertVersioned(SimpleStatement insert, T entity, AdaptibleEntity<T> source,
			CqlIdentifier tableName) {

		return executeSave(entity, tableName, insert, (result, sink) -> {
			if (result.wasApplied()) {
				sink.next(result);
			} else {
				sink.error(OptimisticLockingUtils.insertFailed(source));
			}
		});
	}

	private <T> Mono<EntityWriteResult<T>> doInsert(SimpleStatement insert, T entity, CqlIdentifier tableName) {
		return executeSave(entity, tableName, insert);
	}

	@Override
	public Mono<WriteResult> insertJson(String json, Class<?> entityClass) {
		return insertJson(json, entityClass, InsertOptions.empty());
	}

	@Override
	public Mono<WriteResult> insertJson(String json, Class<?> entityClass, InsertOptions options) {

		Assert.hasText(json, "JSON must not be empty");
		Assert.notNull(entityClass, "Entity type must not be null");
		Assert.notNull(options, "InsertOptions must not be null");

		StatementBuilder<JsonInsert> builder = getStatementFactory().insertJson(json, options,
				getRequiredPersistentEntity(entityClass), getTableName(entityClass));

		return doExecuteAndFlatMap(builder.build(), ReactiveCassandraTemplate::toWriteResult);
	}

	@Override
	public <T> Mono<T> update(T entity) {
		return update(entity, UpdateOptions.empty()).map(EntityWriteResult::getEntity);
	}

	@Override
	public <T> Mono<EntityWriteResult<T>> update(T entity, UpdateOptions options) {

		Assert.notNull(entity, "Entity must not be null");
		Assert.notNull(options, "UpdateOptions must not be null");

		AdaptibleEntity<T> source = this.entityOperations.forEntity(entity, getConverter().getConversionService());
		CassandraPersistentEntity<?> persistentEntity = getRequiredPersistentEntity(entity.getClass());
		CqlIdentifier tableName = persistentEntity.getTableName();

		return maybeCallBeforeConvert(entity, tableName).flatMap(entityToUpdate -> {
			return source.isVersionedEntity() ? doUpdateVersioned(entity, options, tableName, persistentEntity)
					: doUpdate(entity, options, tableName, persistentEntity);
		});
	}

	private <T> Mono<EntityWriteResult<T>> doUpdateVersioned(T entity, UpdateOptions options, CqlIdentifier tableName,
			CassandraPersistentEntity<?> persistentEntity) {

		AdaptibleEntity<T> source = entityOperations.forEntity(entity, getConverter().getConversionService());

		Number previousVersion = source.getVersion();
		T toSave = source.incrementVersion();

		StatementBuilder<Update> builder = getStatementFactory().update(toSave, options, persistentEntity, tableName);
		SimpleStatement update = source.appendVersionCondition(builder, previousVersion).build();

		return executeSave(toSave, tableName, update, (result, sink) -> {
			if (result.wasApplied()) {
				sink.next(result);
			} else {
				sink.error(OptimisticLockingUtils.updateFailed(source));
			}
		});
	}

	private <T> Mono<EntityWriteResult<T>> doUpdate(T entity, UpdateOptions options, CqlIdentifier tableName,
			CassandraPersistentEntity<?> persistentEntity) {

		StatementBuilder<Update> builder = getStatementFactory().update(entity, options, persistentEntity, tableName);

		return executeSave(entity, tableName, builder.build());
	}

	@Override
	public <T> Mono<T> delete(T entity) {
		return delete(entity, QueryOptions.empty()).map(reactiveWriteResult -> entity);
	}

	@Override
	public Mono<WriteResult> delete(Object entity, QueryOptions options) {

		Assert.notNull(entity, "Entity must not be null");
		Assert.notNull(options, "QueryOptions must not be null");

		AdaptibleEntity<Object> source = this.entityOperations.forEntity(entity, getConverter().getConversionService());
		CassandraPersistentEntity<?> persistentEntity = getRequiredPersistentEntity(entity.getClass());
		CqlIdentifier tableName = persistentEntity.getTableName();

		StatementBuilder<Delete> builder = getStatementFactory().delete(entity, options, getConverter(), tableName);

		return source.isVersionedEntity()
				? doDeleteVersioned(source.appendVersionCondition(builder).build(), entity, source, tableName)
				: doDelete(builder.build(), entity, tableName);
	}

	private Mono<WriteResult> doDeleteVersioned(SimpleStatement delete, Object entity, AdaptibleEntity<Object> source,
			CqlIdentifier tableName) {

		return executeDelete(entity, tableName, delete, (result, sink) -> {
			if (result.wasApplied()) {
				sink.next(result);
			} else {
				sink.error(OptimisticLockingUtils.deleteFailed(source));
			}
		});
	}

	private Mono<WriteResult> doDelete(SimpleStatement delete, Object entity, CqlIdentifier tableName) {
		return executeDelete(entity, tableName, delete, (result, sink) -> sink.next(result));
	}

	@Override
	public Mono<Boolean> deleteById(Object id, Class<?> entityClass) {

		Assert.notNull(id, "Id must not be null");
		Assert.notNull(entityClass, "Entity type must not be null");

		CassandraPersistentEntity<?> entity = getRequiredPersistentEntity(entityClass);
		CqlIdentifier tableName = entity.getTableName();

		StatementBuilder<Delete> builder = getStatementFactory().deleteById(id, entity, tableName);
		SimpleStatement delete = builder.build();

		Mono<Boolean> result = execute(delete, ReactiveResultSet::wasApplied)
				.doOnSubscribe(it -> maybeEmitEvent(() -> new BeforeDeleteEvent<>(delete, entityClass, tableName)));

		return result.doOnNext(it -> maybeEmitEvent(() -> new AfterDeleteEvent<>(delete, entityClass, tableName)));
	}

	@Override
	public Mono<Void> truncate(Class<?> entityClass) {

		Assert.notNull(entityClass, "Entity type must not be null");

		CassandraPersistentEntity<?> entity = getRequiredPersistentEntity(entityClass);
		CqlIdentifier tableName = entity.getTableName();

		Truncate truncate = QueryBuilder.truncate(entity.getKeyspace(), tableName);
		SimpleStatement statement = truncate.build();

		Mono<Boolean> result = execute(statement, ReactiveResultSet::wasApplied)
				.doOnSubscribe(it -> maybeEmitEvent(() -> new BeforeDeleteEvent<>(statement, entityClass, tableName)));

		return result.doOnNext(it -> maybeEmitEvent(() -> new AfterDeleteEvent<>(statement, entityClass, tableName)))
				.then();
	}

	// -------------------------------------------------------------------------
	// Fluent API entry points
	// -------------------------------------------------------------------------

	@Override
	public ReactiveDelete delete(Class<?> domainType) {
		return new ReactiveDeleteOperationSupport(this).delete(domainType);
	}

	@Override
	public <T> ReactiveInsert<T> insert(Class<T> domainType) {
		return new ReactiveInsertOperationSupport(this).insert(domainType);
	}

	@Override
	public <T> ReactiveSelect<T> query(Class<T> domainType) {
		return new ReactiveSelectOperationSupport(this, this.queryOperations).query(domainType);
	}

	@Override
	public UntypedSelect query(String cql) {
		return new ReactiveSelectOperationSupport(this, this.queryOperations).query(cql);
	}

	@Override
	public UntypedSelect query(Statement<?> statement) {
		return new ReactiveSelectOperationSupport(this, this.queryOperations).query(statement);
	}

	@Override
	public ReactiveUpdate update(Class<?> domainType) {
		return new ReactiveUpdateOperationSupport(this).update(domainType);
	}

	// -------------------------------------------------------------------------
	// Implementation hooks and utility methods
	// -------------------------------------------------------------------------

	/**
	 * Create a new statement-based {@link ReactivePreparedStatementHandler} using the statement passed in.
	 * <p>
	 * This method allows for the creation to be overridden by subclasses.
	 *
	 * @param statement the statement to be prepared.
	 * @return the new {@link PreparedStatementHandler} to use.
	 * @since 3.3.3
	 */
	protected ReactivePreparedStatementHandler createPreparedStatementHandler(Statement<?> statement) {
		return new PreparedStatementHandler(statement);
	}

	protected <E extends CassandraMappingEvent<T>, T> void maybeEmitEvent(Supplier<E> event) {
		this.eventDelegate.publishEvent(event);
	}

	protected <T> Mono<T> maybeCallBeforeConvert(T object, CqlIdentifier tableName) {

		if (null != entityCallbacks) {
			return entityCallbacks.callback(ReactiveBeforeConvertCallback.class, object, tableName);
		}

		return Mono.just(object);
	}

	protected <T> Mono<T> maybeCallBeforeSave(T object, CqlIdentifier tableName, Statement<?> statement) {

		if (null != entityCallbacks) {
			return entityCallbacks.callback(ReactiveBeforeSaveCallback.class, object, tableName, statement);
		}

		return Mono.just(object);
	}

	private <T> Mono<EntityWriteResult<T>> executeSave(T entity, CqlIdentifier tableName, SimpleStatement statement) {
		return executeSave(entity, tableName, statement, (writeResult, sink) -> sink.next(writeResult));
	}

	private <T> Mono<EntityWriteResult<T>> executeSave(T entity, CqlIdentifier tableName, SimpleStatement statement,
			BiConsumer<EntityWriteResult<T>, SynchronousSink<EntityWriteResult<T>>> handler) {

		return Mono.defer(() -> {

			maybeEmitEvent(() -> new BeforeSaveEvent<>(entity, tableName, statement));

			return maybeCallBeforeSave(entity, tableName, statement).flatMapMany(entityToSave -> {
				Mono<WriteResult> execute = doExecuteAndFlatMap(statement, ReactiveCassandraTemplate::toWriteResult);

				return execute.map(it -> EntityWriteResult.of(it, entityToSave)).handle(handler) //
						.doOnNext(it -> maybeEmitEvent(() -> new AfterSaveEvent<>(entityToSave, tableName)));
			}).next();
		});
	}

	private Mono<WriteResult> executeDelete(Object entity, CqlIdentifier tableName, SimpleStatement statement,
			BiConsumer<WriteResult, SynchronousSink<WriteResult>> handler) {

		maybeEmitEvent(() -> new BeforeDeleteEvent<>(statement, entity.getClass(), tableName));

		Mono<WriteResult> execute = doExecuteAndFlatMap(statement, ReactiveCassandraTemplate::toWriteResult);

		return execute.map(it -> EntityWriteResult.of(it, entity)).handle(handler) //
				.doOnSubscribe(it -> maybeEmitEvent(() -> new BeforeSaveEvent<>(entity, tableName, statement))) //
				.doOnNext(it -> maybeEmitEvent(() -> new AfterDeleteEvent<>(statement, entity.getClass(), tableName)));
	}

	<T> Flux<T> doQuery(Statement<?> statement, RowMapper<T> rowMapper) {

		if (PreparedStatementDelegate.canPrepare(isUsePreparedStatements(), statement, log)) {

			ReactivePreparedStatementHandler statementHandler = createPreparedStatementHandler(statement);
			return getReactiveCqlOperations().query(statementHandler, statementHandler, rowMapper);
		}

		return getReactiveCqlOperations().query(statement, rowMapper);
	}

	<T> Mono<Slice<T>> doSlice(Statement<?> statement, RowMapper<T> rowMapper) {

		Mono<ReactiveResultSet> resultSetMono = execute(statement, Function.identity());
		Mono<Integer> effectiveFetchSizeMono = getEffectiveFetchSize(statement);

		return resultSetMono.zipWith(effectiveFetchSizeMono).flatMap(tuple -> {

			ReactiveResultSet resultSet = tuple.getT1();
			Integer effectiveFetchSize = tuple.getT2();

			return resultSet.availableRows().collectList().map(it -> EntityQueryUtils.readSlice(it,
					resultSet.getExecutionInfo().getPagingState(), rowMapper, 1, effectiveFetchSize));

		}).defaultIfEmpty(new SliceImpl<>(Collections.emptyList()));
	}

	<T> Mono<T> execute(Statement<?> statement, Function<ReactiveResultSet, T> mappingFunction) {

		if (PreparedStatementDelegate.canPrepare(isUsePreparedStatements(), statement, log)) {

			ReactivePreparedStatementHandler statementHandler = createPreparedStatementHandler(statement);
			return getReactiveCqlOperations()
					.query(statementHandler, statementHandler, rs -> Mono.just(mappingFunction.apply(rs))).next();
		}

		return getReactiveCqlOperations().queryForResultSet(statement).map(mappingFunction);
	}

	private <T> Mono<T> doExecuteAndFlatMap(Statement<?> statement,
			Function<ReactiveResultSet, Mono<T>> mappingFunction) {

		if (PreparedStatementDelegate.canPrepare(isUsePreparedStatements(), statement, log)) {

			ReactivePreparedStatementHandler statementHandler = createPreparedStatementHandler(statement);
			return getReactiveCqlOperations().query(statementHandler, statementHandler, mappingFunction::apply).next();
		}

		return getReactiveCqlOperations().queryForResultSet(statement).flatMap(mappingFunction);
	}

	CqlIdentifier getTableName(Class<?> entityClass) {
		return queryOperations.getTableName(entityClass);
	}

	private CassandraPersistentEntity<?> getRequiredPersistentEntity(Class<?> entityType) {
		return queryOperations.getRequiredPersistentEntity(entityType);
	}

	private Mono<Integer> getEffectiveFetchSize(Statement<?> statement) {

		if (statement.getPageSize() > 0) {
			return Mono.just(statement.getPageSize());
		}

		if (getReactiveCqlOperations() instanceof CassandraAccessor) {
			CassandraAccessor accessor = (CassandraAccessor) getReactiveCqlOperations();
			if (accessor.getPageSize() != -1) {
				return Mono.just(accessor.getPageSize());
			}
		}

		class GetConfiguredPageSize implements ReactiveSessionCallback<Integer>, CqlProvider {
			@Override
			public Publisher<Integer> doInSession(ReactiveSession session) {
				return Mono.just(CassandraTemplate.getConfiguredPageSize(session.getContext()));
			}

			@Override
			public String getCql() {
				return QueryExtractorDelegate.getCql(statement);
			}
		}

		return getReactiveCqlOperations().execute(new GetConfiguredPageSize()).single();
	}

	static Mono<WriteResult> toWriteResult(ReactiveResultSet resultSet) {
		return resultSet.rows().collectList()
				.map(rows -> new WriteResult(resultSet.getAllExecutionInfo(), resultSet.wasApplied(), rows));
	}

	/**
	 * General callback interface used to create and bind prepared CQL statements.
	 * <p>
	 * This interface prepares the CQL statement and sets values on a {@link PreparedStatement} as union-type comprised
	 * from {@link ReactivePreparedStatementCreator}, {@link PreparedStatementBinder}, and {@link CqlProvider}.
	 *
	 * @since 3.3.3
	 */
	public interface ReactivePreparedStatementHandler
			extends ReactivePreparedStatementCreator, PreparedStatementBinder, CqlProvider {

	}

	/**
	 * Utility class to prepare a {@link SimpleStatement} and bind values associated with the statement to a
	 * {@link BoundStatement}.
	 *
	 * @since 3.2
	 */
	public static class PreparedStatementHandler implements ReactivePreparedStatementHandler {

		private final SimpleStatement statement;

		public PreparedStatementHandler(Statement<?> statement) {
			this.statement = PreparedStatementDelegate.getStatementForPrepare(statement);
		}

		@Override
		public Mono<PreparedStatement> createPreparedStatement(ReactiveSession session) throws DriverException {

			// Note that prepared statement settings like the keyspace are gone because using the prepare method with a
			// statement object causes cache pollution
			return session.prepare(statement.getQuery());
		}

		@Override
		public BoundStatement bindValues(PreparedStatement ps) throws DriverException {
			return PreparedStatementDelegate.bind(statement, ps);
		}

		@Override
		public String getCql() {
			return statement.getQuery();
		}
	}
}

---

End of Part 1 — continue with Part 2 (sections 8.8–8.16).

[patpatpat123]

Add JSON support to CassandraTemplate — resolves GH-212 (DATACASS-36)

PART 2 of 2 — Kotlin extensions, tests and documentation (sections 8.8–8.16).
The review report (sections 1–7) and the main source files (8.1–8.7) are in Part 1.

8. Changed files — complete contents, continued

Replace each file below wholesale with the block content. Paths are relative to the repository root.

8.8 spring-data-cassandra/src/main/kotlin/org/springframework/data/cassandra/core/CassandraOperationsExtensions.kt

+28 — reified extensions selectJson<T>, selectOneJson<T>, insertJson<T> ×2.

/*
 * Copyright 2018-present the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.springframework.data.cassandra.core

import com.datastax.oss.driver.api.core.CqlIdentifier
import com.datastax.oss.driver.api.core.cql.Statement
import org.springframework.data.cassandra.core.query.Query
import org.springframework.data.cassandra.core.query.Update
import org.springframework.data.domain.Slice
import java.util.stream.Stream

/**
 * Extensions for [CassandraOperations].
 *
 * @author Mark Paluch
 * @since 2.1
 */

/**
 * Extension for [CassandraOperations.getTableName] leveraging reified type parameters.
 */
inline fun <reified T : Any> CassandraOperations.getTableName(): CqlIdentifier =
		getTableName(T::class.java)

// -------------------------------------------------------------------------
// Methods dealing with static CQL
// -------------------------------------------------------------------------

/**
 * Extension for [CassandraOperations.select] leveraging reified type parameters.
 */
inline fun <reified T : Any> CassandraOperations.select(cql: String): List<T> =
		select(cql, T::class.java)

/**
 * Extension for [CassandraOperations.stream] leveraging reified type parameters.
 */
inline fun <reified T : Any> CassandraOperations.stream(cql: String): Stream<T> =
		stream(cql, T::class.java)

/**
 * Extension for [CassandraOperations.selectOne] leveraging reified type parameters.
 */
inline fun <reified T : Any> CassandraOperations.selectOne(cql: String): T? =
		selectOne(cql, T::class.java)

// -------------------------------------------------------------------------
// Methods dealing with com.datastax.oss.driver.api.core.cql.Statement
// -------------------------------------------------------------------------

/**
 * Extension for [CassandraOperations.select] leveraging reified type parameters.
 */
inline fun <reified T : Any> CassandraOperations.select(statement: Statement<*>): List<T> =
		select(statement, T::class.java)

/**
 * Extension for [CassandraOperations.slice] leveraging reified type parameters.
 */
inline fun <reified T : Any> CassandraOperations.slice(statement: Statement<*>): Slice<T> =
		slice(statement, T::class.java)

/**
 * Extension for [CassandraOperations.stream] leveraging reified type parameters.
 */
inline fun <reified T : Any> CassandraOperations.stream(statement: Statement<*>): Stream<T> =
		stream(statement, T::class.java)

/**
 * Extension for [CassandraOperations.selectOne] leveraging reified type parameters.
 */
inline fun <reified T : Any> CassandraOperations.selectOne(statement: Statement<*>): T? =
		selectOne(statement, T::class.java)

// -------------------------------------------------------------------------
// Methods dealing with org.springframework.data.cassandra.core.query.Query
// -------------------------------------------------------------------------

/**
 * Extension for [CassandraOperations.select] leveraging reified type parameters.
 */
inline fun <reified T : Any> CassandraOperations.select(query: Query): List<T> =
		select(query, T::class.java)

/**
 * Extension for [CassandraOperations.slice] leveraging reified type parameters.
 */
inline fun <reified T : Any> CassandraOperations.slice(query: Query): Slice<T> =
		slice(query, T::class.java)

/**
 * Extension for [CassandraOperations.stream] leveraging reified type parameters.
 */
inline fun <reified T : Any> CassandraOperations.stream(query: Query): Stream<T> =
		stream(query, T::class.java)

/**
 * Extension for [CassandraOperations.selectOne] leveraging reified type parameters.
 */
inline fun <reified T : Any> CassandraOperations.selectOne(query: Query): T? =
		selectOne(query, T::class.java)

/**
 * Extension for [CassandraOperations.selectJson] leveraging reified type parameters.
 * @since 5.2
 */
inline fun <reified T : Any> CassandraOperations.selectJson(query: Query): List<String> =
		selectJson(query, T::class.java)

/**
 * Extension for [CassandraOperations.selectOneJson] leveraging reified type parameters.
 * @since 5.2
 */
inline fun <reified T : Any> CassandraOperations.selectOneJson(query: Query): String? =
		selectOneJson(query, T::class.java)

/**
 * Extension for [CassandraOperations.update] leveraging reified type parameters.
 */
inline fun <reified T : Any> CassandraOperations.update(query: Query, update: Update): Boolean =
		update(query, update, T::class.java)

/**
 * Extension for [CassandraOperations.delete] leveraging reified type parameters.
 */
@Suppress("EXTENSION_SHADOWED_BY_MEMBER")
inline fun <reified T : Any> CassandraOperations.delete(query: Query): Boolean =
		delete(query, T::class.java)

// -------------------------------------------------------------------------
// Methods dealing with entities
// -------------------------------------------------------------------------

/**
 * Extension for [CassandraOperations.insertJson] leveraging reified type parameters.
 * @since 5.2
 */
inline fun <reified T : Any> CassandraOperations.insertJson(json: String): WriteResult =
		insertJson(json, T::class.java)

/**
 * Extension for [CassandraOperations.insertJson] leveraging reified type parameters.
 * @since 5.2
 */
inline fun <reified T : Any> CassandraOperations.insertJson(json: String, options: InsertOptions): WriteResult =
		insertJson(json, T::class.java, options)

/**
 * Extension for [CassandraOperations.count] leveraging reified type parameters.
 */
inline fun <reified T : Any> CassandraOperations.count(): Long =
		count(T::class.java)

/**
 * Extension for [CassandraOperations.count] leveraging reified type parameters.
 */
inline fun <reified T : Any> CassandraOperations.count(query: Query): Long =
		count(query, T::class.java)

/**
 * Extension for [CassandraOperations.exists] leveraging reified type parameters.
 */
inline fun <reified T : Any> CassandraOperations.exists(id: Any): Boolean =
		exists(id, T::class.java)

/**
 * Extension for [CassandraOperations.count] leveraging reified type parameters.
 */
inline fun <reified T : Any> CassandraOperations.exists(query: Query): Boolean =
		exists(query, T::class.java)

/**
 * Extension for [CassandraOperations.selectOneById] leveraging reified type parameters.
 */
inline fun <reified T : Any> CassandraOperations.selectOneById(id: Any): T? =
		selectOneById(id, T::class.java)

/**
 * Extension for [CassandraOperations.deleteById] leveraging reified type parameters.
 */
inline fun <reified T : Any> CassandraOperations.deleteById(id: Any): Boolean =
		deleteById(id, T::class.java)

/**
 * Extension for [CassandraOperations.truncate] leveraging reified type parameters.
 */
inline fun <reified T : Any> CassandraOperations.truncate(): Unit =
		truncate(T::class.java)

---

8.9 spring-data-cassandra/src/main/kotlin/org/springframework/data/cassandra/core/AsyncCassandraOperationsExtensions.kt

+28 — same, CompletableFuture variants.

/*
 * Copyright 2018-present the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.springframework.data.cassandra.core

import com.datastax.oss.driver.api.core.cql.Statement
import org.springframework.data.cassandra.core.query.Query
import org.springframework.data.cassandra.core.query.Update
import org.springframework.data.domain.Slice
import java.util.concurrent.CompletableFuture

/**
 * Extensions for [AsyncCassandraOperations].
 *
 * @author Mark Paluch
 * @since 2.1
 */

// -------------------------------------------------------------------------
// Methods dealing with static CQL
// -------------------------------------------------------------------------

/**
 * Extension for [AsyncCassandraOperations.select] leveraging reified type parameters.
 */
inline fun <reified T : Any> AsyncCassandraOperations.select(cql: String): CompletableFuture<List<T>> =
	select(cql, T::class.java)

/**
 * Extension for [AsyncCassandraOperations.select] providing a Consumer-like function leveraging reified type parameters.
 */
inline fun <reified T : Any> AsyncCassandraOperations.select(
	cql: String,
	crossinline consumer: (T) -> Unit
): CompletableFuture<Void> =
	select(cql, { consumer(it) }, T::class.java)

/**
 * Extension for [AsyncCassandraOperations.selectOne] leveraging reified type parameters.
 */
inline fun <reified T : Any> AsyncCassandraOperations.selectOne(cql: String): CompletableFuture<T?> =
	selectOne(cql, T::class.java)

// -------------------------------------------------------------------------
// Methods dealing with com.datastax.oss.driver.api.core.cql.Statement
// -------------------------------------------------------------------------

/**
 * Extension for [AsyncCassandraOperations.select] leveraging reified type parameters.
 */
inline fun <reified T : Any> AsyncCassandraOperations.select(statement: Statement<*>): CompletableFuture<List<T>> =
	select(statement, T::class.java)

/**
 * Extension for [AsyncCassandraOperations.select] providing a Consumer-like function leveraging reified type parameters.
 */
inline fun <reified T : Any> AsyncCassandraOperations.select(
	statement: Statement<*>,
	crossinline consumer: (T) -> Unit
): CompletableFuture<Void> =
	select(statement, { consumer(it) }, T::class.java)

/**
 * Extension for [AsyncCassandraOperations.slice] leveraging reified type parameters.
 */
inline fun <reified T : Any> AsyncCassandraOperations.slice(statement: Statement<*>): CompletableFuture<Slice<T>> =
	slice(statement, T::class.java)

/**
 * Extension for [AsyncCassandraOperations.selectOne] leveraging reified type parameters.
 */
inline fun <reified T : Any> AsyncCassandraOperations.selectOne(statement: Statement<*>): CompletableFuture<T?> =
	selectOne(statement, T::class.java)

// -------------------------------------------------------------------------
// Methods dealing with org.springframework.data.cassandra.core.query.Query
// -------------------------------------------------------------------------

/**
 * Extension for [AsyncCassandraOperations.select] leveraging reified type parameters.
 */
inline fun <reified T : Any> AsyncCassandraOperations.select(query: Query): CompletableFuture<List<T>> =
	select(query, T::class.java)

/**
 * Extension for [AsyncCassandraOperations.slice] leveraging reified type parameters.
 */
inline fun <reified T : Any> AsyncCassandraOperations.slice(query: Query): CompletableFuture<Slice<T>> =
	slice(query, T::class.java)

/**
 * Extension for [AsyncCassandraOperations.selectOne] leveraging reified type parameters.
 */
inline fun <reified T : Any> AsyncCassandraOperations.selectOne(query: Query): CompletableFuture<T?> =
	selectOne(query, T::class.java)

/**
 * Extension for [AsyncCassandraOperations.selectJson] leveraging reified type parameters.
 * @since 5.2
 */
inline fun <reified T : Any> AsyncCassandraOperations.selectJson(query: Query): CompletableFuture<List<String>> =
	selectJson(query, T::class.java)

/**
 * Extension for [AsyncCassandraOperations.selectOneJson] leveraging reified type parameters.
 * @since 5.2
 */
inline fun <reified T : Any> AsyncCassandraOperations.selectOneJson(query: Query): CompletableFuture<String?> =
	selectOneJson(query, T::class.java)

/**
 * Extension for [AsyncCassandraOperations.update] leveraging reified type parameters.
 */
inline fun <reified T : Any> AsyncCassandraOperations.update(
	query: Query,
	update: Update
): CompletableFuture<Boolean> =
	update(query, update, T::class.java)

/**
 * Extension for [AsyncCassandraOperations.delete] leveraging reified type parameters.
 */
@Suppress("EXTENSION_SHADOWED_BY_MEMBER")
inline fun <reified T : Any> AsyncCassandraOperations.delete(query: Query): CompletableFuture<Boolean> =
	delete(query, T::class.java)

// -------------------------------------------------------------------------
// Methods dealing with entities
// -------------------------------------------------------------------------

/**
 * Extension for [AsyncCassandraOperations.insertJson] leveraging reified type parameters.
 * @since 5.2
 */
inline fun <reified T : Any> AsyncCassandraOperations.insertJson(json: String): CompletableFuture<WriteResult> =
	insertJson(json, T::class.java)

/**
 * Extension for [AsyncCassandraOperations.insertJson] leveraging reified type parameters.
 * @since 5.2
 */
inline fun <reified T : Any> AsyncCassandraOperations.insertJson(json: String, options: InsertOptions): CompletableFuture<WriteResult> =
	insertJson(json, T::class.java, options)

/**
 * Extension for [AsyncCassandraOperations.count] leveraging reified type parameters.
 */
inline fun <reified T : Any> AsyncCassandraOperations.count(): CompletableFuture<Long> =
	count(T::class.java)

/**
 * Extension for [AsyncCassandraOperations.count] leveraging reified type parameters.
 */
inline fun <reified T : Any> AsyncCassandraOperations.count(query: Query): CompletableFuture<Long> =
	count(query, T::class.java)

/**
 * Extension for [AsyncCassandraOperations.exists] leveraging reified type parameters.
 */
inline fun <reified T : Any> AsyncCassandraOperations.exists(id: Any): CompletableFuture<Boolean> =
	exists(id, T::class.java)

/**
 * Extension for [AsyncCassandraOperations.count] leveraging reified type parameters.
 */
inline fun <reified T : Any> AsyncCassandraOperations.exists(query: Query): CompletableFuture<Boolean> =
	exists(query, T::class.java)

/**
 * Extension for [AsyncCassandraOperations.selectOneById] leveraging reified type parameters.
 */
inline fun <reified T : Any> AsyncCassandraOperations.selectOneById(id: Any): CompletableFuture<T?> =
	selectOneById(id, T::class.java)

/**
 * Extension for [AsyncCassandraOperations.deleteById] leveraging reified type parameters.
 */
inline fun <reified T : Any> AsyncCassandraOperations.deleteById(id: Any): CompletableFuture<Boolean> =
	deleteById(id, T::class.java)

/**
 * Extension for [AsyncCassandraOperations.truncate] leveraging reified type parameters.
 */
inline fun <reified T : Any> AsyncCassandraOperations.truncate(): CompletableFuture<Void> =
	truncate(T::class.java)

---

8.10 spring-data-cassandra/src/main/kotlin/org/springframework/data/cassandra/core/ReactiveCassandraOperationsExtensions.kt

+28 — same, Flux/Mono variants.

/*
 * Copyright 2018-present the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.springframework.data.cassandra.core

import com.datastax.oss.driver.api.core.cql.Statement
import org.springframework.data.cassandra.core.query.Query
import org.springframework.data.cassandra.core.query.Update
import reactor.core.publisher.Flux
import reactor.core.publisher.Mono

/**
 * Extensions for [ReactiveCassandraOperations].
 *
 * @author Mark Paluch
 * @since 2.1
 */

// -------------------------------------------------------------------------
// Methods dealing with static CQL
// -------------------------------------------------------------------------

/**
 * Extension for [ReactiveCassandraOperations.select] leveraging reified type parameters.
 */
inline fun <reified T : Any> ReactiveCassandraOperations.select(cql: String): Flux<T> =
		select(cql, T::class.java)

/**
 * Extension for [ReactiveCassandraOperations.selectOne] leveraging reified type parameters.
 */
inline fun <reified T : Any> ReactiveCassandraOperations.selectOne(cql: String): Mono<T> =
		selectOne(cql, T::class.java)

// -------------------------------------------------------------------------
// Methods dealing with com.datastax.oss.driver.api.core.cql.Statement
// -------------------------------------------------------------------------

/**
 * Extension for [ReactiveCassandraOperations.select] leveraging reified type parameters.
 */
inline fun <reified T : Any> ReactiveCassandraOperations.select(statement: Statement<*>): Flux<T> =
		select(statement, T::class.java)

/**
 * Extension for [ReactiveCassandraOperations.selectOne] leveraging reified type parameters.
 */
inline fun <reified T : Any> ReactiveCassandraOperations.selectOne(statement: Statement<*>): Mono<T> =
		selectOne(statement, T::class.java)

// -------------------------------------------------------------------------
// Methods dealing with org.springframework.data.cassandra.core.query.Query
// -------------------------------------------------------------------------

/**
 * Extension for [ReactiveCassandraOperations.select] leveraging reified type parameters.
 */
inline fun <reified T : Any> ReactiveCassandraOperations.select(query: Query): Flux<T> =
		select(query, T::class.java)

/**
 * Extension for [ReactiveCassandraOperations.selectOne] leveraging reified type parameters.
 */
inline fun <reified T : Any> ReactiveCassandraOperations.selectOne(query: Query): Mono<T> =
		selectOne(query, T::class.java)

/**
 * Extension for [ReactiveCassandraOperations.selectJson] leveraging reified type parameters.
 * @since 5.2
 */
inline fun <reified T : Any> ReactiveCassandraOperations.selectJson(query: Query): Flux<String> =
		selectJson(query, T::class.java)

/**
 * Extension for [ReactiveCassandraOperations.selectOneJson] leveraging reified type parameters.
 * @since 5.2
 */
inline fun <reified T : Any> ReactiveCassandraOperations.selectOneJson(query: Query): Mono<String> =
		selectOneJson(query, T::class.java)

/**
 * Extension for [ReactiveCassandraOperations.update] leveraging reified type parameters.
 */
inline fun <reified T : Any> ReactiveCassandraOperations.update(query: Query, update: Update): Mono<Boolean> =
		update(query, update, T::class.java)

/**
 * Extension for [ReactiveCassandraOperations.delete] leveraging reified type parameters.
 */
@Suppress("EXTENSION_SHADOWED_BY_MEMBER")
inline fun <reified T : Any> ReactiveCassandraOperations.delete(query: Query): Mono<Boolean> =
		delete(query, T::class.java)

// -------------------------------------------------------------------------
// Methods dealing with entities
// -------------------------------------------------------------------------

/**
 * Extension for [ReactiveCassandraOperations.insertJson] leveraging reified type parameters.
 * @since 5.2
 */
inline fun <reified T : Any> ReactiveCassandraOperations.insertJson(json: String): Mono<WriteResult> =
		insertJson(json, T::class.java)

/**
 * Extension for [ReactiveCassandraOperations.insertJson] leveraging reified type parameters.
 * @since 5.2
 */
inline fun <reified T : Any> ReactiveCassandraOperations.insertJson(json: String, options: InsertOptions): Mono<WriteResult> =
		insertJson(json, T::class.java, options)

/**
 * Extension for [ReactiveCassandraOperations.count] leveraging reified type parameters.
 */
inline fun <reified T : Any> ReactiveCassandraOperations.count(): Mono<Long> =
		count(T::class.java)

/**
 * Extension for [ReactiveCassandraOperations.count] leveraging reified type parameters.
 */
inline fun <reified T : Any> ReactiveCassandraOperations.count(query: Query): Mono<Long> =
		count(query, T::class.java)

/**
 * Extension for [ReactiveCassandraOperations.exists] leveraging reified type parameters.
 */
inline fun <reified T : Any> ReactiveCassandraOperations.exists(id: Any): Mono<Boolean> =
		exists(id, T::class.java)

/**
 * Extension for [ReactiveCassandraOperations.count] leveraging reified type parameters.
 */
inline fun <reified T : Any> ReactiveCassandraOperations.exists(query: Query): Mono<Boolean> =
		exists(query, T::class.java)

/**
 * Extension for [ReactiveCassandraOperations.selectOneById] leveraging reified type parameters.
 */
inline fun <reified T : Any> ReactiveCassandraOperations.selectOneById(id: Any): Mono<T> =
		selectOneById(id, T::class.java)

/**
 * Extension for [ReactiveCassandraOperations.deleteById] leveraging reified type parameters.
 */
inline fun <reified T : Any> ReactiveCassandraOperations.deleteById(id: Any): Mono<Boolean> =
		deleteById(id, T::class.java)

/**
 * Extension for [ReactiveCassandraOperations.truncate] leveraging reified type parameters.
 */
inline fun <reified T : Any> ReactiveCassandraOperations.truncate(): Mono<Void> =
		truncate(T::class.java)

---

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

+106 — 9 new // GH-212 tests asserting exact CQL rendering (literal + bind-marker modes); import JsonInsert.

/*
 * Copyright 2017-present the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.springframework.data.cassandra.core;

import static org.assertj.core.api.Assertions.*;
import static org.springframework.data.cassandra.core.query.Criteria.*;
import static org.springframework.data.domain.Sort.Direction.*;

import java.nio.ByteBuffer;
import java.time.Duration;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.junit.jupiter.api.Test;

import org.springframework.data.annotation.Id;
import org.springframework.data.cassandra.core.convert.MappingCassandraConverter;
import org.springframework.data.cassandra.core.convert.UpdateMapper;
import org.springframework.data.cassandra.core.cql.QueryOptions;
import org.springframework.data.cassandra.core.cql.WriteOptions;
import org.springframework.data.cassandra.core.cql.util.StatementBuilder;
import org.springframework.data.cassandra.core.cql.util.StatementBuilder.ParameterHandling;
import org.springframework.data.cassandra.core.mapping.CassandraPersistentEntity;
import org.springframework.data.cassandra.core.mapping.Column;
import org.springframework.data.cassandra.core.mapping.VectorType;
import org.springframework.data.cassandra.core.query.Columns;
import org.springframework.data.cassandra.core.query.Query;
import org.springframework.data.cassandra.core.query.Update;
import org.springframework.data.cassandra.core.query.VectorSort;
import org.springframework.data.cassandra.domain.Group;
import org.springframework.data.domain.Limit;
import org.springframework.data.domain.Sort;
import org.springframework.data.domain.Vector;
import org.springframework.data.projection.EntityProjection;

import com.datastax.oss.driver.api.core.CqlIdentifier;
import com.datastax.oss.driver.api.core.DefaultConsistencyLevel;
import com.datastax.oss.driver.api.core.ProtocolVersion;
import com.datastax.oss.driver.api.core.cql.SimpleStatement;
import com.datastax.oss.driver.api.core.data.CqlVector;
import com.datastax.oss.driver.api.core.type.DataType;
import com.datastax.oss.driver.api.core.type.DataTypes;
import com.datastax.oss.driver.api.core.type.codec.TypeCodec;
import com.datastax.oss.driver.api.core.type.reflect.GenericType;
import com.datastax.oss.driver.api.querybuilder.QueryBuilder;
import com.datastax.oss.driver.api.querybuilder.delete.Delete;
import com.datastax.oss.driver.api.querybuilder.insert.JsonInsert;
import com.datastax.oss.driver.api.querybuilder.insert.RegularInsert;
import com.datastax.oss.driver.api.querybuilder.select.Select;
import com.datastax.oss.driver.internal.core.type.codec.registry.DefaultCodecRegistry;

/**
 * Unit tests for {@link StatementFactory}.
 *
 * @author Mark Paluch
 * @author Sam Lightfoot
 * @author Jeongjun Min
 */
class StatementFactoryUnitTests {

	private MappingCassandraConverter converter = new MappingCassandraConverter();

	private UpdateMapper updateMapper = new UpdateMapper(converter);

	private StatementFactory statementFactory = new StatementFactory(updateMapper, updateMapper);

	private CassandraPersistentEntity<?> groupEntity = converter.getMappingContext()
			.getRequiredPersistentEntity(Group.class);
	private CassandraPersistentEntity<?> personEntity = converter.getMappingContext()
			.getRequiredPersistentEntity(Person.class);

	@Test // DATACASS-343
	void shouldMapSimpleSelectQuery() {

		StatementBuilder<Select> select = statementFactory.select(Query.empty(),
				converter.getMappingContext().getRequiredPersistentEntity(Group.class));

		assertThat(select.build(ParameterHandling.INLINE).getQuery()).isEqualTo("SELECT * FROM group");
	}

	@Test // GH-1590
	void shouldMapExistsQuery() {

		StatementBuilder<Select> select = statementFactory.selectExists(Query.empty(),
				EntityProjection.nonProjecting(Group.class),
				converter.getMappingContext().getRequiredPersistentEntity(Group.class), CqlIdentifier.fromCql("group"));

		assertThat(select.build(ParameterHandling.INLINE).getQuery())
				.isEqualTo("SELECT groupname,hash_prefix,username FROM group LIMIT 1");
	}

	@Test // GH-1590
	void shouldRenderMappedFields() {

		statementFactory.setProjectionFunction(StatementFactory.ProjectionFunction.mappedProperties());

		StatementBuilder<Select> select = statementFactory.select(Query.empty(),
				converter.getMappingContext().getRequiredPersistentEntity(Group.class));

		assertThat(select.build(ParameterHandling.INLINE).getQuery())
				.isEqualTo("SELECT groupname,hash_prefix,username,email,age FROM group");
	}

	@Test // GH-1275
	void shouldConsiderKeyspaceForSelect() {

		statementFactory.setKeyspaceProvider((entity, tableName) -> CqlIdentifier.fromCql("ks_" + tableName));

		StatementBuilder<Select> select = statementFactory.select(Query.empty(),
				converter.getMappingContext().getRequiredPersistentEntity(Group.class));

		assertThat(select.build(ParameterHandling.INLINE).getQuery()).isEqualTo("SELECT * FROM ks_group.group");
	}

	@Test // DATACASS-708
	void selectShouldApplyQueryOptions() {

		QueryOptions queryOptions = QueryOptions.builder() //
				.executionProfile("foo") //
				.serialConsistencyLevel(DefaultConsistencyLevel.QUORUM) //
				.build();

		StatementBuilder<Select> select = statementFactory.select(Query.empty().queryOptions(queryOptions),
				converter.getMappingContext().getRequiredPersistentEntity(Group.class));

		SimpleStatement statement = select.build();
		assertThat(statement.getExecutionProfileName()).isEqualTo("foo");
		assertThat(statement.getSerialConsistencyLevel()).isEqualTo(DefaultConsistencyLevel.QUORUM);
	}

	@Test // DATACASS-343
	void shouldMapSelectQueryWithColumnsAndCriteria() {

		Query query = Query.query(where("foo").is("bar")).columns(Columns.from("age"));

		StatementBuilder<Select> select = statementFactory.select(query, groupEntity);

		assertThat(select.build(ParameterHandling.INLINE).getQuery()).isEqualTo("SELECT age FROM group WHERE foo='bar'");
	}

	@Test // DATACASS-549
	void shouldMapSelectQueryNotEquals() {

		Query query = Query.query(where("foo").ne("bar")).columns(Columns.from("age"));

		StatementBuilder<Select> select = statementFactory.select(query, groupEntity);

		assertThat(select.build(ParameterHandling.INLINE).getQuery()).isEqualTo("SELECT age FROM group WHERE foo!='bar'");
	}

	@Test // DATACASS-549
	void shouldMapSelectQueryIsNotNull() {

		Query query = Query.query(where("foo").isNotNull()).columns(Columns.from("age"));

		StatementBuilder<Select> select = statementFactory.select(query, groupEntity);

		assertThat(select.build(ParameterHandling.INLINE).getQuery())
				.isEqualTo("SELECT age FROM group WHERE foo IS NOT NULL");
	}

	@Test // DATACASS-343
	void shouldMapSelectQueryWithTtlColumns() {

		Query query = Query.empty().columns(Columns.empty().ttl("email"));

		StatementBuilder<Select> select = statementFactory.select(query,
				converter.getMappingContext().getRequiredPersistentEntity(Group.class));

		assertThat(select.build(ParameterHandling.INLINE).getQuery()).isEqualTo("SELECT ttl(email) FROM group");
	}

	@Test // GH-1008
	void shouldMapSelectQueryWithSort() {

		Query query = Query.empty().sort(Sort.by(DESC, "email", "age"));

		StatementBuilder<Select> select = statementFactory.select(query,
				converter.getMappingContext().getRequiredPersistentEntity(Group.class));

		assertThat(select.build(ParameterHandling.INLINE).getQuery())
				.isEqualTo("SELECT * FROM group ORDER BY email DESC,age DESC");
	}

	@Test // GH-1401
	void shouldMapSelectQueryWithLimit() {

		Query query = Query.query(where("email").is("e@mail")).limit(Limit.of(10));

		StatementBuilder<Select> select = statementFactory.select(query,
				converter.getMappingContext().getRequiredPersistentEntity(Group.class));

		assertThat(select.build(ParameterHandling.INLINE).getQuery())
				.isEqualTo("SELECT * FROM group WHERE email='e@mail' LIMIT 10");

		SimpleStatement statement = select.build(ParameterHandling.BY_INDEX);
		assertThat(statement.getQuery()).isEqualTo("SELECT * FROM group WHERE email=? LIMIT ?");
		assertThat(statement.getPositionalValues()).containsExactly("e@mail", 10);
	}

	@Test // DATACASS-343
	void shouldMapSelectQueryWithSortByEmbeddedLimitAndAllowFiltering() {

		Query query = Query.empty().sort(Sort.by(DESC, "id.hashPrefix", "id.username"));

		StatementBuilder<Select> select = statementFactory.select(query,
				converter.getMappingContext().getRequiredPersistentEntity(Group.class));

		assertThat(select.build(ParameterHandling.INLINE).getQuery())
				.isEqualTo("SELECT * FROM group ORDER BY hash_prefix DESC,username DESC");
	}

	@Test // DATACASS-343
	void shouldMapSelectQueryWithLimitAndAllowFiltering() {

		Query query = Query.empty().limit(10).withAllowFiltering();

		StatementBuilder<Select> select = statementFactory.select(query,
				converter.getMappingContext().getRequiredPersistentEntity(Group.class));

		assertThat(select.build(ParameterHandling.INLINE).getQuery())
				.isEqualTo("SELECT * FROM group LIMIT 10 ALLOW FILTERING");
	}

	@Test // GH-1172
	void shouldMapSelectInQueryAsInlineValue() {

		StatementBuilder<Select> select = statementFactory.select(Query.query(where("foo").in("bar")), groupEntity);

		assertThat(select.build(ParameterHandling.INLINE).getQuery()).isEqualTo("SELECT * FROM group WHERE foo IN ('bar')");

		select = statementFactory.select(Query.query(where("foo").in("bar", "baz")), groupEntity);

		assertThat(select.build(ParameterHandling.INLINE).getQuery())
				.isEqualTo("SELECT * FROM group WHERE foo IN ('bar','baz')");
	}

	@Test // GH-1172
	void shouldMapSelectInQueryAsByIndexValue() {

		StatementBuilder<Select> select = statementFactory.select(Query.query(where("foo").in("bar")), groupEntity);
		SimpleStatement statement = select.build(ParameterHandling.BY_INDEX);

		assertThat(statement.getQuery()).isEqualTo("SELECT * FROM group WHERE foo IN ?");
		assertThat(statement.getPositionalValues()).containsOnly(Collections.singletonList("bar"));

		select = statementFactory.select(Query.query(where("foo").in("bar", "baz")), groupEntity);
		statement = select.build(ParameterHandling.BY_INDEX);

		assertThat(statement.getQuery()).isEqualTo("SELECT * FROM group WHERE foo IN ?");
		assertThat(statement.getPositionalValues()).containsOnly(Arrays.asList("bar", "baz"));
	}

	@Test // GH-1172
	void shouldMapSelectInQueryAsByNamedValue() {

		StatementBuilder<Select> select = statementFactory.select(Query.query(where("foo").in("bar")), groupEntity);
		SimpleStatement statement = select.build(ParameterHandling.BY_NAME);

		assertThat(statement.getQuery()).isEqualTo("SELECT * FROM group WHERE foo IN :p0");
		assertThat(statement.getNamedValues()).hasSize(1).containsEntry(CqlIdentifier.fromCql("p0"),
				Collections.singletonList("bar"));

		select = statementFactory.select(Query.query(where("foo").in("bar", "baz")), groupEntity);
		statement = select.build(ParameterHandling.BY_NAME);

		assertThat(statement.getQuery()).isEqualTo("SELECT * FROM group WHERE foo IN :p0");
		assertThat(statement.getNamedValues()).hasSize(1).containsEntry(CqlIdentifier.fromCql("p0"),
				(Arrays.asList("bar", "baz")));
	}

	@Test // DATACASS-343
	void shouldMapDeleteQueryWithColumns() {

		Query query = Query.empty().columns(Columns.from("age"));

		StatementBuilder<Delete> delete = statementFactory.delete(query,
				converter.getMappingContext().getRequiredPersistentEntity(Group.class));

		assertThat(delete.build(ParameterHandling.INLINE).getQuery()).isEqualTo("DELETE age FROM group");
	}

	@Test // DATACASS-343
	void shouldMapDeleteQueryWithTimestampColumns() {

		DeleteOptions options = DeleteOptions.builder().timestamp(1234).build();
		Query query = Query.query(where("foo").is("bar")).queryOptions(options);

		StatementBuilder<Delete> delete = statementFactory.delete(query,
				converter.getMappingContext().getRequiredPersistentEntity(Group.class));

		assertThat(delete.build(ParameterHandling.INLINE).getQuery())
				.isEqualTo("DELETE FROM group USING TIMESTAMP 1234 WHERE foo='bar'");
	}

	@Test // GH-1401
	void deleteByQueryWithOptionsShouldRenderBindMarkers() {

		DeleteOptions options = DeleteOptions.builder().timestamp(1234).build();
		Query query = Query.query(where("foo").is("bar")).queryOptions(options);

		StatementBuilder<Delete> delete = statementFactory.delete(query,
				converter.getMappingContext().getRequiredPersistentEntity(Group.class));

		SimpleStatement statement = delete.build(ParameterHandling.BY_INDEX);

		assertThat(statement.getQuery()).isEqualTo("DELETE FROM group USING TIMESTAMP ? WHERE foo=?");
		assertThat(statement.getPositionalValues()).containsExactly(1234L, "bar");
	}

	@Test // GH-1401
	void deleteByEntityWithOptionsShouldRenderBindMarkers() {

		Person person = new Person();
		person.id = "foo";

		DeleteOptions options = DeleteOptions.builder().timestamp(1234).build();

		StatementBuilder<Delete> delete = statementFactory.delete(person, options, converter,
				CqlIdentifier.fromCql("person"));

		SimpleStatement statement = delete.build(ParameterHandling.BY_INDEX);

		assertThat(statement.getQuery()).isEqualTo("DELETE FROM person USING TIMESTAMP ? WHERE id=?");
		assertThat(statement.getPositionalValues()).containsExactly(1234L, "foo");
	}

	@Test // GH-1275
	void shouldConsiderKeyspaceForDeleteByEntity() {

		statementFactory.setKeyspaceProvider((entity, tableName) -> CqlIdentifier.fromCql("ks_" + tableName));

		Person person = new Person();
		person.id = "foo";

		StatementBuilder<Delete> delete = statementFactory.delete(person, DeleteOptions.empty(), converter,
				CqlIdentifier.fromCql("person"));

		SimpleStatement statement = delete.build(ParameterHandling.BY_INDEX);

		assertThat(statement.getQuery()).isEqualTo("DELETE FROM ks_person.person WHERE id=?");
	}

	@Test // GH-1275
	void shouldConsiderKeyspaceForDelete() {

		statementFactory.setKeyspaceProvider((entity, tableName) -> CqlIdentifier.fromCql("ks_" + tableName));
		StatementBuilder<Delete> delete = statementFactory.delete(Query.query(where("foo").is("bar")), groupEntity);

		SimpleStatement statement = delete.build(ParameterHandling.BY_INDEX);

		assertThat(statement.getQuery()).isEqualTo("DELETE FROM ks_group.group WHERE foo=?");
	}

	@Test // DATACASS-708
	void deleteShouldApplyQueryOptions() {

		Person person = new Person();
		person.id = "foo";

		QueryOptions queryOptions = QueryOptions.builder() //
				.executionProfile("foo") //
				.serialConsistencyLevel(DefaultConsistencyLevel.QUORUM) //
				.build();

		StatementBuilder<Delete> delete = statementFactory.delete(Query.empty().queryOptions(queryOptions),
				converter.getMappingContext().getRequiredPersistentEntity(Group.class));

		SimpleStatement statement = delete.build();
		assertThat(statement.getExecutionProfileName()).isEqualTo("foo");
		assertThat(statement.getSerialConsistencyLevel()).isEqualTo(DefaultConsistencyLevel.QUORUM);
	}

	@Test // DATACASS-656
	void shouldCreateInsert() {

		Person person = new Person();
		person.id = "foo";

		StatementBuilder<RegularInsert> insert = statementFactory.insert(person, WriteOptions.empty());

		assertThat(insert.build(ParameterHandling.INLINE).getQuery()).isEqualTo("INSERT INTO person (id) VALUES ('foo')");
	}

	@Test // GH-1275
	void shouldConsiderKeyspaceForInsert() {

		statementFactory.setKeyspaceProvider((entity, tableName) -> CqlIdentifier.fromCql("ks_" + tableName));

		Person person = new Person();
		person.id = "foo";

		StatementBuilder<RegularInsert> insert = statementFactory.insert(person, WriteOptions.empty());

		assertThat(insert.build(ParameterHandling.INLINE).getQuery())
				.isEqualTo("INSERT INTO ks_person.person (id) VALUES ('foo')");
	}

	@Test // DATACASS-708
	void insertShouldApplyQueryOptions() {

		Person person = new Person();
		person.id = "foo";

		WriteOptions queryOptions = WriteOptions.builder() //
				.executionProfile("foo") //
				.serialConsistencyLevel(DefaultConsistencyLevel.QUORUM) //
				.build();

		StatementBuilder<RegularInsert> insert = statementFactory.insert(person, queryOptions);

		SimpleStatement statement = insert.build();
		assertThat(statement.getQuery()).isEqualTo("INSERT INTO person (id) VALUES (?)");
		assertThat(statement.getExecutionProfileName()).isEqualTo("foo");
		assertThat(statement.getSerialConsistencyLevel()).isEqualTo(DefaultConsistencyLevel.QUORUM);
	}

	@Test // GH-1401, GH-1535
	void insertWithOptionsShouldRenderBindMarkers() {

		Person person = new Person();
		person.id = "foo";

		WriteOptions queryOptions = WriteOptions.builder() //
				.ttl(10).timestamp(1234).build();

		StatementBuilder<RegularInsert> insert = statementFactory.insert(person, queryOptions);

		SimpleStatement statement = insert.build(ParameterHandling.BY_INDEX);

		assertThat(statement.getQuery()).isEqualTo("INSERT INTO person (id) VALUES (?) USING TIMESTAMP ? AND TTL ?");
		assertThat(statement.getPositionalValues()).containsExactly("foo", 1234L, 10);

		queryOptions = WriteOptions.builder() //
				.ttl(Duration.ZERO).timestamp(1234).build();

		insert = statementFactory.insert(person, queryOptions);

		statement = insert.build(ParameterHandling.BY_INDEX);

		assertThat(statement.getQuery()).isEqualTo("INSERT INTO person (id) VALUES (?) USING TIMESTAMP ? AND TTL ?");
		assertThat(statement.getPositionalValues()).containsExactly("foo", 1234L, 0);
	}

	@Test // DATACASS-656
	void shouldCreateInsertIfNotExists() {

		InsertOptions options = InsertOptions.builder().withIfNotExists().build();
		Person person = new Person();
		person.id = "foo";

		StatementBuilder<RegularInsert> insert = statementFactory.insert(person, options);

		assertThat(insert.build(ParameterHandling.INLINE).getQuery())
				.isEqualTo("INSERT INTO person (id) VALUES ('foo') IF NOT EXISTS");
	}

	@Test // DATACASS-656
	void shouldCreateSetInsertNulls() {

		InsertOptions options = InsertOptions.builder().withInsertNulls().build();
		Person person = new Person();
		person.id = "foo";

		StatementBuilder<RegularInsert> insert = statementFactory.insert(person, options);

		assertThat(insert.build(ParameterHandling.INLINE).getQuery()).isEqualTo(
				"INSERT INTO person (id,number,list,map,set_col,first_name) VALUES ('foo',NULL,NULL,NULL,NULL,NULL)");
	}

	@Test // GH-212
	void shouldCreateInsertJson() {

		StatementBuilder<JsonInsert> insert = statementFactory.insertJson("{\"id\": \"foo\"}", WriteOptions.empty(),
				personEntity, personEntity.getTableName());

		assertThat(insert.build(ParameterHandling.INLINE).getQuery())
				.isEqualTo("INSERT INTO person JSON '{\"id\": \"foo\"}' DEFAULT UNSET");
	}

	@Test // GH-212
	void insertJsonShouldRenderBindMarkers() {

		StatementBuilder<JsonInsert> insert = statementFactory.insertJson("{\"id\": \"foo\"}", WriteOptions.empty(),
				personEntity, personEntity.getTableName());

		SimpleStatement statement = insert.build(ParameterHandling.BY_INDEX);

		assertThat(statement.getQuery()).isEqualTo("INSERT INTO person JSON ? DEFAULT UNSET");
		assertThat(statement.getPositionalValues()).containsExactly("{\"id\": \"foo\"}");
	}

	@Test // GH-212
	void shouldCreateInsertJsonWithInsertNulls() {

		InsertOptions options = InsertOptions.builder().withInsertNulls().build();

		StatementBuilder<JsonInsert> insert = statementFactory.insertJson("{\"id\": \"foo\"}", options, personEntity,
				personEntity.getTableName());

		assertThat(insert.build(ParameterHandling.INLINE).getQuery())
				.isEqualTo("INSERT INTO person JSON '{\"id\": \"foo\"}' DEFAULT NULL");
	}

	@Test // GH-212
	void shouldCreateInsertJsonIfNotExists() {

		InsertOptions options = InsertOptions.builder().withIfNotExists().build();

		StatementBuilder<JsonInsert> insert = statementFactory.insertJson("{\"id\": \"foo\"}", options, personEntity,
				personEntity.getTableName());

		assertThat(insert.build(ParameterHandling.INLINE).getQuery())
				.isEqualTo("INSERT INTO person JSON '{\"id\": \"foo\"}' DEFAULT UNSET IF NOT EXISTS");
	}

	@Test // GH-212
	void insertJsonWithOptionsShouldRenderBindMarkers() {

		WriteOptions options = WriteOptions.builder().ttl(10).timestamp(1234).build();

		StatementBuilder<JsonInsert> insert = statementFactory.insertJson("{\"id\": \"foo\"}", options, personEntity,
				personEntity.getTableName());

		SimpleStatement statement = insert.build(ParameterHandling.BY_INDEX);

		assertThat(statement.getQuery())
				.isEqualTo("INSERT INTO person JSON ? DEFAULT UNSET USING TIMESTAMP ? AND TTL ?");
		assertThat(statement.getPositionalValues()).containsExactly("{\"id\": \"foo\"}", 1234L, 10);
	}

	@Test // GH-212
	void shouldConsiderKeyspaceForInsertJson() {

		statementFactory.setKeyspaceProvider((entity, tableName) -> CqlIdentifier.fromCql("ks_" + tableName));

		StatementBuilder<JsonInsert> insert = statementFactory.insertJson("{\"id\": \"foo\"}", WriteOptions.empty(),
				personEntity, personEntity.getTableName());

		assertThat(insert.build(ParameterHandling.INLINE).getQuery())
				.isEqualTo("INSERT INTO ks_person.person JSON '{\"id\": \"foo\"}' DEFAULT UNSET");
	}

	@Test // GH-212
	void shouldMapSelectJsonQuery() {

		StatementBuilder<Select> select = statementFactory.selectJson(Query.empty(), groupEntity);

		assertThat(select.build(ParameterHandling.INLINE).getQuery()).isEqualTo("SELECT JSON * FROM group");
	}

	@Test // GH-212
	void shouldMapSelectJsonQueryWithColumnsAndCriteria() {

		Query query = Query.query(where("foo").is("bar")).columns(Columns.from("age"));

		StatementBuilder<Select> select = statementFactory.selectJson(query, groupEntity, groupEntity.getTableName());

		assertThat(select.build(ParameterHandling.INLINE).getQuery())
				.isEqualTo("SELECT JSON age FROM group WHERE foo='bar'");
	}

	@Test // GH-212
	void selectJsonShouldRenderBindMarkers() {

		Query query = Query.query(where("foo").is("bar")).limit(10);

		StatementBuilder<Select> select = statementFactory.selectJson(query, groupEntity, groupEntity.getTableName());

		SimpleStatement statement = select.build(ParameterHandling.BY_INDEX);

		assertThat(statement.getQuery()).isEqualTo("SELECT JSON * FROM group WHERE foo=? LIMIT ?");
		assertThat(statement.getPositionalValues()).containsExactly("bar", 10);
	}

	@Test // DATACASS-656
	void shouldCreateSetInsertWithTtl() {

		WriteOptions options = WriteOptions.builder().ttl(Duration.ofMinutes(1)).build();
		Person person = new Person();
		person.id = "foo";

		StatementBuilder<RegularInsert> insert = statementFactory.insert(person, options);

		assertThat(insert.build(ParameterHandling.INLINE).getQuery())
				.isEqualTo("INSERT INTO person (id) VALUES ('foo') USING TTL 60");
	}

	@Test // DATACASS-656
	void shouldCreateSetInsertWithTimestamp() {

		WriteOptions options = WriteOptions.builder().timestamp(1234).build();
		Person person = new Person();
		person.id = "foo";

		StatementBuilder<RegularInsert> insert = statementFactory.insert(person, options);

		assertThat(insert.build(ParameterHandling.INLINE).getQuery())
				.isEqualTo("INSERT INTO person (id) VALUES ('foo') USING TIMESTAMP 1234");
	}

	@Test // DATACASS-343
	void shouldCreateSetUpdate() {

		Query query = Query.query(where("foo").is("bar"));

		StatementBuilder<com.datastax.oss.driver.api.querybuilder.update.Update> update = statementFactory.update(query,
				Update.empty().set("firstName", "baz").set("boo", "baa"), personEntity);

		assertThat(update.build(ParameterHandling.INLINE).getQuery())
				.isEqualTo("UPDATE person SET first_name='baz', boo='baa' WHERE foo='bar'");
	}

	@Test // GH-1275
	void shouldConsiderKeyspaceForCreateSetUpdate() {

		statementFactory.setKeyspaceProvider((entity, tableName) -> CqlIdentifier.fromCql("ks_" + tableName));

		Query query = Query.query(where("foo").is("bar"));

		StatementBuilder<com.datastax.oss.driver.api.querybuilder.update.Update> update = statementFactory.update(query,
				Update.empty().set("firstName", "baz").set("boo", "baa"), personEntity);

		assertThat(update.build(ParameterHandling.INLINE).getQuery())
				.isEqualTo("UPDATE ks_person.person SET first_name='baz', boo='baa' WHERE foo='bar'");
	}

	@Test // DATACASS-656
	void shouldCreateSetUpdateWithTtl() {

		WriteOptions options = WriteOptions.builder().ttl(Duration.ofMinutes(1)).build();
		Query query = Query.query(where("foo").is("bar")).queryOptions(options);

		StatementBuilder<com.datastax.oss.driver.api.querybuilder.update.Update> update = statementFactory.update(query,
				Update.empty().set("firstName", "baz"), personEntity);

		assertThat(update.build(ParameterHandling.INLINE).getQuery())
				.isEqualTo("UPDATE person USING TTL 60 SET first_name='baz' WHERE foo='bar'");
	}

	@Test // DATACASS-656
	void shouldCreateSetUpdateWithTimestamp() {

		WriteOptions options = WriteOptions.builder().timestamp(1234).build();
		Query query = Query.query(where("foo").is("bar")).queryOptions(options);

		StatementBuilder<com.datastax.oss.driver.api.querybuilder.update.Update> update = statementFactory.update(query,
				Update.empty().set("firstName", "baz"), personEntity);

		assertThat(update.build(ParameterHandling.INLINE).getQuery())
				.isEqualTo("UPDATE person USING TIMESTAMP 1234 SET first_name='baz' WHERE foo='bar'");
	}

	@Test // GH-1401
	void updateWithOptionsShouldRenderBindMarker() {

		WriteOptions options = WriteOptions.builder().ttl(Duration.ofMinutes(1)).timestamp(1234).build();
		Query query = Query.query(where("foo").is("bar")).queryOptions(options);

		StatementBuilder<com.datastax.oss.driver.api.querybuilder.update.Update> update = statementFactory.update(query,
				Update.empty().set("firstName", "baz"), personEntity);

		SimpleStatement statement = update.build(ParameterHandling.BY_INDEX);
		assertThat(statement.getQuery())
				.isEqualTo("UPDATE person USING TIMESTAMP ? AND TTL ? SET first_name=? WHERE foo=?");

		assertThat(statement.getPositionalValues()).containsExactly(1234L, 60, "baz", "bar");
	}

	@Test // DATACASS-343, DATACASS-712
	void shouldCreateSetAtIndexUpdate() {

		StatementBuilder<com.datastax.oss.driver.api.querybuilder.update.Update> update = statementFactory
				.update(Query.empty(), Update.empty().set("list").atIndex(10).to("Euro"), personEntity);

		assertThat(update.build(ParameterHandling.INLINE).getQuery()).isEqualTo("UPDATE person SET list[10]='Euro'");
	}

	@Test // DATACASS-343
	void shouldCreateSetAtKeyUpdate() {

		StatementBuilder<com.datastax.oss.driver.api.querybuilder.update.Update> update = statementFactory
				.update(Query.empty(), Update.empty().set("map").atKey("baz").to("Euro"), personEntity);

		assertThat(update.build(ParameterHandling.INLINE).getQuery()).isEqualTo("UPDATE person SET map['baz']='Euro'");
	}

	@Test // DATACASS-343
	void shouldAddToMap() {

		StatementBuilder<com.datastax.oss.driver.api.querybuilder.update.Update> update = statementFactory
				.update(Query.empty(), Update.empty().addTo("map").entry("foo", "Euro"), personEntity);

		assertThat(update.build(ParameterHandling.INLINE).getQuery()).isEqualTo("UPDATE person SET map=map+{'foo':'Euro'}");
	}

	@Test // #1007
	void shouldRemoveFromMap() {

		StatementBuilder<com.datastax.oss.driver.api.querybuilder.update.Update> update = statementFactory
				.update(Query.empty(), Update.empty().removeFrom("map").value("foo"), personEntity);

		assertThat(update.build(ParameterHandling.INLINE).getQuery()).isEqualTo("UPDATE person SET map=map-{'foo'}");

		update = statementFactory.update(Query.empty(), Update.empty().removeFrom("map").values("foo", "bar"),
				personEntity);

		assertThat(update.build(ParameterHandling.INLINE).getQuery()).isEqualTo("UPDATE person SET map=map-{'foo','bar'}");
	}

	@Test // DATACASS-343
	void shouldPrependAllToList() {

		Update update = Update.empty().addTo("list").prependAll("foo", "Euro");

		StatementBuilder<com.datastax.oss.driver.api.querybuilder.update.Update> updateStatementBuilder = statementFactory
				.update(Query.empty(), update, personEntity);

		assertThat(updateStatementBuilder.build(ParameterHandling.INLINE).getQuery())
				.isEqualTo("UPDATE person SET list=['foo','Euro']+list");
	}

	@Test // DATACASS-343
	void shouldAppendAllToList() {

		Update update = Update.empty().addTo("list").appendAll("foo", "Euro");

		StatementBuilder<com.datastax.oss.driver.api.querybuilder.update.Update> updateStatementBuilder = statementFactory
				.update(Query.empty(), update, personEntity);

		assertThat(updateStatementBuilder.build(ParameterHandling.INLINE).getQuery())
				.isEqualTo("UPDATE person SET list=list+['foo','Euro']");
	}

	@Test // DATACASS-343
	void shouldRemoveFromList() {

		Update update = Update.empty().remove("list", "Euro");

		StatementBuilder<com.datastax.oss.driver.api.querybuilder.update.Update> updateStatementBuilder = statementFactory
				.update(Query.empty(), update, personEntity);

		assertThat(updateStatementBuilder.build(ParameterHandling.INLINE).getQuery())
				.isEqualTo("UPDATE person SET list=list-['Euro']");
	}

	@Test // DATACASS-343
	void shouldClearList() {

		StatementBuilder<com.datastax.oss.driver.api.querybuilder.update.Update> update = statementFactory
				.update(Query.empty(), Update.empty().clear("list"), personEntity);

		assertThat(update.build(ParameterHandling.INLINE).getQuery()).isEqualTo("UPDATE person SET list=[]");
	}

	@Test // DATACASS-343
	void shouldAddAllToSet() {

		Update update = Update.empty().addTo("set").appendAll("foo", "Euro");

		StatementBuilder<com.datastax.oss.driver.api.querybuilder.update.Update> updateStatementBuilder = statementFactory
				.update(Query.empty(), update, personEntity);

		assertThat(updateStatementBuilder.build(ParameterHandling.INLINE).getQuery())
				.isEqualTo("UPDATE person SET set_col=set_col+{'foo','Euro'}");
	}

	@Test // DATACASS-343
	void shouldRemoveFromSet() {

		Update update = Update.empty().remove("set", "Euro");

		StatementBuilder<com.datastax.oss.driver.api.querybuilder.update.Update> updateStatementBuilder = statementFactory
				.update(Query.empty(), update, personEntity);

		assertThat(updateStatementBuilder.build(ParameterHandling.INLINE).getQuery())
				.isEqualTo("UPDATE person SET set_col=set_col-{'Euro'}");
	}

	@Test // DATACASS-343
	void shouldClearSet() {

		StatementBuilder<com.datastax.oss.driver.api.querybuilder.update.Update> update = statementFactory
				.update(Query.empty(), Update.empty().clear("set"), personEntity);

		assertThat(update.build(ParameterHandling.INLINE).getQuery()).isEqualTo("UPDATE person SET set_col={}");
	}

	@Test // DATACASS-343
	void shouldCreateIncrementUpdate() {

		StatementBuilder<com.datastax.oss.driver.api.querybuilder.update.Update> update = statementFactory
				.update(Query.empty(), Update.empty().increment("number"), personEntity);

		assertThat(update.build(ParameterHandling.INLINE).getQuery()).isEqualTo("UPDATE person SET number=number+1");
	}

	@Test // DATACASS-735
	void shouldCreateIncrementLongUpdate() {

		StatementBuilder<com.datastax.oss.driver.api.querybuilder.update.Update> update = statementFactory
				.update(Query.empty(), Update.empty().increment("number", Long.MAX_VALUE), personEntity);

		assertThat(update.build(ParameterHandling.INLINE).getQuery())
				.isEqualTo("UPDATE person SET number=number+" + Long.MAX_VALUE);
	}

	@Test // DATACASS-343
	void shouldCreateDecrementUpdate() {

		StatementBuilder<com.datastax.oss.driver.api.querybuilder.update.Update> update = statementFactory
				.update(Query.empty(), Update.empty().decrement("number"), personEntity);

		assertThat(update.build(ParameterHandling.INLINE).getQuery()).isEqualTo("UPDATE person SET number=number-1");
	}

	@Test // DATACASS-735
	void shouldCreateDecrementLongUpdate() {

		StatementBuilder<com.datastax.oss.driver.api.querybuilder.update.Update> update = statementFactory
				.update(Query.empty(), Update.empty().decrement("number", Long.MAX_VALUE), personEntity);

		assertThat(update.build(ParameterHandling.INLINE).getQuery())
				.isEqualTo("UPDATE person SET number=number-" + Long.MAX_VALUE);
	}

	@Test // DATACASS-569
	void shouldCreateSetUpdateIfExists() {

		Query query = Query.query(where("foo").is("bar")).queryOptions(UpdateOptions.builder().withIfExists().build());

		StatementBuilder<com.datastax.oss.driver.api.querybuilder.update.Update> update = statementFactory.update(query,
				Update.empty().set("firstName", "baz"), personEntity);

		assertThat(update.build(ParameterHandling.INLINE).getQuery())
				.isEqualTo("UPDATE person SET first_name='baz' WHERE foo='bar' IF EXISTS");
	}

	@Test // DATACASS-656
	void shouldCreateSetUpdateIfCondition() {

		Query query = Query.query(where("foo").is("bar"))
				.queryOptions(UpdateOptions.builder().ifCondition(where("foo").is("baz")).build());

		StatementBuilder<com.datastax.oss.driver.api.querybuilder.update.Update> update = statementFactory.update(query,
				Update.empty().set("firstName", "baz"), personEntity);

		assertThat(update.build(ParameterHandling.INLINE).getQuery())
				.isEqualTo("UPDATE person SET first_name='baz' WHERE foo='bar' IF foo='baz'");
	}

	@Test // DATACASS-708
	void updateShouldApplyQueryOptions() {

		UpdateOptions queryOptions = UpdateOptions.builder() //
				.executionProfile("foo") //
				.serialConsistencyLevel(DefaultConsistencyLevel.QUORUM) //
				.build();

		Query query = Query.query(where("foo").is("bar")).queryOptions(queryOptions);

		StatementBuilder<com.datastax.oss.driver.api.querybuilder.update.Update> update = statementFactory.update(query,
				Update.empty().set("firstName", "baz"), personEntity);

		SimpleStatement statement = update.build();
		assertThat(statement.getExecutionProfileName()).isEqualTo("foo");
		assertThat(statement.getSerialConsistencyLevel()).isEqualTo(DefaultConsistencyLevel.QUORUM);
	}

	@Test // DATACASS-656
	void shouldCreateSetUpdateFromObject() {

		Person person = new Person();
		person.id = "foo";
		person.firstName = "bar";

		StatementBuilder<com.datastax.oss.driver.api.querybuilder.update.Update> update = statementFactory.update(person,
				WriteOptions.empty());

		assertThat(update.build(ParameterHandling.INLINE).getQuery())
				.isEqualTo("UPDATE person SET number=NULL, list=NULL, map=NULL, set_col=NULL, first_name='bar' WHERE id='foo'");
	}

	@Test // DATACASS-656
	void shouldCreateSetUpdateFromObjectIfExists() {

		UpdateOptions options = UpdateOptions.builder().withIfExists().build();
		Person person = new Person();
		person.id = "foo";
		person.firstName = "bar";

		StatementBuilder<com.datastax.oss.driver.api.querybuilder.update.Update> update = statementFactory.update(person,
				options);

		assertThat(update.build(ParameterHandling.INLINE).getQuery()).endsWith("IF EXISTS");
	}

	@Test // DATACASS-656
	void shouldCreateSetUpdateFromObjectIfCondition() {

		UpdateOptions options = UpdateOptions.builder().ifCondition(where("foo").is("bar")).build();
		Person person = new Person();
		person.id = "foo";
		person.firstName = "bar";

		StatementBuilder<com.datastax.oss.driver.api.querybuilder.update.Update> update = statementFactory.update(person,
				options);

		assertThat(update.build(ParameterHandling.INLINE).getQuery()).endsWith("IF foo='bar'");
	}

	@Test // DATACASS-656
	void shouldCreateSetUpdateFromObjectWithTtl() {

		WriteOptions options = WriteOptions.builder().ttl(Duration.ofMinutes(1)).build();
		Person person = new Person();
		person.id = "foo";

		StatementBuilder<com.datastax.oss.driver.api.querybuilder.update.Update> update = statementFactory.update(person,
				options);

		assertThat(update.build(ParameterHandling.INLINE).getQuery()).startsWith("UPDATE person USING TTL 60 SET");
	}

	@Test // DATACASS-656
	void shouldCreateSetUpdateFromObjectWithTimestamp() {

		WriteOptions options = WriteOptions.builder().timestamp(1234).build();
		Person person = new Person();
		person.id = "foo";

		StatementBuilder<com.datastax.oss.driver.api.querybuilder.update.Update> update = statementFactory.update(person,
				options);

		assertThat(update.build(ParameterHandling.INLINE).getQuery()).startsWith("UPDATE person USING TIMESTAMP 1234 SET");
	}

	@Test // DATACASS-656
	void shouldCreateSetUpdateFromObjectWithEmptyCollections() {

		Person person = new Person();
		person.id = "foo";
		person.set = Collections.emptySet();
		person.list = Collections.emptyList();

		StatementBuilder<com.datastax.oss.driver.api.querybuilder.update.Update> update = statementFactory.update(person,
				WriteOptions.empty());

		assertThat(update.build(ParameterHandling.INLINE).getQuery())
				.isEqualTo("UPDATE person SET number=NULL, list=[], map=NULL, set_col={}, first_name=NULL WHERE id='foo'");
	}

	@Test // DATACASS-708
	void updateObjectShouldApplyQueryOptions() {

		WriteOptions queryOptions = WriteOptions.builder() //
				.executionProfile("foo") //
				.serialConsistencyLevel(DefaultConsistencyLevel.QUORUM) //
				.build();

		Person person = new Person();
		person.id = "foo";
		person.set = Collections.emptySet();
		person.list = Collections.emptyList();

		StatementBuilder<com.datastax.oss.driver.api.querybuilder.update.Update> update = statementFactory.update(person,
				queryOptions);

		SimpleStatement statement = update.build();
		assertThat(statement.getExecutionProfileName()).isEqualTo("foo");
		assertThat(statement.getSerialConsistencyLevel()).isEqualTo(DefaultConsistencyLevel.QUORUM);
	}

	@Test // DATACASS-512
	void shouldCreateCountQuery() {

		Query query = Query.query(where("foo").is("bar"));

		StatementBuilder<Select> count = statementFactory.count(query,
				converter.getMappingContext().getRequiredPersistentEntity(Group.class));

		assertThat(count.build(ParameterHandling.INLINE).getQuery())
				.isEqualTo("SELECT count(1) FROM group WHERE foo='bar'");
	}

	@Test // GH-1114
	void shouldConsiderCodecRegistry() {

		DefaultCodecRegistry cr = new DefaultCodecRegistry("foo");
		cr.register(new TypeCodec<MyString>() {
			@Override
			public GenericType<MyString> getJavaType() {
				return GenericType.of(MyString.class);
			}

			@Override
			public DataType getCqlType() {
				return DataTypes.TEXT;
			}

			@Override
			public ByteBuffer encode(MyString value, ProtocolVersion protocolVersion) {
				return null;
			}

			@Override
			public MyString decode(ByteBuffer bytes, ProtocolVersion protocolVersion) {
				return null;
			}

			@Override
			public String format(MyString value) {
				return "'" + value.value() + "'";
			}

			@Override
			public MyString parse(String value) {
				return new MyString(value);
			}
		});

		converter.setCodecRegistry(cr);

		Query query = Query.query(where("foo").is(new MyString("bar")));

		StatementBuilder<Select> count = statementFactory.count(query,
				converter.getMappingContext().getRequiredPersistentEntity(Group.class));

		assertThat(count.build(ParameterHandling.INLINE).getQuery())
				.isEqualTo("SELECT count(1) FROM group WHERE foo='bar'");
	}

	@Test // GH-1504
	void shouldUpdateCqlVector() {

		WithVector withVector = new WithVector();
		withVector.id = "foo";
		withVector.vector = CqlVector.newInstance(1.2f, 1.3f);
		withVector.array = new float[] { 2.2f, 2.3f };

		SimpleStatement statement = statementFactory.update(withVector, WriteOptions.empty())
				.build(ParameterHandling.BY_NAME);

		assertThat(statement.getQuery()).isEqualTo("UPDATE withvector SET vector=:p0, array=:p1 WHERE id=:p2");

		assertThat(statement.getNamedValues().get(CqlIdentifier.fromCql("p0"))).isInstanceOf(CqlVector.class).hasToString("[1.2, 1.3]");
		assertThat(statement.getNamedValues().get(CqlIdentifier.fromCql("p1"))).isInstanceOf(CqlVector.class).hasToString("[2.2, 2.3]");
	}

	@Test // GH-1504
	void shouldQueryVector() {

		Query query = Query.empty()
				.sort(VectorSort.ann("vector", Vector.of(1.2f, 1.3f)));

		SimpleStatement statement = statementFactory.select(query, converter.getMappingContext().getRequiredPersistentEntity(WithVector.class))
				.build(ParameterHandling.BY_NAME);

		assertThat(statement.getQuery()).isEqualTo("SELECT * FROM withvector ORDER BY vector ANN OF [1.2, 1.3]");
		assertThat(statement.getNamedValues()).isEmpty();
	}

	@Test // GH-1504
	void shouldRenderSimilaritySelector() {

		Vector vector = Vector.of(0.2f, 0.15f, 0.3f, 0.2f, 0.05f);

		Columns columns = Columns.empty().include("comment").select("vector", it -> it.similarity(vector).cosine());

		Query query = Query.select(columns).sort(VectorSort.ann("vector", Vector.of(1.2f, 1.3f)));

		SimpleStatement statement = statementFactory
				.select(query, converter.getMappingContext().getRequiredPersistentEntity(WithVector.class))
				.build(ParameterHandling.BY_NAME);

		assertThat(statement.getQuery()).isEqualTo(
				"SELECT comment,similarity_cosine(vector,[0.2, 0.15, 0.3, 0.2, 0.05]) AS vector FROM withvector ORDER BY vector ANN OF [1.2, 1.3]");
		assertThat(statement.getNamedValues()).isEmpty();
	}

	@Test // GH-1525
	void shouldCreateUpdateWithMultipleOperationsOnSameColumnDifferentKeys() {

		Update update = Update.empty().set("map").atKey("key1").to("value1").set("map").atKey("key2").to("value2");

		StatementBuilder<com.datastax.oss.driver.api.querybuilder.update.Update> updateStatementBuilder = statementFactory
			.update(Query.empty(), update, personEntity);

		String cql = updateStatementBuilder.build(ParameterHandling.INLINE).getQuery();

		assertThat(cql).isEqualTo("UPDATE person SET map['key1']='value1', map['key2']='value2'");
	}

	@Test // GH-1659
	void shouldCreateFunctionForCompositeId() {

		Columns.FunctionCall call = Columns.FunctionCall.from("toJson", Columns.ColumnSelector.from("id"));
		Query query = Query.empty().columns(Columns.empty().select("json", call));

		StatementBuilder<Select> select = statementFactory.select(query,
				converter.getMappingContext().getRequiredPersistentEntity(Group.class));

		SimpleStatement inline = select.build();
		assertThat(inline.getQuery()).isEqualTo("SELECT tojson(groupname,hash_prefix,username) FROM group");
	}

	@Test // GH-1659
	void shouldCreateFunctionWithTerm() {

		Columns.FunctionCall call = Columns.FunctionCall.from("toJson", "foo", QueryBuilder.literal("bar"));
		Query query = Query.empty().columns(Columns.empty().select("json", call));

		StatementBuilder<Select> select = statementFactory.select(query,
				converter.getMappingContext().getRequiredPersistentEntity(Group.class));

		SimpleStatement inline = select.build(ParameterHandling.INLINE);
		assertThat(inline.getQuery()).isEqualTo("SELECT tojson('foo','bar') FROM group");

		SimpleStatement byName = select.build(ParameterHandling.BY_NAME);
		assertThat(byName.getQuery()).isEqualTo("SELECT tojson(:p0,'bar') FROM group");

		SimpleStatement byIndex = select.build(ParameterHandling.BY_INDEX);
		assertThat(byIndex.getQuery()).isEqualTo("SELECT tojson(?,'bar') FROM group");
	}

	@Test // GH-1659
	void shouldCreateFunctionWithLiteral() {

		Columns.FunctionCall call = Columns.FunctionCall.from("toJson", 1L);
		Query query = Query.empty().columns(Columns.empty().select("json", call));

		StatementBuilder<Select> select = statementFactory.select(query,
				converter.getMappingContext().getRequiredPersistentEntity(Group.class));

		SimpleStatement inline = select.build(ParameterHandling.INLINE);
		assertThat(inline.getQuery()).isEqualTo("SELECT tojson(1) FROM group");

		SimpleStatement byName = select.build(ParameterHandling.BY_NAME);
		assertThat(byName.getQuery()).isEqualTo("SELECT tojson(1) FROM group");

		SimpleStatement byIndex = select.build(ParameterHandling.BY_INDEX);
		assertThat(byIndex.getQuery()).isEqualTo("SELECT tojson(1) FROM group");
	}

	@Test // GH-1659
	void shouldCreateFunctionWithColumn() {

		Columns.ColumnSelector column = Columns.ColumnSelector.from(CqlIdentifier.fromInternal("myCol"));
		Columns.FunctionCall call = Columns.FunctionCall.from("toJson", column);
		Query query = Query.empty().columns(Columns.empty().select("json", call));

		StatementBuilder<Select> select = statementFactory.select(query,
				converter.getMappingContext().getRequiredPersistentEntity(Group.class));

		SimpleStatement inline = select.build(ParameterHandling.INLINE);
		assertThat(inline.getQuery()).isEqualTo("SELECT tojson(\"myCol\") FROM group");

		SimpleStatement byName = select.build(ParameterHandling.BY_NAME);
		assertThat(byName.getQuery()).isEqualTo("SELECT tojson(\"myCol\") FROM group");

		SimpleStatement byIndex = select.build(ParameterHandling.BY_INDEX);
		assertThat(byIndex.getQuery()).isEqualTo("SELECT tojson(\"myCol\") FROM group");
	}

	@SuppressWarnings("unused")
	static class Person {

		@Id private String id;

		Integer number;

		private List<String> list;

		Map<String, String> map;

		@Column("set_col") private Set<String> set;

		@Column("first_name") private String firstName;
	}

	record MyString(String value) {

	}

	static class WithVector {

		@Id String id;

		@VectorType(dimensions = 12) CqlVector<Number> vector;
		@VectorType(dimensions = 12) float[] array;
	}
}

---

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

+69 — 5 new // GH-212 tests (mocked CqlSession).

/*
 * Copyright 2016-present the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.springframework.data.cassandra.core;

import static org.assertj.core.api.Assertions.*;
import static org.mockito.ArgumentMatchers.*;
import static org.mockito.Mockito.*;
import static org.springframework.data.cassandra.core.query.Criteria.*;

import java.util.Collections;
import java.util.List;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.mockito.junit.jupiter.MockitoSettings;
import org.mockito.quality.Strictness;
import org.springframework.data.cassandra.CassandraConnectionFailureException;
import org.springframework.data.cassandra.core.mapping.event.BeforeConvertCallback;
import org.springframework.data.cassandra.core.mapping.event.BeforeSaveCallback;
import org.springframework.data.cassandra.core.query.Filter;
import org.springframework.data.cassandra.core.query.Query;
import org.springframework.data.cassandra.core.query.Update;
import org.springframework.data.cassandra.domain.User;
import org.springframework.data.cassandra.domain.VersionedUser;
import org.springframework.data.mapping.callback.EntityCallbacks;

import com.datastax.oss.driver.api.core.CqlIdentifier;
import com.datastax.oss.driver.api.core.CqlSession;
import com.datastax.oss.driver.api.core.NoNodeAvailableException;
import com.datastax.oss.driver.api.core.context.DriverContext;
import com.datastax.oss.driver.api.core.cql.ColumnDefinition;
import com.datastax.oss.driver.api.core.cql.ColumnDefinitions;
import com.datastax.oss.driver.api.core.cql.ResultSet;
import com.datastax.oss.driver.api.core.cql.Row;
import com.datastax.oss.driver.api.core.cql.SimpleStatement;
import com.datastax.oss.driver.api.core.cql.Statement;
import com.datastax.oss.driver.api.core.type.DataTypes;
import com.datastax.oss.driver.api.core.type.codec.registry.CodecRegistry;
import com.datastax.oss.driver.internal.core.type.codec.registry.DefaultCodecRegistry;

/**
 * Unit tests for {@link CassandraTemplate}.
 *
 * @author Mark Paluch
 */
@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
class CassandraTemplateUnitTests {

	@Mock CqlSession session;
	CodecRegistry codecRegistry = new DefaultCodecRegistry("foo");
	@Mock DriverContext driverContext;
	@Mock ResultSet resultSet;
	@Mock Row row;
	@Mock ColumnDefinition columnDefinition;
	@Mock ColumnDefinitions columnDefinitions;
	@Captor ArgumentCaptor<SimpleStatement> statementCaptor;

	private CassandraTemplate template;

	private Object beforeSave;

	private Object beforeConvert;

	@BeforeEach
	void setUp() {

		when(driverContext.getCodecRegistry()).thenReturn(codecRegistry);
		when(session.getContext()).thenReturn(driverContext);
		when(session.execute(any(Statement.class))).thenReturn(resultSet);
		when(row.getColumnDefinitions()).thenReturn(columnDefinitions);

		EntityCallbacks callbacks = EntityCallbacks.create();
		callbacks.addEntityCallback((BeforeSaveCallback<Object>) (entity, tableName, statement) -> {

			assertThat(tableName).isNotNull();
			assertThat(statement).isNotNull();
			beforeSave = entity;
			return entity;
		});

		callbacks.addEntityCallback((BeforeConvertCallback<Object>) (entity, tableName) -> {

			assertThat(tableName).isNotNull();
			beforeConvert = entity;
			return entity;
		});

		template = new CassandraTemplate(session);
		template.setUsePreparedStatements(false);
		template.setEntityCallbacks(callbacks);
	}

	@Test // gh-1133
	void shouldConfigureConverterFromSession() {
		assertThat(template.getConverter().getCodecRegistry()).isEqualTo(session.getContext().getCodecRegistry());
		assertThat(template.getConverter()).extracting("userTypeResolver").isNotNull();
	}

	@Test // DATACASS-292
	void selectUsingCqlShouldReturnMappedResults() {

		when(resultSet.iterator()).thenReturn(Collections.singleton(row).iterator());
		when(columnDefinitions.contains(any(CqlIdentifier.class))).thenReturn(true);

		when(columnDefinitions.get(anyInt())).thenReturn(columnDefinition);
		when(columnDefinitions.firstIndexOf("id")).thenReturn(0);
		when(columnDefinitions.firstIndexOf("firstname")).thenReturn(1);
		when(columnDefinitions.firstIndexOf("lastname")).thenReturn(2);

		when(columnDefinition.getType()).thenReturn(DataTypes.TEXT);

		when(row.getObject(0)).thenReturn("myid");
		when(row.getObject(1)).thenReturn("Walter");
		when(row.getObject(2)).thenReturn("White");

		List<User> list = template.select("SELECT * FROM users", User.class);

		assertThat(list).hasSize(1).contains(new User("myid", "Walter", "White"));
		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue())).isEqualTo("SELECT * FROM users");
	}

	@Test // DATACASS-292
	void selectShouldTranslateException() {

		when(resultSet.iterator()).thenThrow(new NoNodeAvailableException());

		try {
			template.select("SELECT * FROM users", User.class);

			fail("Missing CassandraConnectionFailureException");
		} catch (CassandraConnectionFailureException e) {
			assertThat(e).hasRootCauseInstanceOf(NoNodeAvailableException.class);
		}
	}

	@Test // DATACASS-292
	void selectOneShouldReturnMappedResults() {

		when(resultSet.iterator()).thenReturn(Collections.singleton(row).iterator());
		when(columnDefinitions.contains(any(CqlIdentifier.class))).thenReturn(true);
		when(columnDefinitions.get(anyInt())).thenReturn(columnDefinition);
		when(columnDefinitions.firstIndexOf("id")).thenReturn(0);
		when(columnDefinitions.firstIndexOf("firstname")).thenReturn(1);
		when(columnDefinitions.firstIndexOf("lastname")).thenReturn(2);

		when(columnDefinition.getType()).thenReturn(DataTypes.TEXT);

		when(row.getObject(0)).thenReturn("myid");
		when(row.getObject(1)).thenReturn("Walter");
		when(row.getObject(2)).thenReturn("White");

		User user = template.selectOne("SELECT * FROM users WHERE id='myid'", User.class);

		assertThat(user).isEqualTo(new User("myid", "Walter", "White"));
		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue())).isEqualTo("SELECT * FROM users WHERE id='myid'");
	}

	@Test // DATACASS-696
	void selectOneShouldNull() {

		when(resultSet.iterator()).thenReturn(Collections.singleton(row).iterator());

		String nullValue = template.selectOne("SELECT id FROM users WHERE id='myid'", String.class);

		assertThat(nullValue).isNull();
	}

	@Test // DATACASS-292
	void selectOneByIdShouldReturnMappedResults() {

		when(resultSet.iterator()).thenReturn(Collections.singleton(row).iterator());
		when(columnDefinitions.contains(any(CqlIdentifier.class))).thenReturn(true);
		when(columnDefinitions.get(anyInt())).thenReturn(columnDefinition);
		when(columnDefinitions.firstIndexOf("id")).thenReturn(0);
		when(columnDefinitions.firstIndexOf("firstname")).thenReturn(1);
		when(columnDefinitions.firstIndexOf("lastname")).thenReturn(2);

		when(columnDefinition.getType()).thenReturn(DataTypes.ASCII);

		when(row.getObject(0)).thenReturn("myid");
		when(row.getObject(1)).thenReturn("Walter");
		when(row.getObject(2)).thenReturn("White");

		User user = template.selectOneById("myid", User.class);

		assertThat(user).isEqualTo(new User("myid", "Walter", "White"));
		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue())).isEqualTo("SELECT * FROM users WHERE id='myid' LIMIT 1");
	}

	@Test // DATACASS-313
	void selectProjectedOneShouldReturnMappedResults() {

		when(resultSet.iterator()).thenReturn(Collections.singleton(row).iterator());
		when(columnDefinitions.contains(any(CqlIdentifier.class))).thenReturn(true);
		when(columnDefinitions.get(anyInt())).thenReturn(columnDefinition);
		when(columnDefinitions.firstIndexOf("id")).thenReturn(0);

		when(columnDefinition.getType()).thenReturn(DataTypes.ASCII);

		when(row.getObject(0)).thenReturn("Walter");

		UserProjection user = template.query(User.class).as(UserProjection.class).oneValue();

		assertThat(user.getFirstname()).isEqualTo("Walter");
		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue())).isEqualTo("SELECT firstname FROM users LIMIT 2");
	}

	@Test // DATACASS-292
	void existsShouldReturnExistingElement() {

		when(resultSet.one()).thenReturn(row);

		boolean exists = template.exists("myid", User.class);

		assertThat(exists).isTrue();
		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue())).isEqualTo("SELECT id FROM users WHERE id='myid' LIMIT 1");
	}

	@Test // DATACASS-292
	void existsShouldReturnNonExistingElement() {

		boolean exists = template.exists("myid", User.class);

		assertThat(exists).isFalse();
		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue())).isEqualTo("SELECT id FROM users WHERE id='myid' LIMIT 1");
	}

	@Test // DATACASS-512
	void existsByQueryShouldReturnExistingElement() {

		when(resultSet.one()).thenReturn(row);

		boolean exists = template.exists(Query.empty(), User.class);

		assertThat(exists).isTrue();
		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue())).isEqualTo("SELECT id FROM users LIMIT 1");
	}

	@Test // DATACASS-292
	void countShouldExecuteCountQueryElement() {

		when(resultSet.iterator()).thenReturn(Collections.singleton(row).iterator());
		when(row.getLong(0)).thenReturn(42L);
		when(columnDefinitions.size()).thenReturn(1);

		long count = template.count(User.class);

		assertThat(count).isEqualTo(42L);
		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue())).isEqualTo("SELECT count(1) FROM users");
	}

	@Test // DATACASS-512
	void countByQueryShouldExecuteCountQueryElement() {

		when(resultSet.iterator()).thenReturn(Collections.singleton(row).iterator());
		when(row.getLong(0)).thenReturn(42L);
		when(columnDefinitions.size()).thenReturn(1);

		long count = template.count(Query.empty(), User.class);

		assertThat(count).isEqualTo(42L);
		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue())).isEqualTo("SELECT count(1) FROM users");
	}

	@Test // DATACASS-292, DATACASS-618
	void insertShouldInsertEntity() {

		when(resultSet.wasApplied()).thenReturn(true);

		User user = new User("heisenberg", "Walter", "White");

		template.insert(user);

		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue()))
				.isEqualTo("INSERT INTO users (id,firstname,lastname) VALUES ('heisenberg','Walter','White')");
		assertThat(beforeConvert).isSameAs(user);
		assertThat(beforeSave).isSameAs(user);
	}

	@Test // GH-1295
	void insertShouldConsiderEntityAfterCallback() {

		when(resultSet.wasApplied()).thenReturn(true);

		User user = new User("heisenberg", "Walter", "White");

		EntityCallbacks callbacks = EntityCallbacks.create();
		callbacks.addEntityCallback((BeforeConvertCallback<Object>) (entity, tableName) -> new User("ww", "Walter", "White"));
		template.setEntityCallbacks(callbacks);

		template.insert(user);

		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue()))
				.isEqualTo("INSERT INTO users (id,firstname,lastname) VALUES ('ww','Walter','White')");
	}

	@Test // DATACASS-618
	void insertShouldInsertVersionedEntity() {

		when(resultSet.wasApplied()).thenReturn(true);

		VersionedUser user = new VersionedUser("heisenberg", "Walter", "White");

		template.insert(user);

		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue())).isEqualTo(
				"INSERT INTO vusers (id,version,firstname,lastname) VALUES ('heisenberg',0,'Walter','White') IF NOT EXISTS");
		assertThat(beforeConvert).isSameAs(user);
		assertThat(beforeSave).isSameAs(user);
	}

	@Test // GH-1295
	void insertShouldInsertVersionedEntityAfterCallback() {

		when(resultSet.wasApplied()).thenReturn(true);

		VersionedUser user = new VersionedUser("heisenberg", "Walter", "White");

		EntityCallbacks callbacks = EntityCallbacks.create();
		callbacks.addEntityCallback((BeforeConvertCallback<Object>) (entity, tableName) -> new VersionedUser("ww", "Walter", "White"));
		template.setEntityCallbacks(callbacks);

		template.insert(user);

		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue())).isEqualTo(
				"INSERT INTO vusers (id,version,firstname,lastname) VALUES ('ww',0,'Walter','White') IF NOT EXISTS");
	}

	@Test // DATACASS-250
	void insertShouldInsertWithOptionsEntity() {

		InsertOptions insertOptions = InsertOptions.builder().withIfNotExists().build();

		when(resultSet.wasApplied()).thenReturn(true);

		User user = new User("heisenberg", "Walter", "White");

		template.insert(user, insertOptions);

		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue()))
				.isEqualTo("INSERT INTO users (id,firstname,lastname) VALUES ('heisenberg','Walter','White') IF NOT EXISTS");
	}

	@Test // DATACASS-560
	void insertShouldInsertWithNulls() {

		InsertOptions insertOptions = InsertOptions.builder().withInsertNulls().build();

		when(resultSet.wasApplied()).thenReturn(true);

		User user = new User("heisenberg", null, null);

		template.insert(user, insertOptions);

		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue()))
				.isEqualTo("INSERT INTO users (id,firstname,lastname) VALUES ('heisenberg',NULL,NULL)");
	}

	@Test // DATACASS-292
	void insertShouldTranslateException() {

		reset(session);
		when(session.execute(any(Statement.class))).thenThrow(new NoNodeAvailableException());

		try {
			template.insert(new User("heisenberg", "Walter", "White"));

			fail("Missing CassandraConnectionFailureException");
		} catch (CassandraConnectionFailureException e) {
			assertThat(e).hasRootCauseInstanceOf(NoNodeAvailableException.class);
		}
	}

	@Test // DATACASS-292
	void insertShouldNotApplyInsert() {

		when(resultSet.wasApplied()).thenReturn(false);

		User user = new User("heisenberg", "Walter", "White");

		WriteResult writeResult = template.insert(user, InsertOptions.builder().build());

		assertThat(writeResult.wasApplied()).isFalse();
	}

	@Test // GH-212
	void insertJsonShouldInsertJson() {

		when(resultSet.wasApplied()).thenReturn(true);

		WriteResult writeResult = template.insertJson("{\"id\": \"heisenberg\"}", User.class);

		assertThat(writeResult.wasApplied()).isTrue();
		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue()))
				.isEqualTo("INSERT INTO users JSON '{\"id\": \"heisenberg\"}' DEFAULT UNSET");
	}

	@Test // GH-212
	void insertJsonShouldApplyInsertOptions() {

		InsertOptions insertOptions = InsertOptions.builder().withIfNotExists().build();

		when(resultSet.wasApplied()).thenReturn(true);

		template.insertJson("{\"id\": \"heisenberg\"}", User.class, insertOptions);

		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue()))
				.isEqualTo("INSERT INTO users JSON '{\"id\": \"heisenberg\"}' DEFAULT UNSET IF NOT EXISTS");
	}

	@Test // GH-212
	void insertJsonShouldConsiderInsertNulls() {

		InsertOptions insertOptions = InsertOptions.builder().withInsertNulls().build();

		when(resultSet.wasApplied()).thenReturn(true);

		template.insertJson("{\"id\": \"heisenberg\"}", User.class, insertOptions);

		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue()))
				.isEqualTo("INSERT INTO users JSON '{\"id\": \"heisenberg\"}' DEFAULT NULL");
	}

	@Test // GH-212
	void selectJsonShouldReturnJson() {

		when(resultSet.iterator()).thenReturn(Collections.singleton(row).iterator());
		when(columnDefinitions.size()).thenReturn(1);
		when(row.getString(0)).thenReturn("{\"id\": \"heisenberg\"}");

		List<String> result = template.selectJson(Query.empty(), User.class);

		assertThat(result).containsExactly("{\"id\": \"heisenberg\"}");
		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue())).isEqualTo("SELECT JSON * FROM users");
	}

	@Test // GH-212
	void selectOneJsonShouldReturnJson() {

		when(resultSet.iterator()).thenReturn(Collections.singleton(row).iterator());
		when(columnDefinitions.size()).thenReturn(1);
		when(row.getString(0)).thenReturn("{\"id\": \"heisenberg\"}");

		String result = template.selectOneJson(Query.query(where("id").is("heisenberg")), User.class);

		assertThat(result).isEqualTo("{\"id\": \"heisenberg\"}");
		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue())).isEqualTo("SELECT JSON * FROM users WHERE id='heisenberg'");
	}

	@Test // DATACASS-292, DATACASS-618
	void updateShouldUpdateEntity() {

		when(resultSet.wasApplied()).thenReturn(true);

		User user = new User("heisenberg", "Walter", "White");

		template.update(user);

		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue()))
				.isEqualTo("UPDATE users SET firstname='Walter', lastname='White' WHERE id='heisenberg'");
		assertThat(beforeConvert).isSameAs(user);
		assertThat(beforeSave).isSameAs(user);
	}

	@Test // DATACASS-618
	void updateShouldUpdateVersionedEntity() {

		when(resultSet.wasApplied()).thenReturn(true);

		VersionedUser user = new VersionedUser("heisenberg", "Walter", "White");
		user.setVersion(0L);

		template.update(user);

		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue())).isEqualTo(
				"UPDATE vusers SET version=1, firstname='Walter', lastname='White' WHERE id='heisenberg' IF version=0");
		assertThat(beforeConvert).isSameAs(user);
		assertThat(beforeSave).isSameAs(user);
	}

	@Test // DATACASS-250
	void updateShouldUpdateEntityWithOptions() {

		when(resultSet.wasApplied()).thenReturn(true);

		UpdateOptions updateOptions = UpdateOptions.builder().withIfExists().build();

		User user = new User("heisenberg", "Walter", "White");

		WriteResult writeResult = template.update(user, updateOptions);

		assertThat(writeResult.wasApplied()).isTrue();
		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue()))
				.isEqualTo("UPDATE users SET firstname='Walter', lastname='White' WHERE id='heisenberg' IF EXISTS");
	}

	@Test // DATACASS-575
	void updateShouldUpdateEntityWithLwt() {

		UpdateOptions options = UpdateOptions.builder().ifCondition(where("firstname").is("Walter")).build();
		User user = new User("heisenberg", "Walter", "White");

		template.update(user, options);

		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue()))
				.isEqualTo("UPDATE users SET firstname='Walter', lastname='White' WHERE id='heisenberg' IF firstname='Walter'");
	}

	@Test // DATACASS-575
	void updateShouldApplyUpdateQuery() {

		Query query = Query.query(where("id").is("heisenberg"));
		Update update = Update.update("firstname", "Walter");

		template.update(query, update, User.class);

		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue()))
				.isEqualTo("UPDATE users SET firstname='Walter' WHERE id='heisenberg'");
	}

	@Test // DATACASS-575
	void updateShouldApplyUpdateQueryWitLwt() {

		Filter ifCondition = Filter.from(where("firstname").is("Walter"), where("lastname").is("White"));

		Query query = Query.query(where("id").is("heisenberg"))
				.queryOptions(UpdateOptions.builder().ifCondition(ifCondition).build());

		Update update = Update.update("firstname", "Walter");

		template.update(query, update, User.class);

		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue())).isEqualTo(
				"UPDATE users SET firstname='Walter' WHERE id='heisenberg' IF firstname='Walter' AND lastname='White'");
	}

	@Test // DATACASS-292
	void updateShouldTranslateException() {

		reset(session);
		when(session.execute(any(Statement.class))).thenThrow(new NoNodeAvailableException());

		try {
			template.update(new User("heisenberg", "Walter", "White"));

			fail("Missing CassandraConnectionFailureException");
		} catch (CassandraConnectionFailureException e) {
			assertThat(e).hasRootCauseInstanceOf(NoNodeAvailableException.class);
		}
	}

	@Test // DATACASS-292
	void deleteByIdShouldRemoveEntity() {

		when(resultSet.wasApplied()).thenReturn(true);

		User user = new User("heisenberg", "Walter", "White");

		boolean deleted = template.deleteById(user.getId(), User.class);

		assertThat(deleted).isTrue();
		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue())).isEqualTo("DELETE FROM users WHERE id='heisenberg'");
	}

	@Test // DATACASS-292
	void deleteShouldRemoveEntity() {

		User user = new User("heisenberg", "Walter", "White");

		template.delete(user);

		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue())).isEqualTo("DELETE FROM users WHERE id='heisenberg'");
	}

	@Test // DATACASS-575
	void deleteShouldRemoveEntityWithLwt() {

		User user = new User("heisenberg", "Walter", "White");
		DeleteOptions options = DeleteOptions.builder().ifCondition(where("firstname").is("Walter")).build();

		template.delete(user, options);

		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue()))
				.isEqualTo("DELETE FROM users WHERE id='heisenberg' IF firstname='Walter'");
	}

	@Test // DATACASS-575
	void deleteShouldRemoveByQueryWithLwt() {

		DeleteOptions options = DeleteOptions.builder().ifCondition(where("firstname").is("Walter")).build();
		Query query = Query.query(where("id").is("heisenberg")).queryOptions(options);

		template.delete(query, User.class);

		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue()))
				.isEqualTo("DELETE FROM users WHERE id='heisenberg' IF firstname='Walter'");
	}

	@Test // DATACASS-292
	void deleteShouldTranslateException() {

		reset(session);
		when(session.execute(any(Statement.class))).thenThrow(new NoNodeAvailableException());

		try {
			template.delete(new User("heisenberg", "Walter", "White"));

			fail("Missing CassandraConnectionFailureException");
		} catch (CassandraConnectionFailureException e) {
			assertThat(e).hasRootCauseInstanceOf(NoNodeAvailableException.class);
		}
	}

	@Test // DATACASS-292
	void truncateShouldRemoveEntities() {

		template.truncate(User.class);

		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue())).isEqualTo("TRUNCATE users");
	}

	private static String render(SimpleStatement statement) {

		String query = statement.getQuery();
		List<Object> positionalValues = statement.getPositionalValues();
		for (Object positionalValue : positionalValues) {

			query = query.replaceFirst("\\?",
					positionalValue != null
							? CodecRegistry.DEFAULT.codecFor((Class) positionalValue.getClass()).format(positionalValue)
							: "NULL");
		}

		return query;
	}

	private interface UserProjection {
		String getFirstname();
	}
}

---

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

+58 — 4 new // GH-212 tests.

/*
 * Copyright 2016-present the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.springframework.data.cassandra.core;

import static org.assertj.core.api.Assertions.*;
import static org.mockito.ArgumentMatchers.*;
import static org.mockito.Mockito.*;
import static org.springframework.data.cassandra.core.query.Criteria.*;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.mockito.junit.jupiter.MockitoSettings;
import org.mockito.quality.Strictness;
import org.springframework.data.cassandra.CassandraConnectionFailureException;
import org.springframework.data.cassandra.core.mapping.event.BeforeConvertCallback;
import org.springframework.data.cassandra.core.mapping.event.BeforeSaveCallback;
import org.springframework.data.cassandra.core.query.Filter;
import org.springframework.data.cassandra.core.query.Query;
import org.springframework.data.cassandra.core.query.Update;
import org.springframework.data.cassandra.domain.User;
import org.springframework.data.cassandra.domain.VersionedUser;
import org.springframework.data.mapping.callback.EntityCallbacks;

import com.datastax.oss.driver.api.core.CqlIdentifier;
import com.datastax.oss.driver.api.core.CqlSession;
import com.datastax.oss.driver.api.core.NoNodeAvailableException;
import com.datastax.oss.driver.api.core.context.DriverContext;
import com.datastax.oss.driver.api.core.cql.AsyncResultSet;
import com.datastax.oss.driver.api.core.cql.ColumnDefinition;
import com.datastax.oss.driver.api.core.cql.ColumnDefinitions;
import com.datastax.oss.driver.api.core.cql.Row;
import com.datastax.oss.driver.api.core.cql.SimpleStatement;
import com.datastax.oss.driver.api.core.cql.Statement;
import com.datastax.oss.driver.api.core.type.DataTypes;
import com.datastax.oss.driver.api.core.type.codec.registry.CodecRegistry;
import com.datastax.oss.driver.internal.core.type.codec.registry.DefaultCodecRegistry;

/**
 * Unit tests for {@link AsyncCassandraTemplate}.
 *
 * @author Mark Paluch
 */
@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
class AsyncCassandraTemplateUnitTests {

	@Mock CqlSession session;
	CodecRegistry codecRegistry = new DefaultCodecRegistry("foo");
	@Mock DriverContext driverContext;
	@Mock AsyncResultSet resultSet;
	@Mock Row row;
	@Mock ColumnDefinition columnDefinition;
	@Mock ColumnDefinitions columnDefinitions;

	@Captor ArgumentCaptor<SimpleStatement> statementCaptor;

	private AsyncCassandraTemplate template;

	private Object beforeSave;

	private Object beforeConvert;

	@BeforeEach
	void setUp() {

		when(driverContext.getCodecRegistry()).thenReturn(codecRegistry);
		when(session.getContext()).thenReturn(driverContext);

		when(session.executeAsync(any(Statement.class))).thenReturn(new TestResultSetFuture(resultSet));
		when(row.getColumnDefinitions()).thenReturn(columnDefinitions);

		EntityCallbacks callbacks = EntityCallbacks.create();
		callbacks.addEntityCallback((BeforeSaveCallback<Object>) (entity, tableName, statement) -> {

			assertThat(tableName).isNotNull();
			assertThat(statement).isNotNull();
			beforeSave = entity;
			return entity;
		});

		callbacks.addEntityCallback((BeforeConvertCallback<Object>) (entity, tableName) -> {

			assertThat(tableName).isNotNull();
			beforeConvert = entity;
			return entity;
		});

		template = new AsyncCassandraTemplate(session);
		template.setUsePreparedStatements(false);
		template.setEntityCallbacks(callbacks);
	}

	@Test // gh-1133
	void shouldConfigureConverterFromSession() {
		assertThat(template.getConverter().getCodecRegistry()).isEqualTo(session.getContext().getCodecRegistry());
		assertThat(template.getConverter()).extracting("userTypeResolver").isNotNull();
	}

	@Test // DATACASS-292
	void selectUsingCqlShouldReturnMappedResults() {

		when(resultSet.currentPage()).thenReturn(Collections.singleton(row));
		when(columnDefinitions.contains(any(CqlIdentifier.class))).thenReturn(true);

		when(columnDefinitions.get(anyInt())).thenReturn(columnDefinition);
		when(columnDefinitions.firstIndexOf("id")).thenReturn(0);
		when(columnDefinitions.firstIndexOf("firstname")).thenReturn(1);
		when(columnDefinitions.firstIndexOf("lastname")).thenReturn(2);

		when(columnDefinition.getType()).thenReturn(DataTypes.TEXT);

		when(row.getObject(0)).thenReturn("myid");
		when(row.getObject(1)).thenReturn("Walter");
		when(row.getObject(2)).thenReturn("White");

		CompletableFuture<List<User>> list = template.select("SELECT * FROM users", User.class);

		assertThat(getUninterruptibly(list)).hasSize(1).contains(new User("myid", "Walter", "White"));
		verify(session).executeAsync(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue())).isEqualTo("SELECT * FROM users");
	}

	@Test // DATACASS-292
	void selectUsingCqlShouldInvokeCallbackWithMappedResults() {

		when(resultSet.currentPage()).thenReturn(Collections.singletonList(row));
		when(columnDefinitions.contains(any(CqlIdentifier.class))).thenReturn(true);
		when(columnDefinitions.get(anyInt())).thenReturn(columnDefinition);
		when(columnDefinitions.firstIndexOf("id")).thenReturn(0);
		when(columnDefinitions.firstIndexOf("firstname")).thenReturn(1);
		when(columnDefinitions.firstIndexOf("lastname")).thenReturn(2);

		when(columnDefinition.getType()).thenReturn(DataTypes.TEXT);

		when(row.getObject(0)).thenReturn("myid");
		when(row.getObject(1)).thenReturn("Walter");
		when(row.getObject(2)).thenReturn("White");

		List<User> list = new ArrayList<>();

		CompletableFuture<Void> result = template.select("SELECT * FROM users", list::add, User.class);

		assertThat(getUninterruptibly(result)).isNull();
		assertThat(list).hasSize(1).contains(new User("myid", "Walter", "White"));
		verify(session).executeAsync(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue())).isEqualTo("SELECT * FROM users");
	}

	@Test // DATACASS-292
	void selectShouldTranslateException() throws Exception {

		when(resultSet.currentPage()).thenThrow(new NoNodeAvailableException());

		CompletableFuture<List<User>> list = template.select("SELECT * FROM users", User.class);

		try {
			list.get();

			fail("Missing CassandraConnectionFailureException");
		} catch (ExecutionException e) {
			assertThat(e).hasCauseInstanceOf(CassandraConnectionFailureException.class)
					.hasRootCauseInstanceOf(NoNodeAvailableException.class);
		}
	}

	@Test // DATACASS-292
	void selectOneShouldReturnMappedResults() {

		when(resultSet.currentPage()).thenReturn(Collections.singleton(row));
		when(columnDefinitions.contains(any(CqlIdentifier.class))).thenReturn(true);

		when(columnDefinitions.get(anyInt())).thenReturn(columnDefinition);
		when(columnDefinitions.firstIndexOf("id")).thenReturn(0);
		when(columnDefinitions.firstIndexOf("firstname")).thenReturn(1);
		when(columnDefinitions.firstIndexOf("lastname")).thenReturn(2);

		when(columnDefinition.getType()).thenReturn(DataTypes.TEXT);

		when(row.getObject(0)).thenReturn("myid");
		when(row.getObject(1)).thenReturn("Walter");
		when(row.getObject(2)).thenReturn("White");

		CompletableFuture<User> future = template.selectOne("SELECT * FROM users WHERE id='myid'", User.class);

		assertThat(getUninterruptibly(future)).isEqualTo(new User("myid", "Walter", "White"));
		verify(session).executeAsync(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue())).isEqualTo("SELECT * FROM users WHERE id='myid'");
	}

	@Test // DATACASS-292
	void selectOneByIdShouldReturnMappedResults() {

		when(resultSet.currentPage()).thenReturn(Collections.singleton(row));
		when(columnDefinitions.contains(any(CqlIdentifier.class))).thenReturn(true);
		when(columnDefinitions.get(anyInt())).thenReturn(columnDefinition);
		when(columnDefinitions.firstIndexOf("id")).thenReturn(0);
		when(columnDefinitions.firstIndexOf("firstname")).thenReturn(1);
		when(columnDefinitions.firstIndexOf("lastname")).thenReturn(2);

		when(columnDefinition.getType()).thenReturn(DataTypes.ASCII);

		when(row.getObject(0)).thenReturn("myid");
		when(row.getObject(1)).thenReturn("Walter");
		when(row.getObject(2)).thenReturn("White");

		CompletableFuture<User> future = template.selectOneById("myid", User.class);

		assertThat(getUninterruptibly(future)).isEqualTo(new User("myid", "Walter", "White"));
		verify(session).executeAsync(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue())).isEqualTo("SELECT * FROM users WHERE id='myid' LIMIT 1");
	}

	@Test // DATACASS-696
	void selectOneShouldNull() {

		when(resultSet.currentPage()).thenReturn(Collections.singleton(row));

		CompletableFuture<String> future = template.selectOne("SELECT id FROM users WHERE id='myid'", String.class);

		assertThat(getUninterruptibly(future)).isNull();
	}

	@Test // DATACASS-292
	void existsShouldReturnExistingElement() {

		when(resultSet.one()).thenReturn(row);

		CompletableFuture<Boolean> future = template.exists("myid", User.class);

		assertThat(getUninterruptibly(future)).isTrue();
		verify(session).executeAsync(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue())).isEqualTo("SELECT id FROM users WHERE id='myid' LIMIT 1");
	}

	@Test // DATACASS-292
	void existsShouldReturnNonExistingElement() {

		CompletableFuture<Boolean> future = template.exists("myid", User.class);

		assertThat(getUninterruptibly(future)).isFalse();
		verify(session).executeAsync(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue())).isEqualTo("SELECT id FROM users WHERE id='myid' LIMIT 1");
	}

	@Test // DATACASS-512
	void existsByQueryShouldReturnExistingElement() {

		when(resultSet.one()).thenReturn(row);

		CompletableFuture<Boolean> future = template.exists(Query.empty(), User.class);

		assertThat(getUninterruptibly(future)).isTrue();
		verify(session).executeAsync(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue())).isEqualTo("SELECT id FROM users LIMIT 1");
	}

	@Test // DATACASS-292
	void countShouldExecuteCountQueryElement() {

		when(resultSet.currentPage()).thenReturn(Collections.singleton(row));
		when(row.getLong(0)).thenReturn(42L);
		when(columnDefinitions.size()).thenReturn(1);

		CompletableFuture<Long> future = template.count(User.class);

		assertThat(getUninterruptibly(future)).isEqualTo(42L);
		verify(session).executeAsync(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue())).isEqualTo("SELECT count(1) FROM users");
	}

	@Test // DATACASS-292
	void countByQueryShouldExecuteCountQueryElement() {

		when(resultSet.currentPage()).thenReturn(Collections.singleton(row));
		when(row.getLong(0)).thenReturn(42L);
		when(columnDefinitions.size()).thenReturn(1);

		CompletableFuture<Long> future = template.count(Query.empty(), User.class);

		assertThat(getUninterruptibly(future)).isEqualTo(42L);
		verify(session).executeAsync(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue())).isEqualTo("SELECT count(1) FROM users");
	}

	@Test // DATACASS-292, DATACASS-618
	void insertShouldInsertEntity() {

		when(resultSet.wasApplied()).thenReturn(true);

		User user = new User("heisenberg", "Walter", "White");

		CompletableFuture<User> future = template.insert(user);

		assertThat(getUninterruptibly(future)).isEqualTo(user);
		verify(session).executeAsync(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue()))
				.isEqualTo("INSERT INTO users (id,firstname,lastname) VALUES ('heisenberg','Walter','White')");
		assertThat(beforeConvert).isSameAs(user);
		assertThat(beforeSave).isSameAs(user);
	}

	@Test
		// GH-1295
	void insertShouldConsiderEntityAfterCallback() {

		when(resultSet.wasApplied()).thenReturn(true);

		User user = new User("heisenberg", "Walter", "White");

		EntityCallbacks callbacks = EntityCallbacks.create();
		callbacks.addEntityCallback((BeforeConvertCallback<Object>) (entity, tableName) -> new User("ww", "Walter", "White"));
		template.setEntityCallbacks(callbacks);

		CompletableFuture<User> future = template.insert(user);

		assertThat(getUninterruptibly(future)).isNotSameAs(user);
		verify(session).executeAsync(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue()))
				.isEqualTo("INSERT INTO users (id,firstname,lastname) VALUES ('ww','Walter','White')");
	}

	@Test
		// DATACASS-618
	void insertShouldInsertVersionedEntity() {

		when(resultSet.wasApplied()).thenReturn(true);

		VersionedUser user = new VersionedUser("heisenberg", "Walter", "White");

		CompletableFuture<VersionedUser> future = template.insert(user);

		assertThat(getUninterruptibly(future)).isEqualTo(user);
		verify(session).executeAsync(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue())).isEqualTo(
				"INSERT INTO vusers (id,version,firstname,lastname) VALUES ('heisenberg',0,'Walter','White') IF NOT EXISTS");
		assertThat(beforeConvert).isSameAs(user);
		assertThat(beforeSave).isSameAs(user);
	}

	@Test // GH-212
	void insertJsonShouldInsertJson() {

		when(resultSet.wasApplied()).thenReturn(true);

		CompletableFuture<WriteResult> future = template.insertJson("{\"id\": \"heisenberg\"}", User.class);

		assertThat(getUninterruptibly(future).wasApplied()).isTrue();
		verify(session).executeAsync(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue()))
				.isEqualTo("INSERT INTO users JSON '{\"id\": \"heisenberg\"}' DEFAULT UNSET");
	}

	@Test // GH-212
	void insertJsonShouldApplyInsertOptions() {

		InsertOptions insertOptions = InsertOptions.builder().withIfNotExists().build();

		when(resultSet.wasApplied()).thenReturn(true);

		CompletableFuture<WriteResult> future = template.insertJson("{\"id\": \"heisenberg\"}", User.class,
				insertOptions);

		assertThat(getUninterruptibly(future).wasApplied()).isTrue();
		verify(session).executeAsync(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue()))
				.isEqualTo("INSERT INTO users JSON '{\"id\": \"heisenberg\"}' DEFAULT UNSET IF NOT EXISTS");
	}

	@Test // GH-212
	void selectJsonShouldReturnJson() {

		when(resultSet.currentPage()).thenReturn(Collections.singleton(row));
		when(columnDefinitions.size()).thenReturn(1);
		when(row.getString(0)).thenReturn("{\"id\": \"heisenberg\"}");

		CompletableFuture<List<String>> future = template.selectJson(Query.empty(), User.class);

		assertThat(getUninterruptibly(future)).containsExactly("{\"id\": \"heisenberg\"}");
		verify(session).executeAsync(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue())).isEqualTo("SELECT JSON * FROM users");
	}

	@Test // GH-212
	void selectOneJsonShouldReturnJson() {

		when(resultSet.currentPage()).thenReturn(Collections.singleton(row));
		when(columnDefinitions.size()).thenReturn(1);
		when(row.getString(0)).thenReturn("{\"id\": \"heisenberg\"}");

		CompletableFuture<String> future = template.selectOneJson(Query.query(where("id").is("heisenberg")),
				User.class);

		assertThat(getUninterruptibly(future)).isEqualTo("{\"id\": \"heisenberg\"}");
		verify(session).executeAsync(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue())).isEqualTo("SELECT JSON * FROM users WHERE id='heisenberg'");
	}

	@Test // DATACASS-292
	void insertShouldTranslateException() throws Exception {

		reset(session);
		when(session.executeAsync(any(Statement.class)))
				.thenReturn(TestResultSetFuture.failed(new NoNodeAvailableException()));

		CompletableFuture<User> future = template.insert(new User("heisenberg", "Walter", "White"));

		try {
			future.get();

			fail("Missing CassandraConnectionFailureException");
		} catch (ExecutionException e) {
			assertThat(e).hasCauseInstanceOf(CassandraConnectionFailureException.class)
					.hasRootCauseInstanceOf(NoNodeAvailableException.class);
		}
	}

	@Test // DATACASS-292, DATACASS-618
	void updateShouldUpdateEntity() {

		when(resultSet.wasApplied()).thenReturn(true);

		User user = new User("heisenberg", "Walter", "White");

		CompletableFuture<User> future = template.update(user);

		assertThat(getUninterruptibly(future)).isEqualTo(user);
		verify(session).executeAsync(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue()))
				.isEqualTo("UPDATE users SET firstname='Walter', lastname='White' WHERE id='heisenberg'");
		assertThat(beforeConvert).isSameAs(user);
		assertThat(beforeSave).isSameAs(user);
	}

	@Test // DATACASS-618
	void updateShouldUpdateVersionedEntity() {

		when(resultSet.wasApplied()).thenReturn(true);

		VersionedUser user = new VersionedUser("heisenberg", "Walter", "White");
		user.setVersion(0L);

		CompletableFuture<VersionedUser> future = template.update(user);

		assertThat(getUninterruptibly(future)).isEqualTo(user);
		verify(session).executeAsync(statementCaptor.capture());
		SimpleStatement value = statementCaptor.getValue();
		assertThat(render(value)).isEqualTo(
				"UPDATE vusers SET version=1, firstname='Walter', lastname='White' WHERE id='heisenberg' IF version=0");
		assertThat(beforeConvert).isSameAs(user);
		assertThat(beforeSave).isSameAs(user);
	}

	@Test // DATACASS-575
	void updateShouldUpdateEntityWithOptions() {

		UpdateOptions updateOptions = UpdateOptions.builder().withIfExists().build();
		User user = new User("heisenberg", "Walter", "White");

		template.update(user, updateOptions);

		verify(session).executeAsync(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue()))
				.isEqualTo("UPDATE users SET firstname='Walter', lastname='White' WHERE id='heisenberg' IF EXISTS");
	}

	@Test // DATACASS-575
	void updateShouldUpdateEntityWithLwt() {

		UpdateOptions options = UpdateOptions.builder().ifCondition(where("firstname").is("Walter")).build();
		User user = new User("heisenberg", "Walter", "White");

		template.update(user, options);

		verify(session).executeAsync(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue()))
				.isEqualTo("UPDATE users SET firstname='Walter', lastname='White' WHERE id='heisenberg' IF firstname='Walter'");
	}

	@Test // DATACASS-575
	void updateShouldApplyUpdateQuery() {

		Query query = Query.query(where("id").is("heisenberg"));
		Update update = Update.update("firstname", "Walter");

		template.update(query, update, User.class);

		verify(session).executeAsync(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue()))
				.isEqualTo("UPDATE users SET firstname='Walter' WHERE id='heisenberg'");
	}

	@Test // DATACASS-575
	void updateShouldApplyUpdateQueryWitLwt() {

		Filter ifCondition = Filter.from(where("firstname").is("Walter"), where("lastname").is("White"));

		Query query = Query.query(where("id").is("heisenberg"))
				.queryOptions(UpdateOptions.builder().ifCondition(ifCondition).build());

		Update update = Update.update("firstname", "Walter");

		template.update(query, update, User.class);

		verify(session).executeAsync(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue())).isEqualTo(
				"UPDATE users SET firstname='Walter' WHERE id='heisenberg' IF firstname='Walter' AND lastname='White'");
	}

	@Test // DATACASS-292
	void updateShouldTranslateException() throws Exception {

		reset(session);
		when(session.executeAsync(any(Statement.class)))
				.thenReturn(TestResultSetFuture.failed(new NoNodeAvailableException()));

		CompletableFuture<User> future = template.update(new User("heisenberg", "Walter", "White"));

		try {
			future.get();

			fail("Missing CassandraConnectionFailureException");
		} catch (ExecutionException e) {
			assertThat(e).hasCauseInstanceOf(CassandraConnectionFailureException.class)
					.hasRootCauseInstanceOf(NoNodeAvailableException.class);
		}
	}

	@Test // DATACASS-292
	void deleteByIdShouldRemoveEntity() {

		when(resultSet.wasApplied()).thenReturn(true);

		User user = new User("heisenberg", "Walter", "White");

		CompletableFuture<Boolean> future = template.deleteById(user.getId(), User.class);

		assertThat(getUninterruptibly(future)).isTrue();
		verify(session).executeAsync(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue())).isEqualTo("DELETE FROM users WHERE id='heisenberg'");
	}

	@Test // DATACASS-292
	void deleteShouldRemoveEntity() {

		when(resultSet.wasApplied()).thenReturn(true);

		User user = new User("heisenberg", "Walter", "White");

		CompletableFuture<User> future = template.delete(user);

		assertThat(getUninterruptibly(future)).isEqualTo(user);
		verify(session).executeAsync(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue())).isEqualTo("DELETE FROM users WHERE id='heisenberg'");
	}

	@Test // DATACASS-575
	void deleteShouldRemoveEntityWithLwt() {

		User user = new User("heisenberg", "Walter", "White");
		DeleteOptions options = DeleteOptions.builder().ifCondition(where("firstname").is("Walter")).build();

		template.delete(user, options);

		verify(session).executeAsync(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue()))
				.isEqualTo("DELETE FROM users WHERE id='heisenberg' IF firstname='Walter'");
	}

	@Test // DATACASS-575
	void deleteShouldRemoveByQueryWithLwt() {

		DeleteOptions options = DeleteOptions.builder().ifCondition(where("firstname").is("Walter")).build();
		Query query = Query.query(where("id").is("heisenberg")).queryOptions(options);

		template.delete(query, User.class);

		verify(session).executeAsync(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue()))
				.isEqualTo("DELETE FROM users WHERE id='heisenberg' IF firstname='Walter'");
	}

	@Test // DATACASS-292
	void deleteShouldTranslateException() throws Exception {

		reset(session);
		when(session.executeAsync(any(Statement.class)))
				.thenReturn(TestResultSetFuture.failed(new NoNodeAvailableException()));

		CompletableFuture<User> future = template.delete(new User("heisenberg", "Walter", "White"));

		try {
			future.get();

			fail("Missing CassandraConnectionFailureException");
		} catch (ExecutionException e) {
			assertThat(e).hasCauseInstanceOf(CassandraConnectionFailureException.class)
					.hasRootCauseInstanceOf(NoNodeAvailableException.class);
		}
	}

	@Test // DATACASS-292
	void truncateShouldRemoveEntities() {

		template.truncate(User.class);

		verify(session).executeAsync(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue())).isEqualTo("TRUNCATE users");
	}

	private static String render(SimpleStatement statement) {

		String query = statement.getQuery();
		List<Object> positionalValues = statement.getPositionalValues();
		for (Object positionalValue : positionalValues) {

			query = query.replaceFirst("\\?",
					positionalValue != null
							? CodecRegistry.DEFAULT.codecFor((Class) positionalValue.getClass()).format(positionalValue)
							: "NULL");
		}

		return query;
	}

	private static <T> T getUninterruptibly(Future<T> future) {

		try {
			return future.get();
		} catch (Exception e) {
			throw new IllegalStateException(e);
		}
	}

	private static class TestResultSetFuture extends CompletableFuture<AsyncResultSet> {

		private TestResultSetFuture() {}

		private TestResultSetFuture(AsyncResultSet resultSet) {
			complete(resultSet);
		}

		/**
		 * Create a completed future that reports a failure given {@link Throwable}.
		 *
		 * @param throwable must not be {@literal null}.
		 * @return the completed/failed {@link TestResultSetFuture}.
		 */
		private static TestResultSetFuture failed(Throwable throwable) {

			TestResultSetFuture future = new TestResultSetFuture();
			future.completeExceptionally(throwable);
			return future;
		}
	}
}

---

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

+63 — 4 new // GH-212 tests (StepVerifier).

/*
 * Copyright 2016-present the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.springframework.data.cassandra.core;

import static org.assertj.core.api.Assertions.*;
import static org.mockito.ArgumentMatchers.*;
import static org.mockito.Mockito.*;
import static org.springframework.data.cassandra.core.query.Criteria.*;

import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import reactor.test.StepVerifier;

import java.util.List;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.mockito.junit.jupiter.MockitoSettings;
import org.mockito.quality.Strictness;
import org.springframework.data.cassandra.ReactiveResultSet;
import org.springframework.data.cassandra.ReactiveSession;
import org.springframework.data.cassandra.core.mapping.event.ReactiveBeforeConvertCallback;
import org.springframework.data.cassandra.core.mapping.event.ReactiveBeforeSaveCallback;
import org.springframework.data.cassandra.core.query.Filter;
import org.springframework.data.cassandra.core.query.Query;
import org.springframework.data.cassandra.core.query.Update;
import org.springframework.data.cassandra.domain.User;
import org.springframework.data.cassandra.domain.VersionedUser;
import org.springframework.data.mapping.callback.ReactiveEntityCallbacks;

import com.datastax.oss.driver.api.core.CqlIdentifier;
import com.datastax.oss.driver.api.core.NoNodeAvailableException;
import com.datastax.oss.driver.api.core.context.DriverContext;
import com.datastax.oss.driver.api.core.cql.ColumnDefinition;
import com.datastax.oss.driver.api.core.cql.ColumnDefinitions;
import com.datastax.oss.driver.api.core.cql.Row;
import com.datastax.oss.driver.api.core.cql.SimpleStatement;
import com.datastax.oss.driver.api.core.cql.Statement;
import com.datastax.oss.driver.api.core.type.DataTypes;
import com.datastax.oss.driver.api.core.type.codec.registry.CodecRegistry;
import com.datastax.oss.driver.internal.core.type.codec.registry.DefaultCodecRegistry;

/**
 * Unit tests for {@link ReactiveCassandraTemplate}.
 *
 * @author Mark Paluch
 */
@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
class ReactiveCassandraTemplateUnitTests {

	@Mock ReactiveSession session;
	CodecRegistry codecRegistry = new DefaultCodecRegistry("foo");
	@Mock DriverContext driverContext;
	@Mock ReactiveResultSet reactiveResultSet;
	@Mock Row row;
	@Mock ColumnDefinition columnDefinition;
	@Mock ColumnDefinitions columnDefinitions;

	@Captor ArgumentCaptor<SimpleStatement> statementCaptor;

	private ReactiveCassandraTemplate template;

	private Object beforeSave;

	private Object beforeConvert;

	@BeforeEach
	void setUp() {

		when(driverContext.getCodecRegistry()).thenReturn(codecRegistry);
		when(session.getContext()).thenReturn(driverContext);
		when(session.execute(any(Statement.class))).thenReturn(Mono.just(reactiveResultSet));
		when(row.getColumnDefinitions()).thenReturn(columnDefinitions);

		ReactiveEntityCallbacks callbacks = ReactiveEntityCallbacks.create();
		callbacks.addEntityCallback((ReactiveBeforeSaveCallback<Object>) (entity, tableName, statement) -> {

			assertThat(tableName).isNotNull();
			assertThat(statement).isNotNull();
			beforeSave = entity;
			return Mono.just(entity);
		});

		callbacks.addEntityCallback((ReactiveBeforeConvertCallback<Object>) (entity, tableName) -> {

			assertThat(tableName).isNotNull();
			beforeConvert = entity;
			return Mono.just(entity);
		});

		template = new ReactiveCassandraTemplate(session);
		template.setUsePreparedStatements(false);
		template.setEntityCallbacks(callbacks);
	}

	@Test // gh-1133
	void shouldConfigureConverterFromSession() {
		assertThat(template.getConverter().getCodecRegistry()).isEqualTo(session.getContext().getCodecRegistry());
		assertThat(template.getConverter()).extracting("userTypeResolver").isNotNull();
	}

	@Test // DATACASS-335
	void selectUsingCqlShouldReturnMappedResults() {

		when(reactiveResultSet.rows()).thenReturn(Flux.just(row));
		when(columnDefinitions.contains(any(CqlIdentifier.class))).thenReturn(true);

		when(columnDefinitions.get(anyInt())).thenReturn(columnDefinition);
		when(columnDefinitions.firstIndexOf("id")).thenReturn(0);
		when(columnDefinitions.firstIndexOf("firstname")).thenReturn(1);
		when(columnDefinitions.firstIndexOf("lastname")).thenReturn(2);

		when(columnDefinition.getType()).thenReturn(DataTypes.TEXT);

		when(row.getObject(0)).thenReturn("myid");
		when(row.getObject(1)).thenReturn("Walter");
		when(row.getObject(2)).thenReturn("White");

		template.select("SELECT * FROM users", User.class).as(StepVerifier::create) //
				.expectNext(new User("myid", "Walter", "White")) //
				.verifyComplete();

		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue())).isEqualTo("SELECT * FROM users");
	}

	@Test // DATACASS-335
	void selectShouldTranslateException() {

		when(reactiveResultSet.rows()).thenThrow(new NoNodeAvailableException());

		template.select("SELECT * FROM users", User.class).as(StepVerifier::create) //
				.consumeErrorWith(e -> {
					assertThat(e).hasRootCauseInstanceOf(NoNodeAvailableException.class);
				}).verify();
	}

	@Test // DATACASS-335
	void selectOneByIdShouldReturnMappedResults() {

		when(reactiveResultSet.rows()).thenReturn(Flux.just(row));
		when(columnDefinitions.contains(any(CqlIdentifier.class))).thenReturn(true);
		when(columnDefinitions.get(anyInt())).thenReturn(columnDefinition);
		when(columnDefinitions.firstIndexOf("id")).thenReturn(0);
		when(columnDefinitions.firstIndexOf("firstname")).thenReturn(1);
		when(columnDefinitions.firstIndexOf("lastname")).thenReturn(2);

		when(columnDefinition.getType()).thenReturn(DataTypes.ASCII);

		when(row.getObject(0)).thenReturn("myid");
		when(row.getObject(1)).thenReturn("Walter");
		when(row.getObject(2)).thenReturn("White");

		template.selectOneById("myid", User.class).as(StepVerifier::create) //
				.expectNext(new User("myid", "Walter", "White")) //
				.verifyComplete();

		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue())).isEqualTo("SELECT * FROM users WHERE id='myid' LIMIT 1");
	}

	@Test // DATACASS-313
	void selectProjectedOneShouldReturnMappedResults() {

		when(reactiveResultSet.rows()).thenReturn(Flux.just(row));
		when(columnDefinitions.contains(any(CqlIdentifier.class))).thenReturn(true);
		when(columnDefinitions.get(anyInt())).thenReturn(columnDefinition);
		when(columnDefinitions.firstIndexOf("id")).thenReturn(0);

		when(columnDefinition.getType()).thenReturn(DataTypes.ASCII);

		when(row.getObject(0)).thenReturn("Walter");

		template.query(User.class).as(UserProjection.class).first() //
				.as(StepVerifier::create) //
				.assertNext(actual -> {

					assertThat(actual.getFirstname()).isEqualTo("Walter");
				}).verifyComplete();

		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue())).isEqualTo("SELECT firstname FROM users LIMIT 1");
	}

	@Test // DATACASS-696
	void selectOneShouldNull() {

		when(reactiveResultSet.rows()).thenReturn(Flux.just(row));

		template.selectOne("SELECT id FROM users WHERE id='myid'", String.class).as(StepVerifier::create) //
				.verifyComplete();
	}

	@Test // DATACASS-335
	void existsShouldReturnExistingElement() {

		when(reactiveResultSet.rows()).thenReturn(Flux.just(row));

		template.exists("myid", User.class).as(StepVerifier::create).expectNext(true).verifyComplete();

		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue())).isEqualTo("SELECT id FROM users WHERE id='myid' LIMIT 1");
	}

	@Test // DATACASS-335
	void existsShouldReturnNonExistingElement() {

		when(reactiveResultSet.rows()).thenReturn(Flux.empty());

		template.exists("myid", User.class).as(StepVerifier::create).expectNext(false).verifyComplete();

		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue())).isEqualTo("SELECT id FROM users WHERE id='myid' LIMIT 1");
	}

	@Test // DATACASS-512
	void existsByQueryShouldReturnExistingElement() {

		when(reactiveResultSet.rows()).thenReturn(Flux.just(row));

		template.exists(Query.empty(), User.class).as(StepVerifier::create).expectNext(true).verifyComplete();

		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue())).isEqualTo("SELECT id FROM users LIMIT 1");
	}

	@Test // DATACASS-512
	void existsByQueryShouldReturnNonExistingElement() {

		when(reactiveResultSet.rows()).thenReturn(Flux.empty());

		template.exists(Query.empty(), User.class).as(StepVerifier::create).expectNext(false).verifyComplete();

		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue())).isEqualTo("SELECT id FROM users LIMIT 1");
	}

	@Test // DATACASS-335
	void countShouldExecuteCountQueryElement() {

		when(reactiveResultSet.rows()).thenReturn(Flux.just(row));
		when(row.getLong(0)).thenReturn(42L);
		when(columnDefinitions.size()).thenReturn(1);

		template.count(User.class).as(StepVerifier::create).expectNext(42L).verifyComplete();

		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue())).isEqualTo("SELECT count(1) FROM users");
	}

	@Test // DATACASS-512
	void countByQueryShouldExecuteCountQueryElement() {

		when(reactiveResultSet.rows()).thenReturn(Flux.just(row));
		when(row.getLong(0)).thenReturn(42L);
		when(columnDefinitions.size()).thenReturn(1);

		template.count(Query.empty(), User.class).as(StepVerifier::create).expectNext(42L).verifyComplete();

		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue())).isEqualTo("SELECT count(1) FROM users");
	}

	@Test // DATACASS-335, DATACASS-618
	void insertShouldInsertEntity() {

		when(reactiveResultSet.wasApplied()).thenReturn(true);
		when(reactiveResultSet.rows()).thenReturn(Flux.just(row));

		User user = new User("heisenberg", "Walter", "White");
		template.insert(user).as(StepVerifier::create).expectNext(user).verifyComplete();

		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue()))
				.isEqualTo("INSERT INTO users (id,firstname,lastname) VALUES ('heisenberg','Walter','White')");
		assertThat(beforeConvert).isSameAs(user);
		assertThat(beforeSave).isSameAs(user);
	}

	@Test // DATACASS-618
	void insertShouldInsertVersionedEntity() {

		when(reactiveResultSet.wasApplied()).thenReturn(true);
		when(reactiveResultSet.rows()).thenReturn(Flux.just(row));

		VersionedUser user = new VersionedUser("heisenberg", "Walter", "White");
		StepVerifier.create(template.insert(user)).expectNext(user).verifyComplete();

		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue())).isEqualTo(
				"INSERT INTO vusers (id,version,firstname,lastname) VALUES ('heisenberg',0,'Walter','White') IF NOT EXISTS");
		assertThat(beforeConvert).isSameAs(user);
		assertThat(beforeSave).isSameAs(user);
	}

	@Test // GH-212
	void insertJsonShouldInsertJson() {

		when(reactiveResultSet.wasApplied()).thenReturn(true);
		when(reactiveResultSet.rows()).thenReturn(Flux.empty());

		template.insertJson("{\"id\": \"heisenberg\"}", User.class).as(StepVerifier::create)
				.assertNext(writeResult -> assertThat(writeResult.wasApplied()).isTrue()) //
				.verifyComplete();

		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue()))
				.isEqualTo("INSERT INTO users JSON '{\"id\": \"heisenberg\"}' DEFAULT UNSET");
	}

	@Test // GH-212
	void insertJsonShouldApplyInsertOptions() {

		InsertOptions insertOptions = InsertOptions.builder().withIfNotExists().build();

		when(reactiveResultSet.wasApplied()).thenReturn(true);
		when(reactiveResultSet.rows()).thenReturn(Flux.empty());

		template.insertJson("{\"id\": \"heisenberg\"}", User.class, insertOptions).as(StepVerifier::create)
				.assertNext(writeResult -> assertThat(writeResult.wasApplied()).isTrue()) //
				.verifyComplete();

		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue()))
				.isEqualTo("INSERT INTO users JSON '{\"id\": \"heisenberg\"}' DEFAULT UNSET IF NOT EXISTS");
	}

	@Test // GH-212
	void selectJsonShouldReturnJson() {

		when(reactiveResultSet.rows()).thenReturn(Flux.just(row));
		when(columnDefinitions.size()).thenReturn(1);
		when(row.getString(0)).thenReturn("{\"id\": \"heisenberg\"}");

		template.selectJson(Query.empty(), User.class).as(StepVerifier::create) //
				.expectNext("{\"id\": \"heisenberg\"}") //
				.verifyComplete();

		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue())).isEqualTo("SELECT JSON * FROM users");
	}

	@Test // GH-212
	void selectOneJsonShouldReturnJson() {

		when(reactiveResultSet.rows()).thenReturn(Flux.just(row));
		when(columnDefinitions.size()).thenReturn(1);
		when(row.getString(0)).thenReturn("{\"id\": \"heisenberg\"}");

		template.selectOneJson(Query.query(where("id").is("heisenberg")), User.class).as(StepVerifier::create) //
				.expectNext("{\"id\": \"heisenberg\"}") //
				.verifyComplete();

		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue()))
				.isEqualTo("SELECT JSON * FROM users WHERE id='heisenberg' LIMIT 1");
	}

	@Test // DATACASS-335
	void insertShouldTranslateException() {

		reset(session);
		when(session.execute(any(Statement.class))).thenReturn(Mono.error(new NoNodeAvailableException()));

		template.insert(new User("heisenberg", "Walter", "White")).as(StepVerifier::create) //
				.consumeErrorWith(e -> {

					assertThat(e).hasRootCauseInstanceOf(NoNodeAvailableException.class);
				}).verify();
	}

	@Test // DATACASS-335, DATACASS-618
	void updateShouldUpdateEntity() {

		when(reactiveResultSet.wasApplied()).thenReturn(true);
		when(reactiveResultSet.rows()).thenReturn(Flux.just(row));

		User user = new User("heisenberg", "Walter", "White");

		template.update(user).as(StepVerifier::create).expectNext(user).verifyComplete();

		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue()))
				.isEqualTo("UPDATE users SET firstname='Walter', lastname='White' WHERE id='heisenberg'");
		assertThat(beforeConvert).isSameAs(user);
		assertThat(beforeSave).isSameAs(user);
	}

	@Test // DATACASS-618
	void updateShouldUpdateVersionedEntity() {

		when(reactiveResultSet.wasApplied()).thenReturn(true);
		when(reactiveResultSet.rows()).thenReturn(Flux.just(row));

		VersionedUser user = new VersionedUser("heisenberg", "Walter", "White");
		user.setVersion(0L);

		StepVerifier.create(template.update(user)).expectNext(user).verifyComplete();

		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue())).isEqualTo(
				"UPDATE vusers SET version=1, firstname='Walter', lastname='White' WHERE id='heisenberg' IF version=0");
		assertThat(beforeConvert).isSameAs(user);
		assertThat(beforeSave).isSameAs(user);
	}

	@Test // DATACASS-575
	void updateShouldUpdateEntityWithOptions() {

		when(reactiveResultSet.rows()).thenReturn(Flux.just(row));

		UpdateOptions updateOptions = UpdateOptions.builder().withIfExists().build();
		User user = new User("heisenberg", "Walter", "White");

		template.update(user, updateOptions) //
				.as(StepVerifier::create) //
				.expectNextCount(1) //
				.verifyComplete();

		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue()))
				.isEqualTo("UPDATE users SET firstname='Walter', lastname='White' WHERE id='heisenberg' IF EXISTS");
	}

	@Test // DATACASS-575
	void updateShouldUpdateEntityWithLwt() {

		when(reactiveResultSet.rows()).thenReturn(Flux.just(row));

		UpdateOptions options = UpdateOptions.builder().ifCondition(where("firstname").is("Walter")).build();
		User user = new User("heisenberg", "Walter", "White");

		template.update(user, options) //
				.as(StepVerifier::create) //
				.expectNextCount(1) //
				.verifyComplete();

		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue()))
				.isEqualTo("UPDATE users SET firstname='Walter', lastname='White' WHERE id='heisenberg' IF firstname='Walter'");
	}

	@Test // DATACASS-575
	void updateShouldApplyUpdateQuery() {

		when(reactiveResultSet.rows()).thenReturn(Flux.just(row));

		Query query = Query.query(where("id").is("heisenberg"));
		Update update = Update.update("firstname", "Walter");

		template.update(query, update, User.class) //
				.as(StepVerifier::create) //
				.expectNextCount(1) //
				.verifyComplete();

		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue()))
				.isEqualTo("UPDATE users SET firstname='Walter' WHERE id='heisenberg'");
	}

	@Test // DATACASS-575
	void updateShouldApplyUpdateQueryWitLwt() {

		when(reactiveResultSet.rows()).thenReturn(Flux.just(row));

		Filter ifCondition = Filter.from(where("firstname").is("Walter"), where("lastname").is("White"));

		Query query = Query.query(where("id").is("heisenberg"))
				.queryOptions(UpdateOptions.builder().ifCondition(ifCondition).build());

		Update update = Update.update("firstname", "Walter");

		template.update(query, update, User.class) //
				.as(StepVerifier::create) //
				.expectNextCount(1) //
				.verifyComplete();

		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue())).isEqualTo(
				"UPDATE users SET firstname='Walter' WHERE id='heisenberg' IF firstname='Walter' AND lastname='White'");
	}

	@Test // DATACASS-335
	void deleteShouldRemoveEntity() {

		when(reactiveResultSet.wasApplied()).thenReturn(true);
		when(reactiveResultSet.rows()).thenReturn(Flux.just(row));

		User user = new User("heisenberg", "Walter", "White");

		template.delete(user).as(StepVerifier::create).expectNext(user).verifyComplete();

		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue())).isEqualTo("DELETE FROM users WHERE id='heisenberg'");
	}

	@Test // DATACASS-575
	void deleteShouldRemoveEntityWithLwt() {

		when(reactiveResultSet.rows()).thenReturn(Flux.just(row));

		User user = new User("heisenberg", "Walter", "White");
		DeleteOptions options = DeleteOptions.builder().ifCondition(where("firstname").is("Walter")).build();

		template.delete(user, options) //
				.as(StepVerifier::create) //
				.expectNextCount(1) //
				.verifyComplete();

		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue()))
				.isEqualTo("DELETE FROM users WHERE id='heisenberg' IF firstname='Walter'");
	}

	@Test // DATACASS-575
	void deleteShouldRemoveByQueryWithLwt() {

		when(reactiveResultSet.rows()).thenReturn(Flux.just(row));

		DeleteOptions options = DeleteOptions.builder().ifCondition(where("firstname").is("Walter")).build();
		Query query = Query.query(where("id").is("heisenberg")).queryOptions(options);

		template.delete(query, User.class) //
				.as(StepVerifier::create) //
				.expectNextCount(1) //
				.verifyComplete();

		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue()))
				.isEqualTo("DELETE FROM users WHERE id='heisenberg' IF firstname='Walter'");
	}

	@Test // DATACASS-335
	void truncateShouldRemoveEntities() {

		template.truncate(User.class).as(StepVerifier::create).verifyComplete();

		verify(session).execute(statementCaptor.capture());
		assertThat(render(statementCaptor.getValue())).isEqualTo("TRUNCATE users");
	}

	private static String render(SimpleStatement statement) {

		String query = statement.getQuery();
		List<Object> positionalValues = statement.getPositionalValues();
		for (Object positionalValue : positionalValues) {

			query = query.replaceFirst("\\?",
					positionalValue != null
							? CodecRegistry.DEFAULT.codecFor((Class) positionalValue.getClass()).format(positionalValue)
							: "NULL");
		}

		return query;
	}

	private interface UserProjection {
		String getFirstname();
	}
}

---

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

+93 — 6 new // GH-212 integration tests, gated on CASSANDRA_3_10 (new constant); require Docker/Testcontainers.

/*
 * Copyright 2016-present the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.springframework.data.cassandra.core;

import static org.assertj.core.api.Assertions.*;
import static org.assertj.core.api.Assumptions.assumeThat;
import static org.junit.Assume.*;
import static org.springframework.data.cassandra.core.query.Criteria.*;

import java.time.Instant;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.ZoneId;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.data.annotation.Id;
import org.springframework.data.cassandra.CassandraInvalidQueryException;
import org.springframework.data.cassandra.core.convert.MappingCassandraConverter;
import org.springframework.data.cassandra.core.cql.CqlTemplate;
import org.springframework.data.cassandra.core.cql.PrimaryKeyType;
import org.springframework.data.cassandra.core.cql.QueryOptions;
import org.springframework.data.cassandra.core.mapping.BasicMapId;
import org.springframework.data.cassandra.core.mapping.Embedded;
import org.springframework.data.cassandra.core.mapping.PrimaryKey;
import org.springframework.data.cassandra.core.mapping.PrimaryKeyClass;
import org.springframework.data.cassandra.core.mapping.PrimaryKeyColumn;
import org.springframework.data.cassandra.core.mapping.SimpleUserTypeResolver;
import org.springframework.data.cassandra.core.mapping.Table;
import org.springframework.data.cassandra.core.mapping.UserDefinedType;
import org.springframework.data.cassandra.core.query.CassandraPageRequest;
import org.springframework.data.cassandra.core.query.Columns;
import org.springframework.data.cassandra.core.query.Query;
import org.springframework.data.cassandra.core.query.Update;
import org.springframework.data.cassandra.domain.BookReference;
import org.springframework.data.cassandra.domain.User;
import org.springframework.data.cassandra.domain.UserToken;
import org.springframework.data.cassandra.repository.support.SchemaTestUtils;
import org.springframework.data.cassandra.support.CassandraVersion;
import org.springframework.data.cassandra.test.util.AbstractKeyspaceCreatingIntegrationTests;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Slice;
import org.springframework.data.domain.Sort;
import org.springframework.data.util.Version;
import org.springframework.util.ObjectUtils;

import com.datastax.oss.driver.api.core.CqlIdentifier;
import com.datastax.oss.driver.api.core.uuid.Uuids;

/**
 * Integration tests for {@link CassandraTemplate}.
 *
 * @author Mark Paluch
 * @author Christoph Strobl
 * @author Tomasz Lelek
 */
class CassandraTemplateIntegrationTests extends AbstractKeyspaceCreatingIntegrationTests {

	private static final Version CASSANDRA_3 = Version.parse("3.0");
	private static final Version CASSANDRA_3_10 = Version.parse("3.10");
	private static final Version CASSANDRA_4 = Version.parse("4.0");

	private Version cassandraVersion;

	private CassandraTemplate template;

	@BeforeEach
	void setUp() {

		MappingCassandraConverter converter = new MappingCassandraConverter();
		converter.setUserTypeResolver(new SimpleUserTypeResolver(session, CqlIdentifier.fromCql(keyspace)));
		converter.afterPropertiesSet();

		cassandraVersion = CassandraVersion.get(session);

		template = new CassandraTemplate(new CqlTemplate(session), converter);

		prepareTemplate(template);

		SchemaTestUtils.potentiallyCreateTableFor(User.class, template);
		SchemaTestUtils.potentiallyCreateTableFor(UserToken.class, template);
		SchemaTestUtils.potentiallyCreateTableFor(BookReference.class, template);
		SchemaTestUtils.potentiallyCreateTableFor(TimeClass.class, template);
		SchemaTestUtils.potentiallyCreateTableFor(TypeWithCompositeKey.class, template);
		SchemaTestUtils.potentiallyCreateTableFor(WithNullableEmbeddedType.class, template);
		SchemaTestUtils.potentiallyCreateTableFor(WithEmptyEmbeddedType.class, template);
		SchemaTestUtils.potentiallyCreateTableFor(WithPrefixedNullableEmbeddedType.class, template);
		SchemaTestUtils.createTableAndTypes(OuterWithNullableEmbeddedType.class, template);
		SchemaTestUtils.createTableAndTypes(OuterWithPrefixedNullableEmbeddedType.class, template);
		SchemaTestUtils.createTableAndTypes(WithMappedUdtList.class, template);
		SchemaTestUtils.truncate(User.class, template);
		SchemaTestUtils.truncate(UserToken.class, template);
		SchemaTestUtils.truncate(BookReference.class, template);
		SchemaTestUtils.truncate(TypeWithCompositeKey.class, template);
		SchemaTestUtils.truncate(WithNullableEmbeddedType.class, template);
		SchemaTestUtils.truncate(WithEmptyEmbeddedType.class, template);
		SchemaTestUtils.truncate(WithPrefixedNullableEmbeddedType.class, template);
		SchemaTestUtils.truncate(OuterWithNullableEmbeddedType.class, template);
		SchemaTestUtils.truncate(OuterWithPrefixedNullableEmbeddedType.class, template);
		SchemaTestUtils.truncate(WithMappedUdtList.class, template);
	}

	/**
	 * Post-process the {@link CassandraTemplate} before running the tests.
	 *
	 * @param template
	 */
	void prepareTemplate(CassandraTemplate template) {

	}

	@Test // DATACASS-343
	void shouldSelectByQueryWithAllowFiltering() {

		assumeTrue(cassandraVersion.isGreaterThanOrEqualTo(CASSANDRA_3));

		UserToken userToken = new UserToken();
		userToken.setUserId(Uuids.endOf(System.currentTimeMillis()));
		userToken.setToken(Uuids.startOf(System.currentTimeMillis()));
		userToken.setUserComment("cook");

		template.insert(userToken);

		Query query = Query.query(where("userId").is(userToken.getUserId())).and(where("userComment").is("cook"))
				.withAllowFiltering();
		UserToken loaded = template.selectOne(query, UserToken.class);

		assertThat(loaded).isNotNull();
		assertThat(loaded.getUserComment()).isEqualTo("cook");
	}

	@Test // DATACASS-343
	void shouldSelectByQueryWithSorting() {

		UserToken token1 = new UserToken();
		token1.setUserId(Uuids.endOf(System.currentTimeMillis()));
		token1.setToken(Uuids.startOf(System.currentTimeMillis()));
		token1.setUserComment("foo");

		UserToken token2 = new UserToken();
		token2.setUserId(token1.getUserId());
		token2.setToken(Uuids.endOf(System.currentTimeMillis() + 100));
		token2.setUserComment("bar");

		template.insert(token1);
		template.insert(token2);

		Query query = Query.query(where("userId").is(token1.getUserId())).sort(Sort.by("token"));
		List<UserToken> loaded = template.select(query, UserToken.class);

		assertThat(loaded).containsSequence(token1, token2);
	}

	@Test // DATACASS-638
	void shouldSelectProjection() {

		User user = new User("heisenberg", "Walter", "White");

		template.insert(user);

		Query query = Query.query(where("id").is(user.getId())).columns(Columns.empty().include("id").include("firstname"));
		List<User> loaded = template.select(query, User.class);

		assertThat(loaded).hasSize(1);

		User loadedUser = loaded.get(0);

		assertThat(loadedUser.getFirstname()).isNotNull();
		assertThat(loadedUser.getLastname()).isNull();
	}

	@Test // DATACASS-638
	void shouldSelectProjectionWithCompositeKey() {

		CompositeKey key = new CompositeKey("Walter", "White");
		TypeWithCompositeKey user = new TypeWithCompositeKey(key, "comment");

		template.insert(user);

		Query query = Query.empty().columns(Columns.empty().include("firstname").include("comment"));
		List<TypeWithCompositeKey> loaded = template.select(query, TypeWithCompositeKey.class);

		assertThat(loaded).hasSize(1);

		TypeWithCompositeKey loadedEntity = loaded.get(0);

		assertThat(loadedEntity.getKey()).isNotNull();
		assertThat(loadedEntity.getKey().firstname()).isNotNull();
		assertThat(loadedEntity.getKey().lastname()).isNull();
		assertThat(loadedEntity.getComment()).isNotNull();
	}

	@Test // DATACASS-828
	void shouldSelectClosedProjectionWithCompositeKey() {

		CompositeKey key = new CompositeKey("Walter", "White");
		TypeWithCompositeKey user = new TypeWithCompositeKey(key, "comment");

		template.insert(user);

		WithCompositeKeyProjection loaded = template.query(TypeWithCompositeKey.class).as(WithCompositeKeyProjection.class)
				.firstValue();
		assertThat(loaded).isNotNull();

		assertThat(loaded.getKey()).isEqualTo(key);
	}

	@Test // DATACASS-343
	void shouldSelectOneByQuery() {

		UserToken token1 = new UserToken();
		token1.setUserId(Uuids.endOf(System.currentTimeMillis()));
		token1.setToken(Uuids.startOf(System.currentTimeMillis()));
		token1.setUserComment("foo");

		template.insert(token1);

		Query query = Query.query(where("userId").is(token1.getUserId()));
		UserToken loaded = template.selectOne(query, UserToken.class);

		assertThat(loaded).isEqualTo(token1);
	}

	@Test // DATACASS-292, DATACASS-573
	void insertShouldInsertEntity() {

		User user = new User("heisenberg", "Walter", "White");

		assertThat(template.selectOneById(user.getId(), User.class)).isNull();

		User result = template.insert(user);

		assertThat(result).isSameAs(user);
		assertThat(template.selectOneById(user.getId(), User.class)).isEqualTo(user);
	}

	@Test // DATACASS-250, DATACASS-573
	void insertShouldCreateEntityWithLwt() {

		InsertOptions lwtOptions = InsertOptions.builder().withIfNotExists().build();

		User user = new User("heisenberg", "Walter", "White");

		EntityWriteResult<User> result = template.insert(user, lwtOptions);

		assertThat(result.getEntity()).isSameAs(user);
		assertThat(template.selectOneById(user.getId(), User.class)).isNotNull();
	}

	@Test // DATACASS-250, DATACASS-573
	void insertShouldNotUpdateEntityWithLwt() {

		InsertOptions lwtOptions = InsertOptions.builder().withIfNotExists().build();

		User user = new User("heisenberg", "Walter", "White");

		template.insert(user, lwtOptions);

		user.setFirstname("Walter Hartwell");

		EntityWriteResult<User> lwt = template.insert(user, lwtOptions);

		assertThat(lwt.wasApplied()).isFalse();
		assertThat(template.selectOneById(user.getId(), User.class).getFirstname()).isEqualTo("Walter");
	}

	@Test // DATACASS-292
	void shouldInsertAndCountEntities() {

		User user = new User("heisenberg", "Walter", "White");

		template.insert(user);

		long count = template.count(User.class);
		assertThat(count).isEqualTo(1L);
	}

	@Test // GH-212
	void insertJsonShouldInsertRow() {

		assumeTrue(cassandraVersion.isGreaterThanOrEqualTo(CASSANDRA_3_10));

		WriteResult writeResult = template
				.insertJson("{\"id\": \"heisenberg\", \"firstname\": \"Walter\", \"lastname\": \"White\"}", User.class);

		assertThat(writeResult.wasApplied()).isTrue();
		assertThat(template.selectOneById("heisenberg", User.class))
				.isEqualTo(new User("heisenberg", "Walter", "White"));
	}

	@Test // GH-212
	void insertJsonShouldApplyInsertOptions() {

		assumeTrue(cassandraVersion.isGreaterThanOrEqualTo(CASSANDRA_3_10));

		template.insert(new User("heisenberg", "Walter", "White"));

		WriteResult writeResult = template.insertJson("{\"id\": \"heisenberg\", \"firstname\": \"Gus\"}", User.class,
				InsertOptions.builder().withIfNotExists().build());

		assertThat(writeResult.wasApplied()).isFalse();
		assertThat(template.selectOneById("heisenberg", User.class))
				.isEqualTo(new User("heisenberg", "Walter", "White"));
	}

	@Test // GH-212
	void insertJsonShouldLeaveOmittedColumnsUnset() {

		assumeTrue(cassandraVersion.isGreaterThanOrEqualTo(CASSANDRA_3_10));

		template.insert(new User("heisenberg", "Walter", "White"));

		template.insertJson("{\"id\": \"heisenberg\", \"firstname\": \"Walt\"}", User.class);

		User loaded = template.selectOneById("heisenberg", User.class);

		assertThat(loaded).isNotNull();
		assertThat(loaded.getFirstname()).isEqualTo("Walt");
		assertThat(loaded.getLastname()).isEqualTo("White");
	}

	@Test // GH-212
	void insertJsonShouldInsertNullsForOmittedColumns() {

		assumeTrue(cassandraVersion.isGreaterThanOrEqualTo(CASSANDRA_3_10));

		template.insert(new User("heisenberg", "Walter", "White"));

		template.insertJson("{\"id\": \"heisenberg\", \"firstname\": \"Walt\"}", User.class,
				InsertOptions.builder().withInsertNulls().build());

		User loaded = template.selectOneById("heisenberg", User.class);

		assertThat(loaded).isNotNull();
		assertThat(loaded.getFirstname()).isEqualTo("Walt");
		assertThat(loaded.getLastname()).isNull();
	}

	@Test // GH-212
	void selectJsonShouldReturnJsonRepresentation() {

		assumeTrue(cassandraVersion.isGreaterThanOrEqualTo(CASSANDRA_3_10));

		template.insert(new User("heisenberg", "Walter", "White"));
		template.insert(new User("mike", "Mike", "Ehrmantraut"));

		List<String> result = template.selectJson(Query.empty(), User.class);

		assertThat(result).hasSize(2);
		assertThat(result).allSatisfy(json -> assertThat(json).contains("\"id\""));

		String single = template.selectOneJson(Query.query(where("id").is("heisenberg")), User.class);

		assertThat(single).contains("heisenberg").contains("Walter").contains("White");
	}

	@Test // GH-212
	void selectJsonShouldConsiderColumns() {

		assumeTrue(cassandraVersion.isGreaterThanOrEqualTo(CASSANDRA_3_10));

		template.insert(new User("heisenberg", "Walter", "White"));

		String json = template.selectOneJson(
				Query.query(where("id").is("heisenberg")).columns(Columns.from("firstname")), User.class);

		assertThat(json).contains("Walter").doesNotContain("White");
	}

	@Test // DATACASS-155
	void shouldNotOverrideLaterMutation() {

		Instant now = LocalDateTime.now().atZone(ZoneId.systemDefault()).toInstant();
		User user = new User("heisenberg", "Walter", "White");
		template.insert(user);

		// more recent mutation
		user.setFirstname("John");
		template.update(user);

		// previous mutation
		user.setFirstname("Greg");
		template.update(user, UpdateOptions.builder().timestamp(now.minusSeconds(120)).build());

		User loaded = template.selectOneById(user.getId(), User.class);
		assertThat(loaded.getFirstname()).isEqualTo("John");
	}

	@Test // DATACASS-512
	void shouldInsertEntityAndCountByQuery() {

		User user = new User("heisenberg", "Walter", "White");

		template.insert(user);

		assertThat(template.count(Query.query(where("id").is("heisenberg")), User.class)).isOne();
		assertThat(template.count(Query.query(where("id").is("foo")), User.class)).isZero();
	}

	@Test // DATACASS-512
	void shouldInsertEntityAndExistsByQuery() {

		User user = new User("heisenberg", "Walter", "White");

		template.insert(user);

		assertThat(template.exists(Query.query(where("id").is("heisenberg")), User.class)).isTrue();
		assertThat(template.exists(Query.query(where("id").is("foo")), User.class)).isFalse();
	}

	@Test // DATACASS-292, DATACASS-573
	void updateShouldUpdateEntity() {

		User user = new User("heisenberg", "Walter", "White");
		template.insert(user);

		user.setFirstname("Walter Hartwell");

		User result = template.update(user);

		assertThat(result).isSameAs(user);
		assertThat(template.selectOneById(user.getId(), User.class)).isEqualTo(user);
	}

	@Test // DATACASS-292
	void updateShouldNotCreateEntityWithLwt() {

		UpdateOptions lwtOptions = UpdateOptions.builder().withIfExists().build();

		User user = new User("heisenberg", "Walter", "White");

		WriteResult lwt = template.update(user, lwtOptions);

		assertThat(lwt.wasApplied()).isFalse();
		assertThat(template.selectOneById(user.getId(), User.class)).isNull();
	}

	@Test // DATACASS-292
	void updateShouldUpdateEntityWithLwt() {

		InsertOptions seedOptions = InsertOptions.builder().withIfNotExists().build();
		UpdateOptions lwtOptions = UpdateOptions.builder().withIfExists().build();

		User user = new User("heisenberg", "Walter", "White");

		assertThat(template.insert(user, seedOptions).wasApplied()).isTrue();

		user.setFirstname("Walter Hartwell");

		WriteResult lwt = template.update(user, lwtOptions);

		assertThat(lwt.wasApplied()).isTrue();
	}

	@Test // DATACASS-343
	void updateShouldUpdateEntityByQuery() {

		User person = new User("heisenberg", "Walter", "White");
		template.insert(person);

		Query query = Query.query(where("id").is("heisenberg"));
		boolean result = template.update(query, Update.empty().set("firstname", "Walter Hartwell"), User.class);
		assertThat(result).isTrue();

		assertThat(template.selectOneById(person.getId(), User.class).getFirstname()).isEqualTo("Walter Hartwell");
	}

	@Test // DATACASS-343
	void deleteByQueryShouldRemoveEntity() {

		User user = new User("heisenberg", "Walter", "White");
		template.insert(user);

		Query query = Query.query(where("id").is("heisenberg"));
		assertThat(template.delete(query, User.class)).isTrue();

		assertThat(template.selectOneById(user.getId(), User.class)).isNull();
	}

	@Test // DATACASS-343
	void deleteColumnsByQueryShouldRemoveColumn() {

		User user = new User("heisenberg", "Walter", "White");
		template.insert(user);

		Query query = Query.query(where("id").is("heisenberg")).columns(Columns.from("lastname"));

		assertThat(template.delete(query, User.class)).isTrue();

		User loaded = template.selectOneById(user.getId(), User.class);
		assertThat(loaded.getFirstname()).isEqualTo("Walter");
		assertThat(loaded.getLastname()).isNull();
	}

	@Test // DATACASS-292
	void deleteShouldRemoveEntity() {

		User user = new User("heisenberg", "Walter", "White");
		template.insert(user);

		template.delete(user);

		assertThat(template.selectOneById(user.getId(), User.class)).isNull();
	}

	@Test // DATACASS-292
	void deleteByIdShouldRemoveEntity() {

		User user = new User("heisenberg", "Walter", "White");
		template.insert(user);

		Boolean deleted = template.deleteById(user.getId(), User.class);
		assertThat(deleted).isTrue();

		assertThat(template.selectOneById(user.getId(), User.class)).isNull();
	}

	@Test // DATACASS-606
	void deleteShouldRemoveEntityWithLwt() {

		InsertOptions seedOptions = InsertOptions.builder().withIfNotExists().build();
		DeleteOptions lwtOptions = DeleteOptions.builder().withIfExists().build();

		User user = new User("heisenberg", "Walter", "White");
		assertThat(template.insert(user, seedOptions).wasApplied()).isTrue();

		assertThat(template.delete(user, lwtOptions).wasApplied()).isTrue();
	}

	@Test // DATACASS-606
	void deleteByQueryShouldRemoveEntityWithLwt() {

		InsertOptions seedOptions = InsertOptions.builder().withIfNotExists().build();
		DeleteOptions lwtOptions = DeleteOptions.builder().withIfExists().build();

		User user = new User("heisenberg", "Walter", "White");
		assertThat(template.insert(user, seedOptions).wasApplied()).isTrue();

		Query query = Query.query(where("id").is("heisenberg")).queryOptions(lwtOptions);
		assertThat(template.delete(query, User.class)).isTrue();
	}

	@Test // DATACASS-767
	void selectByQueryWithKeyspaceShouldRetrieveData() {

		assumeThat(cassandraVersion.isGreaterThanOrEqualTo(CASSANDRA_4)).isTrue();

		QueryOptions queryOptions = QueryOptions.builder().keyspace(CqlIdentifier.fromCql(keyspace)).build();

		User user = new User("heisenberg", "Walter", "White");
		template.insert(user);

		Query query = Query.query(where("id").is("heisenberg")).queryOptions(queryOptions);
		assertThat(template.select(query, User.class)).isNotEmpty();
	}

	@Test // DATACASS-767
	void selectByQueryWithNonExistingKeyspaceShouldThrowThatKeyspaceDoesNotExists() {

		assumeThat(cassandraVersion.isGreaterThanOrEqualTo(CASSANDRA_4)).isTrue();

		QueryOptions queryOptions = QueryOptions.builder().keyspace(CqlIdentifier.fromCql("non_existing")).build();

		User user = new User("heisenberg", "Walter", "White");
		template.insert(user);
		template.setUsePreparedStatements(false);

		Query query = Query.query(where("id").is("heisenberg")).queryOptions(queryOptions);
		assertThatThrownBy(() -> assertThat(template.select(query, User.class)).isEmpty())
				.isInstanceOf(CassandraInvalidQueryException.class)
				.hasMessageContaining("Keyspace 'non_existing' does not exist");

		template.setUsePreparedStatements(true);
	}

	@Test // DATACASS-182
	void stream() {

		User user = new User("heisenberg", "Walter", "White");
		template.insert(user);

		Stream<User> stream = template.stream("SELECT * FROM users", User.class);

		assertThat(stream.collect(Collectors.toList())).hasSize(1).contains(user);
	}

	@Test // DATACASS-343
	void streamByQuery() {

		User person = new User("heisenberg", "Walter", "White");
		template.insert(person);

		Query query = Query.query(where("id").is("heisenberg"));

		Stream<User> stream = template.stream(query, User.class);

		assertThat(stream.collect(Collectors.toList())).hasSize(1).contains(person);
	}

	@Test // DATACASS-182
	void updateShouldRemoveFields() {

		User user = new User("heisenberg", "Walter", "White");

		template.insert(user);

		user.setFirstname(null);
		template.update(user);

		User loaded = template.selectOneById(user.getId(), User.class);

		assertThat(loaded.getFirstname()).isNull();
		assertThat(loaded.getId()).isEqualTo("heisenberg");
	}

	@Test // DATACASS-182, DATACASS-420
	void insertShouldNotRemoveFields() {

		User user = new User("heisenberg", "Walter", "White");

		template.insert(user);

		user.setFirstname(null);
		template.insert(user);

		User loaded = template.selectOneById(user.getId(), User.class);

		assertThat(loaded.getFirstname()).isEqualTo("Walter");
		assertThat(loaded.getId()).isEqualTo("heisenberg");
	}

	@Test // DATACASS-182
	void insertAndUpdateToEmptyCollection() {

		BookReference bookReference = new BookReference();

		bookReference.setIsbn("isbn");
		bookReference.setBookmarks(Arrays.asList(1, 2, 3, 4));

		template.insert(bookReference);

		bookReference.setBookmarks(Collections.emptyList());

		template.update(bookReference);

		BookReference loaded = template.selectOneById(bookReference.getIsbn(), BookReference.class);

		assertThat(loaded.getTitle()).isNull();
		assertThat(loaded.getBookmarks()).isNull();
	}

	@Test // #1007
	void updateCollection() {

		BookReference bookReference = new BookReference();

		bookReference.setIsbn("isbn");
		bookReference.setBookmarks(Arrays.asList(1, 2, 3, 4));
		bookReference.setReferences(new LinkedHashSet<>(Arrays.asList("one", "two", "three")));

		Map<String, String> credits = new LinkedHashMap<>();
		credits.put("hello", "world");
		credits.put("other", "world");
		credits.put("external", "place");

		bookReference.setCredits(credits);

		template.insert(bookReference);

		Query query = Query.query(where("isbn").is(bookReference.getIsbn()));

		Update update = Update.empty().removeFrom("bookmarks").values(3, 4).removeFrom("references").values("one", "three")
				.removeFrom("credits").values("hello", "other", "place");

		template.update(query, update, BookReference.class);

		BookReference loaded = template.selectOneById(bookReference.getIsbn(), BookReference.class);

		assertThat(loaded.getBookmarks()).containsOnly(1, 2);
		assertThat(loaded.getReferences()).containsOnly("two");
		assertThat(loaded.getCredits()).containsOnlyKeys("external");
	}

	@Test // DATACASS-206
	void shouldUseSpecifiedColumnNamesForSingleEntityModifyingOperations() {

		UserToken userToken = new UserToken();
		userToken.setToken(Uuids.startOf(System.currentTimeMillis()));
		userToken.setUserId(Uuids.endOf(System.currentTimeMillis()));

		template.insert(userToken);

		userToken.setUserComment("comment");
		template.update(userToken);

		UserToken loaded = template.selectOneById(
				BasicMapId.id("userId", userToken.getUserId()).with("token", userToken.getToken()), UserToken.class);

		assertThat(loaded.getUserComment()).isEqualTo("comment");

		template.delete(userToken);

		UserToken loadAfterDelete = template.selectOneById(
				BasicMapId.id("userId", userToken.getUserId()).with("token", userToken.getToken()), UserToken.class);

		assertThat(loadAfterDelete).isNull();
	}

	@Test // GH-1636
	void shouldReturnUnpagedSlice() {

		Query query = Query.empty().pageRequest(Pageable.unpaged());

		Slice<User> slice = template.slice(query, User.class);
		assertThat(slice).isEmpty();
	}

	@Test // DATACASS-56
	void shouldPageRequests() {

		Set<String> expectedIds = new LinkedHashSet<>();

		for (int count = 0; count < 100; count++) {
			User user = new User("heisenberg" + count, "Walter", "White");
			expectedIds.add(user.getId());
			template.insert(user);
		}

		Set<String> ids = new HashSet<>();

		Query query = Query.empty().pageRequest(CassandraPageRequest.first(10));

		Slice<User> slice = template.slice(query, User.class);

		int iterations = 0;

		do {

			iterations++;

			assertThat(slice).hasSize(10);

			slice.stream().map(User::getId).forEach(ids::add);

			if (slice.hasNext()) {
				slice = template.slice(query.pageRequest(slice.nextPageable()), User.class);
			} else {
				break;
			}
		} while (!slice.getContent().isEmpty());

		assertThat(ids).containsAll(expectedIds);
		assertThat(iterations).isEqualTo(10);
	}

	@Test // DATACASS-167
	void shouldSaveAndReadPrefixedEmbeddedCorrectly() {

		WithPrefixedNullableEmbeddedType entity = new WithPrefixedNullableEmbeddedType();
		entity.id = "id-1";
		entity.nested = new EmbeddedWithSimpleTypes();
		entity.nested.firstname = "fn";
		entity.nested.age = 30;

		template.insert(WithPrefixedNullableEmbeddedType.class).one(entity);

		WithPrefixedNullableEmbeddedType target = template.selectOne(Query.query(where("id").is("id-1")),
				WithPrefixedNullableEmbeddedType.class);
		assertThat(target).isEqualTo(entity);
	}

	@Test // DATACASS-167
	void shouldSaveAndReadEmbeddedCorrectly() {

		WithNullableEmbeddedType entity = new WithNullableEmbeddedType();
		entity.id = "id-1";
		entity.nested = new EmbeddedWithSimpleTypes();
		entity.nested.firstname = "fn";
		entity.nested.age = 30;

		template.insert(WithNullableEmbeddedType.class).one(entity);

		WithNullableEmbeddedType target = template.selectOne(Query.query(where("id").is("id-1")),
				WithNullableEmbeddedType.class);
		assertThat(target).isEqualTo(entity);
	}

	@Test // DATACASS-167
	void shouldSaveAndReadNullableEmbeddedCorrectly() {

		WithNullableEmbeddedType entity = new WithNullableEmbeddedType();
		entity.id = "id-1";
		entity.nested = null;

		template.insert(WithNullableEmbeddedType.class).one(entity);

		WithNullableEmbeddedType target = template.selectOne(Query.query(where("id").is("id-1")),
				WithNullableEmbeddedType.class);
		assertThat(target.id).isEqualTo("id-1");
		assertThat(target.nested).isNull();
	}

	@Test // DATACASS-167
	void shouldSaveAndReadEmptyEmbeddedCorrectly() {

		WithEmptyEmbeddedType entity = new WithEmptyEmbeddedType();
		entity.id = "id-1";
		entity.nested = null;

		template.insert(WithEmptyEmbeddedType.class).one(entity);

		WithEmptyEmbeddedType target = template.selectOne(Query.query(where("id").is("id-1")), WithEmptyEmbeddedType.class);
		assertThat(target.id).isEqualTo("id-1");
		assertThat(target.nested).isNotNull();
	}

	@Test // DATACASS-167
	void shouldSaveAndReadEmbeddedUDTCorrectly() {

		OuterWithNullableEmbeddedType entity = new OuterWithNullableEmbeddedType();
		entity.id = "id-1";
		entity.udtValue = new UDTWithNullableEmbeddedType();
		entity.udtValue.value = "value-1";
		entity.udtValue.nested = new EmbeddedWithSimpleTypes();
		entity.udtValue.nested.firstname = "fn";
		entity.udtValue.nested.age = 30;

		template.insert(OuterWithNullableEmbeddedType.class).one(entity);

		OuterWithNullableEmbeddedType target = template.selectOne(Query.query(where("id").is("id-1")),
				OuterWithNullableEmbeddedType.class);
		assertThat(target).isEqualTo(entity);
	}

	@Test // DATACASS-167
	void shouldSaveAndReadPrefixedUdtEmbeddedCorrectly() {

		OuterWithPrefixedNullableEmbeddedType entity = new OuterWithPrefixedNullableEmbeddedType();
		entity.id = "id-1";
		entity.udtValue = new UDTWithPrefixedNullableEmbeddedType();
		entity.udtValue.value = "value-1";
		entity.udtValue.nested = new EmbeddedWithSimpleTypes();
		entity.udtValue.nested.firstname = "fn";
		entity.udtValue.nested.age = 30;

		template.insert(OuterWithPrefixedNullableEmbeddedType.class).one(entity);

		OuterWithPrefixedNullableEmbeddedType target = template.selectOne(Query.query(where("id").is("id-1")),
				OuterWithPrefixedNullableEmbeddedType.class);
		assertThat(target).isEqualTo(entity);
	}

	@Test // DATACASS-167
	void shouldSaveAndReadNullEmbeddedUDTCorrectly() {

		OuterWithNullableEmbeddedType entity = new OuterWithNullableEmbeddedType();
		entity.id = "id-1";
		entity.udtValue = new UDTWithNullableEmbeddedType();
		entity.udtValue.value = "value-1";
		entity.udtValue.nested = null;

		template.insert(OuterWithNullableEmbeddedType.class).one(entity);

		OuterWithNullableEmbeddedType target = template.selectOne(Query.query(where("id").is("id-1")),
				OuterWithNullableEmbeddedType.class);
		assertThat(target).isEqualTo(entity);
	}

	@Test // DATACASS-829, GH-1525
	void shouldPartiallyUpdateListOfMappedUdt() {

		WithMappedUdtList entity = new WithMappedUdtList();
		entity.id = "id-1";
		entity.mappedUdts = Arrays.asList(new MappedUdt("one"), new MappedUdt("two"), new MappedUdt("three"));

		template.insert(entity);

		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",
				"replacement2");
	}

	@UserDefinedType
	record MappedUdt(String name) {
	}

	@Table
	static class WithMappedUdtList {

		@Id String id;

		List<MappedUdt> mappedUdts;

		public WithMappedUdtList() {}

		public String getId() {
			return this.id;
		}

		public List<MappedUdt> getMappedUdts() {
			return this.mappedUdts;
		}

		public void setId(String id) {
			this.id = id;
		}

		public void setMappedUdts(List<MappedUdt> mappedUdts) {
			this.mappedUdts = mappedUdts;
		}
	}

	static class TimeClass {

		@Id LocalTime id;
		LocalTime bar;

		public TimeClass() {}

		public LocalTime getId() {
			return this.id;
		}

		public LocalTime getBar() {
			return this.bar;
		}

		public void setId(LocalTime id) {
			this.id = id;
		}

		public void setBar(LocalTime bar) {
			this.bar = bar;
		}
	}

	static class TypeWithCompositeKey {
		@PrimaryKey CompositeKey key;
		String comment;

		public TypeWithCompositeKey(CompositeKey key, String comment) {
			this.key = key;
			this.comment = comment;
		}

		public CompositeKey getKey() {
			return this.key;
		}

		public String getComment() {
			return this.comment;
		}

		public void setKey(CompositeKey key) {
			this.key = key;
		}

		public void setComment(String comment) {
			this.comment = comment;
		}
	}

	interface WithCompositeKeyProjection {

		CompositeKey getKey();
	}

	@PrimaryKeyClass
	record CompositeKey(

			@PrimaryKeyColumn(type = PrimaryKeyType.PARTITIONED) String firstname,
			@PrimaryKeyColumn(type = PrimaryKeyType.PARTITIONED) String lastname) {

	}

	static class WithNullableEmbeddedType {

		@Id String id;

		@Embedded.Nullable EmbeddedWithSimpleTypes nested;

		public WithNullableEmbeddedType() {}

		public String getId() {
			return this.id;
		}

		public EmbeddedWithSimpleTypes getNested() {
			return this.nested;
		}

		public void setId(String id) {
			this.id = id;
		}

		public void setNested(EmbeddedWithSimpleTypes nested) {
			this.nested = nested;
		}

		@Override
		public boolean equals(Object o) {
			if (this == o)
				return true;
			if (o == null || getClass() != o.getClass())
				return false;

			WithNullableEmbeddedType that = (WithNullableEmbeddedType) o;

			if (!ObjectUtils.nullSafeEquals(id, that.id)) {
				return false;
			}
			return ObjectUtils.nullSafeEquals(nested, that.nested);
		}

		@Override
		public int hashCode() {
			int result = ObjectUtils.nullSafeHashCode(id);
			result = 31 * result + ObjectUtils.nullSafeHashCode(nested);
			return result;
		}
	}

	static class WithPrefixedNullableEmbeddedType {

		@Id String id;

		@Embedded.Nullable(prefix = "prefix") EmbeddedWithSimpleTypes nested;

		public WithPrefixedNullableEmbeddedType() {}

		public String getId() {
			return this.id;
		}

		public EmbeddedWithSimpleTypes getNested() {
			return this.nested;
		}

		public void setId(String id) {
			this.id = id;
		}

		public void setNested(EmbeddedWithSimpleTypes nested) {
			this.nested = nested;
		}

		@Override
		public boolean equals(Object o) {
			if (this == o)
				return true;
			if (o == null || getClass() != o.getClass())
				return false;

			WithPrefixedNullableEmbeddedType that = (WithPrefixedNullableEmbeddedType) o;

			if (!ObjectUtils.nullSafeEquals(id, that.id)) {
				return false;
			}
			return ObjectUtils.nullSafeEquals(nested, that.nested);
		}

		@Override
		public int hashCode() {
			int result = ObjectUtils.nullSafeHashCode(id);
			result = 31 * result + ObjectUtils.nullSafeHashCode(nested);
			return result;
		}
	}

	static class WithEmptyEmbeddedType {

		@Id String id;

		@Embedded.Empty EmbeddedWithSimpleTypes nested;

		public WithEmptyEmbeddedType() {}

		public String getId() {
			return this.id;
		}

		public EmbeddedWithSimpleTypes getNested() {
			return this.nested;
		}

		public void setId(String id) {
			this.id = id;
		}

		public void setNested(EmbeddedWithSimpleTypes nested) {
			this.nested = nested;
		}
	}

	static class EmbeddedWithSimpleTypes {

		String firstname;
		Integer age;

		public EmbeddedWithSimpleTypes() {}

		public String getFirstname() {
			return this.firstname;
		}

		public Integer getAge() {
			return this.age;
		}

		public void setFirstname(String firstname) {
			this.firstname = firstname;
		}

		public void setAge(Integer age) {
			this.age = age;
		}

		@Override
		public boolean equals(Object o) {
			if (this == o)
				return true;
			if (o == null || getClass() != o.getClass())
				return false;

			EmbeddedWithSimpleTypes that = (EmbeddedWithSimpleTypes) o;

			if (!ObjectUtils.nullSafeEquals(firstname, that.firstname)) {
				return false;
			}
			return ObjectUtils.nullSafeEquals(age, that.age);
		}

		@Override
		public int hashCode() {
			int result = ObjectUtils.nullSafeHashCode(firstname);
			result = 31 * result + ObjectUtils.nullSafeHashCode(age);
			return result;
		}
	}

	static class OuterWithNullableEmbeddedType {

		@Id String id;

		UDTWithNullableEmbeddedType udtValue;

		public OuterWithNullableEmbeddedType() {}

		public String getId() {
			return this.id;
		}

		public UDTWithNullableEmbeddedType getUdtValue() {
			return this.udtValue;
		}

		public void setId(String id) {
			this.id = id;
		}

		public void setUdtValue(UDTWithNullableEmbeddedType udtValue) {
			this.udtValue = udtValue;
		}

		@Override
		public boolean equals(Object o) {
			if (this == o)
				return true;
			if (o == null || getClass() != o.getClass())
				return false;

			OuterWithNullableEmbeddedType that = (OuterWithNullableEmbeddedType) o;

			if (!ObjectUtils.nullSafeEquals(id, that.id)) {
				return false;
			}
			return ObjectUtils.nullSafeEquals(udtValue, that.udtValue);
		}

		@Override
		public int hashCode() {
			int result = ObjectUtils.nullSafeHashCode(id);
			result = 31 * result + ObjectUtils.nullSafeHashCode(udtValue);
			return result;
		}
	}

	static class OuterWithPrefixedNullableEmbeddedType {

		@Id String id;

		UDTWithPrefixedNullableEmbeddedType udtValue;

		@Override
		public boolean equals(Object o) {
			if (this == o)
				return true;
			if (o == null || getClass() != o.getClass())
				return false;

			OuterWithPrefixedNullableEmbeddedType that = (OuterWithPrefixedNullableEmbeddedType) o;

			if (!ObjectUtils.nullSafeEquals(id, that.id)) {
				return false;
			}
			return ObjectUtils.nullSafeEquals(udtValue, that.udtValue);
		}

		@Override
		public int hashCode() {
			int result = ObjectUtils.nullSafeHashCode(id);
			result = 31 * result + ObjectUtils.nullSafeHashCode(udtValue);
			return result;
		}
	}

	@UserDefinedType
	static class UDTWithNullableEmbeddedType {

		String value;

		@Embedded.Nullable EmbeddedWithSimpleTypes nested;

		public UDTWithNullableEmbeddedType() {}

		public String getValue() {
			return this.value;
		}

		public EmbeddedWithSimpleTypes getNested() {
			return this.nested;
		}

		public void setValue(String value) {
			this.value = value;
		}

		public void setNested(EmbeddedWithSimpleTypes nested) {
			this.nested = nested;
		}

		@Override
		public boolean equals(Object o) {
			if (this == o)
				return true;
			if (o == null || getClass() != o.getClass())
				return false;

			UDTWithNullableEmbeddedType that = (UDTWithNullableEmbeddedType) o;

			if (!ObjectUtils.nullSafeEquals(value, that.value)) {
				return false;
			}
			return ObjectUtils.nullSafeEquals(nested, that.nested);
		}

		@Override
		public int hashCode() {
			int result = ObjectUtils.nullSafeHashCode(value);
			result = 31 * result + ObjectUtils.nullSafeHashCode(nested);
			return result;
		}
	}

	@UserDefinedType
	static class UDTWithPrefixedNullableEmbeddedType {

		String value;

		@Embedded.Nullable(prefix = "prefix") EmbeddedWithSimpleTypes nested;

		public UDTWithPrefixedNullableEmbeddedType() {}

		public String getValue() {
			return this.value;
		}

		public EmbeddedWithSimpleTypes getNested() {
			return this.nested;
		}

		public void setValue(String value) {
			this.value = value;
		}

		public void setNested(EmbeddedWithSimpleTypes nested) {
			this.nested = nested;
		}

		@Override
		public boolean equals(Object o) {
			if (this == o)
				return true;
			if (o == null || getClass() != o.getClass())
				return false;

			UDTWithPrefixedNullableEmbeddedType that = (UDTWithPrefixedNullableEmbeddedType) o;

			if (!ObjectUtils.nullSafeEquals(value, that.value)) {
				return false;
			}
			return ObjectUtils.nullSafeEquals(nested, that.nested);
		}

		@Override
		public int hashCode() {
			int result = ObjectUtils.nullSafeHashCode(value);
			result = 31 * result + ObjectUtils.nullSafeHashCode(nested);
			return result;
		}
	}

}

---

8.16 src/main/antora/modules/ROOT/pages/cassandra/template.adoc

+44 — new reference-docs section “Working with JSON” under Methods for Inserting and Updating rows.

[[cassandra.template]]
= Persisting Entities

The `CassandraTemplate` class (and its reactive variant `ReactiveCassandraTemplate`), located in the `org.springframework.data.cassandra` package, is the central class in Spring's Cassandra support and provides a rich feature set to interact with the database.
The template offers convenience operations to create, update, delete, and query Cassandra, and provides a mapping between your domain objects and rows in Cassandra tables.

NOTE: Once configured, a template instance is thread-safe and can be reused across multiple instances.

The mapping between rows in Cassandra and application domain classes is done by delegating to an implementation of the `CassandraConverter` interface.
Spring provides a default implementation, `MappingCassandraConverter`, but you can also write your own custom converter.
See the section on
xref:object-mapping.adoc[Cassandra conversion] for more detailed information.

The `CassandraTemplate` class implements the `CassandraOperations` interface and its reactive variant `ReactiveCassandraTemplate` implements `ReactiveCassandraOperations`.
In as much as possible, the methods on `[Reactive]CassandraOperations` are named after methods available in Cassandra to make the API familiar to developers who are already familiar with Cassandra.

For example, you can find methods such as `select`, `insert`, `delete`, and `update`.
The design goal was to make it as easy as possible to transition between the use of the base Cassandra driver and `[Reactive]CassandraOperations`.
A major difference between the two APIs is that `CassandraOperations` can be passed domain objects instead of CQL and query objects.

NOTE: The preferred way to reference operations on a `[Reactive]CassandraTemplate` instance is through the
`[Reactive]CassandraOperations` interface.

The default converter implementation used by `[Reactive]CassandraTemplate` is `MappingCassandraConverter`.
While `MappingCassandraConverter` can use additional metadata to specify the mapping of objects to rows, it can also convert objects that contain no additional metadata by using some conventions for the mapping of fields and table names.
These conventions, as well as the use of mapping annotations, are explained in the xref:object-mapping.adoc["`Mapping`" chapter].

Another central feature of `[Reactive]CassandraTemplate` is exception translation of exceptions thrown in the Cassandra Java driver into Spring's portable Data Access Exception hierarchy.
See the section on
xref:cassandra/cql-template.adoc#exception-translation[exception translation] for more information.

NOTE: The Template API has different execution model flavors.
The basic `CassandraTemplate` uses a blocking (imperative-synchronous) execution model.
You can use `AsyncCassandraTemplate` for asynchronous execution and synchronization with `CompletableFuture` instances or `ReactiveCassandraTemplate` for reactive execution.

[[cassandra.template.instantiating]]
== Instantiating `CassandraTemplate`

`CassandraTemplate` should always be configured as a Spring bean, although we show an example earlier where you can instantiate it directly.
However, because we are assuming the context of making a Spring module, we assume the presence of the Spring container.

There are two ways to get a `CassandraTemplate`, depending on how you load you Spring `ApplicationContext`:

* xref:cassandra/template.adoc#cassandra-template-autowiring[Autowiring]
* xref:cassandra/template.adoc#cassandra-template-bean-lookup-applicationcontext[Bean Lookup with `ApplicationContext`]

[float]
[[cassandra-template-autowiring]]
=== Autowiring

You can autowire a `[Reactive]CassandraOperations` into your project, as the following example shows:

[tabs]
======
Imperative::
+
[source,java,indent=0,subs="verbatim,quotes",role="primary"]
----
@Autowired
private CassandraOperations cassandraOperations;
----

Reactive::
+
[source,java,indent=0,subs="verbatim,quotes",role="secondary"]
----
@Autowired
private ReactiveCassandraOperations reactiveCassandraOperations;
----
======

As with all Spring autowiring, this assumes there is only one bean of type `[Reactive]CassandraOperations` in the `ApplicationContext`.
If you have multiple `[Reactive]CassandraTemplate` beans (which is the case if you work with multiple keyspaces in the same project), then you can use the `@Qualifier` annotation to designate the bean you want to autowire.

[tabs]
======
Imperative::
+
[source,java,indent=0,subs="verbatim,quotes",role="primary"]
----
@Autowired
@Qualifier("keyspaceOneTemplateBeanId")
private CassandraOperations cassandraOperations;
----

Reactive::
+
[source,java,indent=0,subs="verbatim,quotes",role="secondary"]
----
@Autowired
@Qualifier("keyspaceOneTemplateBeanId")
private ReactiveCassandraOperations reactiveCassandraOperations;
----
======

[float]
[[cassandra-template-bean-lookup-applicationcontext]]
=== Bean Lookup with `ApplicationContext`

You can also look up the `[Reactive]CassandraTemplate` bean from the `ApplicationContext`, as shown in the following example:

[tabs]
======
Imperative::
+
[source,java,indent=0,subs="verbatim,quotes",role="primary"]
----
CassandraOperations cassandraOperations = applicationContext.getBean("cassandraTemplate", CassandraOperations.class);
----

Reactive::
+
[source,java,indent=0,subs="verbatim,quotes",role="secondary"]
----
ReactiveCassandraOperations cassandraOperations = applicationContext.getBean("ReactiveCassandraOperations", ReactiveCassandraOperations.class);
----
======

[[cassandra.template.query]]
== Querying Rows

You can express your queries by using the `Query` and `Criteria` classes, which have method names that reflect the native Cassandra predicate operator names, such as `lt`, `lte`, `is`, and others.

The `Query` and `Criteria` classes follow a fluent API style so that you can easily chain together multiple method criteria and queries while having easy-to-understand code.
Static imports are used in Java when creating `Query`
and `Criteria` instances to improve readability.

[[cassandra.template.query.table]]
=== Querying Rows in a Table

In earlier sections, we saw how to retrieve a single object by using the `selectOneById` method on `[Reactive]CassandraTemplate`.
Doing so returns a single domain object.
We can also query for a collection of rows to be returned as a list of domain objects.
Assuming we have a number of `Person` objects with name and age values stored as rows in a table and that each person has an account balance, we can now run a query by using the following code:

.Querying for rows using `[Reactive]CassandraTemplate`
[tabs]
======
Imperative::
+
[source,java,indent=0,subs="verbatim,quotes",role="primary"]
----
import static org.springframework.data.cassandra.core.query.Criteria.where;
import static org.springframework.data.cassandra.core.query.Query.query;

…

List<Person> result = cassandraTemplate.select(query(where("age").is(50))
  .and(where("balance").gt(1000.00d)).withAllowFiltering(), Person.class);
----

Reactive::
+
[source,java,indent=0,subs="verbatim,quotes",role="secondary"]
----
import static org.springframework.data.cassandra.core.query.Criteria.where;
import static org.springframework.data.cassandra.core.query.Query.query;

…

Flux<Person> result = reactiveCassandraTemplate.select(query(where("age").is(50))
  .and(where("balance").gt(1000.00d)).withAllowFiltering(), Person.class);
----
======

The `select`, `selectOne`, and `stream` methods take a `Query` object as a parameter.
This object defines the criteria and options used to perform the query.
The criteria is specified by using a `Criteria` object that has a static factory method named `where` that instantiates a new `Criteria` object.
We recommend using a static import for `org.springframework.data.cassandra.core.query.Criteria.where` and `Query.query`, to make the query more readable.

This query should return a list of `Person` objects that meet the specified criteria.
The `Criteria` class has the following methods that correspond to the operators provided in Apache Cassandra:

[[cassandra.template.query.criteria]]
==== Methods for the Criteria class

* `CriteriaDefinition` *gt* `(Object value)`: Creates a criterion by using the `>` operator.
* `CriteriaDefinition` *gte* `(Object value)`: Creates a criterion by using the `>=` operator.
* `CriteriaDefinition` *in* `(Object... values)`: Creates a criterion by using the `IN` operator for a varargs argument.
* `CriteriaDefinition` *in* `(Collection<?> collection)`: Creates a criterion by using the `IN` operator using a collection.
* `CriteriaDefinition` *is* `(Object value)`: Creates a criterion by using field matching (`column = value`).
* `CriteriaDefinition` *lt* `(Object value)`: Creates a criterion by using the `<` operator.
* `CriteriaDefinition` *lte* `(Object value)`: Creates a criterion by using the `<=` operator.
* `CriteriaDefinition` *like* `(Object value)`: Creates a criterion by using the `LIKE` operator.
* `CriteriaDefinition` *contains* `(Object value)`: Creates a criterion by using the `CONTAINS` operator.
* `CriteriaDefinition` *containsKey* `(Object key)`: Creates a criterion by using the `CONTAINS KEY` operator.

`Criteria` is immutable once created.

[[cassandra.template.query.query-class]]
=== Methods for the Query class

The `Query` class has some additional methods that you can use to provide options for the query:

* `Query` *by* `(CriteriaDefinition... criteria)`: Used to create a `Query` object.
* `Query` *and* `(CriteriaDefinition criteria)`: Used to add additional criteria to the query.
* `Query` *columns* `(Columns columns)`: Used to define columns to be included in the query results.
* `Query` *limit* `(Limit limit)`: Used to limit the size of the returned results to the provided limit (used `SELECT` limiting).
* `Query` *limit* `(long limit)`: Used to limit the size of the returned results to the provided limit (used `SELECT` limiting).
* `Query` *pageRequest* `(Pageable pageRequest)`: Used to associate `Sort`, `PagingState`, and `fetchSize` with the query (used for paging).
* `Query` *pagingState* `(CassandraScrollPosition pagingState)`: Used to associate a `CassandraScrollPosition` with the query (used for paging).
* `Query` *pagingState* `(ByteBuffer pagingState)`: Used to associate a raw `ByteBuffer` with the query (used for paging).
* `Query` *queryOptions* `(QueryOptions queryOptions)`: Used to associate `QueryOptions` with the query.
* `Query` *sort* `(Sort sort)`: Used to provide a sort definition for the results.
* `Query` *withAllowFiltering* `()`: Used to render `ALLOW FILTERING` queries.

`Query` is immutable once created.
Invoking methods creates new immutable (intermediate) `Query` objects.

[[cassandra.template.query.rows]]
=== Methods for Querying for Rows

The `Query` class has the following methods that return rows:

* `List<T>` *select* `(Query query, Class<T> entityClass)`: Query for a list of objects of type `T` from the table.
* `T` *selectOne* `(Query query, Class<T> entityClass)`: Query for a single object of type `T` from the table.
* `Slice<T>` *slice* `(Query query, Class<T> entityClass)`: Starts or continues paging by querying for a `Slice` of objects of type `T` from the table.
* `Stream<T>` *stream* `(Query query, Class<T> entityClass)`: Query for a stream of objects of type `T` from the table.
* `List<T>` *select* `(String cql, Class<T> entityClass)`: Ad-hoc query for a list of objects of type `T` from the table by providing a CQL statement.
* `T` *selectOne* `(String cql, Class<T> entityClass)`: Ad-hoc query for a single object of type `T` from the table by providing a CQL statement.
* `Stream<T>` *stream* `(String cql, Class<T> entityClass)`: Ad-hoc query for a stream of objects of type `T` from the table by providing a CQL statement.

The query methods must specify the target type `T` that is returned.

[[cassandra.template.query.columns]]
=== Column Projection

When not specifying `Query.colums(…)`, all columns are selected (`SELECT * FROM …`) to enable access to all available columns from entities through `@Value(…)` and when using open projections.

If you provide more information to a query (e.g. when using closed DTO or Interface projections through <<cassandra.template.query.fluent-template-api>>) then the column selection will be limited.

You can configure the default `ProjectionFunction` on `StatementFactory` for each `CassandraTemplate` instance to influence the default column selection:

====
[source,java]
----
CassandraTemplate template = …;
template.getStatementFactory().setProjectionFunction(ProjectionFunction.mappedProperties());
----
====

Explicitly specifying columns through `ProjectionFunctions.mappedProperties()` will limit the selection to mapped properties of the entity type but its explicit nature will validate queries against the entity mapping when running the query and any undesired schema changes will become visible through exceptions.
Note that any unmapped properties won't be available to `@Value(…)`.

Using explicit column selection through `Query.columns(…)` will bypass `Columns` computation from projection functions.

[[cassandra.template.query.fluent-template-api]]
=== Fluent Template API

The `[Reactive]CassandraOperations` interface is one of the central components when it comes to more low-level interaction with Apache Cassandra.
It offers a wide range of methods.
You can find multiple overloads for every method.
Most of them cover optional (nullable) parts of the API.

`FluentCassandraOperations` and its reactive variant `ReactiveFluentCassandraOperations` provide a more narrow interface for common methods of `[Reactive]CassandraOperations`
providing a more readable, fluent API.
The entry points (`query(…)`, `insert(…)`, `update(…)`, and `delete(…)`) follow a natural naming scheme based on the operation to execute.
Moving on from the entry point, the API is designed to offer only context-dependent methods that guide the developer towards a terminating method that invokes the actual `[Reactive]CassandraOperations`.
The following example shows the fluent API:

[tabs]
======
Imperative::
+
[source,java,indent=0,subs="verbatim,quotes",role="primary"]
----
List<SWCharacter> all = ops.query(SWCharacter.class)
  .inTable("star_wars")                        <1>
  .all();
----
<1> Skip this step if `SWCharacter` defines the table name with `@Table` or if using the class name as the table name is not a problem

Reactive::
+
[source,java,indent=0,subs="verbatim,quotes",role="secondary"]
----
Flux<SWCharacter> all = ops.query(SWCharacter.class)
  .inTable("star_wars")                        <1>
  .all();
----
<1> Skip this step if `SWCharacter` defines the table name with `@Table` or if using the class name as the table name is not a problem
======

If a table in Cassandra holds entities of different types, such as a `Jedi` within a Table of `SWCharacters`, you can use different types to map the query result.
You can use `as(Class<?> targetType)` to map results to a different target type, while `query(Class<?> entityType)` still applies to the query and table name.
The following example uses the `query` and `as` methods:

[tabs]
======
Imperative::
+
[source,java,indent=0,subs="verbatim,quotes",role="primary"]
----
List<Jedi> all = ops.query(SWCharacter.class)    <1>
  .as(Jedi.class)                                <2>
  .matching(query(where("jedi").is(true)))
  .all();
----
<1> The query fields are mapped against the `SWCharacter` type.
<2> Resulting rows are mapped into `Jedi`.

Reactive::
+
[source,java,indent=0,subs="verbatim,quotes",role="secondary"]
----
Flux<Jedi> all = ops.query(SWCharacter.class)    <1>
  .as(Jedi.class)                                <2>
  .matching(query(where("jedi").is(true)))
  .all();
----
<1> The query fields are mapped against the `SWCharacter` type.
<2> Resulting rows are mapped into `Jedi`.
======

TIP: You can directly apply xref:repositories/projections.adoc[] to resulting documents by providing only the `interface` type through `as(Class<?>)`.

The terminating methods (`first()`, `one()`, `all()`, and `stream()`) handle switching between retrieving a single entity and retrieving multiple entities as `List` or `Stream` and similar operations.

WARNING: The new fluent template API methods (that is, `query(…)`, `insert(…)`, `update(…)`, and `delete(…)`) use effectively thread-safe supporting objects to compose the CQL statement.
However, it comes at the added cost of additional young-gen JVM heap overhead, since the design is based on final fields for the various CQL statement components and construction on mutation.
You should be careful when possibly inserting or deleting a large number of objects (such as inside a loop, for instance).

=== Vector Search Queries

Projections are the foundation for querying data returned in a different form than the entity.
While Cassandra's primary use-case follows a key-value model – storing what you retrieve – Vector search is different.
Running Vector search queries typically results in an aggregation or report-like result set.
A typical query would return some form of content (such as a `text` column) along with its score (or distance) to the actual vector.

Consider the following domain model:

.Vector Search model
====
[source,java]
----
include::example$VectorSearchExample.java[tags=class]
----
====

`Comments` is the domain type defining a vector column and the `comment` column.

Running a Vector Search requires usage of `ANN` sorting and would typically define a similarity function to determine its distance from the given vector.

.Using Vector Search
====
[source,java,indent=0,subs="verbatim,quotes",role="primary"]
----
Columns columns = Columns.from("comment")                                                <1>
                     .select("vector", builder -> builder.similarity(vector)
                                                         .cosine().as("similarity"));    <2>

Query query = Query.select(columns)
                   .limit(3)
                   .sort(VectorSort.ann("vector", vector));                              <3>

template.query(Comments.class)
        .as(CommentSearch.class)                                                         <4>
        .matching(query)
        .all();
----

<1> Select the columns to query.
<2> Include a function call to `similarity_cosine(vector, […])`. `Columns.select(…)` uses a selector builder customizer to configure the actual selection.
Make sure to declare an alias to map the result onto `CommentSearch.similarity` as result mapping uses column names.
<3> Use the `VectorSort.ann(…)` to define the sort order in comparison to the given vector.
<4> Define the target type to map the result to.
The `CommentSearch` type is result projection type defining columns that map the result.
====

[[cassandra-template.save-update-remove]]
== Saving, Updating, and Removing Rows

`[Reactive]CassandraTemplate` provides a simple way for you to save, update, and delete your domain objects and map those objects to tables managed in Cassandra.

[[cassandra.template.type-mapping]]
=== Type Mapping

Spring Data for Apache Cassandra relies on the DataStax Java driver's `CodecRegistry` to ensure type support.
As types are added or changed, the Spring Data for Apache Cassandra module continues to function without requiring changes.
See https://docs.datastax.com/en/cql/3.3/cql/cql_reference/cql_data_types_c.html[CQL data types]
and "`xref:object-mapping.adoc#mapping-conversion[Data Mapping and Type Conversion]`" for the current type mapping matrix.

[[cassandra.template.insert-update]]
=== Methods for Inserting and Updating rows

`[Reactive]CassandraTemplate` has several convenient methods for saving and inserting your objects.
To have more fine-grained control over the conversion process, you can register Spring `Converter` instances with the `MappingCassandraConverter`
(for example, `Converter<Row, Person>`).

NOTE: The difference between insert and update operations is that `INSERT` operations do not insert `null` values.

The simple case of using the `INSERT` operation is to save a POJO.
In this case, the table name is determined by the simple class name (not the fully qualified class name).
The table to store the object can be overridden by using mapping metadata.

When inserting or updating, the `id` property must be set.
Apache Cassandra has no means to generate an ID.

The following example uses the save operation and retrieves its contents:

.Inserting and retrieving objects by using the `[Reactive]CassandraTemplate`
[tabs]
======
Imperative::
+
[source,java,indent=0,subs="verbatim,quotes",role="primary"]
----
import static org.springframework.data.cassandra.core.query.Criteria.where;
import static org.springframework.data.cassandra.core.query.Query.query;
…

Person bob = new Person("Bob", 33);
cassandraTemplate.insert(bob);

Person queriedBob = cassandraTemplate.selectOneById(query(where("age").is(33)), Person.class);
----

Reactive::
+
[source,java,indent=0,subs="verbatim,quotes",role="secondary"]
----
import static org.springframework.data.cassandra.core.query.Criteria.where;
import static org.springframework.data.cassandra.core.query.Query.query;
…

Person bob = new Person("Bob", 33);
cassandraTemplate.insert(bob);

Mono<Person> queriedBob = reactiveCassandraTemplate.selectOneById(query(where("age").is(33)), Person.class);
----
======

You can use the following operations to insert and save:

* `void` *insert* `(Object objectToSave)`: Inserts the object in an Apache Cassandra table.
* `WriteResult` *insert* `(Object objectToSave, InsertOptions options)`: Inserts the object in an Apache Cassandra table and applies `InsertOptions`.

You can use the following update operations:

* `void` *update* `(Object objectToSave)`: Updates the object in an Apache Cassandra table.
* `WriteResult` *update* `(Object objectToSave, UpdateOptions options)`: Updates the object in an Apache Cassandra table and applies `UpdateOptions`.

You can also use the old fashioned way and write your own CQL statements, as the following example shows:

[tabs]
======
Imperative::
+
[source,java,indent=0,subs="verbatim,quotes",role="primary"]
----
String cql = "INSERT INTO person (age, name) VALUES (39, 'Bob')";

cassandraTemplate().getCqlOperations().execute(cql);
----

Reactive::
+
[source,java,indent=0,subs="verbatim,quotes",role="secondary"]
----
String cql = "INSERT INTO person (age, name) VALUES (39, 'Bob')";

Mono<Boolean> applied = reactiveCassandraTemplate.getReactiveCqlOperations().execute(cql);
----
======

You can also configure additional options such as TTL, consistency level, and lightweight transactions when using `InsertOptions` and `UpdateOptions`.

[[cassandra.template.insert-update.json]]
==== Working with JSON

Apache Cassandra supports `INSERT JSON` and `SELECT JSON` statements to write and read rows using their JSON representation.
`[Reactive]CassandraTemplate` exposes this functionality through `insertJson`, `selectJson`, and `selectOneJson` so that you can persist and obtain rows without materializing entity objects, as the following example shows:

[tabs]
======
Imperative::
+
[source,java,indent=0,subs="verbatim,quotes",role="primary"]
----
import static org.springframework.data.cassandra.core.query.Criteria.where;
import static org.springframework.data.cassandra.core.query.Query.query;
…

cassandraTemplate.insertJson("{\"id\": \"bob\", \"age\": 33}", Person.class);

String json = cassandraTemplate.selectOneJson(query(where("id").is("bob")), Person.class);
----

Reactive::
+
[source,java,indent=0,subs="verbatim,quotes",role="secondary"]
----
import static org.springframework.data.cassandra.core.query.Criteria.where;
import static org.springframework.data.cassandra.core.query.Query.query;
…

Mono<WriteResult> result = reactiveCassandraTemplate.insertJson("{\"id\": \"bob\", \"age\": 33}", Person.class);

Mono<String> json = reactiveCassandraTemplate.selectOneJson(query(where("id").is("bob")), Person.class);
----
======

The entity class is used to resolve the table name while the mapping between JSON keys and columns is performed by Cassandra itself, following the CQL `INSERT JSON` and `SELECT JSON` semantics.
Consequently, JSON keys must correspond to column names, column names containing uppercase characters must be quoted (for example, `"\"myColumn\": 42"`), and values must be encoded according to the CQL JSON encoding of the column type.
Since no entity object is involved, lifecycle events and entity callbacks are not invoked for JSON operations.

Columns omitted from the JSON payload are left unset (`DEFAULT UNSET`).
Configuring `InsertOptions.builder().withInsertNulls()` inserts omitted columns as `null` (`DEFAULT NULL`), aligned with the null handling of entity-based `insert` operations.

NOTE: `INSERT JSON` with `DEFAULT UNSET` requires Apache Cassandra 3.10 or later.

[[cassandra.template.insert-update.table]]
==== Which Table Are My Rows Inserted into?

You can manage the table name that is used for operating on the tables in two ways.
The default table name is the simple class name changed to start with a lower-case letter.
So, an instance of the `com.example.Person` class would be stored in the `person` table.
The second way is to specify a table name in the `@Table` annotation.

[[cassandra.template.batch]]
==== Inserting, Updating, and Deleting Individual Objects in a Batch

The Cassandra protocol supports inserting a collection of rows in one operation by using a batch.

The following methods in the `[Reactive]CassandraTemplate` interface support this functionality:

* `batchOps`: Creates a new `[Reactive]CassandraBatchOperations` to populate the batch.

`[Reactive]CassandraBatchOperations`

* `insert`: Takes a single object, an array (var-args), or an `Iterable` of objects to insert.
* `update`: Takes a single object, an array (var-args), or an `Iterable` of objects to update.
* `delete`: Takes a single object, an array (var-args), or an `Iterable` of objects to delete.
* `withTimestamp`: Applies a TTL to the batch.
* `execute`: Executes the batch.

[[cassandra.template.update]]
=== Updating Rows in a Table

For updates, you can select to update a number of rows.

The following example shows updating a single account object by adding a one-time $50.00 bonus to the balance with the `+` assignment:

.Updating rows using `[Reactive]CasandraTemplate`
[tabs]
======
Imperative::
+
[source,java,indent=0,subs="verbatim,quotes",role="primary"]
----
import static org.springframework.data.cassandra.core.query.Criteria.where;
import org.springframework.data.cassandra.core.query.Query;
import org.springframework.data.cassandra.core.query.Update;

…

boolean applied = cassandraTemplate.update(Query.query(where("id").is("foo")),
  Update.create().increment("balance", 50.00), Account.class);
----

Reactive::
+
[source,java,indent=0,subs="verbatim,quotes",role="secondary"]
----
import static org.springframework.data.cassandra.core.query.Criteria.where;
import org.springframework.data.cassandra.core.query.Query;
import org.springframework.data.cassandra.core.query.Update;

…

Mono<Boolean> wasApplied = reactiveCassandraTemplate.update(Query.query(where("id").is("foo")),
  Update.create().increment("balance", 50.00), Account.class);
----
======

In addition to the `Query` discussed earlier, we provide the update definition by using an `Update` object.
The `Update` class has methods that match the update assignments available for Apache Cassandra.

Most methods return the `Update` object to provide a fluent API for code styling purposes.

[[cassandra.template.update.methods]]
==== Methods for Executing Updates for Rows

The update method can update rows, as follows:

* `boolean` *update* `(Query query, Update update, Class<?> entityClass)`: Updates a selection of objects in the Apache Cassandra table.

[[cassandra.template.update.update]]
==== Methods for the Update class

The `Update` class can be used with a little 'syntax sugar', as its methods are meant to be chained together.
Also, you can kick-start the creation of a new `Update` instance with the static method `public static Update update(String key, Object value)` and by using static imports.

The `Update` class has the following methods:

* `AddToBuilder` *addTo* `(String columnName)` `AddToBuilder` entry-point:
** Update `prepend(Object value)`: Prepends a collection value to the existing collection by using the `+` update assignment.
    ** Update `prependAll(Object... values)`: Prepends all collection values to the existing collection by using the `+` update assignment.
** Update `append(Object value)`: Appends a collection value to the existing collection by using the `+` update assignment.
    ** Update `append(Object... values)`: Appends all collection values to the existing collection by using the `+` update assignment.
** Update `entry(Object key, Object value)`: Adds a map entry by using the `+` update assignment.
    ** Update `addAll(Map<? extends Object, ? extends Object> map)`: Adds all map entries to the map by using the `+` update assignment.
* `Update` *remove* `(String columnName, Object value)`: Removes the value from the collection by using the `-` update assignment.
* `Update` *clear* `(String columnName)`: Clears the collection.
* `Update` *increment* `(String columnName, Number delta)`: Updates by using the `+` update assignment.
* `Update` *decrement* `(String columnName, Number delta)`: Updates by using the `-` update assignment.
* `Update` *set* `(String columnName, Object value)`: Updates by using the `=` update assignment.
* `SetBuilder` *set* `(String columnName)` `SetBuilder` entry-point:
** Update `atIndex(int index).to(Object value)`: Sets a collection at the given index to a value using the `=` update assignment.
** Update `atKey(String object).to(Object value)`: Sets a map entry at the given key to a value the `=` update assignment.

The following listing shows a few update examples:

====
[source]
----
// UPDATE … SET key = 'Spring Data';
Update.update("key", "Spring Data")

// UPDATE … SET key[5] = 'Spring Data';
Update.empty().set("key").atIndex(5).to("Spring Data");

// UPDATE … SET key = key + ['Spring', 'DATA'];
Update.empty().addTo("key").appendAll("Spring", "Data");
----
====

Note that `Update` is immutable once created.
Invoking methods creates new immutable (intermediate) `Update` objects.

[[cassandra.template.delete]]
=== Methods for Removing Rows

You can use the following overloaded methods to remove an object from the database:

* `boolean` *delete* `(Query query, Class<?> entityClass)`: Deletes the objects selected by `Query`.
* `T` *delete* `(T entity)`: Deletes the given object.
* `T` *delete* `(T entity, QueryOptions queryOptions)`: Deletes the given object applying `QueryOptions`.
* `boolean` *deleteById* `(Object id, Class<?> entityClass)`: Deletes the object using the given Id.

[[cassandra.template.optimistic-locking]]
=== Optimistic Locking

The `@Version` annotation provides syntax similar to that of JPA in the context of Cassandra and makes sure updates are only applied to rows with a matching version.
Optimistic Locking leverages Cassandra's lightweight transactions to conditionally insert, update and delete rows.
Therefore, `INSERT` statements are executed with the `IF NOT EXISTS` condition.
For updates and deletes, the actual value of the version property is added to the `UPDATE` condition in such a way that the modification does not have any effect if another operation altered the row in the meantime.
In that case, an `OptimisticLockingFailureException` is thrown.
The following example shows these features:

====
[source,java]
----
@Table
class Person {

  @Id String id;
  String firstname;
  String lastname;
  @Version Long version;
}

Person daenerys = template.insert(new Person("Daenerys"));                            <1>

Person tmp = template.findOne(query(where("id").is(daenerys.getId())), Person.class); <2>

daenerys.setLastname("Targaryen");
template.save(daenerys);                                                              <3>

template.save(tmp); // throws OptimisticLockingFailureException                       <4>
----

<1> Initially insert document. `version` is set to `0`.
<2> Load the just inserted document. `version` is still `0`.
<3> Update the document with `version = 0`.
Set the `lastname` and bump `version` to `1`.
<4> Try to update the previously loaded document that still has `version = 0`.
The operation fails with an `OptimisticLockingFailureException`, as the current `version` is `1`.
====

NOTE: Optimistic Locking is only supported with single-entity operations and not for batch operations.

---

End of report. Generated for review of GH-212; this file is not part of the change set — do not commit it.