Add Alternative Join Construction Methods

Added a few methods to QueryExpressionDSL to allow building joins with a
single method. This allows us to remove the weird CompletableQuery
interface and makes the forthcoming Kotlin DSL easier to implement.

With this addition, joins can be coded in a single method, rather than
the current method chaining technique:

```java
.join(SomeTable, on(a, equalTo(b)))
```

This does not alter or remove the existing method chaining technique.

Author: jeffgbutler

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

@@ -44,8 +44,9 @@
 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.AndJoinCriterion;
 import org.mybatis.dynamic.sql.select.join.JoinCondition;
-import org.mybatis.dynamic.sql.select.join.JoinCriterion;
+import org.mybatis.dynamic.sql.select.join.OnJoinCriterion;
 import org.mybatis.dynamic.sql.update.UpdateDSL;
 import org.mybatis.dynamic.sql.update.UpdateModel;
 import org.mybatis.dynamic.sql.util.Buildable;
@@ -191,10 +192,17 @@ static <T> SqlCriterion<T> and(BindableColumn<T> column, VisitableCondition<T> c
     }
 
     // join support
-    static JoinCriterion and(BasicColumn joinColumn, JoinCondition joinCondition) {
-        return JoinCriterion.withJoinColumn(joinColumn)
+    static OnJoinCriterion on(BasicColumn joinColumn, JoinCondition joinCondition) {
+        return new OnJoinCriterion.Builder()
+                .withJoinColumn(joinColumn)
+                .withJoinCondition(joinCondition)
+                .build();
+    }
+    
+    static AndJoinCriterion and(BasicColumn joinColumn, JoinCondition joinCondition) {
+        return new AndJoinCriterion.Builder()
+                .withJoinColumn(joinColumn)
                 .withJoinCondition(joinCondition)
-                .withConnector("and") //$NON-NLS-1$
                 .build();
     }
 

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

@@ -29,15 +29,17 @@
 import org.mybatis.dynamic.sql.SqlCriterion;
 import org.mybatis.dynamic.sql.SqlTable;
 import org.mybatis.dynamic.sql.VisitableCondition;
+import org.mybatis.dynamic.sql.select.join.AndJoinCriterion;
 import org.mybatis.dynamic.sql.select.join.JoinCondition;
 import org.mybatis.dynamic.sql.select.join.JoinCriterion;
 import org.mybatis.dynamic.sql.select.join.JoinModel;
+import org.mybatis.dynamic.sql.select.join.OnJoinCriterion;
 import org.mybatis.dynamic.sql.select.join.JoinSpecification;
 import org.mybatis.dynamic.sql.select.join.JoinType;
 import org.mybatis.dynamic.sql.util.Buildable;
 import org.mybatis.dynamic.sql.where.AbstractWhereDSL;
 
-public class QueryExpressionDSL<R> implements CompletableQuery<R> {
+public class QueryExpressionDSL<R> implements Buildable<R> {
 
     private String connector;
     private SelectDSL<R> selectDSL;
@@ -62,19 +64,16 @@ public class QueryExpressionDSL<R> implements CompletableQuery<R> {
         tableAliases.put(table, tableAlias);
     }
 
-    @Override
     public QueryExpressionWhereBuilder where() {
         whereBuilder = new QueryExpressionWhereBuilder();
         return whereBuilder;
     }
 
-    @Override
     public <T> QueryExpressionWhereBuilder where(BindableColumn<T> column, VisitableCondition<T> condition) {
         whereBuilder = new QueryExpressionWhereBuilder(column, condition);
         return whereBuilder;
     }
 
-    @Override
     public <T> QueryExpressionWhereBuilder where(BindableColumn<T> column, VisitableCondition<T> condition,
             SqlCriterion<?>...subCriteria) {
         whereBuilder = new QueryExpressionWhereBuilder(column, condition, subCriteria);
@@ -95,6 +94,16 @@ public JoinSpecificationStarter join(SqlTable joinTable, String tableAlias) {
         return join(joinTable);
     }
 
+    public QueryExpressionDSL<R> join(SqlTable joinTable, OnJoinCriterion joinCriterion, AndJoinCriterion...joinCriteria) {
+        addJoinSpecificationBuilder(joinTable, joinCriterion, JoinType.INNER, joinCriteria);
+        return this;
+    }
+    
+    public QueryExpressionDSL<R> join(SqlTable joinTable, String tableAlias, OnJoinCriterion joinCriterion, AndJoinCriterion...joinCriteria) {
+        tableAliases.put(joinTable, tableAlias);
+        return join(joinTable, joinCriterion, joinCriteria);
+    }
+    
     public JoinSpecificationStarter leftJoin(SqlTable joinTable) {
         return new JoinSpecificationStarter(joinTable, JoinType.LEFT);
     }
@@ -104,6 +113,16 @@ public JoinSpecificationStarter leftJoin(SqlTable joinTable, String tableAlias)
         return leftJoin(joinTable);
     }
 
+    public QueryExpressionDSL<R> leftJoin(SqlTable joinTable, OnJoinCriterion joinCriterion, AndJoinCriterion...joinCriteria) {
+        addJoinSpecificationBuilder(joinTable, joinCriterion, JoinType.LEFT, joinCriteria);
+        return this;
+    }
+    
+    public QueryExpressionDSL<R> leftJoin(SqlTable joinTable, String tableAlias, OnJoinCriterion joinCriterion, AndJoinCriterion...joinCriteria) {
+        tableAliases.put(joinTable, tableAlias);
+        return leftJoin(joinTable, joinCriterion, joinCriteria);
+    }
+    
     public JoinSpecificationStarter rightJoin(SqlTable joinTable) {
         return new JoinSpecificationStarter(joinTable, JoinType.RIGHT);
     }
@@ -113,6 +132,16 @@ public JoinSpecificationStarter rightJoin(SqlTable joinTable, String tableAlias)
         return rightJoin(joinTable);
     }
 
+    public QueryExpressionDSL<R> rightJoin(SqlTable joinTable, OnJoinCriterion joinCriterion, AndJoinCriterion...joinCriteria) {
+        addJoinSpecificationBuilder(joinTable, joinCriterion, JoinType.RIGHT, joinCriteria);
+        return this;
+    }
+    
+    public QueryExpressionDSL<R> rightJoin(SqlTable joinTable, String tableAlias, OnJoinCriterion joinCriterion, AndJoinCriterion...joinCriteria) {
+        tableAliases.put(joinTable, tableAlias);
+        return rightJoin(joinTable, joinCriterion, joinCriteria);
+    }
+
     public JoinSpecificationStarter fullJoin(SqlTable joinTable) {
         return new JoinSpecificationStarter(joinTable, JoinType.FULL);
     }
@@ -122,13 +151,30 @@ public JoinSpecificationStarter fullJoin(SqlTable joinTable, String tableAlias)
         return fullJoin(joinTable);
     }
 
-    @Override
+    public QueryExpressionDSL<R> fullJoin(SqlTable joinTable, OnJoinCriterion joinCriterion, AndJoinCriterion...joinCriteria) {
+        addJoinSpecificationBuilder(joinTable, joinCriterion, JoinType.FULL, joinCriteria);
+        return this;
+    }
+    
+    public QueryExpressionDSL<R> fullJoin(SqlTable joinTable, String tableAlias, OnJoinCriterion joinCriterion, AndJoinCriterion...joinCriteria) {
+        tableAliases.put(joinTable, tableAlias);
+        return fullJoin(joinTable, joinCriterion, joinCriteria);
+    }
+
+    private void addJoinSpecificationBuilder(SqlTable joinTable, OnJoinCriterion joinCriterion, JoinType joinType,
+            AndJoinCriterion...joinCriteria) {
+        joinSpecificationBuilders.add(new JoinSpecification.Builder()
+                .withJoinTable(joinTable)
+                .withJoinType(joinType)
+                .withJoinCriterion(joinCriterion)
+                .withJoinCriteria(Arrays.asList(joinCriteria)));
+    }
+    
     public GroupByFinisher groupBy(BasicColumn...columns) {
         groupByModel = GroupByModel.of(columns);
         return new GroupByFinisher();
     }
 
-    @Override
     public SelectDSL<R> orderBy(SortSpecification...columns) {
         selectDSL.orderBy(columns);
         return selectDSL;
@@ -160,17 +206,14 @@ private JoinModel buildJoinModel() {
                 .collect(Collectors.toList()));
     }
 
-    @Override
     public SelectDSL<R>.LimitFinisher limit(long limit) {
         return selectDSL.limit(limit);
     }
 
-    @Override
     public SelectDSL<R>.OffsetFirstFinisher offset(long offset) {
         return selectDSL.offset(offset);
     }
 
-    @Override
     public SelectDSL<R>.FetchFirstFinisher fetchFirst(long fetchFirstRows) {
         return selectDSL.fetchFirst(fetchFirstRows);
     }
@@ -298,19 +341,19 @@ public JoinSpecificationFinisher on(BasicColumn joinColumn, JoinCondition joinCo
         }
 
         public JoinSpecificationFinisher on(BasicColumn joinColumn, JoinCondition joinCondition,
-                JoinCriterion...joinCriteria) {
+                AndJoinCriterion...joinCriteria) {
             return new JoinSpecificationFinisher(joinTable, joinColumn, joinCondition, joinType, joinCriteria);
         }
     }
 
-    public class JoinSpecificationFinisher implements CompletableQuery<R> {
+    public class JoinSpecificationFinisher implements Buildable<R> {
         private JoinSpecification.Builder joinSpecificationBuilder;
 
         public JoinSpecificationFinisher(SqlTable table, BasicColumn joinColumn,
                 JoinCondition joinCondition, JoinType joinType) {
-            JoinCriterion joinCriterion = JoinCriterion.withJoinColumn(joinColumn)
+            JoinCriterion joinCriterion = new OnJoinCriterion.Builder()
+                    .withJoinColumn(joinColumn)
                     .withJoinCondition(joinCondition)
-                    .withConnector("on") //$NON-NLS-1$
                     .build();
 
             joinSpecificationBuilder = JoinSpecification.withJoinTable(table)
@@ -321,10 +364,10 @@ public JoinSpecificationFinisher(SqlTable table, BasicColumn joinColumn,
         }
 
         public JoinSpecificationFinisher(SqlTable table, BasicColumn joinColumn,
-                JoinCondition joinCondition, JoinType joinType, JoinCriterion...joinCriteria) {
-            JoinCriterion joinCriterion = JoinCriterion.withJoinColumn(joinColumn)
+                JoinCondition joinCondition, JoinType joinType, AndJoinCriterion...joinCriteria) {
+            JoinCriterion joinCriterion = new OnJoinCriterion.Builder()
+                    .withJoinColumn(joinColumn)
                     .withJoinCondition(joinCondition)
-                    .withConnector("on") //$NON-NLS-1$
                     .build();
 
             joinSpecificationBuilder = JoinSpecification.withJoinTable(table)
@@ -340,26 +383,23 @@ public R build() {
             return QueryExpressionDSL.this.build();
         }
 
-        @Override
         public QueryExpressionWhereBuilder where() {
             return QueryExpressionDSL.this.where();
         }
 
-        @Override
         public <T> QueryExpressionWhereBuilder where(BindableColumn<T> column, VisitableCondition<T> condition) {
             return QueryExpressionDSL.this.where(column, condition);
         }
 
-        @Override
         public <T> QueryExpressionWhereBuilder where(BindableColumn<T> column, VisitableCondition<T> condition,
                 SqlCriterion<?>...subCriteria) {
             return QueryExpressionDSL.this.where(column, condition, subCriteria);
         }
 
         public JoinSpecificationFinisher and(BasicColumn joinColumn, JoinCondition joinCondition) {
-            JoinCriterion joinCriterion = JoinCriterion.withJoinColumn(joinColumn)
+            JoinCriterion joinCriterion = new AndJoinCriterion.Builder()
+                    .withJoinColumn(joinColumn)
                     .withJoinCondition(joinCondition)
-                    .withConnector("and") //$NON-NLS-1$
                     .build();
             joinSpecificationBuilder.withJoinCriterion(joinCriterion);
             return this;
@@ -397,7 +437,6 @@ public JoinSpecificationStarter fullJoin(SqlTable joinTable, String tableAlias)
             return QueryExpressionDSL.this.fullJoin(joinTable, tableAlias);
         }
 
-        @Override
         public GroupByFinisher groupBy(BasicColumn...columns) {
             return QueryExpressionDSL.this.groupBy(columns);
         }
@@ -410,22 +449,18 @@ public UnionBuilder unionAll() {
             return QueryExpressionDSL.this.unionAll();
         }
 
-        @Override
         public SelectDSL<R> orderBy(SortSpecification...columns) {
             return QueryExpressionDSL.this.orderBy(columns);
         }
 
-        @Override
         public SelectDSL<R>.LimitFinisher limit(long limit) {
             return QueryExpressionDSL.this.limit(limit);
         }
 
-        @Override
         public SelectDSL<R>.OffsetFirstFinisher offset(long offset) {
             return QueryExpressionDSL.this.offset(offset);
         }
 
-        @Override
         public SelectDSL<R>.FetchFirstFinisher fetchFirst(long fetchFirstRows) {
             return QueryExpressionDSL.this.fetchFirst(fetchFirstRows);
         }

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

@@ -63,7 +63,7 @@
  */
 @FunctionalInterface
 public interface SelectDSLCompleter extends
-        Function<CompletableQuery<SelectModel>, Buildable<SelectModel>> {
+        Function<QueryExpressionDSL<SelectModel>, Buildable<SelectModel>> {
 
     /**
      * Returns a completer that can be used to select every row in a table.

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

@@ -0,0 +1,39 @@
+/**
+ *    Copyright 2016-2019 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
+ *
+ *       http://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 AndJoinCriterion extends JoinCriterion {
+    
+    private AndJoinCriterion(Builder builder) {
+        super(builder);
+    }
+
+    @Override
+    public String connector() {
+        return "and"; //$NON-NLS-1$
+    }
+
+    public static class Builder extends AbstractBuilder<Builder> {
+        @Override
+        protected Builder getThis() {
+            return this;
+        }
+
+        public AndJoinCriterion build() {
+            return new AndJoinCriterion(this);
+        }
+    }
+}