ftl.data.sql.r2dbc.postgresql.postgresql-libftl Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of rxmicro-annotation-processor-data-sql-r2dbc-postgresql Show documentation
The RxMicro Annotation Processor internal module that generates PostgreSQL R2DBC repositories.
There is a newer version: 0.11
Show newest version
<#include "../sql-lib.javaftl">
<#-- ------------------------------------------------------------------------------------------------ -->
<#-- ---------------- https://freemarker.apache.org/docs/ref_directive_function.html ---------------- -->
<#-- ------------------------------------------------------------------------------------------------ -->
<#-- ------------------------------------------------------------------------------------------------ -->
<#-- ----------------- https://freemarker.apache.org/docs/ref_directive_macro.html ------------------ -->
<#-- ------------------------------------------------------------------------------------------------ -->
<#macro returnEntityResult RETURN CONNECTION_PROVIDER SQL_PARAMS RESULT_CONVERTER CLOSE_CONNECTION>
<#if RETURN.oneItem>
<#if RETURN.mono>
return ${CONNECTION_PROVIDER}
        .flatMap(c -> executeStatement(c, generatedSQL${SQL_PARAMS})
                .flatMap(r -> Mono.from(r.map(${RESULT_CONVERTER})))
                <#if CLOSE_CONNECTION>
                .switchIfEmpty(close(c)
                        .then(Mono.empty()))
                .delayUntil(s -> close(c))
                .onErrorResume(e -> close(c)
                        .then(Mono.error(e)))
                
        );
<#elseif RETURN.future && !RETURN.optional>
return ${CONNECTION_PROVIDER}
        .flatMap(c -> executeStatement(c, generatedSQL${SQL_PARAMS})
                .flatMap(r -> Mono.from(r.map(${RESULT_CONVERTER})))
                <#if CLOSE_CONNECTION>
                .switchIfEmpty(close(c)
                        .then(Mono.empty()))
                .delayUntil(s -> close(c))
                .onErrorResume(e -> close(c)
                        .then(Mono.error(e)))
                
        )
        .switchIfEmpty(Mono.defer(() -> Mono.error(useOptionalExceptionSupplier(${RETURN.simpleReactiveType}.class, ${RETURN.simpleResultType}.class))))
        .toFuture();
<#elseif RETURN.future && RETURN.optional>
return ${CONNECTION_PROVIDER}
        .flatMap(c -> executeStatement(c, generatedSQL${SQL_PARAMS})
                .flatMap(r -> Mono.from(r.map(${RESULT_CONVERTER})))
                <#if CLOSE_CONNECTION>
                .switchIfEmpty(close(c)
                        .then(Mono.empty()))
                .delayUntil(s -> close(c))
                .onErrorResume(e -> close(c)
                        .then(Mono.error(e)))
                
        )
        .toFuture()
        .thenApply(a -> Optional.ofNullable(a));
<#elseif RETURN.single>
return Single.fromPublisher(
        ${CONNECTION_PROVIDER}
                .flatMap(c -> executeStatement(c, generatedSQL${SQL_PARAMS})
                        .flatMap(r -> Mono.from(r.map(${RESULT_CONVERTER})))
                        <#if CLOSE_CONNECTION>
                        .switchIfEmpty(close(c)
                                .then(Mono.empty()))
                        .delayUntil(s -> close(c))
                        .onErrorResume(e -> close(c)
                                .then(Mono.error(e)))
                        
                )
);
<#elseif RETURN.maybe>
return Flowable.fromPublisher(
        ${CONNECTION_PROVIDER}
                .flatMap(c -> executeStatement(c, generatedSQL${SQL_PARAMS})
                        .flatMap(r -> Mono.from(r.map(${RESULT_CONVERTER})))
                        <#if CLOSE_CONNECTION>
                        .switchIfEmpty(close(c)
                                .then(Mono.empty()))
                        .delayUntil(s -> close(c))
                        .onErrorResume(e -> close(c)
                                .then(Mono.error(e)))
                        
                )
).firstElement();
<#-- -------------------------------------------------------------------------------------------------------- -->
<#else>
//"The RxMicro framework does not know how to generate this method";

<#-- -------------------------------------------------------------------------------------------------------- -->
<#else>
<#if RETURN.flux>
return ${CONNECTION_PROVIDER}
        .flatMapMany(c -> executeStatement(c, generatedSQL${SQL_PARAMS})
                .flatMapMany(r -> Flux.from(r.map(${RESULT_CONVERTER})))
                <#if CLOSE_CONNECTION>
                .onErrorResume(e -> close(c)
                        .then(Mono.error(e)))
                .concatWith(close(c)
                        .then(Mono.empty()))
                
        );
<#elseif RETURN.mono>
return ${CONNECTION_PROVIDER}
        .flatMap(c -> executeStatement(c, generatedSQL${SQL_PARAMS})
                .flatMap(r -> Flux.from(r.map(${RESULT_CONVERTER})).collectList())
                <#if CLOSE_CONNECTION>
                .delayUntil(s -> close(c))
                .onErrorResume(e -> close(c)
                        .then(Mono.error(e)))
                
        );
<#elseif RETURN.future>
return ${CONNECTION_PROVIDER}
        .flatMap(c -> executeStatement(c, generatedSQL${SQL_PARAMS})
                .flatMap(r -> Flux.from(r.map(${RESULT_CONVERTER})).collectList())
                <#if CLOSE_CONNECTION>
                .delayUntil(s -> close(c))
                .onErrorResume(e -> close(c)
                        .then(Mono.error(e)))
                
        )
        .toFuture();
<#elseif RETURN.flowable>
return Flowable.fromPublisher(
        ${CONNECTION_PROVIDER}
                .flatMapMany(c -> executeStatement(c, generatedSQL${SQL_PARAMS})
                        .flatMapMany(r -> Flux.from(r.map(${RESULT_CONVERTER})))
                        <#if CLOSE_CONNECTION>
                        .onErrorResume(e -> close(c)
                                .then(Mono.error(e)))
                        .concatWith(close(c)
                                .then(Mono.empty()))
                        
                )
);
<#elseif RETURN.single>
return Flowable.fromPublisher(
        ${CONNECTION_PROVIDER}
                .flatMapMany(c -> executeStatement(c, generatedSQL${SQL_PARAMS})
                        .flatMapMany(r -> Flux.from(r.map(${RESULT_CONVERTER})))
                        <#if CLOSE_CONNECTION>
                        .onErrorResume(e -> close(c)
                                .then(Mono.error(e)))
                        .concatWith(close(c)
                                .then(Mono.empty()))
                        
                )
).collect(ArrayList::new, (l, e) -> l.add(e));
<#-- -------------------------------------------------------------------------------------------------------- -->
<#else>
//"The RxMicro framework does not know how to generate this method";

<#-- -------------------------------------------------------------------------------------------------------- -->


<#-- ------------------------------------------------------------------------------------------------ -->
<#-- ----------------- https://freemarker.apache.org/docs/ref_directive_macro.html ------------------ -->
<#-- ------------------------------------------------------------------------------------------------ -->