/** * Only boolean atoms are pushable. */ private static boolean isPushable(Function atom) { if (atom.isOperation()) return true; return false; } }
/*** * Counts the number of data atoms in this list of terms. Not recursive. * * @param terms * @return */ public static int countDataItems(List<?extends Term> terms) { int count = 0; for (Term currentTerm : terms) { Function currentAtom = (Function)currentTerm; if (!currentAtom.isOperation()) count += 1; } return count; }
@Override public Boolean f(Function atom) { return atom.isOperation() || TYPE_FACTORY.isBoolean(atom.getFunctionSymbol()); } };
/*** * Returns a string with boolean conditions formed with the boolean atoms * found in the atoms list. */ private Set<String> getBooleanConditionsString( List<Function> atoms, QueryAliasIndex index) { Set<String> conditions = new LinkedHashSet<String>(); for (int atomidx = 0; atomidx < atoms.size(); atomidx++) { Term innerAtom = atoms.get(atomidx); Function innerAtomAsFunction = (Function) innerAtom; // Boolean expression if (innerAtomAsFunction.isOperation()) { String condition = getSQLCondition(innerAtomAsFunction, index); conditions.add(condition); } else if (innerAtomAsFunction.isDataTypeFunction()) { String condition = getSQLString(innerAtom, index, false); conditions.add(condition); } } return conditions; }
Function funcRoot = (Function) queueHead; if (funcRoot.isOperation() || funcRoot.isDataTypeFunction() || funcRoot.isAlgebraFunction()) { for (Term term : funcRoot.getTerms()) {
@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()); }
/**** * Gets all the variables that are defined in this list of atoms, except in * atom i * * @param atoms * @return */ private static Set<Variable> getDefinedVariables(List<Term> atoms) { Set<Variable> currentLevelVariables = new HashSet<>(); for (Term l : atoms) { Function atom = (Function) l; if (atom.isOperation()) { continue; } else if (atom.isAlgebraFunction()) { currentLevelVariables.addAll(getDefinedVariables(atom.getTerms())); } else { TermUtils.addReferencedVariablesTo(currentLevelVariables, atom); } } return currentLevelVariables; }
/** * Returns a string with boolean conditions formed with the boolean atoms * found in the atoms list. */ private Set<String> getBooleanConditions(List<Function> atoms, AliasIndex index) { Set<String> conditions = new LinkedHashSet<>(); for (Function atom : atoms) { if (atom.isOperation()) { // Boolean expression if (atom.getFunctionSymbol() == ExpressionOperation.AND) { // flatten ANDs for (Term t : atom.getTerms()) { Set<String> arg = getBooleanConditions(ImmutableList.of((Function)t), index); conditions.addAll(arg); } } else { String condition = getSQLCondition(atom, index); conditions.add(condition); } } else if (atom.isDataTypeFunction()) { String condition = getSQLString(atom, index, false); conditions.add(condition); } } return conditions; }
/** * Returns a string with boolean conditions formed with the boolean atoms * found in the atoms list. */ private Set<String> getBooleanConditions(List<Function> atoms, AliasIndex index) { Set<String> conditions = new LinkedHashSet<>(); for (Function atom : atoms) { if (atom.isOperation()) { // Boolean expression if (atom.getFunctionSymbol() == ExpressionOperation.AND) { // flatten ANDs for (Term t : atom.getTerms()) { Set<String> arg = getBooleanConditions(ImmutableList.of((Function)t), index); conditions.addAll(arg); } } else { String condition = getSQLCondition(atom, index); conditions.add(condition); } } else if (atom.isDataTypeFunction()) { String condition = getSQLString(atom, index, false); conditions.add(condition); } } return conditions; }
Function funcRoot = (Function) queueHead; if (funcRoot.isOperation() || funcRoot.isDataTypeFunction() || funcRoot.isAlgebraFunction()) { for (Term term : funcRoot.getTerms()) {
/** * updates * * @param rule */ public void updateRuleIndexByBodyPredicate(CQIE rule) { for (Function bodyAtom : rule.getBody()) { if (bodyAtom.isDataFunction()) { Predicate functionSymbol = bodyAtom.getFunctionSymbol(); if (!ruleIndexByBodyPredicate.containsEntry(functionSymbol, rule)){ ruleIndexByBodyPredicate.put(functionSymbol, rule); } } else if (bodyAtom.isAlgebraFunction() || bodyAtom.isOperation()) { updateRuleIndexByBodyPredicate_traverseBodyAtom(rule, bodyAtom); // BC: should we reintroduce arithmetic functions? //} else if (bodyAtom.isArithmeticFunction() || bodyAtom.isDataTypeFunction()){ } else if (bodyAtom.isDataTypeFunction()){ continue; } else { throw new IllegalStateException("Unknown Function"); } } }
/** * Removes the old indexes given by a rule. * * @param rule */ public void removeOldRuleIndexByBodyPredicate(CQIE rule) { for (Function bodyAtom : rule.getBody()) { if (bodyAtom.isDataFunction()) { Predicate functionSymbol = bodyAtom.getFunctionSymbol(); if (ruleIndexByBodyPredicate.containsEntry(functionSymbol, rule)){ ruleIndexByBodyPredicate.remove(functionSymbol, rule); } } else if (bodyAtom.isAlgebraFunction() || bodyAtom.isOperation()) { removeRuleIndexByBodyPredicate_traverseBodyAtom(rule, bodyAtom); // BC: should we reintroduce arithmetic functions?//} // else if (bodyAtom.isArithmeticFunction() || bodyAtom.isDataTypeFunction()){ } else if (bodyAtom.isDataTypeFunction()){ continue; } else { throw new IllegalStateException("Unknown Function"); } } }
/** * updates * * @param rule */ public void updateRuleIndexByBodyPredicate(CQIE rule) { for (Function bodyAtom : rule.getBody()) { if (bodyAtom.isDataFunction()) { Predicate functionSymbol = bodyAtom.getFunctionSymbol(); if (!ruleIndexByBodyPredicate.containsEntry(functionSymbol, rule)){ ruleIndexByBodyPredicate.put(functionSymbol, rule); } } else if (bodyAtom.isAlgebraFunction() || bodyAtom.isOperation()) { updateRuleIndexByBodyPredicate_traverseBodyAtom(rule, bodyAtom); // BC: should we reintroduce arithmetic functions? //} else if (bodyAtom.isArithmeticFunction() || bodyAtom.isDataTypeFunction()){ } else if (bodyAtom.isDataTypeFunction()){ continue; } else { throw new IllegalStateException("Unknown Function"); } } }
properties = new Intersection<>(reasoner.objectPropertiesDAG()); for (Function a : edge.getBAtoms()) { if (a.isOperation()) { log.debug("EDGE {} HAS PROPERTY {} NO BOOLEAN OPERATION PREDICATES ALLOWED IN PROPERTIES", edge, a); properties.setToBottom();
/** * Collects (recursively) the set of variables that participate in data atoms * (either in this atom directly or in nested ones, excluding those on the * right-hand side of left joins. * * @param vars * @param atom * @return */ private void collectVariableReferencesWithLeftJoin(Set<Variable> vars, Function atom) { if (atom.isDataFunction()) { TermUtils.addReferencedVariablesTo(vars, atom); } else if (atom.isAlgebraFunction()) { Predicate functionSymbol = atom.getFunctionSymbol(); if (functionSymbol.equals(datalogFactory.getSparqlJoinPredicate())) { // if it's a join, we need to collect all the variables of each nested atom convert(atom.getTerms()).stream() .filter(f -> !f.isOperation()) .forEach(f -> collectVariableReferencesWithLeftJoin(vars, f)); } else if (functionSymbol.equals(datalogFactory.getSparqlLeftJoinPredicate())) { // if it's a left join, only of the first data/algebra atom (the left atom) collectVariableReferencesWithLeftJoin(vars, (Function) atom.getTerm(0)); } } }
/** * Collects (recursively) the set of variables that participate in data atoms * (either in this atom directly or in nested ones, excluding those on the * right-hand side of left joins. * * @param vars * @param atom * @return */ private void collectVariableReferencesWithLeftJoin(Set<Variable> vars, Function atom) { if (atom.isDataFunction()) { TermUtils.addReferencedVariablesTo(vars, atom); } else if (atom.isAlgebraFunction()) { Predicate functionSymbol = atom.getFunctionSymbol(); if (functionSymbol == DatalogAlgebraOperatorPredicates.SPARQL_JOIN) { // if it's a join, we need to collect all the variables of each nested atom convert(atom.getTerms()).stream() .filter(f -> !f.isOperation()) .forEach(f -> collectVariableReferencesWithLeftJoin(vars, f)); } else if (functionSymbol == DatalogAlgebraOperatorPredicates.SPARQL_LEFTJOIN) { // if it's a left join, only of the first data/algebra atom (the left atom) collectVariableReferencesWithLeftJoin(vars, (Function) atom.getTerm(0)); } } }
/** * Returns the table definition for the given atom. If the atom is a simple * table or view, then it returns the value as defined by the * AliasIndex. If the atom is a Join or Left Join, it will call * getTableDefinitions on the nested term list. */ private String getTableDefinition(Function atom, AliasIndex index, String indent) { if (atom.isAlgebraFunction()) { Predicate functionSymbol = atom.getFunctionSymbol(); ImmutableList<Function> joinAtoms = convert(atom.getTerms()); if (functionSymbol.equals(datalogFactory.getSparqlJoinPredicate())) { // nested joins we need to add parenthesis later boolean parenthesis = joinAtoms.get(0).isAlgebraFunction() || joinAtoms.get(1).isAlgebraFunction(); return getTableDefinitions(joinAtoms, index, "JOIN", parenthesis, indent + INDENT); } else if (functionSymbol.equals(datalogFactory.getSparqlLeftJoinPredicate())) { // in case of left join we want to add the parenthesis only for the right tables // we ignore nested joins from the left tables boolean parenthesis = joinAtoms.get(1).isAlgebraFunction(); return getTableDefinitions(joinAtoms, index, "LEFT OUTER JOIN", parenthesis, indent + INDENT); } } else if (!atom.isOperation() && !atom.isDataTypeFunction()) { return index.getViewDefinition(atom); // a database atom } return null; }
Function castTerm = (Function) term; if (castTerm.isOperation()) {
/*** * 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); } }