Merge c46f5f5 into 675b37e

Author: jeffgbutler

CHANGELOG.md

@@ -2,6 +2,34 @@
 
 This log will detail notable changes to MyBatis Dynamic SQL. Full details are available on the GitHub milestone pages.
 
+## Release 1.5.1 - Unreleased
+
+This is a minor release with a few small enhancements.
+
+GitHub milestone: [https://github.com/mybatis/mybatis-dynamic-sql/milestone/13](https://github.com/mybatis/mybatis-dynamic-sql/milestone/13)
+
+### Parameter Values in Joins
+
+We've added the ability to specify typed values in equi-joins. This allows you to avoid the use of constants, and it is
+type safe. For example:
+
+```java
+SelectStatementProvider selectStatement = select(orderLine.orderId, orderLine.quantity, itemMaster.itemId, itemMaster.description)
+    .from(itemMaster, "im")
+    .join(orderLine, "ol").on(orderLine.itemId, equalTo(itemMaster.itemId))
+    .and(orderLine.orderId, equalTo(1))
+    .build()
+    .render(RenderingStrategies.MYBATIS3);
+```
+
+Note the phrase `and(orderLine.orderId, equalTo(1))` which will be rendered with a bound SQL parameter. Currently, this
+capability is limited to equality only. If you have a use for other functions (not equal, less then, greater than, etc.)
+please let us know.
+
+In order to add this capability, we've modified the join DSL to add type information to the join columns. This should
+be source code compatible with most uses. There could be an issue if you are joining tables with columns of different
+types - which is a rare usage. Please let us know if this causes an undo hardship.
+
 ## Release 1.5.0 - April 21, 2023
 
 GitHub milestone: [https://github.com/mybatis/mybatis-dynamic-sql/milestone/12?closed=1](https://github.com/mybatis/mybatis-dynamic-sql/milestone/12?closed=1)

pom.xml

@@ -57,7 +57,7 @@
 
     <checkstyle.config>checkstyle-override.xml</checkstyle.config>
 
-    <clirr.comparisonVersion>1.2.0</clirr.comparisonVersion>
+    <clirr.comparisonVersion>1.5.0</clirr.comparisonVersion>
 
     <module.name>org.mybatis.dynamic.sql</module.name>
 

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

@@ -54,6 +54,7 @@
 import org.mybatis.dynamic.sql.select.function.Subtract;
 import org.mybatis.dynamic.sql.select.function.Upper;
 import org.mybatis.dynamic.sql.select.join.EqualTo;
+import org.mybatis.dynamic.sql.select.join.EqualToValue;
 import org.mybatis.dynamic.sql.select.join.JoinCondition;
 import org.mybatis.dynamic.sql.select.join.JoinCriterion;
 import org.mybatis.dynamic.sql.update.UpdateDSL;
@@ -425,24 +426,28 @@ static AndOrCriteriaGroup and(List<AndOrCriteriaGroup> subCriteria) {
     }
 
     // join support
-    static JoinCriterion and(BasicColumn joinColumn, JoinCondition joinCondition) {
-        return new JoinCriterion.Builder()
+    static <T> JoinCriterion<T> and(BindableColumn<T> joinColumn, JoinCondition<T> joinCondition) {
+        return new JoinCriterion.Builder<T>()
                 .withConnector("and") //$NON-NLS-1$
                 .withJoinColumn(joinColumn)
                 .withJoinCondition(joinCondition)
                 .build();
     }
 
-    static JoinCriterion on(BasicColumn joinColumn, JoinCondition joinCondition) {
-        return new JoinCriterion.Builder()
+    static <T> JoinCriterion<T> on(BindableColumn<T> joinColumn, JoinCondition<T> joinCondition) {
+        return new JoinCriterion.Builder<T>()
                 .withConnector("on") //$NON-NLS-1$
                 .withJoinColumn(joinColumn)
                 .withJoinCondition(joinCondition)
                 .build();
     }
 
-    static EqualTo equalTo(BasicColumn column) {
-        return new EqualTo(column);
+    static <T> EqualTo<T> equalTo(BindableColumn<T> column) {
+        return new EqualTo<>(column);
+    }
+
+    static <T> EqualToValue<T> equalTo(T value) {
+        return new EqualToValue<>(value);
     }
 
     // aggregate support

src/main/java/org/mybatis/dynamic/sql/select/AbstractQueryExpressionDSL.java

@@ -52,132 +52,132 @@ public TableExpression table() {
         return table;
     }
 
-    public T join(SqlTable joinTable, JoinCriterion onJoinCriterion,
-            JoinCriterion... andJoinCriteria) {
+    public T join(SqlTable joinTable, JoinCriterion<?> onJoinCriterion,
+            JoinCriterion<?>... andJoinCriteria) {
         addJoinSpecificationBuilder(joinTable, onJoinCriterion, JoinType.INNER, Arrays.asList(andJoinCriteria));
         return getThis();
     }
 
-    public T join(SqlTable joinTable, String tableAlias, JoinCriterion onJoinCriterion,
-            JoinCriterion... andJoinCriteria) {
+    public T join(SqlTable joinTable, String tableAlias, JoinCriterion<?> onJoinCriterion,
+            JoinCriterion<?>... andJoinCriteria) {
         addTableAlias(joinTable, tableAlias);
         return join(joinTable, onJoinCriterion, andJoinCriteria);
     }
 
-    public T join(SqlTable joinTable, JoinCriterion onJoinCriterion,
-            List<JoinCriterion> andJoinCriteria) {
+    public T join(SqlTable joinTable, JoinCriterion<?> onJoinCriterion,
+            List<JoinCriterion<?>> andJoinCriteria) {
         addJoinSpecificationBuilder(joinTable, onJoinCriterion, JoinType.INNER, andJoinCriteria);
         return getThis();
     }
 
-    public T join(SqlTable joinTable, String tableAlias, JoinCriterion onJoinCriterion,
-            List<JoinCriterion> andJoinCriteria) {
+    public T join(SqlTable joinTable, String tableAlias, JoinCriterion<?> onJoinCriterion,
+            List<JoinCriterion<?>> andJoinCriteria) {
         addTableAlias(joinTable, tableAlias);
         return join(joinTable, onJoinCriterion, andJoinCriteria);
     }
 
-    public T join(Buildable<SelectModel> subQuery, String tableAlias, JoinCriterion onJoinCriterion,
-                  List<JoinCriterion> andJoinCriteria) {
+    public T join(Buildable<SelectModel> subQuery, String tableAlias, JoinCriterion<?> onJoinCriterion,
+                  List<JoinCriterion<?>> andJoinCriteria) {
         addJoinSpecificationBuilder(buildSubQuery(subQuery, tableAlias), onJoinCriterion, JoinType.INNER,
                 andJoinCriteria);
         return getThis();
     }
 
-    public T leftJoin(SqlTable joinTable, JoinCriterion onJoinCriterion,
-            JoinCriterion... andJoinCriteria) {
+    public T leftJoin(SqlTable joinTable, JoinCriterion<?> onJoinCriterion,
+            JoinCriterion<?>... andJoinCriteria) {
         addJoinSpecificationBuilder(joinTable, onJoinCriterion, JoinType.LEFT, Arrays.asList(andJoinCriteria));
         return getThis();
     }
 
-    public T leftJoin(SqlTable joinTable, String tableAlias, JoinCriterion onJoinCriterion,
-            JoinCriterion... andJoinCriteria) {
+    public T leftJoin(SqlTable joinTable, String tableAlias, JoinCriterion<?> onJoinCriterion,
+            JoinCriterion<?>... andJoinCriteria) {
         addTableAlias(joinTable, tableAlias);
         return leftJoin(joinTable, onJoinCriterion, andJoinCriteria);
     }
 
-    public T leftJoin(SqlTable joinTable, JoinCriterion onJoinCriterion,
-            List<JoinCriterion> andJoinCriteria) {
+    public T leftJoin(SqlTable joinTable, JoinCriterion<?> onJoinCriterion,
+            List<JoinCriterion<?>> andJoinCriteria) {
         addJoinSpecificationBuilder(joinTable, onJoinCriterion, JoinType.LEFT, andJoinCriteria);
         return getThis();
     }
 
-    public T leftJoin(SqlTable joinTable, String tableAlias, JoinCriterion onJoinCriterion,
-            List<JoinCriterion> andJoinCriteria) {
+    public T leftJoin(SqlTable joinTable, String tableAlias, JoinCriterion<?> onJoinCriterion,
+            List<JoinCriterion<?>> andJoinCriteria) {
         addTableAlias(joinTable, tableAlias);
         return leftJoin(joinTable, onJoinCriterion, andJoinCriteria);
     }
 
-    public T leftJoin(Buildable<SelectModel> subQuery, String tableAlias, JoinCriterion onJoinCriterion,
-                      List<JoinCriterion> andJoinCriteria) {
+    public T leftJoin(Buildable<SelectModel> subQuery, String tableAlias, JoinCriterion<?> onJoinCriterion,
+                      List<JoinCriterion<?>> andJoinCriteria) {
         addJoinSpecificationBuilder(buildSubQuery(subQuery, tableAlias), onJoinCriterion, JoinType.LEFT,
                 andJoinCriteria);
         return getThis();
     }
 
-    public T rightJoin(SqlTable joinTable, JoinCriterion onJoinCriterion,
-            JoinCriterion... andJoinCriteria) {
+    public T rightJoin(SqlTable joinTable, JoinCriterion<?> onJoinCriterion,
+            JoinCriterion<?>... andJoinCriteria) {
         addJoinSpecificationBuilder(joinTable, onJoinCriterion, JoinType.RIGHT, Arrays.asList(andJoinCriteria));
         return getThis();
     }
 
-    public T rightJoin(SqlTable joinTable, String tableAlias, JoinCriterion onJoinCriterion,
-            JoinCriterion... andJoinCriteria) {
+    public T rightJoin(SqlTable joinTable, String tableAlias, JoinCriterion<?> onJoinCriterion,
+            JoinCriterion<?>... andJoinCriteria) {
         addTableAlias(joinTable, tableAlias);
         return rightJoin(joinTable, onJoinCriterion, andJoinCriteria);
     }
 
-    public T rightJoin(SqlTable joinTable, JoinCriterion onJoinCriterion,
-            List<JoinCriterion> andJoinCriteria) {
+    public T rightJoin(SqlTable joinTable, JoinCriterion<?> onJoinCriterion,
+            List<JoinCriterion<?>> andJoinCriteria) {
         addJoinSpecificationBuilder(joinTable, onJoinCriterion, JoinType.RIGHT, andJoinCriteria);
         return getThis();
     }
 
-    public T rightJoin(SqlTable joinTable, String tableAlias, JoinCriterion onJoinCriterion,
-            List<JoinCriterion> andJoinCriteria) {
+    public T rightJoin(SqlTable joinTable, String tableAlias, JoinCriterion<?> onJoinCriterion,
+            List<JoinCriterion<?>> andJoinCriteria) {
         addTableAlias(joinTable, tableAlias);
         return rightJoin(joinTable, onJoinCriterion, andJoinCriteria);
     }
 
-    public T rightJoin(Buildable<SelectModel> subQuery, String tableAlias, JoinCriterion onJoinCriterion,
-                      List<JoinCriterion> andJoinCriteria) {
+    public T rightJoin(Buildable<SelectModel> subQuery, String tableAlias, JoinCriterion<?> onJoinCriterion,
+                      List<JoinCriterion<?>> andJoinCriteria) {
         addJoinSpecificationBuilder(buildSubQuery(subQuery, tableAlias), onJoinCriterion, JoinType.RIGHT,
                 andJoinCriteria);
         return getThis();
     }
 
-    public T fullJoin(SqlTable joinTable, JoinCriterion onJoinCriterion,
-            JoinCriterion... andJoinCriteria) {
+    public T fullJoin(SqlTable joinTable, JoinCriterion<?> onJoinCriterion,
+            JoinCriterion<?>... andJoinCriteria) {
         addJoinSpecificationBuilder(joinTable, onJoinCriterion, JoinType.FULL, Arrays.asList(andJoinCriteria));
         return getThis();
     }
 
-    public T fullJoin(SqlTable joinTable, String tableAlias, JoinCriterion onJoinCriterion,
-            JoinCriterion... andJoinCriteria) {
+    public T fullJoin(SqlTable joinTable, String tableAlias, JoinCriterion<?> onJoinCriterion,
+            JoinCriterion<?>... andJoinCriteria) {
         addTableAlias(joinTable, tableAlias);
         return fullJoin(joinTable, onJoinCriterion, andJoinCriteria);
     }
 
-    public T fullJoin(SqlTable joinTable, JoinCriterion onJoinCriterion,
-            List<JoinCriterion> andJoinCriteria) {
+    public T fullJoin(SqlTable joinTable, JoinCriterion<?> onJoinCriterion,
+            List<JoinCriterion<?>> andJoinCriteria) {
         addJoinSpecificationBuilder(joinTable, onJoinCriterion, JoinType.FULL, andJoinCriteria);
         return getThis();
     }
 
-    public T fullJoin(SqlTable joinTable, String tableAlias, JoinCriterion onJoinCriterion,
-            List<JoinCriterion> andJoinCriteria) {
+    public T fullJoin(SqlTable joinTable, String tableAlias, JoinCriterion<?> onJoinCriterion,
+            List<JoinCriterion<?>> andJoinCriteria) {
         addTableAlias(joinTable, tableAlias);
         return fullJoin(joinTable, onJoinCriterion, andJoinCriteria);
     }
 
-    public T fullJoin(Buildable<SelectModel> subQuery, String tableAlias, JoinCriterion onJoinCriterion,
-                  List<JoinCriterion> andJoinCriteria) {
+    public T fullJoin(Buildable<SelectModel> subQuery, String tableAlias, JoinCriterion<?> onJoinCriterion,
+                  List<JoinCriterion<?>> andJoinCriteria) {
         addJoinSpecificationBuilder(buildSubQuery(subQuery, tableAlias), onJoinCriterion, JoinType.FULL,
                 andJoinCriteria);
         return getThis();
     }
 
-    private void addJoinSpecificationBuilder(TableExpression joinTable, JoinCriterion onJoinCriterion,
-            JoinType joinType, List<JoinCriterion> andJoinCriteria) {
+    private void addJoinSpecificationBuilder(TableExpression joinTable, JoinCriterion<?> onJoinCriterion,
+            JoinType joinType, List<JoinCriterion<?>> andJoinCriteria) {
         joinSpecificationBuilders.add(new JoinSpecification.Builder()
                 .withJoinTable(joinTable)
                 .withJoinType(joinType)

src/main/java/org/mybatis/dynamic/sql/select/QueryExpressionDSL.java

@@ -24,6 +24,7 @@
 
 import org.jetbrains.annotations.NotNull;
 import org.mybatis.dynamic.sql.BasicColumn;
+import org.mybatis.dynamic.sql.BindableColumn;
 import org.mybatis.dynamic.sql.CriteriaGroup;
 import org.mybatis.dynamic.sql.SortSpecification;
 import org.mybatis.dynamic.sql.SqlTable;
@@ -349,12 +350,12 @@ public JoinSpecificationStarter(TableExpression joinTable, JoinType joinType) {
             this.joinType = joinType;
         }
 
-        public JoinSpecificationFinisher on(BasicColumn joinColumn, JoinCondition joinCondition) {
+        public <T> JoinSpecificationFinisher on(BindableColumn<T> joinColumn, JoinCondition<T> joinCondition) {
             return new JoinSpecificationFinisher(joinTable, joinColumn, joinCondition, joinType);
         }
 
-        public JoinSpecificationFinisher on(BasicColumn joinColumn, JoinCondition onJoinCondition,
-                JoinCriterion... andJoinCriteria) {
+        public <T> JoinSpecificationFinisher on(BindableColumn<T> joinColumn, JoinCondition<T> onJoinCondition,
+                JoinCriterion<?>... andJoinCriteria) {
             return new JoinSpecificationFinisher(joinTable, joinColumn, onJoinCondition, joinType, andJoinCriteria);
         }
     }
@@ -364,9 +365,9 @@ public class JoinSpecificationFinisher
             implements Buildable<R> {
         private final JoinSpecification.Builder joinSpecificationBuilder;
 
-        public JoinSpecificationFinisher(TableExpression table, BasicColumn joinColumn,
-                JoinCondition joinCondition, JoinType joinType) {
-            JoinCriterion joinCriterion = new JoinCriterion.Builder()
+        public <T> JoinSpecificationFinisher(TableExpression table, BindableColumn<T> joinColumn,
+                JoinCondition<T> joinCondition, JoinType joinType) {
+            JoinCriterion<T> joinCriterion = new JoinCriterion.Builder<T>()
                     .withConnector("on") //$NON-NLS-1$
                     .withJoinColumn(joinColumn)
                     .withJoinCondition(joinCondition)
@@ -379,9 +380,9 @@ public JoinSpecificationFinisher(TableExpression table, BasicColumn joinColumn,
             addJoinSpecificationBuilder(joinSpecificationBuilder);
         }
 
-        public JoinSpecificationFinisher(TableExpression table, BasicColumn joinColumn,
-                JoinCondition joinCondition, JoinType joinType, JoinCriterion... andJoinCriteria) {
-            JoinCriterion onJoinCriterion = new JoinCriterion.Builder()
+        public <T> JoinSpecificationFinisher(TableExpression table, BindableColumn<T> joinColumn,
+                JoinCondition<T> joinCondition, JoinType joinType, JoinCriterion<?>... andJoinCriteria) {
+            JoinCriterion<T> onJoinCriterion = new JoinCriterion.Builder<T>()
                     .withConnector("on") //$NON-NLS-1$
                     .withJoinColumn(joinColumn)
                     .withJoinCondition(joinCondition)
@@ -412,8 +413,8 @@ public QueryExpressionWhereBuilder where() {
             return QueryExpressionDSL.this.where();
         }
 
-        public JoinSpecificationFinisher and(BasicColumn joinColumn, JoinCondition joinCondition) {
-            JoinCriterion joinCriterion = new JoinCriterion.Builder()
+        public <T> JoinSpecificationFinisher and(BindableColumn<T> joinColumn, JoinCondition<T> joinCondition) {
+            JoinCriterion<T> joinCriterion = new JoinCriterion.Builder<T>()
                     .withConnector("and") //$NON-NLS-1$
                     .withJoinColumn(joinColumn)
                     .withJoinCondition(joinCondition)

src/main/java/org/mybatis/dynamic/sql/select/join/ColumnBasedJoinCondition.java

@@ -0,0 +1,37 @@
+/*
+ *    Copyright 2016-2023 the original author or authors.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *       https://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+package org.mybatis.dynamic.sql.select.join;
+
+import java.util.Objects;
+
+import org.mybatis.dynamic.sql.BasicColumn;
+
+public abstract class ColumnBasedJoinCondition<T> implements JoinCondition<T> {
+    private final BasicColumn rightColumn;
+
+    protected ColumnBasedJoinCondition(BasicColumn rightColumn) {
+        this.rightColumn = Objects.requireNonNull(rightColumn);
+    }
+
+    public BasicColumn rightColumn() {
+        return rightColumn;
+    }
+
+    @Override
+    public <R> R accept(JoinConditionVisitor<T, R> visitor) {
+        return visitor.visit(this);
+    }
+}

src/main/java/org/mybatis/dynamic/sql/select/join/EqualTo.java

@@ -17,7 +17,7 @@
 
 import org.mybatis.dynamic.sql.BasicColumn;
 
-public class EqualTo extends JoinCondition {
+public class EqualTo<T> extends ColumnBasedJoinCondition<T> {
 
     public EqualTo(BasicColumn rightColumn) {
         super(rightColumn);

src/main/java/org/mybatis/dynamic/sql/select/join/EqualToValue.java

@@ -0,0 +1,27 @@
+/*
+ *    Copyright 2016-2023 the original author or authors.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *       https://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+package org.mybatis.dynamic.sql.select.join;
+
+public class EqualToValue<T> extends TypedJoinCondition<T> {
+    public EqualToValue(T value) {
+        super(value);
+    }
+
+    @Override
+    public String operator() {
+        return "="; //$NON-NLS-1$
+    }
+}