Fix for #37 - disjunction expression should not produce inner join - left outer join instead

src/test/java/com/avaje/tests/query/joins/TestDisjunctWhereOuterJoin.java

@@ -0,0 +1,65 @@
+package com.avaje.tests.query.joins;
+
+import java.util.List;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import com.avaje.ebean.BaseTestCase;
+import com.avaje.ebean.Ebean;
+import com.avaje.ebean.Query;
+import com.avaje.tests.model.basic.MRole;
+import com.avaje.tests.model.basic.MUser;
+
+public class TestDisjunctWhereOuterJoin extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    Ebean.beginTransaction();
+
+    MRole r1 = new MRole();
+    r1.setRoleName("role1");
+    Ebean.save(r1);
+
+    MRole r2 = new MRole();
+    r2.setRoleName("role2special");
+    Ebean.save(r2);
+
+    MRole r3 = new MRole();
+    r3.setRoleName("role3");
+    Ebean.save(r3);
+
+    MUser u0 = new MUser();
+    u0.setUserName("user0");
+    u0.addRole(r1);
+    u0.addRole(r2);
+
+    Ebean.save(u0);
+
+    MUser u1 = new MUser();
+    u1.setUserName("user1");
+    u1.addRole(r1);
+
+    Ebean.save(u1);
+
+    Ebean.commitTransaction();
+
+    
+    Query<MUser> query = Ebean.find(MUser.class)
+        .where().disjunction()
+                .eq("roles.roleName", "role2special") // user0
+                .eq("roles.roleName", "role3") // nobody
+            .endJunction().query();
+
+    List<MUser> list = query.findList();
+    Assert.assertSame(1, list.size()); // list should contain user0
+    System.out.println(list);
+
+    String sql = query.getGeneratedSql();
+    Assert.assertTrue(sql.indexOf("select distinct") > -1);
+    Assert.assertTrue(sql.indexOf("outer join mrole ") > -1);
+    Assert.assertTrue(sql.indexOf(".role_name = ?") > -1);
+
+  }
+}

src/test/java/com/avaje/tests/query/joins/TestDisjunctWhereOuterOnMany.java

@@ -0,0 +1,61 @@
+package com.avaje.tests.query.joins;
+
+import java.util.List;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import com.avaje.ebean.BaseTestCase;
+import com.avaje.ebean.Ebean;
+import com.avaje.ebean.Query;
+import com.avaje.tests.model.basic.UUOne;
+import com.avaje.tests.model.basic.UUTwo;
+
+public class TestDisjunctWhereOuterOnMany extends BaseTestCase {
+
+  @Test
+  public void test() {
+    
+    // setup
+    UUOne master1 = new UUOne();
+    master1.setName("testDisjOuter_1_name");
+
+    UUTwo detail1 = new UUTwo();
+    detail1.setMaster(master1);
+    detail1.setName("testDisjOuter_CHILD_1");
+
+    UUOne master2 = new UUOne();
+    master2.setName("testDisjOuter_2_name");
+
+    Ebean.save(master1);
+    Ebean.save(detail1);
+    Ebean.save(master2);
+    
+    
+    // Have outer join so that "testDisjOuter_2_name" is found
+    Query<UUOne> query = Ebean.find(UUOne.class)
+      .where().disjunction()
+        .eq("name", "testDisjOuter_2_name")
+        .eq("comments.name", "testDisjOuter_CHILD_1")
+        .endJunction()
+        .query();
+    
+    List<UUOne> list = query.findList();
+    int rowCount = query.findRowCount();
+    
+    // select distinct t0.id c0, t0.name c1 
+    // from uuone t0 
+    // join uutwo u1 on u1.master_id = t0.id  
+    // left outer join uutwo t1 on t1.master_id = t0.id 
+    // where (t0.name = ?  or u1.name = ? ) ; 
+    // --bind(testDisjOuter_2_name,testDisjOuter_CHILD_1)
+    
+    Assert.assertEquals(2, list.size());
+    Assert.assertEquals(2, rowCount);
+    
+    String expectedSql = "select distinct t0.id c0, t0.name c1 from uuone t0 left outer join uutwo u1 on u1.master_id = t0.id  where (t0.name = ?  or u1.name = ? ) ";
+    Assert.assertEquals(expectedSql, query.getGeneratedSql());
+    
+  }
+  
+}

src/test/java/com/avaje/tests/query/joins/TestQueryJoinManyNonRoot.java

@@ -0,0 +1,96 @@
+package com.avaje.tests.query.joins;
+
+import java.util.List;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import com.avaje.ebean.BaseTestCase;
+import com.avaje.ebean.Ebean;
+import com.avaje.ebean.FetchConfig;
+import com.avaje.ebean.Query;
+import com.avaje.tests.model.basic.Order;
+import com.avaje.tests.model.basic.ResetBasicData;
+
+public class TestQueryJoinManyNonRoot extends BaseTestCase {
+
+  @Test
+  public void test_manyNonRoot() {
+
+    ResetBasicData.reset();
+
+    Query<Order> q = Ebean.find(Order.class)
+        .fetch("customer")
+        .fetch("customer.contacts")
+        .where().gt("id", 0).query();
+
+    List<Order> list = q.findList();
+    String sql = q.getGeneratedSql();
+
+    Assert.assertTrue(list.size() > 0);
+    Assert.assertTrue(sql.contains("join o_customer t1 on t1.id "));
+    Assert.assertTrue(sql.contains("left outer join contact t2 on"));
+    
+    // select t0.id c0, t0.status c1, t0.order_date c2, t0.ship_date c3, t1.name c4, t0.cretime c5, t0.updtime c6, 
+    //        t1.id c7, t1.status c8, t1.name c9, t1.smallnote c10, t1.anniversary c11, t1.cretime c12, t1.updtime c13, t1.billing_address_id c14, t1.shipping_address_id c15, 
+    //        t2.id c16, t2.first_name c17, t2.last_name c18, t2.phone c19, t2.mobile c20, t2.email c21, t2.cretime c22, t2.updtime c23, t2.customer_id c24, t2.group_id c25 
+    // from o_order t0 
+    // join o_customer t1 on t1.id = t0.kcustomer_id 
+    // left outer join contact t2 on t2.customer_id = t1.id 
+    // where t0.id > ? ; --bind(0)
+    
+  }
+
+  @Test
+  public void test_manyRootQueryJoinOrderDetailsFirst() {
+
+    ResetBasicData.reset();
+
+    Query<Order> q = Ebean.find(Order.class)
+        .fetch("details")
+        .fetch("details.product")
+        .fetch("customer")
+        .fetch("customer.contacts")
+        .where().gt("id", 0).query();
+
+    List<Order> list = q.findList();
+    String sql = q.getGeneratedSql();
+
+    Assert.assertTrue(list.size() > 0);
+    Assert.assertTrue(sql.contains("join o_customer t1 on t1.id "));
+    Assert.assertTrue(sql.contains("left outer join o_order_detail "));
+    Assert.assertTrue(sql.contains("left outer join o_product "));
+
+    Assert.assertFalse(sql.contains("left outer join contact"));
+
+  }
+
+  @Test
+  public void test_manyRootQueryJoinCustomerContactsFirst() {
+
+    ResetBasicData.reset();
+
+    Query<Order> q = Ebean.find(Order.class)
+        .fetch("customer")
+        .fetch("customer.contacts")
+        .fetch("details", new FetchConfig().query(10))
+        .fetch("details.product")
+        .where().gt("id", 0).query();
+
+    List<Order> list = q.findList();
+    String sql = q.getGeneratedSql();
+    
+    for (Order order : list) {
+      order.getCustomer().getContacts().size();
+    }
+
+    Assert.assertTrue(list.size() > 0);
+    Assert.assertTrue(sql.contains("join o_customer t1 on t1.id "));
+    Assert.assertTrue(sql.contains("left outer join contact "));
+
+    Assert.assertFalse(sql.contains("left outer join o_order_detail "));
+    Assert.assertFalse(sql.contains("left outer join o_product "));
+
+  }
+
+}

src/test/java/com/avaje/tests/query/joins/TestQueryJoinQueryNonRoot.java

@@ -0,0 +1,58 @@
+package com.avaje.tests.query.joins;
+
+import java.util.List;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import com.avaje.ebean.BaseTestCase;
+import com.avaje.ebean.Ebean;
+import com.avaje.ebean.FetchConfig;
+import com.avaje.ebeaninternal.api.SpiEbeanServer;
+import com.avaje.ebeaninternal.server.deploy.BeanDescriptor;
+import com.avaje.ebeaninternal.server.el.ElPropertyValue;
+import com.avaje.tests.model.basic.Contact;
+import com.avaje.tests.model.basic.Order;
+import com.avaje.tests.model.basic.ResetBasicData;
+
+public class TestQueryJoinQueryNonRoot extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    SpiEbeanServer server = (SpiEbeanServer) Ebean.getServer(null);
+    BeanDescriptor<Order> d = server.getBeanDescriptor(Order.class);
+    ElPropertyValue elGetValue = d.getElGetValue("customer.contacts");
+
+    Assert.assertTrue(elGetValue.containsMany());
+
+    ResetBasicData.reset();
+
+    List<Order> list = Ebean.find(Order.class)
+        .fetch("customer")
+        .fetch("customer.contacts", "firstName", new FetchConfig().query().lazy(10))
+        .fetch("customer.contacts.group")
+        .where().lt("id", 3).findList();
+
+    Assert.assertNotNull(list);
+    Assert.assertTrue(list.size() > 0);
+
+    for (Order order : list) {
+      List<Contact> contacts = order.getCustomer().getContacts();
+      for (Contact contact : contacts) {
+        contact.getFirstName();
+      }
+    }
+
+    // String oq =
+    // "find order join customer join customer.contacts join details (+query(4),+lazy(5))";
+    // Query<Order> q = Ebean.createQuery(Order.class, oq);
+    // q.setAutofetch(false);
+    // List<Order> list2 = q.findList();
+    //
+    // Assert.assertTrue(list2.size() > 0);
+
+  }
+  
+
+}

src/test/java/com/avaje/tests/query/joins/TestQueryManyToOneWhereClauseJoin.java

@@ -0,0 +1,94 @@
+package com.avaje.tests.query.joins;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import com.avaje.ebean.BaseTestCase;
+import com.avaje.ebean.Ebean;
+import com.avaje.ebean.Query;
+import com.avaje.tests.model.basic.Order;
+import com.avaje.tests.model.basic.ResetBasicData;
+
+public class TestQueryManyToOneWhereClauseJoin extends BaseTestCase {
+
+
+  /**
+   * Testing 'where join' created for a ManyToOne relationship.
+   */
+  @Test
+  public void testJoin() {
+
+    ResetBasicData.reset();
+
+    Query<Order> query = Ebean.find(Order.class)
+        .where().ilike("customer.name", "rob%")
+        .query();
+
+    query.findList();
+    
+    //select t0.id c0, t0.status c1, t0.order_date c2, t0.ship_date c3, t1.name c4, t0.cretime c5, t0.updtime c6, t0.kcustomer_id c7 
+    String expectedSql = "from o_order t0 join o_customer t1 on t1.id = t0.kcustomer_id  where lower(t1.name) like ? ";
+    Assert.assertTrue(query.getGeneratedSql().contains(expectedSql));
+
+    // select t0.id c0, t0.status c1, t0.order_date c2, t0.ship_date c3, t1.name c4, t0.cretime c5, t0.updtime c6, t0.kcustomer_id c7 
+    // from o_order t0 
+    // join o_customer t1 on t1.id = t0.kcustomer_id  
+    // where lower(t1.name) like ? ; --bind(rob%)
+  }
+
+  /**
+   * Although this is a disjunction it is on a ManyToOne so the 'default' join type is still fine.
+   */
+  @Test
+  public void testDisjunctionOnManyToOneJoin() {
+
+    ResetBasicData.reset();
+
+    Query<Order> query = Ebean.find(Order.class)
+        .where().disjunction().ilike("customer.name", "rob%").gt("id", 1).endJunction()
+        .query();
+
+    query.findList();
+    
+    //select t0.id c0, t0.status c1, t0.order_date c2, t0.ship_date c3, t1.name c4, t0.cretime c5, t0.updtime c6, t0.kcustomer_id c7 
+    String expectedSql = "from o_order t0 join o_customer t1 on t1.id = t0.kcustomer_id  where (lower(t1.name) like ?  or t0.id > ? ) ";
+    Assert.assertTrue(query.getGeneratedSql().contains(expectedSql));
+    
+    // select t0.id c0, t0.status c1, t0.order_date c2, t0.ship_date c3, t1.name c4, t0.cretime c5, t0.updtime c6, t0.kcustomer_id c7 
+    // from o_order t0 
+    // join o_customer t1 on t1.id = t0.kcustomer_id  
+    // where (lower(t1.name) like ?  or t0.id > ? ) ; --bind(rob%,1)
+    
+  }
+  
+
+  /**
+   * Testing ManyToOne relationship with predicate and fetch.
+   */
+  @Test
+  public void testWhereAndFetch() {
+
+    ResetBasicData.reset();
+
+    Query<Order> query = Ebean.find(Order.class)
+        .fetch("customer")
+        .fetch("customer.contacts")
+        .where().ilike("customer.name", "rob%")
+        .query();
+
+    query.findList();
+    
+    String generatedSql = query.getGeneratedSql();
+    Assert.assertTrue(generatedSql.contains("from o_order t0 join o_customer t1 on t1.id = t0.kcustomer_id"));
+    Assert.assertTrue(generatedSql.contains("left outer join contact t2 on t2.customer_id = t1.id"));
+    Assert.assertTrue(generatedSql.contains("where lower(t1.name) like ?"));
+    
+    // select t0.id c0, t0.status c1, t0.order_date c2, t0.ship_date c3, t1.name c4, t0.cretime c5, t0.updtime c6, 
+    //        t1.id c7, t1.status c8, t1.name c9, t1.smallnote c10, t1.anniversary c11, t1.cretime c12, t1.updtime c13, t1.billing_address_id c14, t1.shipping_address_id c15, 
+    //        t2.id c16, t2.first_name c17, t2.last_name c18, t2.phone c19, t2.mobile c20, t2.email c21, t2.cretime c22, t2.updtime c23, t2.customer_id c24, t2.group_id c25 
+    // from o_order t0 
+    // join o_customer t1 on t1.id = t0.kcustomer_id  
+    // left outer join contact t2 on t2.customer_id = t1.id 
+    // where lower(t1.name) like ? ; --bind(rob%)
+  }
+}