ReactiveCqlTemplate (Spring Data for Apache Cassandra 3.4.1 API)

java.lang.Object
- org.springframework.data.cassandra.core.cql.ReactiveCassandraAccessor
- - org.springframework.data.cassandra.core.cql.ReactiveCqlTemplate

All Implemented Interfaces:

InitializingBean, ReactiveCqlOperations
```
public class ReactiveCqlTemplate
extends ReactiveCassandraAccessor
implements ReactiveCqlOperations
```
This is the central class in the CQL core package for reactive Cassandra data access. It simplifies the use of CQL and helps to avoid common errors. It executes core CQL workflow, leaving application code to provide CQL and extract results. This class executes CQL queries or updates, initiating iteration over ReactiveResultSets and catching DriverException exceptions and translating them to the generic, more informative exception hierarchy defined in the org.springframework.dao package.
Code using this class need only implement callback interfaces, giving them a clearly defined contract. The PreparedStatementCreator callback interface creates a prepared statement given a Connection, providing CQL and any necessary parameters. The ResultSetExtractor interface extracts values from a ReactiveResultSet. See also PreparedStatementBinder and RowMapper for two popular alternative callback interfaces.
Can be used within a service implementation via direct instantiation with a ReactiveSessionFactory reference, or get prepared in an application context and given to services as bean reference. Note: The 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.
Because this class is parameterizable by the callback interfaces and the PersistenceExceptionTranslator interface, there should be no need to subclass it.
All CQL operations performed by this class are logged at debug level, using "org.springframework.data.cassandra.core.cql.ReactiveCqlTemplate" as log category.
NOTE: An instance of this class is thread-safe once configured.

Since:

2.0

Author:

Mark Paluch, Tomasz Lelek

See Also:

PreparedStatementCreator, PreparedStatementBinder, PreparedStatementCallback, ResultSetExtractor, RowCallbackHandler, RowMapper, PersistenceExceptionTranslator

Field Summary
- Fields inherited from class org.springframework.data.cassandra.core.cql.ReactiveCassandraAccessor
  logger

Constructor Summary

Constructors
Constructor and Description
`ReactiveCqlTemplate()` Construct a new `ReactiveCqlTemplate`.
`ReactiveCqlTemplate(ReactiveSession reactiveSession)` Construct a new `ReactiveCqlTemplate`, given a `ReactiveSession`.
`ReactiveCqlTemplate(ReactiveSessionFactory reactiveSessionFactory)` Construct a new `ReactiveCqlTemplate`, given a `ReactiveSessionFactory` to obtain `ReactiveSession`s from.

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`protected com.datastax.oss.driver.api.core.cql.Statement<?>`	`applyStatementSettings(com.datastax.oss.driver.api.core.cql.Statement<?> statement)` Prepare the given CQL Statement applying statement settings such as page size and consistency level.
`protected <T> reactor.core.publisher.Flux<T>`	`createFlux(ReactiveSessionCallback<T> callback)` Create a reusable `Flux` given a `ReactiveSessionCallback` without exception translation.
`protected <T> reactor.core.publisher.Flux<T>`	`createFlux(com.datastax.oss.driver.api.core.cql.Statement<?> statement, ReactiveStatementCallback<T> callback)` Create a reusable `Flux` given a `ReactiveStatementCallback` without exception translation.
`protected <T> reactor.core.publisher.Mono<T>`	`createMono(com.datastax.oss.driver.api.core.cql.Statement<?> statement, ReactiveStatementCallback<T> callback)` Create a reusable `Mono` given a `ReactiveStatementCallback` without exception translation.
`reactor.core.publisher.Flux<Boolean>`	`execute(org.reactivestreams.Publisher<String> statementPublisher)` Issue multiple CQL statements from a CQL statement `Publisher`.
`reactor.core.publisher.Mono<Boolean>`	`execute(ReactivePreparedStatementCreator psc)` Issue a single CQL execute operation (such as an insert, update or delete statement) using a `ReactivePreparedStatementCreator` to provide CQL and any required parameters.
`<T> reactor.core.publisher.Flux<T>`	`execute(ReactivePreparedStatementCreator psc, ReactivePreparedStatementCallback<T> action)` Execute a CQL data access operation, implemented as callback action working on a CQL `PreparedStatement`.
`<T> reactor.core.publisher.Flux<T>`	`execute(ReactiveSessionCallback<T> action)` Execute a CQL data access operation, implemented as callback action working on a `ReactiveSession`.
`reactor.core.publisher.Mono<Boolean>`	`execute(com.datastax.oss.driver.api.core.cql.Statement<?> statement)` Issue a single CQL execute, typically a DDL statement, insert, update or delete statement.
`reactor.core.publisher.Mono<Boolean>`	`execute(String cql)` Issue a single CQL execute, typically a DDL statement, insert, update or delete statement.
`reactor.core.publisher.Mono<Boolean>`	`execute(String cql, Object... args)` Issue a single CQL operation (such as an insert, update or delete statement) via a prepared statement, binding the given arguments.
`reactor.core.publisher.Mono<Boolean>`	`execute(String cql, PreparedStatementBinder psb)` Issue an statement using a `PreparedStatementBinder` to set bind parameters, with given CQL.
`reactor.core.publisher.Flux<Boolean>`	`execute(String cql, org.reactivestreams.Publisher<Object[]> args)` Issue a single CQL operation (such as an insert, update or delete statement) via a prepared statement, binding the given arguments.
`<T> reactor.core.publisher.Flux<T>`	`execute(String cql, ReactivePreparedStatementCallback<T> action)` Execute a CQL data access operation, implemented as callback action working on a CQL `PreparedStatement`.
`protected RowMapper<Map<String,Object>>`	`getColumnMapRowMapper()` Create a new RowMapper for reading columns as key-value pairs.
`com.datastax.oss.driver.api.core.ConsistencyLevel`	`getConsistencyLevel()`
`ExecutionProfileResolver`	`getExecutionProfileResolver()`
`int`	`getFetchSize()` Deprecated. since 3.0, use `getPageSize()`.
`com.datastax.oss.driver.api.core.CqlIdentifier`	`getKeyspace()`
`int`	`getPageSize()`
`com.datastax.oss.driver.api.core.ConsistencyLevel`	`getSerialConsistencyLevel()`
`protected <T> RowMapper<T>`	`getSingleColumnRowMapper(Class<T> requiredType)` Create a new RowMapper for reading result objects from a single column.
`protected PreparedStatementBinder`	`newArgPreparedStatementBinder(Object[] args)` Create a new arg-based PreparedStatementSetter using the args passed in.
`protected ReactivePreparedStatementCreator`	`newReactivePreparedStatementCreator(String cql)` Create a new CQL-based `ReactivePreparedStatementCreator` using the CQL passed in.
`<T> reactor.core.publisher.Flux<T>`	`query(ReactivePreparedStatementCreator psc, PreparedStatementBinder preparedStatementBinder, ReactiveResultSetExtractor<T> rse)` Query using a prepared statement, reading the `ReactiveResultSet` with a `ReactiveResultSetExtractor`.
`<T> reactor.core.publisher.Flux<T>`	`query(ReactivePreparedStatementCreator psc, PreparedStatementBinder psb, RowMapper<T> rowMapper)` Query using a prepared statement and a `PreparedStatementBinder` implementation that knows how to bind values to the query, mapping each row to a Java object via a `RowMapper`.
`<T> reactor.core.publisher.Flux<T>`	`query(ReactivePreparedStatementCreator psc, ReactiveResultSetExtractor<T> rse)` Query using a prepared statement, reading the `ReactiveResultSet` with a `ReactiveResultSetExtractor`.
`<T> reactor.core.publisher.Flux<T>`	`query(ReactivePreparedStatementCreator psc, RowMapper<T> rowMapper)` Query using a prepared statement, mapping each row to a Java object via a `RowMapper`.
`<T> reactor.core.publisher.Flux<T>`	`query(com.datastax.oss.driver.api.core.cql.Statement<?> statement, ReactiveResultSetExtractor<T> rse)` Execute a query given static CQL, reading the `ReactiveResultSet` with a `ReactiveResultSetExtractor`.
`<T> reactor.core.publisher.Flux<T>`	`query(com.datastax.oss.driver.api.core.cql.Statement<?> statement, RowMapper<T> rowMapper)` Execute a query given static CQL, mapping each row to a Java object via a `RowMapper`.
`<T> reactor.core.publisher.Flux<T>`	`query(String cql, PreparedStatementBinder psb, ReactiveResultSetExtractor<T> rse)` Query using a prepared statement, reading the `ReactiveResultSet` with a `ReactiveResultSetExtractor`.
`<T> reactor.core.publisher.Flux<T>`	`query(String cql, PreparedStatementBinder psb, RowMapper<T> rowMapper)` Query given CQL to create a prepared statement from CQL and a `PreparedStatement`Binder implementation that knows how to bind values to the query, mapping each row to a Java object via a `RowMapper`.
`<T> reactor.core.publisher.Flux<T>`	`query(String cql, ReactiveResultSetExtractor<T> resultSetExtractor)` Execute a query given static CQL, reading the `ReactiveResultSet` with a `ReactiveResultSetExtractor`.
`<T> reactor.core.publisher.Flux<T>`	`query(String cql, ReactiveResultSetExtractor<T> rse, Object... args)` Query given CQL to create a prepared statement from CQL and a list of arguments to bind to the query, reading the `ReactiveResultSet` with a `ReactiveResultSetExtractor`.
`<T> reactor.core.publisher.Flux<T>`	`query(String cql, RowMapper<T> rowMapper)` Execute a query given static CQL, mapping each row to a Java object via a `RowMapper`.
`<T> reactor.core.publisher.Flux<T>`	`query(String cql, RowMapper<T> rowMapper, Object... args)` Query given CQL to create a prepared statement from CQL and a list of arguments to bind to the query, mapping each row to a Java object via a `RowMapper`.
`reactor.core.publisher.Flux<Map<String,Object>>`	`queryForFlux(com.datastax.oss.driver.api.core.cql.Statement<?> statement)` Execute a query for a result `Flux`, given static CQL.
`<T> reactor.core.publisher.Flux<T>`	`queryForFlux(com.datastax.oss.driver.api.core.cql.Statement<?> statement, Class<T> elementType)` Execute a query for a result `Flux`, given static CQL.
`reactor.core.publisher.Flux<Map<String,Object>>`	`queryForFlux(String cql)` Execute a query for a result `Flux`, given static CQL.
`<T> reactor.core.publisher.Flux<T>`	`queryForFlux(String cql, Class<T> elementType)` Execute a query for a result `Flux`, given static CQL.
`<T> reactor.core.publisher.Flux<T>`	`queryForFlux(String cql, Class<T> elementType, Object... args)` Query given CQL to create a prepared statement from CQL and a list of arguments to bind to the query, expecting a result `Flux`.
`reactor.core.publisher.Flux<Map<String,Object>>`	`queryForFlux(String cql, Object... args)` Query given CQL to create a prepared statement from CQL and a list of arguments to bind to the query, expecting a result `Flux`.
`reactor.core.publisher.Mono<Map<String,Object>>`	`queryForMap(com.datastax.oss.driver.api.core.cql.Statement<?> statement)` Execute a query for a result Map, given static CQL.
`reactor.core.publisher.Mono<Map<String,Object>>`	`queryForMap(String cql)` Execute a query for a result Map, given static CQL.
`reactor.core.publisher.Mono<Map<String,Object>>`	`queryForMap(String cql, Object... args)` Query given CQL to create a prepared statement from CQL and a list of arguments to bind to the query, expecting a result Map.
`<T> reactor.core.publisher.Mono<T>`	`queryForObject(com.datastax.oss.driver.api.core.cql.Statement<?> statement, Class<T> requiredType)` Execute a query for a result object, given static CQL.
`<T> reactor.core.publisher.Mono<T>`	`queryForObject(com.datastax.oss.driver.api.core.cql.Statement<?> statement, RowMapper<T> rowMapper)` Execute a query given static CQL, mapping a single result row to a Java object via a `RowMapper`.
`<T> reactor.core.publisher.Mono<T>`	`queryForObject(String cql, Class<T> requiredType)` Execute a query for a result object, given static CQL.
`<T> reactor.core.publisher.Mono<T>`	`queryForObject(String cql, Class<T> requiredType, Object... args)` Query given CQL to create a prepared statement from CQL and a list of arguments to bind to the query, expecting a result object.
`<T> reactor.core.publisher.Mono<T>`	`queryForObject(String cql, RowMapper<T> rowMapper)` Execute a query given static CQL, mapping a single result row to a Java object via a `RowMapper`.
`<T> reactor.core.publisher.Mono<T>`	`queryForObject(String cql, RowMapper<T> rowMapper, Object... args)` Query given CQL to create a prepared statement from CQL and a list of arguments to bind to the query, mapping a single result row to a Java object via a `RowMapper`.
`reactor.core.publisher.Mono<ReactiveResultSet>`	`queryForResultSet(com.datastax.oss.driver.api.core.cql.Statement<?> statement)` Execute a query for a ResultSet, given static CQL.
`reactor.core.publisher.Mono<ReactiveResultSet>`	`queryForResultSet(String cql)` Execute a query for a ResultSet, given static CQL.
`reactor.core.publisher.Mono<ReactiveResultSet>`	`queryForResultSet(String cql, Object... args)` Query given CQL to create a prepared statement from CQL and a list of arguments to bind to the query, expecting a ResultSet.
`reactor.core.publisher.Flux<com.datastax.oss.driver.api.core.cql.Row>`	`queryForRows(com.datastax.oss.driver.api.core.cql.Statement<?> statement)` Execute a query for Rows, given static CQL.
`reactor.core.publisher.Flux<com.datastax.oss.driver.api.core.cql.Row>`	`queryForRows(String cql)` Execute a query for Rows, given static CQL.
`reactor.core.publisher.Flux<com.datastax.oss.driver.api.core.cql.Row>`	`queryForRows(String cql, Object... args)` Query given CQL to create a prepared statement from CQL and a list of arguments to bind to the query, expecting Rows.
`void`	`setConsistencyLevel(com.datastax.oss.driver.api.core.ConsistencyLevel consistencyLevel)` Set the consistency level for this `ReactiveCqlTemplate`.
`void`	`setExecutionProfile(String profileName)` Set the driver execution profile for this template.
`void`	`setExecutionProfileResolver(ExecutionProfileResolver executionProfileResolver)` Set the `ExecutionProfileResolver` for this template.
`void`	`setFetchSize(int fetchSize)` Deprecated. since 3.0, use `setPageSize(int)`
`void`	`setKeyspace(com.datastax.oss.driver.api.core.CqlIdentifier keyspace)` Set the `keyspace` to be applied on statement-level for this template.
`void`	`setPageSize(int fetchSize)` Set the page size for this template.
`void`	`setSerialConsistencyLevel(com.datastax.oss.driver.api.core.ConsistencyLevel consistencyLevel)` Set the serial consistency level for this template.
`protected Function<Throwable,Throwable>`	`translateException(String task, String cql)` Exception translation `Function` intended for `Mono.onErrorMap(Function)` usage.
`protected Function<Throwable,Throwable>`	`translateException(String task, Supplier<String> cql)` Exception translation `Function` intended for `Mono.onErrorMap(Function)` usage.

Methods inherited from class org.springframework.data.cassandra.core.cql.ReactiveCassandraAccessor
afterPropertiesSet, getExceptionTranslator, getSessionFactory, setExceptionTranslator, setSessionFactory, toCql, translate, translateExceptionIfPossible

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - ReactiveCqlTemplate
```
public ReactiveCqlTemplate()
```
    Construct a new ReactiveCqlTemplate. Note: The ReactiveSessionFactory has to be set before using the instance.
    
    See Also:
    
    ReactiveCassandraAccessor.setSessionFactory(org.springframework.data.cassandra.ReactiveSessionFactory)
  - ReactiveCqlTemplate
```
public ReactiveCqlTemplate(ReactiveSession reactiveSession)
```
    Construct a new ReactiveCqlTemplate, given a ReactiveSession.
    
    Parameters:
    
    reactiveSession - the ReactiveSession, must not be null.
  - ReactiveCqlTemplate
```
public ReactiveCqlTemplate(ReactiveSessionFactory reactiveSessionFactory)
```
    Construct a new ReactiveCqlTemplate, given a ReactiveSessionFactory to obtain ReactiveSessions from.
    
    Parameters:
    
    reactiveSessionFactory - the ReactiveSessionFactory to obtain ReactiveSessions from, must not be null.
- Method Detail
  - setConsistencyLevel
```
public void setConsistencyLevel(@Nullable
                                com.datastax.oss.driver.api.core.ConsistencyLevel consistencyLevel)
```
    Set the consistency level for this ReactiveCqlTemplate. Consistency level defines the number of nodes involved into query processing. Relaxed consistency level settings use fewer nodes but eventual consistency is more likely to occur while a higher consistency level involves more nodes to obtain results with a higher consistency guarantee.
    
    See Also:
    
    Statement.setConsistencyLevel(ConsistencyLevel), RetryPolicy
  - getConsistencyLevel
```
@Nullable
public com.datastax.oss.driver.api.core.ConsistencyLevel getConsistencyLevel()
```
    Returns:
    
    the ConsistencyLevel specified for this ReactiveCqlTemplate.
  - setExecutionProfile
```
public void setExecutionProfile(String profileName)
```
    Set the driver execution profile for this template.
    
    Since:
    
    3.0
    
    See Also:
    
    Statement.setExecutionProfileName(String), ExecutionProfileResolver
  - setExecutionProfileResolver
```
public void setExecutionProfileResolver(ExecutionProfileResolver executionProfileResolver)
```
    Set the ExecutionProfileResolver for this template.
    
    Since:
    
    3.0
    
    See Also:
    
    DriverExecutionProfile, ExecutionProfileResolver
  - getExecutionProfileResolver
```
public ExecutionProfileResolver getExecutionProfileResolver()
```
    Returns:
    
    the ExecutionProfileResolver specified for this ReactiveCqlTemplate.
    
    Since:
    
    3.0
  - setFetchSize
```
@Deprecated
public void setFetchSize(int fetchSize)
```
    Deprecated. since 3.0, use setPageSize(int)
    
    Set the fetch size for this template. This is important for processing large result sets: Setting this higher than the default value will increase processing speed at the cost of memory consumption; setting this lower can avoid transferring row data that will never be read by the application. Default is -1, indicating to use the CQL driver's default configuration (i.e. to not pass a specific fetch size setting on to the driver).
    
    See Also:
    
    StatementBuilder.setPageSize(int)
  - getFetchSize
```
@Deprecated
public int getFetchSize()
```
    Deprecated. since 3.0, use getPageSize().
    
    Returns:
    
    the fetch size specified for this template.
  - setKeyspace
```
public void setKeyspace(com.datastax.oss.driver.api.core.CqlIdentifier keyspace)
```
    Set the keyspace to be applied on statement-level for this template. If not set, the default CqlSession keyspace will be used.
    
    Parameters:
    
    keyspace - the keyspace to apply, must not be null.
    
    Since:
    
    3.1
    
    See Also:
    
    SimpleStatement.setKeyspace(CqlIdentifier), BatchStatement.setKeyspace(CqlIdentifier)
  - getKeyspace
```
@Nullable
public com.datastax.oss.driver.api.core.CqlIdentifier getKeyspace()
```
    Returns:
    
    the keyspace to be applied on statement-level for this template.
    
    Since:
    
    3.1
  - setPageSize
```
public void setPageSize(int fetchSize)
```
    Set the page size for this template. This is important for processing large result sets: Setting this higher than the default value will increase processing speed at the cost of memory consumption; setting this lower can avoid transferring row data that will never be read by the application. Default is -1, indicating to use the CQL driver's default configuration (i.e. to not pass a specific page size setting on to the driver).
    
    See Also:
    
    StatementBuilder.setPageSize(int)
  - getPageSize
```
public int getPageSize()
```
    Returns:
    
    the page size specified for this template.
  - setSerialConsistencyLevel
```
public void setSerialConsistencyLevel(@Nullable
                                      com.datastax.oss.driver.api.core.ConsistencyLevel consistencyLevel)
```
    Set the serial consistency level for this template.
    
    Since:
    
    3.0
    
    See Also:
    
    Statement.setSerialConsistencyLevel(ConsistencyLevel), ConsistencyLevel
  - getSerialConsistencyLevel
```
@Nullable
public com.datastax.oss.driver.api.core.ConsistencyLevel getSerialConsistencyLevel()
```
    Returns:
    
    the serial ConsistencyLevel specified for this template.
    
    Since:
    
    3.0
  - execute
```
public <T> reactor.core.publisher.Flux<T> execute(ReactiveSessionCallback<T> action)
                                           throws DataAccessException
```
    Description copied from interface: ReactiveCqlOperations
    
    Execute a CQL data access operation, implemented as callback action working on a ReactiveSession. This allows for implementing arbitrary data access operations, within Spring's managed CQL environment: that is, converting CQL DriverExceptions into Spring's DataAccessException hierarchy.
    The callback action can return a result object, for example a domain object or a collection of domain objects.
    
    Specified by:
    
    execute in interface ReactiveCqlOperations
    
    Parameters:
    
    action - the callback object that specifies the action.
    
    Returns:
    
    a result object returned by the action, or null.
    
    Throws:
    
    DataAccessException - if there is any problem executing the query.
  - execute
```
public reactor.core.publisher.Mono<Boolean> execute(String cql)
                                             throws DataAccessException
```
    Description copied from interface: ReactiveCqlOperations
    
    Issue a single CQL execute, typically a DDL statement, insert, update or delete statement.
    
    Specified by:
    
    execute in interface ReactiveCqlOperations
    
    Parameters:
    
    cql - static CQL to execute, must not be empty or null.
    
    Returns:
    
    boolean value whether the statement was applied.
    
    Throws:
    
    DataAccessException - if there is any problem executing the query.
  - query
```
public <T> reactor.core.publisher.Flux<T> query(String cql,
                                                ReactiveResultSetExtractor<T> resultSetExtractor)
                                         throws DataAccessException
```
    Description copied from interface: ReactiveCqlOperations
    
    Execute a query given static CQL, reading the ReactiveResultSet with a ReactiveResultSetExtractor.
    Uses a CQL Statement, not a PreparedStatement. If you want to execute a static query with a PreparedStatement, use the overloaded query method with null as argument array.
    
    Specified by:
    
    query in interface ReactiveCqlOperations
    
    Parameters:
    
    cql - static CQL to execute, must not be empty or null.
    
    resultSetExtractor - object that will extract all rows of results, must not be null.
    
    Returns:
    
    an arbitrary result object, as returned by the ReactiveResultSetExtractor.
    
    Throws:
    
    DataAccessException - if there is any problem executing the query.
    
    See Also:
    
    ReactiveCqlOperations.query(String, ReactiveResultSetExtractor, Object...)
  - query
```
public <T> reactor.core.publisher.Flux<T> query(String cql,
                                                RowMapper<T> rowMapper)
                                         throws DataAccessException
```
    Description copied from interface: ReactiveCqlOperations
    
    Execute a query given static CQL, mapping each row to a Java object via a RowMapper.
    Uses a CQL Statement, not a PreparedStatement. If you want to execute a static query with a PreparedStatement, use the overloaded query method with null as argument array.
    
    Specified by:
    
    query in interface ReactiveCqlOperations
    
    Parameters:
    
    cql - static CQL to execute, must not be empty or null.
    
    rowMapper - object that will map one object per row, must not be null.
    
    Returns:
    
    the result Flux, containing mapped objects.
    
    Throws:
    
    DataAccessException - if there is any problem executing the query.
    
    See Also:
    
    ReactiveCqlOperations.query(String, RowMapper, Object[])
  - queryForObject
```
public <T> reactor.core.publisher.Mono<T> queryForObject(String cql,
                                                         RowMapper<T> rowMapper)
                                                  throws DataAccessException
```
    Description copied from interface: ReactiveCqlOperations
    
    Execute a query given static CQL, mapping a single result row to a Java object via a RowMapper.
    Uses a CQL Statement, not a PreparedStatement. If you want to execute a static query with a PreparedStatement, use the overloaded ReactiveCqlOperations.queryForObject(String, RowMapper, Object...) method with null as argument array.
    
    Specified by:
    
    queryForObject in interface ReactiveCqlOperations
    
    Parameters:
    
    cql - static CQL to execute, must not be empty or null.
    
    rowMapper - object that will map one object per row, must not be null.
    
    Returns:
    
    the single mapped object.
    
    Throws:
    
    IncorrectResultSizeDataAccessException - if the query does not return exactly one row.
    
    DataAccessException - if there is any problem executing the query.
    
    See Also:
    
    ReactiveCqlOperations.queryForObject(String, RowMapper, Object[])
  - queryForObject
```
public <T> reactor.core.publisher.Mono<T> queryForObject(String cql,
                                                         Class<T> requiredType)
                                                  throws DataAccessException
```
    Description copied from interface: ReactiveCqlOperations
    
    Execute a query for a result object, given static CQL.
    Uses a CQL Statement, not a PreparedStatement. If you want to execute a static query with a PreparedStatement, use the overloaded ReactiveCqlOperations.queryForObject(String, Class, Object...) method with null as argument array.
    This method is useful for running static CQL with a known outcome. The query is expected to be a single row/single column query; the returned result will be directly mapped to the corresponding object type.
    
    Specified by:
    
    queryForObject in interface ReactiveCqlOperations
    
    Parameters:
    
    cql - static CQL to execute, must not be empty or null.
    
    requiredType - the type that the result object is expected to match, must not be null.
    
    Returns:
    
    the result object of the required type, or Mono.empty() in case of CQL NULL.
    
    Throws:
    
    IncorrectResultSizeDataAccessException - if the query does not return exactly one row, or does not return exactly one column in that row.
    
    DataAccessException - if there is any problem executing the query.
    
    See Also:
    
    ReactiveCqlOperations.queryForObject(String, Class, Object[])
  - queryForMap
```
public reactor.core.publisher.Mono<Map<String,Object>> queryForMap(String cql)
                                                            throws DataAccessException
```
    Description copied from interface: ReactiveCqlOperations
    
    Execute a query for a result Map, given static CQL.
    Uses a CQL Statement, not a PreparedStatement. If you want to execute a static query with a PreparedStatement, use the overloaded ReactiveCqlOperations.queryForMap(String, Object...) method with null as argument array.
    The query is expected to be a single row query; the result row will be mapped to a Map (one entry for each column, using the column name as the key).
    
    Specified by:
    
    queryForMap in interface ReactiveCqlOperations
    
    Parameters:
    
    cql - static CQL to execute, must not be empty or null.
    
    Returns:
    
    the result Map (one entry for each column, using the column name as the key), must not be null.
    
    Throws:
    
    IncorrectResultSizeDataAccessException - if the query does not return exactly one row.
    
    DataAccessException - if there is any problem executing the query.
    
    See Also:
    
    ReactiveCqlOperations.queryForMap(String, Object[]), ColumnMapRowMapper
  - queryForFlux
```
public <T> reactor.core.publisher.Flux<T> queryForFlux(String cql,
                                                       Class<T> elementType)
                                                throws DataAccessException
```
    Description copied from interface: ReactiveCqlOperations
    
    Execute a query for a result Flux, given static CQL.
    Uses a CQL Statement, not a PreparedStatement. If you want to execute a static query with a PreparedStatement, use the overloaded queryForFlux method with null as argument array.
    The results will be mapped to a Flux (one item for each row) of result objects, each of them matching the specified element type.
    
    Specified by:
    
    queryForFlux in interface ReactiveCqlOperations
    
    Parameters:
    
    cql - static CQL to execute, must not be empty or null.
    
    elementType - the required type of element in the result Flux (for example, Integer.class), must not be null.
    
    Returns:
    
    a Flux of objects that match the specified element type.
    
    Throws:
    
    DataAccessException - if there is any problem executing the query.
    
    See Also:
    
    ReactiveCqlOperations.queryForFlux(String, Class, Object[]), SingleColumnRowMapper
  - queryForFlux
```
public reactor.core.publisher.Flux<Map<String,Object>> queryForFlux(String cql)
                                                             throws DataAccessException
```
    Description copied from interface: ReactiveCqlOperations
    
    Execute a query for a result Flux, given static CQL.
    Uses a CQL Statement, not a PreparedStatement. If you want to execute a static query with a PreparedStatement, use the overloaded queryForFlux method with null as argument array.
    The results will be mapped to a Flux (one item for each row) of Maps (one entry for each column using the column name as the key). Each item in the Flux will be of the form returned by this interface's queryForMap() methods.
    
    Specified by:
    
    queryForFlux in interface ReactiveCqlOperations
    
    Parameters:
    
    cql - static CQL to execute, must not be empty or null.
    
    Returns:
    
    a Flux that contains a Map per row.
    
    Throws:
    
    DataAccessException - if there is any problem executing the query.
    
    See Also:
    
    ReactiveCqlOperations.queryForFlux(String, Object[])
  - queryForResultSet
```
public reactor.core.publisher.Mono<ReactiveResultSet> queryForResultSet(String cql)
                                                                 throws DataAccessException
```
    Description copied from interface: ReactiveCqlOperations
    
    Execute a query for a ResultSet, given static CQL.
    Uses a CQL Statement, not a PreparedStatement. If you want to execute a static query with a PreparedStatement, use the overloaded queryForResultSet method with null as argument array.
    The results will be mapped to an ReactiveResultSet.
    
    Specified by:
    
    queryForResultSet in interface ReactiveCqlOperations
    
    Parameters:
    
    cql - static CQL to execute, must not be empty or null.
    
    Returns:
    
    a ReactiveResultSet representation.
    
    Throws:
    
    DataAccessException - if there is any problem executing the query.
    
    See Also:
    
    ReactiveCqlOperations.queryForResultSet(String, Object[])
  - queryForRows
```
public reactor.core.publisher.Flux<com.datastax.oss.driver.api.core.cql.Row> queryForRows(String cql)
                                                                                   throws DataAccessException
```
    Description copied from interface: ReactiveCqlOperations
    
    Execute a query for Rows, given static CQL.
    Uses a CQL Statement, not a PreparedStatement. If you want to execute a static query with a PreparedStatement, use the overloaded queryForResultSet method with null as argument array.
    The results will be mapped to Rows.
    
    Specified by:
    
    queryForRows in interface ReactiveCqlOperations
    
    Parameters:
    
    cql - static CQL to execute, must not be empty or null.
    
    Returns:
    
    a Row representation.
    
    Throws:
    
    DataAccessException - if there is any problem executing the query.
    
    See Also:
    
    ReactiveCqlOperations.queryForResultSet(String, Object[])
  - execute
```
public reactor.core.publisher.Flux<Boolean> execute(org.reactivestreams.Publisher<String> statementPublisher)
                                             throws DataAccessException
```
    Description copied from interface: ReactiveCqlOperations
    
    Issue multiple CQL statements from a CQL statement Publisher.
    
    Specified by:
    
    execute in interface ReactiveCqlOperations
    
    Parameters:
    
    statementPublisher - defining a Publisher of CQL statements that will be executed.
    
    Returns:
    
    an array of the number of rows affected by each statement
    
    Throws:
    
    DataAccessException - if there is any problem executing the batch.
  - execute
```
public reactor.core.publisher.Mono<Boolean> execute(com.datastax.oss.driver.api.core.cql.Statement<?> statement)
                                             throws DataAccessException
```
    Description copied from interface: ReactiveCqlOperations
    
    Issue a single CQL execute, typically a DDL statement, insert, update or delete statement.
    
    Specified by:
    
    execute in interface ReactiveCqlOperations
    
    Parameters:
    
    statement - static CQL Statement, must not be null.
    
    Returns:
    
    boolean value whether the statement was applied.
    
    Throws:
    
    DataAccessException - if there is any problem executing the query.
  - query
```
public <T> reactor.core.publisher.Flux<T> query(com.datastax.oss.driver.api.core.cql.Statement<?> statement,
                                                ReactiveResultSetExtractor<T> rse)
                                         throws DataAccessException
```
    Description copied from interface: ReactiveCqlOperations
    
    Execute a query given static CQL, reading the ReactiveResultSet with a ReactiveResultSetExtractor.
    Uses a CQL Statement, not a PreparedStatement. If you want to execute a static query with a PreparedStatement, use the overloaded query method with null as argument array.
    
    Specified by:
    
    query in interface ReactiveCqlOperations
    
    Parameters:
    
    statement - static CQL Statement, must not be null.
    
    rse - object that will extract all rows of results, must not be null.
    
    Returns:
    
    an arbitrary result object, as returned by the ReactiveResultSetExtractor.
    
    Throws:
    
    DataAccessException - if there is any problem executing the query.
    
    See Also:
    
    ReactiveCqlOperations.query(String, ReactiveResultSetExtractor, Object...)
  - query
```
public <T> reactor.core.publisher.Flux<T> query(com.datastax.oss.driver.api.core.cql.Statement<?> statement,
                                                RowMapper<T> rowMapper)
                                         throws DataAccessException
```
    Description copied from interface: ReactiveCqlOperations
    
    Execute a query given static CQL, mapping each row to a Java object via a RowMapper.
    Uses a CQL Statement, not a PreparedStatement. If you want to execute a static query with a PreparedStatement, use the overloaded query method with null as argument array.
    
    Specified by:
    
    query in interface ReactiveCqlOperations
    
    Parameters:
    
    statement - static CQL Statement, must not be null.
    
    rowMapper - object that will map one object per row, must not be null.
    
    Returns:
    
    the result Flux, containing mapped objects.
    
    Throws:
    
    DataAccessException - if there is any problem executing the query.
    
    See Also:
    
    ReactiveCqlOperations.query(String, RowMapper, Object[])
  - queryForObject
```
public <T> reactor.core.publisher.Mono<T> queryForObject(com.datastax.oss.driver.api.core.cql.Statement<?> statement,
                                                         RowMapper<T> rowMapper)
                                                  throws DataAccessException
```
    Description copied from interface: ReactiveCqlOperations
    
    Execute a query given static CQL, mapping a single result row to a Java object via a RowMapper.
    Uses a CQL Statement, not a PreparedStatement. If you want to execute a static query with a PreparedStatement, use the overloaded ReactiveCqlOperations.queryForObject(String, RowMapper, Object...) method with null as argument array.
    
    Specified by:
    
    queryForObject in interface ReactiveCqlOperations
    
    Parameters:
    
    statement - static CQL Statement, must not be null.
    
    rowMapper - object that will map one object per row, must not be null.
    
    Returns:
    
    the single mapped object.
    
    Throws:
    
    IncorrectResultSizeDataAccessException - if the query does not return exactly one row.
    
    DataAccessException - if there is any problem executing the query.
    
    See Also:
    
    ReactiveCqlOperations.queryForObject(String, RowMapper, Object[])
  - queryForObject
```
public <T> reactor.core.publisher.Mono<T> queryForObject(com.datastax.oss.driver.api.core.cql.Statement<?> statement,
                                                         Class<T> requiredType)
                                                  throws DataAccessException
```
    Description copied from interface: ReactiveCqlOperations
    
    Execute a query for a result object, given static CQL.
    Uses a CQL Statement, not a PreparedStatement. If you want to execute a static query with a PreparedStatement, use the overloaded ReactiveCqlOperations.queryForObject(String, Class, Object...) method with null as argument array.
    This method is useful for running static CQL with a known outcome. The query is expected to be a single row/single column query; the returned result will be directly mapped to the corresponding object type.
    
    Specified by:
    
    queryForObject in interface ReactiveCqlOperations
    
    Parameters:
    
    statement - static CQL Statement, must not be null.
    
    requiredType - the type that the result object is expected to match, must not be null.
    
    Returns:
    
    the result object of the required type, or Mono.empty() in case of CQL NULL.
    
    Throws:
    
    IncorrectResultSizeDataAccessException - if the query does not return exactly one row, or does not return exactly one column in that row.
    
    DataAccessException - if there is any problem executing the query.
    
    See Also:
    
    ReactiveCqlOperations.queryForObject(String, Class, Object[])
  - queryForMap
```
public reactor.core.publisher.Mono<Map<String,Object>> queryForMap(com.datastax.oss.driver.api.core.cql.Statement<?> statement)
                                                            throws DataAccessException
```
    Description copied from interface: ReactiveCqlOperations
    
    Execute a query for a result Map, given static CQL.
    Uses a CQL Statement, not a PreparedStatement. If you want to execute a static query with a PreparedStatement, use the overloaded ReactiveCqlOperations.queryForMap(String, Object...) method with null as argument array.
    The query is expected to be a single row query; the result row will be mapped to a Map (one entry for each column, using the column name as the key).
    
    Specified by:
    
    queryForMap in interface ReactiveCqlOperations
    
    Parameters:
    
    statement - static CQL Statement, must not be null.
    
    Returns:
    
    the result Map (one entry for each column, using the column name as the key), must not be null.
    
    Throws:
    
    IncorrectResultSizeDataAccessException - if the query does not return exactly one row.
    
    DataAccessException - if there is any problem executing the query.
    
    See Also:
    
    ReactiveCqlOperations.queryForMap(String, Object[]), ColumnMapRowMapper
  - queryForFlux
```
public <T> reactor.core.publisher.Flux<T> queryForFlux(com.datastax.oss.driver.api.core.cql.Statement<?> statement,
                                                       Class<T> elementType)
                                                throws DataAccessException
```
    Description copied from interface: ReactiveCqlOperations
    
    Execute a query for a result Flux, given static CQL.
    Uses a CQL Statement, not a PreparedStatement. If you want to execute a static query with a PreparedStatement, use the overloaded queryForFlux method with null as argument array.
    The results will be mapped to a Flux (one item for each row) of result objects, each of them matching the specified element type.
    
    Specified by:
    
    queryForFlux in interface ReactiveCqlOperations
    
    Parameters:
    
    statement - static CQL Statement, must not be null.
    
    elementType - the required type of element in the result Flux (for example, Integer.class), must not be null.
    
    Returns:
    
    a Flux of objects that match the specified element type.
    
    Throws:
    
    DataAccessException - if there is any problem executing the query.
    
    See Also:
    
    ReactiveCqlOperations.queryForFlux(String, Class, Object[]), SingleColumnRowMapper
  - queryForFlux
```
public reactor.core.publisher.Flux<Map<String,Object>> queryForFlux(com.datastax.oss.driver.api.core.cql.Statement<?> statement)
                                                             throws DataAccessException
```
    Description copied from interface: ReactiveCqlOperations
    
    Execute a query for a result Flux, given static CQL.
    Uses a CQL Statement, not a PreparedStatement. If you want to execute a static query with a PreparedStatement, use the overloaded queryForFlux method with null as argument array.
    The results will be mapped to a Flux (one item for each row) of Maps (one entry for each column using the column name as the key). Each item in the Flux will be of the form returned by this interface's queryForMap() methods.
    
    Specified by:
    
    queryForFlux in interface ReactiveCqlOperations
    
    Parameters:
    
    statement - static CQL Statement, must not be null.
    
    Returns:
    
    a Flux that contains a Map per row.
    
    Throws:
    
    DataAccessException - if there is any problem executing the query.
    
    See Also:
    
    ReactiveCqlOperations.queryForFlux(String, Object[])
  - queryForResultSet
```
public reactor.core.publisher.Mono<ReactiveResultSet> queryForResultSet(com.datastax.oss.driver.api.core.cql.Statement<?> statement)
                                                                 throws DataAccessException
```
    Description copied from interface: ReactiveCqlOperations
    
    Execute a query for a ResultSet, given static CQL.
    Uses a CQL Statement, not a PreparedStatement. If you want to execute a static query with a PreparedStatement, use the overloaded queryForResultSet method with null as argument array.
    The results will be mapped to an ReactiveResultSet.
    
    Specified by:
    
    queryForResultSet in interface ReactiveCqlOperations
    
    Parameters:
    
    statement - static CQL Statement, must not be null.
    
    Returns:
    
    a ReactiveResultSet representation.
    
    Throws:
    
    DataAccessException - if there is any problem executing the query.
    
    See Also:
    
    ReactiveCqlOperations.queryForResultSet(String, Object[])
  - queryForRows
```
public reactor.core.publisher.Flux<com.datastax.oss.driver.api.core.cql.Row> queryForRows(com.datastax.oss.driver.api.core.cql.Statement<?> statement)
                                                                                   throws DataAccessException
```
    Description copied from interface: ReactiveCqlOperations
    
    Execute a query for Rows, given static CQL.
    Uses a CQL Statement, not a PreparedStatement. If you want to execute a static query with a PreparedStatement, use the overloaded queryForResultSet method with null as argument array.
    The results will be mapped to Rows.
    
    Specified by:
    
    queryForRows in interface ReactiveCqlOperations
    
    Parameters:
    
    statement - static CQL Statement, must not be null.
    
    Returns:
    
    a Row representation.
    
    Throws:
    
    DataAccessException - if there is any problem executing the query.
    
    See Also:
    
    ReactiveCqlOperations.queryForResultSet(String, Object[])
  - execute
```
public <T> reactor.core.publisher.Flux<T> execute(ReactivePreparedStatementCreator psc,
                                                  ReactivePreparedStatementCallback<T> action)
                                           throws DataAccessException
```
    Description copied from interface: ReactiveCqlOperations
    
    Execute a CQL data access operation, implemented as callback action working on a CQL PreparedStatement. This allows for implementing arbitrary data access operations on a single PreparedStatement, within Spring's managed CQL environment: that is, participating in Spring-managed transactions and converting CQL DriverExceptions into Spring's DataAccessException hierarchy.
    The callback action can return a result object, for example a domain object or a collection of domain objects.
    
    Specified by:
    
    execute in interface ReactiveCqlOperations
    
    Parameters:
    
    psc - object that can create a PreparedStatement given a ReactiveSession, must not be null.
    
    action - callback object that specifies the action, must not be null.
    
    Returns:
    
    a result object returned by the action, or null.
    
    Throws:
    
    DataAccessException - if there is any problem executing the query.
  - execute
```
public <T> reactor.core.publisher.Flux<T> execute(String cql,
                                                  ReactivePreparedStatementCallback<T> action)
                                           throws DataAccessException
```
    Description copied from interface: ReactiveCqlOperations
    
    Execute a CQL data access operation, implemented as callback action working on a CQL PreparedStatement. This allows for implementing arbitrary data access operations on a single Statement, within Spring's managed CQL environment: that is, participating in Spring-managed transactions and converting CQL DriverExceptions into Spring's DataAccessException hierarchy.
    The callback action can return a result object, for example a domain object or a collection of domain objects.
    
    Specified by:
    
    execute in interface ReactiveCqlOperations
    
    Parameters:
    
    cql - static CQL to execute, must not be empty or null.
    
    action - callback object that specifies the action, must not be null.
    
    Returns:
    
    a result object returned by the action, or null
    
    Throws:
    
    DataAccessException - if there is any problem executing the query.
  - query
```
public <T> reactor.core.publisher.Flux<T> query(ReactivePreparedStatementCreator psc,
                                                @Nullable
                                                PreparedStatementBinder preparedStatementBinder,
                                                ReactiveResultSetExtractor<T> rse)
                                         throws DataAccessException
```
    Query using a prepared statement, reading the ReactiveResultSet with a ReactiveResultSetExtractor.
    
    Specified by:
    
    query in interface ReactiveCqlOperations
    
    Parameters:
    
    psc - object that can create a PreparedStatement given a ReactiveSession
    
    preparedStatementBinder - object that knows how to set values on the prepared statement. If this is null, the CQL will be assumed to contain no bind parameters.
    
    rse - object that will extract results
    
    Returns:
    
    an arbitrary result object, as returned by the ReactiveResultSetExtractor
    
    Throws:
    
    DataAccessException - if there is any problem
  - query
```
public <T> reactor.core.publisher.Flux<T> query(ReactivePreparedStatementCreator psc,
                                                ReactiveResultSetExtractor<T> rse)
                                         throws DataAccessException
```
    Description copied from interface: ReactiveCqlOperations
    
    Query using a prepared statement, reading the ReactiveResultSet with a ReactiveResultSetExtractor.
    
    Specified by:
    
    query in interface ReactiveCqlOperations
    
    Parameters:
    
    psc - object that can create a PreparedStatement given a ReactiveSession, must not be null.
    
    rse - object that will extract results, must not be null.
    
    Returns:
    
    an arbitrary result object, as returned by the ReactiveResultSetExtractor
    
    Throws:
    
    DataAccessException - if there is any problem executing the query.
  - query
```
public <T> reactor.core.publisher.Flux<T> query(String cql,
                                                @Nullable
                                                PreparedStatementBinder psb,
                                                ReactiveResultSetExtractor<T> rse)
                                         throws DataAccessException
```
    Description copied from interface: ReactiveCqlOperations
    
    Query using a prepared statement, reading the ReactiveResultSet with a ReactiveResultSetExtractor.
    
    Specified by:
    
    query in interface ReactiveCqlOperations
    
    Parameters:
    
    cql - static CQL to execute, must not be empty or null.
    
    psb - object that knows how to set values on the prepared statement. If this is null, the CQL will be assumed to contain no bind parameters. Even if there are no bind parameters, this object may be used to set fetch size and other performance options.
    
    rse - object that will extract results, must not be null.
    
    Returns:
    
    an arbitrary result object, as returned by the ReactiveResultSetExtractor.
    
    Throws:
    
    DataAccessException - if there is any problem executing the query.
  - query
```
public <T> reactor.core.publisher.Flux<T> query(String cql,
                                                ReactiveResultSetExtractor<T> rse,
                                                Object... args)
                                         throws DataAccessException
```
    Description copied from interface: ReactiveCqlOperations
    
    Query given CQL to create a prepared statement from CQL and a list of arguments to bind to the query, reading the ReactiveResultSet with a ReactiveResultSetExtractor.
    
    Specified by:
    
    query in interface ReactiveCqlOperations
    
    Parameters:
    
    cql - static CQL to execute, must not be empty or null.
    
    rse - object that will extract results, must not be null.
    
    args - arguments to bind to the query (leaving it to the PreparedStatement to guess the corresponding CQL type).
    
    Returns:
    
    an arbitrary result object, as returned by the ReactiveResultSetExtractor
    
    Throws:
    
    DataAccessException - if there is any problem executing the query.
  - query
```
public <T> reactor.core.publisher.Flux<T> query(ReactivePreparedStatementCreator psc,
                                                RowMapper<T> rowMapper)
                                         throws DataAccessException
```
    Description copied from interface: ReactiveCqlOperations
    
    Query using a prepared statement, mapping each row to a Java object via a RowMapper.
    
    Specified by:
    
    query in interface ReactiveCqlOperations
    
    Parameters:
    
    psc - object that can create a PreparedStatement given a ReactiveSession, must not be null.
    
    rowMapper - object that will map one object per row, must not be null.
    
    Returns:
    
    the result Flux, containing mapped objects.
    
    Throws:
    
    DataAccessException - if there is any problem executing the query.
  - query
```
public <T> reactor.core.publisher.Flux<T> query(String cql,
                                                @Nullable
                                                PreparedStatementBinder psb,
                                                RowMapper<T> rowMapper)
                                         throws DataAccessException
```
    Description copied from interface: ReactiveCqlOperations
    
    Query given CQL to create a prepared statement from CQL and a PreparedStatementBinder implementation that knows how to bind values to the query, mapping each row to a Java object via a RowMapper.
    
    Specified by:
    
    query in interface ReactiveCqlOperations
    
    Parameters:
    
    cql - static CQL to execute, must not be empty or null.
    
    psb - object that knows how to set values on the prepared statement. If this is null, the CQL will be assumed to contain no bind parameters. Even if there are no bind parameters, this object may be used to set fetch size and other performance options.
    
    rowMapper - object that will map one object per row, must not be null.
    
    Returns:
    
    the result Flux, containing mapped objects.
    
    Throws:
    
    DataAccessException - if there is any problem executing the query.
  - query
```
public <T> reactor.core.publisher.Flux<T> query(ReactivePreparedStatementCreator psc,
                                                @Nullable
                                                PreparedStatementBinder psb,
                                                RowMapper<T> rowMapper)
                                         throws DataAccessException
```
    Description copied from interface: ReactiveCqlOperations
    
    Query using a prepared statement and a PreparedStatementBinder implementation that knows how to bind values to the query, mapping each row to a Java object via a RowMapper.
    
    Specified by:
    
    query in interface ReactiveCqlOperations
    
    Parameters:
    
    psc - object that can create a PreparedStatement given a CqlSession, must not be null.
    
    psb - object that knows how to set values on the prepared statement. If this is null, the CQL will be assumed to contain no bind parameters. Even if there are no bind parameters, this object may be used to set fetch size and other performance options.
    
    rowMapper - object that will map one object per row, must not be null.
    
    Returns:
    
    the result Flux, containing mapped objects.
    
    Throws:
    
    DataAccessException - if there is any problem executing the query.
  - query
```
public <T> reactor.core.publisher.Flux<T> query(String cql,
                                                RowMapper<T> rowMapper,
                                                Object... args)
                                         throws DataAccessException
```
    Description copied from interface: ReactiveCqlOperations
    
    Query given CQL to create a prepared statement from CQL and a list of arguments to bind to the query, mapping each row to a Java object via a RowMapper.
    
    Specified by:
    
    query in interface ReactiveCqlOperations
    
    Parameters:
    
    cql - static CQL to execute, must not be empty or null.
    
    rowMapper - object that will map one object per row
    
    args - arguments to bind to the query (leaving it to the PreparedStatement to guess the corresponding CQL type)
    
    Returns:
    
    the result Flux, containing mapped objects
    
    Throws:
    
    DataAccessException - if there is any problem executing the query.
  - queryForObject
```
public <T> reactor.core.publisher.Mono<T> queryForObject(String cql,
                                                         RowMapper<T> rowMapper,
                                                         Object... args)
                                                  throws DataAccessException
```
    Description copied from interface: ReactiveCqlOperations
    
    Query given CQL to create a prepared statement from CQL and a list of arguments to bind to the query, mapping a single result row to a Java object via a RowMapper.
    
    Specified by:
    
    queryForObject in interface ReactiveCqlOperations
    
    Parameters:
    
    cql - static CQL to execute, must not be empty or null.
    
    rowMapper - object that will map one object per row, must not be null.
    
    args - arguments to bind to the query (leaving it to the PreparedStatement to guess the corresponding CQL type)
    
    Returns:
    
    the single mapped object
    
    Throws:
    
    IncorrectResultSizeDataAccessException - if the query does not return exactly one row.
    
    DataAccessException - if there is any problem executing the query.
  - queryForObject
```
public <T> reactor.core.publisher.Mono<T> queryForObject(String cql,
                                                         Class<T> requiredType,
                                                         Object... args)
                                                  throws DataAccessException
```
    Description copied from interface: ReactiveCqlOperations
    
    Query given CQL to create a prepared statement from CQL and a list of arguments to bind to the query, expecting a result object.
    The query is expected to be a single row/single column query; the returned result will be directly mapped to the corresponding object type.
    
    Specified by:
    
    queryForObject in interface ReactiveCqlOperations
    
    Parameters:
    
    cql - static CQL to execute, must not be empty or null.
    
    requiredType - the type that the result object is expected to match, must not be null.
    
    args - arguments to bind to the query (leaving it to the PreparedStatement to guess the corresponding CQL type)
    
    Returns:
    
    the result object of the required type, or Mono.empty() in case of CQL NULL.
    
    Throws:
    
    IncorrectResultSizeDataAccessException - if the query does not return exactly one row, or does not return exactly one column in that row.
    
    DataAccessException - if there is any problem executing the query.
    
    See Also:
    
    ReactiveCqlOperations.queryForObject(String, Class)
  - queryForMap
```
public reactor.core.publisher.Mono<Map<String,Object>> queryForMap(String cql,
                                                                   Object... args)
                                                            throws DataAccessException
```
    Description copied from interface: ReactiveCqlOperations
    
    Query given CQL to create a prepared statement from CQL and a list of arguments to bind to the query, expecting a result Map. The queryForMap() methods defined by this interface are appropriate when you don't have a domain model. Otherwise, consider using one of the queryForObject() methods.
    The query is expected to be a single row query; the result row will be mapped to a Map (one entry for each column, using the column name as the key).
    
    Specified by:
    
    queryForMap in interface ReactiveCqlOperations
    
    Parameters:
    
    cql - static CQL to execute, must not be empty or null.
    
    args - arguments to bind to the query (leaving it to the PreparedStatement to guess the corresponding CQL type).
    
    Returns:
    
    the result Map (one entry for each column, using the column name as the key).
    
    Throws:
    
    IncorrectResultSizeDataAccessException - if the query does not return exactly one row
    
    DataAccessException - if there is any problem executing the query.
    
    See Also:
    
    ReactiveCqlOperations.queryForMap(String), ColumnMapRowMapper
  - queryForFlux
```
public <T> reactor.core.publisher.Flux<T> queryForFlux(String cql,
                                                       Class<T> elementType,
                                                       Object... args)
                                                throws DataAccessException
```
    Description copied from interface: ReactiveCqlOperations
    
    Query given CQL to create a prepared statement from CQL and a list of arguments to bind to the query, expecting a result Flux.
    The results will be mapped to a Flux (one item for each row) of result objects, each of them matching the specified element type.
    
    Specified by:
    
    queryForFlux in interface ReactiveCqlOperations
    
    Parameters:
    
    cql - static CQL to execute, must not be empty or null.
    
    elementType - the required type of element in the result Flux (for example, Integer.class), must not be null.
    
    args - arguments to bind to the query (leaving it to the PreparedStatement to guess the corresponding CQL type).
    
    Returns:
    
    a Flux of objects that match the specified element type.
    
    Throws:
    
    DataAccessException - if there is any problem executing the query.
    
    See Also:
    
    ReactiveCqlOperations.queryForFlux(String, Class), SingleColumnRowMapper
  - queryForFlux
```
public reactor.core.publisher.Flux<Map<String,Object>> queryForFlux(String cql,
                                                                    Object... args)
                                                             throws DataAccessException
```
    Description copied from interface: ReactiveCqlOperations
    
    Query given CQL to create a prepared statement from CQL and a list of arguments to bind to the query, expecting a result Flux.
    The results will be mapped to a Flux (one item for each row) of Maps (one entry for each column, using the column name as the key). Each item in the Flux will be of the form returned by this interface's queryForMap() methods.
    
    Specified by:
    
    queryForFlux in interface ReactiveCqlOperations
    
    Parameters:
    
    cql - static CQL to execute, must not be empty or null.
    
    args - arguments to bind to the query (leaving it to the PreparedStatement to guess the corresponding CQL type).
    
    Returns:
    
    a Flux that contains a Map per row
    
    Throws:
    
    DataAccessException - if there is any problem executing the query.
    
    See Also:
    
    ReactiveCqlOperations.queryForFlux(String)
  - queryForResultSet
```
public reactor.core.publisher.Mono<ReactiveResultSet> queryForResultSet(String cql,
                                                                        Object... args)
                                                                 throws DataAccessException
```
    Description copied from interface: ReactiveCqlOperations
    
    Query given CQL to create a prepared statement from CQL and a list of arguments to bind to the query, expecting a ResultSet.
    The results will be mapped to an ReactiveResultSet.
    
    Specified by:
    
    queryForResultSet in interface ReactiveCqlOperations
    
    Parameters:
    
    cql - static CQL to execute, must not be empty or null.
    
    args - arguments to bind to the query (leaving it to the PreparedStatement to guess the corresponding CQL type).
    
    Returns:
    
    a ReactiveResultSet representation.
    
    Throws:
    
    DataAccessException - if there is any problem executing the query.
    
    See Also:
    
    ReactiveCqlOperations.queryForResultSet(String)
  - queryForRows
```
public reactor.core.publisher.Flux<com.datastax.oss.driver.api.core.cql.Row> queryForRows(String cql,
                                                                                          Object... args)
                                                                                   throws DataAccessException
```
    Description copied from interface: ReactiveCqlOperations
    
    Query given CQL to create a prepared statement from CQL and a list of arguments to bind to the query, expecting Rows.
    The results will be mapped to Rows.
    
    Specified by:
    
    queryForRows in interface ReactiveCqlOperations
    
    Parameters:
    
    cql - static CQL to execute, must not be empty or null.
    
    args - arguments to bind to the query (leaving it to the PreparedStatement to guess the corresponding CQL type).
    
    Returns:
    
    a Row representation.
    
    Throws:
    
    DataAccessException - if there is any problem executing the query.
    
    See Also:
    
    ReactiveCqlOperations.queryForResultSet(String)
  - execute
```
public reactor.core.publisher.Mono<Boolean> execute(ReactivePreparedStatementCreator psc)
                                             throws DataAccessException
```
    Description copied from interface: ReactiveCqlOperations
    
    Issue a single CQL execute operation (such as an insert, update or delete statement) using a ReactivePreparedStatementCreator to provide CQL and any required parameters.
    
    Specified by:
    
    execute in interface ReactiveCqlOperations
    
    Parameters:
    
    psc - object that provides CQL and any necessary parameters, must not be null.
    
    Returns:
    
    boolean value whether the statement was applied.
    
    Throws:
    
    DataAccessException - if there is any problem issuing the execution.
  - execute
```
public reactor.core.publisher.Mono<Boolean> execute(String cql,
                                                    @Nullable
                                                    PreparedStatementBinder psb)
                                             throws DataAccessException
```
    Description copied from interface: ReactiveCqlOperations
    
    Issue an statement using a PreparedStatementBinder to set bind parameters, with given CQL. Simpler than using a ReactivePreparedStatementCreator as this method will create the PreparedStatement: The PreparedStatementBinder just needs to set parameters.
    
    Specified by:
    
    execute in interface ReactiveCqlOperations
    
    Parameters:
    
    cql - static CQL to execute, must not be empty or null.
    
    psb - object that knows how to set values on the prepared statement. If this is null, the CQL will be assumed to contain no bind parameters. Even if there are no bind parameters, this object may be used to set fetch size and other performance options.
    
    Returns:
    
    boolean value whether the statement was applied.
    
    Throws:
    
    DataAccessException - if there is any problem executing the query.
  - execute
```
public reactor.core.publisher.Mono<Boolean> execute(String cql,
                                                    Object... args)
                                             throws DataAccessException
```
    Description copied from interface: ReactiveCqlOperations
    
    Issue a single CQL operation (such as an insert, update or delete statement) via a prepared statement, binding the given arguments.
    
    Specified by:
    
    execute in interface ReactiveCqlOperations
    
    Parameters:
    
    cql - static CQL to execute, must not be empty or null.
    
    args - arguments to bind to the query (leaving it to the PreparedStatement to guess the corresponding CQL type).
    
    Returns:
    
    boolean value whether the statement was applied.
    
    Throws:
    
    DataAccessException - if there is any problem executing the query.
  - execute
```
public reactor.core.publisher.Flux<Boolean> execute(String cql,
                                                    org.reactivestreams.Publisher<Object[]> args)
                                             throws DataAccessException
```
    Description copied from interface: ReactiveCqlOperations
    
    Issue a single CQL operation (such as an insert, update or delete statement) via a prepared statement, binding the given arguments.
    
    Specified by:
    
    execute in interface ReactiveCqlOperations
    
    Parameters:
    
    cql - static CQL to execute containing bind parameters, must not be empty or null.
    
    args - arguments to bind to the query (leaving it to the PreparedStatement to guess the corresponding CQL type).
    
    Returns:
    
    boolean value whether the statement was applied.
    
    Throws:
    
    DataAccessException - if there is any problem executing the query.
  - newReactivePreparedStatementCreator
```
protected ReactivePreparedStatementCreator newReactivePreparedStatementCreator(String cql)
```
    Create a new CQL-based ReactivePreparedStatementCreator using the CQL passed in. By default, we'll create an SimpleReactivePreparedStatementCreator. This method allows for the creation to be overridden by subclasses.
    
    Parameters:
    
    cql - static CQL to execute, must not be empty or null.
    
    Returns:
    
    the new ReactivePreparedStatementCreator to use
    
    Since:
    
    2.0.8
  - createFlux
```
protected <T> reactor.core.publisher.Flux<T> createFlux(com.datastax.oss.driver.api.core.cql.Statement<?> statement,
                                                        ReactiveStatementCallback<T> callback)
```
    Create a reusable Flux given a ReactiveStatementCallback without exception translation.
    
    Parameters:
    
    callback - must not be null.
    
    Returns:
    
    a reusable Flux wrapping the ReactiveStatementCallback.
  - createMono
```
protected <T> reactor.core.publisher.Mono<T> createMono(com.datastax.oss.driver.api.core.cql.Statement<?> statement,
                                                        ReactiveStatementCallback<T> callback)
```
    Create a reusable Mono given a ReactiveStatementCallback without exception translation.
    
    Parameters:
    
    callback - must not be null.
    
    Returns:
    
    a reusable Mono wrapping the ReactiveStatementCallback.
  - createFlux
```
protected <T> reactor.core.publisher.Flux<T> createFlux(ReactiveSessionCallback<T> callback)
```
    Create a reusable Flux given a ReactiveSessionCallback without exception translation.
    
    Parameters:
    
    callback - must not be null.
    
    Returns:
    
    a reusable Flux wrapping the ReactiveSessionCallback.
  - translateException
```
protected Function<Throwable,Throwable> translateException(String task,
                                                           @Nullable
                                                           String cql)
```
    Exception translation Function intended for Mono.onErrorMap(Function) usage.
    
    Parameters:
    
    task - readable text describing the task being attempted
    
    cql - CQL query or update that caused the problem (may be null)
    
    Returns:
    
    the exception translation Function
    
    See Also:
    
    CqlProvider
  - translateException
```
protected Function<Throwable,Throwable> translateException(String task,
                                                           Supplier<String> cql)
```
    Exception translation Function intended for Mono.onErrorMap(Function) usage.
    
    Parameters:
    
    task - readable text describing the task being attempted
    
    cql - supplier of CQL query or update that caused the problem (may be null)
    
    Returns:
    
    the exception translation Function
    
    Since:
    
    3.3.3
    
    See Also:
    
    CqlProvider
  - getColumnMapRowMapper
```
protected RowMapper<Map<String,Object>> getColumnMapRowMapper()
```
    Create a new RowMapper for reading columns as key-value pairs.
    
    Returns:
    
    the RowMapper to use
    
    See Also:
    
    ColumnMapRowMapper
  - getSingleColumnRowMapper
```
protected <T> RowMapper<T> getSingleColumnRowMapper(Class<T> requiredType)
```
    Create a new RowMapper for reading result objects from a single column.
    
    Parameters:
    
    requiredType - the type that each result object is expected to match
    
    Returns:
    
    the RowMapper to use
    
    See Also:
    
    SingleColumnRowMapper
  - applyStatementSettings
```
protected com.datastax.oss.driver.api.core.cql.Statement<?> applyStatementSettings(com.datastax.oss.driver.api.core.cql.Statement<?> statement)
```
    Prepare the given CQL Statement applying statement settings such as page size and consistency level.
    
    Parameters:
    
    statement - the CQL Statement to prepare
    
    See Also:
    
    setConsistencyLevel(ConsistencyLevel), setSerialConsistencyLevel(ConsistencyLevel), setPageSize(int), setExecutionProfile(String), setExecutionProfileResolver(ExecutionProfileResolver)
  - newArgPreparedStatementBinder
```
protected PreparedStatementBinder newArgPreparedStatementBinder(Object[] args)
```
    Create a new arg-based PreparedStatementSetter using the args passed in.
    By default, we'll create an ArgumentPreparedStatementBinder. This method allows for the creation to be overridden by subclasses.
    
    Parameters:
    
    args - object array with arguments
    
    Returns:
    
    the new PreparedStatementBinder to use

Class ReactiveCqlTemplate

Field Summary

Fields inherited from class org.springframework.data.cassandra.core.cql.ReactiveCassandraAccessor

Constructor Summary

Method Summary

Methods inherited from class org.springframework.data.cassandra.core.cql.ReactiveCassandraAccessor

Methods inherited from class java.lang.Object

Constructor Detail

ReactiveCqlTemplate

ReactiveCqlTemplate

ReactiveCqlTemplate

Method Detail

setConsistencyLevel

getConsistencyLevel

setExecutionProfile

setExecutionProfileResolver

getExecutionProfileResolver

setFetchSize

getFetchSize

setKeyspace

getKeyspace

setPageSize

getPageSize

setSerialConsistencyLevel

getSerialConsistencyLevel

execute

execute

query

query

queryForObject

queryForObject

queryForMap

queryForFlux

queryForFlux

queryForResultSet

queryForRows

execute

execute

query

query

queryForObject

queryForObject

queryForMap

queryForFlux

queryForFlux

queryForResultSet

queryForRows

execute

execute

query

query

query

query

query

query

query

query

queryForObject

queryForObject

queryForMap

queryForFlux

queryForFlux

queryForResultSet

queryForRows

execute

execute

execute

execute

newReactivePreparedStatementCreator

createFlux

createMono

createFlux

translateException

translateException

getColumnMapRowMapper

getSingleColumnRowMapper

applyStatementSettings

newArgPreparedStatementBinder