ImmutableList<Function> getAtomsExtendedWithNulls(ImmutableSet<Variable> allVariables) { Sets.SetView<Variable> nullVariables = Sets.difference(allVariables, variables); if (nullVariables.isEmpty()) return atoms; return getAtomsExtended(nullVariables.stream().map(v -> termFactory.getFunctionEQ(v, valueNull))); }
/** * Extends the current translation result with bindings coming from {@link Extension} (expr AS ?x) or {@link BindingSetAssignment} (VALUES in SPARQL) * * @param bindings a stream of bindings. A binding is a pair of a variable, and a value/expression * @param varMapper a function from bindings to {@link Variable}s * @param exprMapper a function maps a pair of a binding and a set variables to a {@link Term} * @param <T> A class for binding. E.g. {@link org.eclipse.rdf4j.query.Binding} or {@link org.eclipse.rdf4j.query.algebra.ExtensionElem} * @return extended translation result */ <T> TranslationResult extendWithBindings(Stream<T> bindings, java.util.function.Function<? super T, Variable> varMapper, BiFunctionWithUnsupportedException<? super T, ImmutableSet<Variable>, Term> exprMapper) throws OntopUnsupportedInputQueryException, OntopInvalidInputQueryException { Set<Variable> vars = new HashSet<>(variables); List<Function> eqAtoms = new ArrayList<>(); // Functional-style replaced because of OntopUnsupportedInputQueryException for(T b : bindings.collect(Collectors.toList())) { Term expr = exprMapper.apply(b, ImmutableSet.copyOf(vars)); Variable v = varMapper.apply(b); if (!vars.add(v)) throw new IllegalArgumentException("Duplicate binding for variable " + v); eqAtoms.add(termFactory.getFunctionEQ(v, expr)); } return new TranslationResult(getAtomsExtended(eqAtoms.stream()), ImmutableSet.copyOf(vars), false); }
for (int i = 0; i < varList.size() - 1; i++) { for (int j = i + 1; j < varList.size(); j++) { Function equality = TERM_FACTORY.getFunctionEQ(varList.get(i), varList.get(j)); boolSet.add(equality);
/** * internal implementation of JOIN USING and NATURAL JOIN * * @param re1 a {@link RAExpressionAttributes} * @param re2 a {@link RAExpressionAttributes} * @param using a {@link ImmutableSet}<{@link QuotedID}> * @return a {@Link ImmutableList}<{@link Function}> */ private static ImmutableList<Function> getJoinOnFilter(RAExpressionAttributes re1, RAExpressionAttributes re2, ImmutableSet<QuotedID> using, TermFactory termFactory) { return using.stream() .map(id -> new QualifiedAttributeID(null, id)) .map(id -> { // TODO: this will be removed later, when OBDA factory will start checking non-nulls Term v1 = re1.getAttributes().get(id); if (v1 == null) throw new IllegalArgumentException("Term " + id + " not found in " + re1); Term v2 = re2.getAttributes().get(id); if (v2 == null) throw new IllegalArgumentException("Term " + id + " not found in " + re2); return termFactory.getFunctionEQ(v1, v2); }) .collect(ImmutableCollectors.toList()); }
/** * internal implementation of JOIN USING and NATURAL JOIN * * @param re1 a {@link RAExpressionAttributes} * @param re2 a {@link RAExpressionAttributes} * @param using a {@link ImmutableSet}<{@link QuotedID}> * @return a {@Link ImmutableList}<{@link Function}> */ private static ImmutableList<Function> getJoinOnFilter(RAExpressionAttributes re1, RAExpressionAttributes re2, ImmutableSet<QuotedID> using) { return using.stream() .map(id -> new QualifiedAttributeID(null, id)) .map(id -> { // TODO: this will be removed later, when OBDA factory will start checking non-nulls Term v1 = re1.getAttributes().get(id); if (v1 == null) throw new IllegalArgumentException("Term " + id + " not found in " + re1); Term v2 = re2.getAttributes().get(id); if (v2 == null) throw new IllegalArgumentException("Term " + id + " not found in " + re2); return TERM_FACTORY.getFunctionEQ(v1, v2); }) .collect(ImmutableCollectors.toList()); }
/** * Converts the variable-to-constant pairs into a list of equalities. */ private static List<Function> generateVariableConstantEqualities(List<P2<Variable, Constant>> varConstantPairs) { return varConstantPairs .map((F<P2<Variable, Constant>, Function>) pair -> TERM_FACTORY.getFunctionEQ(pair._1(), pair._2())); }
private Function replaceConstants(Function a, List<Function> filters) { Function atom = (Function)a.clone(); for (int i = 0; i < atom.getTerms().size(); i++) { Term term = atom.getTerm(i); if (term instanceof Constant) { // Found a constant, replacing with a fresh variable // and adding the new equality atom Constant c = (Constant)term; Variable var = valueMap.get(c); if (var == null) { freshVarCount++; var = termFactory.getVariable("?FreshVar" + freshVarCount); valueMap.put(c, var); filters.add(termFactory.getFunctionEQ(var, c)); } atom.setTerm(i, var); } } return atom; }
private Function replaceConstants(Function a, List<Function> filters) { Function atom = (Function)a.clone(); for (int i = 0; i < atom.getTerms().size(); i++) { Term term = atom.getTerm(i); if (term instanceof Constant) { // Found a constant, replacing with a fresh variable // and adding the new equality atom Constant c = (Constant)term; Variable var = valueMap.get(c); if (var == null) { freshVarCount++; var = TERM_FACTORY.getVariable("?FreshVar" + freshVarCount); valueMap.put(c, var); filters.add(TERM_FACTORY.getFunctionEQ(var, c)); } atom.setTerm(i, var); } } return atom; }
return termFactory.getFunctionEQ(term2, term1); } else { if(term1 instanceof ValueConstant){ if (isEqual) return termFactory.getFunctionEQ(term1, term2); else return termFactory.getFunctionNEQ(term1, term2); return termFactory.getFunctionEQ(term1, term2); else return termFactory.getFunctionNEQ(term1, term2);
@Inject private DatalogTools(TermFactory termFactory, DatalogFactory datalogFactory) { this.termFactory = termFactory; this.datalogFactory = datalogFactory; ValueConstant valueTrue = termFactory.getBooleanConstant(true); TRUE_EQ = termFactory.getFunctionEQ(valueTrue, valueTrue); IS_DATA_OR_LJ_OR_JOIN_ATOM_FCT = this::isDataOrLeftJoinOrJoinAtom; IS_NOT_DATA_OR_COMPOSITE_ATOM_FCT = atom -> !isDataOrLeftJoinOrJoinAtom(atom); IS_BOOLEAN_ATOM_FCT = atom -> atom.isOperation() || isXsdBoolean(atom.getFunctionSymbol()); }
return TERM_FACTORY.getFunctionEQ(term2, term1); } else { if(term1 instanceof ValueConstant){ if (isEqual) return TERM_FACTORY.getFunctionEQ(term1, term2); else return TERM_FACTORY.getFunctionNEQ(term1, term2); return TERM_FACTORY.getFunctionEQ(term1, term2); else return TERM_FACTORY.getFunctionNEQ(term1, term2);
for (Variable var : keys) { if (isEqual) result = termFactory.getFunctionEQ(var, theta.get(var)); else result = termFactory.getFunctionNEQ(var, theta.get(var));
for (Variable var : keys) { if (isEqual) result = TERM_FACTORY.getFunctionEQ(var, theta.get(var)); else result = TERM_FACTORY.getFunctionNEQ(var, theta.get(var));
/** * Converts the variable-to-variable pairs into a list of equalities. */ private static List<Function> generateVariableEqualities(Set<Variable> equivalentVariables) { List<Variable> variableList = equivalentVariables.toList(); List<P2<Variable, Variable>> variablePairs = variableList.zip(variableList.tail()); return variablePairs .map((F<P2<Variable, Variable>, Function>) pair -> TERM_FACTORY.getFunctionEQ(pair._1(), pair._2())); }
/*** * Adds a trivial equality to a LeftJoin in case the left join doesn't have * at least one boolean condition. This is necessary to have syntactically * correct LeftJoins in SQL. * * @param leftJoin */ private static void addMinimalEqualityToLeftJoin(Function leftJoin) { int booleanAtoms = 0; boolean isLeftJoin = leftJoin.isAlgebraFunction(); for (Term term : leftJoin.getTerms()) { Function f = (Function) term; if (f.isAlgebraFunction()) { addMinimalEqualityToLeftJoin(f); } if (f.isOperation()) booleanAtoms += 1; } if (isLeftJoin && booleanAtoms == 0) { Function trivialEquality = TERM_FACTORY.getFunctionEQ(TERM_FACTORY.getConstantLiteral("1", COL_TYPE.INTEGER), TERM_FACTORY.getConstantLiteral("1", COL_TYPE.INTEGER)); leftJoin.getTerms().add(trivialEquality); } }
private void addMinimalEqualityToLeftOrNestedInnerJoin(Function algebraFunctionalTerm) { int booleanAtoms = 0; for (Term term : algebraFunctionalTerm.getTerms()) { Function f = (Function) term; if (f.isAlgebraFunction()) { addMinimalEqualityToLeftOrNestedInnerJoin(f); } if (f.isOperation()) booleanAtoms++; } if (algebraFunctionalTerm.isAlgebraFunction() && booleanAtoms == 0) { Function trivialEquality = termFactory.getFunctionEQ( termFactory.getConstantLiteral("1", typeFactory.getXsdIntegerDatatype()), termFactory.getConstantLiteral("1", typeFactory.getXsdIntegerDatatype())); algebraFunctionalTerm.getTerms().add(trivialEquality); } }
private Term evalIsTrue(Function term) { Term teval = eval(term.getTerm(0)); if (teval instanceof Function) { Function f = (Function) teval; Predicate predicate = f.getFunctionSymbol(); if (predicate == ExpressionOperation.IS_NOT_NULL) { return TERM_FACTORY.getFunctionIsNotNull(f.getTerm(0)); } else if (predicate == ExpressionOperation.IS_NULL) { return TERM_FACTORY.getFunctionIsNull(f.getTerm(0)); } else if (predicate == ExpressionOperation.NEQ) { return TERM_FACTORY.getFunctionNEQ(f.getTerm(0), f.getTerm(1)); } else if (predicate == ExpressionOperation.EQ) { return TERM_FACTORY.getFunctionEQ(f.getTerm(0), f.getTerm(1)); } } else if (teval instanceof Constant) { return teval; } return term; }
private Term evalIsTrue(Function term) { Term teval = eval(term.getTerm(0)); if (teval instanceof Function) { Function f = (Function) teval; Predicate predicate = f.getFunctionSymbol(); if (predicate == ExpressionOperation.IS_NOT_NULL) { return termFactory.getFunctionIsNotNull(f.getTerm(0)); } else if (predicate == ExpressionOperation.IS_NULL) { return termFactory.getFunctionIsNull(f.getTerm(0)); } else if (predicate == ExpressionOperation.NEQ) { return termFactory.getFunctionNEQ(f.getTerm(0), f.getTerm(1)); } else if (predicate == ExpressionOperation.EQ) { return termFactory.getFunctionEQ(f.getTerm(0), f.getTerm(1)); } } else if (teval instanceof Constant) { return teval; } return term; }
private Term evalNot(Function term) { Term teval = eval(term.getTerm(0)); if (teval instanceof Function) { Function f = (Function) teval; Predicate predicate = f.getFunctionSymbol(); if (predicate == ExpressionOperation.IS_NOT_NULL) { return TERM_FACTORY.getFunctionIsNull(f.getTerm(0)); } else if (predicate == ExpressionOperation.IS_NULL) { return TERM_FACTORY.getFunctionIsNotNull(f.getTerm(0)); } else if (predicate == ExpressionOperation.NEQ) { return TERM_FACTORY.getFunctionEQ(f.getTerm(0), f.getTerm(1)); } else if (predicate == ExpressionOperation.EQ) { return TERM_FACTORY.getFunctionNEQ(f.getTerm(0), f.getTerm(1)); } } else if (teval instanceof Constant) { if (teval == TermConstants.FALSE) return TermConstants.TRUE; else if (teval == TermConstants.TRUE) return TermConstants.FALSE; else if (teval == TermConstants.NULL) return teval; // ROMAN (10 Jan 2017): this needs to be revised return teval; } return term; }
private Term evalNot(Function term) { Term teval = eval(term.getTerm(0)); if (teval instanceof Function) { Function f = (Function) teval; Predicate predicate = f.getFunctionSymbol(); if (predicate == ExpressionOperation.IS_NOT_NULL) { return termFactory.getFunctionIsNull(f.getTerm(0)); } else if (predicate == ExpressionOperation.IS_NULL) { return termFactory.getFunctionIsNotNull(f.getTerm(0)); } else if (predicate == ExpressionOperation.NEQ) { return termFactory.getFunctionEQ(f.getTerm(0), f.getTerm(1)); } else if (predicate == ExpressionOperation.EQ) { return termFactory.getFunctionNEQ(f.getTerm(0), f.getTerm(1)); } } else if (teval instanceof Constant) { if (teval == valueFalse) return valueTrue; else if (teval == valueTrue) return valueFalse; else if (teval == valueNull) return teval; // ROMAN (10 Jan 2017): this needs to be revised return teval; } return term; }