Expose aliases to all sub queries in where clauses

Author: jeffgbutler

src/main/java/org/mybatis/dynamic/sql/select/render/QueryExpressionRenderer.java

@@ -60,13 +60,13 @@ private QueryExpressionRenderer(Builder builder) {
 
     /**
      * This function calculates a table alias calculator to use in the current context. There are several
-     * possibilities: this could be a renderer for a regular select statement, or it could be a renderer for a table
+     * possibilities: this could be a renderer for a top level select statement, or it could be a renderer for a table
      * expression in a join, or a column to sub query where condition, or it could be a renderer for a select
-     * statement in an "exists" condition.
+     * statement in an "exists" condition in a where clause.
      *
-     * <p>In the case of "exists" conditions, we will have a parent table alias calculator. We want to give visibility
-     * to the aliases in the outer select statement to this renderer so columns in aliased tables can be used in exists
-     * conditions without having to re-specify the alias.
+     * <p>In the case of conditions in a where clause, we will have a parent table alias calculator. This will give
+     * visibility to the aliases in the outer select statement to this renderer so columns in aliased tables can be
+     * used in where clause sub query conditions without having to re-specify the alias.
      *
      * <p>Another complication is that we calculate aliases differently if there are joins and sub queries. The
      * cases are as follows:

src/main/java/org/mybatis/dynamic/sql/where/render/WhereConditionVisitor.java

@@ -1,5 +1,5 @@
 /*
- *    Copyright 2016-2021 the original author or authors.
+ *    Copyright 2016-2022 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.
@@ -96,6 +96,7 @@ public FragmentAndParameters visit(AbstractSubselectCondition<T> condition) {
         SelectStatementProvider selectStatement = SelectRenderer.withSelectModel(condition.selectModel())
                 .withRenderingStrategy(renderingStrategy)
                 .withSequence(sequence)
+                .withParentTableAliasCalculator(tableAliasCalculator)
                 .build()
                 .render();
 

src/test/java/org/mybatis/dynamic/sql/subselect/FooDynamicSqlSupport.java

@@ -0,0 +1,37 @@
+/*
+ *    Copyright 2016-2022 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.subselect;
+
+import org.mybatis.dynamic.sql.SqlColumn;
+import org.mybatis.dynamic.sql.SqlTable;
+
+import java.sql.JDBCType;
+import java.util.Date;
+
+public class FooDynamicSqlSupport {
+    public static final Foo foo = new Foo();
+    public static final SqlColumn<Date> column1 = foo.column1;
+    static final SqlColumn<Integer> column2 = foo.column2;
+
+    public static class Foo extends SqlTable {
+        public final SqlColumn<Date> column1 = column("column1", JDBCType.DATE);
+        public final SqlColumn<Integer> column2 = column("column2", JDBCType.INTEGER);
+
+        public Foo() {
+            super("foo");
+        }
+    }
+}

src/test/java/org/mybatis/dynamic/sql/subselect/SubSelectTest.java

@@ -1,5 +1,5 @@
 /*
- *    Copyright 2016-2020 the original author or authors.
+ *    Copyright 2016-2022 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.
@@ -18,29 +18,30 @@
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.assertAll;
 import static org.mybatis.dynamic.sql.SqlBuilder.*;
+import static org.mybatis.dynamic.sql.subselect.FooDynamicSqlSupport.*;
 
-import java.sql.JDBCType;
 import java.util.Date;
 
 import org.junit.jupiter.api.Test;
-import org.mybatis.dynamic.sql.SqlColumn;
-import org.mybatis.dynamic.sql.SqlTable;
 import org.mybatis.dynamic.sql.render.RenderingStrategies;
 import org.mybatis.dynamic.sql.select.render.SelectStatementProvider;
 
 class SubSelectTest {
 
-    static final SqlTable table = SqlTable.of("foo");
-    static final SqlColumn<Date> column1 = table.column("column1", JDBCType.DATE);
-    static final SqlColumn<Integer> column2 = table.column("column2", JDBCType.INTEGER);
-
     @Test
     void testInSubSelect() {
         Date d = new Date();
 
+        Foo foo2 = new Foo();
+
         SelectStatementProvider selectStatement = select(column1.as("A_COLUMN1"), column2)
-                .from(table, "a")
-                .where(column2, isIn(select(column2).from(table).where(column2, isEqualTo(3))))
+                .from(foo, "a")
+                .where(column2, isIn(
+                        select(foo2.column2)
+                                .from(foo2)
+                                .where(foo2.column2, isEqualTo(3))
+                    )
+                )
                 .and(column1, isLessThan(d))
                 .build()
                 .render(RenderingStrategies.MYBATIS3);
@@ -61,9 +62,16 @@ void testInSubSelect() {
     void testNotInSubSelect() {
         Date d = new Date();
 
+        Foo foo2 = new Foo();
+
         SelectStatementProvider selectStatement = select(column1.as("A_COLUMN1"), column2)
-                .from(table, "a")
-                .where(column2, isNotIn(select(column2).from(table).where(column2, isEqualTo(3))))
+                .from(foo, "a")
+                .where(column2, isNotIn(
+                        select(foo2.column2)
+                                .from(foo2)
+                                .where(foo2.column2, isEqualTo(3))
+                    )
+                )
                 .and(column1, isLessThan(d))
                 .build()
                 .render(RenderingStrategies.MYBATIS3);

src/test/kotlin/examples/kotlin/mybatis3/joins/JoinMapperTest.kt

@@ -33,6 +33,7 @@ import org.assertj.core.api.Assertions.entry
 import org.junit.jupiter.api.Test
 import org.mybatis.dynamic.sql.util.kotlin.KInvalidSQLException
 import org.mybatis.dynamic.sql.util.kotlin.elements.equalTo
+import org.mybatis.dynamic.sql.util.kotlin.elements.max
 import org.mybatis.dynamic.sql.util.kotlin.elements.qualifiedWith
 import org.mybatis.dynamic.sql.util.kotlin.mybatis3.select
 import java.io.InputStreamReader
@@ -774,6 +775,50 @@ class JoinMapperTest {
         }.withMessage("You must specify an \"on\" condition in a join")
     }
 
+    @Test
+    fun testThatAliasesPropagateToSubQueryConditions() {
+        newSession().use { session ->
+            val mapper = session.getMapper(JoinMapper::class.java)
+
+            val orderLine2 = OrderLineDynamicSQLSupport.OrderLine()
+
+            val selectStatement = select(orderLine.orderId, orderLine.lineNumber) {
+                from(orderLine, "ol")
+                where {
+                    orderLine.lineNumber isEqualTo  {
+                        select(max(orderLine2.lineNumber)) {
+                            from(orderLine2, "ol2")
+                            where { orderLine2.orderId isEqualTo orderLine.orderId }
+                        }
+                    }
+                }
+                orderBy(orderLine.orderId)
+            }
+
+            val expectedStatement = "select ol.order_id, ol.line_number " +
+                    "from OrderLine ol " +
+                    "where ol.line_number = " +
+                    "(select max(ol2.line_number) from OrderLine ol2 where ol2.order_id = ol.order_id) " +
+                    "order by order_id"
+
+            assertThat(selectStatement.selectStatement).isEqualTo(expectedStatement)
+
+            val rows = mapper.selectManyMappedRows(selectStatement)
+
+            assertThat(rows).hasSize(2)
+
+            assertThat(rows[0]).containsOnly(
+                entry("ORDER_ID", 1),
+                entry("LINE_NUMBER", 2)
+            )
+
+            assertThat(rows[1]).containsOnly(
+                entry("ORDER_ID", 2),
+                entry("LINE_NUMBER", 3)
+            )
+        }
+    }
+
     companion object {
         const val JDBC_URL = "jdbc:hsqldb:mem:aname"
         const val JDBC_DRIVER = "org.hsqldb.jdbcDriver"