Package net.lecousin.reactive.data.relational

Class LcReactiveDataRelationalClient

java.lang.Object

net.lecousin.reactive.data.relational.LcReactiveDataRelationalClient

@Component
public class LcReactiveDataRelationalClient
extends Object

Field Summary

Fields

Modifier and Type	Field	Description
static org.apache.commons.logging.Log	logger

Constructor Summary

Constructors

Constructor	Description
LcReactiveDataRelationalClient()

Method Summary

Modifier and Type	Method	Description
RelationalDatabaseSchema	buildSchemaFromEntities()
reactor.core.publisher.Mono<Void>	createSchemaContent(RelationalDatabaseSchema schema)
<T> reactor.core.publisher.Mono<Void>	delete(Iterable<T> entities)
<T> reactor.core.publisher.Mono<Void>	delete(org.reactivestreams.Publisher<T> publisher)
<T> reactor.core.publisher.Mono<Void>	delete(T entity)
reactor.core.publisher.Mono<Void>	dropCreateSchemaContent(RelationalDatabaseSchema schema)
reactor.core.publisher.Mono<Void>	dropSchemaContent(RelationalDatabaseSchema schema)
<T> reactor.core.publisher.Flux<T>	execute(SelectQuery<T> query, LcEntityReader reader)
LcReactiveDataAccessStrategy	getDataAccess()
org.springframework.data.r2dbc.dialect.R2dbcDialect	getDialect()
LcMappingR2dbcConverter	getMapper()
org.springframework.data.mapping.context.MappingContext<org.springframework.data.relational.core.mapping.RelationalPersistentEntity<?>,? extends org.springframework.data.relational.core.mapping.RelationalPersistentProperty>	getMappingContext()
RelationalDatabaseSchemaDialect	getSchemaDialect()
org.springframework.r2dbc.core.DatabaseClient	getSpringClient()
void	init()
<T> reactor.core.publisher.Mono<T>	lazyLoad(T entity)
<T> reactor.core.publisher.Mono<T>	lazyLoad(T entity, EntityState state, org.springframework.data.relational.core.mapping.RelationalPersistentEntity<?> entityType)
<T> reactor.core.publisher.Mono<T>	lazyLoad(T entity, org.springframework.data.relational.core.mapping.RelationalPersistentEntity<?> entityType)
<T> reactor.core.publisher.Flux<T>	save(Iterable<T> entities)
<T> reactor.core.publisher.Flux<T>	save(org.reactivestreams.Publisher<T> publisher)
<T> reactor.core.publisher.Mono<T>	save(T entity)
reactor.core.publisher.Mono<Void>	saveAll(Iterable<Object> entities)
reactor.core.publisher.Mono<Void>	saveAll(Object... entities)
void	setMapper(LcMappingR2dbcConverter mapper)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

logger

public static final org.apache.commons.logging.Log logger

Constructor Detail

LcReactiveDataRelationalClient

public LcReactiveDataRelationalClient()

Method Detail

init

@PostConstruct
public void init()

getMapper

public LcMappingR2dbcConverter getMapper()

setMapper

public void setMapper(LcMappingR2dbcConverter mapper)

getSpringClient

public org.springframework.r2dbc.core.DatabaseClient getSpringClient()

getMappingContext

public org.springframework.data.mapping.context.MappingContext<org.springframework.data.relational.core.mapping.RelationalPersistentEntity<?>,? extends org.springframework.data.relational.core.mapping.RelationalPersistentProperty> getMappingContext()

getDataAccess

public LcReactiveDataAccessStrategy getDataAccess()

getSchemaDialect

public RelationalDatabaseSchemaDialect getSchemaDialect()

getDialect

public org.springframework.data.r2dbc.dialect.R2dbcDialect getDialect()

dropSchemaContent

public reactor.core.publisher.Mono<Void> dropSchemaContent(RelationalDatabaseSchema schema)

createSchemaContent

public reactor.core.publisher.Mono<Void> createSchemaContent(RelationalDatabaseSchema schema)

dropCreateSchemaContent

public reactor.core.publisher.Mono<Void> dropCreateSchemaContent(RelationalDatabaseSchema schema)

buildSchemaFromEntities

public RelationalDatabaseSchema buildSchemaFromEntities()

save

public <T> reactor.core.publisher.Mono<T> save(T entity)

save

public <T> reactor.core.publisher.Flux<T> save(Iterable<T> entities)

save

public <T> reactor.core.publisher.Flux<T> save(org.reactivestreams.Publisher<T> publisher)

saveAll

public reactor.core.publisher.Mono<Void> saveAll(Iterable<Object> entities)

saveAll

public reactor.core.publisher.Mono<Void> saveAll(Object... entities)

lazyLoad

public <T> reactor.core.publisher.Mono<T> lazyLoad(T entity)

lazyLoad

public <T> reactor.core.publisher.Mono<T> lazyLoad(T entity,
                                                   org.springframework.data.relational.core.mapping.RelationalPersistentEntity<?> entityType)

lazyLoad

public <T> reactor.core.publisher.Mono<T> lazyLoad(T entity,
                                                   EntityState state,
                                                   org.springframework.data.relational.core.mapping.RelationalPersistentEntity<?> entityType)

execute

public <T> reactor.core.publisher.Flux<T> execute(SelectQuery<T> query,
                                                  @Nullable
                                                  LcEntityReader reader)

delete

public <T> reactor.core.publisher.Mono<Void> delete(T entity)

delete

public <T> reactor.core.publisher.Mono<Void> delete(Iterable<T> entities)

delete

public <T> reactor.core.publisher.Mono<Void> delete(org.reactivestreams.Publisher<T> publisher)