Merge branch 'master' into window-functions

Author: jeffgbutler

pom.xml

@@ -60,7 +60,7 @@
     <java.release.version>17</java.release.version>
     <java.test.version>17</java.test.version>
     <java.test.release.version>17</java.test.release.version>
-    <junit.jupiter.version>6.0.0</junit.jupiter.version>
+    <junit.jupiter.version>6.0.1</junit.jupiter.version>
     <spring.batch.version>5.2.4</spring.batch.version>
 
     <checkstyle.config>checkstyle-override.xml</checkstyle.config>
@@ -69,7 +69,7 @@
 
     <module.name>org.mybatis.dynamic.sql</module.name>
 
-    <kotlin.version>2.1.21</kotlin.version>
+    <kotlin.version>2.2.21</kotlin.version>
     <kotlin.compiler.jvmTarget>17</kotlin.compiler.jvmTarget>
     <kotlin.compiler.languageVersion>2.0</kotlin.compiler.languageVersion>
     <kotlin.compiler.apiVersion>2.0</kotlin.compiler.apiVersion>
@@ -80,7 +80,7 @@
     <sonar.host.url>http://localhost:9000</sonar.host.url>
 
     <kotlin.code.style>official</kotlin.code.style>
-    <test.containers.version>1.21.3</test.containers.version>
+    <test.containers.version>2.0.1</test.containers.version>
     <osgi.export>org.mybatis.dynamic.sql.*;version=${project.version};-noimport:=true</osgi.export>
 
     <!-- Reproducible Builds -->
@@ -95,7 +95,7 @@
     </dependency>
     <dependency>
       <groupId>org.jetbrains.kotlin</groupId>
-      <artifactId>kotlin-stdlib-jdk8</artifactId>
+      <artifactId>kotlin-stdlib</artifactId>
       <version>${kotlin.version}</version>
       <scope>provided</scope>
       <optional>true</optional>
@@ -177,13 +177,13 @@
     </dependency>
     <dependency>
       <groupId>org.testcontainers</groupId>
-      <artifactId>junit-jupiter</artifactId>
+      <artifactId>testcontainers-junit-jupiter</artifactId>
       <version>${test.containers.version}</version>
       <scope>test</scope>
     </dependency>
     <dependency>
       <groupId>org.testcontainers</groupId>
-      <artifactId>postgresql</artifactId>
+      <artifactId>testcontainers-postgresql</artifactId>
       <version>${test.containers.version}</version>
       <scope>test</scope>
     </dependency>
@@ -195,7 +195,7 @@
     </dependency>
     <dependency>
       <groupId>org.testcontainers</groupId>
-      <artifactId>mariadb</artifactId>
+      <artifactId>testcontainers-mariadb</artifactId>
       <version>${test.containers.version}</version>
       <scope>test</scope>
     </dependency>
@@ -207,14 +207,14 @@
     </dependency>
     <dependency>
       <groupId>org.testcontainers</groupId>
-      <artifactId>mysql</artifactId>
+      <artifactId>testcontainers-mysql</artifactId>
       <version>${test.containers.version}</version>
       <scope>test</scope>
     </dependency>
     <dependency>
       <groupId>com.mysql</groupId>
       <artifactId>mysql-connector-j</artifactId>
-      <version>9.4.0</version>
+      <version>9.5.0</version>
       <scope>test</scope>
     </dependency>
   </dependencies>

src/main/java/org/mybatis/dynamic/sql/SqlColumn.java

@@ -33,7 +33,7 @@
  * the {@link SqlTable} the column is a part of.
  *
  * <p>The class can be extended if you wish to associate additional attributes with a column for your
- * own purposes. Extending the class is a bit more challenging than you might expect because you will need to
+ * own purposes. Extending the class is a bit more challenging than you might expect because you may need to
  * handle the covariant types for many methods in {@code SqlColumn}. Additionally, many methods in {@code SqlColumn}
  * create new instances of the class in keeping with the library's primary strategy of immutability. You will also
  * need to ensure that these methods create instances of your extended class, rather than the base {@code SqlColumn}
@@ -44,16 +44,18 @@
  *     <li>Create a class that extends {@link SqlColumn}</li>
  *     <li>In your extended class, create a static builder class that extends {@link SqlColumn.AbstractBuilder}</li>
  *     <li>Add your desired attributes to the class and the builder</li>
- *     <li>In your extended class, override the {@link SqlColumn#copyBuilder()} method and return a new instance of
- *       your builder with all attributes set. You should call the
+ *     <li>You MUST override the {@link SqlColumn#copyBuilder()} method and return a new instance of
+ *       your builder with all attributes set. In the overridden method you should call the superclass
  *       {@link SqlColumn#populateBaseBuilder(AbstractBuilder)} method
- *       to set the attributes from {@code SqlColumn}, then populate your extended attributes.
+ *       to set the attributes from the base {@code SqlColumn}, then populate your extended attributes. During normal
+ *       usage, the library may create additional instances of your class. If you do not override the
+ *       {@link SqlColumn#copyBuilder()} method properly, then your extended attributes will be lost.
  *     </li>
- *     <li>You MUST override the following methods. These methods are used with regular operations in the library.
- *         If you do not override these methods, it is likely that your extended attributes will be lost during
- *         regular usage. For example, if you do not override the {@code as} method and a user calls the method to
- *         apply an alias, then the base {@code SqlColumn} class would create a new instance of {@code SqlColumn}, NOT
- *         your extended class.
+ *     <li>You MAY override the following methods. These methods are used with regular operations in the library and
+ *         create new instances of the class. However, these methods are not typically chained, so losing the specific
+ *         type may not be a problem. If you want to preserve the type, then you can override these methods
+ *         to specify the covariant return type. See below for usage of the {@link SqlColumn#cast(SqlColumn)} method
+ *         to make it easier to override these methods.
  *       <ul>
  *           <li>{@link SqlColumn#as(String)}</li>
  *           <li>{@link SqlColumn#asCamelCase()}</li>
@@ -63,8 +65,10 @@
  *     </li>
  *     <li>You SHOULD override the following methods. These methods can be used to add additional attributes to a
  *         column by creating a new instance with a specified attribute set. These methods are used during the
- *         construction of columns. If you do not override these methods, and a user calls them, then a new
- *         {@code SqlColumn} will be created that does not contain your extended attributes.
+ *         construction of columns. If you do not override these methods, and a user calls them, then the specific type
+ *         will be lost. If you want to preserve the type, then you can override these methods
+ *         to specify the covariant return type. See below for usage of the {@link SqlColumn#cast(SqlColumn)} method
+ *         to make it easier to override these methods.
  *       <ul>
  *           <li>{@link SqlColumn#withJavaProperty(String)}</li>
  *           <li>{@link SqlColumn#withRenderingStrategy(RenderingStrategy)}</li>
@@ -88,7 +92,7 @@
  * }
  * </pre>
  *
- * <p>The test code for this library contains an example of a proper extension of this class.
+ * <p>The test code for this library contains an example of a fully executed extension of this class.
  *
  * @param <T> the Java type associated with the column
  */
@@ -164,7 +168,7 @@ public Optional<String> javaProperty() {
      */
     @Override
     public SqlColumn<T> descending() {
-        return cast(copyBuilder().withDescendingPhrase(" DESC").build()); //$NON-NLS-1$
+        return copyBuilder().withDescendingPhrase(" DESC").build(); //$NON-NLS-1$
     }
 
     /**
@@ -177,7 +181,7 @@ public SqlColumn<T> descending() {
      */
     @Override
     public SqlColumn<T> as(String alias) {
-        return cast(copyBuilder().withAlias(alias).build());
+        return copyBuilder().withAlias(alias).build();
     }
 
     /**
@@ -188,7 +192,7 @@ public SqlColumn<T> as(String alias) {
      * @return a new column that will be rendered with the specified table qualifier
      */
     public SqlColumn<T> qualifiedWith(String tableQualifier) {
-        return cast(copyBuilder().withTableQualifier(tableQualifier).build());
+        return copyBuilder().withTableQualifier(tableQualifier).build();
     }
 
     /**
@@ -203,9 +207,9 @@ public SqlColumn<T> qualifiedWith(String tableQualifier) {
      * @return a new column aliased with a camel case version of the column name
      */
     public SqlColumn<T> asCamelCase() {
-        return cast(copyBuilder()
+        return copyBuilder()
                 .withAlias("\"" + StringUtilities.toCamelCase(name) + "\"") //$NON-NLS-1$ //$NON-NLS-2$
-                .build());
+                .build();
     }
 
     @Override
@@ -318,6 +322,14 @@ public <S> SqlColumn<S> withJavaProperty(String javaProperty) {
         return cast(copyBuilder().withJavaProperty(javaProperty).build());
     }
 
+    /**
+     * Create a new Builder, then populate all attributes in the builder with current values.
+     *
+     * <p>This method is used to create copies of the class during normal operations (e.g. when calling the
+     * {@link SqlColumn#as(String)} method). Any subclass of {@code SqlColumn} MUST override this method.
+     *
+     * @return a new Builder instance with all current values populated
+     */
     protected AbstractBuilder<T, ?, ?> copyBuilder() {
         return populateBaseBuilder(new Builder<>());
     }

src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/GroupingCriteriaCollector.kt

@@ -317,10 +317,6 @@ open class GroupingCriteriaCollector : SubCriteriaCollector() {
 
     fun <T : Any> BindableColumn<T>.isIn(vararg values: T) = isIn(values.asList())
 
-    @JvmName("isInArray")
-    infix fun <T : Any> BindableColumn<T>.isIn(values: Array<out T>) =
-        invoke(org.mybatis.dynamic.sql.util.kotlin.elements.isIn(values))
-
     infix fun <T : Any> BindableColumn<T>.isIn(values: Collection<T>) =
         invoke(org.mybatis.dynamic.sql.util.kotlin.elements.isIn(values))
 
@@ -329,19 +325,11 @@ open class GroupingCriteriaCollector : SubCriteriaCollector() {
 
     fun <T : Any> BindableColumn<T>.isInWhenPresent(vararg values: T?) = isInWhenPresent(values.asList())
 
-    @JvmName("isInArrayWhenPresent")
-    infix fun <T : Any> BindableColumn<T>.isInWhenPresent(values: Array<out T?>?) =
-        invoke(org.mybatis.dynamic.sql.util.kotlin.elements.isInWhenPresent(values))
-
     infix fun <T : Any> BindableColumn<T>.isInWhenPresent(values: Collection<T?>?) =
         invoke(org.mybatis.dynamic.sql.util.kotlin.elements.isInWhenPresent(values))
 
     fun <T : Any> BindableColumn<T>.isNotIn(vararg values: T) = isNotIn(values.asList())
 
-    @JvmName("isNotInArray")
-    infix fun <T : Any> BindableColumn<T>.isNotIn(values: Array<out T>) =
-        invoke(org.mybatis.dynamic.sql.util.kotlin.elements.isNotIn(values))
-
     infix fun <T : Any> BindableColumn<T>.isNotIn(values: Collection<T>) =
         invoke(org.mybatis.dynamic.sql.util.kotlin.elements.isNotIn(values))
 
@@ -350,10 +338,6 @@ open class GroupingCriteriaCollector : SubCriteriaCollector() {
 
     fun <T : Any> BindableColumn<T>.isNotInWhenPresent(vararg values: T?) = isNotInWhenPresent(values.asList())
 
-    @JvmName("isNotInArrayWhenPresent")
-    infix fun <T : Any> BindableColumn<T>.isNotInWhenPresent(values: Array<out T?>?) =
-        invoke(org.mybatis.dynamic.sql.util.kotlin.elements.isNotInWhenPresent(values))
-
     infix fun <T : Any> BindableColumn<T>.isNotInWhenPresent(values: Collection<T?>?) =
         invoke(org.mybatis.dynamic.sql.util.kotlin.elements.isNotInWhenPresent(values))
 
@@ -410,40 +394,24 @@ open class GroupingCriteriaCollector : SubCriteriaCollector() {
 
     fun BindableColumn<String>.isInCaseInsensitive(vararg values: String) = isInCaseInsensitive(values.asList())
 
-    @JvmName("isInArrayCaseInsensitive")
-    infix fun BindableColumn<String>.isInCaseInsensitive(values: Array<out String>) =
-        invoke(org.mybatis.dynamic.sql.util.kotlin.elements.isInCaseInsensitive(values))
-
     infix fun BindableColumn<String>.isInCaseInsensitive(values: Collection<String>) =
         invoke(org.mybatis.dynamic.sql.util.kotlin.elements.isInCaseInsensitive(values))
 
     fun BindableColumn<String>.isInCaseInsensitiveWhenPresent(vararg values: String?) =
         isInCaseInsensitiveWhenPresent(values.asList())
 
-    @JvmName("isInArrayCaseInsensitiveWhenPresent")
-    infix fun BindableColumn<String>.isInCaseInsensitiveWhenPresent(values: Array<out String?>?) =
-        invoke(org.mybatis.dynamic.sql.util.kotlin.elements.isInCaseInsensitiveWhenPresent(values))
-
     infix fun BindableColumn<String>.isInCaseInsensitiveWhenPresent(values: Collection<String?>?) =
         invoke(org.mybatis.dynamic.sql.util.kotlin.elements.isInCaseInsensitiveWhenPresent(values))
 
     fun BindableColumn<String>.isNotInCaseInsensitive(vararg values: String) =
         isNotInCaseInsensitive(values.asList())
 
-    @JvmName("isNotInArrayCaseInsensitive")
-    infix fun BindableColumn<String>.isNotInCaseInsensitive(values: Array<out String>) =
-        invoke(org.mybatis.dynamic.sql.util.kotlin.elements.isNotInCaseInsensitive(values))
-
     infix fun BindableColumn<String>.isNotInCaseInsensitive(values: Collection<String>) =
         invoke(org.mybatis.dynamic.sql.util.kotlin.elements.isNotInCaseInsensitive(values))
 
     fun BindableColumn<String>.isNotInCaseInsensitiveWhenPresent(vararg values: String?) =
         isNotInCaseInsensitiveWhenPresent(values.asList())
 
-    @JvmName("isNotInArrayCaseInsensitiveWhenPresent")
-    infix fun BindableColumn<String>.isNotInCaseInsensitiveWhenPresent(values: Array<out String?>?) =
-        invoke(org.mybatis.dynamic.sql.util.kotlin.elements.isNotInCaseInsensitiveWhenPresent(values))
-
     infix fun BindableColumn<String>.isNotInCaseInsensitiveWhenPresent(values: Collection<String?>?) =
         invoke(org.mybatis.dynamic.sql.util.kotlin.elements.isNotInCaseInsensitiveWhenPresent(values))
 

src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/elements/SqlElements.kt

@@ -286,36 +286,24 @@ fun <T : Any> isLessThanOrEqualToWhenPresent(value: T?): IsLessThanOrEqualToWhen
 
 fun <T : Any> isIn(vararg values: T): IsIn<T> = isIn(values.asList())
 
-@JvmName("isInArray")
-fun <T : Any> isIn(values: Array<out T>): IsIn<T> = SqlBuilder.isIn(values.asList())
-
 fun <T : Any> isIn(values: Collection<T>): IsIn<T> = SqlBuilder.isIn(values)
 
 fun <T : Any> isIn(subQuery: KotlinSubQueryBuilder.() -> Unit): IsInWithSubselect<T> =
     SqlBuilder.isIn(KotlinSubQueryBuilder().apply(subQuery))
 
 fun <T : Any> isInWhenPresent(vararg values: T?): IsInWhenPresent<T> = isInWhenPresent(values.asList())
 
-@JvmName("isInArrayWhenPresent")
-fun <T : Any> isInWhenPresent(values: Array<out T?>?): IsInWhenPresent<T> = SqlBuilder.isInWhenPresent(values?.asList())
-
 fun <T : Any> isInWhenPresent(values: Collection<T?>?): IsInWhenPresent<T> = SqlBuilder.isInWhenPresent(values)
 
 fun <T : Any> isNotIn(vararg values: T): IsNotIn<T> = isNotIn(values.asList())
 
-@JvmName("isNotInArray")
-fun <T : Any> isNotIn(values: Array<out T>): IsNotIn<T> = SqlBuilder.isNotIn(values.asList())
-
 fun <T : Any> isNotIn(values: Collection<T>): IsNotIn<T> = SqlBuilder.isNotIn(values)
 
 fun <T : Any> isNotIn(subQuery: KotlinSubQueryBuilder.() -> Unit): IsNotInWithSubselect<T> =
     SqlBuilder.isNotIn(KotlinSubQueryBuilder().apply(subQuery))
 
 fun <T : Any> isNotInWhenPresent(vararg values: T?): IsNotInWhenPresent<T> = isNotInWhenPresent(values.asList())
 
-@JvmName("isNotInArrayWhenPresent")
-fun <T : Any> isNotInWhenPresent(values: Array<out T?>?): IsNotInWhenPresent<T> = SqlBuilder.isNotInWhenPresent(values?.asList())
-
 fun <T : Any> isNotInWhenPresent(values: Collection<T?>?): IsNotInWhenPresent<T> = SqlBuilder.isNotInWhenPresent(values)
 
 fun <T : Any> isBetween(value1: T): BetweenBuilder<T> = BetweenBuilder(value1)
@@ -354,40 +342,24 @@ fun isNotLikeCaseInsensitiveWhenPresent(value: String?): IsNotLikeCaseInsensitiv
 
 fun isInCaseInsensitive(vararg values: String): IsInCaseInsensitive<String> = isInCaseInsensitive(values.asList())
 
-@JvmName("isInArrayCaseInsensitive")
-fun isInCaseInsensitive(values: Array<out String>): IsInCaseInsensitive<String> =
-    SqlBuilder.isInCaseInsensitive(values.asList())
-
 fun isInCaseInsensitive(values: Collection<String>): IsInCaseInsensitive<String> =
     SqlBuilder.isInCaseInsensitive(values)
 
 fun isInCaseInsensitiveWhenPresent(vararg values: String?): IsInCaseInsensitiveWhenPresent<String> =
     isInCaseInsensitiveWhenPresent(values.asList())
 
-@JvmName("isInArrayCaseInsensitiveWhenPresent")
-fun isInCaseInsensitiveWhenPresent(values: Array<out String?>?): IsInCaseInsensitiveWhenPresent<String> =
-    SqlBuilder.isInCaseInsensitiveWhenPresent(values?.asList())
-
 fun isInCaseInsensitiveWhenPresent(values: Collection<String?>?): IsInCaseInsensitiveWhenPresent<String> =
     SqlBuilder.isInCaseInsensitiveWhenPresent(values)
 
 fun isNotInCaseInsensitive(vararg values: String): IsNotInCaseInsensitive<String> =
     isNotInCaseInsensitive(values.asList())
 
-@JvmName("isNotInArrayCaseInsensitive")
-fun isNotInCaseInsensitive(values: Array<out String>): IsNotInCaseInsensitive<String> =
-    SqlBuilder.isNotInCaseInsensitive(values.asList())
-
 fun isNotInCaseInsensitive(values: Collection<String>): IsNotInCaseInsensitive<String> =
     SqlBuilder.isNotInCaseInsensitive(values)
 
 fun isNotInCaseInsensitiveWhenPresent(vararg values: String?): IsNotInCaseInsensitiveWhenPresent<String> =
     isNotInCaseInsensitiveWhenPresent(values.asList())
 
-@JvmName("isNotInArrayCaseInsensitiveWhenPresent")
-fun isNotInCaseInsensitiveWhenPresent(values: Array<out String?>?): IsNotInCaseInsensitiveWhenPresent<String> =
-    SqlBuilder.isNotInCaseInsensitiveWhenPresent(values?.asList())
-
 fun isNotInCaseInsensitiveWhenPresent(values: Collection<String?>?): IsNotInCaseInsensitiveWhenPresent<String> =
     SqlBuilder.isNotInCaseInsensitiveWhenPresent(values)
 

src/test/java/config/TestContainersConfiguration.java

@@ -23,6 +23,5 @@
 public interface TestContainersConfiguration {
     DockerImageName POSTGRES_LATEST = DockerImageName.parse("postgres:18.0");
     DockerImageName MARIADB_LATEST = DockerImageName.parse("mariadb:12.0.2");
-    // Note - Can't go past MySQL:9.2.0 until this is released: https://github.com/testcontainers/testcontainers-java/pull/10185
-    DockerImageName MYSQL_LATEST = DockerImageName.parse("mysql:9.2.0");
+    DockerImageName MYSQL_LATEST = DockerImageName.parse("mysql:9.5.0");
 }

src/test/java/examples/custom_render/CustomRenderingTest.java

@@ -50,17 +50,16 @@
 import org.mybatis.dynamic.sql.select.render.SelectStatementProvider;
 import org.mybatis.dynamic.sql.update.render.UpdateStatementProvider;
 import org.mybatis.dynamic.sql.util.mybatis3.CommonSelectMapper;
-import org.testcontainers.containers.PostgreSQLContainer;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
+import org.testcontainers.postgresql.PostgreSQLContainer;
 
 @Testcontainers
 class CustomRenderingTest {
 
-    @SuppressWarnings("resource")
     @Container
-    private static final PostgreSQLContainer<?> postgres =
-            new PostgreSQLContainer<>(TestContainersConfiguration.POSTGRES_LATEST)
+    private static final PostgreSQLContainer postgres =
+            new PostgreSQLContainer(TestContainersConfiguration.POSTGRES_LATEST)
                     .withInitScript("examples/custom_render/dbInit.sql");
 
     private SqlSessionFactory sqlSessionFactory;