org.aksw.jena_sparql_api.utils.ClauseUtils Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of jena-sparql-api-utils Show documentation
There is a newer version: 3.17.0-1
Show newest version
package org.aksw.jena_sparql_api.utils;

import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.StreamSupport;

import org.apache.jena.sparql.algebra.optimize.ExprTransformConstantFold;
import org.apache.jena.sparql.core.Var;
import org.apache.jena.sparql.engine.binding.BindingRoot;
import org.apache.jena.sparql.expr.E_LogicalNot;
import org.apache.jena.sparql.expr.Expr;
import org.apache.jena.sparql.expr.ExprTransformer;
import org.apache.jena.sparql.expr.NodeValue;
import org.apache.jena.sparql.graph.NodeTransform;

public class ClauseUtils
{

    public static final Set TRUE = Collections.singleton(NodeValue.TRUE);

    /*
     * Use ExprIndex.filterByVars instead
    public static Set filterByVars(Collection clauses, Set requiredVars) {

        Set result = new HashSet();

        for(Clause clause : clauses) {
            Set clauseVars = clause.getVarsMentioned();

            if(!clauseVars.containsAll(requiredVars)) {
                continue;
            }

            result.add(clause);
        }


        return result;
    }*/

    //Iterable 
    public static Set canonicalize(Iterable clause) {
        Set result = StreamSupport.stream(clause.spliterator(), false)
            .map(e -> ExprUtils.canonicalize(e))
            .collect(Collectors.toSet());
        
        return result;
    }
    

    public static Set> filterByVars(Set> clauses, Set requiredVars) {

        Set> result = new HashSet>();

        for(Set clause : clauses) {
            Set clauseVars = ClauseUtils.getVarsMentioned(clause);

            if(!clauseVars.containsAll(requiredVars)) {
                continue;
            }

            result.add(clause);
        }


        return result;
    }

    /**
     * false means that it is no satisfiable.
     *
     * true is actually a 'maybe'
     *
     * @param clause
     * @return
     */
    public static boolean isSatisfiable(Set clause)
    {
        for(Expr expr : clause) {
            if(expr.equals(NodeValue.FALSE)) {
                return false;
            }

            if(!isSatisfiable(expr)) {
                return false;
            }

            if(expr instanceof E_LogicalNot) {
                Expr child = ((E_LogicalNot)expr).getArg();

                if(clause.contains(child)) {
                    return false;
                }
            }
        }

        return true;
    }

    public static boolean isSatisfiable(Expr expr)
    {
        // NOTE Folding does not detect cases such as E_LogicalAnd(E_Equals(x = y), false)
    	Expr exprCopy = expr.copySubstitute(BindingRoot.create());
    	Expr folded = ExprTransformer.transform(new ExprTransformConstantFold(), exprCopy) ;
        
        return !folded.equals(NodeValue.FALSE);
    }

    public static Set getVarsMentioned(Iterable clause)
    {
        Set result = new HashSet();

        for(Expr expr : clause) {
            result.addAll(expr.getVarsMentioned());
        }

        return result;
    }

    public static Set> applyNodeTransformSet(Set> clauses, NodeTransform nodeTransform) {
        Set> result = new HashSet>();
        for(Set clause : clauses) {
            Set transformedClause = applyNodeTransform(clause, nodeTransform);
            result.add(transformedClause);
        }

        return result;
    }

    public static Set applyNodeTransform(Set clause, NodeTransform nodeTransform) {
        Set result = new HashSet();
        for(Expr expr : clause) {
            Expr transformedExpr = expr.applyNodeTransform(nodeTransform);
            result.add(transformedExpr);
        }

        return result;
    }

    /*
    public static Set getVarsMentioned(Set clause)
    {
        Set vars = new HashSet();

        for(Expr expr : clause) {
            Set exprVars = expr.getVarsMentioned();

            if(vars.isEmpty()) { // this happens on the first expr
                vars.addAll(exprVars);
            } else {
                vars.retainAll(exprVars);
                if(vars.isEmpty()) {
                    break;
                }
            }
        }

        return vars;
    }
     */

}