Search in sources :

Example 1 with TraversingIndex

use of org.apache.jackrabbit.oak.query.index.TraversingIndex in project jackrabbit-oak by apache.

the class QueryImpl method getBestSelectorExecutionPlan.

private SelectorExecutionPlan getBestSelectorExecutionPlan(NodeState rootState, FilterImpl filter, QueryIndexProvider indexProvider, boolean traversalEnabled) {
    QueryIndex bestIndex = null;
    if (LOG.isDebugEnabled()) {
        logDebug("cost using filter " + filter);
    }
    double bestCost = Double.POSITIVE_INFINITY;
    IndexPlan bestPlan = null;
    // Sort the indexes according to their minimum cost to be able to skip the remaining indexes if the cost of the
    // current index is below the minimum cost of the next index.
    List<? extends QueryIndex> queryIndexes = MINIMAL_COST_ORDERING.sortedCopy(indexProvider.getQueryIndexes(rootState));
    List<OrderEntry> sortOrder = getSortOrder(filter);
    for (int i = 0; i < queryIndexes.size(); i++) {
        QueryIndex index = queryIndexes.get(i);
        double minCost = index.getMinimumCost();
        if (minCost > bestCost) {
            // Stop looking if the minimum cost is higher than the current best cost
            break;
        }
        double cost;
        String indexName = index.getIndexName();
        IndexPlan indexPlan = null;
        if (index instanceof AdvancedQueryIndex) {
            AdvancedQueryIndex advIndex = (AdvancedQueryIndex) index;
            long maxEntryCount = limit;
            if (offset > 0) {
                if (offset + limit < 0) {
                    // long overflow
                    maxEntryCount = Long.MAX_VALUE;
                } else {
                    maxEntryCount = offset + limit;
                }
            }
            List<IndexPlan> ipList = advIndex.getPlans(filter, sortOrder, rootState);
            cost = Double.POSITIVE_INFINITY;
            for (IndexPlan p : ipList) {
                long entryCount = p.getEstimatedEntryCount();
                if (p.getSupportsPathRestriction()) {
                    entryCount = scaleEntryCount(rootState, filter, entryCount);
                }
                if (sortOrder == null || p.getSortOrder() != null) {
                    // if the query is unordered, or
                    // if the query contains "order by" and the index can sort on that,
                    // then we don't need to read all entries from the index
                    entryCount = Math.min(maxEntryCount, entryCount);
                }
                double c = p.getCostPerExecution() + entryCount * p.getCostPerEntry();
                if (LOG.isDebugEnabled()) {
                    String plan = advIndex.getPlanDescription(p, rootState);
                    String msg = String.format("cost for [%s] of type (%s) with plan [%s] is %1.2f", p.getPlanName(), indexName, plan, c);
                    logDebug(msg);
                }
                if (c < cost) {
                    cost = c;
                    indexPlan = p;
                }
            }
            if (indexPlan != null && indexPlan.getPlanName() != null) {
                indexName += "[" + indexPlan.getPlanName() + "]";
            }
        } else {
            cost = index.getCost(filter, rootState);
        }
        if (LOG.isDebugEnabled()) {
            logDebug("cost for " + indexName + " is " + cost);
        }
        if (cost < 0) {
            LOG.error("cost below 0 for " + indexName + " is " + cost);
        }
        if (cost < bestCost) {
            bestCost = cost;
            bestIndex = index;
            bestPlan = indexPlan;
        }
    }
    potentiallySlowTraversalQuery = bestIndex == null;
    if (traversalEnabled) {
        TraversingIndex traversal = new TraversingIndex();
        double cost = traversal.getCost(filter, rootState);
        if (LOG.isDebugEnabled()) {
            logDebug("cost for " + traversal.getIndexName() + " is " + cost);
        }
        if (cost < bestCost || bestCost == Double.POSITIVE_INFINITY) {
            bestCost = cost;
            bestPlan = null;
            bestIndex = traversal;
            if (potentiallySlowTraversalQuery) {
                potentiallySlowTraversalQuery = traversal.isPotentiallySlow(filter, rootState);
            }
        }
    }
    return new SelectorExecutionPlan(filter.getSelector(), bestIndex, bestPlan, bestCost);
}
Also used : SelectorExecutionPlan(org.apache.jackrabbit.oak.query.plan.SelectorExecutionPlan) AdvancedQueryIndex(org.apache.jackrabbit.oak.spi.query.QueryIndex.AdvancedQueryIndex) OrderEntry(org.apache.jackrabbit.oak.spi.query.QueryIndex.OrderEntry) IndexPlan(org.apache.jackrabbit.oak.spi.query.QueryIndex.IndexPlan) TraversingIndex(org.apache.jackrabbit.oak.query.index.TraversingIndex) QueryIndex(org.apache.jackrabbit.oak.spi.query.QueryIndex) AdvancedQueryIndex(org.apache.jackrabbit.oak.spi.query.QueryIndex.AdvancedQueryIndex)

Example 2 with TraversingIndex

use of org.apache.jackrabbit.oak.query.index.TraversingIndex in project jackrabbit-oak by apache.

the class PropertyIndexTest method costMaxEstimation.

@Test
public void costMaxEstimation() throws Exception {
    NodeState root = EmptyNodeState.EMPTY_NODE;
    // Add index definition
    NodeBuilder builder = root.builder();
    createIndexDefinition(builder.child(INDEX_DEFINITIONS_NAME), "foo", true, false, ImmutableSet.of("foo"), null);
    NodeState before = builder.getNodeState();
    // 100 nodes in the index:
    // with a single level /content cost is 121
    // adding a second level /content/data cost is133
    // 101 nodes in the index:
    // with a single level /content cost is 121
    // adding a second level /content/data cost is 133
    // 100 nodes, 12 levels deep, cost is 345
    // 101 nodes, 12 levels deep, cost is 345
    // threshold for estimation (PropertyIndexLookup.MAX_COST) is at 100
    int nodes = 101;
    int levels = 12;
    NodeBuilder data = builder;
    for (int i = 0; i < levels; i++) {
        data = data.child("l" + i);
    }
    for (int i = 0; i < nodes; i++) {
        NodeBuilder c = data.child("c_" + i);
        c.setProperty("foo", "azerty");
    }
    // add more nodes (to make traversal more expensive)
    for (int i = 0; i < 10000; i++) {
        data.child("cx_" + i);
    }
    NodeState after = builder.getNodeState();
    NodeState indexed = HOOK.processCommit(before, after, CommitInfo.EMPTY);
    FilterImpl f = createFilter(indexed, NT_BASE);
    PropertyIndexLookup lookup = new PropertyIndexLookup(indexed);
    double cost = lookup.getCost(f, "foo", PropertyValues.newString("azerty"));
    double traversal = new TraversingIndex().getCost(f, indexed);
    assertTrue("Estimated cost for " + nodes + " nodes should not be higher than traversal (" + cost + " < " + traversal + ")", cost < traversal);
}
Also used : EmptyNodeState(org.apache.jackrabbit.oak.plugins.memory.EmptyNodeState) NodeState(org.apache.jackrabbit.oak.spi.state.NodeState) FilterImpl(org.apache.jackrabbit.oak.query.index.FilterImpl) TraversingIndex(org.apache.jackrabbit.oak.query.index.TraversingIndex) NodeBuilder(org.apache.jackrabbit.oak.spi.state.NodeBuilder) Test(org.junit.Test)

Aggregations

TraversingIndex (org.apache.jackrabbit.oak.query.index.TraversingIndex)2 EmptyNodeState (org.apache.jackrabbit.oak.plugins.memory.EmptyNodeState)1 FilterImpl (org.apache.jackrabbit.oak.query.index.FilterImpl)1 SelectorExecutionPlan (org.apache.jackrabbit.oak.query.plan.SelectorExecutionPlan)1 QueryIndex (org.apache.jackrabbit.oak.spi.query.QueryIndex)1 AdvancedQueryIndex (org.apache.jackrabbit.oak.spi.query.QueryIndex.AdvancedQueryIndex)1 IndexPlan (org.apache.jackrabbit.oak.spi.query.QueryIndex.IndexPlan)1 OrderEntry (org.apache.jackrabbit.oak.spi.query.QueryIndex.OrderEntry)1 NodeBuilder (org.apache.jackrabbit.oak.spi.state.NodeBuilder)1 NodeState (org.apache.jackrabbit.oak.spi.state.NodeState)1 Test (org.junit.Test)1