ReorderSortAndRemoveDuplicates.java

/*
 * ModeShape (http://www.modeshape.org)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.modeshape.jcr.query.optimize;

import java.util.LinkedList;
import org.modeshape.common.annotation.Immutable;
import org.modeshape.jcr.query.QueryContext;
import org.modeshape.jcr.query.plan.PlanNode;
import org.modeshape.jcr.query.plan.PlanNode.Traversal;
import org.modeshape.jcr.query.plan.PlanNode.Type;

/**
 * An {@link OptimizerRule optimizer rule} that looks for a {@link Type#SORT} plan node below a {@link Type#DUP_REMOVE}, and swaps
 * them. This ensures that the duplicate removal is always lower in the tree. This is advantageous because many sort algorithms
 * can also efficiently remove duplicates, so it is often better for the {@link Type#SORT} plan node to appear higher in the
 * optimized plan.
 */
@Immutable
public class ReorderSortAndRemoveDuplicates implements OptimizerRule {

    public static final ReorderSortAndRemoveDuplicates INSTANCE = new ReorderSortAndRemoveDuplicates();

    @Override
    public PlanNode execute( QueryContext context,
                             PlanNode plan,
                             LinkedList<OptimizerRule> ruleStack ) {
        for (PlanNode distinct : plan.findAllAtOrBelow(Traversal.PRE_ORDER, Type.DUP_REMOVE)) {
            // If there is a SORT below the DUP_REMOVE, then swap them...
            if (distinct.getFirstChild().getType() == Type.SORT) {
                // Swap them so that duplicate removal happens first (it's lower in the plan) ...
                PlanNode parent = distinct.getParent();
                PlanNode sort = distinct.getFirstChild();
                assert sort.getParent() == distinct;
                // First, remove SORT from DUP_REMOVE (which will be empty) ...
                sort.removeFromParent();
                assert sort.getParent() == null;
                // Move all children of SORT into the currently-empty DUP_REMOVE ...
                distinct.addChildren(sort.getChildren());
                assert sort.getChildCount() == 0;
                assert sort.getParent() == null;
                // Swap DUP_REMOVE in parent with SORT
                parent.replaceChild(distinct, sort);
                assert sort.getParent() == parent;
                assert sort.getChildCount() == 0;
                assert distinct.getParent() == null;
                // Now move DUP_REMOVE under SORT ...
                distinct.setParent(sort);
                assert distinct.getParent() == sort;
                assert sort.getParent() == parent;
            }
        }
        return plan;
    }

    @Override
    public String toString() {
        return getClass().getSimpleName();
    }

}