#566 - Refactor internals - SpiExpression, add prepareExpression() to merge queryAutoTuneHash() and queryPlanHash() - sameByPlan() & sameByBind()

src/test/java/com/avaje/ebean/BaseTestCase.java

@@ -1,6 +1,7 @@
 package com.avaje.ebean;
 
 import com.avaje.ebeaninternal.api.SpiEbeanServer;
+import com.avaje.ebeaninternal.server.deploy.BeanDescriptor;
 import org.avaje.agentloader.AgentLoader;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -29,4 +30,16 @@ public class BaseTestCase {
     SpiEbeanServer spi = (SpiEbeanServer)Ebean.getDefaultServer();
     return spi.getDatabasePlatform().getName().equals("h2");
   }
+
+  protected <T> BeanDescriptor<T> getBeanDescriptor(Class<T> cls) {
+    return spiEbeanServer().getBeanDescriptor(cls);
+  }
+
+  protected SpiEbeanServer spiEbeanServer() {
+    return (SpiEbeanServer) Ebean.getDefaultServer();
+  }
+
+  protected EbeanServer server() {
+    return Ebean.getDefaultServer();
+  }
 }

src/test/java/com/avaje/ebeaninternal/server/deploy/TableJoinColumnTest.java

@@ -0,0 +1,49 @@
+package com.avaje.ebeaninternal.server.deploy;
+
+import com.avaje.ebeaninternal.server.deploy.meta.DeployTableJoinColumn;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class TableJoinColumnTest {
+
+  TableJoinColumn col(String localDbColumn, String foreignDbColumn, boolean insertable, boolean updateable) {
+    DeployTableJoinColumn column = new DeployTableJoinColumn(localDbColumn, foreignDbColumn, insertable, updateable);
+    return new TableJoinColumn(column);
+  }
+
+  @Test
+  public void equals_when_same() {
+    assertSame(col("a", "b", true, true), col("a", "b", true, true));
+  }
+
+  @Test
+  public void equals_when_diffFirstCol() {
+    assertDifferent(col("a", "b", true, true), col("c", "b", true, true));
+  }
+
+  @Test
+  public void equals_when_diffSecondCol() {
+    assertDifferent(col("a", "b", true, true), col("a", "c", true, true));
+  }
+
+  @Test
+  public void equals_when_diffInsertable() {
+    assertDifferent(col("a", "b", true, true), col("a", "b", false, true));
+  }
+
+  @Test
+  public void equals_when_diffUpdateable() {
+    assertDifferent(col("a", "b", true, true), col("a", "b", true, false));
+  }
+
+  private void assertDifferent(TableJoinColumn col, TableJoinColumn col2) {
+    assertThat(col).isNotEqualTo(col2);
+    assertThat(col.hashCode()).isNotEqualTo(col2.hashCode());
+  }
+
+  private void assertSame(TableJoinColumn col, TableJoinColumn col2) {
+    assertThat(col).isEqualTo(col2);
+    assertThat(col.hashCode()).isEqualTo(col2.hashCode());
+  }
+}

src/test/java/com/avaje/ebeaninternal/server/deploy/TableJoinTest.java

@@ -0,0 +1,67 @@
+package com.avaje.ebeaninternal.server.deploy;
+
+
+import com.avaje.ebeaninternal.server.deploy.meta.DeployTableJoin;
+import com.avaje.ebeaninternal.server.deploy.meta.DeployTableJoinColumn;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class TableJoinTest {
+
+  DeployTableJoinColumn col(String localDbColumn, String foreignDbColumn, boolean insertable, boolean updateable) {
+    return new DeployTableJoinColumn(localDbColumn, foreignDbColumn, insertable, updateable);
+  }
+
+  TableJoin table(String tableName, String col1, String col2) {
+    DeployTableJoin deploy = new DeployTableJoin();
+    deploy.setTable(tableName);
+    deploy.addJoinColumn(col(col1, col2, true, true));
+    return new TableJoin(deploy);
+  }
+
+  TableJoin table(String tableName, String col1, String col2, String col3, String col4) {
+    DeployTableJoin deploy = new DeployTableJoin();
+    deploy.setTable(tableName);
+    deploy.addJoinColumn(col(col1, col2, true, true));
+    deploy.addJoinColumn(col(col3, col4, true, true));
+    return new TableJoin(deploy);
+  }
+
+  @Test
+  public void equals_when_same() {
+    assertSame(table("myTable", "a", "b"), table("myTable", "a", "b"));
+  }
+
+  @Test
+  public void equals_when_diffTable() {
+    assertDifferent(table("myTable", "a", "b"), table("diffTable", "a", "b"));
+  }
+
+  @Test
+  public void equals_when_diffColumn() {
+    assertDifferent(table("myTable", "a", "b"), table("myTable", "c", "b"));
+  }
+
+  @Test
+  public void equals_when_moreColumns() {
+    assertDifferent(table("myTable", "a", "b"), table("myTable", "a", "b", "c", "d"));
+  }
+
+  @Test
+  public void equals_when_lessColumns() {
+    assertDifferent(table("myTable", "a", "b", "c", "d"), table("myTable", "a", "b"));
+  }
+
+  void assertSame(TableJoin join1, TableJoin join2) {
+    assertThat(join1).isEqualTo(join1);
+    assertThat(join1.hashCode()).isEqualTo(join1.hashCode());
+  }
+
+
+  void assertDifferent(TableJoin join1, TableJoin join2) {
+    assertThat(join1).isNotEqualTo(join2);
+    assertThat(join1.hashCode()).isNotEqualTo(join2.hashCode());
+  }
+
+}

src/test/java/com/avaje/ebeaninternal/server/expression/AllEqualsExpressionTest.java

@@ -0,0 +1,118 @@
+package com.avaje.ebeaninternal.server.expression;
+
+import org.jetbrains.annotations.NotNull;
+import org.junit.Test;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import static org.assertj.core.api.StrictAssertions.assertThat;
+
+public class AllEqualsExpressionTest {
+
+  @Test
+  public void isSameByPlan_when_same() {
+
+    assertThat(exp("a", 10).isSameByPlan(exp("a", 10))).isTrue();
+  }
+
+  @Test
+  public void isSameByBind_when_sameMultiple() {
+
+    assertThat(exp("a", 10, "b", "23").isSameByBind(exp("a", 10, "b", "23"))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffBindValue() {
+
+    assertThat(exp("a", 10).isSameByPlan(exp("a", 20))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_multiple() {
+
+    assertThat(exp("a", 10, "b", 20, "c", 30).isSameByPlan(exp("a", 10, "b", 20, "c", 30))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_less() {
+
+    assertThat(exp("a", 10, "b", 20, "c", 30).isSameByPlan(exp("a", 10, "b", 20))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_more() {
+
+    assertThat(exp("a", 10, "b", 20).isSameByPlan(exp("a", 10, "b", 20, "c", 30))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffProperty_diff() {
+
+    assertThat(exp("a", 10).isSameByPlan(exp("b", 10))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffType_diff() {
+
+    assertThat(exp("a", 10).isSameByPlan(new NoopExpression())).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffBindByNull_last() {
+
+    assertThat(exp("a", 10).isSameByPlan(exp("a", null))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffBindByNull_first() {
+
+    assertThat(exp("a", null).isSameByPlan(exp("a", 10))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_differentExpressionType() {
+
+    assertThat(exp("a", null).isSameByPlan(new NoopExpression())).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_diffBindByNull_last() {
+
+    assertThat(exp("a", 10).isSameByBind(exp("a", null))).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_diffBindByNull_first() {
+
+    assertThat(exp("a", null).isSameByBind(exp("a", 10))).isFalse();
+  }
+
+
+  @NotNull
+  private AllEqualsExpression exp(Map<String, Object> propMap) {
+    return new AllEqualsExpression(propMap);
+  }
+
+  AllEqualsExpression exp(String key0, Object val1) {
+    LinkedHashMap<String,Object> map = new LinkedHashMap<String,Object>();
+    map.put(key0, val1);
+    return exp(map);
+  }
+
+
+  AllEqualsExpression exp(String key0, Object val1, String key2, Object val2) {
+    LinkedHashMap<String,Object> map = new LinkedHashMap<String,Object>();
+    map.put(key0, val1);
+    map.put(key2, val2);
+    return exp(map);
+  }
+
+  AllEqualsExpression exp(String key0, Object val1, String key2, Object val2, String key3, Object val3) {
+    LinkedHashMap<String,Object> map = new LinkedHashMap<String,Object>();
+    map.put(key0, val1);
+    map.put(key2, val2);
+    map.put(key3, val3);
+    return exp(map);
+  }
+}

src/test/java/com/avaje/ebeaninternal/server/expression/BaseExpressionTest.java

@@ -0,0 +1,13 @@
+package com.avaje.ebeaninternal.server.expression;
+
+import com.avaje.ebean.BaseTestCase;
+import com.avaje.ebeaninternal.server.deploy.BeanDescriptor;
+import com.avaje.tests.model.basic.Order;
+
+public abstract class BaseExpressionTest extends BaseTestCase {
+
+  protected DefaultExpressionRequest newExpressionRequest() {
+    BeanDescriptor<Order> desc = getBeanDescriptor(Order.class);
+    return new DefaultExpressionRequest(desc);
+  }
+}

src/test/java/com/avaje/ebeaninternal/server/expression/BetweenExpressionTest.java

@@ -0,0 +1,69 @@
+package com.avaje.ebeaninternal.server.expression;
+
+import com.avaje.ebeaninternal.api.SpiExpression;
+import org.junit.Test;
+
+import static org.assertj.core.api.StrictAssertions.assertThat;
+
+public class BetweenExpressionTest extends BaseExpressionTest {
+
+  @Test
+  public void addSql() throws Exception {
+
+    DefaultExpressionRequest expReq = newExpressionRequest();
+
+    BetweenExpression exp = new BetweenExpression("startDate", 1, 2);
+    exp.addSql(expReq);
+
+    assertThat(expReq.getSql()).isEqualTo("startDate between  ? and ? ");
+  }
+
+  @Test
+  public void copyForPlanKey_isSameInstance() throws Exception {
+
+    BetweenExpression exp = new BetweenExpression("startDate", 1, 2);
+    SpiExpression other = exp.copyForPlanKey();
+
+    assertThat(exp).isSameAs(other);
+  }
+
+  @Test
+  public void isSameByPlan_when_properties_match() throws Exception {
+
+    BetweenExpression exp0 = new BetweenExpression("startDate", 1, 2);
+    BetweenExpression exp1 = new BetweenExpression("startDate", 3, 4);
+
+    assertThat(exp0.isSameByPlan(exp1)).isTrue();
+    assertThat(exp1.isSameByPlan(exp0)).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_properties_do_not_match() throws Exception {
+
+    BetweenExpression exp0 = new BetweenExpression("startDate", 1, 2);
+    BetweenExpression exp1 = new BetweenExpression("endDate", 1, 2);
+
+    assertThat(exp0.isSameByPlan(exp1)).isFalse();
+    assertThat(exp1.isSameByPlan(exp0)).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_values_do_not_match() throws Exception {
+
+    BetweenExpression exp0 = new BetweenExpression("startDate", 1, 2);
+    BetweenExpression exp1 = new BetweenExpression("startDate", 1, 3);
+
+    assertThat(exp0.isSameByBind(exp1)).isFalse();
+    assertThat(exp1.isSameByBind(exp0)).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_values_match() throws Exception {
+
+    BetweenExpression exp0 = new BetweenExpression("startDate", 1, 2);
+    BetweenExpression exp1 = new BetweenExpression("startDate", 1, 2);
+
+    assertThat(exp0.isSameByBind(exp1)).isTrue();
+    assertThat(exp1.isSameByBind(exp0)).isTrue();
+  }
+}

src/test/java/com/avaje/ebeaninternal/server/expression/BetweenPropertyExpressionTest.java

@@ -0,0 +1,45 @@
+package com.avaje.ebeaninternal.server.expression;
+
+import org.jetbrains.annotations.NotNull;
+import org.junit.Test;
+
+import static org.assertj.core.api.StrictAssertions.assertThat;
+
+public class BetweenPropertyExpressionTest {
+
+  @NotNull
+  private BetweenPropertyExpression exp(String lowProperty, String highProperty, Object value) {
+    return new BetweenPropertyExpression(lowProperty, highProperty, value);
+  }
+
+  @Test
+  public void isSameByPlan_when_same() {
+    assertThat(exp("a", "b", 10).isSameByPlan(exp("a", "b", 10))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffValue() {
+    assertThat(exp("a", "b", 10).isSameByPlan(exp("a", "b", 20))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffProperty() {
+    assertThat(exp("a", "b", 10).isSameByPlan(exp("a", "c", 10))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffExpressionType() {
+    assertThat(exp("a", "b", 10).isSameByPlan(new NoopExpression())).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_same() {
+    assertThat(exp("a", "b", 10).isSameByBind(exp("a", "b", 10))).isTrue();
+  }
+
+  @Test
+  public void isSameByBind_when_diff() {
+    assertThat(exp("a", "b", 10).isSameByBind(exp("a", "b", 20))).isFalse();
+  }
+
+}

src/test/java/com/avaje/ebeaninternal/server/expression/CaseInsensitiveEqualExpressionTest.java

@@ -0,0 +1,50 @@
+package com.avaje.ebeaninternal.server.expression;
+
+
+import org.junit.Test;
+
+import static org.assertj.core.api.StrictAssertions.assertThat;
+
+public class CaseInsensitiveEqualExpressionTest {
+
+  CaseInsensitiveEqualExpression exp(String propName, String value) {
+    return new CaseInsensitiveEqualExpression(propName, value);
+  }
+
+  @Test
+  public void isSameByPlan_when_same() {
+
+    assertThat(exp("a", "10").isSameByPlan(exp("a", "10"))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffBind_same() {
+
+    assertThat(exp("a", "10").isSameByPlan(exp("a", "20"))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffProperty_diff() {
+
+    assertThat(exp("a", "10").isSameByPlan(exp("b", "10"))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffType_diff() {
+
+    assertThat(exp("a", "10").isSameByPlan(new NoopExpression())).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_sameBindValues() {
+
+    assertThat(exp("a", "10").isSameByBind(exp("b", "10"))).isTrue();
+  }
+
+  @Test
+  public void isSameByBind_when_diffBindValues() {
+
+    assertThat(exp("a", "10").isSameByBind(exp("b", "20"))).isFalse();
+  }
+
+}

src/test/java/com/avaje/ebeaninternal/server/expression/DefaultExampleExpressionTest.java

@@ -1,13 +1,11 @@
 package com.avaje.ebeaninternal.server.expression;
 
 import com.avaje.ebean.BaseTestCase;
-import com.avaje.ebean.Ebean;
 import com.avaje.ebean.LikeType;
 import com.avaje.ebean.Query;
 import com.avaje.ebean.bean.EntityBean;
 import com.avaje.ebean.event.BeanQueryRequest;
 import com.avaje.ebeaninternal.api.HashQueryPlanBuilder;
-import com.avaje.ebeaninternal.api.SpiEbeanServer;
 import com.avaje.ebeaninternal.api.SpiQuery;
 import com.avaje.ebeaninternal.server.core.OrmQueryRequest;
 import com.avaje.ebeaninternal.server.deploy.BeanDescriptor;
@@ -22,42 +20,68 @@ import static org.assertj.core.api.Assertions.assertThat;
 public class DefaultExampleExpressionTest extends BaseTestCase {
 
 
-  @Test
-  public void test() {
-
-    SpiEbeanServer server = (SpiEbeanServer)Ebean.getDefaultServer();
-    BeanDescriptor<Customer> desc = server.getBeanDescriptor(Customer.class);
-
-    SpiQuery<Customer> query = (SpiQuery<Customer>)server.find(Customer.class);
-
+  Customer customer() {
     Address address = new Address();
     address.setCity("billingAddress.city");
 
     Customer customer = new Customer();
     customer.setName("name");
     customer.setBillingAddress(address);
+    return customer;
+  }
 
+  DefaultExampleExpression exp() {
+    Customer customer = customer();
+    return new DefaultExampleExpression((EntityBean)customer, false, LikeType.EQUAL_TO);
+  }
 
-    DefaultExampleExpression expr = new DefaultExampleExpression((EntityBean)customer, false, LikeType.EQUAL_TO);
+  DefaultExampleExpression expExtra() {
+    Customer customer = customer();
+    customer.setSmallnote("smallNote");
+    return new DefaultExampleExpression((EntityBean)customer, false, LikeType.EQUAL_TO);
+  }
 
+  DefaultExampleExpression expDiffName() {
+    Customer customer = customer();
+    customer.setName("otherName");
+    return new DefaultExampleExpression((EntityBean)customer, false, LikeType.EQUAL_TO);
+  }
 
-    BeanQueryRequest<?> request = create(query, desc);
+  BeanDescriptor<Customer> customerBeanDescriptor() {
+    return getBeanDescriptor(Customer.class);
+  }
+
+  DefaultExampleExpression prepare(DefaultExampleExpression expr) {
+
+    SpiQuery<Customer> query = (SpiQuery<Customer>)spiEbeanServer().find(Customer.class);
+    BeanQueryRequest<?> request = create(query, customerBeanDescriptor());
     expr.prepareExpression(request);
 
+    return expr;
+  }
+
+  @Test
+  public void test() {
+
+    DefaultExampleExpression expr = exp();
+
+    prepare(expr);
+
     HashQueryPlanBuilder builder = new HashQueryPlanBuilder();
     expr.queryPlanHash(builder);
 
-    TDSpiExpressionRequest req = new TDSpiExpressionRequest(desc);
+    TDSpiExpressionRequest req = new TDSpiExpressionRequest(customerBeanDescriptor());
     expr.addBindValues(req);
 
     assertThat(req.bindValues).contains("name", "billingAddress.city");
 
-    address.setCity("Auckland");
+    Customer customer = customer();
     customer.setName("Rob");
+    customer.getBillingAddress().setCity("Auckland");
 
     ResetBasicData.reset();
 
-    Query<Customer> query1 = server.find(Customer.class)
+    Query<Customer> query1 = server().find(Customer.class)
         .where().exampleLike(customer)
         .query();
 
@@ -72,4 +96,28 @@ public class DefaultExampleExpressionTest extends BaseTestCase {
     return new OrmQueryRequest<T>(null, null, query, desc, null);
   }
 
+  @Test
+  public void isSameByPlan_whenSame() {
+
+    assertThat(prepare(exp()).isSameByPlan(prepare(exp()))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffBindValue_stillSame() {
+
+    assertThat(prepare(exp()).isSameByPlan(prepare(expDiffName()))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_extraExpression_then_different() {
+
+    assertThat(prepare(exp()).isSameByPlan(prepare(expExtra()))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_lessExpression_then_different() {
+
+    assertThat(prepare(expExtra()).isSameByPlan(prepare(exp()))).isFalse();
+  }
+
 }

src/test/java/com/avaje/ebeaninternal/server/expression/DefaultExpressionListTest.java

@@ -0,0 +1,98 @@
+package com.avaje.ebeaninternal.server.expression;
+
+import com.avaje.ebean.ExpressionList;
+import org.junit.Test;
+
+import static org.assertj.core.api.StrictAssertions.assertThat;
+
+public class DefaultExpressionListTest {
+
+
+  DefaultExpressionList exp() {
+
+    return new DefaultExpressionList<Object>(null, new DefaultExpressionFactory(true), null);
+  }
+
+  DefaultExpressionList spi(ExpressionList list) {
+    return (DefaultExpressionList)list;
+  }
+
+  @Test
+  public void isSameByPlan_when_same() {
+
+    assertThat(spi(exp().eq("a", 10).eq("b", 20))
+        .isSameByPlan(spi(exp().eq("a", 10).eq("b", 20)))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffExpressionType() {
+
+    assertThat(spi(exp().eq("a", 10).eq("b", 20))
+        .isSameByPlan(new NoopExpression())).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_less() {
+
+    assertThat(spi(exp().eq("a", 10).eq("b", 20))
+        .isSameByPlan(spi(exp().eq("a", 10)))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_lessEmptyLast() {
+
+    assertThat(spi(exp().eq("a", 10).eq("b", 20))
+        .isSameByPlan(spi(exp()))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_lessEmptyFirst() {
+
+    assertThat(spi(exp())
+        .isSameByPlan(spi(exp().eq("a", 10)))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_more() {
+
+    assertThat(spi(exp().eq("a", 10).eq("b", 20))
+        .isSameByPlan(spi(exp().eq("a", 10).eq("b", 20).eq("c", 30)))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffProperties() {
+
+    assertThat(spi(exp().eq("a", 10).eq("b", 20))
+        .isSameByPlan(spi(exp().eq("c", 10).eq("b", 20)))).isFalse();
+  }
+
+
+  @Test
+  public void isSameByBind_when_same() {
+
+    assertThat(spi(exp().eq("a", 10).eq("b", 20))
+        .isSameByBind(spi(exp().eq("a", 10).eq("b", 20)))).isTrue();
+  }
+
+  @Test
+  public void isSameByBind_when_diffValues() {
+
+    assertThat(spi(exp().eq("a", 10).eq("b", 20))
+        .isSameByBind(spi(exp().eq("a", 10).eq("b", 30)))).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_less() {
+
+    assertThat(spi(exp().eq("a", 10))
+        .isSameByBind(spi(exp().eq("a", 10).eq("b", 20)))).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_more() {
+
+    assertThat(spi(exp().eq("a", 10))
+        .isSameByBind(spi(exp().eq("a", 10).eq("b", 20)))).isFalse();
+  }
+
+}

src/test/java/com/avaje/ebeaninternal/server/expression/ExistsExpressionTest.java

@@ -0,0 +1,85 @@
+package com.avaje.ebeaninternal.server.expression;
+
+
+import org.jetbrains.annotations.NotNull;
+import org.junit.Test;
+
+import java.util.Arrays;
+
+import static org.assertj.core.api.StrictAssertions.assertThat;
+
+public class ExistsExpressionTest {
+
+
+  @NotNull
+  private ExistsExpression exp(boolean not, String sql, Object... bindValues) {
+    return new ExistsExpression(not, sql, Arrays.asList(bindValues));
+  }
+
+  @Test
+  public void isSameByPlan_when_same() {
+
+    assertThat(exp(true,"a", 10).isSameByPlan(exp(true,"a", 10))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffBind_same() {
+
+    assertThat(exp(true,"a", 10).isSameByPlan(exp(true,"a", 20))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffNot() {
+
+    assertThat(exp(true,"a", 10).isSameByPlan(exp(false,"a", 10))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffSql() {
+
+    assertThat(exp(true,"a", 10).isSameByPlan(exp(true,"b", 10))).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_sameBindValues() {
+
+    assertThat(exp(true,"a", 10).isSameByBind(exp(true,"a", 10))).isTrue();
+  }
+
+  @Test
+  public void isSameByBind_when_sameMultipleBindValues() {
+
+    assertThat(exp(true,"a", 10, "ABC", 20).isSameByBind(exp(true,"a", 10, "ABC", 20))).isTrue();
+  }
+
+  @Test
+  public void isSameByBind_when_diffMultipleBindValues() {
+
+    assertThat(exp(true,"a", 10, "ABC", 20).isSameByBind(exp(true,"a", 10, "ABC", 21))).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_diffMultipleBindValuesByOrder() {
+
+    assertThat(exp(true,"a", 10, "ABC", 20).isSameByBind(exp(true,"a", 10, 20, "ABC"))).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_diffBindValues() {
+
+    assertThat(exp(true,"a", 10).isSameByBind(exp(true,"a", 20))).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_lessBindValues() {
+
+    assertThat(exp(true,"a", 10, 20).isSameByBind(exp(true,"a", 20))).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_moreBindValues() {
+
+    assertThat(exp(true,"a", 10).isSameByBind(exp(true,"a", 10, 20))).isFalse();
+  }
+
+}

src/test/java/com/avaje/ebeaninternal/server/expression/IdExpressionTest.java

@@ -0,0 +1,41 @@
+package com.avaje.ebeaninternal.server.expression;
+
+
+import org.jetbrains.annotations.NotNull;
+import org.junit.Test;
+
+import static org.assertj.core.api.StrictAssertions.assertThat;
+
+public class IdExpressionTest {
+
+
+  @NotNull
+  private IdExpression exp(Object value) {
+    return new IdExpression(value);
+  }
+
+  @Test
+  public void isSameByPlan_when_same() {
+
+    assertThat(exp(10).isSameByPlan(exp(10))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffBind_same() {
+
+    assertThat(exp(10).isSameByPlan(exp(20))).isTrue();
+  }
+
+  @Test
+  public void isSameByBind_when_sameBindValues() {
+
+    assertThat(exp(10).isSameByBind(exp(10))).isTrue();
+  }
+
+  @Test
+  public void isSameByBind_when_diffBindValues() {
+
+    assertThat(exp(10).isSameByBind(exp(20))).isFalse();
+    assertThat(exp(10).isSameByBind(exp("junk"))).isFalse();
+  }
+}

src/test/java/com/avaje/ebeaninternal/server/expression/IdInExpressionTest.java

@@ -0,0 +1,67 @@
+package com.avaje.ebeaninternal.server.expression;
+
+import org.jetbrains.annotations.NotNull;
+import org.junit.Test;
+
+import java.util.Arrays;
+
+import static org.assertj.core.api.StrictAssertions.assertThat;
+
+public class IdInExpressionTest {
+
+
+  @NotNull
+  private IdInExpression exp(Object... values) {
+    return new IdInExpression(Arrays.asList(values));
+  }
+
+  @Test
+  public void isSameByPlan_when_same() {
+
+    assertThat(exp(10).isSameByPlan(exp(10))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffBind_same() {
+
+    assertThat(exp(10).isSameByPlan(exp(20))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffBindCount() {
+
+    assertThat(exp(10).isSameByPlan(exp(10, 20))).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_sameBindValues() {
+
+    assertThat(exp(10).isSameByBind(exp(10))).isTrue();
+  }
+
+  @Test
+  public void isSameByBind_when_mulitpleSameBindValues() {
+
+    assertThat(exp(10,"ABC", 20).isSameByBind(exp(10, "ABC", 20))).isTrue();
+  }
+
+  @Test
+  public void isSameByBind_when_diffBindValues() {
+
+    assertThat(exp(10).isSameByBind(exp("junk"))).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_lessBindValues() {
+
+    assertThat(exp(10,"ABC", 20).isSameByBind(exp(10, "ABC"))).isFalse();
+  }
+
+
+  @Test
+  public void isSameByBind_when_moreBindValues() {
+
+    assertThat(exp(10,"ABC").isSameByBind(exp(10, "ABC", 30))).isFalse();
+  }
+
+}

src/test/java/com/avaje/ebeaninternal/server/expression/InExpressionTest.java

@@ -1,12 +1,16 @@
 package com.avaje.ebeaninternal.server.expression;
 
 import com.avaje.ebeaninternal.api.HashQueryPlanBuilder;
+import org.jetbrains.annotations.NotNull;
 import org.junit.Test;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 
-import static org.junit.Assert.*;
+import static org.assertj.core.api.StrictAssertions.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
 
 public class InExpressionTest {
 
@@ -87,4 +91,70 @@ public class InExpressionTest {
     }
     return list;
   }
+
+  @NotNull
+  private InExpression exp(String propName, boolean not, Object... values) {
+    return new InExpression(propName, Arrays.asList(values), not);
+  }
+
+  @Test
+  public void isSameByPlan_when_same() {
+
+    assertThat(exp("a", false, 10).isSameByPlan(exp("a", false, 10))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffPropertyName() {
+
+    assertThat(exp("a", false, 10).isSameByPlan(exp("b", false, 10))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffNot() {
+
+    assertThat(exp("a", false, 10).isSameByPlan(exp("a", true, 10))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffBind_same() {
+
+    assertThat(exp("a", false, 10).isSameByPlan(exp("a", false, 10, 20))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffBindCount() {
+
+    assertThat(exp("a", false, 10).isSameByPlan(exp("a", false, 10, 20))).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_sameBindValues() {
+
+    assertThat(exp("a", false, 10).isSameByBind(exp("a", false, 10))).isTrue();
+  }
+
+  @Test
+  public void isSameByBind_when_sameMultipleBindValues() {
+
+    assertThat(exp("a", false, 10, "ABC", 20).isSameByBind(exp("a", false, 10, "ABC", 20))).isTrue();
+  }
+
+  @Test
+  public void isSameByBind_when_diffBindValues() {
+
+    assertThat(exp("a", false, 10).isSameByBind(exp("a", false, "foo"))).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_lessBindValues() {
+
+    assertThat(exp("a", false, 10, "ABC", 20).isSameByBind(exp("a", false, 10, "ABC"))).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_moreBindValues() {
+
+    assertThat(exp("a", false, 10, "ABC").isSameByBind(exp("a", false, 10, "ABC", 30))).isFalse();
+  }
+
 }

src/test/java/com/avaje/ebeaninternal/server/expression/InQueryExpressionTest.java

@@ -0,0 +1,89 @@
+package com.avaje.ebeaninternal.server.expression;
+
+import org.jetbrains.annotations.NotNull;
+import org.junit.Test;
+
+import java.util.Arrays;
+
+import static org.assertj.core.api.StrictAssertions.assertThat;
+
+public class InQueryExpressionTest {
+
+
+  @NotNull
+  private InQueryExpression exp(String propertyName, boolean not, String sql, Object... bindValues) {
+    return new InQueryExpression(propertyName, not, sql, Arrays.asList(bindValues));
+  }
+
+  @Test
+  public void isSameByPlan_when_same() {
+
+    assertThat(exp("name",true,"sql", 10).isSameByPlan(exp("name",true,"sql", 10))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffBind_same() {
+
+    assertThat(exp("name",true,"sql", 10).isSameByPlan(exp("name",true,"sql", 20))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffNPropertyName() {
+
+    assertThat(exp("name",true,"sql", 10).isSameByPlan(exp("nameDiff",true,"sql", 10))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffNot() {
+
+    assertThat(exp("name",true,"sql", 10).isSameByPlan(exp("name",false,"sql", 10))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffSql() {
+
+    assertThat(exp("name",true,"sql", 10).isSameByPlan(exp("name",true,"sqlDiff", 10))).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_sameBindValues() {
+
+    assertThat(exp("name",true,"sql", 10).isSameByBind(exp("name",true,"sql", 10))).isTrue();
+  }
+
+  @Test
+  public void isSameByBind_when_sameMultipleBindValues() {
+
+    assertThat(exp("name",true,"sql", 10, "ABC", 20).isSameByBind(exp("name",true,"sql", 10, "ABC", 20))).isTrue();
+  }
+
+  @Test
+  public void isSameByBind_when_diffMultipleBindValues() {
+
+    assertThat(exp("name",true,"sql", 10, "ABC", 20).isSameByBind(exp("name",true,"sql", 10, "ABC", 21))).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_diffMultipleBindValuesByOrder() {
+
+    assertThat(exp("name",true,"sql", 10, "ABC", 20).isSameByBind(exp("name",true,"sql", 10, 20, "ABC"))).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_diffBindValues() {
+
+    assertThat(exp("name",true,"sql", 10).isSameByBind(exp("name",true,"sql", 20))).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_lessBindValues() {
+
+    assertThat(exp("name",true,"sql", 10, 20).isSameByBind(exp("name",true,"sql", 20))).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_moreBindValues() {
+
+    assertThat(exp("name",true,"sql", 10).isSameByBind(exp("name",true,"sql", 10, 20))).isFalse();
+  }
+}

src/test/java/com/avaje/ebeaninternal/server/expression/JsonPathExpressionTest.java

@@ -0,0 +1,81 @@
+package com.avaje.ebeaninternal.server.expression;
+
+import org.jetbrains.annotations.NotNull;
+import org.junit.Test;
+
+import static org.assertj.core.api.StrictAssertions.assertThat;
+
+public class JsonPathExpressionTest {
+
+  @NotNull
+  private JsonPathExpression exp(String propertyName, String path, Op operator, Object value) {
+    return new JsonPathExpression(propertyName, path, operator, value);
+  }
+
+  @Test
+  public void isSameByPlan_when_same() {
+
+    assertThat(exp("a", "path", Op.EQ, 10).isSameByPlan(exp("a", "path", Op.EQ, 10))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffBind_same() {
+
+    assertThat(exp("a", "path", Op.EQ, 10).isSameByPlan(exp("a", "path", Op.EQ, 20))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffPath() {
+
+    assertThat(exp("a", "path", Op.EQ, 10).isSameByPlan(exp("a", "pathDiff", Op.EQ, 10))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffProperty_diff() {
+
+    assertThat(exp("a", "path", Op.EQ, 10).isSameByPlan(exp("b", "path", Op.EQ, 10))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffOperator_diff() {
+
+    assertThat(exp("a", "path", Op.EQ, 10).isSameByPlan(exp("a", "path", Op.LT, 10))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffType_diff() {
+
+    assertThat(exp("a", "path", Op.EQ, 10).isSameByPlan(new NoopExpression())).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_sameBindValues() {
+
+    assertThat(exp("a", "path", Op.EQ, 10).isSameByBind(exp("a", "path", Op.LT, 10))).isTrue();
+  }
+
+  @Test
+  public void isSameByBind_when_sameNullBindValues() {
+
+    assertThat(exp("a", "path", Op.EQ, null).isSameByBind(exp("a", "path", Op.LT, null))).isTrue();
+  }
+
+  @Test
+  public void isSameByBind_when_diffBindValues() {
+
+    assertThat(exp("a", "path", Op.EQ, 10).isSameByBind(exp("a", "path", Op.EQ, "junk"))).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_diffFirstNullBindValues() {
+
+    assertThat(exp("a", "path", Op.EQ, null).isSameByBind(exp("a", "path", Op.LT, 10))).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_diffLastNullBindValues() {
+
+    assertThat(exp("a", "path", Op.EQ, 10).isSameByBind(exp("a", "path", Op.LT, null))).isFalse();
+  }
+
+}

src/test/java/com/avaje/ebeaninternal/server/expression/JunctionExpressionTest.java

@@ -0,0 +1,60 @@
+package com.avaje.ebeaninternal.server.expression;
+
+import com.avaje.ebean.Expr;
+import com.avaje.ebean.Expression;
+import org.junit.Test;
+
+import static org.assertj.core.api.StrictAssertions.assertThat;
+
+public class JunctionExpressionTest {
+
+  Expression eq(String propName, int value) {
+    return Expr.eq(propName, value);
+  }
+
+
+  DefaultExpressionList<?> exp(Expression... expressions) {
+
+    DefaultExpressionList<Object> list = new DefaultExpressionList<Object>(null, new DefaultExpressionFactory(true), null);
+    for (Expression ex : expressions) {
+      list.add(ex);
+    }
+    return list;
+  }
+
+  <T> JunctionExpression and(DefaultExpressionList<T> list) {
+    return new JunctionExpression.Conjunction<T>(list);
+  }
+
+  <T> JunctionExpression or(DefaultExpressionList<T> list) {
+    return new JunctionExpression.Disjunction<T>(list);
+  }
+
+  @Test
+  public void isSameByPlan_when_same() {
+
+    assertThat(and(exp(eq("a", 10), eq("b", 10)))
+        .isSameByPlan(and(exp(eq("a", 10), eq("b", 10))))).isTrue();
+  }
+
+  @Test
+  public void copyForPlanKey_isSameByPlan_when_same() {
+
+    assertThat(and(exp(eq("a", 10), eq("b", 10)).copyForPlanKey())
+        .isSameByPlan(and(exp(eq("a", 10), eq("b", 10))))).isTrue();
+  }
+
+  @Test
+  public void copyForPlanKey_isSameByPlan_when_diff() {
+
+    assertThat(and(exp(eq("a", 10), eq("b", 10)).copyForPlanKey())
+        .isSameByPlan(and(exp(eq("a", 10), eq("c", 10))))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffType() {
+
+    assertThat(and(exp(eq("a", 10), eq("b", 10)))
+        .isSameByPlan(or(exp(eq("a", 10), eq("b", 10))))).isFalse();
+  }
+}

src/test/java/com/avaje/ebeaninternal/server/expression/LikeExpressionTest.java

@@ -0,0 +1,66 @@
+package com.avaje.ebeaninternal.server.expression;
+
+import com.avaje.ebean.LikeType;
+import org.jetbrains.annotations.NotNull;
+import org.junit.Test;
+
+import static org.assertj.core.api.StrictAssertions.assertThat;
+
+public class LikeExpressionTest extends BaseExpressionTest {
+
+
+  @NotNull
+  private LikeExpression exp(String propertyName, String value, boolean caseInsensitive, LikeType type) {
+    return new LikeExpression(propertyName, value, caseInsensitive, type);
+  }
+
+  @Test
+  public void isSameByPlan_when_same() {
+
+    assertThat(exp("a", "rob", true, LikeType.STARTS_WITH)
+        .isSameByPlan(exp("a", "rob", true, LikeType.STARTS_WITH))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffBind_then_stillSame() {
+
+    assertThat(exp("a", "rob", true, LikeType.STARTS_WITH)
+        .isSameByPlan(exp("a", "bor", true, LikeType.STARTS_WITH))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffCaseInsensitive() {
+
+    assertThat(exp("a", "rob", true, LikeType.STARTS_WITH)
+        .isSameByPlan(exp("a", "rob", false, LikeType.STARTS_WITH))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffLikeType() {
+
+    assertThat(exp("a", "rob", true, LikeType.STARTS_WITH)
+        .isSameByPlan(exp("a", "rob", true, LikeType.ENDS_WITH))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffProperty() {
+
+    assertThat(exp("a", "rob", true, LikeType.STARTS_WITH)
+        .isSameByPlan(exp("b", "rob", true, LikeType.STARTS_WITH))).isFalse();
+  }
+
+
+  @Test
+  public void isSameByBind_when_sameBindValues() {
+
+    assertThat(exp("a", "rob", true, LikeType.STARTS_WITH)
+        .isSameByBind(exp("a", "rob", true, LikeType.STARTS_WITH))).isTrue();
+  }
+
+  @Test
+  public void isSameByBind_when_diffBindValues() {
+
+    assertThat(exp("a", "rob", true, LikeType.STARTS_WITH)
+        .isSameByBind(exp("a", "bor", true, LikeType.STARTS_WITH))).isFalse();
+  }
+}

src/test/java/com/avaje/ebeaninternal/server/expression/LogicExpressionTest.java

@@ -0,0 +1,78 @@
+package com.avaje.ebeaninternal.server.expression;
+
+import com.avaje.ebean.Expr;
+import com.avaje.ebean.Expression;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class LogicExpressionTest extends BaseExpressionTest {
+
+  Expression eq(String propName, int value) {
+    return Expr.eq(propName, value);
+  }
+
+  LogicExpression and(Expression a, Expression b) {
+    return new LogicExpression.And(a, b);
+  }
+
+  LogicExpression or(Expression a, Expression b) {
+    return new LogicExpression.Or(a, b);
+  }
+
+  @Test
+  public void isSameByPlan_when_same() {
+
+    assertThat(and(eq("a", 10), eq("b", 10))
+        .isSameByPlan(and(eq("a", 10), eq("b", 10)))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffBind_then_stillSame() {
+
+    assertThat(and(eq("a", 10), eq("b", 10))
+        .isSameByPlan(and(eq("a", 20), eq("b", 20)))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffExp1_then_diff() {
+
+    assertThat(and(eq("a", 10), eq("b", 10))
+        .isSameByPlan(and(eq("c", 10), eq("b", 10)))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffExp2_then_diff() {
+
+    assertThat(and(eq("a", 10), eq("b", 10))
+        .isSameByPlan(and(eq("a", 10), eq("c", 10)))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffType_then_diff() {
+
+    assertThat(or(eq("a", 10), eq("b", 10))
+        .isSameByPlan(and(eq("a", 10), eq("c", 10)))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffExpressionType() {
+
+    assertThat(or(eq("a", 10), eq("b", 10))
+        .isSameByPlan(new NoopExpression())).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_sameBindValues() {
+
+    assertThat(and(eq("a", 10), eq("b", 10))
+        .isSameByBind(and(eq("a", 10), eq("c", 10)))).isTrue();
+  }
+
+  @Test
+  public void isSameByBind_when_diffBindValues() {
+
+    assertThat(and(eq("a", 10), eq("b", 10))
+        .isSameByBind(and(eq("a", 10), eq("c", 20)))).isFalse();
+  }
+}

src/test/java/com/avaje/ebeaninternal/server/expression/NoopExpressionTest.java

@@ -8,7 +8,8 @@ import org.junit.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
-public class NoopExpressionQueryTest extends BaseTestCase {
+
+public class NoopExpressionTest extends BaseTestCase {
 
   @Test
   public void test() {
@@ -39,4 +40,29 @@ public class NoopExpressionQueryTest extends BaseTestCase {
 
     assertThat(generatedSql).contains("select t0.id c0 from o_customer t0 where t0.name is null  and 1=1 and t0.status is not null");
   }
+
+  @Test
+  public void isSameByPlan_when_same() {
+
+    assertThat(new NoopExpression().isSameByPlan(new NoopExpression())).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffExpressionType() {
+
+    assertThat(new NoopExpression().isSameByPlan(null)).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_same() {
+
+    assertThat(new NoopExpression().isSameByBind(new NoopExpression())).isTrue();
+  }
+
+  @Test
+  public void isSameByBind_when_diffExpressionType() {
+
+    assertThat(new NoopExpression().isSameByBind(null)).isTrue();
+  }
+
 }

src/test/java/com/avaje/ebeaninternal/server/expression/NotExpressionTest.java

@@ -0,0 +1,58 @@
+package com.avaje.ebeaninternal.server.expression;
+
+
+import com.avaje.ebean.Expression;
+import org.junit.Test;
+
+import static com.avaje.ebean.Expr.eq;
+import static org.assertj.core.api.StrictAssertions.assertThat;
+
+public class NotExpressionTest {
+
+
+  NotExpression not(Expression expression) {
+    return new NotExpression(expression);
+  }
+
+  @Test
+  public void isSameByPlan_when_same() {
+
+    assertThat(not(eq("a", 10))
+        .isSameByPlan(not(eq("a", 10)))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_sameByPlan() {
+
+    assertThat(not(eq("a", 10))
+        .isSameByPlan(not(eq("a", 20)))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_different() {
+
+    assertThat(not(eq("a", 10))
+        .isSameByPlan(not(eq("b", 10)))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_differentExpressionType() {
+
+    assertThat(not(eq("a", 10))
+        .isSameByPlan(new NoopExpression())).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_same() {
+
+    assertThat(not(eq("a", 10))
+        .isSameByBind(not(eq("b", 10)))).isTrue();
+  }
+
+  @Test
+  public void isSameByBind_when_different() {
+
+    assertThat(not(eq("a", 10))
+        .isSameByBind(not(eq("a", 20)))).isFalse();
+  }
+}

src/test/java/com/avaje/ebeaninternal/server/expression/NullExpressionTest.java

@@ -0,0 +1,91 @@
+package com.avaje.ebeaninternal.server.expression;
+
+import com.avaje.ebeaninternal.api.SpiExpression;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class NullExpressionTest extends BaseExpressionTest {
+
+  NullExpression nullExp(String propertyName, boolean notNull) {
+    return new NullExpression(propertyName, notNull);
+  }
+
+  @Test
+  public void addSql_when_notNull() throws Exception {
+
+    DefaultExpressionRequest expReq = newExpressionRequest();
+
+    nullExp("id", true).addSql(expReq);
+
+    assertThat(expReq.getSql()).isEqualTo("id is not null ");
+  }
+
+  @Test
+  public void addSql_when_null() throws Exception {
+
+    DefaultExpressionRequest expReq = newExpressionRequest();
+
+    nullExp("id", false).addSql(expReq);
+
+    assertThat(expReq.getSql()).isEqualTo("id is null ");
+  }
+
+  @Test
+  public void addSql_when_notNull_and_assocOne() throws Exception {
+
+    DefaultExpressionRequest expReq = newExpressionRequest();
+
+    nullExp("customer", true).addSql(expReq);
+
+    assertThat(expReq.getSql()).isEqualTo("customer.id is not null ");
+  }
+
+  @Test
+  public void addSql_when_null_and_assocOne() throws Exception {
+
+    DefaultExpressionRequest expReq = newExpressionRequest();
+
+    nullExp("customer", false).addSql(expReq);
+
+    assertThat(expReq.getSql()).isEqualTo("customer.id is null ");
+  }
+
+  @Test
+  public void copyForPlanKey_isSameInstance() throws Exception {
+
+    NullExpression exp = nullExp("customer.name", false);
+    SpiExpression other = exp.copyForPlanKey();
+
+    assertThat(exp).isSameAs(other);
+  }
+
+  @Test
+  public void isSameByBind_true() throws Exception {
+
+    assertThat(nullExp("customer.name", false)
+        .isSameByBind(nullExp("customer.name", false))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_true() throws Exception {
+
+    assertThat(nullExp("customer.name", false)
+        .isSameByPlan(nullExp("customer.name", false))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_false_when_notNullDiff() throws Exception {
+
+    assertThat(new NullExpression("customer.name", false)
+        .isSameByPlan(new NullExpression("customer.name", true))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_false_when_propertyNameDiff() throws Exception {
+
+    assertThat(new NullExpression("customer.startDate", true)
+        .isSameByPlan(new NullExpression("customer.name", true))).isFalse();
+  }
+
+}

src/test/java/com/avaje/ebeaninternal/server/expression/RawExpressionTest.java

@@ -0,0 +1,50 @@
+package com.avaje.ebeaninternal.server.expression;
+
+import org.jetbrains.annotations.NotNull;
+import org.junit.Test;
+
+import static org.assertj.core.api.StrictAssertions.assertThat;
+
+public class RawExpressionTest {
+
+  @NotNull
+  private RawExpression exp(String sql, Object... values) {
+    return new RawExpression(sql, values);
+  }
+
+  @Test
+  public void isSameByPlan_when_same() {
+    assertThat(exp("a", 10).isSameByPlan(exp("a", 10))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffBindValues() {
+    assertThat(exp("a", 10).isSameByPlan(exp("a", 20))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffSql() {
+    assertThat(exp("a", 10).isSameByPlan(exp("b", 10))).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_same() {
+    assertThat(exp("a", 10).isSameByBind(exp("a", 10))).isTrue();
+  }
+
+  @Test
+  public void isSameByBind_when_diffBindValues() {
+    assertThat(exp("a", 10).isSameByBind(exp("a", 20))).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_moreBindValues() {
+    assertThat(exp("a", 10).isSameByBind(exp("a", 10, 20))).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_lessBindValues() {
+    assertThat(exp("a", 10, 20).isSameByBind(exp("a", 10))).isFalse();
+  }
+
+}

src/test/java/com/avaje/ebeaninternal/server/expression/SameTest.java

@@ -0,0 +1,29 @@
+package com.avaje.ebeaninternal.server.expression;
+
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+
+public class SameTest {
+
+  @Test
+  public void sameByNull() throws Exception {
+
+    assertThat(Same.sameByNull("a", "a")).isTrue();
+    assertThat(Same.sameByNull("a", "b")).isTrue();
+    assertThat(Same.sameByNull(null, null)).isTrue();
+    assertThat(Same.sameByNull("a", null)).isFalse();
+    assertThat(Same.sameByNull(null, "a")).isFalse();
+  }
+
+  @Test
+  public void sameByValue() throws Exception {
+
+    assertThat(Same.sameByValue("a", "a")).isTrue();
+    assertThat(Same.sameByValue("a", "b")).isFalse();
+    assertThat(Same.sameByValue(null, null)).isTrue();
+    assertThat(Same.sameByValue("a", null)).isFalse();
+    assertThat(Same.sameByValue(null, "a")).isFalse();
+  }
+}

src/test/java/com/avaje/ebeaninternal/server/expression/SimpleExpressionTest.java

@@ -0,0 +1,58 @@
+package com.avaje.ebeaninternal.server.expression;
+
+
+import org.jetbrains.annotations.NotNull;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class SimpleExpressionTest extends BaseExpressionTest {
+
+  @NotNull
+  private SimpleExpression exp(String propertyName, Op operator, Object value) {
+    return new SimpleExpression(propertyName, operator, value);
+  }
+
+  @Test
+  public void isSameByPlan_when_same() {
+
+    assertThat(exp("a", Op.EQ, 10).isSameByPlan(exp("a", Op.EQ, 10))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffBind_same() {
+
+    assertThat(exp("a", Op.EQ, 10).isSameByPlan(exp("a", Op.EQ, 20))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffProperty_diff() {
+
+    assertThat(exp("a", Op.EQ, 10).isSameByPlan(exp("b", Op.EQ, 10))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffOperator_diff() {
+
+    assertThat(exp("a", Op.EQ, 10).isSameByPlan(exp("a", Op.LT, 10))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffType_diff() {
+
+    assertThat(exp("a", Op.EQ, 10).isSameByPlan(new NoopExpression())).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_sameBindValues() {
+
+    assertThat(exp("a", Op.EQ, 10).isSameByBind(exp("a", Op.LT, 10))).isTrue();
+  }
+
+  @Test
+  public void isSameByBind_when_diffBindValues() {
+
+    assertThat(exp("a", Op.EQ, 10).isSameByBind(exp("a", Op.EQ, "junk"))).isFalse();
+  }
+
+}

src/test/java/com/avaje/ebeaninternal/server/query/RawSqlQueryPlanKeyTest.java

@@ -0,0 +1,61 @@
+package com.avaje.ebeaninternal.server.query;
+
+
+import org.jetbrains.annotations.NotNull;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class RawSqlQueryPlanKeyTest {
+
+
+  @Test
+  public void test_equals_same_instance() {
+
+    RawSqlQueryPlanKey key = key("select foo", true, true, "");
+    assertThat(key).isEqualTo(key);
+    assertThat(key.hashCode()).isEqualTo(key.hashCode());
+  }
+
+  @Test
+  public void test_equals_diff_instance() {
+
+    assertThat(key("select foo", true, true, "")).isEqualTo(key("select foo", true, true, ""));
+    assertThat(key("select foo", true, true, "").hashCode()).isEqualTo(key("select foo", true, true, "").hashCode());
+  }
+
+  @Test
+  public void test_notEquals_diff_sql() {
+
+    assertThat(key("select foo", true, true, "")).isNotEqualTo(key("select bar", true, true, ""));
+    assertThat(key("select foo", true, true, "").hashCode()).isNotEqualTo(key("select bar", true, true, "").hashCode());
+  }
+
+  @Test
+  public void test_notEquals_diff_rawSqlFlag() {
+
+    assertThat(key("select foo", true, true, "")).isNotEqualTo(key("select foo", false, true, ""));
+    assertThat(key("select foo", true, true, "").hashCode()).isNotEqualTo(key("select foo", false, true, "").hashCode());
+  }
+
+  @Test
+  public void test_notEquals_diff_rowNumberIncluded() {
+
+    assertThat(key("select foo", true, true, "")).isNotEqualTo(key("select foo", true, false, ""));
+    assertThat(key("select foo", true, true, "").hashCode()).isNotEqualTo(key("select foo", true, false, "").hashCode());
+  }
+
+
+  @Test
+  public void test_notEquals_diff_logWhereSql() {
+
+    assertThat(key("select foo", true, true, "")).isNotEqualTo(key("select foo", true, true, "a"));
+    assertThat(key("select foo", true, true, "").hashCode()).isNotEqualTo(key("select foo", true, true, "a").hashCode());
+  }
+
+  @NotNull
+  private RawSqlQueryPlanKey key(String sql, boolean rawSql, boolean rowNumberIncluded, String logWhereSql) {
+    return new RawSqlQueryPlanKey(sql, rawSql, rowNumberIncluded, logWhereSql);
+  }
+
+}

src/test/java/com/avaje/ebeaninternal/server/querydefn/DefaultOrmQueryTest.java

@@ -16,7 +16,7 @@ public class DefaultOrmQueryTest {
     DefaultOrmQuery<Order> q1 = (DefaultOrmQuery<Order>)Ebean.find(Order.class).where().in("name", "a","b","c").query();
     DefaultOrmQuery<Order> q2 = (DefaultOrmQuery<Order>)Ebean.find(Order.class).where().in("id", 2,2,3).query();
 
-    assertThat(q1.calculateQueryPlanHash()).isNotEqualTo(q2.calculateQueryPlanHash());
+    assertThat(q1.createQueryPlanKey()).isNotEqualTo(q2.createQueryPlanKey());
     assertThat(q1.queryBindHash()).isNotEqualTo(q2.queryBindHash());
   }
 
@@ -26,7 +26,7 @@ public class DefaultOrmQueryTest {
     DefaultOrmQuery<Order> q1 = (DefaultOrmQuery<Order>)Ebean.find(Order.class).where().in("id", 1,2,3).query();
     DefaultOrmQuery<Order> q2 = (DefaultOrmQuery<Order>)Ebean.find(Order.class).where().in("id", 2,2,3).query();
 
-    assertThat(q1.calculateQueryPlanHash()).isEqualTo(q2.calculateQueryPlanHash());
+    assertThat(q1.createQueryPlanKey()).isEqualTo(q2.createQueryPlanKey());
     assertThat(q1.queryBindHash()).isNotEqualTo(q2.queryBindHash());
   }
 
@@ -36,7 +36,7 @@ public class DefaultOrmQueryTest {
     DefaultOrmQuery<Order> q1 = (DefaultOrmQuery<Order>)Ebean.find(Order.class).where().in("id", 1,2,3).query();
     DefaultOrmQuery<Order> q2 = (DefaultOrmQuery<Order>)Ebean.find(Order.class).where().in("id", 1,2,3).query();
 
-    assertThat(q1.calculateQueryPlanHash()).isEqualTo(q2.calculateQueryPlanHash());
+    assertThat(q1.createQueryPlanKey()).isEqualTo(q2.createQueryPlanKey());
     assertThat(q1.queryBindHash()).isEqualTo(q2.queryBindHash());
   }
 
@@ -55,7 +55,7 @@ public class DefaultOrmQueryTest {
         .fetch("details", "orderQty, unitPrice")
         .fetch("details.product", "sku, name");
 
-    assertThat(query1.calculateQueryPlanHash()).isNotEqualTo(query2.calculateQueryPlanHash());
+    assertThat(query1.createQueryPlanKey()).isNotEqualTo(query2.createQueryPlanKey());
   }
 
   @Test
@@ -69,7 +69,7 @@ public class DefaultOrmQueryTest {
         .setFirstRow(1)
         .setMaxRows(0);
 
-    assertThat(query1.calculateQueryPlanHash()).isNotEqualTo(query2.calculateQueryPlanHash());
+    assertThat(query1.createQueryPlanKey()).isNotEqualTo(query2.createQueryPlanKey());
   }
 
 }

src/test/java/com/avaje/ebeaninternal/server/querydefn/OrmQueryPlanKeyTest.java

@@ -0,0 +1,432 @@
+package com.avaje.ebeaninternal.server.querydefn;
+
+
+import com.avaje.ebean.OrderBy;
+import com.avaje.ebeaninternal.api.SpiExpression;
+import com.avaje.ebeaninternal.api.SpiExpressionList;
+import com.avaje.ebeaninternal.api.SpiQuery;
+import com.avaje.ebeaninternal.server.deploy.TableJoin;
+import com.avaje.ebeaninternal.server.deploy.meta.DeployTableJoin;
+import com.avaje.ebeaninternal.server.deploy.meta.DeployTableJoinColumn;
+import com.avaje.ebeaninternal.server.expression.BaseExpressionTest;
+import com.avaje.tests.model.basic.Customer;
+import org.jetbrains.annotations.NotNull;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class OrmQueryPlanKeyTest extends BaseExpressionTest {
+
+
+  @Test
+  public void equals_when_defaults() {
+
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+
+    assertSame(key1, key2);
+  }
+
+  @Test
+  public void equals_when_diffTableJoinNull() {
+
+    TableJoin tableJoin = tableJoin("id", "customer_id");
+
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(tableJoin, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+
+    assertDifferent(key1, key2);
+  }
+
+  @Test
+  public void equals_when_diffTableJoin() {
+
+    TableJoin tableJoin1 = tableJoin("id", "customer_id");
+    TableJoin tableJoin2 = tableJoin("id", "other_customer_id");
+
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(tableJoin1, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(tableJoin2, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+
+    assertDifferent(key1, key2);
+  }
+
+  @Test
+  public void equals_when_sameTableJoin() {
+
+    TableJoin tableJoin1 = tableJoin("id", "customer_id");
+    TableJoin tableJoin2 = tableJoin("id", "customer_id");
+
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(tableJoin1, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(tableJoin2, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+
+    assertSame(key1, key2);
+  }
+
+  @NotNull
+  private TableJoin tableJoin(String col1, String col2) {
+    DeployTableJoin deploy = new DeployTableJoin();
+    deploy.setTable("myTable");
+    deploy.addJoinColumn(new DeployTableJoinColumn(col1, col2));
+    return new TableJoin(deploy);
+  }
+
+  @Test
+  public void equals_when_diffQueryType() {
+
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.LIST, null, 0, 0, false, null, null, null, null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+
+    assertDifferent(key1, key2);
+  }
+
+  @Test
+  public void equals_when_firstRowsDifferent() {
+
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 10, false, null, null, null, null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+
+    assertDifferent(key1, key2);
+  }
+
+  @Test
+  public void equals_when_maxRowsDifferent() {
+
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 10, 0, false, null, null, null, null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+
+    assertDifferent(key1, key2);
+  }
+
+  @Test
+  public void equals_when_firstRowsMaxRowsSame() {
+
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 10, 20, false, null, null, null, null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 10, 20, false, null, null, null, null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+
+    assertSame(key1, key2);
+  }
+
+  @Test
+  public void equals_when_diffDisableLazyLoading() {
+
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, true, null, null, null, null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+
+    assertDifferent(key1, key2);
+  }
+
+  @Test
+  public void equals_when_diffRawWhereNull() {
+
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, "rawWhere", null, null, null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+
+    assertDifferent(key1, key2);
+  }
+
+  @Test
+  public void equals_when_diffRawWhere() {
+
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, "rawWhere", null, null, null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, "rawDiff", null, null, null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+
+    assertDifferent(key1, key2);
+  }
+
+  @Test
+  public void equals_when_diffOrderByNull() {
+
+    OrderBy<Object> o1 = new OrderBy<Object>("id");
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, o1, null, null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+
+    assertDifferent(key1, key2);
+  }
+
+  @Test
+  public void equals_when_orderBySame() {
+
+    OrderBy<Object> o1 = new OrderBy<Object>("id, name");
+    OrderBy<Object> o2 = new OrderBy<Object>("id, name");
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, o1, null, null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, o2, null, null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+
+    assertSame(key1, key2);
+  }
+
+  @Test
+  public void equals_when_diffQueryNull() {
+
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, "query", null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    assertDifferent(key1, key2);
+  }
+
+
+  @Test
+  public void equals_when_diffQuery() {
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, "query", null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, "queryDiff", null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    assertDifferent(key1, key2);
+  }
+
+  @Test
+  public void equals_when_querySame() {
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, "query", null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, "query", null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    assertSame(key1, key2);
+  }
+
+  @Test
+  public void equals_when_diffAddWhereNull() {
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, "addWhere", null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    assertDifferent(key1, key2);
+  }
+
+  @Test
+  public void equals_when_diffAddWhere() {
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, "addWhere", null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, "diff", null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    assertDifferent(key1, key2);
+  }
+
+  @Test
+  public void equals_when_sameAddWhere() {
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, "addWhere", null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, "addWhere", null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    assertSame(key1, key2);
+  }
+
+  @Test
+  public void equals_when_diffAddHavingNull() {
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, "addHaving", false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    assertDifferent(key1, key2);
+  }
+
+  @Test
+  public void equals_when_diffAddHaving() {
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, "addHaving", false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, "diff", false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    assertDifferent(key1, key2);
+  }
+
+  @Test
+  public void equals_when_sameAddHaving() {
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, "addHaving", false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, "addHaving", false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    assertSame(key1, key2);
+  }
+
+
+  @Test
+  public void equals_when_diffDistinct() {
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, true, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    assertDifferent(key1, key2);
+  }
+
+  @Test
+  public void equals_when_sameDistinct() {
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, true, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, true, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    assertSame(key1, key2);
+  }
+
+  @Test
+  public void equals_when_diffSqlDistinct() {
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, true, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    assertDifferent(key1, key2);
+  }
+
+  @Test
+  public void equals_when_sameSqlDistinct() {
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, true, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, true, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    assertSame(key1, key2);
+  }
+
+  @Test
+  public void equals_when_diffMapKeyNull() {
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, "mapKey", null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    assertDifferent(key1, key2);
+  }
+
+  @Test
+  public void equals_when_diffMapKey() {
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, "mapKey", null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, "diff", null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    assertDifferent(key1, key2);
+  }
+
+  @Test
+  public void equals_when_sameMapKey() {
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, "mapKey", null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, "mapKey", null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    assertSame(key1, key2);
+  }
+
+  @Test
+  public void equals_when_diffIdNull() {
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, 42, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    assertDifferent(key1, key2);
+  }
+
+  @Test
+  public void equals_when_idBothGiven() {
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, 42, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, 23, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    assertSame(key1, key2);
+  }
+
+  @Test
+  public void equals_when_diffTemporalMode() {
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.DRAFT, false, null, null);
+    assertDifferent(key1, key2);
+  }
+
+  @Test
+  public void equals_when_diffForUpdate() {
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, true, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    assertDifferent(key1, key2);
+  }
+
+  @Test
+  public void equals_when_diffRootAliasNull() {
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, "rootAlias", null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    assertDifferent(key1, key2);
+  }
+
+  @Test
+  public void equals_when_diffRootAlias() {
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, "rootAlias", null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, "diff", null);
+    assertDifferent(key1, key2);
+  }
+
+  @Test
+  public void equals_when_sameRootAlias() {
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, "rootAlias", null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, "rootAlias", null);
+    assertSame(key1, key2);
+  }
+
+  SpiExpressionList<Customer> list_id_eq_42() {
+    return (SpiExpressionList<Customer>) server().find(Customer.class)
+        .where().eq("id", 42);
+  }
+
+  SpiExpressionList<Customer> list_id_eq_43() {
+    return (SpiExpressionList<Customer>) server().find(Customer.class)
+        .where().eq("id", 43);
+  }
+
+  SpiExpressionList<Customer> list_id_eq_42_and_name_eq_rob() {
+    return (SpiExpressionList<Customer>) server().find(Customer.class)
+        .where().eq("id", 43).eq("name", "rob");
+  }
+
+
+  @Test
+  public void equals_when_sameWhere() {
+
+
+    SpiExpressionList<Customer> list1 = list_id_eq_42();
+    SpiExpressionList<Customer> list2 = list_id_eq_43();
+
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, null, null, list1, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, null, null, list2, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    assertSame(key1, key2);
+  }
+
+
+  @Test
+  public void equals_when_diffWhere() {
+
+    SpiExpressionList<Customer> where1 = list_id_eq_42();
+    SpiExpressionList<Customer> where2 = list_id_eq_42_and_name_eq_rob();
+
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, null, null, where1, null, SpiQuery.TemporalMode.DRAFT, false, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, null, null, where2, null, SpiQuery.TemporalMode.DRAFT, false, null, null);
+    assertDifferent(key1, key2);
+  }
+
+  @Test
+  public void equals_when_diffWhereNullLast() {
+
+    SpiExpressionList<Customer> list1 = list_id_eq_42();
+
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, null, null, list1, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    assertDifferent(key1, key2);
+  }
+
+  @Test
+  public void equals_when_diffWhereNullFirst() {
+
+    SpiExpressionList<Customer> list1 = list_id_eq_42();
+
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, null, null, list1, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    assertDifferent(key1, key2);
+  }
+
+  @Test
+  public void equals_when_diffHaving() {
+
+    SpiExpression having1 = list_id_eq_42().copyForPlanKey();
+    SpiExpression having2 = list_id_eq_42_and_name_eq_rob().copyForPlanKey();
+
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, null, null, null, having1, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, null, null, null, having2, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    assertDifferent(key1, key2);
+  }
+
+  @Test
+  public void equals_when_sameHaving() {
+
+    SpiExpression having1 = list_id_eq_42().copyForPlanKey();
+    SpiExpression having2 = list_id_eq_42().copyForPlanKey();
+
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, null, null, null, having1, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, null, null, null, having2, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    assertSame(key1, key2);
+  }
+
+  @Test
+  public void equals_when_havingNullLast() {
+
+    SpiExpression having1 = list_id_eq_42().copyForPlanKey();
+
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, null, null, null, having1, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    assertSame(key1, key2);
+  }
+
+  @Test
+  public void equals_when_havingNullFirst() {
+
+    SpiExpression having1 = list_id_eq_42().copyForPlanKey();
+
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, null, null, null, null, false, false, null, null, null, null, having1, SpiQuery.TemporalMode.CURRENT, false, null, null);
+    assertSame(key1, key2);
+  }
+
+  private void assertDifferent(OrmQueryPlanKey key1, OrmQueryPlanKey key2) {
+    assertThat(key1).isNotEqualTo(key2);
+    assertThat(key1.hashCode()).isNotEqualTo(key2.hashCode());
+  }
+
+  private void assertSame(OrmQueryPlanKey key1, OrmQueryPlanKey key2) {
+    assertThat(key1).isEqualTo(key2);
+    assertThat(key1.hashCode()).isEqualTo(key2.hashCode());
+  }
+}