com.redhat.lightblue.assoc.qrew.QueryRewriter Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of lightblue-core-crud Show documentation
There is a newer version: 2.18.0
/*
 Copyright 2013 Red Hat, Inc. and/or its affiliates.

 This file is part of lightblue.

 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.

 This program 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 General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program.  If not, see .
 */
package com.redhat.lightblue.assoc.qrew;

import java.util.Set;
import java.util.HashSet;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.redhat.lightblue.query.QueryExpression;
import com.redhat.lightblue.query.UnaryLogicalExpression;
import com.redhat.lightblue.query.NaryLogicalExpression;
import com.redhat.lightblue.query.ArrayMatchExpression;

import com.redhat.lightblue.util.CopyOnWriteIterator;

import com.redhat.lightblue.assoc.qrew.rules.*;

/**
 * Implementation of Rewriter that orchestrates rewriting rules with registered
 * Rewriter instances.
 */
public final class QueryRewriter extends Rewriter {

    private static final Logger LOGGER = LoggerFactory.getLogger(QueryRewriter.class);

    private static final Set rewriteRules = new HashSet<>(16);

    public QueryRewriter() {
        this(true);
    }

    public QueryRewriter(boolean withDefaultRules) {
        if (withDefaultRules) {
            registerDefaultRules();
        }
    }

    /**
     * Register a Rewriter instance. If attempt to register QueryRewriter
     * returns without doing anything.
     *
     * @param rule the rewriter to register
     */
    public void register(Rewriter rule) {
        if (rule instanceof QueryRewriter) {
            return;
        }
        rewriteRules.add(rule);
    }

    /**
     * Register default rules.
     */
    protected void registerDefaultRules() {
        register(CombineANDsToNIN.INSTANCE);
        register(CombineINsInOR.INSTANCE);
        register(CombineNINsInAND.INSTANCE);
        register(CombineORsToIN.INSTANCE);
        register(EliminateNOT.INSTANCE);
        register(EliminateNOTNOT.INSTANCE);
        register(EliminateNOTOR.INSTANCE);
        register(EliminateSingleANDOR.INSTANCE);
        register(ExtendINsInOR.INSTANCE);
        register(ExtendNINsInAND.INSTANCE);
        register(PromoteNestedAND.INSTANCE);
        register(SimpleElemMatchIsComparison.INSTANCE);
    }

    protected QueryExpression rewriteIteration(QueryExpression q) {
        LOGGER.debug("Rewrite iteration begins for q={}", q);
        QueryExpression newq = q;
        if (q instanceof UnaryLogicalExpression) {
            LOGGER.debug("q is a unary logical expression, rewriting nested query");
            QueryExpression nestedq = ((UnaryLogicalExpression) q).getQuery();
            QueryExpression newNestedq = rewriteIteration(nestedq);
            LOGGER.debug("Rewritten nested query={}", newNestedq);
            if (newNestedq != nestedq) {
                newq = new UnaryLogicalExpression(((UnaryLogicalExpression) q).getOp(), newNestedq);
            }
        } else if (q instanceof NaryLogicalExpression) {
            LOGGER.debug("q is a n-ary logical expression, rewriting nested terms");
            CopyOnWriteIterator cowr = new CopyOnWriteIterator<>(((NaryLogicalExpression) q).getQueries());
            while (cowr.hasNext()) {
                QueryExpression nestedq = cowr.next();
                QueryExpression newNestedq = rewriteIteration(nestedq);
                if (newNestedq != nestedq) {
                    cowr.set(newNestedq);
                }
            }
            if (cowr.isCopied()) {
                newq = new NaryLogicalExpression(((NaryLogicalExpression) q).getOp(), cowr.getCopiedList());
            }
        } else if (q instanceof ArrayMatchExpression) {
            LOGGER.debug("q is an array match expression, rewriting nested query");
            QueryExpression nestedq = ((ArrayMatchExpression) q).getElemMatch();
            QueryExpression newNestedq = rewriteIteration(nestedq);
            LOGGER.debug("Rewritten nested query={}", newNestedq);
            if (newNestedq != nestedq) {
                newq = new ArrayMatchExpression(((ArrayMatchExpression) q).getArray(), newNestedq);
            }
        }
        LOGGER.debug("Applying rewrite rules to q");
        newq = applyRules(newq);
        LOGGER.debug("Rewritten q={}", newq);

        return newq;
    }

    @Override
    public QueryExpression rewrite(QueryExpression q) {
        QueryExpression trc = q;
        QueryExpression newq;
        boolean done = false;
        do {
            newq = rewriteIteration(trc);
            LOGGER.debug("Rewrite iteration pre={}", trc);
            LOGGER.debug("Rewrite iteration post={}", newq);
            if (newq == trc) {
                done = true;
            }
            trc = newq;
        } while (!done);
        return newq;
    }

    private QueryExpression applyRules(QueryExpression q) {
        QueryExpression newq = q;
        for (Rewriter r : rewriteRules) {
            newq = r.rewrite(newq);
        }
        return newq;
    }
}