Spring Data Cassandra

https://github.com/spring-projects/spring-data-cassandra
Admin
Spring Data Cassandra provides Spring Data support for Apache Cassandra, enabling easy integration...
Tokens:581,918
Snippets:3,152
Trust Score:9.7
License:Apache-2.0
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Configuration for repositories

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/repositories/repositories.adoc

Provides imperative Java, XML, and reactive Java configuration examples for enabling Cassandra repositories.

```java
@Configuration
@EnableCassandraRepositories
class ApplicationConfig extends AbstractCassandraConfiguration {

  @Override
  protected String getKeyspaceName() {
    return "keyspace";
  }

  public String[] getEntityBasePackages() {
    return new String[] { "com.oreilly.springdata.cassandra" };
  }
}
```

```xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xmlns:cassandra="http://www.springframework.org/schema/data/cassandra"
  xsi:schemaLocation="
    http://www.springframework.org/schema/data/cassandra
    https://www.springframework.org/schema/data/cassandra/spring-cassandra.xsd
    http://www.springframework.org/schema/beans
    https://www.springframework.org/schema/beans/spring-beans.xsd">

    <cassandra:session port="9042" keyspace-name="keyspaceName"/>

    <cassandra:mapping
            entity-base-packages="com.acme.*.entities">
    </cassandra:mapping>

    <cassandra:converter/>

    <cassandra:template/>

    <cassandra:repositories base-package="com.acme.*.entities"/>
</beans>
```

```java
@Configuration
@EnableReactiveCassandraRepositories
class ApplicationConfig extends AbstractReactiveCassandraConfiguration {

  @Override
  protected String getKeyspaceName() {
    return "keyspace";
  }

  public String[] getEntityBasePackages() {
    return new String[] { "com.oreilly.springdata.cassandra" };
  }
}
```

--------------------------------

### Configure SessionFactory for CqlTemplate and ReactiveCqlTemplate

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/cql-template.adoc

Shows how to configure a default SessionFactory for both imperative and reactive templates. The imperative example uses DefaultSessionFactory, while the reactive example uses DefaultBridgedReactiveSession.

```java
CqlSession session = … // get a Cassandra Session

CqlTemplate template = new CqlTemplate();

template.setSessionFactory(new DefaultSessionFactory(session));
```

```java

CqlSession session = … // get a Cassandra Session

ReactiveCqlTemplate template = new ReactiveCqlTemplate(new DefaultBridgedReactiveSession(session));
```

--------------------------------

### CqlTemplate and ReactiveCqlTemplate INSERT operation

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/cql-template.adoc

Imperative and reactive examples of performing an INSERT operation with CqlTemplate. The source uses include directives, so the actual code is not visible on this page.

```java
include::example$CqlTemplateExamples.java[tags=insert]
```

```java
include::example$ReactiveCqlTemplateExamples.java[tags=insert]
```

--------------------------------

### Execute raw CQL INSERT with CassandraTemplate

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/template.adoc

Shows how to execute a raw CQL INSERT statement using the imperative CassandraTemplate's CqlOperations. The example inserts a row into the person table.

```java
String cql = "INSERT INTO person (age, name) VALUES (39, 'Bob')";

cassandraTemplate().getCqlOperations().execute(cql);
```

--------------------------------

### Build Spring Data with Maven wrapper

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/README.adoc

Use this command to build Spring Data for Apache Cassandra from source. Requires JDK 17. The Maven wrapper is used, so no separate Maven installation is needed.

```bash
 $ ./mvnw clean install
```

--------------------------------

### Create QueryOptions with builder

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/migration-guide/migration-guide-1.5-to-2.0.adoc

Shows how to create an immutable QueryOptions instance using the builder pattern. The builder allows setting consistency level, retry policy, read timeout, fetch size, and tracing. This example is from the migration guide for Spring Data Cassandra 2.0.

```java
QueryOptions queryOptions = QueryOptions.builder()
		.consistencyLevel(ConsistencyLevel.ANY)
		.retryPolicy(FallthroughRetryPolicy.INSTANCE)
		.readTimeout(Duration.ofSeconds(10))
		.fetchSize(10)
		.tracing(true)
		.build();
```

--------------------------------

### CqlTemplate and ReactiveCqlTemplate UPDATE operation

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/cql-template.adoc

Imperative and reactive examples of performing an UPDATE operation with CqlTemplate. The source uses include directives, so the actual code is not visible on this page.

```java
include::example$CqlTemplateExamples.java[tags=update]
```

```java
include::example$ReactiveCqlTemplateExamples.java[tags=update]
```

--------------------------------

### Spring Data Cassandra Repository and Configuration Example

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/README.adoc

Shows a PersonRepository extending CrudRepository with custom query methods, a MyService using the repository, and an ApplicationConfig with @EnableCassandraRepositories. Requires a Cassandra instance at localhost and a keyspace named 'springdata'.

```java
public interface PersonRepository extends CrudRepository<Person, Long> {

  List<Person> findByLastname(String lastname);

  List<Person> findByFirstnameLike(String firstname);
}

@Service
public class MyService {

  private final PersonRepository repository;

  public MyService(PersonRepository repository) {
    this.repository = repository;
  }

  public void doWork() {

    repository.deleteAll();

    Person person = new Person();
    person.setFirstname("Matthew");
    person.setLastname("Adams");
    repository.save(person);

    List<Person> lastNameResults = repository.findByLastname("Adams");
    List<Person> firstNameResults = repository.findByFirstnameLike("M*");
 }
}

@Configuration
@EnableCassandraRepositories
class ApplicationConfig extends AbstractCassandraConfiguration {

  @Override
  public String getContactPoints() {
    return "localhost";
  }

  @Override
  protected String getKeyspaceName() {
    return "springdata";
  }
}
```

--------------------------------

### CqlTemplate and ReactiveCqlTemplate query with RowMapper (findAllActors)

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/cql-template.adoc

Imperative and reactive examples of querying with a RowMapper, shown as tabs. The source uses include directives, so the actual code is not visible on this page.

```java
include::example$CqlTemplateExamples.java[tags=findAllActors]
```

```java
include::example$ReactiveCqlTemplateExamples.java[tags=findAllActors]
```

--------------------------------

### CqlTemplate execute for DDL (other)

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/cql-template.adoc

Example of using execute() for arbitrary CQL, often used for DDL statements. The source uses an include directive, so the actual code is not visible on this page.

```java
include::example$CqlTemplateExamples.java[tags=other]
```

--------------------------------

### UserRepository interface for AOT metadata example

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/repositories/aot.adoc

Example repository interface used to illustrate the JSON metadata file that AOT processing generates. The method `findUserNoArgumentsBy()` is a derived query method that will be processed by AOT repositories.

```java
interface UserRepository extends CrudRepository<User, Integer> {

  List<User> findUserNoArgumentsBy();                                                  <1>

```

--------------------------------

### CqlTemplate and ReactiveCqlTemplate DELETE operation

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/cql-template.adoc

Imperative and reactive examples of performing a DELETE operation with CqlTemplate. The source uses include directives, so the actual code is not visible on this page.

```java
include::example$CqlTemplateExamples.java[tags=delete]
```

```java
include::example$ReactiveCqlTemplateExamples.java[tags=delete]
```

--------------------------------

### Update class fluent examples

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/template.adoc

Shows fluent usage of the `Update` class: setting a key, setting a collection element by index, and appending to a collection. The `Update` class is immutable; each method returns a new immutable intermediate object.

```java
// 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");
```

--------------------------------

### Query DSL for selectBySimpleIds replacement

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/migration-guide/migration-guide-1.5-to-2.0.adoc

Use the query DSL to select by a single column ID, replacing the removed selectBySimpleIds method. This example shows a query with a criteria on the 'id' column.

```java
cassandraTemplate.select(Query.query(Criteria.where("id").in(…)), Person.class)
```

--------------------------------

### Sorting Person entities with Sort.by and Order

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/repositories/repositories.adoc

Sorts Person entities by lastname in ascending order using a repository method that accepts a Sort parameter. The example shows the expected usage inside a test method.

```java
@Test
public void sortsElementsCorrectly() {
    Flux<Person> people = repository.findAll(Sort.by(new Order(ASC, 
```

```java
lastname")));
}
```

--------------------------------

### Using SearchResults<T> in a Repository Search Method

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/partials/vector-search-repository-include.adoc

Defines a Spring Data Cassandra repository method that returns SearchResults<Comment> using a vector search with a scoring function and limit. The method signature and a usage example show how to call it with Vector.of, ScoringFunction.cosine, and Limit.of.

```java
interface CommentRepository extends Repository<Comment, String> {

  SearchResults<Comment> searchByEmbeddingNearAndCountry(Vector vector, ScoringFunction function, String country, Limit limit);

}

SearchResults<Comment> results = repository.searchByEmbeddingNearAndCountry(Vector.of(…), ScoringFunction.cosine(), "…", Limit.of(10));
```

--------------------------------

### Example domain object with @Table annotation

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/object-mapping.adoc

Annotate domain objects with @Table so the classpath scanner can extract metadata for schema actions. Only annotated entities are used for schema operations; unannotated entities are ignored.

```java
package com.mycompany.domain;

@Table
public class Person {

  @Id
  private String id;

  @CassandraType(type = Name.INT)
  private int age;
}
```

--------------------------------

### Optimistic Locking with @Version in Spring Data Cassandra

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/template.adoc

Defines a Person entity with a @Version property and demonstrates insert, find, update, and a failing update that throws OptimisticLockingFailureException. The version starts at 0, increments on update, and a stale update fails.

```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>
```

--------------------------------

### Build reference documentation with Antora

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/README.adoc

Builds the documentation and the project without running tests. The generated documentation is available from spring-data-cassandra-distribution/antora/site/index.html.

```bash
 $ ./mvnw clean install -Pantora
```

--------------------------------

### Before query method

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/repositories/query-methods.adoc

Maps the Before keyword to a less-than comparison on a date column.

```java
findByBirthdateBefore(Date date)
```

--------------------------------

### Like, StartingWith, EndingWith keyword query method

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/repositories/query-methods.adoc

Finds entities where the property matches a LIKE expression.

```java
findByFirstnameLike(String name)
```

--------------------------------

### Basic access to Person entities

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/repositories/repositories.adoc

Shows imperative and reactive test classes that autowire the repository and call findAll() to verify data is present.

```java
@ExtendWith(SpringExtension.class)
class PersonRepositoryTests {

    @Autowired PersonRepository repository;

    @Test
    void readsPersonTableCorrectly() {

      List<Person> persons = repository.findAll();
      assertThat(persons.isEmpty()).isFalse();
    }
}
```

```java
public class PersonRepositoryTests {

    @Autowired ReactivePersonRepository repository;

    @Test
    void readsPersonTableCorrectly() {

      Flux<Person> persons = repository.findAll();
      assertThat(persons.collectList().block().isEmpty()).isFalse();
    }
}
```

--------------------------------

### No keyword query method

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/repositories/query-methods.adoc

Finds entities by exact property match.

```java
findByFirstname(String name)
```

--------------------------------

### CassandraCustomConversions configuration with adapter

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/property-converters.adoc

Configure CassandraCustomConversions with programmatic value conversions using CassandraConverterConfigurationAdapter. This allows registering converters and defining the PropertyValueConverterFactory.

```java
CassandraCustomConversions conversions = CassandraCustomConversions.create(adapter -> {
  adapter.registerConverter(…);
  adapter.configurePropertyConversions(registrar -> {
    registrar.registerConverter(Person.class, "name", String.class)
        .writing((from, ctx) -> …)
        .reading((from, ctx) -> …);
  });
});
```

--------------------------------

### PersonRepository with query methods (imperative and reactive)

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/repositories/query-methods.adoc

Imperative and reactive repository interfaces showing supported query method signatures for Cassandra. Imperative methods demonstrate derived queries, pagination, scrolling, query options, sorting, limiting, and @AllowFiltering. Reactive methods use Flux/Mono return types and support Publisher parameters.

```java
interface PersonRepository extends CrudRepository<Person, String> {

    List<Person> findByLastname(String lastname);                           <1>

    Slice<Person> findByFirstname(String firstname, Pageable pageRequest);  <2>

    Window<Person> findByFirstname(String firstname, CassandraScrollPosition pos, Limit limit);  <3>

    List<Person> findByFirstname(String firstname, QueryOptions opts);      <4>

    List<Person> findByFirstname(String firstname, Sort sort);              <5>

    List<Person> findByFirstname(String firstname, Limit limit);            <6>

    Person findByShippingAddress(Address address);                          <7>

    Person findFirstByShippingAddress(Address address);                     <8>

    Stream<Person> findAllBy();                                             <9>

    @AllowFiltering
    List<Person> findAllByAge(int age);                                     <10>
}
```

```java
interface ReactivePersonRepository extends ReactiveSortingRepository<Person, Long> {

  Flux<Person> findByFirstname(String firstname);                                <1>

  Flux<Person> findByFirstname(Publisher<String> firstname);                     <2>

  Mono<Person> findByFirstnameAndLastname(String firstname, String lastname);    <3>

  Mono<Person> findFirstByFirstname(String firstname);                           <4>

  @AllowFiltering
  Flux<Person> findByAge(int age);                                               <5>
}
```

--------------------------------

### Activating auditing through configuration (XML)

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/auditing.adoc

XML configuration that enables Cassandra auditing using the cassandra:auditing element, specifying a custom mapping context and an auditor-aware implementation.

```xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xmlns:cassandra="http://www.springframework.org/schema/data/cassandra"
  xsi:schemaLocation="
    http://www.springframework.org/schema/data/cassandra
    https://www.springframework.org/schema/data/cassandra/spring-cassandra.xsd
    http://www.springframework.org/schema/beans
    https://www.springframework.org/schema/beans/spring-beans.xsd">

    <cassandra:auditing mapping-context-ref="customMappingContext" auditor-aware-ref="yourAuditorAwareImpl"/>
</beans>
```

--------------------------------

### Enable keyspace initializer via system property

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/schema-management.adoc

Configures the keyspace initializer to be enabled based on a system property named INITIALIZE_KEYSPACE. The enabled attribute uses a Spring expression to pull the boolean value from system properties.

```xml
<cassandra:initialize-keyspace session-factory-ref="cassandraSessionFactory"
    enabled="#{systemProperties.INITIALIZE_KEYSPACE}">    <1>
    <cassandra:script location="..."/>
</cassandra:initialize-database>

```

--------------------------------

### Query rows using Query and Criteria with CassandraTemplate

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/template.adoc

Demonstrates querying for Person objects where age is 50 and balance is greater than 1000.00, using withAllowFiltering(). The imperative version returns a List<Person>, while the reactive version returns a Flux<Person>.

```java
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);
```

```java
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);
```

--------------------------------

### Activating auditing through configuration (Java)

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/auditing.adoc

Java configuration class that enables Cassandra auditing with @EnableCassandraAuditing and defines an AuditorAware bean. The AuditorAware bean is automatically picked up by the auditing infrastructure to determine the current user.

```java
@Configuration
@EnableCassandraAuditing
class Config {

  @Bean
  public AuditorAware<AuditableUser> myAuditorProvider() {
      return new AuditorAwareImpl();
  }
}
```

--------------------------------

### Enable Micrometer instrumentation with ObservableCqlSessionFactoryBean and ObservableReactiveSessionFactoryBean

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/observability.adoc

Apply this configuration to enable Micrometer observations for Cassandra statement execution. The first bean wraps the CQL session to observe blocking execution and registers ObservationRequestTracker.INSTANCE with the CqlSessionBuilder. The second bean wraps a CQL session for reactive execution.

```java
@Configuration
class ObservabilityConfiguration {

  @Bean
  public ObservableCqlSessionFactoryBean observableCqlSession(CqlSessionBuilder builder,
                                                              ObservationRegistry registry) {
    return new ObservableCqlSessionFactoryBean(builder, registry); // <1>
  }

  @Bean
  public ObservableReactiveSessionFactoryBean observableReactiveSession(CqlSession session,
                                                              ObservationRegistry registry) {
    return new ObservableReactiveSessionFactoryBean(session, registry); // <2>
  }
}
```

--------------------------------

### Basic repository interface to persist Person entities

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/repositories/repositories.adoc

Shows imperative and reactive repository interfaces extending CrudRepository and ReactiveCrudRepository respectively.

```java
interface PersonRepository extends CrudRepository<Person, String> {

  // additional custom finder methods go here
}
```

```java
interface PersonRepository extends ReactiveCrudRepository<Person, String> {

  // additional custom finder methods go here
}
```

--------------------------------

### XML schema to configure Cassandra using the cassandra namespace

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/configuration.adoc

Configures a CqlSession using the cassandra namespace. The default bean name is 'cassandraSession'. Includes a session-factory with a script to execute schema.cql.

```xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xmlns:cassandra="http://www.springframework.org/schema/data/cassandra"
  xsi:schemaLocation="
    http://www.springframework.org/schema/data/cassandra
    https://www.springframework.org/schema/data/cassandra/spring-cassandra.xsd
    http://www.springframework.org/schema/beans
    https://www.springframework.org/schema/beans/spring-beans.xsd">

  <!-- Default bean name is 'cassandraSession' -->
  <cassandra:session contact-points="localhost" port="9042">
    <cassandra:keyspace action="CREATE_DROP" name="mykeyspace" />
  </cassandra:session>

  <cassandra:session-factory>
    <cassandra:script
            location="classpath:/org/springframework/data/cassandra/config/schema.cql"/>
  </cassandra:session-factory>
</beans>
```

--------------------------------

### Cassandra UserRepository query methods

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/repositories/aot.adoc

Repository interface methods for derived, paginated, annotated, and named queries. The numbered callouts (1-4) map to the listed query types: derived query without arguments, derived query using pagination, annotated query, and named query.

```java
Slice<User> findSliceOfUsersByLastnameStartingWith(String lastname, Pageable page);  <2>

  @Query("select * from User where emailAddress = :emailAddress")
  User findAnnotatedQueryByEmailAddress(String emailAddress);                          <3>

  User findByEmailAddress(String emailAddress);                                        <4>

```

--------------------------------

### Execute raw CQL INSERT with ReactiveCassandraTemplate

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/template.adoc

Shows how to execute a raw CQL INSERT statement using the reactive ReactiveCassandraTemplate's ReactiveCqlOperations, returning a Mono<Boolean>.

```java
String cql = "INSERT INTO person (age, name) VALUES (39, 'Bob')";

Mono<Boolean> applied = reactiveCassandraTemplate.getReactiveCqlOperations().execute(cql);
```

--------------------------------

### Ignore failed DROP statements in keyspace initializer

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/schema-management.adoc

Configures the keyspace initializer to ignore failed DROP statements. This is useful when scripts are run against an empty keyspace and contain DROP statements that would fail. Other failures will still cause an exception.

```xml
<cassandra:initialize-keyspace session-factory-ref="cassandraSessionFactory" ignore-failures="DROPS">
    <cassandra:script location="..."/>
</cassandra:initialize-database>

```

--------------------------------

### Configuring Spring Data components by using XML

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/configuration.adoc

Configures Spring Data Cassandra components: property placeholder, session, mapping, converter, template, and repositories. The session uses placeholders from cassandra.properties. The template bean id is 'cassandraTemplate'. Repositories base package is 'org.spring.cassandra.example.repo'.

```xml

<!-- Loads the properties into the Spring Context and uses them to fill
in placeholders in the bean definitions -->
<context:property-placeholder location="classpath:cassandra.properties" />

<!-- REQUIRED: The Cassandra Session -->
<cassandra:session contact-points="${cassandra.contactpoints}" keyspace-name="${cassandra.keyspace}" />

<!-- REQUIRED: The default Cassandra mapping context used by `CassandraConverter` -->
<cassandra:mapping>
  <cassandra:user-type-resolver keyspace-name="${cassandra.keyspace}" />
</cassandra:mapping>

<!-- REQUIRED: The default Cassandra converter used by `CassandraTemplate` -->
<cassandra:converter />

<!-- REQUIRED: The Cassandra template is the foundation of all Spring
Data Cassandra -->
<cassandra:template id="cassandraTemplate" />

<!-- OPTIONAL: If you use Spring Data for Apache Cassandra repositories, add
your base packages to scan here -->
<cassandra:repositories base-package="org.spring.cassandra.example.repo" />

```

--------------------------------

### Activating reactive auditing using JavaConfig

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/auditing.adoc

Java configuration class that enables reactive Cassandra auditing with @EnableReactiveCassandraAuditing and defines a ReactiveAuditorAware bean. The ReactiveAuditorAware bean is automatically picked up by the auditing infrastructure to determine the current user.

```java
@Configuration
@EnableReactiveCassandraAuditing
class Config {

  @Bean
  public ReactiveAuditorAware<AuditableUser> myAuditorProvider() {
      return new AuditorAwareImpl();
  }
}
```

--------------------------------

### AOT metadata for UserRepository

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/repositories/aot.adoc

JSON metadata describing the imperative repository methods and their generated queries for the Cassandra module. Use this to verify the AOT-generated query strings and signatures for each repository method.

```json
{
  "name": "com.acme.UserRepository",
  "module": "Cassandra",
  "type": "IMPERATIVE",
  "methods": [
    {
      "name": "findUserNoArgumentsBy",
      "signature": "public abstract java.util.List<com.acme.User> com.acme.UserRepository.findUserNoArgumentsBy()",
      "query": {
        "query": "select * from user"
      }
    },
    {
      "name": "findSliceOfUsersByLastnameStartingWith",
      "signature": "public abstract org.springframework.data.domain.Slice<com.acme.User> com.acme.UserRepository.findSliceOfUsersByLastnameStartingWith(java.lang.String,org.springframework.data.domain.Pageable)",
      "query": {
        "query": "select * from user where lastname like ?"
      }
    },
    {
      "name": "findAnnotatedQueryByEmailAddress",
      "signature": 
```

--------------------------------

### Specifying entity base packages in XML configuration

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/schema-management.adoc

XML configuration to specify entity base packages for Cassandra mapping. The entity-base-packages attribute accepts a comma-separated list of packages.

```xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xmlns:cassandra="http://www.springframework.org/schema/data/cassandra"
  xsi:schemaLocation="
    http://www.springframework.org/schema/data/cassandra
    https://www.springframework.org/schema/data/cassandra/spring-cassandra.xsd
    http://www.springframework.org/schema/beans
    https://www.springframework.org/schema/beans/spring-beans.xsd">

    <cassandra:mapping entity-base-packages="com.foo,com.bar"/>
</beans>
```

--------------------------------

### Using @Embedded.Nullable shortcut

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/object-mapping.adoc

Shows the @Embedded.Nullable shortcut, which is equivalent to @Embedded(onEmpty = USE_NULL) and also sets JSR-305 @javax.annotation.Nonnull accordingly.

```java
public class MyEntity {

    @Id
    Integer id;

    @Embedded.Nullable <1>
    EmbeddedEntity embeddedEntity;
}
```

--------------------------------

### Query with as() to map to different type

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/template.adoc

Query rows from a table that holds entities of different types, mapping results to a different target type with `as(Class<?>)`. The query fields are mapped against `SWCharacter`, while resulting rows are mapped into `Jedi`. The imperative variant returns a `List`, the reactive variant returns a `Flux`.

```java
List<Jedi> all = ops.query(SWCharacter.class)    <1>
  .as(Jedi.class)                                <2>
  .matching(query(where("jedi").is(true)))
  .all();

```

```java
Flux<Jedi> all = ops.query(SWCharacter.class)    <1>
  .as(Jedi.class)                                <2>
  .matching(query(where("jedi").is(true)))
  .all();

```

--------------------------------

### Update rows using [Reactive]CassandraTemplate

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/template.adoc

Updates a single account by incrementing its balance by 50.00 using the `+` assignment. The imperative version returns a boolean; the reactive version returns a Mono<Boolean>. Both use the `Update` class with the `increment` method.

```java
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);
```

```java
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);
```

--------------------------------

### Insert and retrieve a Person using CassandraTemplate

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/template.adoc

Shows the imperative CassandraTemplate insert and selectOneById operations. Requires the id property to be set, as Cassandra cannot generate IDs. The table name defaults to the simple class name with a lower-case first letter.

```java
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);
```

--------------------------------

### CassandraTemplate Operations

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/template.adoc

Methods for inserting, updating, selecting, and batch operations on the [Reactive]CassandraTemplate, plus raw CQL execution.

```APIDOC
## [Reactive]CassandraTemplate.insert(Object)

### Description
Inserts an object into an Apache Cassandra table. The table name is determined by the simple class name (lowercased) unless overridden by mapping metadata. The `id` property must be set.

### Method
insert

### Parameters
- **objectToSave** (Object) - Required - The object to insert.

### Request Example
```java
Person bob = new Person("Bob", 33);
cassandraTemplate.insert(bob);
```

### Response
No explicit return value (void).
```

```APIDOC
## [Reactive]CassandraTemplate.insert(Object, InsertOptions)

### Description
Inserts an object into an Apache Cassandra table and applies `InsertOptions` (e.g., TTL, consistency level, lightweight transactions).

### Method
insert

### Parameters
- **objectToSave** (Object) - Required - The object to insert.
- **options** (InsertOptions) - Required - Options to apply to the insert operation.

### Response
Returns a `WriteResult`.
```

```APIDOC
## [Reactive]CassandraTemplate.update(Object)

### Description
Updates an object in an Apache Cassandra table. The `id` property must be set.

### Method
update

### Parameters
- **objectToSave** (Object) - Required - The object to update.

### Response
No explicit return value (void).
```

```APIDOC
## [Reactive]CassandraTemplate.update(Object, UpdateOptions)

### Description
Updates an object in an Apache Cassandra table and applies `UpdateOptions` (e.g., TTL, consistency level, lightweight transactions).

### Method
update

### Parameters
- **objectToSave** (Object) - Required - The object to update.
- **options** (UpdateOptions) - Required - Options to apply to the update operation.

### Response
Returns a `WriteResult`.
```

```APIDOC
## [Reactive]CassandraTemplate.selectOneById(Query, Class)

### Description
Retrieves a single object by query criteria. The example uses a query with a criterion on the `age` property.

### Method
selectOneById

### Parameters
- **query** (Query) - Required - The query criteria.
- **entityType** (Class) - Required - The entity class to map the result to.

### Request Example
```java
Person queriedBob = cassandraTemplate.selectOneById(query(where("age").is(33)), Person.class);
```

### Response
Returns the entity of the specified type.
```

```APIDOC
## [Reactive]CassandraTemplate.batchOps()

### Description
Creates a new `[Reactive]CassandraBatchOperations` to populate a batch for inserting, updating, or deleting multiple objects in one operation.

### Method
batchOps

### Response
Returns a `[Reactive]CassandraBatchOperations` instance.
```

```APIDOC
## [Reactive]CassandraBatchOperations.insert(Object|Object[]|Iterable)

### Description
Adds objects to the batch for insertion. Accepts a single object, an array (var-args), or an `Iterable` of objects.

### Method
insert

### Parameters
- **objects** (Object|Object[]|Iterable) - Required - The object(s) to insert.
```

```APIDOC
## [Reactive]CassandraBatchOperations.update(Object|Object[]|Iterable)

### Description
Adds objects to the batch for updating. Accepts a single object, an array (var-args), or an `Iterable` of objects.

### Method
update

### Parameters
- **objects** (Object|Object[]|Iterable) - Required - The object(s) to update.
```

```APIDOC
## [Reactive]CassandraBatchOperations.delete(Object|Object[]|Iterable)

### Description
Adds objects to the batch for deletion. Accepts a single object, an array (var-args), or an `Iterable` of objects.

### Method
delete

### Parameters
- **objects** (Object|Object[]|Iterable) - Required - The object(s) to delete.
```

```APIDOC
## [Reactive]CassandraBatchOperations.withTimestamp(long)

### Description
Applies a TTL to the batch.

### Method
withTimestamp

### Parameters
- **timestamp** (long) - Required - The timestamp to apply.
```

```APIDOC
## [Reactive]CassandraBatchOperations.execute()

### Description
Executes the batch operation.

### Method
execute
```

```APIDOC
## CqlOperations.execute(String)

### Description
Executes a raw CQL statement. This is the "old fashioned way" to write your own CQL statements.

### Method
execute

### Parameters
- **cql** (String) - Required - The CQL statement to execute.

### Request Example
```java
String cql = "INSERT INTO person (age, name) VALUES (39, 'Bob')";
cassandraTemplate().getCqlOperations().execute(cql);
```

### Response
For imperative, returns void. For reactive, returns `Mono<Boolean>`.
```

--------------------------------

### Between query method

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/repositories/query-methods.adoc

Maps the Between keyword to a range query. Supports both explicit from/to parameters and a Spring Data `Range` argument, with lower and upper bounds (`>` / `>=` and `<` / `<=`) applied according to the `Range`.

```java
findByAgeBetween(int from, int to)
```

```java
findByAgeBetween(Range<Integer> range)
```

--------------------------------

### Update.addTo(String)

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/template.adoc

Entry-point for building update assignments that add to collections or maps using the '+' update assignment. Provides methods to prepend, append, or add entries.

```APIDOC
## Update.addTo(String)

### Description
Entry-point for building update assignments that add to collections or maps using the '+' update assignment. Provides methods to prepend, append, or add entries.

### Method
addTo

### Parameters
- **columnName** (String) - Required - The name of the column to update.

### Return Value
- **AddToBuilder** - A builder for specifying the addition operation.

### AddToBuilder Methods
- **prepend(Object value)** - Prepends a collection value to the existing collection using the '+' update assignment.
- **prependAll(Object... values)** - Prepends all collection values to the existing collection using the '+' update assignment.
- **append(Object value)** - Appends a collection value to the existing collection using the '+' update assignment.
- **append(Object... values)** - Appends all collection values to the existing collection using the '+' update assignment.
- **entry(Object key, Object value)** - Adds a map entry using the '+' update assignment.
- **addAll(Map<? extends Object, ? extends Object> map)** - Adds all map entries to the map using the '+' update assignment.
```

--------------------------------

### LessThan query method

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/repositories/query-methods.adoc

Maps the LessThan keyword to a less-than comparison.

```java
findByAgeLessThan(int age)
```

--------------------------------

### Java query for SWCharacter objects

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/kotlin/extensions.adoc

Java version of the query to retrieve a list of SWCharacter objects using the Cassandra template.

```java
Flux<SWCharacter> characters = template.query(SWCharacter.class).inTable("star-wars").all()
```

--------------------------------

### Set statement separator for keyspace initializer scripts

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/schema-management.adoc

Configures the keyspace initializer with a default statement separator of @@, overriding it to ; for the db-schema.cql script. The two test-data scripts use the default separator.

```xml
<cassandra:initialize-keyspace session-factory-ref="cassandraSessionFactory" separator="@@">
    <cassandra:script location="classpath:com/myapp/cql/db-schema.cql" separator=";"/>
    <cassandra:script location="classpath:com/myapp/cql/db-test-data-1.cql"/>
    <cassandra:script location="classpath:com/myapp/cql/db-test-data-2.cql"/>
</cassandra:initialize-keyspace>

```

--------------------------------

### Create a Vector with Vector.of

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/partials/vector-search.adoc

Creates a Vector instance from a list of floating-point numbers. Use this to represent an n-dimensional embedding for vector search queries or as a property on a domain entity.

```java
Vector vector = Vector.of(0.23f, 0.11f, 0.77f);
```

--------------------------------

### LessThanEqual query method

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/repositories/query-methods.adoc

Maps the LessThanEqual keyword to a less-than-or-equal comparison.

```java
findByAgeLessThanEqual(int age)
```

--------------------------------

### ReactiveCqlTemplate query with RowMapper (listOfRowMapper)

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/cql-template.adoc

Reactive variant of querying with a RowMapper. The source uses an include directive, so the actual code is not visible on this page.

```java
include::example$ReactiveCqlTemplateExamples.java[tags=listOfRowMapper]
```

--------------------------------

### Look up CassandraTemplate bean from ApplicationContext

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/template.adoc

Shows how to retrieve the CassandraOperations bean from the ApplicationContext using the bean name 'cassandraTemplate'. The reactive variant retrieves ReactiveCassandraOperations using the type-based lookup.

```java
CassandraOperations cassandraOperations = applicationContext.getBean("cassandraTemplate", CassandraOperations.class);
```

```java
ReactiveCassandraOperations cassandraOperations = applicationContext.getBean("ReactiveCassandraOperations", ReactiveCassandraOperations.class);
```

--------------------------------

### In keyword query method

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/repositories/query-methods.adoc

Finds entities where the property value is contained in the given collection.

```java
findByAgeIn(Collection ages)
```

--------------------------------

### cassandra.properties: Set contact points and keyspace

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/configuration.adoc

Defines the Cassandra contact points and keyspace used by the application. These properties are loaded into the Spring context and used as placeholders in XML bean definitions.

```properties
cassandra.contactpoints=10.1.55.80:9042,10.1.55.81:9042
cassandra.keyspace=showcase
```

--------------------------------

### Using ScoringFunction in a Repository Search Method

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/partials/vector-search-scoring-include.adoc

Define a repository method that accepts a ScoringFunction and call it with ScoringFunction.cosine() or ScoringFunction.euclidean() to compute similarity using the respective distance function.

```java
interface CommentRepository extends Repository<Comment, String> {

  SearchResults<Comment> searchByEmbeddingNear(Vector vector, ScoringFunction function);
}

repository.searchByEmbeddingNear(Vector.of(…), ScoringFunction.cosine());     <1>

repository.searchByEmbeddingNear(Vector.of(…), ScoringFunction.euclidean());  <2>
```

--------------------------------

### Update Maven dependencies for Cassandra driver groupId migration

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/migration-guide/migration-guide-4.0-to-4.3.adoc

Shows the Maven dependency coordinates for the Cassandra Java driver before and after the groupId migration from com.datastax.oss to org.apache.cassandra. The first block is the configuration up to 4.2.x, the second is the updated configuration for 4.3.x.

```xml
<dependency>
	<groupId>com.datastax.oss</groupId>
	<artifactId>java-driver-core</artifactId>
</dependency>

<dependency>
	<groupId>com.datastax.oss</groupId>
	<artifactId>java-driver-query-builder</artifactId>
</dependency>
```

```xml
<dependency>
	<groupId>org.apache.cassandra</groupId>
	<artifactId>java-driver-core</artifactId>
</dependency>

<dependency>
	<groupId>org.apache.cassandra</groupId>
	<artifactId>java-driver-query-builder</artifactId>
</dependency>
```

--------------------------------

### GreaterThanEqual query method

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/repositories/query-methods.adoc

Maps the GreaterThanEqual keyword to a CQL greater-than-or-equal predicate on the age column.

```java
findByAgeGreaterThanEqual(int age)
```

--------------------------------

### Insert and retrieve a Person using ReactiveCassandraTemplate

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/template.adoc

Shows the reactive variant using ReactiveCassandraTemplate, returning a Mono<Person> from selectOneById. Requires the id property to be set, as Cassandra cannot generate IDs.

```java
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);
```

--------------------------------

### Vector search query with ANN sorting

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/template.adoc

Run a vector search query using `ANN` sorting and a similarity function. Selects the `comment` column and includes a `similarity_cosine(vector, [...])` function call with an alias `similarity` to map onto `CommentSearch.similarity`. Uses `VectorSort.ann("vector", vector)` for sorting and maps results to the `CommentSearch` projection type.

```java
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();

```

--------------------------------

### Cassandra Repository Query Methods

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/repositories/aot.adoc

This snippet shows the different types of query methods in a Spring Data Cassandra repository: derived queries, pagination, annotated queries, and named queries.

```java
Slice<User> findSliceOfUsersByLastnameStartingWith(String lastname, Pageable page);  <2>
```

```java
@Query("select * from User where emailAddress = :emailAddress")
User findAnnotatedQueryByEmailAddress(String emailAddress);
```

```java
User findByEmailAddress(String emailAddress);
```

--------------------------------

### Maven dependency for spring-data-cassandra

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/migration-guide/migration-guide-1.5-to-2.0.adoc

Include the merged spring-data-cassandra module in Maven dependencies. The standalone spring-cql module is no longer available.

```xml
<dependencies>

  <dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-cassandra</artifactId>
    <version>{version}</version>
  </dependency>

</dependencies>
```

--------------------------------

### Query all rows with inTable

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/template.adoc

Query all rows from a specific table using the fluent template API. The `inTable("star_wars")` step can be skipped if the entity defines the table name with `@Table` or if using the class name as the table name is acceptable. The imperative variant returns a `List`, while the reactive variant returns a `Flux`.

```java
List<SWCharacter> all = ops.query(SWCharacter.class)
  .inTable("star_wars")                        <1>
  .all();

```

```java
Flux<SWCharacter> all = ops.query(SWCharacter.class)
  .inTable("star_wars")                        <1>
  .all();

```

--------------------------------

### Maven Snapshot Dependency and Repository for Spring Data Cassandra

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/README.adoc

Configures Maven to use the latest snapshots of the upcoming major version by declaring a -SNAPSHOT dependency and the Spring snapshot repository.

```xml
<dependency>
  <groupId>org.springframework.data</groupId>
  <artifactId>spring-data-cassandra</artifactId>
  <version>${version}-SNAPSHOT</version>
</dependency>

<repository>
  <id>spring-snapshot</id>
  <name>Spring Snapshot Repository</name>
  <url>https://repo.spring.io/snapshot</url>
</repository>
```

--------------------------------

### Using Near and Within Keywords in Repository Search Methods

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/partials/vector-search-method-derived-include.adoc

Defines a Spring Data Cassandra repository interface using the `Near` and `Within` keywords in search method names. The `searchByEmbeddingNear` method returns a list of comments, while `searchByEmbeddingNearAndCountry` returns `SearchResults` and accepts a `ScoringFunction` argument to specify the similarity scoring function. Cassandra does not allow limiting search results by score, so the `ScoringFunction` is used to calculate similarity.

```java
interface CommentRepository extends Repository<Comment, String> {

  List<Comment> searchByEmbeddingNear(Vector vector);

  SearchResults<Comment> searchByEmbeddingNearAndCountry(Vector vector, ScoringFunction function, String country);

}
```

--------------------------------

### Using a composite primary key with @PrimaryKey

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/object-mapping.adoc

Shows an entity class using a composite primary key class as its @PrimaryKey field. The @Column annotation maps the ipAddress property to the ip_address column.

```java
@Table(value = "login_event")
public class LoginEvent {

  @PrimaryKey
  private LoginEventKey key;

  @Column("ip_address")
  private String ipAddress;

  // getters and setters omitted
}
```

--------------------------------

### Maven Dependency for Spring Data Cassandra

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/README.adoc

Adds the stable spring-data-cassandra dependency to a Maven pom.xml. Replace ${version} with the desired version.

```xml
<dependency>
  <groupId>org.springframework.data</groupId>
  <artifactId>spring-data-cassandra</artifactId>
  <version>${version}</version>
</dependency>
```

--------------------------------

### Kotlin query for SWCharacter objects

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/kotlin/extensions.adoc

Kotlin version of the query using Spring Data extensions. Both lines are equivalent; the first uses reified generics and type inference, the second explicitly declares the type.

```kotlin
val characters = template.query<SWCharacter>().inTable("star-wars").all()
// or (both are equivalent)
val characters : Flux<SWCharacter> = template.query().inTable("star-wars").all()
```

--------------------------------

### Using @Query for vector search in Spring Data Cassandra

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/partials/vector-search-method-annotated-include.adoc

Defines a repository method using @Query with a Cassandra vector search query. The query selects a similarity score via similarity_cosine and orders by ANN (approximate nearest neighbor). Note that Cassandra does not allow limiting results by score; use a score projection column or a ScoringFunction argument if needed.

```java
interface CommentRepository extends Repository<Comment, String> {

  @Query("""
         SELECT id, description, country, similarity_cosine(embedding,:embedding) AS score
         FROM comments
         WHERE country = :country
         ORDER BY embedding ANN OF :embedding LIMIT :limit
         """)
  SearchResults<WithVectorFields> searchByEmbeddingNearAndCountry(Vector embedding, String country, Limit limit);
}
```

--------------------------------

### update(Query, Update, Class)

Source: https://github.com/spring-projects/spring-data-cassandra/blob/main/src/main/antora/modules/ROOT/pages/cassandra/template.adoc

Updates a selection of objects in the Apache Cassandra table based on the provided query and update definition. Returns a boolean indicating whether the update was applied.

```APIDOC
## update(Query, Update, Class)

### Description
Updates a selection of objects in the Apache Cassandra table based on the provided query and update definition. Returns a boolean indicating whether the update was applied.

### Method
update

### Parameters
- **query** (Query) - Required - The query that selects the rows to update.
- **update** (Update) - Required - The update definition to apply.
- **entityClass** (Class<?>) - Required - The entity class that maps to the table.

### Return Value
- **boolean** - Whether the update was applied.

### Example
```java
boolean applied = cassandraTemplate.update(Query.query(where("id").is("foo")),
  Update.create().increment("balance", 50.00), Account.class);
```
```
Tokens:
Raw