From 9cd189034caab5bb6292442bd06774e3d753b3b5 Mon Sep 17 00:00:00 2001 From: rob bygrave Date: Tue, 26 Jun 2018 21:33:44 +1200 Subject: [PATCH] #1437 - or(expr, expr) ... where expr has a ToMany should produce a LEFT JOIN (and instead we only get JOIN) --- .../server/expression/LogicExpression.java | 30 ++++++---- .../joins/TestDisjunctWhereOuterJoin.java | 55 ++++++++++++++++--- 2 files changed, 67 insertions(+), 18 deletions(-) diff --git a/src/main/java/io/ebeaninternal/server/expression/LogicExpression.java b/src/main/java/io/ebeaninternal/server/expression/LogicExpression.java index 363b40aab..2dd7a4882 100644 --- a/src/main/java/io/ebeaninternal/server/expression/LogicExpression.java +++ b/src/main/java/io/ebeaninternal/server/expression/LogicExpression.java @@ -23,7 +23,7 @@ abstract class LogicExpression implements SpiExpression { static class And extends LogicExpression { And(Expression expOne, Expression expTwo) { - super(AND, expOne, expTwo); + super(true, expOne, expTwo); } @Override @@ -36,7 +36,7 @@ abstract class LogicExpression implements SpiExpression { static class Or extends LogicExpression { Or(Expression expOne, Expression expTwo) { - super(OR, expOne, expTwo); + super(false, expOne, expTwo); } @Override @@ -45,14 +45,14 @@ abstract class LogicExpression implements SpiExpression { } } - protected SpiExpression expOne; + SpiExpression expOne; - protected SpiExpression expTwo; + SpiExpression expTwo; - private final String joinType; + private final boolean conjunction; - LogicExpression(String joinType, Expression expOne, Expression expTwo) { - this.joinType = joinType; + LogicExpression(boolean conjunction, Expression expOne, Expression expTwo) { + this.conjunction = conjunction; this.expOne = (SpiExpression) expOne; this.expTwo = (SpiExpression) expTwo; } @@ -71,7 +71,6 @@ abstract class LogicExpression implements SpiExpression { @Override public void writeDocQuery(DocQueryContext context) throws IOException { - boolean conjunction = joinType.equals(AND); context.startBool(conjunction ? Junction.Type.AND : Junction.Type.OR); expOne.writeDocQuery(context); expTwo.writeDocQuery(context); @@ -107,8 +106,19 @@ abstract class LogicExpression implements SpiExpression { @Override public void containsMany(BeanDescriptor desc, ManyWhereJoins manyWhereJoin) { + + // get the current state for 'require outer joins' + boolean parentOuterJoins = manyWhereJoin.isRequireOuterJoins(); + if (!conjunction) { + // turn on outer joins required for disjunction expressions + manyWhereJoin.setRequireOuterJoins(true); + } expOne.containsMany(desc, manyWhereJoin); expTwo.containsMany(desc, manyWhereJoin); + if (!conjunction && !parentOuterJoins) { + // restore state to not forcing outer joins + manyWhereJoin.setRequireOuterJoins(false); + } } @Override @@ -128,7 +138,7 @@ abstract class LogicExpression implements SpiExpression { request.append("("); expOne.addSql(request); - request.append(joinType); + request.append(conjunction ? AND : OR); expTwo.addSql(request); request.append(") "); } @@ -144,7 +154,7 @@ abstract class LogicExpression implements SpiExpression { */ @Override public void queryPlanHash(StringBuilder builder) { - builder.append("Logic").append(joinType).append("["); + builder.append("Logic").append(conjunction ? AND : OR).append("["); expOne.queryPlanHash(builder); builder.append(","); expTwo.queryPlanHash(builder); diff --git a/src/test/java/org/tests/query/joins/TestDisjunctWhereOuterJoin.java b/src/test/java/org/tests/query/joins/TestDisjunctWhereOuterJoin.java index 1c6fdc9a5..0610c7fa6 100644 --- a/src/test/java/org/tests/query/joins/TestDisjunctWhereOuterJoin.java +++ b/src/test/java/org/tests/query/joins/TestDisjunctWhereOuterJoin.java @@ -2,14 +2,16 @@ package org.tests.query.joins; import io.ebean.BaseTestCase; import io.ebean.Ebean; +import io.ebean.Expr; import io.ebean.Query; +import org.junit.Test; import org.tests.model.basic.MRole; import org.tests.model.basic.MUser; -import org.junit.Assert; -import org.junit.Test; import java.util.List; +import static org.assertj.core.api.Assertions.assertThat; + public class TestDisjunctWhereOuterJoin extends BaseTestCase { @Test @@ -43,6 +45,9 @@ public class TestDisjunctWhereOuterJoin extends BaseTestCase { Ebean.save(u1); + queryOrExpression(r2.getRoleid()); + + queryDisjunction(r2.getRoleid()); Query query = Ebean.find(MUser.class) .where().disjunction() @@ -51,17 +56,51 @@ public class TestDisjunctWhereOuterJoin extends BaseTestCase { .endJunction().query(); List list = query.findList(); - Assert.assertSame(1, list.size()); // list should contain user0 - System.out.println(list); + assertThat(list).hasSize(1); // list should contain user0 - String sql = query.getGeneratedSql(); - Assert.assertTrue(sql.contains("select distinct")); - Assert.assertTrue(sql.contains("left join mrole ")); - Assert.assertTrue(sql.contains(".role_name = ?")); + String sql = sqlOf(query); + assertSqlOuterJoins(sql); + assertThat(sql).contains(".role_name = ?"); } finally { Ebean.rollbackTransaction(); } + } + private void queryDisjunction(Integer roleid) { + + Query query = Ebean.find(MUser.class) + .where().or() + .eq("userName", "user0B") + .eq("roles.roleid", roleid) + .endOr().query(); + + query.findList(); + + String sql = sqlOf(query); + assertSqlOuterJoins(sql); + assertThat(sql).contains("where (t0.user_name = ? or u1.roleid = ? )"); + } + + private void queryOrExpression(Integer roleid) { + + Query query = Ebean.find(MUser.class) + .where().or( + Expr.eq("userName", "user0B"), + Expr.eq("roles.roleid", roleid) + ) + .query(); + + query.findList(); + + String sql = sqlOf(query); + assertSqlOuterJoins(sql); + assertThat(sql).contains("where (t0.user_name = ? or u1.roleid = ? )"); + } + + private void assertSqlOuterJoins(String sql) { + assertThat(sql).contains("select distinct"); + assertThat(sql).contains("left join mrole_muser u1z_ on u1z_.muser_userid = t0.userid"); + assertThat(sql).contains("left join mrole u1 on u1.roleid = u1z_.mrole_roleid"); } }