Method iterative

basex-core/src/main/java/org/basex/query/expr/path/Path.java:447–497

Checks if a path can be evaluated iteratively (i.e., if all results will be in distinct document order without final sorting). @param root root expression (can be null) @param steps path steps @return result of check

(final Expr root, final Expr... steps)

   * @return result of check
   */
  private static boolean iterative(final Expr root, final Expr... steps) {
    if(root == null || !root.ddo()) return false;

    final SeqType st = root.seqType();
    boolean atMostOne = st.zeroOrOne();
    boolean sameDepth = atMostOne || st.type.instanceOf(NodeType.DOCUMENT);

    for(final Expr expr : steps) {
      final Step step = (Step) expr;
      switch(step.axis) {
        case ATTRIBUTE:
        case SELF:
          // nothing changes
          break;
        case PARENT:
        case FOLLOWING_SIBLING:
        case FOLLOWING_SIBLING_OR_SELF:
          // can overlap, preserves level
          if(!atMostOne) return false;
          break;
        case CHILD:
          // order is only ensured if all nodes are on the same level
          if(!sameDepth) return false;
          break;
        case DESCENDANT:
        case DESCENDANT_OR_SELF:
          // non-overlapping if all nodes are on the same level
          if(!sameDepth) return false;
          sameDepth = false;
          break;
        case ANCESTOR:
        case ANCESTOR_OR_SELF:
        case PRECEDING:
        case PRECEDING_OR_SELF:
        case PRECEDING_SIBLING:
        case PRECEDING_SIBLING_OR_SELF:
          // backwards axes must be reordered
          return false;
        case FOLLOWING:
        case FOLLOWING_OR_SELF:
          // can overlap
          if(!atMostOne) return false;
          sameDepth = false;
          break;
        default:
          throw Util.notExpected();
      }
      atMostOne &= step.seqType().zeroOrOne();
    }
    return true;
  }

  /**
   * Assigns a sequence type and (if statically known) result size.