/** * Normalizations of the Datalog program requirend by the Datalog to SQL translator */ private void normalizeRule(CQIE cq) { DatalogNormalizer.foldJoinTrees(cq); DatalogNormalizer.addMinimalEqualityToLeftJoin(cq); }
/*** * 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. */ public void addMinimalEqualityToLeftOrNestedInnerJoin(CQIE query) { for (Function f : query.getBody()) { if (f.isAlgebraFunction()) { addMinimalEqualityToLeftOrNestedInnerJoin(f); } } }
public static void pullOutLeftJoinConditions(CQIE query) { Set<Function> booleanAtoms = new HashSet<>(); Set<Function> tempBooleans = new HashSet<>(); List<Function> body = query.getBody(); pullOutLJCond(body, booleanAtoms, false, tempBooleans, false); body.addAll(booleanAtoms); }
public void foldJoinTrees(CQIE query) { foldJoinTrees(query.getBody(), false); }
public static void addMinimalEqualityToLeftJoin(CQIE query) { for (Function f : query.getBody()) { if (f.isAlgebraFunction()) { addMinimalEqualityToLeftJoin(f); } } }
nestedProblemVariables.addAll(getProblemVariablesForBranchN(currentLevelAtoms, focusBranch)); pullUpNestedReferences(terms, head, nestedProblemVariables, booleanConditions, freshVariableCount); saturateEqualities(booleanConditions);
Function currentAtom = (Function) body.get(i); if (currentAtom.getFunctionSymbol() == DatalogAlgebraOperatorPredicates.SPARQL_LEFTJOIN) unfoldJoinTrees(currentAtom.getTerms(), false); else if (currentAtom.getFunctionSymbol() == DatalogAlgebraOperatorPredicates.SPARQL_JOIN) { unfoldJoinTrees(currentAtom.getTerms(), true); int dataAtoms = countDataItems(currentAtom.getTerms()); if (isJoin || dataAtoms == 1) { body.remove(i);
/**** * 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; }
/*** * This method introduces new variable names in each data atom and * equalities to account for JOIN operations. This method is called before * generating SQL queries and allows to avoid cross refrences in nested * JOINs, which generate wrong ON or WHERE conditions. * * * @param query */ public static void pullOutEqualities(CQIE query) { Substitution substitutions = new SubstitutionImpl(); int[] newVarCounter = { 1 }; Set<Function> booleanAtoms = new HashSet<>(); List<Function> equalities = new LinkedList<>(); pullOutEqualities(query.getBody(), substitutions, equalities, newVarCounter, false); List<Function> body = query.getBody(); body.addAll(equalities); /* * All new variables have been generated, the substitutions also, we * need to apply them to the equality atoms and to the head of the * query. */ SubstitutionUtilities.applySubstitution(query, substitutions, false); }
/*** * This will * * @param query * @return */ public static void pullUpNestedReferences(CQIE query) { List<Function> body = query.getBody(); Function head = query.getHead(); /* * This set is only for reference */ Set<Variable> currentLevelVariables = new HashSet<>(); /* * This set will be modified in the process */ Set<Function> resultingBooleanConditions = new HashSet<>(); /* * Analyze each atom that is a Join or LeftJoin, the process will * replace everything needed. */ int[] freshVariableCount = { 0 }; pullUpNestedReferences(body, head, currentLevelVariables, resultingBooleanConditions, freshVariableCount); /* * Adding any remiding boolean conditions to the top level. */ for (Function condition : resultingBooleanConditions) body.add(condition); }
public static void foldJoinTrees(CQIE query) { foldJoinTrees(query.getBody(), false); }
/*** * 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); } }
TermUtils.addReferencedVariablesTo(currentLevelVariables, atom); } else if (atom.isAlgebraFunction()) { currentLevelVariables.addAll(getDefinedVariables(atom.getTerms())); } else {
pullOutEqualities(subterms, substitutions, eqList, newVarCounter, true); else pullOutEqualities(subterms, substitutions, eqList, newVarCounter, false);
DatalogNormalizer.foldJoinTrees(cq); DatalogNormalizer.addMinimalEqualityToLeftJoin(cq);
dataAtoms.add(atom); if (atom.getFunctionSymbol() == DatalogAlgebraOperatorPredicates.SPARQL_LEFTJOIN) foldJoinTrees(atom.getTerms(), false); if (atom.getFunctionSymbol() == DatalogAlgebraOperatorPredicates.SPARQL_JOIN) foldJoinTrees(atom.getTerms(), true);
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); } }
is2 = true; if (atom.getFunctionSymbol() == DatalogAlgebraOperatorPredicates.SPARQL_LEFTJOIN) pullOutLJCond(subterms, leftConditionBooleans, true, currentBooleans, is2); else pullOutLJCond(subterms, leftConditionBooleans, false, currentBooleans, is2);
dataAtoms.add(atom); if (atom.getFunctionSymbol().equals(datalogFactory.getSparqlLeftJoinPredicate())) foldJoinTrees(atom.getTerms(), false); if (atom.getFunctionSymbol().equals(datalogFactory.getSparqlJoinPredicate())) foldJoinTrees(atom.getTerms(), true);
datalogNormalizer.addMinimalEqualityToLeftOrNestedInnerJoin(cq);