41106813683

Committed 30 Oct 2026 06:25PM UTC coverage: 58.246% (+0.07%) from 58.179%

Build # 41106813683

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #6941 from joewiz/optimize/6895-direct-attribute-select

Coverage Stats

32560 of 61746 branches covered (52.73%)

Branch coverage included in aggregate %.

14 of 15 new or added lines in 2 files covered. (93.33%)

19 existing lines in 4 files now uncovered.

85668 of 141233 relevant lines covered (60.66%)

2.73 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

78.45

/exist-core/src/main/java/org/exist/xquery/LocationStep.java

/*
 * eXist-db Open Source Native XML Database
 * Copyright (C) 2001 The eXist-db Authors
 *
 * info@exist-db.org
 * http://www.exist-db.org
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */
package org.exist.xquery;

import org.exist.collections.Collection;
import org.exist.dom.persistent.*;
import org.exist.indexing.StructuralIndex;
import org.exist.dom.memtree.InMemoryNodeSet;
import org.exist.dom.memtree.NodeImpl;
import org.exist.numbering.NodeId;
import org.exist.stax.*;
import org.exist.storage.ElementValue;
import org.exist.storage.IndexSpec;
import org.exist.storage.UpdateListener;
import org.exist.xmldb.XmldbURI;
import org.exist.xquery.value.*;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import javax.annotation.Nullable;
import javax.xml.stream.StreamFilter;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamReader;
import java.io.IOException;
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.Iterator;

/**
 * Processes all location path steps (like descendant::*, ancestor::XXX).
 *
 * The results of the first evaluation of the expression are cached for the
 * lifetime of the object and only reloaded if the context sequence (as passed
 * to the {@link #eval(Sequence, Item)} method) has changed.
 *
 * @author wolf
 */
public class LocationStep extends Step {

    private static final int INDEX_SCAN_THRESHOLD = 10000;

    private NodeSet currentSet = null;
    private DocumentSet currentDocs = null;
    protected UpdateListener listener = null;
    protected Expression parent = null;

    /**
     * Whether this step is the initial (first) step of its parent expression,
     * as determined during {@link #analyze(AnalyzeContextInfo)}. This is cached
     * because the parent's child list may be rewritten after analysis (for
     * example, {@link Function#checkArgument} wraps a function argument in a
     * {@link DynamicCardinalityCheck} or type-check expression), which would
     * otherwise make a lazy {@code parent.getSubExpression(0) == this} test in
     * {@link #getDependencies()} report the wrong answer at evaluation time.
     */
    private boolean initialStep = false;

    //private int parentDeps = Dependency.UNKNOWN_DEPENDENCY;
    private boolean preloadedData = false;
    protected boolean optimized = false;
//    private boolean inUpdate = false;
    private boolean useDirectChildSelect = false;
    private boolean applyPredicate = true;

    // Cache for the current NodeTest type
    private Integer nodeTestType = null;

    /**
     * Creates a new instance.
     *
     * @param context the XQuery context
     * @param axis    the axis of the location step
     */
    public LocationStep(final XQueryContext context, final int axis) {
        super(context, axis);
    }

    /**
     * Creates a new instance.
     *
     * @param context the XQuery context
     * @param axis the axis of the location step
     * @param test a node test on the axis
     */
    public LocationStep(final XQueryContext context, final  int axis, final NodeTest test) {
        super(context, axis, test);
    }

    @Override
    public int getDependencies() {
        int deps = Dependency.CONTEXT_SET;

        // self axis has an obvious dependency on the context item
        // likewise we depend on the context item if this is the initial step of
        // the enclosing expression (outside a predicate). initialStep is captured
        // during analyze, before the parent's child list may be rewritten (e.g. a
        // function argument being wrapped in a cardinality/type check). See #6521.
        if (!this.inPredicate &&
                (this.axis == Constants.SELF_AXIS || this.initialStep)) {
            deps = deps | Dependency.CONTEXT_ITEM;
        }

        // TODO : normally, we should call this one...
        // int deps = super.getDependencies(); ???
        if (predicates != null) {
            for (final Predicate pred : predicates) {
                deps |= pred.getDependencies();
            }
        }

        // TODO : should we remove the CONTEXT_ITEM dependency returned by the
        // predicates ? See the comment above.
        // consider nested predicates however...

        return deps;
    }

    /**
     * If the current path expression depends on local variables from a for
     * expression, we can optimize by preloading entire element or attribute
     * sets.
     *
     * @return Whether or not we can optimize
     */
    private boolean hasPreloadedData() {
        // TODO : log elsewhere ?
        if (preloadedData) {
            context.getProfiler().message(this, Profiler.OPTIMIZATIONS, null,
                    "Preloaded NodeSets");
            return true;
        }
//                if (inUpdate)
//                        return false;
//                if ((parentDeps & Dependency.LOCAL_VARS) == Dependency.LOCAL_VARS) {
//                        context.getProfiler().message(this, Profiler.OPTIMIZATIONS, null,
//                                        "Preloaded NodeSets");
//                        return true;
//                }
        return false;
    }

    /**
     * The method <code>setPreloadedData</code>
     *
     * @param docs  a <code>DocumentSet</code> value
     * @param nodes a <code>NodeSet</code> value
     */
    public void setPreloadedData(final DocumentSet docs, final NodeSet nodes) {
        this.preloadedData = true;
        this.currentDocs = docs;
        this.currentSet = nodes;
        this.optimized = true;
    }

    /**
     * The method <code>applyPredicate</code>
     *
     * @param outerSequence   a <code>Sequence</code> value
     * @param contextSequence a <code>Sequence</code> value
     * @return a <code>Sequence</code> value
     * @throws XPathException if an error occurs
     */
    private Sequence applyPredicate(Sequence outerSequence, final Sequence contextSequence) throws XPathException {
        if (contextSequence == null) {
            return Sequence.EMPTY_SEQUENCE;
        }
        if (predicates == null
                || !applyPredicate
                || (!(contextSequence instanceof VirtualNodeSet) && contextSequence
                .isEmpty()))
        // Nothing to apply
        {
            return contextSequence;
        }
        Sequence result;
        final Predicate pred = predicates[0];
        // If the current step is an // abbreviated step, we have to treat the
        // predicate
        // specially to get the context position right. //a[1] translates to
        // /descendant-or-self::node()/a[1],
        // so we need to return the 1st a from any parent of a.
        //
        // If the predicate is known to return a node set, no special treatment
        // is required.
        if (abbreviatedStep
                && (pred.getExecutionMode() == Predicate.ExecutionMode.POSITIONAL || !contextSequence
                .isPersistentSet())) {
            result = new ValueSequence();
            ((ValueSequence) result).keepUnOrdered(unordered);
            if (contextSequence.isPersistentSet()) {
                final NodeSet contextSet = contextSequence.toNodeSet();
                outerSequence = contextSet.getParents(-1);
                for (final SequenceIterator i = outerSequence.iterate(); i.hasNext(); ) {
                    final NodeValue node = (NodeValue) i.nextItem();
                    final Sequence newContextSeq = contextSet.selectParentChild(
                            (NodeSet) node, NodeSet.DESCENDANT,
                            getExpressionId());
                    final Sequence temp = processPredicate(outerSequence,
                            newContextSeq);
                    result.addAll(temp);
                }
            } else {
                final MemoryNodeSet nodes = contextSequence.toMemNodeSet();
                outerSequence = nodes.getParents(new AnyNodeTest());
                for (final SequenceIterator i = outerSequence.iterate(); i.hasNext(); ) {
                    final NodeValue node = (NodeValue) i.nextItem();
                    final InMemoryNodeSet newSet = new InMemoryNodeSet();
                    ((NodeImpl) node).selectChildren(test, newSet);
                    final Sequence temp = processPredicate(outerSequence, newSet);
                    result.addAll(temp);
                }
            }
        } else {
            result = processPredicate(outerSequence, contextSequence);
        }
        return result;
    }

    private Sequence processPredicate(Sequence outerSequence, final Sequence contextSequence) throws XPathException {
        Sequence result = contextSequence;
        if (predicates != null) {
            for (int i = 0; i < predicates.length && (result instanceof VirtualNodeSet || !result.isEmpty()); i++) {
                // TODO : log and/or profile ?
                final Predicate pred = predicates[i];
                pred.setContextDocSet(getContextDocSet());
                result = pred.evalPredicate(outerSequence, result, axis);
                // subsequent predicates operate on the result of the previous one
                outerSequence = null;
                context.setContextSequencePosition(0, null);
            }
        }
        return result;
    }

    @Override
    public void analyze(final AnalyzeContextInfo contextInfo) throws XPathException {
        this.parent = contextInfo.getParent();

        unordered = (contextInfo.getFlags() & UNORDERED) > 0;

//        parentDeps = parent.getDependencies();
//        if ((contextInfo.getFlags() & IN_UPDATE) > 0) {
//            inUpdate = true;
//        }
//                if ((contextInfo.getFlags() & SINGLE_STEP_EXECUTION) > 0) {
//                        preloadedData = true;
//                }
        if ((contextInfo.getFlags() & USE_TREE_TRAVERSAL) > 0) {
            useDirectChildSelect = true;
        }
        // Mark ".", which is expanded as self::node() by the parser
        // even though it may *also* be relevant with atomic sequences
        if (this.axis == Constants.SELF_AXIS
                && this.test.getType() == Type.NODE) {
            contextInfo.addFlag(DOT_TEST);
        }

        //Change axis from descendant-or-self to descendant for '//'
        if (this.axis == Constants.DESCENDANT_SELF_AXIS && isAbbreviated()) {
            this.axis = Constants.DESCENDANT_AXIS;
        }

        final Expression contextStep;
        final NodeTest stepTest;
        final NodeTest contextStepTest;

        // static analysis for empty-sequence
        switch (axis) {
            case Constants.SELF_AXIS:
                if (getTest().getType() == Type.NODE) {
                    break;
                }

                // WM: the following checks will only work on simple filters like //a[self::b], so we
                // have to make sure they are not applied to more complex expression types
                if (parent.getSubExpressionCount() > 1) {
                    break;
                }

                contextStep = contextInfo.getContextStep();
                if (!(contextStep instanceof LocationStep cStep)) {
                    break;
                }

                stepTest = getTest();
                contextStepTest = cStep.getTest();

                if (!Type.subTypeOf(stepTest.getType(), contextStepTest.getType())) {
                    // return empty sequence
                    contextInfo.setStaticType(Type.EMPTY_SEQUENCE);
                    staticReturnType = Type.EMPTY_SEQUENCE;
                    break;
                }

                if (!stepTest.isWildcardTest() &&
                        !contextStepTest.isWildcardTest() &&
                        !contextStepTest.equals(stepTest)) {
                    // return empty sequence
                    contextInfo.setStaticType(Type.EMPTY_SEQUENCE);
                    staticReturnType = Type.EMPTY_SEQUENCE;
                }
                break;
//                      case Constants.DESCENDANT_AXIS:
            case Constants.DESCENDANT_SELF_AXIS:
                contextStep = contextInfo.getContextStep();
                if (!(contextStep instanceof LocationStep cStep)) {
                    break;
                }

                stepTest = getTest();
                contextStepTest = cStep.getTest();

                if ((contextStepTest.getType() == Type.ATTRIBUTE || contextStepTest.getType() == Type.TEXT) &&
                        contextStepTest != stepTest) {
                    // return empty sequence
                    contextInfo.setStaticType(Type.EMPTY_SEQUENCE);
                    staticReturnType = Type.EMPTY_SEQUENCE;
                }
                break;
//                case Constants.PARENT_AXIS:
//                case Constants.ATTRIBUTE_AXIS:
            default:
        }

        // TODO : log somewhere ?
        super.analyze(contextInfo);

        // Capture whether this step is the initial step of its parent expression
        // now, while the parent's child list still reflects the source structure.
        // It may be rewritten afterwards (e.g. Function.checkArgument wrapping the
        // argument), so deferring this test to getDependencies() is unreliable.
        this.initialStep = parent != null && parent.getSubExpressionCount() > 0
                && parent.getSubExpression(0) == this;
    }

    @Override
    public Sequence eval(Sequence contextSequence, final Item contextItem)
            throws XPathException {
        if (context.getProfiler().isEnabled()) {
            context.getProfiler().start(this);
            context.getProfiler().message(this, Profiler.DEPENDENCIES,
                    "DEPENDENCIES",
                    Dependency.getDependenciesName(this.getDependencies()));
            if (contextSequence != null) {
                context.getProfiler().message(this, Profiler.START_SEQUENCES,
                        "CONTEXT SEQUENCE", contextSequence);
            }
            if (contextItem != null) {
                context.getProfiler().message(this, Profiler.START_SEQUENCES,
                        "CONTEXT ITEM", contextItem.toSequence());
            }
        }

        if (contextItem != null) {
            contextSequence = contextItem.toSequence();
        }

        Sequence result;
        if (needsComputation()) {
            if (contextSequence == null) {
                throw new XPathException(this,
                        ErrorCodes.XPDY0002, "Undefined context sequence for '"
                        + this + "'");
            }

            try {
                switch (axis) {

                    case Constants.DESCENDANT_AXIS:
                    case Constants.DESCENDANT_SELF_AXIS:
                        result = getDescendants(context, contextSequence);
                        break;

                    case Constants.CHILD_AXIS:
                        // VirtualNodeSets may have modified the axis ; checking the
                        // type
                        // TODO : further checks ?
//                                if (this.test.getType() == Type.ATTRIBUTE) {
//                                        this.axis = Constants.ATTRIBUTE_AXIS;
//                                        result = getAttributes(context, contextSequence);
//                                } else {
                        result = getChildren(context, contextSequence);
//                                }
                        break;

                    case Constants.ANCESTOR_SELF_AXIS:
                    case Constants.ANCESTOR_AXIS:
                        result = getAncestors(context, contextSequence);
                        break;

                    case Constants.PARENT_AXIS:
                        result = getParents(context, contextSequence);
                        break;

                    case Constants.SELF_AXIS:
                        if (!(contextSequence instanceof VirtualNodeSet)
                                && Type.subTypeOf(contextSequence.getItemType(),
                                Type.ANY_ATOMIC_TYPE)) {
                            // This test is copied from the legacy method
                            // getSelfAtomic()
                            if (!test.isWildcardTest()) {
                                throw new XPathException(this, test.toString()
                                        + " cannot be applied to an atomic value.");
                            }
                            result = contextSequence;
                        } else {
                            result = getSelf(context, contextSequence);
                        }
                        break;

                    case Constants.ATTRIBUTE_AXIS:
                    case Constants.DESCENDANT_ATTRIBUTE_AXIS:
                        result = getAttributes(context, contextSequence);
                        break;

                    case Constants.PRECEDING_AXIS:
                    case Constants.FOLLOWING_AXIS:
                        result = getPrecedingOrFollowing(context, contextSequence);
                        break;

                    case Constants.PRECEDING_SIBLING_AXIS:
                    case Constants.FOLLOWING_SIBLING_AXIS:
                        result = getSiblings(context, contextSequence);
                        break;

                    default:
                        throw new IllegalArgumentException("Unsupported axis specified");
                }
            } catch (final XPathException e) {
                if (e.getLine() <= 0) {
                    e.setLocation(getLine(), getColumn(), getSource());
                }
                throw e;
            }
        } else {
            result = NodeSet.EMPTY_SET;
        }
        if (axis != Constants.SELF_AXIS && contextSequence != null
                && contextSequence.isCacheable()) {
            registerUpdateListener();
        }
        // Remove duplicate nodes
        result.removeDuplicates();
        // Apply the predicate
        result = applyPredicate(contextSequence, result);

        if (context.getProfiler().isEnabled()) {
            context.getProfiler().end(this, "", result);
        }
        // actualReturnType = result.getItemType();

        return result;
    }

    // Avoid unnecessary tests (these should be detected by the parser)
    private boolean needsComputation() {
        // TODO : log this ?
        switch (axis) {
            // Certainly not exhaustive
            case Constants.ANCESTOR_SELF_AXIS:
            case Constants.PARENT_AXIS:
                // case Constants.SELF_AXIS:
                if (nodeTestType == null) {
                    nodeTestType = test.getType();
                }
                if (nodeTestType != Type.DOCUMENT
                        && nodeTestType != Type.NODE
                        && nodeTestType != Type.ELEMENT
                        && nodeTestType != Type.PROCESSING_INSTRUCTION) {
                    if (context.getProfiler().isEnabled()) {
                        context.getProfiler().message(this, Profiler.OPTIMIZATIONS,
                                "OPTIMIZATION", "avoid useless computations");
                    }
                    return false;
                }

        }
        return true;
    }

    private Sequence getSelf(final XQueryContext context, final Sequence contextSequence) throws XPathException {
        if (!contextSequence.isPersistentSet()) {
            final MemoryNodeSet nodes = contextSequence.toMemNodeSet();
            return nodes.getSelf(test);
        }

        if (hasPreloadedData()) {
            @Nullable final NodeSet ns;
            if (contextSequence instanceof NodeSet set) {
                ns = set;
            } else {
                ns = null;
            }

            final NewArrayNodeSet newCurrentSet = new NewArrayNodeSet(currentSet.getItemCount());
            for (NodeProxy p : currentSet) {
                if (test.isWildcardTest()) {
                    if (ns != null) {
                        @Nullable final NodeProxy np = ns.get(p);
                        if (np != null) {
                            p = np;
                        }
                    }
                } else {
                    if (ns != null) {
                        @Nullable final NodeProxy np = ns.get(p);
                        if (np != null && np.getMatches() != null) {
                            p.addMatch(np.getMatches());
                        }
                    }
                }
                p.addContextNode(contextId, p);
                newCurrentSet.add(p);
            }
            currentSet = newCurrentSet;
            return newCurrentSet;
        }

        final NodeSet contextSet = contextSequence.toNodeSet();

        // A processing instruction is addressable by name, but the structural index has only an
        // element half and an attribute half -- there is nowhere to look one up. Without this
        // branch a named test fell through to the index and searched for an *element* of that
        // name, so self::processing-instruction(NAME) never matched. Matching directly against
        // the context set needs no index; the VirtualNodeSet the other axes use is not usable on
        // the self axis, which is why the branch that had been commented out here stayed unused.
        if (test.getType() == Type.PROCESSING_INSTRUCTION) {
            return selfProcessingInstructions(contextSet);
        }

        if (test.isWildcardTest()) {
            if (nodeTestType == null) {
                nodeTestType = test.getType();
            }

            if (Type.subTypeOf(nodeTestType, Type.NODE)) {
                if (Expression.NO_CONTEXT_ID != contextId) {
                    if (contextSet instanceof VirtualNodeSet set && test.getType() == Type.NODE) {
                        // self::node() selects every node of the set, which can stay virtual
                        set.setInPredicate(true);
                        set.setContextId(contextId);
                        set.setSelfIsContext();
                        return contextSet;
                    }
                    // only the nodes that pass the test: returning the whole context set made
                    // e.g. node()[self::comment()] select every node, and node()[not(self::*)] none
                    final NewArrayNodeSet results = new NewArrayNodeSet();
                    for (final NodeProxy p : contextSet) {
                        if (test.matches(p)) {
                            p.addContextNode(contextId, p);
                            results.add(p);
                        }
                    }
                    return results;
                } else {
                    final NewArrayNodeSet results = new NewArrayNodeSet();
                    for (final NodeProxy p : contextSet) {
                        if(test.matches(p)) {
                            results.add(p);
                        }
                    }
                    return results;
                }
            } else {
                final VirtualNodeSet vset = new VirtualNodeSet(context.getBroker(), axis, test, contextId, contextSet);
                vset.setInPredicate(Expression.NO_CONTEXT_ID != contextId);
                return vset;
            }
        } else {
            final DocumentSet docs = getDocumentSet(contextSet);
            final StructuralIndex index = context.getBroker().getStructuralIndex();
            if (context.getProfiler().isEnabled()) {
                context.getProfiler().message(this, Profiler.OPTIMIZATIONS,
                        "OPTIMIZATION",
                        "Using structural index '" + index.toString() + "'");
            }
            final NodeSelector selector = new SelfSelector(contextSet, contextId);
            return index.findElementsByTagName(indexTypeFor(test), docs, test.getName(), selector, this);
        }
    }

    /**
     * Selects the half of the structural index that a node test should be looked up in.
     *
     * <p>The index is split into an element half and an attribute half. A named attribute kind
     * test such as {@code self::attribute(id)} must be looked up in the latter; searching the
     * element half for an element of that name always comes back empty.</p>
     *
     * <p>Processing instructions are handled before this point, so only element and attribute
     * tests reach here.</p>
     *
     * @param test the node test being applied
     * @return {@link ElementValue#ATTRIBUTE} for an attribute test, {@link ElementValue#ELEMENT} otherwise
     */
    private static byte indexTypeFor(final NodeTest test) {
        return test.getType() == Type.ATTRIBUTE ? ElementValue.ATTRIBUTE : ElementValue.ELEMENT;
    }

    /**
     * Selects the processing instructions in {@code contextSet} that satisfy this step's test.
     *
     * <p>A processing instruction is addressable by name, but the structural index has only an
     * element half and an attribute half, so there is nowhere to look one up. Matching directly
     * against the context set needs no index. (The {@code VirtualNodeSet} the other axes use for
     * processing instructions is not usable on the self axis — it leaves the result without the
     * context it needs — which is why the branch that once stood here was commented out.)</p>
     *
     * @param contextSet the nodes on the self axis
     * @return those matching this step's test, carrying the current context where one applies
     */
    private Sequence selfProcessingInstructions(final NodeSet contextSet) {
        final NewArrayNodeSet results = new NewArrayNodeSet();
        for (final NodeProxy p : contextSet) {
            if (test.matches(p)) {
                if (Expression.NO_CONTEXT_ID != contextId) {
                    p.addContextNode(contextId, p);
                }
                results.add(p);
            }
        }
        return results;
    }

    protected Sequence getAttributes(final XQueryContext context, final Sequence contextSequence)
            throws XPathException {
        if (!contextSequence.isPersistentSet()) {
            final MemoryNodeSet nodes = contextSequence.toMemNodeSet();
            if (axis == Constants.DESCENDANT_ATTRIBUTE_AXIS) {
                return nodes.getDescendantAttributes(test);
            } else {
                return nodes.getAttributes(test);
            }
        }
        final NodeSet contextSet = contextSequence.toNodeSet();
        if (!hasPreloadedData() && test.isWildcardTest()) {
            final NodeSet result = new VirtualNodeSet(context.getBroker(), axis, test, contextId, contextSet);
            ((VirtualNodeSet) result).setInPredicate(Expression.NO_CONTEXT_ID != contextId);
            return result;
            // if there's just a single known node in the context, it is faster
            // do directly search for the attribute in the parent node.
        }
        if (hasPreloadedData()) {
            final DocumentSet docs = getDocumentSet(contextSet);
            synchronized (context) {
                if (currentSet == null
                        || currentDocs == null
                        || (!optimized && !(docs == currentDocs || docs
                        .equalDocs(currentDocs)))) {
                    final StructuralIndex index = context.getBroker().getStructuralIndex();
                    if (context.getProfiler().isEnabled()) {
                        context.getProfiler().message(
                                this,
                                Profiler.OPTIMIZATIONS,
                                "OPTIMIZATION",
                                "Using structural index '" + index.toString()
                                        + "'");
                    }
                    // TODO : why a null selector here ? We have one below !
                    currentSet = index.findElementsByTagName(ElementValue.ATTRIBUTE, docs, test.getName(), null, this);
                    currentDocs = docs;
                    registerUpdateListener();
                }
                return switch (axis) {
                    case Constants.ATTRIBUTE_AXIS ->
                            currentSet.selectParentChild(contextSet, NodeSet.DESCENDANT, contextId);
                    case Constants.DESCENDANT_ATTRIBUTE_AXIS ->
                            currentSet.selectAncestorDescendant(contextSet, NodeSet.DESCENDANT, false, contextId,
                                    true);
                    default -> throw new IllegalArgumentException("Unsupported axis specified");
                };
            }
        } else if (canSelectAttributesDirectly(context, contextSet)) {
            return contextSet.directSelectAttribute(context.getBroker(), test, contextId);
        } else {
            final DocumentSet docs = getDocumentSet(contextSet);
            final StructuralIndex index = context.getBroker().getStructuralIndex();
            if (context.getProfiler().isEnabled()) {
                context.getProfiler().message(this, Profiler.OPTIMIZATIONS,
                        "OPTIMIZATION",
                        "Using structural index '" + index.toString() + "'");
            }
            if (!contextSet.getProcessInReverseOrder()) {
                return index.findDescendantsByTagName(ElementValue.ATTRIBUTE, test.getName(), axis, docs, contextSet,
                        contextId, this);
            } else {
                final NodeSelector selector = switch (axis) {
                    case Constants.ATTRIBUTE_AXIS -> new ChildSelector(contextSet, contextId);
                    case Constants.DESCENDANT_ATTRIBUTE_AXIS -> new DescendantSelector(contextSet, contextId);
                    default -> throw new IllegalArgumentException("Unsupported axis specified");
                };
                return index.findElementsByTagName(ElementValue.ATTRIBUTE, docs, test.getName(), selector, this);
            }
        }
    }

    /**
     * Whether to read each context element's own attributes instead of asking the structural index, for a
     * named attribute step without preloaded data. The structural index runs one range query per context
     * node over its whole subtree, so a lookup on a node high in the tree, such as a parent or ancestor
     * step's result, costs time in proportion to the document's size. For a large context set the index
     * is cheaper per node, so the direct read is limited to sets smaller than {@link #INDEX_SCAN_THRESHOLD}.
     */
    private boolean canSelectAttributesDirectly(final XQueryContext context, final NodeSet contextSet) {
        return axis == Constants.ATTRIBUTE_AXIS
                && !(contextSet instanceof VirtualNodeSet)
                && contextSet.getLength() < INDEX_SCAN_THRESHOLD
                && !hasLegacyRangeIndex(context, contextSet);
    }

    /**
     * Whether a collection of the context nodes configures a legacy range index (by path or by QName).
     * The structural index records such an index's type with each attribute it returns, and comparisons
     * use that type, so these attributes can't be read directly from their elements.
     */
    private static boolean hasLegacyRangeIndex(final XQueryContext context, final NodeSet contextSet) {
        for (final Iterator<Collection> i = contextSet.getCollectionIterator(); i.hasNext(); ) {
            final Collection collection = i.next();
            if (collection.getURI().equalsInternal(XmldbURI.SYSTEM_COLLECTION_URI)) {
                continue;
            }
            final IndexSpec indexSpec = collection.getIndexConfiguration(context.getBroker());
            if (indexSpec != null && (indexSpec.hasIndexesByPath() || indexSpec.hasIndexesByQName())) {
                return true;
            }
        }
        return false;
    }

    private Sequence getChildren(final XQueryContext context, final Sequence contextSequence) throws XPathException {
        if (!contextSequence.isPersistentSet()) {
            final MemoryNodeSet nodes = contextSequence.toMemNodeSet();
            return nodes.getChildren(test);
        }

        final NodeSet contextSet = contextSequence.toNodeSet();
        // TODO : understand this. I guess comments should be treated in a
        // similar way ? -pb
        if ((!hasPreloadedData() && test.isWildcardTest()) || test.getType() == Type.PROCESSING_INSTRUCTION) {
            // test is one out of *, text(), node() including
            // processing-instruction(targetname)
            final VirtualNodeSet vset = new VirtualNodeSet(context.getBroker(), axis, test, contextId, contextSet);
            vset.setInPredicate(Expression.NO_CONTEXT_ID != contextId);
            return vset;
        }

        // IndexStatistics stats = (IndexStatistics)
        // context.getBroker().getBrokerPool().
        // getIndexManager().getIndexById(IndexStatistics.ID);
        // int parentDepth = stats.getMaxParentDepth(test.getName());
        // LOG.debug("parentDepth for " + test.getName() + ": " + parentDepth);

        if (useDirectChildSelect) {
            final NewArrayNodeSet result = new NewArrayNodeSet();
            for (final NodeProxy p : contextSet) {
                result.addAll(p.directSelectChild(test.getName(), contextId));
            }
            return result;
        } else if (hasPreloadedData()) {
            final DocumentSet docs = getDocumentSet(contextSet);
            synchronized (context) {
                // TODO : understand why this one is different from the other
                // ones
                if (currentSet == null
                        || currentDocs == null
                        || (!optimized && !(docs == currentDocs || docs
                        .equalDocs(currentDocs)))) {
                    final StructuralIndex index = context.getBroker().getStructuralIndex();
                    if (context.getProfiler().isEnabled()) {
                        context.getProfiler().message(
                                this,
                                Profiler.OPTIMIZATIONS,
                                "OPTIMIZATION",
                                "Using structural index '" + index.toString()
                                        + "'");
                    }
                    currentSet = index.findElementsByTagName(ElementValue.ELEMENT, docs, test.getName(), null, this);
                    currentDocs = docs;
                    registerUpdateListener();
                }
                return currentSet.selectParentChild(contextSet, NodeSet.DESCENDANT, contextId);
            }
        } else {
            final DocumentSet docs = getDocumentSet(contextSet);
            final StructuralIndex index = context.getBroker().getStructuralIndex();
            if (context.getProfiler().isEnabled()) {
                context.getProfiler().message(this, Profiler.OPTIMIZATIONS,
                        "OPTIMIZATION",
                        "Using structural index '" + index.toString() + "'");
            }
            if (!contextSet.getProcessInReverseOrder() && !(contextSet instanceof VirtualNodeSet) &&
                    contextSet.getLength() < INDEX_SCAN_THRESHOLD) {
                return index.findDescendantsByTagName(ElementValue.ELEMENT,
                        test.getName(), axis, docs, contextSet,
                        contextId, parent);
            } else {
                // if (contextSet instanceof VirtualNodeSet)
                // ((VirtualNodeSet)contextSet).realize();
                final NodeSelector selector = new ChildSelector(contextSet, contextId);
                return index.findElementsByTagName(ElementValue.ELEMENT, docs, test.getName(), selector, this);
            }
        }
    }

    private Sequence getDescendants(final XQueryContext context, final Sequence contextSequence) throws XPathException {
        if (!contextSequence.isPersistentSet()) {
            final MemoryNodeSet nodes = contextSequence.toMemNodeSet();
            return nodes.getDescendants(axis == Constants.DESCENDANT_SELF_AXIS,
                    test);
        }

        final NodeSet contextSet = contextSequence.toNodeSet();
        // TODO : understand this. I guess comments should be treated in a
        // similar way ? -pb
        if ((!hasPreloadedData() && test.isWildcardTest())
                || test.getType() == Type.PROCESSING_INSTRUCTION) {
            // test is one out of *, text(), node() including
            // processing-instruction(targetname)
            final VirtualNodeSet vset = new VirtualNodeSet(context.getBroker(), axis, test, contextId, contextSet);
            vset.setInPredicate(Expression.NO_CONTEXT_ID != contextId);
            return vset;
        } else if (hasPreloadedData()) {
            final DocumentSet docs = getDocumentSet(contextSet);
            synchronized (context) {
                // TODO : understand why this one is different from the other
                // ones
                if (currentSet == null
                        || currentDocs == null
                        || (!optimized && !(docs == currentDocs || docs
                        .equalDocs(currentDocs)))) {
                    final StructuralIndex index = context.getBroker().getStructuralIndex();
                    if (context.getProfiler().isEnabled()) {
                        context.getProfiler().message(
                                this,
                                Profiler.OPTIMIZATIONS,
                                "OPTIMIZATION",
                                "Using structural index '" + index.toString()
                                        + "'");
                    }
                    currentSet = index.findElementsByTagName(ElementValue.ELEMENT, docs, test.getName(), null, this);
                    currentDocs = docs;
                    registerUpdateListener();
                }

                return switch (axis) {
                    case Constants.DESCENDANT_SELF_AXIS ->
                            currentSet.selectAncestorDescendant(contextSet, NodeSet.DESCENDANT, true, contextId,
                                    true);
                    case Constants.DESCENDANT_AXIS ->
                            currentSet.selectAncestorDescendant(contextSet, NodeSet.DESCENDANT, false, contextId,
                                    true);
                    default -> throw new IllegalArgumentException("Unsupported axis specified");
                };
            }
        } else {
            final DocumentSet docs = contextSet.getDocumentSet();
            final StructuralIndex index = context.getBroker().getStructuralIndex();
            if (context.getProfiler().isEnabled()) {
                context.getProfiler().message(this, Profiler.OPTIMIZATIONS,
                        "OPTIMIZATION",
                        "Using structural index '" + index.toString() + "'");
            }
            if (!contextSet.getProcessInReverseOrder()
                    && (contextSet instanceof VirtualNodeSet || contextSet.getLength() < INDEX_SCAN_THRESHOLD)) {
                return index.findDescendantsByTagName(ElementValue.ELEMENT, test.getName(), axis, docs, contextSet,
                        contextId, this);
            } else {
                final NodeSelector selector = switch (axis) {
                    case Constants.DESCENDANT_SELF_AXIS -> new DescendantOrSelfSelector(contextSet, contextId);
                    case Constants.DESCENDANT_AXIS -> new DescendantSelector(contextSet, contextId);
                    default -> throw new IllegalArgumentException("Unsupported axis specified");
                };
                return index.findElementsByTagName(ElementValue.ELEMENT, docs, test.getName(), selector, this);
            }

        }
    }

    /**
     * Get's the sibling nodes of the context set
     *
     * @param context         a <code>XQueryContext</code> value
     * @param contextSequence a <code>NodeSet</code> value
     * @return a <code>NodeSet</code> value
     * @throws XPathException in case of dynamic error
     */
    protected Sequence getSiblings(final XQueryContext context, final Sequence contextSequence) throws XPathException {
        if (!contextSequence.isPersistentSet()) {
            final MemoryNodeSet nodes = contextSequence.toMemNodeSet();
            if (axis == Constants.PRECEDING_SIBLING_AXIS) {
                return nodes.getPrecedingSiblings(test);
            } else {
                return nodes.getFollowingSiblings(test);
            }
        }

        final NodeSet contextSet = contextSequence.toNodeSet();

        // A processing instruction is not in the structural index, so it is matched while streaming
        // the siblings, like a wildcard test. The VirtualNodeSet it was handed to instead found no
        // sibling processing instructions at all.
        if (test.isWildcardTest() || test.getType() == Type.PROCESSING_INSTRUCTION) {
            final AVLTreeNodeSet result = new AVLTreeNodeSet();
            try {
                final int limit = computeLimit();
                for (final NodeProxy current : contextSet) {
                    // document-node() does not have any preceding or following elements
                    if (NodeId.DOCUMENT_NODE.equals(current.getNodeId())) {
                        continue;
                    }

                    final IEmbeddedXMLStreamReader reader;
                    final StreamFilter filter;
                    if (axis == Constants.PRECEDING_SIBLING_AXIS) {
                        final NodeId startNodeId;
                        if (NodeId.DOCUMENT_NODE.equals(current.getNodeId().getParentId())) {
                            // parent would be document-node(), start from document-node()/node()[1]
                            startNodeId = NodeId.ROOT_NODE;
                        } else {
                            startNodeId = current.getNodeId().getParentId().getChild(1);
                        }
                        final NodeProxy startNode = new NodeProxy(this, current.getOwnerDocument(), startNodeId);

                        reader = context.getBroker().getXMLStreamReader(startNode, false);
                        filter = new PrecedingSiblingFilter(test, startNode, current, result, contextId);
                    } else {
                        reader = context.getBroker().getXMLStreamReader(current, false);
                        filter = new FollowingSiblingFilter(test, current, result, contextId, limit);
                    }

                    reader.filter(filter);
                }
            } catch (final IOException | XMLStreamException e) {
                throw new XPathException(this, e);
            }

            return result;
        } else {
            // TODO : no test on preloaded data ?
            final DocumentSet docs = getDocumentSet(contextSet);
            synchronized (context) {
                if (currentSet == null || currentDocs == null || !(docs.equalDocs(currentDocs))) {
                    final StructuralIndex index = context.getBroker().getStructuralIndex();
                    if (context.getProfiler().isEnabled()) {
                        context.getProfiler().message(
                                this,
                                Profiler.OPTIMIZATIONS,
                                "OPTIMIZATION",
                                "Using structural index '" + index.toString()
                                        + "'");
                    }
                    currentSet = index.findElementsByTagName(ElementValue.ELEMENT, docs, test.getName(), null, this);
                    currentDocs = docs;
                    registerUpdateListener();
                }
                return switch (axis) {
                    case Constants.PRECEDING_SIBLING_AXIS -> currentSet.selectPrecedingSiblings(contextSet, contextId);
                    case Constants.FOLLOWING_SIBLING_AXIS -> currentSet.selectFollowingSiblings(contextSet, contextId);
                    default -> throw new IllegalArgumentException("Unsupported axis specified");
                };
            }
        }
    }

    /**
     * Get the preceding or following axis nodes
     *
     * @param context the xquery context
     * @param contextSequence the context sequence
     *
     * @return the nodes from the preceding or following axis
     *
     * @throws XPathException if an error occurs
     */
    private Sequence getPrecedingOrFollowing(final XQueryContext context, final Sequence contextSequence)
            throws XPathException {
        final int position = computeLimit();

        // process an in-memory node set
        if (!contextSequence.isPersistentSet()) {
            final MemoryNodeSet nodes = contextSequence.toMemNodeSet();
            if (position > -1) {
                applyPredicate = false;
            }

            if (axis == Constants.PRECEDING_AXIS) {
                return nodes.getPreceding(test, position);
            } else {
                return nodes.getFollowing(test, position);
            }
        }

        final NodeSet contextSet = contextSequence.toNodeSet();
        // TODO : understand this. I guess comments should be treated in a
        // similar way ? -pb
        if (test.getType() == Type.PROCESSING_INSTRUCTION) {
            final VirtualNodeSet vset = new VirtualNodeSet(context.getBroker(), axis, test, contextId, contextSet);
            vset.setInPredicate(Expression.NO_CONTEXT_ID != contextId);
            return vset;
        }

        // handle node(), * etc.
        if (test.isWildcardTest()) {
            try {
                final NodeSet result = new NewArrayNodeSet();
                for (final NodeProxy next : contextSet) {
                    final NodeList cl = next.getOwnerDocument().getChildNodes();
                    for (int j = 0; j < cl.getLength(); j++) {
                        final NodeHandle node = (NodeHandle) cl.item(j);
                        final NodeProxy root = new NodeProxy(this, node);
                        final StreamFilter filter;
                        if (axis == Constants.PRECEDING_AXIS) {
                            filter = new PrecedingFilter(test, root, next, result, contextId, position);
                        } else {
                            filter = new FollowingFilter(test, root, next, result, contextId, position);
                        }
                        // See readerStartForWildcardAxis: for FOLLOWING_AXIS we now start the
                        // reader at the reference node, eliminating the position-dependent
                        // doc-start walk reported in #2129.
                        final IEmbeddedXMLStreamReader reader = context.getBroker()
                                .getXMLStreamReader(readerStartForWildcardAxis(node, root, next), false);
                        reader.filter(filter);
                    }
                }
                return result;
            } catch (final XMLStreamException | IOException e) {
                throw new XPathException(this, e);
            }
        } else {
            // TODO : no test on preloaded data ?
            final DocumentSet docs = getDocumentSet(contextSet);
            synchronized (context) {
                if (currentSet == null || currentDocs == null || !(docs.equalDocs(currentDocs))) {
                    final StructuralIndex index = context.getBroker().getStructuralIndex();
                    if (context.getProfiler().isEnabled()) {
                        context.getProfiler().message(this, Profiler.OPTIMIZATIONS, "OPTIMIZATION",
                                "Using structural index '" + index.toString() + "'");
                    }
                    currentSet = index.findElementsByTagName(ElementValue.ELEMENT, docs, test.getName(), null, this);
                    currentDocs = docs;
                    registerUpdateListener();
                }

                if (position > -1) {
                    try {
                        applyPredicate = false;
                        if (axis == Constants.PRECEDING_AXIS) {
                            return currentSet.selectPreceding(contextSet, position, contextId);
                        } else {
                            return currentSet.selectFollowing(contextSet, position, contextId);
                        }
                    } catch (final UnsupportedOperationException e) {
                        if (axis == Constants.PRECEDING_AXIS) {
                            return currentSet.selectPreceding(contextSet, contextId);
                        } else {
                            return currentSet.selectFollowing(contextSet, contextId);
                        }
                    }
                } else {
                    if (axis == Constants.PRECEDING_AXIS) {
                        return currentSet.selectPreceding(contextSet, contextId);
                    } else {
                        return currentSet.selectFollowing(contextSet, contextId);
                    }
                }
            }
        }
    }

    /**
     * Decide where the wildcard preceding-or-following StAX reader should start.
     *
     * <p>For PRECEDING_AXIS we keep the historical behaviour and walk the document-child's
     * subtree from its root; the {@link PrecedingFilter} short-circuits as soon as the reader
     * crosses the reference node.</p>
     *
     * <p>For FOLLOWING_AXIS we start the reader at the reference node itself when it lies
     * inside this document-child's subtree. The {@link FollowingFilter} already skips the
     * reference node and its descendants (via its isAfter / isDescendantOf checks) and
     * terminates on END_ELEMENT at the document-child's tree level, so starting later in
     * document order is safe and removes the O(refPosition) doc-start walk reported in
     * issue #2129. When the reference node is in some other document-child's subtree, fall
     * back to walking from this subtree's root - every event in it is by definition after
     * the reference node.</p>
     */
    private NodeHandle readerStartForWildcardAxis(final NodeHandle node, final NodeProxy root,
            final NodeProxy next) {
        if (axis != Constants.FOLLOWING_AXIS) {
            return node;
        }
        final NodeId rootId = root.getNodeId();
        final NodeId refId = next.getNodeId();
        return refId.equals(rootId) || refId.isDescendantOf(rootId) ? next : node;
    }

    /**
     * If the optimizer has determined that the first filter after this step is a simple positional
     * predicate and can be optimized, try to precompute the position and return it to limit the
     * number of items being processed by axes.
     *
     * @return max number of nodes to be processed until position is reached
     * @throws XPathException if a dynamic error occurs
     */
    private int computeLimit() throws XPathException {
        int position = -1;
        if (this.checkPositionalFilters(this.inPredicate)) {
            final Predicate pred = predicates[0];
            final Sequence seq = pred.preprocess();

            final NumericValue v = (NumericValue) seq.itemAt(0);
            // Non integers return... nothing, not even an error !
            if (!v.hasFractionalPart() && !v.isZero()) {
                position = v.getInt();
            }
        }
        return position;
    }

    /**
     * Get the ancestor axis nodes
     *
     * @param context the xquery context
     * @param contextSequence the context sequence
     *
     * @return the ancestor nodes
     *
     * @throws XPathException if an error occurs
     */
    protected Sequence getAncestors(final XQueryContext context, final Sequence contextSequence) throws XPathException {
        if (!contextSequence.isPersistentSet()) {
            final MemoryNodeSet nodes = contextSequence.toMemNodeSet();
            return nodes.getAncestors(axis == Constants.ANCESTOR_SELF_AXIS, test);
        }

        final NodeSet contextSet = contextSequence.toNodeSet();
        if (test.isWildcardTest()) {
            final NodeSet result = new NewArrayNodeSet();
            result.setProcessInReverseOrder(true);
            for (final NodeProxy current : contextSet) {
                NodeProxy ancestor;
                if (axis == Constants.ANCESTOR_SELF_AXIS && test.matches(current)) {
                    ancestor = new NodeProxy(this, current);
                    ancestor.setNodeType(Node.ELEMENT_NODE);
                    final NodeProxy t = result.get(ancestor);
                    if (t == null) {
                        if (Expression.NO_CONTEXT_ID != contextId) {
                            ancestor.addContextNode(contextId, current);
                        } else {
                            NodeProxy.propagatePredicateContextFrom(ancestor, current, contextId);
                        }
                        ancestor.addMatches(current);
                        result.add(ancestor);
                    } else {
                        t.addContextNode(contextId, current);
                        t.addMatches(current);
                    }
                }

                NodeId parentID = current.getNodeId().getParentId();
                while (parentID != null) {
                    ancestor = new NodeProxy(this, current.getOwnerDocument(), parentID, parentID == NodeId.DOCUMENT_NODE ? Node.DOCUMENT_NODE : Node.ELEMENT_NODE);
                    // Filter out the temporary nodes wrapper element
                    if (!(parentID.getTreeLevel() == 1 && current.getOwnerDocument().getCollection().isTempCollection())) {
                        if (test.matches(ancestor)) {
                            final NodeProxy t = result.get(ancestor);
                            if (t == null) {
                                if (Expression.NO_CONTEXT_ID != contextId) {
                                    ancestor.addContextNode(contextId, current);
                                } else {
                                    NodeProxy.propagatePredicateContextFrom(ancestor, current, contextId);
                                }
                                ancestor.addMatches(current);
                                result.add(ancestor);
                            } else {
                                t.addContextNode(contextId, current);
                                t.addMatches(current);
                            }
                        }
                    }
                    parentID = parentID.getParentId();
                }
            }
            return result;
        } else if (hasPreloadedData()) {
            final DocumentSet docs = getDocumentSet(contextSet);
            synchronized (context) {
                if (currentSet == null || currentDocs == null || (!optimized && !(docs == currentDocs || docs.equalDocs(currentDocs)))) {
                    final StructuralIndex index = context.getBroker().getStructuralIndex();
                    if (context.getProfiler().isEnabled()) {
                        context.getProfiler().message(
                                this,
                                Profiler.OPTIMIZATIONS,
                                "OPTIMIZATION",
                                "Using structural index '" + index.toString()
                                        + "'");
                    }
                    currentSet = index.findElementsByTagName(ElementValue.ELEMENT, docs, test.getName(), null, this);
                    currentDocs = docs;
                    registerUpdateListener();
                }
                return switch (axis) {
                    case Constants.ANCESTOR_SELF_AXIS -> currentSet.selectAncestors(contextSet, true, contextId);
                    case Constants.ANCESTOR_AXIS -> currentSet.selectAncestors(contextSet, false, contextId);
                    default -> throw new IllegalArgumentException("Unsupported axis specified");
                };
            }
        } else {
            final DocumentSet docs = getDocumentSet(contextSet);
            final StructuralIndex index = context.getBroker().getStructuralIndex();
            if (context.getProfiler().isEnabled()) {
                context.getProfiler().message(this, Profiler.OPTIMIZATIONS,
                        "OPTIMIZATION",
                        "Using structural index '" + index.toString() + "'");
            }
            return index.findAncestorsByTagName(ElementValue.ELEMENT, test.getName(), axis, docs, contextSet, contextId);
        }
    }

    /**
     * Get the parent axis nodes
     *
     * @param context the xquery context
     * @param contextSequence the context sequence
     *
     * @return the parent nodes
     *
     * @throws XPathException if an error occurs
     */
    protected Sequence getParents(final XQueryContext context, final Sequence contextSequence) throws XPathException {
        if (!contextSequence.isPersistentSet()) {
            final MemoryNodeSet nodes = contextSequence.toMemNodeSet();
            return nodes.getParents(test);
        }

        final NodeSet contextSet = contextSequence.toNodeSet();
        if (test.isWildcardTest()) {
            final NodeSet temp = contextSet.getParents(contextId);
            final NodeSet result = new NewArrayNodeSet();
            for (final NodeProxy p : temp) {
                if (test.matches(p)) {
                    result.add(p);
                }
            }
            return result;
        } else if (hasPreloadedData()) {
            final DocumentSet docs = getDocumentSet(contextSet);
            synchronized (context) {
                if (currentSet == null || currentDocs == null || (!optimized && !(docs == currentDocs || docs.equalDocs(currentDocs)))) {
                    final StructuralIndex index = context.getBroker().getStructuralIndex();
                    if (context.getProfiler().isEnabled()) {
                        context.getProfiler().message(
                                this,
                                Profiler.OPTIMIZATIONS,
                                "OPTIMIZATION",
                                "Using structural index '" + index.toString()
                                        + "'");
                    }
                    currentSet = index.findElementsByTagName(ElementValue.ELEMENT, docs, test.getName(), null, this);
                    currentDocs = docs;
                    registerUpdateListener();
                }
                return contextSet.selectParentChild(currentSet, NodeSet.ANCESTOR);
            }
        } else {
            final DocumentSet docs = getDocumentSet(contextSet);
            final StructuralIndex index = context.getBroker().getStructuralIndex();
            if (context.getProfiler().isEnabled()) {
                context.getProfiler().message(this, Profiler.OPTIMIZATIONS,
                        "OPTIMIZATION",
                        "Using structural index '" + index.toString() + "'");
            }
            return index.findAncestorsByTagName(ElementValue.ELEMENT, test.getName(), Constants.PARENT_AXIS, docs, contextSet, contextId);
        }
    }

    /**
     * Get the document set
     *
     * @param contextSet the context set
     * @return the document set
     */
    protected DocumentSet getDocumentSet(final NodeSet contextSet) {
        DocumentSet ds = getContextDocSet();
        if (ds == null) {
            ds = contextSet.getDocumentSet();
        }
        return ds;
    }

    /**
     * Get the parent expression
     *
     * @return the parent expression
     */
    public Expression getParentExpression() {
        return this.parent;
    }

    /**
     * Register the update listener
     */
    protected void registerUpdateListener() {
        if (listener == null) {
            listener = new UpdateListener() {
                @Override
                public void documentUpdated(final DocumentImpl document, final int event) {
                    if (document == null || event == UpdateListener.ADD || event == UpdateListener.REMOVE) {
                        // clear all
                        currentDocs = null;
                        currentSet = null;
                    } else {
                        if (currentDocs != null && currentDocs.contains(document.getDocId())) {
                            currentDocs = null;
                            currentSet = null;
                        }
                    }
                }

                @Override
                public void nodeMoved(final NodeId oldNodeId, final NodeHandle newNode) {
                    //no-op
                }

                @Override
                public void unsubscribe() {
                    LocationStep.this.listener = null;
                }

                @Override
                public void debug() {
                    if (LOG.isDebugEnabled()) {
                        LOG.debug("UpdateListener: Line: {}; id: {}", LocationStep.this.toString(), LocationStep.this.getExpressionId());
                    }
                }
            };
            context.registerUpdateListener(listener);
        }
    }

    @Override
    public void accept(final ExpressionVisitor visitor) {
        visitor.visitLocationStep(this);
    }

    /**
     * Set the parent expression
     *
     * @param parent the parent expression
     */
    public void setParent(final Expression parent) {
        this.parent = parent;
    }

    @Override
    public void resetState(final boolean postOptimization) {
        super.resetState(postOptimization);
        if (!postOptimization) {
            // TODO : preloadedData = false ?
            // No : introduces a regression in testMatchCount
            // TODO : Investigate...
            currentSet = null;
            currentDocs = null;
            optimized = false;
            listener = null;
        }
    }

    private abstract class AbstractFilterBase implements StreamFilter {
        final NodeTest test;
        final NodeSet result;
        final int limit;
        int nodesRead = 0;
        final int contextId;

        AbstractFilterBase(final NodeTest test, final NodeSet result, final int contextId, final int limit) {
            this.test = test;
            this.result = result;
            this.contextId = contextId;
            this.limit = limit;
            if (limit > -1 && context.getProfiler().traceFunctions()) {
                context.getProfiler().traceOptimization(context, PerformanceStats.OptimizationType.POSITIONAL_PREDICATE,
                        LocationStep.this);
            }
        }
    }

    private class FollowingSiblingFilter extends AbstractFilterBase {
        final NodeProxy start;
        final int level;
        boolean sibling = false;

        FollowingSiblingFilter(final NodeTest test, final NodeProxy start, final NodeSet result,
                final int contextId, final int limit) {
            super(test, result, contextId, limit);
            this.start = start;
            this.level = start.getNodeId().getTreeLevel();
        }

        @Override
        public boolean accept(final XMLStreamReader reader) {
            final NodeId currentId = (NodeId) reader.getProperty(ExtendedXMLStreamReader.PROPERTY_NODE_ID);
            final int currentLevel = currentId.getTreeLevel();

            if (!sibling) {
                // skip over the start node to the first sibling
                sibling = currentId.equals(start.getNodeId());

            } else if (currentLevel == level && !reader.isEndElement() && test.matches(reader)) {
                // sibling which matches the test
                NodeProxy sibling = result.get(start.getOwnerDocument(), currentId);
                if (sibling == null) {
                    sibling = new NodeProxy(null, start.getOwnerDocument(), currentId,
                            StaXUtil.streamType2DOM(reader.getEventType()), ((EmbeddedXMLStreamReader) reader).getCurrentPosition());

                    if (Expression.IGNORE_CONTEXT != contextId) {
                        if (Expression.NO_CONTEXT_ID == contextId) {
                            NodeProxy.propagatePredicateContextFrom(sibling, start, contextId);
                        } else {
                            sibling.addContextNode(contextId, start);
                        }
                    }
                    result.add(sibling);
                } else if (Expression.NO_CONTEXT_ID != contextId) {
                    sibling.addContextNode(contextId, start);
                }
                nodesRead++;
                if (this.limit > -1 && nodesRead == this.limit) {
                    return false;
                }

            } else if (currentLevel < level) {
                // exited the parent node, so stop filtering
                return false;
            }

            return true;
        }
    }

    private class PrecedingSiblingFilter extends AbstractFilterBase {
        final int level;
        final NodeProxy referenceNode;

        PrecedingSiblingFilter(final NodeTest test, final NodeProxy start, final NodeProxy referenceNode,
                final NodeSet result, final int contextId) {
            super(test, result, contextId, -1);
            this.level = start.getNodeId().getTreeLevel();
            this.referenceNode = referenceNode;
        }

        @Override
        public boolean accept(final XMLStreamReader reader) {
            final NodeId currentId = (NodeId) reader.getProperty(ExtendedXMLStreamReader.PROPERTY_NODE_ID);

            final NodeId refId = referenceNode.getNodeId();
            if (currentId.equals(refId)) {
                // reached the reference node
                return false;
            }

            if (reader.isEndElement()) {
                return true;
            }
            if (currentId.getTreeLevel() == level && test.matches(reader)) {
                // sibling which matches the test
                NodeProxy sibling = result.get(referenceNode.getOwnerDocument(), currentId);
                if (sibling == null) {
                    sibling = new NodeProxy(null, referenceNode.getOwnerDocument(), currentId,
                            StaXUtil.streamType2DOM(reader.getEventType()), ((EmbeddedXMLStreamReader) reader).getCurrentPosition());
                    if (Expression.IGNORE_CONTEXT != contextId) {
                        if (Expression.NO_CONTEXT_ID == contextId) {
                            NodeProxy.propagatePredicateContextFrom(sibling, referenceNode, contextId);
                        } else {
                            sibling.addContextNode(contextId, referenceNode);
                        }
                    }
                    result.add(sibling);
                } else if (Expression.NO_CONTEXT_ID != contextId) {
                    sibling.addContextNode(contextId, referenceNode);
                }
            }

            return true;
        }
    }

    private class FollowingFilter extends AbstractFilterBase {
        final NodeProxy root;
        final NodeProxy referenceNode;
        boolean isAfter = false;

        FollowingFilter(final NodeTest test, final NodeProxy root, final NodeProxy referenceNode, final NodeSet result,
                final int contextId, final int limit) {
            super(test, result, contextId, limit);
            this.root = root;
            this.referenceNode = referenceNode;
        }

        @Override
        public boolean accept(final XMLStreamReader reader) {
            final NodeId currentId = (NodeId) reader.getProperty(ExtendedXMLStreamReader.PROPERTY_NODE_ID);
            if (reader.getEventType() == XMLStreamReader.END_ELEMENT) {
                if (currentId.getTreeLevel() == root.getNodeId().getTreeLevel()) {
                    // exited the root element, so  stop filtering
                    return false;
                }

                return true;
            }

            final NodeId refId = referenceNode.getNodeId();

            if (!isAfter) {
                isAfter = currentId.compareTo(refId) > 0 && !currentId.isDescendantOf(refId);
            }

            if (isAfter && !refId.isDescendantOf(currentId) && test.matches(reader)) {
                final NodeProxy proxy = new NodeProxy(null, referenceNode.getOwnerDocument(), currentId,
                        StaXUtil.streamType2DOM(reader.getEventType()), ((EmbeddedXMLStreamReader) reader).getCurrentPosition());
                if (Expression.IGNORE_CONTEXT != contextId) {
                    if (Expression.NO_CONTEXT_ID == contextId) {
                        NodeProxy.propagatePredicateContextFrom(proxy, referenceNode, contextId);
                    } else {
                        proxy.addContextNode(contextId, referenceNode);
                    }
                }
                result.add(proxy);
                nodesRead++;
                if (this.limit > -1 && nodesRead == this.limit) {
                    return false;
                }
            }
            return true;
        }
    }

    private class PrecedingFilter extends AbstractFilterBase {
        final NodeProxy root;
        final NodeProxy referenceNode;
        // Sliding window of the most recent {@code limit} matches. Non-null only
        // when limit > 0 (positional predicate {@code [K]} present). The K-th
        // preceding element in axis order is the (K-th-from-end) match in doc
        // order, so any match earlier than the K most recent cannot be selected
        // and may be discarded as new ones are found.
        final Deque<NodeProxy> window;

        PrecedingFilter(final NodeTest test, final NodeProxy root, final NodeProxy referenceNode, final NodeSet result,
                final int contextId, final int limit) {
            super(test, result, contextId, limit);
            this.root = root;
            this.referenceNode = referenceNode;
            this.window = limit > 0 ? new ArrayDeque<>(limit) : null;
        }

        @Override
        public boolean accept(final XMLStreamReader reader) {
            final NodeId currentId = (NodeId) reader.getProperty(ExtendedXMLStreamReader.PROPERTY_NODE_ID);

            if (reader.getEventType() == XMLStreamReader.END_ELEMENT) {
                // exited the root element, so  stop filtering
                if (currentId.getTreeLevel() == root.getNodeId().getTreeLevel()) {
                    flushWindow();
                    return false;
                }
                return true;
            }

            final NodeId refId = referenceNode.getNodeId();
            if (currentId.compareTo(refId) >= 0) {
                flushWindow();
                return false;
            }

            if (!refId.isDescendantOf(currentId) && test.matches(reader)) {
                final NodeProxy proxy = new NodeProxy(null, referenceNode.getOwnerDocument(), currentId,
                        StaXUtil.streamType2DOM(reader.getEventType()), ((EmbeddedXMLStreamReader) reader).getCurrentPosition());
                if (Expression.IGNORE_CONTEXT != contextId) {
                    if (Expression.NO_CONTEXT_ID == contextId) {
                        NodeProxy.propagatePredicateContextFrom(proxy, referenceNode, contextId);
                    } else {
                        proxy.addContextNode(contextId, referenceNode);
                    }
                }
                if (window != null) {
                    if (window.size() == limit) {
                        window.pollFirst();
                    }
                    window.addLast(proxy);
                } else {
                    result.add(proxy);
                }
            }
            return true;
        }

        private void flushWindow() {
            if (window != null) {
                for (final NodeProxy proxy : window) {
                    result.add(proxy);
                }
                window.clear();
            }
        }
    }

}

eXist-db / exist / 41106813683

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous