diff --git a/README.md b/README.md index 451c7a2a..3f9da97b 100644 --- a/README.md +++ b/README.md @@ -9,6 +9,7 @@ This repository includes the following examples: * [example-sql-annotation](example-sql-annotation) - Uses SQL annotations to store SQL templates. * [example-criteria](example-criteria) - Uses the Criteria API. * [example-jpms](example-jpms) - Uses the Java Platform Module System (JPMS). +* [example-geometric-type](example-geometric-type) - Uses Geometric types of PostgreSQL. ER diagram --------------------- diff --git a/common/build.gradle.kts b/common/build.gradle.kts index 06f455e7..3e7f99a1 100644 --- a/common/build.gradle.kts +++ b/common/build.gradle.kts @@ -9,5 +9,7 @@ tasks { mapOf( "doma.domain.converters" to "example.common.domain.DomainConverterProvider", ) + // If you are not using Eclipse, you can simply write the above code as follows without using aptOptions; + // options.compilerArgs.add("-Adoma.domain.converters=example.common.domain.DomainConverterProvider") } } diff --git a/example-geometric-type/.gitignore b/example-geometric-type/.gitignore new file mode 100644 index 00000000..b01581f4 --- /dev/null +++ b/example-geometric-type/.gitignore @@ -0,0 +1,13 @@ +.classpath +.factorypath +.project +.settings +/.apt_generated +/bin +/build +.gradle +.idea +out +/.apt_generated_tests/ +.vscode +.sdkmanrc diff --git a/example-geometric-type/build.gradle.kts b/example-geometric-type/build.gradle.kts new file mode 100644 index 00000000..84743b8d --- /dev/null +++ b/example-geometric-type/build.gradle.kts @@ -0,0 +1,21 @@ +plugins { + id("java") +} + +dependencies { + implementation(libs.jdbc.postgresql) + testImplementation(platform(libs.testcontainers.bom)) + testImplementation(libs.testcontainers.postgresql) +} + +tasks { + compileJava { + val aptOptions = extensions.getByType() + aptOptions.processorArgs = + mapOf( + "doma.domain.converters" to "example.geometric.type.domain.DomainConverterProvider", + ) + // If you are not using Eclipse, you can simply write the above code as follows without using aptOptions; + // options.compilerArgs.add("-Adoma.domain.converters=example.geometric.type.domain.DomainConverterProvider") + } +} diff --git a/example-geometric-type/src/main/java/example/geometric/type/dao/CircleZoneDao.java b/example-geometric-type/src/main/java/example/geometric/type/dao/CircleZoneDao.java new file mode 100644 index 00000000..115ca97f --- /dev/null +++ b/example-geometric-type/src/main/java/example/geometric/type/dao/CircleZoneDao.java @@ -0,0 +1,18 @@ +package example.geometric.type.dao; + +import example.geometric.type.entity.CircleZone; +import org.seasar.doma.Dao; +import org.seasar.doma.Insert; +import org.seasar.doma.Select; +import org.seasar.doma.Sql; + +@Dao +public interface CircleZoneDao { + + @Sql("select /*%expand */* from circle_zone where id = /* id */0") + @Select + CircleZone selectById(Integer id); + + @Insert + int insert(CircleZone circleZone); +} diff --git a/example-geometric-type/src/main/java/example/geometric/type/dao/LandmarkDao.java b/example-geometric-type/src/main/java/example/geometric/type/dao/LandmarkDao.java new file mode 100644 index 00000000..5ec7b3a3 --- /dev/null +++ b/example-geometric-type/src/main/java/example/geometric/type/dao/LandmarkDao.java @@ -0,0 +1,18 @@ +package example.geometric.type.dao; + +import example.geometric.type.entity.Landmark; +import org.seasar.doma.Dao; +import org.seasar.doma.Insert; +import org.seasar.doma.Select; +import org.seasar.doma.Sql; + +@Dao +public interface LandmarkDao { + + @Sql("select /*%expand */* from landmark where id = /* id */0") + @Select + Landmark selectById(Integer id); + + @Insert + int insert(Landmark landmark); +} diff --git a/example-geometric-type/src/main/java/example/geometric/type/dao/ScriptDao.java b/example-geometric-type/src/main/java/example/geometric/type/dao/ScriptDao.java new file mode 100644 index 00000000..7ec5b8e0 --- /dev/null +++ b/example-geometric-type/src/main/java/example/geometric/type/dao/ScriptDao.java @@ -0,0 +1,14 @@ +package example.geometric.type.dao; + +import org.seasar.doma.Dao; +import org.seasar.doma.Script; + +@Dao +public interface ScriptDao { + + @Script + void create(); + + @Script + void drop(); +} diff --git a/example-geometric-type/src/main/java/example/geometric/type/domain/Circle.java b/example-geometric-type/src/main/java/example/geometric/type/domain/Circle.java new file mode 100644 index 00000000..8f628251 --- /dev/null +++ b/example-geometric-type/src/main/java/example/geometric/type/domain/Circle.java @@ -0,0 +1,3 @@ +package example.geometric.type.domain; + +public record Circle(Point center, double radius) {} diff --git a/example-geometric-type/src/main/java/example/geometric/type/domain/CircleTypeProvider.java b/example-geometric-type/src/main/java/example/geometric/type/domain/CircleTypeProvider.java new file mode 100644 index 00000000..c2a65398 --- /dev/null +++ b/example-geometric-type/src/main/java/example/geometric/type/domain/CircleTypeProvider.java @@ -0,0 +1,64 @@ +package example.geometric.type.domain; + +import java.sql.CallableStatement; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.sql.Types; +import org.postgresql.geometric.PGcircle; +import org.postgresql.geometric.PGpoint; +import org.seasar.doma.ExternalDomain; +import org.seasar.doma.jdbc.domain.JdbcTypeProvider; +import org.seasar.doma.jdbc.type.AbstractJdbcType; +import org.seasar.doma.jdbc.type.JdbcType; + +@ExternalDomain +public class CircleTypeProvider extends JdbcTypeProvider { + + private static final CircleType circleType = new CircleType(); + + @Override + public JdbcType getJdbcType() { + return circleType; + } +} + +class CircleType extends AbstractJdbcType { + + protected CircleType() { + super(Types.OTHER); + } + + @Override + protected Circle doGetValue(ResultSet resultSet, int index) throws SQLException { + PGcircle c = resultSet.getObject(index, PGcircle.class); + return toCircle(c); + } + + @Override + protected void doSetValue(PreparedStatement preparedStatement, int index, Circle value) + throws SQLException { + PGpoint p = new PGpoint(value.center().x(), value.center().y()); + PGcircle c = new PGcircle(p, value.radius()); + preparedStatement.setObject(index, c); + } + + @Override + protected Circle doGetValue(CallableStatement callableStatement, int index) throws SQLException { + PGcircle c = callableStatement.getObject(index, PGcircle.class); + return toCircle(c); + } + + @Override + protected String doConvertToLogFormat(Circle value) { + return value.toString(); + } + + static Circle toCircle(PGcircle c) { + if (c == null) { + return null; + } + Point center = PointType.toPoint(c.center); + return new Circle(center, c.radius); + } +} diff --git a/example-geometric-type/src/main/java/example/geometric/type/domain/DomainConverterProvider.java b/example-geometric-type/src/main/java/example/geometric/type/domain/DomainConverterProvider.java new file mode 100644 index 00000000..3b30d7df --- /dev/null +++ b/example-geometric-type/src/main/java/example/geometric/type/domain/DomainConverterProvider.java @@ -0,0 +1,6 @@ +package example.geometric.type.domain; + +import org.seasar.doma.DomainConverters; + +@DomainConverters({CircleTypeProvider.class, PointTypeProvider.class}) +public class DomainConverterProvider {} diff --git a/example-geometric-type/src/main/java/example/geometric/type/domain/Point.java b/example-geometric-type/src/main/java/example/geometric/type/domain/Point.java new file mode 100644 index 00000000..9b0cb09b --- /dev/null +++ b/example-geometric-type/src/main/java/example/geometric/type/domain/Point.java @@ -0,0 +1,3 @@ +package example.geometric.type.domain; + +public record Point(double x, double y) {} diff --git a/example-geometric-type/src/main/java/example/geometric/type/domain/PointTypeProvider.java b/example-geometric-type/src/main/java/example/geometric/type/domain/PointTypeProvider.java new file mode 100644 index 00000000..f9e9f2c6 --- /dev/null +++ b/example-geometric-type/src/main/java/example/geometric/type/domain/PointTypeProvider.java @@ -0,0 +1,61 @@ +package example.geometric.type.domain; + +import java.sql.CallableStatement; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.sql.Types; +import org.postgresql.geometric.PGpoint; +import org.seasar.doma.ExternalDomain; +import org.seasar.doma.jdbc.domain.JdbcTypeProvider; +import org.seasar.doma.jdbc.type.AbstractJdbcType; +import org.seasar.doma.jdbc.type.JdbcType; + +@ExternalDomain +public class PointTypeProvider extends JdbcTypeProvider { + + private static final PointType pointType = new PointType(); + + @Override + public JdbcType getJdbcType() { + return pointType; + } +} + +class PointType extends AbstractJdbcType { + + protected PointType() { + super(Types.OTHER); + } + + @Override + protected Point doGetValue(ResultSet resultSet, int index) throws SQLException { + PGpoint p = resultSet.getObject(index, PGpoint.class); + return toPoint(p); + } + + @Override + protected void doSetValue(PreparedStatement preparedStatement, int index, Point value) + throws SQLException { + PGpoint p = new PGpoint(value.x(), value.y()); + preparedStatement.setObject(index, p); + } + + @Override + protected Point doGetValue(CallableStatement callableStatement, int index) throws SQLException { + PGpoint p = callableStatement.getObject(index, PGpoint.class); + return toPoint(p); + } + + @Override + protected String doConvertToLogFormat(Point value) { + return value.toString(); + } + + static Point toPoint(PGpoint p) { + if (p == null) { + return null; + } + return new Point(p.x, p.y); + } +} diff --git a/example-geometric-type/src/main/java/example/geometric/type/entity/CircleZone.java b/example-geometric-type/src/main/java/example/geometric/type/entity/CircleZone.java new file mode 100644 index 00000000..a2ee8053 --- /dev/null +++ b/example-geometric-type/src/main/java/example/geometric/type/entity/CircleZone.java @@ -0,0 +1,18 @@ +package example.geometric.type.entity; + +import example.geometric.type.domain.Circle; +import org.seasar.doma.Entity; +import org.seasar.doma.Id; +import org.seasar.doma.Metamodel; + +@Entity(metamodel = @Metamodel) +public class CircleZone { + @Id public Integer id; + public String name; + public Circle boundary; + + @Override + public String toString() { + return "CircleZone [id=" + id + ", name=" + name + ", boundary=" + boundary + "]"; + } +} diff --git a/example-geometric-type/src/main/java/example/geometric/type/entity/Landmark.java b/example-geometric-type/src/main/java/example/geometric/type/entity/Landmark.java new file mode 100644 index 00000000..1298e3f6 --- /dev/null +++ b/example-geometric-type/src/main/java/example/geometric/type/entity/Landmark.java @@ -0,0 +1,18 @@ +package example.geometric.type.entity; + +import example.geometric.type.domain.Point; +import org.seasar.doma.Entity; +import org.seasar.doma.Id; +import org.seasar.doma.Metamodel; + +@Entity(metamodel = @Metamodel) +public class Landmark { + @Id public Integer id; + public String name; + public Point location; + + @Override + public String toString() { + return "Landmark [id=" + id + ", name=" + name + ", location=" + location + "]"; + } +} diff --git a/example-geometric-type/src/main/resources/META-INF/example/geometric/type/dao/ScriptDao/create.script b/example-geometric-type/src/main/resources/META-INF/example/geometric/type/dao/ScriptDao/create.script new file mode 100644 index 00000000..86253b6d --- /dev/null +++ b/example-geometric-type/src/main/resources/META-INF/example/geometric/type/dao/ScriptDao/create.script @@ -0,0 +1,11 @@ +CREATE TABLE landmark ( + id INTEGER PRIMARY KEY, + name TEXT NOT NULL, + location POINT NOT NULL +); + +CREATE TABLE circle_zone ( + id INTEGER PRIMARY KEY, + name TEXT NOT NULL, + boundary CIRCLE NOT NULL +); \ No newline at end of file diff --git a/example-geometric-type/src/main/resources/META-INF/example/geometric/type/dao/ScriptDao/drop.script b/example-geometric-type/src/main/resources/META-INF/example/geometric/type/dao/ScriptDao/drop.script new file mode 100644 index 00000000..d4fe213c --- /dev/null +++ b/example-geometric-type/src/main/resources/META-INF/example/geometric/type/dao/ScriptDao/drop.script @@ -0,0 +1,2 @@ +DROP TABLE landmark; +DROP TABLE circle_zone; diff --git a/example-geometric-type/src/test/java/example/geometric/type/CircleZoneTest.java b/example-geometric-type/src/test/java/example/geometric/type/CircleZoneTest.java new file mode 100644 index 00000000..d3434a98 --- /dev/null +++ b/example-geometric-type/src/test/java/example/geometric/type/CircleZoneTest.java @@ -0,0 +1,58 @@ +package example.geometric.type; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; + +import example.geometric.type.dao.CircleZoneDao; +import example.geometric.type.dao.CircleZoneDaoImpl; +import example.geometric.type.domain.Circle; +import example.geometric.type.domain.Point; +import example.geometric.type.entity.CircleZone; +import example.geometric.type.entity.CircleZone_; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.seasar.doma.jdbc.Config; +import org.seasar.doma.jdbc.criteria.QueryDsl; + +@ExtendWith(TestEnvironment.class) +public class CircleZoneTest { + + @Test + void testCircle_withSqlAnnotation(Config config) { + CircleZoneDao dao = new CircleZoneDaoImpl(config); + + CircleZone circleZone = new CircleZone(); + circleZone.id = 1; + circleZone.name = "Round Plaza"; + circleZone.boundary = new Circle(new Point(35.6804, 139.7690), 0.005); + + int count = dao.insert(circleZone); + assertEquals(1, count); + + CircleZone entity = dao.selectById(1); + assertNotNull(entity); + assertEquals(circleZone.id, entity.id); + assertEquals(circleZone.name, entity.name); + assertEquals(circleZone.boundary, entity.boundary); + } + + @Test + void testCircle_withCriteria(Config config) { + QueryDsl dsl = new QueryDsl(config); + CircleZone_ c = new CircleZone_(); + + CircleZone circleZone = new CircleZone(); + circleZone.id = 1; + circleZone.name = "Round Plaza"; + circleZone.boundary = new Circle(new Point(35.6804, 139.7690), 0.005); + + var result = dsl.insert(c).single(circleZone).execute(); + assertEquals(1, result.getCount()); + + CircleZone entity = dsl.from(c).where(wh -> wh.eq(c.id, 1)).fetchOne(); + assertNotNull(entity); + assertEquals(circleZone.id, entity.id); + assertEquals(circleZone.name, entity.name); + assertEquals(circleZone.boundary, entity.boundary); + } +} diff --git a/example-geometric-type/src/test/java/example/geometric/type/DbConfig.java b/example-geometric-type/src/test/java/example/geometric/type/DbConfig.java new file mode 100644 index 00000000..8006105b --- /dev/null +++ b/example-geometric-type/src/test/java/example/geometric/type/DbConfig.java @@ -0,0 +1,53 @@ +package example.geometric.type; + +import java.util.Objects; +import javax.sql.DataSource; +import org.seasar.doma.jdbc.Config; +import org.seasar.doma.jdbc.JdbcLogger; +import org.seasar.doma.jdbc.Naming; +import org.seasar.doma.jdbc.dialect.Dialect; +import org.seasar.doma.jdbc.tx.TransactionManager; + +public class DbConfig implements Config { + + private final Dialect dialect; + private final DataSource dataSource; + private final JdbcLogger jdbcLogger; + private final TransactionManager transactionManager; + + public DbConfig( + Dialect dialect, + DataSource dataSource, + JdbcLogger jdbcLogger, + TransactionManager transactionManager) { + this.dialect = Objects.requireNonNull(dialect); + this.dataSource = Objects.requireNonNull(dataSource); + this.jdbcLogger = Objects.requireNonNull(jdbcLogger); + this.transactionManager = Objects.requireNonNull(transactionManager); + } + + @Override + public JdbcLogger getJdbcLogger() { + return jdbcLogger; + } + + @Override + public Dialect getDialect() { + return dialect; + } + + @Override + public DataSource getDataSource() { + return dataSource; + } + + @Override + public TransactionManager getTransactionManager() { + return transactionManager; + } + + @Override + public Naming getNaming() { + return Naming.SNAKE_LOWER_CASE; + } +} diff --git a/example-geometric-type/src/test/java/example/geometric/type/LandmarkTest.java b/example-geometric-type/src/test/java/example/geometric/type/LandmarkTest.java new file mode 100644 index 00000000..0a4cc1b1 --- /dev/null +++ b/example-geometric-type/src/test/java/example/geometric/type/LandmarkTest.java @@ -0,0 +1,57 @@ +package example.geometric.type; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; + +import example.geometric.type.dao.LandmarkDao; +import example.geometric.type.dao.LandmarkDaoImpl; +import example.geometric.type.domain.Point; +import example.geometric.type.entity.Landmark; +import example.geometric.type.entity.Landmark_; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.seasar.doma.jdbc.Config; +import org.seasar.doma.jdbc.criteria.QueryDsl; + +@ExtendWith(TestEnvironment.class) +public class LandmarkTest { + + @Test + void testPoint_withSqlAnnotation(Config config) { + LandmarkDao dao = new LandmarkDaoImpl(config); + + Landmark landmark = new Landmark(); + landmark.id = 1; + landmark.name = "Tokyo Tower"; + landmark.location = new Point(35.6586, 139.7454); + + int count = dao.insert(landmark); + assertEquals(1, count); + + Landmark entity = dao.selectById(1); + assertNotNull(entity); + assertEquals(landmark.id, entity.id); + assertEquals(landmark.name, entity.name); + assertEquals(landmark.location, entity.location); + } + + @Test + void testPoint_withCriteria(Config config) { + QueryDsl dsl = new QueryDsl(config); + Landmark_ l = new Landmark_(); + + Landmark landmark = new Landmark(); + landmark.id = 1; + landmark.name = "Tokyo Tower"; + landmark.location = new Point(35.6586, 139.7454); + + var result = dsl.insert(l).single(landmark).execute(); + assertEquals(1, result.getCount()); + + Landmark entity = dsl.from(l).where(wh -> wh.eq(l.id, 1)).fetchOne(); + assertNotNull(entity); + assertEquals(landmark.id, entity.id); + assertEquals(landmark.name, entity.name); + assertEquals(landmark.location, entity.location); + } +} diff --git a/example-geometric-type/src/test/java/example/geometric/type/TestEnvironment.java b/example-geometric-type/src/test/java/example/geometric/type/TestEnvironment.java new file mode 100644 index 00000000..e4710600 --- /dev/null +++ b/example-geometric-type/src/test/java/example/geometric/type/TestEnvironment.java @@ -0,0 +1,70 @@ +package example.geometric.type; + +import example.geometric.type.dao.ScriptDao; +import example.geometric.type.dao.ScriptDaoImpl; +import org.junit.jupiter.api.extension.AfterAllCallback; +import org.junit.jupiter.api.extension.AfterTestExecutionCallback; +import org.junit.jupiter.api.extension.BeforeAllCallback; +import org.junit.jupiter.api.extension.BeforeTestExecutionCallback; +import org.junit.jupiter.api.extension.ExtensionContext; +import org.junit.jupiter.api.extension.ParameterContext; +import org.junit.jupiter.api.extension.ParameterResolver; +import org.seasar.doma.jdbc.JdbcLogger; +import org.seasar.doma.jdbc.dialect.Dialect; +import org.seasar.doma.jdbc.dialect.PostgresDialect; +import org.seasar.doma.jdbc.tx.LocalTransactionDataSource; +import org.seasar.doma.jdbc.tx.LocalTransactionManager; +import org.seasar.doma.slf4j.Slf4jJdbcLogger; + +public class TestEnvironment + implements BeforeAllCallback, + AfterAllCallback, + BeforeTestExecutionCallback, + AfterTestExecutionCallback, + ParameterResolver { + + private final LocalTransactionManager transactionManager; + private final DbConfig config; + private final ScriptDao dao; + + public TestEnvironment() { + Dialect dialect = new PostgresDialect(); + LocalTransactionDataSource dataSource = + new LocalTransactionDataSource( + "jdbc:tc:postgresql:12.20:///test?TC_DAEMON=true", "test", "test"); + JdbcLogger jdbcLogger = new Slf4jJdbcLogger(); + transactionManager = new LocalTransactionManager(dataSource, jdbcLogger); + config = new DbConfig(dialect, dataSource, jdbcLogger, transactionManager); + dao = new ScriptDaoImpl(config); + } + + @Override + public void beforeAll(ExtensionContext context) { + transactionManager.required(dao::create); + } + + @Override + public void afterAll(ExtensionContext context) { + transactionManager.required(dao::drop); + } + + @Override + public void beforeTestExecution(ExtensionContext context) { + transactionManager.getTransaction().begin(); + } + + @Override + public void afterTestExecution(ExtensionContext context) { + transactionManager.getTransaction().rollback(); + } + + public boolean supportsParameter( + ParameterContext parameterContext, ExtensionContext extensionContext) { + return parameterContext.getParameter().getType().isAssignableFrom(DbConfig.class); + } + + public Object resolveParameter( + ParameterContext parameterContext, ExtensionContext extensionContext) { + return config; + } +} diff --git a/example-jpms/build.gradle.kts b/example-jpms/build.gradle.kts index 37c88536..aedf8ac1 100644 --- a/example-jpms/build.gradle.kts +++ b/example-jpms/build.gradle.kts @@ -10,6 +10,8 @@ tasks { mapOf( "doma.domain.converters" to "example.jpms.domain.DomainConverterProvider", ) + // If you are not using Eclipse, you can simply write the above code as follows without using aptOptions; + // options.compilerArgs.add("-Adoma.domain.converters=example.jpms.domain.DomainConverterProvider") } } diff --git a/example-sql-annotation/build.gradle.kts b/example-sql-annotation/build.gradle.kts index 8b415dd6..05e4160e 100644 --- a/example-sql-annotation/build.gradle.kts +++ b/example-sql-annotation/build.gradle.kts @@ -9,6 +9,8 @@ tasks { mapOf( "doma.domain.converters" to "example.common.domain.DomainConverterProvider", ) + // If you are not using Eclipse, you can simply write the above code as follows without using aptOptions; + // options.compilerArgs.add("-Adoma.domain.converters=example.common.domain.DomainConverterProvider") } } diff --git a/example-sql-file/build.gradle.kts b/example-sql-file/build.gradle.kts index 8b415dd6..05e4160e 100644 --- a/example-sql-file/build.gradle.kts +++ b/example-sql-file/build.gradle.kts @@ -9,6 +9,8 @@ tasks { mapOf( "doma.domain.converters" to "example.common.domain.DomainConverterProvider", ) + // If you are not using Eclipse, you can simply write the above code as follows without using aptOptions; + // options.compilerArgs.add("-Adoma.domain.converters=example.common.domain.DomainConverterProvider") } } diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml index dffcb72a..8b4636ce 100644 --- a/gradle/libs.versions.toml +++ b/gradle/libs.versions.toml @@ -3,17 +3,21 @@ doma = "3.4.0" junit = "5.11.4" [libraries] -doma-core = { module = "org.seasar.doma:doma-core", version.ref = "doma"} -doma-processor = { module = "org.seasar.doma:doma-processor", version.ref = "doma"} -doma-slf4j = { module = "org.seasar.doma:doma-slf4j", version.ref = "doma"} +doma-core = { module = "org.seasar.doma:doma-core", version.ref = "doma" } +doma-processor = { module = "org.seasar.doma:doma-processor", version.ref = "doma" } +doma-slf4j = { module = "org.seasar.doma:doma-slf4j", version.ref = "doma" } jdbc-h2 = { module = "com.h2database:h2", version = "2.3.232" } +jdbc-postgresql = { module = "org.postgresql:postgresql", version = "42.7.5" } logback-classic = { module = "ch.qos.logback:logback-classic", version = "1.5.16" } junit-jupiter-api = { module = "org.junit.jupiter:junit-jupiter-api", version.ref = "junit" } junit-jupiter-engine = { module = "org.junit.jupiter:junit-jupiter-engine", version.ref = "junit" } +testcontainers-bom = { module = "org.testcontainers:testcontainers-bom", version = "1.20.5" } +testcontainers-postgresql = { module = "org.testcontainers:postgresql" } + google-java-format = { module = "com.google.googlejavaformat:google-java-format", version = "1.25.2" } ktlint = { module = "com.pinterest.ktlint:ktlint-cli", version = "1.5.0" } diff --git a/settings.gradle.kts b/settings.gradle.kts index 3be78f35..b4ed899d 100644 --- a/settings.gradle.kts +++ b/settings.gradle.kts @@ -1,7 +1,10 @@ rootProject.name = "simple-examples" + +include("common") +include("common-test") + include("example-sql-file") include("example-sql-annotation") include("example-criteria") include("example-jpms") -include("common") -include("common-test") +include("example-geometric-type")