org.springframework.data.r2dbc.core

Interface R2dbcEntityOperations

All Superinterfaces:

FluentR2dbcOperations, ReactiveDeleteOperation, ReactiveInsertOperation, ReactiveSelectOperation, ReactiveUpdateOperation

All Known Implementing Classes:

R2dbcEntityTemplate

public interface R2dbcEntityOperations
extends FluentR2dbcOperations

Interface specifying a basic set of reactive R2DBC operations using entities. Implemented by R2dbcEntityTemplate. Not often used directly, but a useful option to enhance testability, as it can easily be mocked or stubbed.

Since:

1.1

Author:

Mark Paluch

See Also:

DatabaseClient

Nested Class Summary

Nested classes/interfaces inherited from interface org.springframework.data.r2dbc.core.ReactiveSelectOperation

ReactiveSelectOperation.ReactiveSelect<T>, ReactiveSelectOperation.SelectWithProjection<T>, ReactiveSelectOperation.SelectWithQuery<T>, ReactiveSelectOperation.SelectWithTable<T>, ReactiveSelectOperation.TerminatingSelect<T>

Nested classes/interfaces inherited from interface org.springframework.data.r2dbc.core.ReactiveInsertOperation

ReactiveInsertOperation.InsertWithTable<T>, ReactiveInsertOperation.ReactiveInsert<T>, ReactiveInsertOperation.TerminatingInsert<T>

Nested classes/interfaces inherited from interface org.springframework.data.r2dbc.core.ReactiveUpdateOperation

ReactiveUpdateOperation.ReactiveUpdate, ReactiveUpdateOperation.TerminatingUpdate, ReactiveUpdateOperation.UpdateWithQuery, ReactiveUpdateOperation.UpdateWithTable

Nested classes/interfaces inherited from interface org.springframework.data.r2dbc.core.ReactiveDeleteOperation

ReactiveDeleteOperation.DeleteWithQuery, ReactiveDeleteOperation.DeleteWithTable, ReactiveDeleteOperation.ReactiveDelete, ReactiveDeleteOperation.TerminatingDelete

Method Summary

Modifier and Type	Method and Description
reactor.core.publisher.Mono<Long>	count(org.springframework.data.relational.core.query.Query query, Class<?> entityClass) Returns the number of rows for the given entity class applying Query.
reactor.core.publisher.Mono<Integer>	delete(org.springframework.data.relational.core.query.Query query, Class<?> entityClass) Remove entities (rows)/columns from the table by Query.
<T> reactor.core.publisher.Mono<T>	delete(T entity) Delete the given entity and emit the entity if the delete was applied.
reactor.core.publisher.Mono<Boolean>	exists(org.springframework.data.relational.core.query.Query query, Class<?> entityClass) Determine whether the result for entityClass Query yields at least one row.
DatabaseClient	getDatabaseClient() Expose the underlying DatabaseClient to allow SQL operations.
<T> reactor.core.publisher.Mono<T>	insert(T entity) Insert the given entity and emit the entity if the insert was applied.
<T> reactor.core.publisher.Flux<T>	select(org.springframework.data.relational.core.query.Query query, Class<T> entityClass) Execute a SELECT query and convert the resulting items to a stream of entities.
<T> reactor.core.publisher.Mono<T>	selectOne(org.springframework.data.relational.core.query.Query query, Class<T> entityClass) Execute a SELECT query and convert the resulting item to an entity.
reactor.core.publisher.Mono<Integer>	update(org.springframework.data.relational.core.query.Query query, org.springframework.data.relational.core.query.Update update, Class<?> entityClass) Update the queried entities and return true if the update was applied.
<T> reactor.core.publisher.Mono<T>	update(T entity) Update the given entity and emit the entity if the update was applied.

Methods inherited from interface org.springframework.data.r2dbc.core.ReactiveSelectOperation

select

Methods inherited from interface org.springframework.data.r2dbc.core.ReactiveInsertOperation

insert

Methods inherited from interface org.springframework.data.r2dbc.core.ReactiveUpdateOperation

update

Methods inherited from interface org.springframework.data.r2dbc.core.ReactiveDeleteOperation

delete

Method Detail

getDatabaseClient

DatabaseClient getDatabaseClient()

Expose the underlying DatabaseClient to allow SQL operations.

Returns:

the underlying DatabaseClient.

See Also:

DatabaseClient

count

reactor.core.publisher.Mono<Long> count(org.springframework.data.relational.core.query.Query query,
                                        Class<?> entityClass)
                                 throws DataAccessException

Returns the number of rows for the given entity class applying Query. This overridden method allows users to further refine the selection Query using a Query predicate to determine how many entities of the given type match the Query.

Parameters:

query - user-defined count Query to execute; must not be null.

entityClass - type of the entity; must not be null.

Returns:

the number of existing entities.

Throws:

DataAccessException - if any problem occurs while executing the query.

exists

reactor.core.publisher.Mono<Boolean> exists(org.springframework.data.relational.core.query.Query query,
                                            Class<?> entityClass)
                                     throws DataAccessException

Determine whether the result for entityClass Query yields at least one row.

Parameters:

query - user-defined exists Query to execute; must not be null.

entityClass - type of the entity; must not be null.

Returns:

true if the object exists.

Throws:

DataAccessException - if any problem occurs while executing the query.

Since:

2.1

select

<T> reactor.core.publisher.Flux<T> select(org.springframework.data.relational.core.query.Query query,
                                          Class<T> entityClass)
                                   throws DataAccessException

Execute a SELECT query and convert the resulting items to a stream of entities.

Parameters:

query - must not be null.

entityClass - The entity type must not be null.

Returns:

the result objects returned by the action.

Throws:

DataAccessException - if there is any problem issuing the execution.

selectOne

<T> reactor.core.publisher.Mono<T> selectOne(org.springframework.data.relational.core.query.Query query,
                                             Class<T> entityClass)
                                      throws DataAccessException

Execute a SELECT query and convert the resulting item to an entity.

Parameters:

query - must not be null.

entityClass - The entity type must not be null.

Returns:

the result object returned by the action or Mono.empty().

Throws:

DataAccessException - if there is any problem issuing the execution.

update

reactor.core.publisher.Mono<Integer> update(org.springframework.data.relational.core.query.Query query,
                                            org.springframework.data.relational.core.query.Update update,
                                            Class<?> entityClass)
                                     throws DataAccessException

Update the queried entities and return true if the update was applied.

Parameters:

query - must not be null.

update - must not be null.

entityClass - The entity type must not be null.

Returns:

the number of affected rows.

Throws:

DataAccessException - if there is any problem executing the query.

delete

reactor.core.publisher.Mono<Integer> delete(org.springframework.data.relational.core.query.Query query,
                                            Class<?> entityClass)
                                     throws DataAccessException

Remove entities (rows)/columns from the table by Query.

Parameters:

query - must not be null.

entityClass - The entity type must not be null.

Returns:

the number of affected rows.

Throws:

DataAccessException - if there is any problem issuing the execution.

insert

<T> reactor.core.publisher.Mono<T> insert(T entity)
                                   throws DataAccessException

Insert the given entity and emit the entity if the insert was applied.

Parameters:

entity - The entity to insert, must not be null.

Returns:

the inserted entity.

Throws:

DataAccessException - if there is any problem issuing the execution.

update

<T> reactor.core.publisher.Mono<T> update(T entity)
                                   throws DataAccessException

Update the given entity and emit the entity if the update was applied.

Parameters:

entity - The entity to update, must not be null.

Returns:

the updated entity.

Throws:

DataAccessException - if there is any problem issuing the execution.

TransientDataAccessResourceException - if the update did not affect any rows.

delete

<T> reactor.core.publisher.Mono<T> delete(T entity)
                                   throws DataAccessException

Delete the given entity and emit the entity if the delete was applied.

Parameters:

entity - must not be null.

Returns:

the deleted entity.

Throws:

DataAccessException - if there is any problem issuing the execution.