diff --git a/src/test/java/examples/array/StringArrayTypeHandler.java b/src/test/java/examples/array/StringArrayTypeHandler.java index 50f2d2907..238124a58 100644 --- a/src/test/java/examples/array/StringArrayTypeHandler.java +++ b/src/test/java/examples/array/StringArrayTypeHandler.java @@ -22,7 +22,6 @@ import java.sql.SQLException; import java.util.Arrays; import java.util.List; -import java.util.stream.Collectors; import org.apache.ibatis.type.BaseTypeHandler; import org.apache.ibatis.type.JdbcType; @@ -59,7 +58,7 @@ private String[] extractArray(Array array) throws SQLException { List stringList = Arrays.stream(objArray) .map(Object::toString) - .collect(Collectors.toList()); + .toList(); String[] stringArray = new String[stringList.size()]; return stringList.toArray(stringArray); diff --git a/src/test/java/examples/complexquery/GroupingTest.java b/src/test/java/examples/complexquery/GroupingTest.java index c7e09c467..683fa9d11 100644 --- a/src/test/java/examples/complexquery/GroupingTest.java +++ b/src/test/java/examples/complexquery/GroupingTest.java @@ -33,9 +33,9 @@ class GroupingTest { private static class Foo extends SqlTable { - public SqlColumn A = column("A"); - public SqlColumn B = column("B"); - public SqlColumn C = column("C"); + public SqlColumn columnA = column("A"); + public SqlColumn columnB = column("B"); + public SqlColumn columnC = column("C"); public Foo() { super("Foo"); @@ -43,16 +43,16 @@ public Foo() { } private static final Foo foo = new Foo(); - private static final SqlColumn A = foo.A; - private static final SqlColumn B = foo.B; - private static final SqlColumn C = foo.C; + private static final SqlColumn columnA = foo.columnA; + private static final SqlColumn columnB = foo.columnB; + private static final SqlColumn columnC = foo.columnC; @Test void testSimpleGrouping() { - SelectStatementProvider selectStatement = select(A, B, C) + SelectStatementProvider selectStatement = select(columnA, columnB, columnC) .from(foo) - .where(A, isEqualTo(1), or(A, isEqualTo(2))) - .and(B, isEqualTo(3)) + .where(columnA, isEqualTo(1), or(columnA, isEqualTo(2))) + .and(columnB, isEqualTo(3)) .build() .render(RenderingStrategies.MYBATIS3); @@ -68,14 +68,14 @@ void testSimpleGrouping() { @Test void testComplexGrouping() { - SelectStatementProvider selectStatement = select(A, B, C) + SelectStatementProvider selectStatement = select(columnA, columnB, columnC) .from(foo) .where( - group(A, isEqualTo(1), or(A, isGreaterThan(5))), - and(B, isEqualTo(1)), - or(A, isLessThan(0), and(B, isEqualTo(2))) + group(columnA, isEqualTo(1), or(columnA, isGreaterThan(5))), + and(columnB, isEqualTo(1)), + or(columnA, isLessThan(0), and(columnB, isEqualTo(2))) ) - .and(C, isEqualTo(1)) + .and(columnC, isEqualTo(1)) .build() .render(RenderingStrategies.MYBATIS3); @@ -94,14 +94,14 @@ void testComplexGrouping() { @Test void testGroupAndExists() { - SelectStatementProvider selectStatement = select(A, B, C) + SelectStatementProvider selectStatement = select(columnA, columnB, columnC) .from(foo) .where( - group(exists(select(foo.allColumns()).from(foo).where(A, isEqualTo(3))), and (A, isEqualTo(1)), or(A, isGreaterThan(5))), - and(B, isEqualTo(1)), - or(A, isLessThan(0), and(B, isEqualTo(2))) + group(exists(select(foo.allColumns()).from(foo).where(columnA, isEqualTo(3))), and (columnA, isEqualTo(1)), or(columnA, isGreaterThan(5))), + and(columnB, isEqualTo(1)), + or(columnA, isLessThan(0), and(columnB, isEqualTo(2))) ) - .and(C, isEqualTo(1)) + .and(columnC, isEqualTo(1)) .build() .render(RenderingStrategies.MYBATIS3); @@ -121,14 +121,14 @@ void testGroupAndExists() { @Test void testNestedGrouping() { - SelectStatementProvider selectStatement = select(A, B, C) + SelectStatementProvider selectStatement = select(columnA, columnB, columnC) .from(foo) .where( - group(group(A, isEqualTo(1), or(A, isGreaterThan(5))), and(A, isGreaterThan(5))), - and(group(A, isEqualTo(1), or(A, isGreaterThan(5))), or(B, isEqualTo(1))), - or(group(A, isEqualTo(1), or(A, isGreaterThan(5))), and(A, isLessThan(0), and(B, isEqualTo(2)))) + group(group(columnA, isEqualTo(1), or(columnA, isGreaterThan(5))), and(columnA, isGreaterThan(5))), + and(group(columnA, isEqualTo(1), or(columnA, isGreaterThan(5))), or(columnB, isEqualTo(1))), + or(group(columnA, isEqualTo(1), or(columnA, isGreaterThan(5))), and(columnA, isLessThan(0), and(columnB, isEqualTo(2)))) ) - .and(C, isEqualTo(1)) + .and(columnC, isEqualTo(1)) .build() .render(RenderingStrategies.MYBATIS3); @@ -152,12 +152,12 @@ void testNestedGrouping() { @Test void testAndOrCriteriaGroups() { - SelectStatementProvider selectStatement = select(A, B, C) + SelectStatementProvider selectStatement = select(columnA, columnB, columnC) .from(foo) - .where(A, isEqualTo(6)) - .and(C, isEqualTo(1)) - .and(group(A, isEqualTo(1), or(A, isGreaterThan(5))), or(B, isEqualTo(1))) - .or(group(A, isEqualTo(1), or(A, isGreaterThan(5))), and(A, isLessThan(0), and(B, isEqualTo(2)))) + .where(columnA, isEqualTo(6)) + .and(columnC, isEqualTo(1)) + .and(group(columnA, isEqualTo(1), or(columnA, isGreaterThan(5))), or(columnB, isEqualTo(1))) + .or(group(columnA, isEqualTo(1), or(columnA, isGreaterThan(5))), and(columnA, isLessThan(0), and(columnB, isEqualTo(2)))) .build() .render(RenderingStrategies.MYBATIS3); diff --git a/src/test/java/examples/emptywhere/EmptyWhereTest.java b/src/test/java/examples/emptywhere/EmptyWhereTest.java index 8b3fdc546..eca321cd9 100644 --- a/src/test/java/examples/emptywhere/EmptyWhereTest.java +++ b/src/test/java/examples/emptywhere/EmptyWhereTest.java @@ -170,7 +170,7 @@ void testJoinThreeConditions() { String lName = "Flintstone"; QueryExpressionDSL.QueryExpressionWhereBuilder builder = select(id, firstName, PersonDynamicSqlSupport.lastName, orderDate) - .from(person).join(order).on(person.id, equalTo(order.personId)) + .from(person).join(order).on(person.id, isEqualTo(order.personId)) .where(id, isEqualTo(3)); builder.and(firstName, isEqualTo(fName).filter(Objects::nonNull)); @@ -192,7 +192,7 @@ void testJoinThreeConditions() { @MethodSource("joinWhereVariations") void testJoinVariations(Variation variation) { QueryExpressionDSL.QueryExpressionWhereBuilder builder = select(id, firstName, PersonDynamicSqlSupport.lastName, orderDate) - .from(person).join(order).on(person.id, equalTo(order.personId)) + .from(person).join(order).on(person.id, isEqualTo(order.personId)) .where(); builder.and(firstName, isEqualTo(variation.firstName).filter(Objects::nonNull)); diff --git a/src/test/java/examples/generated/always/mybatis/GeneratedAlwaysMapper.java b/src/test/java/examples/generated/always/mybatis/GeneratedAlwaysMapper.java index ac2f7f86b..38521f063 100644 --- a/src/test/java/examples/generated/always/mybatis/GeneratedAlwaysMapper.java +++ b/src/test/java/examples/generated/always/mybatis/GeneratedAlwaysMapper.java @@ -76,8 +76,8 @@ default List select(SelectDSLCompleter completer) { return MyBatis3Utils.selectList(this::selectMany, selectList, generatedAlways, completer); } - default Optional selectByPrimaryKey(Integer _id) { - return selectOne(c -> c.where(id, isEqualTo(_id))); + default Optional selectByPrimaryKey(Integer recordId) { + return selectOne(c -> c.where(id, isEqualTo(recordId))); } default int insert(GeneratedAlwaysRecord row) { diff --git a/src/test/java/examples/groupby/GroupByTest.java b/src/test/java/examples/groupby/GroupByTest.java index 0a5ce6645..793fe2429 100644 --- a/src/test/java/examples/groupby/GroupByTest.java +++ b/src/test/java/examples/groupby/GroupByTest.java @@ -126,7 +126,7 @@ void testGroupByAfterJoin() { CommonSelectMapper mapper = session.getMapper(CommonSelectMapper.class); SelectStatementProvider selectStatement = select(lastName, streetAddress, count().as("count")) - .from(person, "p").join(address, "a").on(person.addressId, equalTo(address.id)) + .from(person, "p").join(address, "a").on(person.addressId, isEqualTo(address.id)) .groupBy(lastName, streetAddress) .build() .render(RenderingStrategies.MYBATIS3); @@ -156,10 +156,10 @@ void testUnionAfterJoin() { CommonSelectMapper mapper = session.getMapper(CommonSelectMapper.class); SelectStatementProvider selectStatement = select(lastName, firstName, streetAddress) - .from(person, "p").join(address, "a").on(person.addressId, equalTo(address.id)) + .from(person, "p").join(address, "a").on(person.addressId, isEqualTo(address.id)) .union() .select(person2.lastName, person2.firstName, streetAddress) - .from(person2, "p").join(address, "a").on(person2.addressId, equalTo(address.id)) + .from(person2, "p").join(address, "a").on(person2.addressId, isEqualTo(address.id)) .orderBy(lastName, firstName) .build() .render(RenderingStrategies.MYBATIS3); @@ -192,10 +192,10 @@ void testUnionAllAfterJoin() { CommonSelectMapper mapper = session.getMapper(CommonSelectMapper.class); SelectStatementProvider selectStatement = select(lastName, firstName, streetAddress) - .from(person, "p").join(address, "a").on(person.addressId, equalTo(address.id)) + .from(person, "p").join(address, "a").on(person.addressId, isEqualTo(address.id)) .unionAll() .select(person2.lastName, person2.firstName, streetAddress) - .from(person2, "p").join(address, "a").on(person2.addressId, equalTo(address.id)) + .from(person2, "p").join(address, "a").on(person2.addressId, isEqualTo(address.id)) .orderBy(lastName, firstName) .build() .render(RenderingStrategies.MYBATIS3); diff --git a/src/test/java/examples/joins/JoinMapperTest.java b/src/test/java/examples/joins/JoinMapperTest.java index 50c8e30f5..1b22697e1 100644 --- a/src/test/java/examples/joins/JoinMapperTest.java +++ b/src/test/java/examples/joins/JoinMapperTest.java @@ -83,7 +83,7 @@ void testSingleTableJoin1() { SelectStatementProvider selectStatement = select(orderMaster.orderId, orderDate, orderDetail.lineNumber, orderDetail.description, orderDetail.quantity) .from(orderMaster, "om") - .join(orderDetail, "od").on(orderMaster.orderId, equalTo(orderDetail.orderId)) + .join(orderDetail, "od").on(orderMaster.orderId, isEqualTo(orderDetail.orderId)) .build() .render(RenderingStrategies.MYBATIS3); @@ -117,7 +117,7 @@ void testSingleTableJoin2() { SelectStatementProvider selectStatement = select(orderMaster.orderId, orderDate, orderDetail.lineNumber, orderDetail.description, orderDetail.quantity) .from(orderMaster, "om") - .join(orderDetail, "od", on(orderMaster.orderId, equalTo(orderDetail.orderId))) + .join(orderDetail, "od", on(orderMaster.orderId, isEqualTo(orderDetail.orderId))) .build() .render(RenderingStrategies.MYBATIS3); @@ -149,7 +149,7 @@ void testCompoundJoin1() { // this is a nonsensical join, but it does test the "and" capability SelectStatementProvider selectStatement = select(orderMaster.orderId, orderDate, orderDetail.lineNumber, orderDetail.description, orderDetail.quantity) .from(orderMaster, "om") - .join(orderDetail, "od").on(orderMaster.orderId, equalTo(orderDetail.orderId), and(orderMaster.orderId, equalTo(orderDetail.orderId))) + .join(orderDetail, "od").on(orderMaster.orderId, isEqualTo(orderDetail.orderId), and(orderMaster.orderId, isEqualTo(orderDetail.orderId))) .build() .render(RenderingStrategies.MYBATIS3); @@ -163,9 +163,9 @@ void testCompoundJoin2() { // this is a nonsensical join, but it does test the "and" capability SelectStatementProvider selectStatement = select(orderMaster.orderId, orderDate, orderDetail.lineNumber, orderDetail.description, orderDetail.quantity) .from(orderMaster, "om") - .join(orderDetail, "od").on(orderMaster.orderId, equalTo(orderDetail.orderId)) + .join(orderDetail, "od").on(orderMaster.orderId, isEqualTo(orderDetail.orderId)) .configureStatement(c -> c.setNonRenderingWhereClauseAllowed(true)) - .and(orderMaster.orderId, equalTo(orderDetail.orderId)) + .and(orderMaster.orderId, isEqualTo(orderDetail.orderId)) .build() .render(RenderingStrategies.MYBATIS3); @@ -179,7 +179,7 @@ void testCompoundJoin3() { // this is a nonsensical join, but it does test the "and" capability SelectStatementProvider selectStatement = select(orderMaster.orderId, orderDate, orderDetail.lineNumber, orderDetail.description, orderDetail.quantity) .from(orderMaster, "om") - .join(orderDetail, "od", on(orderMaster.orderId, equalTo(orderDetail.orderId)), and(orderMaster.orderId, equalTo(orderDetail.orderId))) + .join(orderDetail, "od", on(orderMaster.orderId, isEqualTo(orderDetail.orderId)), and(orderMaster.orderId, isEqualTo(orderDetail.orderId))) .build() .render(RenderingStrategies.MYBATIS3); @@ -193,7 +193,7 @@ void testCompoundJoin4() { // this is a nonsensical join, but it does test the "and" capability SelectStatementProvider selectStatement = select(orderMaster.orderId, orderDate, orderDetail.lineNumber, orderDetail.description, orderDetail.quantity) .from(orderMaster, "om") - .leftJoin(orderDetail, "od", on(orderMaster.orderId, equalTo(orderDetail.orderId)), and(orderMaster.orderId, equalTo(orderDetail.orderId))) + .leftJoin(orderDetail, "od", on(orderMaster.orderId, isEqualTo(orderDetail.orderId)), and(orderMaster.orderId, isEqualTo(orderDetail.orderId))) .build() .render(RenderingStrategies.MYBATIS3); @@ -207,7 +207,7 @@ void testCompoundJoin5() { // this is a nonsensical join, but it does test the "and" capability SelectStatementProvider selectStatement = select(orderMaster.orderId, orderDate, orderDetail.lineNumber, orderDetail.description, orderDetail.quantity) .from(orderMaster, "om") - .rightJoin(orderDetail, "od", on(orderMaster.orderId, equalTo(orderDetail.orderId)), and(orderMaster.orderId, equalTo(orderDetail.orderId))) + .rightJoin(orderDetail, "od", on(orderMaster.orderId, isEqualTo(orderDetail.orderId)), and(orderMaster.orderId, isEqualTo(orderDetail.orderId))) .build() .render(RenderingStrategies.MYBATIS3); @@ -221,7 +221,7 @@ void testCompoundJoin6() { // this is a nonsensical join, but it does test the "and" capability SelectStatementProvider selectStatement = select(orderMaster.orderId, orderDate, orderDetail.lineNumber, orderDetail.description, orderDetail.quantity) .from(orderMaster, "om") - .fullJoin(orderDetail, "od", on(orderMaster.orderId, equalTo(orderDetail.orderId)), and(orderMaster.orderId, equalTo(orderDetail.orderId))) + .fullJoin(orderDetail, "od", on(orderMaster.orderId, isEqualTo(orderDetail.orderId)), and(orderMaster.orderId, isEqualTo(orderDetail.orderId))) .build() .render(RenderingStrategies.MYBATIS3); @@ -237,8 +237,8 @@ void testMultipleTableJoinWithWhereClause() { SelectStatementProvider selectStatement = select(orderMaster.orderId, orderDate, orderLine.lineNumber, itemMaster.description, orderLine.quantity) .from(orderMaster, "om") - .join(orderLine, "ol").on(orderMaster.orderId, equalTo(orderLine.orderId)) - .join(itemMaster, "im").on(orderLine.itemId, equalTo(itemMaster.itemId)) + .join(orderLine, "ol").on(orderMaster.orderId, isEqualTo(orderLine.orderId)) + .join(itemMaster, "im").on(orderLine.itemId, isEqualTo(itemMaster.itemId)) .where(orderMaster.orderId, isEqualTo(2)) .build() .render(RenderingStrategies.MYBATIS3); @@ -268,8 +268,8 @@ void testMultipleTableJoinWithApplyWhere() { SelectStatementProvider selectStatement = select(orderMaster.orderId, orderDate, orderLine.lineNumber, itemMaster.description, orderLine.quantity) .from(orderMaster, "om") - .join(orderLine, "ol").on(orderMaster.orderId, equalTo(orderLine.orderId)) - .join(itemMaster, "im").on(orderLine.itemId, equalTo(itemMaster.itemId)) + .join(orderLine, "ol").on(orderMaster.orderId, isEqualTo(orderLine.orderId)) + .join(itemMaster, "im").on(orderLine.itemId, isEqualTo(itemMaster.itemId)) .applyWhere(where(orderMaster.orderId, isEqualTo(2)).toWhereApplier()) .build() .render(RenderingStrategies.MYBATIS3); @@ -299,8 +299,8 @@ void testMultipleTableJoinWithComplexWhereClause() { SelectStatementProvider selectStatement = select(orderMaster.orderId, orderDate, orderLine.lineNumber, itemMaster.description, orderLine.quantity) .from(orderMaster, "om") - .join(orderLine, "ol").on(orderMaster.orderId, equalTo(orderLine.orderId)) - .join(itemMaster, "im").on(orderLine.itemId, equalTo(itemMaster.itemId)) + .join(orderLine, "ol").on(orderMaster.orderId, isEqualTo(orderLine.orderId)) + .join(itemMaster, "im").on(orderLine.itemId, isEqualTo(itemMaster.itemId)) .where(orderMaster.orderId, isEqualTo(2), and(orderLine.lineNumber, isEqualTo(2))) .build() .render(RenderingStrategies.MYBATIS3); @@ -328,8 +328,8 @@ void testMultipleTableJoinWithOrderBy() { SelectStatementProvider selectStatement = select(orderMaster.orderId, orderDate, orderLine.lineNumber, itemMaster.description, orderLine.quantity) .from(orderMaster, "om") - .join(orderLine, "ol").on(orderMaster.orderId, equalTo(orderLine.orderId)) - .join(itemMaster, "im").on(orderLine.itemId, equalTo(itemMaster.itemId)) + .join(orderLine, "ol").on(orderMaster.orderId, isEqualTo(orderLine.orderId)) + .join(itemMaster, "im").on(orderLine.itemId, isEqualTo(itemMaster.itemId)) .orderBy(orderMaster.orderId) .build() .render(RenderingStrategies.MYBATIS3); @@ -365,8 +365,8 @@ void testMultipleTableJoinNoAliasWithOrderBy() { SelectStatementProvider selectStatement = select(orderMaster.orderId, orderDate, orderLine.lineNumber, itemMaster.description, orderLine.quantity) .from(orderMaster) - .join(orderLine).on(orderMaster.orderId, equalTo(orderLine.orderId)) - .join(itemMaster).on(orderLine.itemId, equalTo(itemMaster.itemId)) + .join(orderLine).on(orderMaster.orderId, isEqualTo(orderLine.orderId)) + .join(itemMaster).on(orderLine.itemId, isEqualTo(itemMaster.itemId)) .where(orderMaster.orderId, isEqualTo(2)) .orderBy(orderMaster.orderId) .build() @@ -398,7 +398,7 @@ void testRightJoin() { SelectStatementProvider selectStatement = select(orderLine.orderId, orderLine.quantity, itemMaster.itemId, itemMaster.description) .from(orderLine, "ol") - .rightJoin(itemMaster, "im").on(orderLine.itemId, equalTo(itemMaster.itemId)) + .rightJoin(itemMaster, "im").on(orderLine.itemId, isEqualTo(itemMaster.itemId)) .orderBy(itemMaster.itemId) .build() .render(RenderingStrategies.MYBATIS3); @@ -432,8 +432,8 @@ void testRightJoin2() { SelectStatementProvider selectStatement = select(orderLine.orderId, orderLine.quantity, itemMaster.itemId, itemMaster.description) .from(orderMaster, "om") - .join(orderLine, "ol").on(orderMaster.orderId, equalTo(orderLine.orderId)) - .rightJoin(itemMaster, "im").on(orderLine.itemId, equalTo(itemMaster.itemId)) + .join(orderLine, "ol").on(orderMaster.orderId, isEqualTo(orderLine.orderId)) + .rightJoin(itemMaster, "im").on(orderLine.itemId, isEqualTo(itemMaster.itemId)) .orderBy(orderLine.orderId, itemMaster.itemId) .build() .render(RenderingStrategies.MYBATIS3); @@ -468,8 +468,8 @@ void testRightJoin3() { SelectStatementProvider selectStatement = select(orderLine.orderId, orderLine.quantity, itemMaster.itemId, itemMaster.description) .from(orderMaster, "om") - .join(orderLine, "ol", on(orderMaster.orderId, equalTo(orderLine.orderId))) - .rightJoin(itemMaster, "im", on(orderLine.itemId, equalTo(itemMaster.itemId))) + .join(orderLine, "ol", on(orderMaster.orderId, isEqualTo(orderLine.orderId))) + .rightJoin(itemMaster, "im", on(orderLine.itemId, isEqualTo(itemMaster.itemId))) .orderBy(orderLine.orderId, itemMaster.itemId) .build() .render(RenderingStrategies.MYBATIS3); @@ -504,8 +504,8 @@ void testRightJoinNoAliases() { SelectStatementProvider selectStatement = select(orderLine.orderId, orderLine.quantity, itemMaster.itemId, itemMaster.description) .from(orderMaster) - .join(orderLine).on(orderMaster.orderId, equalTo(orderLine.orderId)) - .rightJoin(itemMaster).on(orderLine.itemId, equalTo(itemMaster.itemId)) + .join(orderLine).on(orderMaster.orderId, isEqualTo(orderLine.orderId)) + .rightJoin(itemMaster).on(orderLine.itemId, isEqualTo(itemMaster.itemId)) .orderBy(orderLine.orderId, itemMaster.itemId) .build() .render(RenderingStrategies.MYBATIS3); @@ -540,7 +540,7 @@ void testLeftJoin() { SelectStatementProvider selectStatement = select(orderLine.orderId, orderLine.quantity, itemMaster.itemId, itemMaster.description) .from(itemMaster, "im") - .leftJoin(orderLine, "ol").on(orderLine.itemId, equalTo(itemMaster.itemId)) + .leftJoin(orderLine, "ol").on(orderLine.itemId, isEqualTo(itemMaster.itemId)) .orderBy(itemMaster.itemId) .build() .render(RenderingStrategies.MYBATIS3); @@ -574,8 +574,8 @@ void testLeftJoin2() { SelectStatementProvider selectStatement = select(orderLine.orderId, orderLine.quantity, itemMaster.itemId, itemMaster.description) .from(orderMaster, "om") - .join(orderLine, "ol").on(orderMaster.orderId, equalTo(orderLine.orderId)) - .leftJoin(itemMaster, "im").on(orderLine.itemId, equalTo(itemMaster.itemId)) + .join(orderLine, "ol").on(orderMaster.orderId, isEqualTo(orderLine.orderId)) + .leftJoin(itemMaster, "im").on(orderLine.itemId, isEqualTo(itemMaster.itemId)) .orderBy(orderLine.orderId, itemMaster.itemId) .build() .render(RenderingStrategies.MYBATIS3); @@ -610,8 +610,8 @@ void testLeftJoin3() { SelectStatementProvider selectStatement = select(orderLine.orderId, orderLine.quantity, itemMaster.itemId, itemMaster.description) .from(orderMaster, "om") - .join(orderLine, "ol", on(orderMaster.orderId, equalTo(orderLine.orderId))) - .leftJoin(itemMaster, "im", on(orderLine.itemId, equalTo(itemMaster.itemId))) + .join(orderLine, "ol", on(orderMaster.orderId, isEqualTo(orderLine.orderId))) + .leftJoin(itemMaster, "im", on(orderLine.itemId, isEqualTo(itemMaster.itemId))) .orderBy(orderLine.orderId, itemMaster.itemId) .build() .render(RenderingStrategies.MYBATIS3); @@ -646,8 +646,8 @@ void testLeftJoinNoAliases() { SelectStatementProvider selectStatement = select(orderLine.orderId, orderLine.quantity, itemMaster.itemId, itemMaster.description) .from(orderMaster) - .join(orderLine).on(orderMaster.orderId, equalTo(orderLine.orderId)) - .leftJoin(itemMaster).on(orderLine.itemId, equalTo(itemMaster.itemId)) + .join(orderLine).on(orderMaster.orderId, isEqualTo(orderLine.orderId)) + .leftJoin(itemMaster).on(orderLine.itemId, isEqualTo(itemMaster.itemId)) .orderBy(orderLine.orderId, itemMaster.itemId) .build() .render(RenderingStrategies.MYBATIS3); @@ -682,7 +682,7 @@ void testFullJoin() { SelectStatementProvider selectStatement = select(orderLine.orderId, orderLine.quantity, orderLine.itemId.as("ol_itemid"), itemMaster.itemId.as("im_itemid"), itemMaster.description) .from(itemMaster, "im") - .fullJoin(orderLine, "ol").on(itemMaster.itemId, equalTo(orderLine.itemId)) + .fullJoin(orderLine, "ol").on(itemMaster.itemId, isEqualTo(orderLine.itemId)) .orderBy(orderLine.orderId, sortColumn("im_itemid")) .build() .render(RenderingStrategies.MYBATIS3); @@ -723,8 +723,8 @@ void testFullJoin2() { SelectStatementProvider selectStatement = select(orderLine.orderId, orderLine.quantity, itemMaster.itemId, itemMaster.description) .from(orderMaster, "om") - .join(orderLine, "ol").on(orderMaster.orderId, equalTo(orderLine.orderId)) - .fullJoin(itemMaster, "im").on(orderLine.itemId, equalTo(itemMaster.itemId)) + .join(orderLine, "ol").on(orderMaster.orderId, isEqualTo(orderLine.orderId)) + .fullJoin(itemMaster, "im").on(orderLine.itemId, isEqualTo(itemMaster.itemId)) .orderBy(orderLine.orderId, itemMaster.itemId) .build() .render(RenderingStrategies.MYBATIS3); @@ -765,8 +765,8 @@ void testFullJoin3() { SelectStatementProvider selectStatement = select(orderLine.orderId, orderLine.quantity, itemMaster.itemId, itemMaster.description) .from(orderMaster, "om") - .join(orderLine, "ol", on(orderMaster.orderId, equalTo(orderLine.orderId))) - .fullJoin(itemMaster, "im", on(orderLine.itemId, equalTo(itemMaster.itemId))) + .join(orderLine, "ol", on(orderMaster.orderId, isEqualTo(orderLine.orderId))) + .fullJoin(itemMaster, "im", on(orderLine.itemId, isEqualTo(itemMaster.itemId))) .orderBy(orderLine.orderId, itemMaster.itemId) .build() .render(RenderingStrategies.MYBATIS3); @@ -807,8 +807,8 @@ void testFullJoin4() { SelectStatementProvider selectStatement = select(orderLine.orderId, orderLine.quantity, itemMaster.description) .from(orderMaster, "om") - .join(orderLine, "ol", on(orderMaster.orderId, equalTo(orderLine.orderId))) - .fullJoin(itemMaster, "im", on(orderLine.itemId, equalTo(itemMaster.itemId))) + .join(orderLine, "ol", on(orderMaster.orderId, isEqualTo(orderLine.orderId))) + .fullJoin(itemMaster, "im", on(orderLine.itemId, isEqualTo(itemMaster.itemId))) .orderBy(orderLine.orderId, sortColumn("im", itemMaster.itemId)) .build() .render(RenderingStrategies.MYBATIS3); @@ -846,8 +846,8 @@ void testFullJoin5() { SelectStatementProvider selectStatement = select(orderLine.orderId, orderLine.quantity, itemMaster.description) .from(orderMaster, "om") - .join(orderLine, "ol", on(orderMaster.orderId, equalTo(orderLine.orderId))) - .fullJoin(itemMaster, "im", on(orderLine.itemId, equalTo(itemMaster.itemId))) + .join(orderLine, "ol", on(orderMaster.orderId, isEqualTo(orderLine.orderId))) + .fullJoin(itemMaster, "im", on(orderLine.itemId, isEqualTo(itemMaster.itemId))) .orderBy(orderLine.orderId, sortColumn("im", itemMaster.itemId).descending()) .build() .render(RenderingStrategies.MYBATIS3); @@ -885,8 +885,8 @@ void testFullJoinNoAliases() { SelectStatementProvider selectStatement = select(orderLine.orderId, orderLine.quantity, itemMaster.itemId, itemMaster.description) .from(orderMaster) - .join(orderLine).on(orderMaster.orderId, equalTo(orderLine.orderId)) - .fullJoin(itemMaster).on(orderLine.itemId, equalTo(itemMaster.itemId)) + .join(orderLine).on(orderMaster.orderId, isEqualTo(orderLine.orderId)) + .fullJoin(itemMaster).on(orderLine.itemId, isEqualTo(itemMaster.itemId)) .orderBy(orderLine.orderId, itemMaster.itemId) .build() .render(RenderingStrategies.MYBATIS3); @@ -931,7 +931,7 @@ void testSelf() { // get Bamm Bamm's parent - should be Barney SelectStatementProvider selectStatement = select(user.userId, user.userName, user.parentId) .from(user, "u1") - .join(user2, "u2").on(user.userId, equalTo(user2.parentId)) + .join(user2, "u2").on(user.userId, isEqualTo(user2.parentId)) .where(user2.userId, isEqualTo(4)) .build() .render(RenderingStrategies.MYBATIS3); @@ -971,7 +971,7 @@ void testSelfWithNewAlias() { // get Bamm Bamm's parent - should be Barney SelectStatementProvider selectStatement = select(user.userId, user.userName, user.parentId) .from(user) - .join(user2).on(user.userId, equalTo(user2.parentId)) + .join(user2).on(user.userId, isEqualTo(user2.parentId)) .where(user2.userId, isEqualTo(4)) .build() .render(RenderingStrategies.MYBATIS3); @@ -1002,7 +1002,7 @@ void testSelfWithNewAliasAndOverride() { // get Bamm Bamm's parent - should be Barney SelectStatementProvider selectStatement = select(user.userId, user.userName, user.parentId) .from(user, "u1") - .join(user2, "u2").on(user.userId, equalTo(user2.parentId)) + .join(user2, "u2").on(user.userId, isEqualTo(user2.parentId)) .where(user2.userId, isEqualTo(4)) .build() .render(RenderingStrategies.MYBATIS3); @@ -1029,7 +1029,7 @@ void testLimitAndOffsetAfterJoin() { SelectStatementProvider selectStatement = select(orderLine.orderId, orderLine.quantity, itemMaster.itemId, itemMaster.description) .from(itemMaster, "im") - .leftJoin(orderLine, "ol").on(orderLine.itemId, equalTo(itemMaster.itemId)) + .leftJoin(orderLine, "ol").on(orderLine.itemId, isEqualTo(itemMaster.itemId)) .limit(2) .offset(1) .build() @@ -1064,7 +1064,7 @@ void testLimitOnlyAfterJoin() { SelectStatementProvider selectStatement = select(orderLine.orderId, orderLine.quantity, itemMaster.itemId, itemMaster.description) .from(itemMaster, "im") - .leftJoin(orderLine, "ol").on(orderLine.itemId, equalTo(itemMaster.itemId)) + .leftJoin(orderLine, "ol").on(orderLine.itemId, isEqualTo(itemMaster.itemId)) .limit(2) .build() .render(RenderingStrategies.MYBATIS3); @@ -1098,7 +1098,7 @@ void testOffsetOnlyAfterJoin() { SelectStatementProvider selectStatement = select(orderLine.orderId, orderLine.quantity, itemMaster.itemId, itemMaster.description) .from(itemMaster, "im") - .leftJoin(orderLine, "ol").on(orderLine.itemId, equalTo(itemMaster.itemId)) + .leftJoin(orderLine, "ol").on(orderLine.itemId, isEqualTo(itemMaster.itemId)) .offset(2) .build() .render(RenderingStrategies.MYBATIS3); @@ -1132,7 +1132,7 @@ void testOffsetAndFetchFirstAfterJoin() { SelectStatementProvider selectStatement = select(orderLine.orderId, orderLine.quantity, itemMaster.itemId, itemMaster.description) .from(itemMaster, "im") - .leftJoin(orderLine, "ol").on(orderLine.itemId, equalTo(itemMaster.itemId)) + .leftJoin(orderLine, "ol").on(orderLine.itemId, isEqualTo(itemMaster.itemId)) .offset(1) .fetchFirst(2).rowsOnly() .build() @@ -1167,7 +1167,7 @@ void testFetchFirstOnlyAfterJoin() { SelectStatementProvider selectStatement = select(orderLine.orderId, orderLine.quantity, itemMaster.itemId, itemMaster.description) .from(itemMaster, "im") - .leftJoin(orderLine, "ol").on(orderLine.itemId, equalTo(itemMaster.itemId)) + .leftJoin(orderLine, "ol").on(orderLine.itemId, isEqualTo(itemMaster.itemId)) .fetchFirst(2).rowsOnly() .build() .render(RenderingStrategies.MYBATIS3); @@ -1201,8 +1201,8 @@ void testJoinWithParameterValue() { 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)) + .join(orderLine, "ol").on(orderLine.itemId, isEqualTo(itemMaster.itemId)) + .and(orderLine.orderId, isEqualTo(1)) .build() .render(RenderingStrategies.MYBATIS3); @@ -1235,8 +1235,8 @@ void testJoinWithConstant() { 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(constant("1"))) + .join(orderLine, "ol").on(orderLine.itemId, isEqualTo(itemMaster.itemId)) + .and(orderLine.orderId, isEqualTo(constant("1"))) .build() .render(RenderingStrategies.MYBATIS3); diff --git a/src/test/java/examples/joins/JoinSubQueryTest.java b/src/test/java/examples/joins/JoinSubQueryTest.java index 588844828..1bda4983e 100644 --- a/src/test/java/examples/joins/JoinSubQueryTest.java +++ b/src/test/java/examples/joins/JoinSubQueryTest.java @@ -20,7 +20,6 @@ import static examples.joins.OrderLineDynamicSQLSupport.orderLine; import static examples.joins.OrderMasterDynamicSQLSupport.orderMaster; import static org.assertj.core.api.Assertions.assertThat; -import static org.mybatis.dynamic.sql.SqlBuilder.equalTo; import static org.mybatis.dynamic.sql.SqlBuilder.isEqualTo; import static org.mybatis.dynamic.sql.SqlBuilder.select; import static org.mybatis.dynamic.sql.SqlBuilder.sortColumn; @@ -82,7 +81,7 @@ void testSingleTableJoin1() { .from(orderMaster, "om") .join(select(orderDetail.orderId, orderDetail.lineNumber, orderDetail.description, orderDetail.quantity) .from(orderDetail), - "od").on(orderMaster.orderId, equalTo(orderDetail.orderId.qualifiedWith("od"))) + "od").on(orderMaster.orderId, isEqualTo(orderDetail.orderId.qualifiedWith("od"))) .build() .render(RenderingStrategies.MYBATIS3); @@ -121,11 +120,11 @@ void testMultipleTableJoinWithWhereClause() { .join(select(orderLine.orderId, orderLine.itemId, orderLine.quantity, orderLine.lineNumber) .from(orderLine), "ol") - .on(orderMaster.orderId, equalTo(orderLine.orderId.qualifiedWith("ol"))) + .on(orderMaster.orderId, isEqualTo(orderLine.orderId.qualifiedWith("ol"))) .join(select(itemMaster.itemId, itemMaster.description) .from(itemMaster), "im") - .on(orderLine.itemId.qualifiedWith("ol"), equalTo(itemMaster.itemId.qualifiedWith("im"))) + .on(orderLine.itemId.qualifiedWith("ol"), isEqualTo(itemMaster.itemId.qualifiedWith("im"))) .where(orderMaster.orderId, isEqualTo(2)) .build() .render(RenderingStrategies.MYBATIS3); @@ -158,9 +157,9 @@ void testMultipleTableJoinWithSelectStar() { SelectStatementProvider selectStatement = select(orderMaster.orderId, orderMaster.orderDate, orderLine.lineNumber, itemMaster.description, orderLine.quantity) .from(orderMaster, "om") .join(select(orderLine.allColumns()).from(orderLine), "ol") - .on(orderMaster.orderId, equalTo(orderLine.orderId.qualifiedWith("ol"))) + .on(orderMaster.orderId, isEqualTo(orderLine.orderId.qualifiedWith("ol"))) .join(select(itemMaster.allColumns()).from(itemMaster), "im") - .on(orderLine.itemId.qualifiedWith("ol"), equalTo(itemMaster.itemId.qualifiedWith("im"))) + .on(orderLine.itemId.qualifiedWith("ol"), isEqualTo(itemMaster.itemId.qualifiedWith("im"))) .where(orderMaster.orderId, isEqualTo(2)) .orderBy(orderMaster.orderId) .build() @@ -197,7 +196,7 @@ void testRightJoin() { itemMaster.itemId.qualifiedWith("im"), itemMaster.description) .from(orderLine, "ol") .rightJoin(select(itemMaster.allColumns()).from(itemMaster), "im") - .on(orderLine.itemId, equalTo(itemMaster.itemId.qualifiedWith("im"))) + .on(orderLine.itemId, isEqualTo(itemMaster.itemId.qualifiedWith("im"))) .orderBy(itemMaster.itemId) .build() .render(RenderingStrategies.MYBATIS3); @@ -232,9 +231,9 @@ void testRightJoin2() { SelectStatementProvider selectStatement = select(orderLine.orderId, orderLine.quantity, itemMaster.itemId.qualifiedWith(("im")), itemMaster.description) .from(orderMaster, "om") - .join(orderLine, "ol").on(orderMaster.orderId, equalTo(orderLine.orderId)) + .join(orderLine, "ol").on(orderMaster.orderId, isEqualTo(orderLine.orderId)) .rightJoin(select(itemMaster.allColumns()).from(itemMaster), "im") - .on(orderLine.itemId, equalTo(itemMaster.itemId.qualifiedWith("im"))) + .on(orderLine.itemId, isEqualTo(itemMaster.itemId.qualifiedWith("im"))) .orderBy(orderLine.orderId, itemMaster.itemId) .build() .render(RenderingStrategies.MYBATIS3); @@ -271,7 +270,7 @@ void testLeftJoin() { itemMaster.itemId.qualifiedWith("im"), itemMaster.description) .from(itemMaster, "im") .leftJoin(select(orderLine.allColumns()).from(orderLine), "ol") - .on(orderLine.itemId.qualifiedWith("ol"), equalTo(itemMaster.itemId)) + .on(orderLine.itemId.qualifiedWith("ol"), isEqualTo(itemMaster.itemId)) .orderBy(itemMaster.itemId) .build() .render(RenderingStrategies.MYBATIS3); @@ -307,9 +306,9 @@ void testLeftJoin2() { SelectStatementProvider selectStatement = select(orderLine.orderId, orderLine.quantity, itemMaster.itemId.qualifiedWith("im"), itemMaster.description) .from(orderMaster, "om") - .join(orderLine, "ol").on(orderMaster.orderId, equalTo(orderLine.orderId)) + .join(orderLine, "ol").on(orderMaster.orderId, isEqualTo(orderLine.orderId)) .leftJoin(select(itemMaster.allColumns()).from(itemMaster), "im") - .on(orderLine.itemId, equalTo(itemMaster.itemId.qualifiedWith("im"))) + .on(orderLine.itemId, isEqualTo(itemMaster.itemId.qualifiedWith("im"))) .orderBy(orderLine.orderId, itemMaster.itemId) .build() .render(RenderingStrategies.MYBATIS3); @@ -346,7 +345,7 @@ void testFullJoin() { orderLine.itemId.as("ol_itemid").qualifiedWith("ol"), itemMaster.itemId.as("im_itemid"), itemMaster.description) .from(itemMaster, "im") .fullJoin(select(orderLine.allColumns()).from(orderLine), "ol") - .on(itemMaster.itemId, equalTo(orderLine.itemId.qualifiedWith("ol"))) + .on(itemMaster.itemId, isEqualTo(orderLine.itemId.qualifiedWith("ol"))) .orderBy(orderLine.orderId, sortColumn("im_itemid")) .build() .render(RenderingStrategies.MYBATIS3); @@ -389,9 +388,9 @@ void testFullJoin2() { SelectStatementProvider selectStatement = select(orderLine.orderId, orderLine.quantity, itemMaster.itemId.qualifiedWith("im"), itemMaster.description) .from(orderMaster, "om") - .join(orderLine, "ol").on(orderMaster.orderId, equalTo(orderLine.orderId)) + .join(orderLine, "ol").on(orderMaster.orderId, isEqualTo(orderLine.orderId)) .fullJoin(select(itemMaster.allColumns()).from(itemMaster), "im") - .on(orderLine.itemId, equalTo(itemMaster.itemId.qualifiedWith("im"))) + .on(orderLine.itemId, isEqualTo(itemMaster.itemId.qualifiedWith("im"))) .orderBy(orderLine.orderId, itemMaster.itemId) .build() .render(RenderingStrategies.MYBATIS3); diff --git a/src/test/java/examples/joins/NewSyntaxJoinMapperTest.java b/src/test/java/examples/joins/NewSyntaxJoinMapperTest.java deleted file mode 100644 index ae8f5d0f0..000000000 --- a/src/test/java/examples/joins/NewSyntaxJoinMapperTest.java +++ /dev/null @@ -1,1270 +0,0 @@ -/* - * Copyright 2016-2024 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 examples.joins; - -import org.apache.ibatis.datasource.unpooled.UnpooledDataSource; -import org.apache.ibatis.jdbc.ScriptRunner; -import org.apache.ibatis.mapping.Environment; -import org.apache.ibatis.session.Configuration; -import org.apache.ibatis.session.SqlSession; -import org.apache.ibatis.session.SqlSessionFactory; -import org.apache.ibatis.session.SqlSessionFactoryBuilder; -import org.apache.ibatis.transaction.jdbc.JdbcTransactionFactory; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import org.mybatis.dynamic.sql.exception.DuplicateTableAliasException; -import org.mybatis.dynamic.sql.render.RenderingStrategies; -import org.mybatis.dynamic.sql.select.QueryExpressionDSL; -import org.mybatis.dynamic.sql.select.SelectModel; -import org.mybatis.dynamic.sql.select.render.SelectStatementProvider; -import org.mybatis.dynamic.sql.util.Messages; -import org.mybatis.dynamic.sql.util.mybatis3.CommonSelectMapper; - -import java.io.InputStream; -import java.io.InputStreamReader; -import java.sql.Connection; -import java.sql.DriverManager; -import java.util.List; -import java.util.Map; - -import static examples.joins.ItemMasterDynamicSQLSupport.itemMaster; -import static examples.joins.OrderDetailDynamicSQLSupport.orderDetail; -import static examples.joins.OrderLineDynamicSQLSupport.orderLine; -import static examples.joins.OrderMasterDynamicSQLSupport.orderDate; -import static examples.joins.OrderMasterDynamicSQLSupport.orderMaster; -import static examples.joins.UserDynamicSQLSupport.user; -import static org.assertj.core.api.Assertions.assertThat; -import static org.assertj.core.api.Assertions.assertThatExceptionOfType; -import static org.mybatis.dynamic.sql.SqlBuilder.and; -import static org.mybatis.dynamic.sql.SqlBuilder.constant; -import static org.mybatis.dynamic.sql.SqlBuilder.isEqualTo; -import static org.mybatis.dynamic.sql.SqlBuilder.on; -import static org.mybatis.dynamic.sql.SqlBuilder.select; -import static org.mybatis.dynamic.sql.SqlBuilder.sortColumn; -import static org.mybatis.dynamic.sql.SqlBuilder.where; - -class NewSyntaxJoinMapperTest { - - private static final String JDBC_URL = "jdbc:hsqldb:mem:aname"; - private static final String JDBC_DRIVER = "org.hsqldb.jdbcDriver"; - - private SqlSessionFactory sqlSessionFactory; - - @BeforeEach - void setup() throws Exception { - Class.forName(JDBC_DRIVER); - InputStream is = getClass().getResourceAsStream("/examples/joins/CreateJoinDB.sql"); - assert is != null; - try (Connection connection = DriverManager.getConnection(JDBC_URL, "sa", "")) { - ScriptRunner sr = new ScriptRunner(connection); - sr.setLogWriter(null); - sr.runScript(new InputStreamReader(is)); - } - - UnpooledDataSource ds = new UnpooledDataSource(JDBC_DRIVER, JDBC_URL, "sa", ""); - Environment environment = new Environment("test", new JdbcTransactionFactory(), ds); - Configuration config = new Configuration(environment); - config.addMapper(JoinMapper.class); - config.addMapper(CommonSelectMapper.class); - sqlSessionFactory = new SqlSessionFactoryBuilder().build(config); - } - - @Test - void testSingleTableJoin1() { - try (SqlSession session = sqlSessionFactory.openSession()) { - JoinMapper mapper = session.getMapper(JoinMapper.class); - - SelectStatementProvider selectStatement = select(orderMaster.orderId, orderDate, orderDetail.lineNumber, orderDetail.description, orderDetail.quantity) - .from(orderMaster, "om") - .join(orderDetail, "od").on(orderMaster.orderId, isEqualTo(orderDetail.orderId)) - .build() - .render(RenderingStrategies.MYBATIS3); - - String expectedStatement = "select om.order_id, om.order_date, od.line_number, od.description, od.quantity" - + " from OrderMaster om join OrderDetail od on om.order_id = od.order_id"; - assertThat(selectStatement.getSelectStatement()).isEqualTo(expectedStatement); - - List rows = mapper.selectMany(selectStatement); - - assertThat(rows).hasSize(2); - OrderMaster orderMaster = rows.get(0); - assertThat(orderMaster.getId()).isEqualTo(1); - assertThat(orderMaster.getDetails()).hasSize(2); - OrderDetail orderDetail = orderMaster.getDetails().get(0); - assertThat(orderDetail.getLineNumber()).isEqualTo(1); - orderDetail = orderMaster.getDetails().get(1); - assertThat(orderDetail.getLineNumber()).isEqualTo(2); - - orderMaster = rows.get(1); - assertThat(orderMaster.getId()).isEqualTo(2); - assertThat(orderMaster.getDetails()).hasSize(1); - orderDetail = orderMaster.getDetails().get(0); - assertThat(orderDetail.getLineNumber()).isEqualTo(1); - } - } - - @Test - void testSingleTableJoin2() { - try (SqlSession session = sqlSessionFactory.openSession()) { - JoinMapper mapper = session.getMapper(JoinMapper.class); - - SelectStatementProvider selectStatement = select(orderMaster.orderId, orderDate, orderDetail.lineNumber, orderDetail.description, orderDetail.quantity) - .from(orderMaster, "om") - .join(orderDetail, "od", on(orderMaster.orderId, isEqualTo(orderDetail.orderId))) - .build() - .render(RenderingStrategies.MYBATIS3); - - String expectedStatement = "select om.order_id, om.order_date, od.line_number, od.description, od.quantity" - + " from OrderMaster om join OrderDetail od on om.order_id = od.order_id"; - assertThat(selectStatement.getSelectStatement()).isEqualTo(expectedStatement); - - List rows = mapper.selectMany(selectStatement); - - assertThat(rows).hasSize(2); - OrderMaster orderMaster = rows.get(0); - assertThat(orderMaster.getId()).isEqualTo(1); - assertThat(orderMaster.getDetails()).hasSize(2); - OrderDetail orderDetail = orderMaster.getDetails().get(0); - assertThat(orderDetail.getLineNumber()).isEqualTo(1); - orderDetail = orderMaster.getDetails().get(1); - assertThat(orderDetail.getLineNumber()).isEqualTo(2); - - orderMaster = rows.get(1); - assertThat(orderMaster.getId()).isEqualTo(2); - assertThat(orderMaster.getDetails()).hasSize(1); - orderDetail = orderMaster.getDetails().get(0); - assertThat(orderDetail.getLineNumber()).isEqualTo(1); - } - } - - @Test - void testCompoundJoin1() { - // this is a nonsensical join, but it does test the "and" capability - SelectStatementProvider selectStatement = select(orderMaster.orderId, orderDate, orderDetail.lineNumber, orderDetail.description, orderDetail.quantity) - .from(orderMaster, "om") - .join(orderDetail, "od").on(orderMaster.orderId, isEqualTo(orderDetail.orderId), and(orderMaster.orderId, isEqualTo(orderDetail.orderId))) - .build() - .render(RenderingStrategies.MYBATIS3); - - String expectedStatement = "select om.order_id, om.order_date, od.line_number, od.description, od.quantity" - + " from OrderMaster om join OrderDetail od on om.order_id = od.order_id and om.order_id = od.order_id"; - assertThat(selectStatement.getSelectStatement()).isEqualTo(expectedStatement); - } - - @Test - void testCompoundJoin2() { - // this is a nonsensical join, but it does test the "and" capability - SelectStatementProvider selectStatement = select(orderMaster.orderId, orderDate, orderDetail.lineNumber, orderDetail.description, orderDetail.quantity) - .from(orderMaster, "om") - .join(orderDetail, "od").on(orderMaster.orderId, isEqualTo(orderDetail.orderId)) - .configureStatement(c -> c.setNonRenderingWhereClauseAllowed(true)) - .and(orderMaster.orderId, isEqualTo(orderDetail.orderId)) - .build() - .render(RenderingStrategies.MYBATIS3); - - String expectedStatement = "select om.order_id, om.order_date, od.line_number, od.description, od.quantity" - + " from OrderMaster om join OrderDetail od on om.order_id = od.order_id and om.order_id = od.order_id"; - assertThat(selectStatement.getSelectStatement()).isEqualTo(expectedStatement); - } - - @Test - void testCompoundJoin3() { - // this is a nonsensical join, but it does test the "and" capability - SelectStatementProvider selectStatement = select(orderMaster.orderId, orderDate, orderDetail.lineNumber, orderDetail.description, orderDetail.quantity) - .from(orderMaster, "om") - .join(orderDetail, "od", on(orderMaster.orderId, isEqualTo(orderDetail.orderId)), and(orderMaster.orderId, isEqualTo(orderDetail.orderId))) - .build() - .render(RenderingStrategies.MYBATIS3); - - String expectedStatement = "select om.order_id, om.order_date, od.line_number, od.description, od.quantity" - + " from OrderMaster om join OrderDetail od on om.order_id = od.order_id and om.order_id = od.order_id"; - assertThat(selectStatement.getSelectStatement()).isEqualTo(expectedStatement); - } - - @Test - void testCompoundJoin4() { - // this is a nonsensical join, but it does test the "and" capability - SelectStatementProvider selectStatement = select(orderMaster.orderId, orderDate, orderDetail.lineNumber, orderDetail.description, orderDetail.quantity) - .from(orderMaster, "om") - .leftJoin(orderDetail, "od", on(orderMaster.orderId, isEqualTo(orderDetail.orderId)), and(orderMaster.orderId, isEqualTo(orderDetail.orderId))) - .build() - .render(RenderingStrategies.MYBATIS3); - - String expectedStatement = "select om.order_id, om.order_date, od.line_number, od.description, od.quantity" - + " from OrderMaster om left join OrderDetail od on om.order_id = od.order_id and om.order_id = od.order_id"; - assertThat(selectStatement.getSelectStatement()).isEqualTo(expectedStatement); - } - - @Test - void testCompoundJoin5() { - // this is a nonsensical join, but it does test the "and" capability - SelectStatementProvider selectStatement = select(orderMaster.orderId, orderDate, orderDetail.lineNumber, orderDetail.description, orderDetail.quantity) - .from(orderMaster, "om") - .rightJoin(orderDetail, "od", on(orderMaster.orderId, isEqualTo(orderDetail.orderId)), and(orderMaster.orderId, isEqualTo(orderDetail.orderId))) - .build() - .render(RenderingStrategies.MYBATIS3); - - String expectedStatement = "select om.order_id, om.order_date, od.line_number, od.description, od.quantity" - + " from OrderMaster om right join OrderDetail od on om.order_id = od.order_id and om.order_id = od.order_id"; - assertThat(selectStatement.getSelectStatement()).isEqualTo(expectedStatement); - } - - @Test - void testCompoundJoin6() { - // this is a nonsensical join, but it does test the "and" capability - SelectStatementProvider selectStatement = select(orderMaster.orderId, orderDate, orderDetail.lineNumber, orderDetail.description, orderDetail.quantity) - .from(orderMaster, "om") - .fullJoin(orderDetail, "od", on(orderMaster.orderId, isEqualTo(orderDetail.orderId)), and(orderMaster.orderId, isEqualTo(orderDetail.orderId))) - .build() - .render(RenderingStrategies.MYBATIS3); - - String expectedStatement = "select om.order_id, om.order_date, od.line_number, od.description, od.quantity" - + " from OrderMaster om full join OrderDetail od on om.order_id = od.order_id and om.order_id = od.order_id"; - assertThat(selectStatement.getSelectStatement()).isEqualTo(expectedStatement); - } - - @Test - void testMultipleTableJoinWithWhereClause() { - try (SqlSession session = sqlSessionFactory.openSession()) { - JoinMapper mapper = session.getMapper(JoinMapper.class); - - SelectStatementProvider selectStatement = select(orderMaster.orderId, orderDate, orderLine.lineNumber, itemMaster.description, orderLine.quantity) - .from(orderMaster, "om") - .join(orderLine, "ol").on(orderMaster.orderId, isEqualTo(orderLine.orderId)) - .join(itemMaster, "im").on(orderLine.itemId, isEqualTo(itemMaster.itemId)) - .where(orderMaster.orderId, isEqualTo(2)) - .build() - .render(RenderingStrategies.MYBATIS3); - - String expectedStatement = "select om.order_id, om.order_date, ol.line_number, im.description, ol.quantity" - + " from OrderMaster om join OrderLine ol on om.order_id = ol.order_id join ItemMaster im on ol.item_id = im.item_id" - + " where om.order_id = #{parameters.p1,jdbcType=INTEGER}"; - assertThat(selectStatement.getSelectStatement()).isEqualTo(expectedStatement); - - List rows = mapper.selectMany(selectStatement); - - assertThat(rows).hasSize(1); - OrderMaster orderMaster = rows.get(0); - assertThat(orderMaster.getId()).isEqualTo(2); - assertThat(orderMaster.getDetails()).hasSize(2); - OrderDetail orderDetail = orderMaster.getDetails().get(0); - assertThat(orderDetail.getLineNumber()).isEqualTo(1); - orderDetail = orderMaster.getDetails().get(1); - assertThat(orderDetail.getLineNumber()).isEqualTo(2); - } - } - - @Test - void testMultipleTableJoinWithApplyWhere() { - try (SqlSession session = sqlSessionFactory.openSession()) { - JoinMapper mapper = session.getMapper(JoinMapper.class); - - SelectStatementProvider selectStatement = select(orderMaster.orderId, orderDate, orderLine.lineNumber, itemMaster.description, orderLine.quantity) - .from(orderMaster, "om") - .join(orderLine, "ol").on(orderMaster.orderId, isEqualTo(orderLine.orderId)) - .join(itemMaster, "im").on(orderLine.itemId, isEqualTo(itemMaster.itemId)) - .applyWhere(where(orderMaster.orderId, isEqualTo(2)).toWhereApplier()) - .build() - .render(RenderingStrategies.MYBATIS3); - - String expectedStatement = "select om.order_id, om.order_date, ol.line_number, im.description, ol.quantity" - + " from OrderMaster om join OrderLine ol on om.order_id = ol.order_id join ItemMaster im on ol.item_id = im.item_id" - + " where om.order_id = #{parameters.p1,jdbcType=INTEGER}"; - assertThat(selectStatement.getSelectStatement()).isEqualTo(expectedStatement); - - List rows = mapper.selectMany(selectStatement); - - assertThat(rows).hasSize(1); - OrderMaster orderMaster = rows.get(0); - assertThat(orderMaster.getId()).isEqualTo(2); - assertThat(orderMaster.getDetails()).hasSize(2); - OrderDetail orderDetail = orderMaster.getDetails().get(0); - assertThat(orderDetail.getLineNumber()).isEqualTo(1); - orderDetail = orderMaster.getDetails().get(1); - assertThat(orderDetail.getLineNumber()).isEqualTo(2); - } - } - - @Test - void testMultipleTableJoinWithComplexWhereClause() { - try (SqlSession session = sqlSessionFactory.openSession()) { - JoinMapper mapper = session.getMapper(JoinMapper.class); - - SelectStatementProvider selectStatement = select(orderMaster.orderId, orderDate, orderLine.lineNumber, itemMaster.description, orderLine.quantity) - .from(orderMaster, "om") - .join(orderLine, "ol").on(orderMaster.orderId, isEqualTo(orderLine.orderId)) - .join(itemMaster, "im").on(orderLine.itemId, isEqualTo(itemMaster.itemId)) - .where(orderMaster.orderId, isEqualTo(2), and(orderLine.lineNumber, isEqualTo(2))) - .build() - .render(RenderingStrategies.MYBATIS3); - - String expectedStatement = "select om.order_id, om.order_date, ol.line_number, im.description, ol.quantity" - + " from OrderMaster om join OrderLine ol on om.order_id = ol.order_id join ItemMaster im on ol.item_id = im.item_id" - + " where om.order_id = #{parameters.p1,jdbcType=INTEGER} and ol.line_number = #{parameters.p2,jdbcType=INTEGER}"; - assertThat(selectStatement.getSelectStatement()).isEqualTo(expectedStatement); - - List rows = mapper.selectMany(selectStatement); - - assertThat(rows).hasSize(1); - OrderMaster orderMaster = rows.get(0); - assertThat(orderMaster.getId()).isEqualTo(2); - assertThat(orderMaster.getDetails()).hasSize(1); - OrderDetail orderDetail = orderMaster.getDetails().get(0); - assertThat(orderDetail.getLineNumber()).isEqualTo(2); - } - } - - @Test - void testMultipleTableJoinWithOrderBy() { - try (SqlSession session = sqlSessionFactory.openSession()) { - JoinMapper mapper = session.getMapper(JoinMapper.class); - - SelectStatementProvider selectStatement = select(orderMaster.orderId, orderDate, orderLine.lineNumber, itemMaster.description, orderLine.quantity) - .from(orderMaster, "om") - .join(orderLine, "ol").on(orderMaster.orderId, isEqualTo(orderLine.orderId)) - .join(itemMaster, "im").on(orderLine.itemId, isEqualTo(itemMaster.itemId)) - .orderBy(orderMaster.orderId) - .build() - .render(RenderingStrategies.MYBATIS3); - - String expectedStatement = "select om.order_id, om.order_date, ol.line_number, im.description, ol.quantity" - + " from OrderMaster om join OrderLine ol on om.order_id = ol.order_id join ItemMaster im on ol.item_id = im.item_id" - + " order by order_id"; - assertThat(selectStatement.getSelectStatement()).isEqualTo(expectedStatement); - - List rows = mapper.selectMany(selectStatement); - - assertThat(rows).hasSize(2); - OrderMaster orderMaster = rows.get(0); - assertThat(orderMaster.getId()).isEqualTo(1); - assertThat(orderMaster.getDetails()).hasSize(1); - OrderDetail orderDetail = orderMaster.getDetails().get(0); - assertThat(orderDetail.getLineNumber()).isEqualTo(1); - - orderMaster = rows.get(1); - assertThat(orderMaster.getId()).isEqualTo(2); - assertThat(orderMaster.getDetails()).hasSize(2); - orderDetail = orderMaster.getDetails().get(0); - assertThat(orderDetail.getLineNumber()).isEqualTo(1); - orderDetail = orderMaster.getDetails().get(1); - assertThat(orderDetail.getLineNumber()).isEqualTo(2); - } - } - - @Test - void testMultipleTableJoinNoAliasWithOrderBy() { - try (SqlSession session = sqlSessionFactory.openSession()) { - JoinMapper mapper = session.getMapper(JoinMapper.class); - - SelectStatementProvider selectStatement = select(orderMaster.orderId, orderDate, orderLine.lineNumber, itemMaster.description, orderLine.quantity) - .from(orderMaster) - .join(orderLine).on(orderMaster.orderId, isEqualTo(orderLine.orderId)) - .join(itemMaster).on(orderLine.itemId, isEqualTo(itemMaster.itemId)) - .where(orderMaster.orderId, isEqualTo(2)) - .orderBy(orderMaster.orderId) - .build() - .render(RenderingStrategies.MYBATIS3); - - String expectedStatement = "select OrderMaster.order_id, OrderMaster.order_date, OrderLine.line_number, ItemMaster.description, OrderLine.quantity" - + " from OrderMaster join OrderLine on OrderMaster.order_id = OrderLine.order_id join ItemMaster on OrderLine.item_id = ItemMaster.item_id" - + " where OrderMaster.order_id = #{parameters.p1,jdbcType=INTEGER}" - + " order by order_id"; - assertThat(selectStatement.getSelectStatement()).isEqualTo(expectedStatement); - - List rows = mapper.selectMany(selectStatement); - - assertThat(rows).hasSize(1); - OrderMaster orderMaster = rows.get(0); - assertThat(orderMaster.getId()).isEqualTo(2); - assertThat(orderMaster.getDetails()).hasSize(2); - OrderDetail orderDetail = orderMaster.getDetails().get(0); - assertThat(orderDetail.getLineNumber()).isEqualTo(1); - orderDetail = orderMaster.getDetails().get(1); - assertThat(orderDetail.getLineNumber()).isEqualTo(2); - } - } - - @Test - void testRightJoin() { - try (SqlSession session = sqlSessionFactory.openSession()) { - CommonSelectMapper mapper = session.getMapper(CommonSelectMapper.class); - - SelectStatementProvider selectStatement = select(orderLine.orderId, orderLine.quantity, itemMaster.itemId, itemMaster.description) - .from(orderLine, "ol") - .rightJoin(itemMaster, "im").on(orderLine.itemId, isEqualTo(itemMaster.itemId)) - .orderBy(itemMaster.itemId) - .build() - .render(RenderingStrategies.MYBATIS3); - - String expectedStatement = "select ol.order_id, ol.quantity, im.item_id, im.description" - + " from OrderLine ol right join ItemMaster im on ol.item_id = im.item_id" - + " order by item_id"; - assertThat(selectStatement.getSelectStatement()).isEqualTo(expectedStatement); - - List> rows = mapper.selectManyMappedRows(selectStatement); - - assertThat(rows).hasSize(5); - Map row = rows.get(2); - assertThat(row).containsEntry("ORDER_ID", 1); - assertThat(row).containsEntry("QUANTITY", 1); - assertThat(row).containsEntry("DESCRIPTION", "First Base Glove"); - assertThat(row).containsEntry("ITEM_ID", 33); - - row = rows.get(4); - assertThat(row).doesNotContainKey("ORDER_ID"); - assertThat(row).doesNotContainKey("QUANTITY"); - assertThat(row).containsEntry("DESCRIPTION", "Catcher Glove"); - assertThat(row).containsEntry("ITEM_ID", 55); - } - } - - @Test - void testRightJoin2() { - try (SqlSession session = sqlSessionFactory.openSession()) { - CommonSelectMapper mapper = session.getMapper(CommonSelectMapper.class); - - SelectStatementProvider selectStatement = select(orderLine.orderId, orderLine.quantity, itemMaster.itemId, itemMaster.description) - .from(orderMaster, "om") - .join(orderLine, "ol").on(orderMaster.orderId, isEqualTo(orderLine.orderId)) - .rightJoin(itemMaster, "im").on(orderLine.itemId, isEqualTo(itemMaster.itemId)) - .orderBy(orderLine.orderId, itemMaster.itemId) - .build() - .render(RenderingStrategies.MYBATIS3); - - String expectedStatement = "select ol.order_id, ol.quantity, im.item_id, im.description" - + " from OrderMaster om join OrderLine ol on om.order_id = ol.order_id" - + " right join ItemMaster im on ol.item_id = im.item_id" - + " order by order_id, item_id"; - assertThat(selectStatement.getSelectStatement()).isEqualTo(expectedStatement); - - List> rows = mapper.selectManyMappedRows(selectStatement); - - assertThat(rows).hasSize(5); - Map row = rows.get(0); - assertThat(row).doesNotContainKey("ORDER_ID"); - assertThat(row).doesNotContainKey("QUANTITY"); - assertThat(row).containsEntry("DESCRIPTION", "Catcher Glove"); - assertThat(row).containsEntry("ITEM_ID", 55); - - row = rows.get(4); - assertThat(row).containsEntry("ORDER_ID", 2); - assertThat(row).containsEntry("QUANTITY", 1); - assertThat(row).containsEntry("DESCRIPTION", "Outfield Glove"); - assertThat(row).containsEntry("ITEM_ID", 44); - } - } - - @Test - void testRightJoin3() { - try (SqlSession session = sqlSessionFactory.openSession()) { - CommonSelectMapper mapper = session.getMapper(CommonSelectMapper.class); - - SelectStatementProvider selectStatement = select(orderLine.orderId, orderLine.quantity, itemMaster.itemId, itemMaster.description) - .from(orderMaster, "om") - .join(orderLine, "ol", on(orderMaster.orderId, isEqualTo(orderLine.orderId))) - .rightJoin(itemMaster, "im", on(orderLine.itemId, isEqualTo(itemMaster.itemId))) - .orderBy(orderLine.orderId, itemMaster.itemId) - .build() - .render(RenderingStrategies.MYBATIS3); - - String expectedStatement = "select ol.order_id, ol.quantity, im.item_id, im.description" - + " from OrderMaster om join OrderLine ol on om.order_id = ol.order_id" - + " right join ItemMaster im on ol.item_id = im.item_id" - + " order by order_id, item_id"; - assertThat(selectStatement.getSelectStatement()).isEqualTo(expectedStatement); - - List> rows = mapper.selectManyMappedRows(selectStatement); - - assertThat(rows).hasSize(5); - Map row = rows.get(0); - assertThat(row).doesNotContainKey("ORDER_ID"); - assertThat(row).doesNotContainKey("QUANTITY"); - assertThat(row).containsEntry("DESCRIPTION", "Catcher Glove"); - assertThat(row).containsEntry("ITEM_ID", 55); - - row = rows.get(4); - assertThat(row).containsEntry("ORDER_ID", 2); - assertThat(row).containsEntry("QUANTITY", 1); - assertThat(row).containsEntry("DESCRIPTION", "Outfield Glove"); - assertThat(row).containsEntry("ITEM_ID", 44); - } - } - - @Test - void testRightJoinNoAliases() { - try (SqlSession session = sqlSessionFactory.openSession()) { - CommonSelectMapper mapper = session.getMapper(CommonSelectMapper.class); - - SelectStatementProvider selectStatement = select(orderLine.orderId, orderLine.quantity, itemMaster.itemId, itemMaster.description) - .from(orderMaster) - .join(orderLine).on(orderMaster.orderId, isEqualTo(orderLine.orderId)) - .rightJoin(itemMaster).on(orderLine.itemId, isEqualTo(itemMaster.itemId)) - .orderBy(orderLine.orderId, itemMaster.itemId) - .build() - .render(RenderingStrategies.MYBATIS3); - - String expectedStatement = "select OrderLine.order_id, OrderLine.quantity, ItemMaster.item_id, ItemMaster.description" - + " from OrderMaster join OrderLine on OrderMaster.order_id = OrderLine.order_id" - + " right join ItemMaster on OrderLine.item_id = ItemMaster.item_id" - + " order by order_id, item_id"; - assertThat(selectStatement.getSelectStatement()).isEqualTo(expectedStatement); - - List> rows = mapper.selectManyMappedRows(selectStatement); - - assertThat(rows).hasSize(5); - Map row = rows.get(0); - assertThat(row).doesNotContainKey("ORDER_ID"); - assertThat(row).doesNotContainKey("QUANTITY"); - assertThat(row).containsEntry("DESCRIPTION", "Catcher Glove"); - assertThat(row).containsEntry("ITEM_ID", 55); - - row = rows.get(4); - assertThat(row).containsEntry("ORDER_ID", 2); - assertThat(row).containsEntry("QUANTITY", 1); - assertThat(row).containsEntry("DESCRIPTION", "Outfield Glove"); - assertThat(row).containsEntry("ITEM_ID", 44); - } - } - - @Test - void testLeftJoin() { - try (SqlSession session = sqlSessionFactory.openSession()) { - CommonSelectMapper mapper = session.getMapper(CommonSelectMapper.class); - - SelectStatementProvider selectStatement = select(orderLine.orderId, orderLine.quantity, itemMaster.itemId, itemMaster.description) - .from(itemMaster, "im") - .leftJoin(orderLine, "ol").on(orderLine.itemId, isEqualTo(itemMaster.itemId)) - .orderBy(itemMaster.itemId) - .build() - .render(RenderingStrategies.MYBATIS3); - - String expectedStatement = "select ol.order_id, ol.quantity, im.item_id, im.description" - + " from ItemMaster im left join OrderLine ol on ol.item_id = im.item_id" - + " order by item_id"; - assertThat(selectStatement.getSelectStatement()).isEqualTo(expectedStatement); - - List> rows = mapper.selectManyMappedRows(selectStatement); - - assertThat(rows).hasSize(5); - Map row = rows.get(2); - assertThat(row).containsEntry("ORDER_ID", 1); - assertThat(row).containsEntry("QUANTITY", 1); - assertThat(row).containsEntry("DESCRIPTION", "First Base Glove"); - assertThat(row).containsEntry("ITEM_ID", 33); - - row = rows.get(4); - assertThat(row).doesNotContainKey("ORDER_ID"); - assertThat(row).doesNotContainKey("QUANTITY"); - assertThat(row).containsEntry("DESCRIPTION", "Catcher Glove"); - assertThat(row).containsEntry("ITEM_ID", 55); - } - } - - @Test - void testLeftJoin2() { - try (SqlSession session = sqlSessionFactory.openSession()) { - CommonSelectMapper mapper = session.getMapper(CommonSelectMapper.class); - - SelectStatementProvider selectStatement = select(orderLine.orderId, orderLine.quantity, itemMaster.itemId, itemMaster.description) - .from(orderMaster, "om") - .join(orderLine, "ol").on(orderMaster.orderId, isEqualTo(orderLine.orderId)) - .leftJoin(itemMaster, "im").on(orderLine.itemId, isEqualTo(itemMaster.itemId)) - .orderBy(orderLine.orderId, itemMaster.itemId) - .build() - .render(RenderingStrategies.MYBATIS3); - - String expectedStatement = "select ol.order_id, ol.quantity, im.item_id, im.description" - + " from OrderMaster om join OrderLine ol on om.order_id = ol.order_id" - + " left join ItemMaster im on ol.item_id = im.item_id" - + " order by order_id, item_id"; - assertThat(selectStatement.getSelectStatement()).isEqualTo(expectedStatement); - - List> rows = mapper.selectManyMappedRows(selectStatement); - - assertThat(rows).hasSize(5); - Map row = rows.get(2); - assertThat(row).containsEntry("ORDER_ID", 2); - assertThat(row).containsEntry("QUANTITY", 6); - assertThat(row).doesNotContainKey("DESCRIPTION"); - assertThat(row).doesNotContainKey("ITEM_ID"); - - row = rows.get(4); - assertThat(row).containsEntry("ORDER_ID", 2); - assertThat(row).containsEntry("QUANTITY", 1); - assertThat(row).containsEntry("DESCRIPTION", "Outfield Glove"); - assertThat(row).containsEntry("ITEM_ID", 44); - } - } - - @Test - void testLeftJoin3() { - try (SqlSession session = sqlSessionFactory.openSession()) { - CommonSelectMapper mapper = session.getMapper(CommonSelectMapper.class); - - SelectStatementProvider selectStatement = select(orderLine.orderId, orderLine.quantity, itemMaster.itemId, itemMaster.description) - .from(orderMaster, "om") - .join(orderLine, "ol", on(orderMaster.orderId, isEqualTo(orderLine.orderId))) - .leftJoin(itemMaster, "im", on(orderLine.itemId, isEqualTo(itemMaster.itemId))) - .orderBy(orderLine.orderId, itemMaster.itemId) - .build() - .render(RenderingStrategies.MYBATIS3); - - String expectedStatement = "select ol.order_id, ol.quantity, im.item_id, im.description" - + " from OrderMaster om join OrderLine ol on om.order_id = ol.order_id" - + " left join ItemMaster im on ol.item_id = im.item_id" - + " order by order_id, item_id"; - assertThat(selectStatement.getSelectStatement()).isEqualTo(expectedStatement); - - List> rows = mapper.selectManyMappedRows(selectStatement); - - assertThat(rows).hasSize(5); - Map row = rows.get(2); - assertThat(row).containsEntry("ORDER_ID", 2); - assertThat(row).containsEntry("QUANTITY", 6); - assertThat(row).doesNotContainKey("DESCRIPTION"); - assertThat(row).doesNotContainKey("ITEM_ID"); - - row = rows.get(4); - assertThat(row).containsEntry("ORDER_ID", 2); - assertThat(row).containsEntry("QUANTITY", 1); - assertThat(row).containsEntry("DESCRIPTION", "Outfield Glove"); - assertThat(row).containsEntry("ITEM_ID", 44); - } - } - - @Test - void testLeftJoinNoAliases() { - try (SqlSession session = sqlSessionFactory.openSession()) { - CommonSelectMapper mapper = session.getMapper(CommonSelectMapper.class); - - SelectStatementProvider selectStatement = select(orderLine.orderId, orderLine.quantity, itemMaster.itemId, itemMaster.description) - .from(orderMaster) - .join(orderLine).on(orderMaster.orderId, isEqualTo(orderLine.orderId)) - .leftJoin(itemMaster).on(orderLine.itemId, isEqualTo(itemMaster.itemId)) - .orderBy(orderLine.orderId, itemMaster.itemId) - .build() - .render(RenderingStrategies.MYBATIS3); - - String expectedStatement = "select OrderLine.order_id, OrderLine.quantity, ItemMaster.item_id, ItemMaster.description" - + " from OrderMaster join OrderLine on OrderMaster.order_id = OrderLine.order_id" - + " left join ItemMaster on OrderLine.item_id = ItemMaster.item_id" - + " order by order_id, item_id"; - assertThat(selectStatement.getSelectStatement()).isEqualTo(expectedStatement); - - List> rows = mapper.selectManyMappedRows(selectStatement); - - assertThat(rows).hasSize(5); - Map row = rows.get(2); - assertThat(row).containsEntry("ORDER_ID", 2); - assertThat(row).containsEntry("QUANTITY", 6); - assertThat(row).doesNotContainKey("DESCRIPTION"); - assertThat(row).doesNotContainKey("ITEM_ID"); - - row = rows.get(4); - assertThat(row).containsEntry("ORDER_ID", 2); - assertThat(row).containsEntry("QUANTITY", 1); - assertThat(row).containsEntry("DESCRIPTION", "Outfield Glove"); - assertThat(row).containsEntry("ITEM_ID", 44); - } - } - - @Test - void testFullJoin() { - try (SqlSession session = sqlSessionFactory.openSession()) { - CommonSelectMapper mapper = session.getMapper(CommonSelectMapper.class); - - SelectStatementProvider selectStatement = select(orderLine.orderId, orderLine.quantity, orderLine.itemId.as("ol_itemid"), itemMaster.itemId.as("im_itemid"), itemMaster.description) - .from(itemMaster, "im") - .fullJoin(orderLine, "ol").on(itemMaster.itemId, isEqualTo(orderLine.itemId)) - .orderBy(orderLine.orderId, sortColumn("im_itemid")) - .build() - .render(RenderingStrategies.MYBATIS3); - - String expectedStatement = "select ol.order_id, ol.quantity, ol.item_id as ol_itemid, im.item_id as im_itemid, im.description" - + " from ItemMaster im full join OrderLine ol on im.item_id = ol.item_id" - + " order by order_id, im_itemid"; - assertThat(selectStatement.getSelectStatement()).isEqualTo(expectedStatement); - - List> rows = mapper.selectManyMappedRows(selectStatement); - - assertThat(rows).hasSize(6); - Map row = rows.get(0); - assertThat(row).doesNotContainKey("ORDER_ID"); - assertThat(row).doesNotContainKey("QUANTITY"); - assertThat(row).containsEntry("DESCRIPTION", "Catcher Glove"); - assertThat(row).containsEntry("IM_ITEMID", 55); - - row = rows.get(2); - assertThat(row).containsEntry("ORDER_ID", 1); - assertThat(row).containsEntry("QUANTITY", 1); - assertThat(row).containsEntry("DESCRIPTION", "First Base Glove"); - assertThat(row).containsEntry("IM_ITEMID", 33); - - row = rows.get(3); - assertThat(row).containsEntry("ORDER_ID", 2); - assertThat(row).containsEntry("QUANTITY", 6); - assertThat(row).containsEntry("OL_ITEMID", 66); - assertThat(row).doesNotContainKey("DESCRIPTION"); - assertThat(row).doesNotContainKey("IM_ITEMID"); - } - } - - @Test - void testFullJoin2() { - try (SqlSession session = sqlSessionFactory.openSession()) { - CommonSelectMapper mapper = session.getMapper(CommonSelectMapper.class); - - SelectStatementProvider selectStatement = select(orderLine.orderId, orderLine.quantity, itemMaster.itemId, itemMaster.description) - .from(orderMaster, "om") - .join(orderLine, "ol").on(orderMaster.orderId, isEqualTo(orderLine.orderId)) - .fullJoin(itemMaster, "im").on(orderLine.itemId, isEqualTo(itemMaster.itemId)) - .orderBy(orderLine.orderId, itemMaster.itemId) - .build() - .render(RenderingStrategies.MYBATIS3); - - String expectedStatement = "select ol.order_id, ol.quantity, im.item_id, im.description" - + " from OrderMaster om join OrderLine ol on om.order_id = ol.order_id" - + " full join ItemMaster im on ol.item_id = im.item_id" - + " order by order_id, item_id"; - assertThat(selectStatement.getSelectStatement()).isEqualTo(expectedStatement); - - List> rows = mapper.selectManyMappedRows(selectStatement); - - assertThat(rows).hasSize(6); - Map row = rows.get(0); - assertThat(row).doesNotContainKey("ORDER_ID"); - assertThat(row).doesNotContainKey("QUANTITY"); - assertThat(row).containsEntry("DESCRIPTION", "Catcher Glove"); - assertThat(row).containsEntry("ITEM_ID", 55); - - row = rows.get(3); - assertThat(row).containsEntry("ORDER_ID", 2); - assertThat(row).containsEntry("QUANTITY", 6); - assertThat(row).doesNotContainKey("DESCRIPTION"); - assertThat(row).doesNotContainKey("ITEM_ID"); - - row = rows.get(5); - assertThat(row).containsEntry("ORDER_ID", 2); - assertThat(row).containsEntry("QUANTITY", 1); - assertThat(row).containsEntry("DESCRIPTION", "Outfield Glove"); - assertThat(row).containsEntry("ITEM_ID", 44); - } - } - - @Test - void testFullJoin3() { - try (SqlSession session = sqlSessionFactory.openSession()) { - CommonSelectMapper mapper = session.getMapper(CommonSelectMapper.class); - - SelectStatementProvider selectStatement = select(orderLine.orderId, orderLine.quantity, itemMaster.itemId, itemMaster.description) - .from(orderMaster, "om") - .join(orderLine, "ol", on(orderMaster.orderId, isEqualTo(orderLine.orderId))) - .fullJoin(itemMaster, "im", on(orderLine.itemId, isEqualTo(itemMaster.itemId))) - .orderBy(orderLine.orderId, itemMaster.itemId) - .build() - .render(RenderingStrategies.MYBATIS3); - - String expectedStatement = "select ol.order_id, ol.quantity, im.item_id, im.description" - + " from OrderMaster om join OrderLine ol on om.order_id = ol.order_id" - + " full join ItemMaster im on ol.item_id = im.item_id" - + " order by order_id, item_id"; - assertThat(selectStatement.getSelectStatement()).isEqualTo(expectedStatement); - - List> rows = mapper.selectManyMappedRows(selectStatement); - - assertThat(rows).hasSize(6); - Map row = rows.get(0); - assertThat(row).doesNotContainKey("ORDER_ID"); - assertThat(row).doesNotContainKey("QUANTITY"); - assertThat(row).containsEntry("DESCRIPTION", "Catcher Glove"); - assertThat(row).containsEntry("ITEM_ID", 55); - - row = rows.get(3); - assertThat(row).containsEntry("ORDER_ID", 2); - assertThat(row).containsEntry("QUANTITY", 6); - assertThat(row).doesNotContainKey("DESCRIPTION"); - assertThat(row).doesNotContainKey("ITEM_ID"); - - row = rows.get(5); - assertThat(row).containsEntry("ORDER_ID", 2); - assertThat(row).containsEntry("QUANTITY", 1); - assertThat(row).containsEntry("DESCRIPTION", "Outfield Glove"); - assertThat(row).containsEntry("ITEM_ID", 44); - } - } - - @Test - void testFullJoin4() { - try (SqlSession session = sqlSessionFactory.openSession()) { - CommonSelectMapper mapper = session.getMapper(CommonSelectMapper.class); - - SelectStatementProvider selectStatement = select(orderLine.orderId, orderLine.quantity, itemMaster.description) - .from(orderMaster, "om") - .join(orderLine, "ol", on(orderMaster.orderId, isEqualTo(orderLine.orderId))) - .fullJoin(itemMaster, "im", on(orderLine.itemId, isEqualTo(itemMaster.itemId))) - .orderBy(orderLine.orderId, sortColumn("im", itemMaster.itemId)) - .build() - .render(RenderingStrategies.MYBATIS3); - - String expectedStatement = "select ol.order_id, ol.quantity, im.description" - + " from OrderMaster om join OrderLine ol on om.order_id = ol.order_id" - + " full join ItemMaster im on ol.item_id = im.item_id" - + " order by order_id, im.item_id"; - assertThat(selectStatement.getSelectStatement()).isEqualTo(expectedStatement); - - List> rows = mapper.selectManyMappedRows(selectStatement); - - assertThat(rows).hasSize(6); - Map row = rows.get(0); - assertThat(row).doesNotContainKey("ORDER_ID"); - assertThat(row).doesNotContainKey("QUANTITY"); - assertThat(row).containsEntry("DESCRIPTION", "Catcher Glove"); - - row = rows.get(3); - assertThat(row).containsEntry("ORDER_ID", 2); - assertThat(row).containsEntry("QUANTITY", 6); - assertThat(row).doesNotContainKey("DESCRIPTION"); - - row = rows.get(5); - assertThat(row).containsEntry("ORDER_ID", 2); - assertThat(row).containsEntry("QUANTITY", 1); - assertThat(row).containsEntry("DESCRIPTION", "Outfield Glove"); - } - } - - @Test - void testFullJoin5() { - try (SqlSession session = sqlSessionFactory.openSession()) { - CommonSelectMapper mapper = session.getMapper(CommonSelectMapper.class); - - SelectStatementProvider selectStatement = select(orderLine.orderId, orderLine.quantity, itemMaster.description) - .from(orderMaster, "om") - .join(orderLine, "ol", on(orderMaster.orderId, isEqualTo(orderLine.orderId))) - .fullJoin(itemMaster, "im", on(orderLine.itemId, isEqualTo(itemMaster.itemId))) - .orderBy(orderLine.orderId, sortColumn("im", itemMaster.itemId).descending()) - .build() - .render(RenderingStrategies.MYBATIS3); - - String expectedStatement = "select ol.order_id, ol.quantity, im.description" - + " from OrderMaster om join OrderLine ol on om.order_id = ol.order_id" - + " full join ItemMaster im on ol.item_id = im.item_id" - + " order by order_id, im.item_id DESC"; - assertThat(selectStatement.getSelectStatement()).isEqualTo(expectedStatement); - - List> rows = mapper.selectManyMappedRows(selectStatement); - - assertThat(rows).hasSize(6); - Map row = rows.get(0); - assertThat(row).doesNotContainKey("ORDER_ID"); - assertThat(row).doesNotContainKey("QUANTITY"); - assertThat(row).containsEntry("DESCRIPTION", "Catcher Glove"); - - row = rows.get(3); - assertThat(row).containsEntry("ORDER_ID", 2); - assertThat(row).containsEntry("QUANTITY", 6); - assertThat(row).doesNotContainKey("DESCRIPTION"); - - row = rows.get(5); - assertThat(row).containsEntry("ORDER_ID", 2); - assertThat(row).containsEntry("QUANTITY", 1); - assertThat(row).containsEntry("DESCRIPTION", "Helmet"); - } - } - - @Test - void testFullJoinNoAliases() { - try (SqlSession session = sqlSessionFactory.openSession()) { - CommonSelectMapper mapper = session.getMapper(CommonSelectMapper.class); - - SelectStatementProvider selectStatement = select(orderLine.orderId, orderLine.quantity, itemMaster.itemId, itemMaster.description) - .from(orderMaster) - .join(orderLine).on(orderMaster.orderId, isEqualTo(orderLine.orderId)) - .fullJoin(itemMaster).on(orderLine.itemId, isEqualTo(itemMaster.itemId)) - .orderBy(orderLine.orderId, itemMaster.itemId) - .build() - .render(RenderingStrategies.MYBATIS3); - - String expectedStatement = "select OrderLine.order_id, OrderLine.quantity, ItemMaster.item_id, ItemMaster.description" - + " from OrderMaster join OrderLine on OrderMaster.order_id = OrderLine.order_id" - + " full join ItemMaster on OrderLine.item_id = ItemMaster.item_id" - + " order by order_id, item_id"; - assertThat(selectStatement.getSelectStatement()).isEqualTo(expectedStatement); - - List> rows = mapper.selectManyMappedRows(selectStatement); - - assertThat(rows).hasSize(6); - Map row = rows.get(0); - assertThat(row).doesNotContainKey("ORDER_ID"); - assertThat(row).doesNotContainKey("QUANTITY"); - assertThat(row).containsEntry("DESCRIPTION", "Catcher Glove"); - assertThat(row).containsEntry("ITEM_ID", 55); - - row = rows.get(3); - assertThat(row).containsEntry("ORDER_ID", 2); - assertThat(row).containsEntry("QUANTITY", 6); - assertThat(row).doesNotContainKey("DESCRIPTION"); - assertThat(row).doesNotContainKey("ITEM_ID"); - - row = rows.get(5); - assertThat(row).containsEntry("ORDER_ID", 2); - assertThat(row).containsEntry("QUANTITY", 1); - assertThat(row).containsEntry("DESCRIPTION", "Outfield Glove"); - assertThat(row).containsEntry("ITEM_ID", 44); - } - } - - @Test - void testSelf() { - try (SqlSession session = sqlSessionFactory.openSession()) { - JoinMapper mapper = session.getMapper(JoinMapper.class); - - // create second table instance for self-join - UserDynamicSQLSupport.User user2 = new UserDynamicSQLSupport.User(); - - // get Bamm Bamm's parent - should be Barney - SelectStatementProvider selectStatement = select(user.userId, user.userName, user.parentId) - .from(user, "u1") - .join(user2, "u2").on(user.userId, isEqualTo(user2.parentId)) - .where(user2.userId, isEqualTo(4)) - .build() - .render(RenderingStrategies.MYBATIS3); - - String expectedStatement = "select u1.user_id, u1.user_name, u1.parent_id" - + " from User u1 join User u2 on u1.user_id = u2.parent_id" - + " where u2.user_id = #{parameters.p1,jdbcType=INTEGER}"; - assertThat(selectStatement.getSelectStatement()).isEqualTo(expectedStatement); - - List rows = mapper.selectUsers(selectStatement); - - assertThat(rows).hasSize(1); - User row = rows.get(0); - assertThat(row.getUserId()).isEqualTo(2); - assertThat(row.getUserName()).isEqualTo("Barney"); - assertThat(row.getParentId()).isNull(); - } - } - - @Test - void testSelfWithDuplicateAlias() { - QueryExpressionDSL dsl = select(user.userId, user.userName, user.parentId) - .from(user, "u1"); - - assertThatExceptionOfType(DuplicateTableAliasException.class).isThrownBy(() -> dsl.join(user, "u2")) - .withMessage(Messages.getString("ERROR.1", user.tableName(), "u2", "u1")); - } - - @Test - void testSelfWithNewAlias() { - try (SqlSession session = sqlSessionFactory.openSession()) { - JoinMapper mapper = session.getMapper(JoinMapper.class); - - // create second table instance for self-join - UserDynamicSQLSupport.User user2 = user.withAlias("u2"); - - // get Bamm Bamm's parent - should be Barney - SelectStatementProvider selectStatement = select(user.userId, user.userName, user.parentId) - .from(user) - .join(user2).on(user.userId, isEqualTo(user2.parentId)) - .where(user2.userId, isEqualTo(4)) - .build() - .render(RenderingStrategies.MYBATIS3); - - String expectedStatement = "select User.user_id, User.user_name, User.parent_id" - + " from User join User u2 on User.user_id = u2.parent_id" - + " where u2.user_id = #{parameters.p1,jdbcType=INTEGER}"; - assertThat(selectStatement.getSelectStatement()).isEqualTo(expectedStatement); - - List rows = mapper.selectUsers(selectStatement); - - assertThat(rows).hasSize(1); - User row = rows.get(0); - assertThat(row.getUserId()).isEqualTo(2); - assertThat(row.getUserName()).isEqualTo("Barney"); - assertThat(row.getParentId()).isNull(); - } - } - - @Test - void testSelfWithNewAliasAndOverride() { - try (SqlSession session = sqlSessionFactory.openSession()) { - JoinMapper mapper = session.getMapper(JoinMapper.class); - - // create second table instance for self-join - UserDynamicSQLSupport.User user2 = user.withAlias("other_user"); - - // get Bamm Bamm's parent - should be Barney - SelectStatementProvider selectStatement = select(user.userId, user.userName, user.parentId) - .from(user, "u1") - .join(user2, "u2").on(user.userId, isEqualTo(user2.parentId)) - .where(user2.userId, isEqualTo(4)) - .build() - .render(RenderingStrategies.MYBATIS3); - - String expectedStatement = "select u1.user_id, u1.user_name, u1.parent_id" - + " from User u1 join User u2 on u1.user_id = u2.parent_id" - + " where u2.user_id = #{parameters.p1,jdbcType=INTEGER}"; - assertThat(selectStatement.getSelectStatement()).isEqualTo(expectedStatement); - - List rows = mapper.selectUsers(selectStatement); - - assertThat(rows).hasSize(1); - User row = rows.get(0); - assertThat(row.getUserId()).isEqualTo(2); - assertThat(row.getUserName()).isEqualTo("Barney"); - assertThat(row.getParentId()).isNull(); - } - } - - @Test - void testLimitAndOffsetAfterJoin() { - try (SqlSession session = sqlSessionFactory.openSession()) { - CommonSelectMapper mapper = session.getMapper(CommonSelectMapper.class); - - SelectStatementProvider selectStatement = select(orderLine.orderId, orderLine.quantity, itemMaster.itemId, itemMaster.description) - .from(itemMaster, "im") - .leftJoin(orderLine, "ol").on(orderLine.itemId, isEqualTo(itemMaster.itemId)) - .limit(2) - .offset(1) - .build() - .render(RenderingStrategies.MYBATIS3); - - String expectedStatement = "select ol.order_id, ol.quantity, im.item_id, im.description" - + " from ItemMaster im left join OrderLine ol on ol.item_id = im.item_id" - + " limit #{parameters.p1} offset #{parameters.p2}"; - assertThat(selectStatement.getSelectStatement()).isEqualTo(expectedStatement); - - List> rows = mapper.selectManyMappedRows(selectStatement); - - assertThat(rows).hasSize(2); - Map row = rows.get(0); - assertThat(row).containsEntry("ORDER_ID", 2); - assertThat(row).containsEntry("QUANTITY", 1); - assertThat(row).containsEntry("DESCRIPTION", "Helmet"); - assertThat(row).containsEntry("ITEM_ID", 22); - - row = rows.get(1); - assertThat(row).containsEntry("ORDER_ID", 1); - assertThat(row).containsEntry("QUANTITY", 1); - assertThat(row).containsEntry("DESCRIPTION", "First Base Glove"); - assertThat(row).containsEntry("ITEM_ID", 33); - } - } - - @Test - void testLimitOnlyAfterJoin() { - try (SqlSession session = sqlSessionFactory.openSession()) { - CommonSelectMapper mapper = session.getMapper(CommonSelectMapper.class); - - SelectStatementProvider selectStatement = select(orderLine.orderId, orderLine.quantity, itemMaster.itemId, itemMaster.description) - .from(itemMaster, "im") - .leftJoin(orderLine, "ol").on(orderLine.itemId, isEqualTo(itemMaster.itemId)) - .limit(2) - .build() - .render(RenderingStrategies.MYBATIS3); - - String expectedStatement = "select ol.order_id, ol.quantity, im.item_id, im.description" - + " from ItemMaster im left join OrderLine ol on ol.item_id = im.item_id" - + " limit #{parameters.p1}"; - assertThat(selectStatement.getSelectStatement()).isEqualTo(expectedStatement); - - List> rows = mapper.selectManyMappedRows(selectStatement); - - assertThat(rows).hasSize(2); - Map row = rows.get(0); - assertThat(row).containsEntry("ORDER_ID", 1); - assertThat(row).containsEntry("QUANTITY", 1); - assertThat(row).containsEntry("DESCRIPTION", "Helmet"); - assertThat(row).containsEntry("ITEM_ID", 22); - - row = rows.get(1); - assertThat(row).containsEntry("ORDER_ID", 2); - assertThat(row).containsEntry("QUANTITY", 1); - assertThat(row).containsEntry("DESCRIPTION", "Helmet"); - assertThat(row).containsEntry("ITEM_ID", 22); - } - } - - @Test - void testOffsetOnlyAfterJoin() { - try (SqlSession session = sqlSessionFactory.openSession()) { - CommonSelectMapper mapper = session.getMapper(CommonSelectMapper.class); - - SelectStatementProvider selectStatement = select(orderLine.orderId, orderLine.quantity, itemMaster.itemId, itemMaster.description) - .from(itemMaster, "im") - .leftJoin(orderLine, "ol").on(orderLine.itemId, isEqualTo(itemMaster.itemId)) - .offset(2) - .build() - .render(RenderingStrategies.MYBATIS3); - - String expectedStatement = "select ol.order_id, ol.quantity, im.item_id, im.description" - + " from ItemMaster im left join OrderLine ol on ol.item_id = im.item_id" - + " offset #{parameters.p1} rows"; - assertThat(selectStatement.getSelectStatement()).isEqualTo(expectedStatement); - - List> rows = mapper.selectManyMappedRows(selectStatement); - - assertThat(rows).hasSize(3); - Map row = rows.get(0); - assertThat(row).containsEntry("ORDER_ID", 1); - assertThat(row).containsEntry("QUANTITY", 1); - assertThat(row).containsEntry("DESCRIPTION", "First Base Glove"); - assertThat(row).containsEntry("ITEM_ID", 33); - - row = rows.get(1); - assertThat(row).containsEntry("ORDER_ID", 2); - assertThat(row).containsEntry("QUANTITY", 1); - assertThat(row).containsEntry("DESCRIPTION", "Outfield Glove"); - assertThat(row).containsEntry("ITEM_ID", 44); - } - } - - @Test - void testOffsetAndFetchFirstAfterJoin() { - try (SqlSession session = sqlSessionFactory.openSession()) { - CommonSelectMapper mapper = session.getMapper(CommonSelectMapper.class); - - SelectStatementProvider selectStatement = select(orderLine.orderId, orderLine.quantity, itemMaster.itemId, itemMaster.description) - .from(itemMaster, "im") - .leftJoin(orderLine, "ol").on(orderLine.itemId, isEqualTo(itemMaster.itemId)) - .offset(1) - .fetchFirst(2).rowsOnly() - .build() - .render(RenderingStrategies.MYBATIS3); - - String expectedStatement = "select ol.order_id, ol.quantity, im.item_id, im.description" - + " from ItemMaster im left join OrderLine ol on ol.item_id = im.item_id" - + " offset #{parameters.p1} rows fetch first #{parameters.p2} rows only"; - assertThat(selectStatement.getSelectStatement()).isEqualTo(expectedStatement); - - List> rows = mapper.selectManyMappedRows(selectStatement); - - assertThat(rows).hasSize(2); - Map row = rows.get(0); - assertThat(row).containsEntry("ORDER_ID", 2); - assertThat(row).containsEntry("QUANTITY", 1); - assertThat(row).containsEntry("DESCRIPTION", "Helmet"); - assertThat(row).containsEntry("ITEM_ID", 22); - - row = rows.get(1); - assertThat(row).containsEntry("ORDER_ID", 1); - assertThat(row).containsEntry("QUANTITY", 1); - assertThat(row).containsEntry("DESCRIPTION", "First Base Glove"); - assertThat(row).containsEntry("ITEM_ID", 33); - } - } - - @Test - void testFetchFirstOnlyAfterJoin() { - try (SqlSession session = sqlSessionFactory.openSession()) { - CommonSelectMapper mapper = session.getMapper(CommonSelectMapper.class); - - SelectStatementProvider selectStatement = select(orderLine.orderId, orderLine.quantity, itemMaster.itemId, itemMaster.description) - .from(itemMaster, "im") - .leftJoin(orderLine, "ol").on(orderLine.itemId, isEqualTo(itemMaster.itemId)) - .fetchFirst(2).rowsOnly() - .build() - .render(RenderingStrategies.MYBATIS3); - - String expectedStatement = "select ol.order_id, ol.quantity, im.item_id, im.description" - + " from ItemMaster im left join OrderLine ol on ol.item_id = im.item_id" - + " fetch first #{parameters.p1} rows only"; - assertThat(selectStatement.getSelectStatement()).isEqualTo(expectedStatement); - - List> rows = mapper.selectManyMappedRows(selectStatement); - - assertThat(rows).hasSize(2); - Map row = rows.get(0); - assertThat(row).containsEntry("ORDER_ID", 1); - assertThat(row).containsEntry("QUANTITY", 1); - assertThat(row).containsEntry("DESCRIPTION", "Helmet"); - assertThat(row).containsEntry("ITEM_ID", 22); - - row = rows.get(1); - assertThat(row).containsEntry("ORDER_ID", 2); - assertThat(row).containsEntry("QUANTITY", 1); - assertThat(row).containsEntry("DESCRIPTION", "Helmet"); - assertThat(row).containsEntry("ITEM_ID", 22); - } - } - - @Test - void testJoinWithParameterValue() { - try (SqlSession session = sqlSessionFactory.openSession()) { - CommonSelectMapper mapper = session.getMapper(CommonSelectMapper.class); - - SelectStatementProvider selectStatement = select(orderLine.orderId, orderLine.quantity, itemMaster.itemId, itemMaster.description) - .from(itemMaster, "im") - .join(orderLine, "ol").on(orderLine.itemId, isEqualTo(itemMaster.itemId)) - .and(orderLine.orderId, isEqualTo(1)) - .build() - .render(RenderingStrategies.MYBATIS3); - - String expectedStatement = "select ol.order_id, ol.quantity, im.item_id, im.description" - + " from ItemMaster im join OrderLine ol on ol.item_id = im.item_id" - + " and ol.order_id = #{parameters.p1,jdbcType=INTEGER}"; - assertThat(selectStatement.getSelectStatement()).isEqualTo(expectedStatement); - - List> rows = mapper.selectManyMappedRows(selectStatement); - - assertThat(rows).hasSize(2); - Map row = rows.get(0); - assertThat(row).containsEntry("ORDER_ID", 1); - assertThat(row).containsEntry("QUANTITY", 1); - assertThat(row).containsEntry("DESCRIPTION", "Helmet"); - assertThat(row).containsEntry("ITEM_ID", 22); - - row = rows.get(1); - assertThat(row).containsEntry("ORDER_ID", 1); - assertThat(row).containsEntry("QUANTITY", 1); - assertThat(row).containsEntry("DESCRIPTION", "First Base Glove"); - assertThat(row).containsEntry("ITEM_ID", 33); - } - } - - @Test - void testJoinWithConstant() { - try (SqlSession session = sqlSessionFactory.openSession()) { - CommonSelectMapper mapper = session.getMapper(CommonSelectMapper.class); - - SelectStatementProvider selectStatement = select(orderLine.orderId, orderLine.quantity, itemMaster.itemId, itemMaster.description) - .from(itemMaster, "im") - .join(orderLine, "ol").on(orderLine.itemId, isEqualTo(itemMaster.itemId)) - .and(orderLine.orderId, isEqualTo(constant("1"))) - .build() - .render(RenderingStrategies.MYBATIS3); - - String expectedStatement = "select ol.order_id, ol.quantity, im.item_id, im.description" - + " from ItemMaster im join OrderLine ol on ol.item_id = im.item_id" - + " and ol.order_id = 1"; - assertThat(selectStatement.getSelectStatement()).isEqualTo(expectedStatement); - - List> rows = mapper.selectManyMappedRows(selectStatement); - - assertThat(rows).hasSize(2); - Map row = rows.get(0); - assertThat(row).containsEntry("ORDER_ID", 1); - assertThat(row).containsEntry("QUANTITY", 1); - assertThat(row).containsEntry("DESCRIPTION", "Helmet"); - assertThat(row).containsEntry("ITEM_ID", 22); - - row = rows.get(1); - assertThat(row).containsEntry("ORDER_ID", 1); - assertThat(row).containsEntry("QUANTITY", 1); - assertThat(row).containsEntry("DESCRIPTION", "First Base Glove"); - assertThat(row).containsEntry("ITEM_ID", 33); - } - } -} diff --git a/src/test/java/examples/simple/PersonMapper.java b/src/test/java/examples/simple/PersonMapper.java index bb9560f75..d31f4af1a 100644 --- a/src/test/java/examples/simple/PersonMapper.java +++ b/src/test/java/examples/simple/PersonMapper.java @@ -90,9 +90,9 @@ default int delete(DeleteDSLCompleter completer) { return MyBatis3Utils.deleteFrom(this::delete, person, completer); } - default int deleteByPrimaryKey(Integer id_) { + default int deleteByPrimaryKey(Integer recordId) { return delete(c -> - c.where(id, isEqualTo(id_)) + c.where(id, isEqualTo(recordId)) ); } @@ -152,9 +152,9 @@ default List selectDistinct(SelectDSLCompleter completer) { return MyBatis3Utils.selectDistinct(this::selectMany, selectList, person, completer); } - default Optional selectByPrimaryKey(Integer id_) { + default Optional selectByPrimaryKey(Integer recordId) { return selectOne(c -> - c.where(id, isEqualTo(id_)) + c.where(id, isEqualTo(recordId)) ); } diff --git a/src/test/java/examples/simple/PersonWithAddressMapper.java b/src/test/java/examples/simple/PersonWithAddressMapper.java index a36946bad..dc47df896 100644 --- a/src/test/java/examples/simple/PersonWithAddressMapper.java +++ b/src/test/java/examples/simple/PersonWithAddressMapper.java @@ -80,25 +80,25 @@ public interface PersonWithAddressMapper extends CommonCountMapper { default Optional selectOne(SelectDSLCompleter completer) { QueryExpressionDSL start = SqlBuilder.select(selectList).from(person) - .join(address, on(person.addressId, equalTo(address.id))); + .join(address, on(person.addressId, isEqualTo(address.id))); return MyBatis3Utils.selectOne(this::selectOne, start, completer); } default List select(SelectDSLCompleter completer) { QueryExpressionDSL start = SqlBuilder.select(selectList).from(person) - .join(address, on(person.addressId, equalTo(address.id))); + .join(address, on(person.addressId, isEqualTo(address.id))); return MyBatis3Utils.selectList(this::selectMany, start, completer); } - default Optional selectByPrimaryKey(Integer id_) { + default Optional selectByPrimaryKey(Integer recordId) { return selectOne(c -> - c.where(id, isEqualTo(id_)) + c.where(id, isEqualTo(recordId)) ); } default long count(CountDSLCompleter completer) { CountDSL start = countFrom(person) - .join(address, on(person.addressId, equalTo(address.id))); + .join(address, on(person.addressId, isEqualTo(address.id))); return MyBatis3Utils.countFrom(this::count, start, completer); } } diff --git a/src/test/java/examples/spring/PersonTemplateTest.java b/src/test/java/examples/spring/PersonTemplateTest.java index 2cd2b6b42..2f0e5b2dc 100644 --- a/src/test/java/examples/spring/PersonTemplateTest.java +++ b/src/test/java/examples/spring/PersonTemplateTest.java @@ -633,7 +633,7 @@ void testJoinAllRows() { Buildable selectStatement = select(id, firstName, lastName, birthDate, employed, occupation, address.id, address.streetAddress, address.city, address.state) .from(person) - .join(address, on(person.addressId, equalTo(address.id))) + .join(address, on(person.addressId, isEqualTo(address.id))) .orderBy(id); List records = template.selectList(selectStatement, personWithAddressRowMapper); @@ -656,7 +656,7 @@ void testJoinOneRow() { Buildable selectStatement = select(id, firstName, lastName, birthDate, employed, occupation, address.id, address.streetAddress, address.city, address.state) .from(person) - .join(address, on(person.addressId, equalTo(address.id))) + .join(address, on(person.addressId, isEqualTo(address.id))) .where(id, isEqualTo(1)); List records = template.selectList(selectStatement, personWithAddressRowMapper); @@ -679,7 +679,7 @@ void testJoinPrimaryKey() { Buildable selectStatement = select(id, firstName, lastName, birthDate, employed, occupation, address.id, address.streetAddress, address.city, address.state) .from(person) - .join(address, on(person.addressId, equalTo(address.id))) + .join(address, on(person.addressId, isEqualTo(address.id))) .where(id, isEqualTo(1)); Optional row = template.selectOne(selectStatement, personWithAddressRowMapper); @@ -703,7 +703,7 @@ void testJoinPrimaryKeyInvalidRecord() { Buildable selectStatement = select(id, firstName, lastName, birthDate, employed, occupation, address.id, address.streetAddress, address.city, address.state) .from(person) - .join(address, on(person.addressId, equalTo(address.id))) + .join(address, on(person.addressId, isEqualTo(address.id))) .where(id, isEqualTo(55)); Optional row = template.selectOne(selectStatement, personWithAddressRowMapper); @@ -713,7 +713,7 @@ void testJoinPrimaryKeyInvalidRecord() { @Test void testJoinCount() { Buildable countStatement = countFrom(person) - .join(address, on(person.addressId, equalTo(address.id))) + .join(address, on(person.addressId, isEqualTo(address.id))) .where(id, isEqualTo(55)); long count = template.count(countStatement); @@ -723,7 +723,7 @@ void testJoinCount() { @Test void testJoinCountWithSubCriteria() { Buildable countStatement = countFrom(person) - .join(address, on(person.addressId, equalTo(address.id))) + .join(address, on(person.addressId, isEqualTo(address.id))) .where(person.id, isEqualTo(55), or(person.id, isEqualTo(1))); long count = template.count(countStatement); diff --git a/src/test/java/examples/spring/SpringMapToRowTest.java b/src/test/java/examples/spring/SpringMapToRowTest.java index c3b1077c9..d87c67201 100644 --- a/src/test/java/examples/spring/SpringMapToRowTest.java +++ b/src/test/java/examples/spring/SpringMapToRowTest.java @@ -24,7 +24,6 @@ import static org.mybatis.dynamic.sql.SqlBuilder.insertMultiple; import static org.mybatis.dynamic.sql.SqlBuilder.select; -import java.util.ArrayList; import java.util.List; import java.util.stream.IntStream; diff --git a/src/test/java/issues/gh100/FromJoinWhereTest.java b/src/test/java/issues/gh100/FromJoinWhereTest.java index 47867128d..6695d56a6 100644 --- a/src/test/java/issues/gh100/FromJoinWhereTest.java +++ b/src/test/java/issues/gh100/FromJoinWhereTest.java @@ -32,7 +32,7 @@ void testNormalUsage() { SelectStatementProvider selectStatement = select(StudentDynamicSqlSupport.id, StudentDynamicSqlSupport.name, StudentDynamicSqlSupport.idcard) .from(StudentDynamicSqlSupport.student) .join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)) + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)) .where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")) .union() .select(StudentDynamicSqlSupport.id, StudentDynamicSqlSupport.name, StudentDynamicSqlSupport.idcard) @@ -76,7 +76,7 @@ void testFromJoinB1() { .from(StudentDynamicSqlSupport.student); builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); String expected = "select student.id, student.name, student.idcard" + " from student" @@ -93,7 +93,7 @@ void testFromJoinB2() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); String expected = "select student.id, student.name, student.idcard" + " from student" @@ -110,7 +110,7 @@ void testfromJoinWhereB1() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -130,7 +130,7 @@ void testfromJoinWhereB2() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -150,7 +150,7 @@ void testfromJoinWhereB3() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -170,7 +170,7 @@ void testFromJoinWhereUnionB1() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -197,7 +197,7 @@ void testFromJoinWhereUnionB2() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -224,7 +224,7 @@ void testFromJoinWhereUnionB3() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -251,7 +251,7 @@ void testFromJoinWhereUnionB4() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -278,7 +278,7 @@ void testFromJoinWhereUnionUnionB1() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -316,7 +316,7 @@ void testFromJoinWhereUnionUnionB2() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -354,7 +354,7 @@ void testFromJoinWhereUnionUnionB3() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -392,7 +392,7 @@ void testFromJoinWhereUnionUnionB4() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -430,7 +430,7 @@ void testFromJoinWhereUnionUnionB5() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -468,7 +468,7 @@ void testFromJoinWhereUnionOrderByB1() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -498,7 +498,7 @@ void testFromJoinWhereUnionOrderByB2() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -528,7 +528,7 @@ void testFromJoinWhereUnionOrderByB3() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -558,7 +558,7 @@ void testFromJoinWhereUnionOrderByB4() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -588,7 +588,7 @@ void testFromJoinWhereUnionOrderByB5() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -618,7 +618,7 @@ void testFromJoinWhereUnionOrderByLimitB1() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -651,7 +651,7 @@ void testFromJoinWhereUnionOrderByLimitB2() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -684,7 +684,7 @@ void testFromJoinWhereUnionOrderByLimitB3() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -717,7 +717,7 @@ void testFromJoinWhereUnionOrderByLimitB4() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -750,7 +750,7 @@ void testFromJoinWhereUnionOrderByLimitB5() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -783,7 +783,7 @@ void testFromJoinWhereUnionOrderByLimitB6() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -816,7 +816,7 @@ void testFromJoinWhereUnionOrderByLimitOffsetB1() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -852,7 +852,7 @@ void testFromJoinWhereUnionOrderByLimitOffsetB2() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -888,7 +888,7 @@ void testFromJoinWhereUnionOrderByLimitOffsetB3() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -924,7 +924,7 @@ void testFromJoinWhereUnionOrderByLimitOffsetB4() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -960,7 +960,7 @@ void testFromJoinWhereUnionOrderByLimitOffsetB5() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -996,7 +996,7 @@ void testFromJoinWhereUnionOrderByLimitOffsetB6() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -1032,7 +1032,7 @@ void testFromJoinWhereUnionOrderByLimitOffsetB7() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -1068,7 +1068,7 @@ void testFromJoinWhereUnionOrderByOffsetB1() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -1102,7 +1102,7 @@ void testFromJoinWhereUnionOrderByOffsetB2() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -1136,7 +1136,7 @@ void testFromJoinWhereUnionOrderByOffsetB3() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -1170,7 +1170,7 @@ void testFromJoinWhereUnionOrderByOffsetB4() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -1204,7 +1204,7 @@ void testFromJoinWhereUnionOrderByOffsetB5() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -1238,7 +1238,7 @@ void testFromJoinWhereUnionOrderByOffsetB6() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -1272,7 +1272,7 @@ void testFromJoinWhereUnionOrderByOffsetFetchFirstB1() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -1308,7 +1308,7 @@ void testFromJoinWhereUnionOrderByOffsetFetchFirstB2() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -1344,7 +1344,7 @@ void testFromJoinWhereUnionOrderByOffsetFetchFirstB3() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -1380,7 +1380,7 @@ void testFromJoinWhereUnionOrderByOffsetFetchFirstB4() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -1416,7 +1416,7 @@ void testFromJoinWhereUnionOrderByOffsetFetchFirstB5() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -1452,7 +1452,7 @@ void testFromJoinWhereUnionOrderByOffsetFetchFirstB6() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -1488,7 +1488,7 @@ void testFromJoinWhereUnionOrderByOffsetFetchFirstB7() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -1524,7 +1524,7 @@ void testFromJoinWhereUnionOrderByFetchFirstB1() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -1557,7 +1557,7 @@ void testFromJoinWhereUnionOrderByFetchFirstB2() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -1590,7 +1590,7 @@ void testFromJoinWhereUnionOrderByFetchFirstB3() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -1623,7 +1623,7 @@ void testFromJoinWhereUnionOrderByFetchFirstB4() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -1656,7 +1656,7 @@ void testFromJoinWhereUnionOrderByFetchFirstB5() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -1689,7 +1689,7 @@ void testFromJoinWhereUnionOrderByFetchFirstB6() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -1722,7 +1722,7 @@ void testFromJoinWhereUnionLimitB1() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -1752,7 +1752,7 @@ void testFromJoinWhereUnionLimitB2() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -1782,7 +1782,7 @@ void testFromJoinWhereUnionLimitB3() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -1812,7 +1812,7 @@ void testFromJoinWhereUnionLimitB4() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -1842,7 +1842,7 @@ void testFromJoinWhereUnionLimitB5() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -1872,7 +1872,7 @@ void testFromJoinWhereUnionLimitOffsetB1() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -1905,7 +1905,7 @@ void testFromJoinWhereUnionLimitOffsetB2() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -1938,7 +1938,7 @@ void testFromJoinWhereUnionLimitOffsetB3() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -1971,7 +1971,7 @@ void testFromJoinWhereUnionLimitOffsetB4() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -2004,7 +2004,7 @@ void testFromJoinWhereUnionLimitOffsetB5() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -2037,7 +2037,7 @@ void testFromJoinWhereUnionLimitOffsetB6() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -2070,7 +2070,7 @@ void testFromJoinWhereUnionOffsetB1() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -2100,7 +2100,7 @@ void testFromJoinWhereUnionOffsetB2() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -2130,7 +2130,7 @@ void testFromJoinWhereUnionOffsetB3() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -2160,7 +2160,7 @@ void testFromJoinWhereUnionOffsetB4() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -2190,7 +2190,7 @@ void testFromJoinWhereUnionOffsetB5() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -2220,7 +2220,7 @@ void testFromJoinWhereUnionOffsetFetchFirstB1() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -2253,7 +2253,7 @@ void testFromJoinWhereUnionOffsetFetchFirstB2() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -2286,7 +2286,7 @@ void testFromJoinWhereUnionOffsetFetchFirstB3() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -2319,7 +2319,7 @@ void testFromJoinWhereUnionOffsetFetchFirstB4() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -2352,7 +2352,7 @@ void testFromJoinWhereUnionOffsetFetchFirstB5() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -2385,7 +2385,7 @@ void testFromJoinWhereUnionOffsetFetchFirstB6() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -2418,7 +2418,7 @@ void testFromJoinWhereUnionFetchFirstB1() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -2448,7 +2448,7 @@ void testFromJoinWhereUnionFetchFirstB2() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -2478,7 +2478,7 @@ void testFromJoinWhereUnionFetchFirstB3() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -2508,7 +2508,7 @@ void testFromJoinWhereUnionFetchFirstB4() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -2538,7 +2538,7 @@ void testFromJoinWhereUnionFetchFirstB5() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -2568,7 +2568,7 @@ void testFromJoinWhereOrderByB1() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -2591,7 +2591,7 @@ void testFromJoinWhereOrderByB2() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -2614,7 +2614,7 @@ void testFromJoinWhereOrderByB3() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -2637,7 +2637,7 @@ void testFromJoinWhereOrderByB4() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -2660,7 +2660,7 @@ void testFromJoinWhereOrderByLimitB1() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -2686,7 +2686,7 @@ void testFromJoinWhereOrderByLimitB2() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -2712,7 +2712,7 @@ void testFromJoinWhereOrderByLimitB3() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -2738,7 +2738,7 @@ void testFromJoinWhereOrderByLimitB4() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -2764,7 +2764,7 @@ void testFromJoinWhereOrderByLimitB5() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -2790,7 +2790,7 @@ void testFromJoinWhereOrderByLimitOffsetB1() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -2819,7 +2819,7 @@ void testFromJoinWhereOrderByLimitOffsetB2() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -2848,7 +2848,7 @@ void testFromJoinWhereOrderByLimitOffsetB3() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -2877,7 +2877,7 @@ void testFromJoinWhereOrderByLimitOffsetB4() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -2906,7 +2906,7 @@ void testFromJoinWhereOrderByLimitOffsetB5() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -2935,7 +2935,7 @@ void testFromJoinWhereOrderByLimitOffsetB6() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -2964,7 +2964,7 @@ void testFromJoinWhereOrderByOffsetB1() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -2990,7 +2990,7 @@ void testFromJoinWhereOrderByOffsetB2() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -3016,7 +3016,7 @@ void testFromJoinWhereOrderByOffsetB3() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -3042,7 +3042,7 @@ void testFromJoinWhereOrderByOffsetB4() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -3068,7 +3068,7 @@ void testFromJoinWhereOrderByOffsetB5() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -3094,7 +3094,7 @@ void testFromJoinWhereOrderByOffsetFetchFirstB1() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -3123,7 +3123,7 @@ void testFromJoinWhereOrderByOffsetFetchFirstB2() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -3152,7 +3152,7 @@ void testFromJoinWhereOrderByOffsetFetchFirstB3() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -3181,7 +3181,7 @@ void testFromJoinWhereOrderByOffsetFetchFirstB4() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -3210,7 +3210,7 @@ void testFromJoinWhereOrderByOffsetFetchFirstB5() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -3239,7 +3239,7 @@ void testFromJoinWhereOrderByOffsetFetchFirstB6() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -3268,7 +3268,7 @@ void testFromJoinWhereOrderByFetchFirstB1() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -3294,7 +3294,7 @@ void testFromJoinWhereOrderByFetchFirstB2() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -3320,7 +3320,7 @@ void testFromJoinWhereOrderByFetchFirstB3() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -3346,7 +3346,7 @@ void testFromJoinWhereOrderByFetchFirstB4() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -3372,7 +3372,7 @@ void testFromJoinWhereOrderByFetchFirstB5() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -3398,7 +3398,7 @@ void testFromJoinWhereLimitB1() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -3421,7 +3421,7 @@ void testFromJoinWhereLimitB2() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -3444,7 +3444,7 @@ void testFromJoinWhereLimitB3() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -3467,7 +3467,7 @@ void testFromJoinWhereLimitB4() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -3490,7 +3490,7 @@ void testFromJoinWhereLimitOffsetB1() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -3516,7 +3516,7 @@ void testFromJoinWhereLimitOffsetB2() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -3542,7 +3542,7 @@ void testFromJoinWhereLimitOffsetB3() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -3568,7 +3568,7 @@ void testFromJoinWhereLimitOffsetB4() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -3594,7 +3594,7 @@ void testFromJoinWhereLimitOffsetB5() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -3620,7 +3620,7 @@ void testFromJoinWhereOffsetB1() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -3643,7 +3643,7 @@ void testFromJoinWhereOffsetB2() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -3666,7 +3666,7 @@ void testFromJoinWhereOffsetB3() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -3689,7 +3689,7 @@ void testFromJoinWhereOffsetB4() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -3712,7 +3712,7 @@ void testFromJoinWhereOffsetFetchFirstB1() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -3738,7 +3738,7 @@ void testFromJoinWhereOffsetFetchFirstB2() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -3764,7 +3764,7 @@ void testFromJoinWhereOffsetFetchFirstB3() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -3790,7 +3790,7 @@ void testFromJoinWhereOffsetFetchFirstB4() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -3816,7 +3816,7 @@ void testFromJoinWhereOffsetFetchFirstB5() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -3842,7 +3842,7 @@ void testFromJoinWhereFetchFirstB1() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -3865,7 +3865,7 @@ void testFromJoinWhereFetchFirstB2() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -3888,7 +3888,7 @@ void testFromJoinWhereFetchFirstB3() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -3911,7 +3911,7 @@ void testFromJoinWhereFetchFirstB4() { .from(StudentDynamicSqlSupport.student); QueryExpressionDSL.JoinSpecificationFinisher builder2 = builder1.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); QueryExpressionDSL.QueryExpressionWhereBuilder builder3 = builder2.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); diff --git a/src/test/java/issues/gh100/Issue100StartAfterJoinTest.java b/src/test/java/issues/gh100/Issue100StartAfterJoinTest.java index 9c3631c4d..aff76db96 100644 --- a/src/test/java/issues/gh100/Issue100StartAfterJoinTest.java +++ b/src/test/java/issues/gh100/Issue100StartAfterJoinTest.java @@ -32,7 +32,7 @@ void testSuccessiveBuild02() { QueryExpressionDSL.JoinSpecificationFinisher builder = select(StudentDynamicSqlSupport.id, StudentDynamicSqlSupport.name, StudentDynamicSqlSupport.idcard) .from(StudentDynamicSqlSupport.student) .join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); builder.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); @@ -50,7 +50,7 @@ void testSuccessiveBuild03() { QueryExpressionDSL.JoinSpecificationFinisher builder = select(StudentDynamicSqlSupport.id, StudentDynamicSqlSupport.name, StudentDynamicSqlSupport.idcard) .from(StudentDynamicSqlSupport.student) .join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); SelectDSL selectModel = builder.orderBy(StudentDynamicSqlSupport.id); @@ -71,7 +71,7 @@ void testSuccessiveBuild04() { QueryExpressionDSL.JoinSpecificationFinisher builder = select(StudentDynamicSqlSupport.id, StudentDynamicSqlSupport.name, StudentDynamicSqlSupport.idcard) .from(StudentDynamicSqlSupport.student) .join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); builder.limit(3); @@ -89,7 +89,7 @@ void testSuccessiveBuild05() { QueryExpressionDSL.JoinSpecificationFinisher builder = select(StudentDynamicSqlSupport.id, StudentDynamicSqlSupport.name, StudentDynamicSqlSupport.idcard) .from(StudentDynamicSqlSupport.student) .join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); builder.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")) .orderBy(StudentDynamicSqlSupport.id) @@ -113,7 +113,7 @@ void testSuccessiveBuild06() { QueryExpressionDSL.JoinSpecificationFinisher builder = select(StudentDynamicSqlSupport.id, StudentDynamicSqlSupport.name, StudentDynamicSqlSupport.idcard) .from(StudentDynamicSqlSupport.student) .join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); builder.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")) .orderBy(StudentDynamicSqlSupport.id) @@ -135,7 +135,7 @@ void testSuccessiveBuild07() { QueryExpressionDSL.JoinSpecificationFinisher builder = select(StudentDynamicSqlSupport.id, StudentDynamicSqlSupport.name, StudentDynamicSqlSupport.idcard) .from(StudentDynamicSqlSupport.student) .join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); builder.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")) .orderBy(StudentDynamicSqlSupport.id) @@ -159,7 +159,7 @@ void testSuccessiveBuild08() { QueryExpressionDSL.JoinSpecificationFinisher builder = select(StudentDynamicSqlSupport.id, StudentDynamicSqlSupport.name, StudentDynamicSqlSupport.idcard) .from(StudentDynamicSqlSupport.student) .join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); builder.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")) .orderBy(StudentDynamicSqlSupport.id) diff --git a/src/test/java/issues/gh100/Issue100Test.java b/src/test/java/issues/gh100/Issue100Test.java index f0411c774..01a8e0b0e 100644 --- a/src/test/java/issues/gh100/Issue100Test.java +++ b/src/test/java/issues/gh100/Issue100Test.java @@ -31,7 +31,7 @@ void testNormalUsage() { SelectStatementProvider selectStatement = select(StudentDynamicSqlSupport.id, StudentDynamicSqlSupport.name, StudentDynamicSqlSupport.idcard) .from(StudentDynamicSqlSupport.student) .join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)) + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)) .where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")) .union() .select(StudentDynamicSqlSupport.id, StudentDynamicSqlSupport.name, StudentDynamicSqlSupport.idcard) @@ -60,7 +60,7 @@ void testSuccessiveBuild01() { .from(StudentDynamicSqlSupport.student); builder.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); SelectStatementProvider selectStatement = builder.build() .render(RenderingStrategies.MYBATIS3); @@ -76,7 +76,7 @@ void testSuccessiveBuild02() { .from(StudentDynamicSqlSupport.student); builder.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)) + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)) .where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); SelectStatementProvider selectStatement = builder.build() @@ -94,7 +94,7 @@ void testSuccessiveBuild03() { .from(StudentDynamicSqlSupport.student); builder.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)) + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)) .where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")) .orderBy(StudentDynamicSqlSupport.id); @@ -114,7 +114,7 @@ void testSuccessiveBuild04() { .from(StudentDynamicSqlSupport.student); builder.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)) + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)) .where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")) .orderBy(StudentDynamicSqlSupport.id) .limit(3); @@ -136,7 +136,7 @@ void testSuccessiveBuild05() { .from(StudentDynamicSqlSupport.student); builder.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)) + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)) .where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")) .orderBy(StudentDynamicSqlSupport.id) .limit(3) @@ -182,8 +182,8 @@ void testSuccessiveBuild07() { .from(StudentDynamicSqlSupport.student); builder.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)) - .where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")) + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)) + .where(StudentDynamicSqlSupport.idcard, equalTo("fred")) .orderBy(StudentDynamicSqlSupport.id) .offset(2) .fetchFirst(3).rowsOnly(); @@ -206,7 +206,7 @@ void testSuccessiveBuild08() { .from(StudentDynamicSqlSupport.student); builder.join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)) + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)) .where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")) .orderBy(StudentDynamicSqlSupport.id) .fetchFirst(3).rowsOnly(); @@ -227,7 +227,7 @@ void test3() { QueryExpressionDSL.JoinSpecificationFinisher on = select(StudentDynamicSqlSupport.id, StudentDynamicSqlSupport.name, StudentDynamicSqlSupport.idcard) .from(StudentDynamicSqlSupport.student) .join(StudentRegDynamicSqlSupport.studentReg) - .on(StudentDynamicSqlSupport.id, equalTo(StudentRegDynamicSqlSupport.studentid)); + .on(StudentDynamicSqlSupport.id, isEqualTo(StudentRegDynamicSqlSupport.studentid)); on.where(StudentDynamicSqlSupport.idcard, isEqualTo("fred")); diff --git a/src/test/java/issues/gh324/NameTableMapper.java b/src/test/java/issues/gh324/NameTableMapper.java index 1ba3d0428..6a71f7cc0 100644 --- a/src/test/java/issues/gh324/NameTableMapper.java +++ b/src/test/java/issues/gh324/NameTableMapper.java @@ -49,9 +49,9 @@ default Optional selectOne(SelectDSLCompleter completer) { return MyBatis3Utils.selectOne(this::selectOne, selectList, nameTable, completer); } - default Optional selectByPrimaryKey(Integer id_) { + default Optional selectByPrimaryKey(Integer recordId) { return selectOne(c -> - c.where(id, isEqualTo(id_)) + c.where(id, isEqualTo(recordId)) ); } diff --git a/src/test/java/org/mybatis/dynamic/sql/where/condition/FilterAndMapTest.java b/src/test/java/org/mybatis/dynamic/sql/where/condition/FilterAndMapTest.java index 3e35af01b..3ab419b33 100644 --- a/src/test/java/org/mybatis/dynamic/sql/where/condition/FilterAndMapTest.java +++ b/src/test/java/org/mybatis/dynamic/sql/where/condition/FilterAndMapTest.java @@ -20,7 +20,6 @@ import java.util.List; import java.util.Objects; -import java.util.stream.Collectors; import org.junit.jupiter.api.Test; import org.mybatis.dynamic.sql.SqlBuilder; @@ -432,7 +431,7 @@ void testIsInRenderableMapShouldReturnMappedObject() { IsIn cond = SqlBuilder.isIn("Fred", "Wilma"); assertThat(cond.isEmpty()).isFalse(); IsIn mapped = cond.map(String::toUpperCase); - List mappedValues = mapped.values().collect(Collectors.toList()); + List mappedValues = mapped.values().toList(); assertThat(mappedValues).containsExactly("FRED", "WILMA"); } @@ -441,31 +440,31 @@ void testIsNotInRenderableMapShouldReturnMappedObject() { IsNotIn cond = SqlBuilder.isNotIn("Fred", "Wilma"); assertThat(cond.isEmpty()).isFalse(); IsNotIn mapped = cond.map(String::toUpperCase); - List mappedValues = mapped.values().collect(Collectors.toList()); + List mappedValues = mapped.values().toList(); assertThat(mappedValues).containsExactly("FRED", "WILMA"); } @Test void testIsNotInCaseInsensitiveRenderableMapShouldReturnMappedObject() { IsNotInCaseInsensitive cond = SqlBuilder.isNotInCaseInsensitive("Fred ", "Wilma "); - List values = cond.values().collect(Collectors.toList()); + List values = cond.values().toList(); assertThat(values).containsExactly("FRED ", "WILMA "); assertThat(cond.isEmpty()).isFalse(); IsNotInCaseInsensitive mapped = cond.map(String::trim); - List mappedValues = mapped.values().collect(Collectors.toList()); + List mappedValues = mapped.values().toList(); assertThat(mappedValues).containsExactly("FRED", "WILMA"); } @Test void testIsInCaseInsensitiveRenderableMapShouldReturnMappedObject() { IsInCaseInsensitive cond = SqlBuilder.isInCaseInsensitive("Fred ", "Wilma "); - List values = cond.values().collect(Collectors.toList()); + List values = cond.values().toList(); assertThat(values).containsExactly("FRED ", "WILMA "); assertThat(cond.isEmpty()).isFalse(); IsInCaseInsensitive mapped = cond.map(String::trim); - List mappedValues = mapped.values().collect(Collectors.toList()); + List mappedValues = mapped.values().toList(); assertThat(mappedValues).containsExactly("FRED", "WILMA"); } diff --git a/src/test/kotlin/examples/kotlin/mybatis3/canonical/PersonWithAddressMapperExtensions.kt b/src/test/kotlin/examples/kotlin/mybatis3/canonical/PersonWithAddressMapperExtensions.kt index c24c3a967..df4c91da8 100644 --- a/src/test/kotlin/examples/kotlin/mybatis3/canonical/PersonWithAddressMapperExtensions.kt +++ b/src/test/kotlin/examples/kotlin/mybatis3/canonical/PersonWithAddressMapperExtensions.kt @@ -35,8 +35,8 @@ private val columnList = listOf(id `as` "A_ID", firstName, lastName, birthDate, fun PersonWithAddressMapper.selectOne(completer: SelectCompleter): PersonWithAddress? = select(columnList) { from(person) - fullJoin(address) { - on(person.addressId) equalTo address.id + fullJoin(address) on { + person.addressId isEqualTo address.id } completer() }.run(this::selectOne) @@ -44,8 +44,8 @@ fun PersonWithAddressMapper.selectOne(completer: SelectCompleter): PersonWithAdd fun PersonWithAddressMapper.select(completer: SelectCompleter): List = select(columnList) { from(person, "p") - fullJoin(address) { - on(person.addressId) equalTo address.id + fullJoin(address) on { + person.addressId isEqualTo address.id } completer() }.run(this::selectMany) @@ -53,8 +53,8 @@ fun PersonWithAddressMapper.select(completer: SelectCompleter): List = selectDistinct(columnList) { from(person) - fullJoin(address) { - on(person.addressId) equalTo address.id + fullJoin(address) on { + person.addressId isEqualTo address.id } completer() }.run(this::selectMany) diff --git a/src/test/kotlin/examples/kotlin/mybatis3/general/GeneralKotlinTest.kt b/src/test/kotlin/examples/kotlin/mybatis3/general/GeneralKotlinTest.kt index 68d073cc9..4f0368248 100644 --- a/src/test/kotlin/examples/kotlin/mybatis3/general/GeneralKotlinTest.kt +++ b/src/test/kotlin/examples/kotlin/mybatis3/general/GeneralKotlinTest.kt @@ -367,8 +367,8 @@ class GeneralKotlinTest { address.id, address.streetAddress, address.city, address.state ) { from(person) - join(address) { - on(addressId) equalTo address.id + join(address) on { + addressId isEqualTo address.id } where { id isLessThan 4 } orderBy(id) @@ -403,8 +403,8 @@ class GeneralKotlinTest { address.id, address.streetAddress, address.city, address.state ) { from(person) - join(address) { - on(addressId) equalTo address.id + join(address) on { + addressId isEqualTo address.id } where { id isLessThan 5 @@ -446,8 +446,8 @@ class GeneralKotlinTest { address.id, address.streetAddress, address.city, address.state ) { from(person) - join(address) { - on(addressId) equalTo address.id + join(address) on { + addressId isEqualTo address.id } where { id isEqualTo 5 diff --git a/src/test/kotlin/examples/kotlin/mybatis3/joins/JoinMapperTest.kt b/src/test/kotlin/examples/kotlin/mybatis3/joins/DeprecatedJoinMapperTest.kt similarity index 66% rename from src/test/kotlin/examples/kotlin/mybatis3/joins/JoinMapperTest.kt rename to src/test/kotlin/examples/kotlin/mybatis3/joins/DeprecatedJoinMapperTest.kt index 5754fe631..7a05b79e4 100644 --- a/src/test/kotlin/examples/kotlin/mybatis3/joins/JoinMapperTest.kt +++ b/src/test/kotlin/examples/kotlin/mybatis3/joins/DeprecatedJoinMapperTest.kt @@ -30,14 +30,12 @@ import org.junit.jupiter.api.Test import org.junit.jupiter.api.TestInstance import org.mybatis.dynamic.sql.util.Messages import org.mybatis.dynamic.sql.util.kotlin.KInvalidSQLException -import org.mybatis.dynamic.sql.util.kotlin.elements.constant import org.mybatis.dynamic.sql.util.kotlin.elements.invoke -import org.mybatis.dynamic.sql.util.kotlin.elements.max import org.mybatis.dynamic.sql.util.kotlin.mybatis3.select @Suppress("LargeClass") @TestInstance(TestInstance.Lifecycle.PER_CLASS) -class JoinMapperTest { +class DeprecatedJoinMapperTest { private lateinit var sqlSessionFactory: SqlSessionFactory @BeforeAll @@ -48,45 +46,6 @@ class JoinMapperTest { } } - @Test - fun testSingleTableJoin() { - sqlSessionFactory.openSession().use { session -> - val mapper = session.getMapper(JoinMapper::class.java) - - val selectStatement = select( - orderMaster.orderId, orderMaster.orderDate, - orderDetail.lineNumber, orderDetail.description, orderDetail.quantity - ) { - from(orderMaster, "om") - join(orderDetail, "od") { - on(orderMaster.orderId) equalTo orderDetail.orderId - } - } - - val expectedStatement = "select om.order_id, om.order_date, od.line_number, od.description, od.quantity" + - " from OrderMaster om join OrderDetail od on om.order_id = od.order_id" - - assertThat(selectStatement.selectStatement).isEqualTo(expectedStatement) - - val rows = mapper.selectMany(selectStatement) - - assertThat(rows).hasSize(2) - - with(rows[0]) { - assertThat(id).isEqualTo(1) - assertThat(details).hasSize(2) - assertThat(details?.get(0)?.lineNumber).isEqualTo(1) - assertThat(details?.get(1)?.lineNumber).isEqualTo(2) - } - - with(rows[1]) { - assertThat(id).isEqualTo(2) - assertThat(details).hasSize(1) - assertThat(details?.get(0)?.lineNumber).isEqualTo(1) - } - } - } - @Test fun testSingleTableJoinWithValue() { sqlSessionFactory.openSession().use { session -> @@ -96,51 +55,16 @@ class JoinMapperTest { orderMaster.orderId, orderMaster.orderDate, orderDetail.lineNumber, orderDetail.description, orderDetail.quantity ) { - from(orderMaster, "om") - join(orderDetail, "od") { + from(orderMaster) + join(orderDetail) { on(orderMaster.orderId) equalTo orderDetail.orderId and(orderMaster.orderId) equalTo 1 } } - val expectedStatement = "select om.order_id, om.order_date, od.line_number, od.description, od.quantity" + - " from OrderMaster om join OrderDetail od on om.order_id = od.order_id" + - " and om.order_id = #{parameters.p1,jdbcType=INTEGER}" - - assertThat(selectStatement.selectStatement).isEqualTo(expectedStatement) - - val rows = mapper.selectMany(selectStatement) - - assertThat(rows).hasSize(1) - - with(rows[0]) { - assertThat(id).isEqualTo(1) - assertThat(details).hasSize(2) - assertThat(details?.get(0)?.lineNumber).isEqualTo(1) - assertThat(details?.get(1)?.lineNumber).isEqualTo(2) - } - } - } - - @Test - fun testSingleTableJoinWithConstant() { - sqlSessionFactory.openSession().use { session -> - val mapper = session.getMapper(JoinMapper::class.java) - - val selectStatement = select( - orderMaster.orderId, orderMaster.orderDate, - orderDetail.lineNumber, orderDetail.description, orderDetail.quantity - ) { - from(orderMaster, "om") - join(orderDetail, "od") { - on(orderMaster.orderId) equalTo orderDetail.orderId - and(orderMaster.orderId) equalTo constant("1") - } - } - - val expectedStatement = "select om.order_id, om.order_date, od.line_number, od.description, od.quantity" + - " from OrderMaster om join OrderDetail od on om.order_id = od.order_id" + - " and om.order_id = 1" + val expectedStatement = "select OrderMaster.order_id, OrderMaster.order_date, OrderDetail.line_number, OrderDetail.description, OrderDetail.quantity" + + " from OrderMaster join OrderDetail on OrderMaster.order_id = OrderDetail.order_id" + + " and OrderMaster.order_id = #{parameters.p1,jdbcType=INTEGER}" assertThat(selectStatement.selectStatement).isEqualTo(expectedStatement) @@ -176,64 +100,6 @@ class JoinMapperTest { assertThat(selectStatement.selectStatement).isEqualTo(expectedStatement) } - @Test - fun testCompoundJoin2() { - // this is a nonsensical join, but it does test the "and" capability - val selectStatement = select( - orderMaster.orderId, orderMaster.orderDate, orderDetail.lineNumber, - orderDetail.description, orderDetail.quantity - ) { - from(orderMaster, "om") - join(orderDetail, "od") { - on(orderMaster.orderId) equalTo orderDetail.orderId - and(orderMaster.orderId) equalTo orderDetail.orderId - } - where { orderMaster.orderId isEqualTo 1 } - } - - val expectedStatement = "select om.order_id, om.order_date, od.line_number, od.description, od.quantity" + - " from OrderMaster om join OrderDetail od on om.order_id = od.order_id and om.order_id = od.order_id" + - " where om.order_id = #{parameters.p1,jdbcType=INTEGER}" - assertThat(selectStatement.selectStatement).isEqualTo(expectedStatement) - } - - @Test - fun testMultipleTableJoinWithWhereClause() { - sqlSessionFactory.openSession().use { session -> - val mapper = session.getMapper(JoinMapper::class.java) - - val selectStatement = select( - orderMaster.orderId, orderMaster.orderDate, orderLine.lineNumber, - itemMaster.description, orderLine.quantity - ) { - from(orderMaster, "om") - join(orderLine, "ol") { - on(orderMaster.orderId) equalTo orderLine.orderId - } - join(itemMaster, "im") { - on(orderLine.itemId) equalTo itemMaster.itemId - } - where { orderMaster.orderId isEqualTo 2 } - } - - val expectedStatement = "select om.order_id, om.order_date, ol.line_number, im.description, ol.quantity" + - " from OrderMaster om join OrderLine ol" + - " on om.order_id = ol.order_id join ItemMaster im on ol.item_id = im.item_id" + - " where om.order_id = #{parameters.p1,jdbcType=INTEGER}" - assertThat(selectStatement.selectStatement).isEqualTo(expectedStatement) - - val rows = mapper.selectMany(selectStatement) - - assertThat(rows).hasSize(1) - with(rows[0]) { - assertThat(id).isEqualTo(2) - assertThat(details).hasSize(2) - assertThat(details?.get(0)?.lineNumber).isEqualTo(1) - assertThat(details?.get(1)?.lineNumber).isEqualTo(2) - } - } - } - @Test fun testFullJoinWithAliases() { sqlSessionFactory.openSession().use { session -> @@ -703,100 +569,6 @@ class JoinMapperTest { } } - @Test - fun testSelf() { - sqlSessionFactory.openSession().use { session -> - val mapper = session.getMapper(JoinMapper::class.java) - - // create second table instance for self-join - val user2 = UserDynamicSQLSupport.User() - - // get Bamm Bamm's parent - should be Barney - val selectStatement = select(user.userId, user.userName, user.parentId) { - from(user, "u1") - join(user2, "u2") { - on(user.userId) equalTo user2.parentId - } - where { user2.userId isEqualTo 4 } - } - - val expectedStatement = "select u1.user_id, u1.user_name, u1.parent_id" + - " from User u1 join User u2 on u1.user_id = u2.parent_id" + - " where u2.user_id = #{parameters.p1,jdbcType=INTEGER}" - assertThat(selectStatement.selectStatement).isEqualTo(expectedStatement) - val rows = mapper.selectManyMappedRows(selectStatement) - - assertThat(rows).hasSize(1) - assertThat(rows[0]).containsExactly( - entry("USER_ID", 2), - entry("USER_NAME", "Barney"), - ) - } - } - - @Test - fun testSelfWithNewAlias() { - sqlSessionFactory.openSession().use { session -> - val mapper = session.getMapper(JoinMapper::class.java) - - // create second table instance for self-join - val user2 = user.withAlias("u2") - - // get Bamm Bamm's parent - should be Barney - val selectStatement = select(user.userId, user.userName, user.parentId) { - from(user) - join(user2) { - on(user.userId) equalTo user2.parentId - } - where { user2.userId isEqualTo 4 } - } - - val expectedStatement = "select User.user_id, User.user_name, User.parent_id" + - " from User join User u2 on User.user_id = u2.parent_id" + - " where u2.user_id = #{parameters.p1,jdbcType=INTEGER}" - assertThat(selectStatement.selectStatement).isEqualTo(expectedStatement) - - val rows = mapper.selectManyMappedRows(selectStatement) - assertThat(rows).hasSize(1) - - assertThat(rows[0]).containsExactly( - entry("USER_ID", 2), - entry("USER_NAME", "Barney"), - ) - } - } - - @Test - fun testSelfWithNewAliasAndOverride() { - sqlSessionFactory.openSession().use { session -> - val mapper = session.getMapper(JoinMapper::class.java) - - // create second table instance for self-join - val user2 = user.withAlias("other_user") - - // get Bamm Bamm's parent - should be Barney - val selectStatement = select(user.userId, user.userName, user.parentId) { - from(user, "u1") - join(user2, "u2") { - on(user.userId) equalTo user2.parentId - } - where { user2.userId isEqualTo 4 } - } - - val expectedStatement = "select u1.user_id, u1.user_name, u1.parent_id" + - " from User u1 join User u2 on u1.user_id = u2.parent_id" + - " where u2.user_id = #{parameters.p1,jdbcType=INTEGER}" - assertThat(selectStatement.selectStatement).isEqualTo(expectedStatement) - val rows = mapper.selectManyMappedRows(selectStatement) - assertThat(rows).hasSize(1) - - assertThat(rows[0]).containsExactly( - entry("USER_ID", 2), - entry("USER_NAME", "Barney"), - ) - } - } - @Test fun testJoinWithNoOnCondition() { // create second table instance for self-join @@ -829,48 +601,4 @@ class JoinMapperTest { } }.withMessage(Messages.getString("ERROR.45")) //$NON-NLS-1$ } - - @Test - fun testThatAliasesPropagateToSubQueryConditions() { - sqlSessionFactory.openSession().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) - ) - } - } } diff --git a/src/test/kotlin/examples/kotlin/spring/canonical/CanonicalSpringKotlinTemplateDirectTest.kt b/src/test/kotlin/examples/kotlin/spring/canonical/CanonicalSpringKotlinTemplateDirectTest.kt index 7157e709a..18b4f9922 100644 --- a/src/test/kotlin/examples/kotlin/spring/canonical/CanonicalSpringKotlinTemplateDirectTest.kt +++ b/src/test/kotlin/examples/kotlin/spring/canonical/CanonicalSpringKotlinTemplateDirectTest.kt @@ -577,8 +577,8 @@ open class CanonicalSpringKotlinTemplateDirectTest { address.id, address.streetAddress, address.city, address.state ) { from(person, "p") - join(address, "a") { - on(addressId) equalTo address.id + join(address, "a") on { + addressId isEqualTo address.id } where { id isLessThan 4 } orderBy(id) diff --git a/src/test/kotlin/examples/kotlin/spring/canonical/CanonicalSpringKotlinTest.kt b/src/test/kotlin/examples/kotlin/spring/canonical/CanonicalSpringKotlinTest.kt index 7b9093892..23c6e8058 100644 --- a/src/test/kotlin/examples/kotlin/spring/canonical/CanonicalSpringKotlinTest.kt +++ b/src/test/kotlin/examples/kotlin/spring/canonical/CanonicalSpringKotlinTest.kt @@ -1122,8 +1122,8 @@ open class CanonicalSpringKotlinTest { address.streetAddress, address.city, address.state ) { from(person, "p") - join(address, "a") { - on(addressId) equalTo address.id + join(address, "a") on { + addressId isEqualTo address.id } where { id isLessThan 4 } orderBy(id)