From 1f79eee62d94a470e324b779bb0e72cb2805b03e Mon Sep 17 00:00:00 2001 From: Guillaume Le Cousin Date: Sat, 9 Apr 2022 13:30:21 +0200 Subject: [PATCH] v0.10.0 --- README.md | 327 ++++++++++++++++++++------------ core/pom.xml | 2 +- h2/pom.xml | 2 +- jacoco-report-aggregate/pom.xml | 2 +- mysql/pom.xml | 2 +- pom.xml | 2 +- postgres/pom.xml | 2 +- test-junit-5/pom.xml | 2 +- test-spring-boot/pom.xml | 2 +- 9 files changed, 218 insertions(+), 125 deletions(-) diff --git a/README.md b/README.md index 39d8614..fc7d1cb 100644 --- a/README.md +++ b/README.md @@ -1,26 +1,17 @@ # lc-spring-data-r2dbc -[![Maven Central](https://img.shields.io/maven-central/v/net.lecousin.reactive-data-relational/core.svg)](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22net.lecousin.reactive-data-relational%22%20AND%20a%3A%22core%22) -[![Javadoc](https://img.shields.io/badge/javadoc-0.9.0-brightgreen.svg)](https://www.javadoc.io/doc/net.lecousin.reactive-data-relational/core/0.9.0) -![Build status](https://github.com/lecousin/lc-spring-data-r2dbc/actions/workflows/maven.yml/badge.svg?branch=master) +   +   + +
+   +   +   +   + -[![Codecov](https://codecov.io/gh/lecousin/lc-spring-data-r2dbc/branch/master/graph/badge.svg)](https://codecov.io/gh/lecousin/lc-spring-data-r2dbc/branch/master) -[![Coverage](https://sonarcloud.io/api/project_badges/measure?project=lecousin_lc-spring-data-r2dbc&metric=coverage)](https://sonarcloud.io/summary/new_code?id=lecousin_lc-spring-data-r2dbc) -[![Bugs](https://sonarcloud.io/api/project_badges/measure?project=lecousin_lc-spring-data-r2dbc&metric=bugs)](https://sonarcloud.io/summary/new_code?id=lecousin_lc-spring-data-r2dbc) -[![Vulnerabilities](https://sonarcloud.io/api/project_badges/measure?project=lecousin_lc-spring-data-r2dbc&metric=vulnerabilities)](https://sonarcloud.io/summary/new_code?id=lecousin_lc-spring-data-r2dbc) -[![Code Smells](https://sonarcloud.io/api/project_badges/measure?project=lecousin_lc-spring-data-r2dbc&metric=code_smells)](https://sonarcloud.io/summary/new_code?id=lecousin_lc-spring-data-r2dbc) -The goal this library is to provide basic ORM features not covered by [Spring Data R2DBC](https://github.com/spring-projects/spring-data-r2dbc). - -Spring Data R2DBC states that -> This is NOT an ORM - -> it does NOT offer caching, lazy loading, write behind or many other features of ORM frameworks. This makes Spring Data R2DBC a simple, limited, opinionated object mapper - -In another hand, [Hibernate Reactive](https://github.com/hibernate/hibernate-reactive) is not integrated with Spring Data. - -Waiting for a full ORM (like Hibernate), providing reactive streams to access to a relational database, and being integrated with Spring Data (with repositories...), -this library aims at providing the most useful features that are really missing from Spring Data R2DBC and that was provided by Spring Data JPA. +The goal this library is to provide basic ORM features not covered by Spring Data R2DBC (now part of [Spring Data Relational](https://github.com/spring-projects/spring-data-relational) project). ## Features @@ -43,21 +34,65 @@ Features are detailed with examples in the [wiki section](https://github.com/lec - Postgres - MySql -## Dependencies - - - Spring Boot (org.springframework.boot:spring-boot-starter-data-r2dbc) version 2.6.6, Latest version: ![Maven Central](https://img.shields.io/maven-central/v/org.springframework.boot/spring-boot-starter-data-r2dbc.svg) - - commons-lang3 version 3.12.0, Latest version: ![Maven Central](https://img.shields.io/maven-central/v/org.apache.commons/commons-lang3.svg) - - javassist version 3.28.0-GA, Latest version: ![Maven Central](https://img.shields.io/maven-central/v/org.javassist/javassist.svg) - - - H2 (io.r2dbc:r2dbc-h2) version 0.9.1.RELEASE, Latest version: ![Maven Central](https://img.shields.io/maven-central/v/io.r2dbc/r2dbc-h2.svg) - - MySql (dev.miku:r2dbc-mysql) version 0.8.2.RELEASE, Latest version: ![Maven Central](https://img.shields.io/maven-central/v/dev.miku/r2dbc-mysql.svg) - - Postgres (org.postgresql:r2dbc-postgresql) version 0.9.1.RELEASE, Latest version: ![Maven Central](https://img.shields.io/maven-central/v/org.postgresql/r2dbc-postgresql.svg) +## Dependencies version + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
DependencygroupIdartifactIdversionLatest version
Spring Bootorg.springframework.bootspring-boot-starter-data-r2dbc2.6.6
Appache Commons Langorg.apache.commonscommons-lang33.12.0
Javassistorg.javassistjavassist3.28.0-GA
H2 driverio.r2dbcr2dbc-h20.9.1.RELEASE
MySql driverdev.mikur2dbc-mysql0.8.2.RELEASE
PostgreSQL driverorg.postgresqlr2dbc-postgresql0.9.1.RELEASE
# Configuration ## Dependency configuration -Add the dependency to your project, depending on your database: +Add the dependency to your project, depending on your database (you may add several if you are using multiple databases in your project): ### H2 @@ -66,13 +101,13 @@ Maven net.lecousin.reactive-data-relational h2 - 0.9.0 + 0.10.0 ``` Gradle ```groovy -implementation group: 'net.lecousin.reactive-data-relational', name: 'h2', version: '0.9.0' +implementation group: 'net.lecousin.reactive-data-relational', name: 'h2', version: '0.10.0' ``` ### Postgres @@ -82,13 +117,13 @@ Maven net.lecousin.reactive-data-relational postgres - 0.9.0 + 0.10.0 ``` Gradle ```groovy -implementation group: 'net.lecousin.reactive-data-relational', name: 'postgres', version: '0.9.0' +implementation group: 'net.lecousin.reactive-data-relational', name: 'postgres', version: '0.10.0' ``` ### MySql @@ -98,13 +133,13 @@ Maven net.lecousin.reactive-data-relational mysql - 0.9.0 + 0.10.0 ``` Gradle ```groovy -implementation group: 'net.lecousin.reactive-data-relational', name: 'mysql', version: '0.9.0' +implementation group: 'net.lecousin.reactive-data-relational', name: 'mysql', version: '0.10.0' ``` ## Spring Boot configuration @@ -112,12 +147,14 @@ implementation group: 'net.lecousin.reactive-data-relational', name: 'mysql', ve In your Spring Boot application class, you need to: - add `@EnableR2dbcRepositories(repositoryFactoryBeanClass = LcR2dbcRepositoryFactoryBean.class)` - launch the initializer `LcReactiveDataRelationalInitializer.init()` that will add functionalities to your entity classes, before your application starts. This step **MUST** be done before Spring starts to ensure no entity class is loaded yet in the JVM. +- configure your database Example: ```java @SpringBootApplication @EnableR2dbcRepositories(repositoryFactoryBeanClass = LcR2dbcRepositoryFactoryBean.class) +@Import(PostgresConfiguration.class) // here you can change depending on the database you are using public class MyApp { public static void main(String[] args) { @@ -128,21 +165,12 @@ public class MyApp { } ``` -The last step is to provide the R2DBC configuration with the connection to the database. Depending on the database type, you can use one of this configuration class: +The `@Import` annotation is used when using a single database connection, and your connection is configured through application properties (`application.properties` or `application.yml`). Depending on your database, you can use one of this configuration class: - `net.lecousin.reactive.data.relational.h2.H2Configuration` - `net.lecousin.reactive.data.relational.mysql.MySqlConfiguration` - `net.lecousin.reactive.data.relational.postgres.PostgresConfiguration` -### Using application properties - -If you configure the connection using application properties, you just have to import the configuration class in your application class. -Example for H2: - -```java -@Import(H2Configuration.class) -``` - -And configure the connection in application.properties or application.yml, using Spring R2DBC normal configuration: +Finally, configure how to connect to the database using Spring R2DBC normal configuration, here is an example of application.yml file: ```yaml spring: @@ -151,14 +179,11 @@ spring: url: r2dbc:h2:mem:///testdb;DB_CLOSE_DELAY=-1; ``` -An example of a basic Spring Boot application is available [here](https://github.com/lecousin/lc-spring-data-r2dbc/tree/master/test-spring-boot) - ### Using custom connection factory -Another way is to extend the configuration class to provide your own ConnectionFactory - -Example for H2 in-memory database: - +If you want to configure the connection programmatically instead of using application properties, +instead of using `@Import` annotation like in the previous example, you can extend the configuration class to provide your own `ConnectionFactory`: + ```java import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; @@ -184,33 +209,9 @@ public class H2TestConfiguration extends H2Configuration { } ``` -### Startup faster by configuring your entities in lc-reactive-data-relational.yaml - -By default, when calling `LcReactiveDataRelationalInitializer.init()`, all classes present in the class path are analyzed to find entity classes. -This can take some time especially if you have many libraries in your class path. - -To avoid this, and startup faster your application, you can declare the list of entity classes in a YAML resource file `lc-reactive-data-relational.yaml` (similar to file `persistence.xml` for JPA). -The classes are declared under the name `entities`, each level can declare a package, then leaf names are classes. For example: - -```yaml -entities: - - net.lecousin.reactive.data.relational.test: - - simplemodel: - - BooleanTypes - - CharacterTypes - - onetoonemodel: - - MyEntity1 - - MySubEntity1 - - onetomanymodel: - - RootEntity - - SubEntity - - SubEntity2 - - SubEntity3 -``` - ### Multiple databases -If you need to connect to multiple databases, the configuration is different. You need to create a `@Configuration` class for each database connection, extending class `LcR2dbcEntityOperationsBuilder`. Instead of declaring `@EnableR2dbcRepositories` on your application, you will declare it to each configuration class. +If you need to connect to multiple databases, the configuration is different. You need to create a `@Configuration` class for each database connection, extending class `LcR2dbcEntityOperationsBuilder`. Instead of declaring `@EnableR2dbcRepositories` directly on your application class, you will declare it to each configuration class. Here is an example of such a configuration class: @@ -219,12 +220,14 @@ Here is an example of such a configuration class: @EnableR2dbcRepositories(repositoryFactoryBeanClass = LcR2dbcRepositoryFactoryBean.class, basePackages = "com.example.book.dao.repository", entityOperationsRef = "bookOperations") public class BookConfig extends LcR2dbcEntityOperationsBuilder { + /** Connection factory. */ @Bean @Qualifier("bookDatabaseConnectionFactory") public ConnectionFactory bookDatabaseConnectionFactory(@Value("${database.book}") String databaseUrl) { return ConnectionFactories.get(databaseUrl); } + /** Entity operations bean. */ @Bean @Qualifier("bookOperations") public LcR2dbcEntityTemplate bookOperations(@Qualifier("bookDatabaseConnectionFactory") ConnectionFactory connectionFactory) { @@ -235,50 +238,107 @@ public class BookConfig extends LcR2dbcEntityOperationsBuilder { ``` - define a bean to create a `ConnectionFactory` (here we get a url from the application configuration, but you can create it in another way) -- define a bean `LcR2dbcEntityTemplate` with the connection factory +- define a bean `LcR2dbcEntityTemplate` with the connection factory as argument - add the annotation `@EnableR2dbcRepositories` with the packages containing the repositories that will use this database, and the attribute `entityOperationsRef` set to the qualifier of the `LcR2dbcEntityTemplate` bean A complete example illustrating a Spring Boot application connecting to different databases is available in the repository [lc-spring-data-r2dbc-sample](https://github.com/lecousin/lc-spring-data-r2dbc-sample). + +### Application startup time + +By default, when calling `LcReactiveDataRelationalInitializer.init()`, all classes present in the class path are analyzed to find entity classes. +This can take some time especially if you have many libraries in your class path. + +This behavior allows no additional configuration, which make it easier during development. However for production, if it is important for your application to startup faster +(for example a microservice), you can declare the list of entity classes in a YAML resource file `lc-reactive-data-relational.yaml` (similar to file `persistence.xml` for JPA). +The classes are declared under the name `entities`, each level can declare a package, then leaf names are classes. For example: + +```yaml +entities: + - net.lecousin.reactive.data.relational.test: + - simplemodel: + - BooleanTypes + - CharacterTypes + - onetoonemodel: + - MyEntity1 + - MySubEntity1 + - onetomanymodel: + - RootEntity + - SubEntity + - SubEntity2 + - SubEntity3 +``` + +The presence of this file will disable class path analysis. Note that you may have several resource files `lc-reactive-data-relational.yaml` in your class path (for example if several modules are providing entities), and all will be processed. + ## JUnit 5 For your tests, using JUnit 5, you can use the annotation `@DataR2dbcTest` provided by Spring, and add the annotation `@EnableR2dbcRepositories(repositoryFactoryBeanClass = LcR2dbcRepositoryFactoryBean.class)`. -In order to make sure the initializer is launched before any test class is loaded, add the following maven dependency, which will automatically call `LcReactiveDataRelationalInitializer.init()` to load your `lc-reactive-data-relational.yaml` configuration file during JUnit startup: +In order to make sure the initializer is launched before any test class is loaded, add the following maven dependency, which will automatically call `LcReactiveDataRelationalInitializer.init()` during JUnit startup: ```xml net.lecousin.reactive-data-relational test-junit-5 - 0.9.0 + 0.10.0 test ``` # Usage +A more complete guide is available in the [wiki section](https://github.com/lecousin/lc-spring-data-r2dbc/wiki), here is an overview. + ## Entity class -You can declare your entity classes in the same way as Spring Data R2DBC (with annotations `@Table` and `@Column`). -In addition, here are the following supported options: -- Annotation `org.springframework.data.annotation.Id` can be used to indicate a primary key -- Annotation `net.lecousin.reactive.data.relational.annotations.CompositeId` can be used to indicate properties to use as a unique key (when no @Id property is present) -- Annotation `net.lecousin.reactive.data.relational.annotations.GeneratedValue` can be used to indicate the value should be generated by the database (auto increment, using a sequence, or generating a random UUID) -- Annotation `org.springframework.data.annotation.Version` can be used for optimistic lock -- Annotation `net.lecousin.reactive.data.relational.annotations.ForeignKey` can be used to indicate a link. The cascade behavior can be specified using the attributes `optional`, `onForeignDeleted`, and `cascadeDelete`. A foreign key cannot be used on a collection type. -- Annotation `net.lecousin.reactive.data.relational.annotations.ForeignTable` is the other side of the foreign key. It does not store anything in the database -but indicates the link to another class. A foreign table can be used on a collection type for a one to many link. -- Annotation `net.lecousin.reactive.data.relational.annotations.JoinTable` can be used for a many to many (n-n) relationship when no additional field is required +Your entity classes are declared using the Spring Data R2DBC annotations `@Table` and `@Column`: + +```java +@Table +public class MyEntity { + @Column + private String myText; +} +``` + +In addition, here are the following supported annotations: +- `org.springframework.data.annotation.Id` indicates a primary key +- `net.lecousin.reactive.data.relational.annotations.CompositeId` indicates properties to use as a unique key (cannot be used together with @Id) +- `net.lecousin.reactive.data.relational.annotations.GeneratedValue` indicates a value that should be generated by the database (auto increment, using a sequence, or generating a random UUID) +- `org.springframework.data.annotation.Version` is used for optimistic lock +- `net.lecousin.reactive.data.relational.annotations.ForeignKey` indicates a link with a foreign key stored in the table. The cascade behavior can be specified using the attributes `optional`, `onForeignDeleted`, and `cascadeDelete`. The type of the attribute in the class will be the linked entity class (not the foreign key itself). A foreign key cannot be used on a collection type. +- `net.lecousin.reactive.data.relational.annotations.ForeignTable` is the other side of the foreign key. It does not store anything in the table +but indicates the link to another class to use with joins or lazy loading. A foreign table can be used on a collection type for a one to many link. +- `net.lecousin.reactive.data.relational.annotations.JoinTable` can be used for a many to many (n-n) relationship when no additional field is required on the join table. The join table will be automatically created with the 2 foreign keys. This allows to join directly between 2 tables with many to many relationship in a transparent manner. -- Annotations `org.springframework.data.annotation.CreatedDate` and `org.springframework.data.annotation.LastModifiedDate` can be used to automatically store respectively the creation date and modification date. It can be used with a column of type `Long`, `Instant`, `LocalDate`, `LocalTime` or `LocalDateTime`. `OffsetTime` and `ZonedDateTime` can be used except for MySql that does not support columns with timezone information. -- Annotation `net.lecousin.reactive.data.relational.annotations.ColumnDefinition` can be used to specify constraints for schema generation. +- `org.springframework.data.annotation.CreatedDate` and `org.springframework.data.annotation.LastModifiedDate` can be used to automatically store respectively the creation date and modification date. It can be used with a column of type `Long`, `Instant`, `LocalDate`, `LocalTime` or `LocalDateTime`. `OffsetTime` and `ZonedDateTime` can be used except for MySql that does not support columns with timezone information. +- `net.lecousin.reactive.data.relational.annotations.ColumnDefinition` allows to specify constraints for schema generation. Additional methods may be declared in an Entity class to handle lazy loading, documented in the [dedicated section](#lazy-loading). -## Important note for Java > 11 +Example: + +```java +@Table +public class MyEntity { + @Id @GeneratedValue + private Long id; + + @ColumnDefinition(max = 100, nullable = true) + private String someOptionalText; + + @ForeignKey(optional = false) + private MyOtherEntity linkedEntity; + + [...] +} +``` + +### Important note for Java > 11 -If you use a Java version > 11, the JVM does not allow to modify classes in another package, and this library won't be able to enhance your classes to provide all the functionalities. As a workaround for now, you must explicitly allow it by placing an empty interface named `AllowEnhancer` in every package containing entities. +If you use a Java version > 11, the JVM does not allow to modify classes in another package, and this library won't be able to enhance your classes to provide all the functionalities. As a workaround for now, you must explicitly allow it by placing an empty interface named `AllowEnhancer` in **every package containing entities**. You can just create it like this: @@ -295,7 +355,9 @@ The select methods (findXXX) do not perform any join by default, but allow lazy ## Lazy loading -Spring Repository methods to find entities (`find...`) do not perform any join. If your class has links to other classes, they won't be loaded, however you can use lazy loading. +Spring Repository methods to find entities (`find...`) do not perform any join. If your class has links to other classes, they won't be loaded, however this library supports +_lazy loading_ +which will load the linked entities on demand. Lazy loading is done by declaring additional methods on your entity class, with a default body. **The body will be automatically replaced with the correct code**. @@ -332,26 +394,26 @@ public class MyEntity { this.links = links; } - /* Lazy loading attributes */ + /* Lazy loading methods. */ public Mono lazyGetOther() { - return null; // you can just return null, the body will be automatically generated by the enhancer + return null; // you can just return null, the correct code will be automatically generated. } public Flux lazyGetLinks() { - return null; // you can just return null, the body will be automatically generated by the enhancer + return null; // you can just return null, the correct code will be automatically generated. } - /* Lazy loading of this MyEntity */ + /* Lazy loading of this MyEntity (this class). */ - /** @return true if this MyEntity is loaded from database. */ + /** @return true if this MyEntity is loaded from database, false if only the @Id is available. */ public boolean entityLoaded() { - return false; // you can just return false, the body will be automatically generated by the enhancer + return false; // you can just return false, the correct code will be automatically generated. } /** Ensure this MyEntity is loaded from database before to use. */ - public Mono loadEntity() { - return null; // you can just return null, the body will be automatically generated by the enhancer + public Mono loadEntity() { + return null; // you can just return null, the correct code will be automatically generated. } } @@ -360,28 +422,29 @@ public class MyEntity { As illustrated by this example, you can define the following methods to handle lazy loading on an entity class: - methods `public Mono lazyGetXXX() { return null; }` to get a loaded entity on a @ForeignKey or @ForeignTable field XXX. - For collections, the same method can be declared with a `Flux`: `public Flux lazyGetXXX() { return null; }` to get entities from a collection with @ForeignTable -- a method `public boolean entityLoaded() { return false; }` to know if the entity instance is loaded or not. -- a method `public Mono loadEntity() { return null; }` where T is your class, to load the entity. If the entity is already loaded, `Mono.just(this)`is returned. +- a method `public boolean entityLoaded() { return false; }` to know if the entity instance is fully loaded or not. +- a method `public Mono loadEntity() { return null; }` where T is your entity class, to load the instance from the database. If the entity is already loaded, `Mono.just(this)` is returned (no redundant database query on each call). -The body of those methods will be automatically generated during enhancement (when calling `LcReactiveDataRelationalInitializer.init()` at startup), so -you can just leave it as simple as possible. +The body of those methods will be automatically generated during enhancement (when calling `LcReactiveDataRelationalInitializer.init()` at startup), that's why you can just return null or false in your code. Using methods `lazyGetXXX` or `loadEntity` allow to ensure the entity or attributes are loaded. If already loaded, nothing is done, else a database request is done. That's why -a `Mono` or `Flux` is returned, so you can perform your actions in a non-blocking mode even if a database request needs to be executed before. +a `Mono` or `Flux` is returned, so you can perform your actions in a non-blocking mode even if a database request needs to be executed. In case an entity or attribute is not loaded, and you are not using those methods, here is the behavior you can expect: - On a @ForeignKey attribute, a class will be instantiated with the foreign key as id, all other attributes are not set. That means your attribute is not null (using classical getter) -but all its attributes are null except its primary key which is pre-filled. -- On a @ForeignTable attribute, the attribute will be null. +but all its attributes are null except its primary key which is pre-filled. In other words you can get the foreign key value without needing to load the full entity. +- On a @ForeignTable attribute, the attribute will be null. The reason is that the database table of your entity does not store any information about this link (unlike when having a foreign key). -Note that all those methods are completely optional. If you define a method the enhancer will generate its code, else the method will just not be available. +Note that all those methods are completely optional. If you define some of those methods, the enhancer will generate the corresponding code, else the method will just not be available. -## Entity graph +## Select with joins -Lazy loading is often not a good solution in term of performance, and we may want to load a graph of entities in a single database request using joins. +Lazy loading is often not a good solution in term of performance, and we may want to load linked entities in a single database request using joins. In JPA, entity graphs are used to specify the attributes to fetch automatically. This library does not provide similar way to indicate which links need to be loaded, -but you can use the class `SelectQuery` in your repositories to perform more complex searches and load linked entities. +but you can use the class `SelectQuery` to perform more complex searches and load linked entities. + +The `SelectQuery` can be used anywhere, including in your Spring Data repositories as default method (note that default methods in Spring Data repositories is not supported with Kotlin). For example: @@ -440,8 +503,38 @@ public interface RootEntityRepository extends LcR2dbcRepository net.lecousin.reactive-data-relational parent - 0.9.0 + 0.10.0 core diff --git a/h2/pom.xml b/h2/pom.xml index 35b651e..7942695 100644 --- a/h2/pom.xml +++ b/h2/pom.xml @@ -3,7 +3,7 @@ net.lecousin.reactive-data-relational parent - 0.9.0 + 0.10.0 h2 diff --git a/jacoco-report-aggregate/pom.xml b/jacoco-report-aggregate/pom.xml index bc641b7..0d55da7 100644 --- a/jacoco-report-aggregate/pom.xml +++ b/jacoco-report-aggregate/pom.xml @@ -3,7 +3,7 @@ net.lecousin.reactive-data-relational parent - 0.9.0 + 0.10.0 jacoco-report-aggregate pom diff --git a/mysql/pom.xml b/mysql/pom.xml index 855aa25..817e93b 100644 --- a/mysql/pom.xml +++ b/mysql/pom.xml @@ -3,7 +3,7 @@ net.lecousin.reactive-data-relational parent - 0.9.0 + 0.10.0 mysql diff --git a/pom.xml b/pom.xml index e1f002e..1c99b8e 100644 --- a/pom.xml +++ b/pom.xml @@ -2,7 +2,7 @@ 4.0.0 net.lecousin.reactive-data-relational parent - 0.9.0 + 0.10.0 pom net.lecousin.reactive-data-relational aka lc-spring-data-r2dbc diff --git a/postgres/pom.xml b/postgres/pom.xml index b564f59..dbd2968 100644 --- a/postgres/pom.xml +++ b/postgres/pom.xml @@ -3,7 +3,7 @@ net.lecousin.reactive-data-relational parent - 0.9.0 + 0.10.0 postgres diff --git a/test-junit-5/pom.xml b/test-junit-5/pom.xml index 559bc08..b888907 100644 --- a/test-junit-5/pom.xml +++ b/test-junit-5/pom.xml @@ -3,7 +3,7 @@ net.lecousin.reactive-data-relational parent - 0.9.0 + 0.10.0 test-junit-5 diff --git a/test-spring-boot/pom.xml b/test-spring-boot/pom.xml index a8e8dc3..7039b89 100644 --- a/test-spring-boot/pom.xml +++ b/test-spring-boot/pom.xml @@ -3,7 +3,7 @@ net.lecousin.reactive-data-relational parent - 0.9.0 + 0.10.0 test-spring-boot