#743 - Fix issue with ElasticSearch nested path query with multiple nested path expressions

src/main/java/com/avaje/ebeaninternal/server/expression/PrepareDocNested.java

@@ -0,0 +1,163 @@
+package com.avaje.ebeaninternal.server.expression;
+
+import com.avaje.ebean.Junction;
+import com.avaje.ebeaninternal.api.SpiExpression;
+import com.avaje.ebeaninternal.server.deploy.BeanDescriptor;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Prepare nested path expressions for
+ */
+class PrepareDocNested {
+
+  /**
+   * Prepare the top level expressions for nested path handling.
+   */
+  static void prepare(DefaultExpressionList<?> expressions, BeanDescriptor<?> beanDescriptor) {
+    new PrepareDocNested(expressions, beanDescriptor, null).process();
+  }
+
+  /**
+   * Prepare the Junction expressions for nested path handling.
+   */
+  static void prepare(DefaultExpressionList<?> expressions, BeanDescriptor<?> beanDescriptor, Junction.Type type) {
+    new PrepareDocNested(expressions, beanDescriptor, type).process();
+  }
+
+  enum Mode {
+    NONE,
+    SINGLE,
+    MIXED
+  }
+
+  private final Junction.Type type;
+  private final DefaultExpressionList<?> original;
+  private final BeanDescriptor<?> beanDescriptor;
+  private final List<SpiExpression> origUnderlying;
+  private final int origSize;
+
+  private boolean hasNesting;
+  private boolean hasMixedNesting;
+  private String firstNestedPath;
+
+
+  PrepareDocNested(DefaultExpressionList<?> original, BeanDescriptor<?> beanDescriptor, Junction.Type type) {
+    this.type = type;
+    this.beanDescriptor = beanDescriptor;
+    this.original = original;
+    this.origUnderlying = original.getUnderlyingList();
+    this.origSize = origUnderlying.size();
+  }
+
+  void process() {
+
+    PrepareDocNested.Mode mode = determineMode();
+    if (mode == PrepareDocNested.Mode.SINGLE) {
+      original.setAllDocNested(firstNestedPath);
+
+    } else if (mode == PrepareDocNested.Mode.MIXED) {
+      original.setUnderlying(group());
+    }
+
+  }
+
+  /**
+   * Reorganise the flat list of expressions into a tree grouping expressions by nested path.
+   *
+   * Returns the new top level list of expressions.
+   */
+  private List<SpiExpression> group() {
+
+    Map<String,Group> groups = new LinkedHashMap<String,Group>();
+
+    // organise expressions by nestedPath
+    for (int i = 0; i < origSize; i++) {
+      SpiExpression expr = origUnderlying.get(i);
+      String nestedPath = expr.nestedPath(beanDescriptor);
+      Group group = groups.get(nestedPath);
+      if (group == null) {
+        group = new Group(nestedPath);
+        groups.put(nestedPath, group);
+      }
+      group.list.add(expr);
+    }
+
+    List<SpiExpression> newList = new ArrayList<SpiExpression>();
+    Collection<Group> values = groups.values();
+    for (Group group : values) {
+      group.addTo(newList);
+    }
+    return newList;
+  }
+
+  /**
+   * Determined the nested path mode.
+   */
+  private Mode determineMode() {
+
+    if (!hasNesting()) {
+      // no nested paths at all
+      return Mode.NONE;
+    }
+    if (!hasMixedNesting) {
+      // single nested path for all expressions
+      return Mode.SINGLE;
+    }
+    // mixed nested paths to underlying expression list needs re-organising by nested path
+    return Mode.MIXED;
+  }
+
+  /**
+   * Return true if the expressions have nested paths.
+   */
+  private boolean hasNesting() {
+
+    for (int i = 0; i < origSize; i++) {
+      SpiExpression expr = origUnderlying.get(i);
+      String nestedPath = expr.nestedPath(beanDescriptor);
+      if (nestedPath == null) {
+        hasMixedNesting = true;
+
+      } if (nestedPath != null) {
+        hasNesting = true;
+        if (firstNestedPath == null) {
+          firstNestedPath = nestedPath;
+        } else if (hasMixedNesting || !firstNestedPath.equals(nestedPath)) {
+          hasMixedNesting = true;
+          return true;
+        }
+      }
+    }
+
+    return hasNesting;
+  }
+
+
+  /**
+   * List of SpiExpression grouped by nested path.
+   */
+  class Group {
+
+    final String nestedPath;
+
+    final List<SpiExpression> list = new ArrayList<SpiExpression>();
+
+    Group(String nestedPath) {
+      this.nestedPath = nestedPath;
+    }
+
+    void addTo(List<SpiExpression> newList) {
+      if (nestedPath == null) {
+        newList.addAll(list);
+      } else {
+        newList.add(original.wrap(list, nestedPath, type));
+      }
+    }
+  }
+
+}