private DistinctVariableOnlyDataAtom generateProjectionAtom(ImmutableSet<Variable> projectedVariables) { AtomPredicate newPredicate = ATOM_FACTORY.getAtomPredicate(DATALOG_FACTORY.getSubqueryPredicatePrefix() + ++subQueryCounter, projectedVariables.size()); return ATOM_FACTORY.getDistinctVariableOnlyDataAtom(newPredicate, ImmutableList.copyOf(projectedVariables)); }
private DataAtom<RelationPredicate> computeNewRightAtom(RelationPredicate predicate, ImmutableList<? extends VariableOrGroundTerm> rightArguments, ImmutableList<Integer> conflictingRightArgumentIndexes, VariableGenerator variableGenerator) { ImmutableList<VariableOrGroundTerm> newArguments = IntStream.range(0, rightArguments.size()) .boxed() .map(i -> conflictingRightArgumentIndexes.contains(i) ? variableGenerator.generateNewVariable() : rightArguments.get(i)) .collect(ImmutableCollectors.toList()); return atomFactory.getDataAtom(predicate, newArguments); }
private IntensionalDataNode getIDN(Variable formerVariable, Variable newVariable) { return iqFactory.createIntensionalDataNode( atomFactory.getIntensionalTripleAtom( newVariable, Ontop.CANONICAL_IRI, formerVariable )); }
private DistinctVariableOnlyDataAtom generateProjectionAtom(ImmutableSet<Variable> projectedVariables) { AtomPredicate newPredicate = datalogFactory.getSubqueryPredicate("" + ++subQueryCounter, projectedVariables.size()); return atomFactory.getDistinctVariableOnlyDataAtom(newPredicate, ImmutableList.copyOf(projectedVariables)); }
private ImmutableList<Function> getAtomsForGenerators(Collection<TreeWitnessGenerator> gens, Term r0) { return TreeWitnessGenerator.getMaximalBasicConcepts(gens, reasoner).stream() .map(con -> { log.debug(" BASIC CONCEPT: {}", con); if (con instanceof OClass) { return atomFactory.getMutableTripleBodyAtom(r0, ((OClass) con).getIRI()); } else if (con instanceof ObjectSomeValuesFrom) { ObjectPropertyExpression ope = ((ObjectSomeValuesFrom)con).getProperty(); return (!ope.isInverse()) ? atomFactory.getMutableTripleBodyAtom(r0, ope.getIRI(), getFreshVariable()) : atomFactory.getMutableTripleBodyAtom(getFreshVariable(), ope.getIRI(), r0); } else { DataPropertyExpression dpe = ((DataSomeValuesFrom)con).getProperty(); return atomFactory.getMutableTripleBodyAtom(r0, dpe.getIRI(), getFreshVariable()); } }) .collect(ImmutableCollectors.toList()); }
@Override protected AtomPredicate convertToAtomPredicate(Predicate originalPredicate, Map<Predicate, AtomPredicate> predicateCache) { if (originalPredicate instanceof AtomPredicate) { return (AtomPredicate) originalPredicate; } else if (predicateCache.containsKey(originalPredicate)) { return predicateCache.get(originalPredicate); } else { AtomPredicate atomPredicate = ATOM_FACTORY.getAtomPredicate(originalPredicate); // Cache it predicateCache.put(originalPredicate, atomPredicate); return atomPredicate; } }
public TMappingIndexEntry copyOf(IRI newPredicate) { TMappingIndexEntry copy = new TMappingIndexEntry(); for (TMappingRule rule : rules) { List<Term> headTerms = rule.getHeadTerms(); Function newHead = rule.isClass() ? atomFactory.getMutableTripleHeadAtom(headTerms.get(0), newPredicate) : atomFactory.getMutableTripleHeadAtom(headTerms.get(0), newPredicate, headTerms.get(2)); TMappingRule newRule = new TMappingRule(newHead, rule, datalogFactory, termFactory, eqNormalizer, rule.isClass()); copy.rules.add(newRule); } return copy; }
? atomFactory.getMutableTripleAtom(r0, a.getTerm(1), a.getTerm(2)) : atomFactory.getMutableTripleAtom(r0, a.getTerm(1), r0));
@Override public TargetAtom getTripleTargetAtom(ImmutableTerm subject, ImmutableTerm pred, ImmutableTerm object) { DistinctVariableOnlyDataAtom projectionAtom = atomFactory.getDistinctTripleAtom( (subject instanceof Variable) ? (Variable) subject : s, (pred instanceof Variable) && (!pred.equals(subject)) ? (Variable) pred : p, (object instanceof Variable) && (!object.equals(subject)) && (!object.equals(pred)) ? (Variable) object : o); ImmutableList<ImmutableTerm> initialTerms = ImmutableList.of(subject, pred, object); ImmutableSubstitution<ImmutableTerm> substitution = substitutionFactory.getSubstitution( IntStream.range(0, 3) .boxed() .map(i -> Maps.immutableEntry(projectionAtom.getTerm(i), initialTerms.get(i))) .filter(e -> !e.getKey().equals(e.getValue())) .collect(ImmutableCollectors.toMap())); return new TargetAtomImpl(projectionAtom, substitution); }
@Override public DistinctVariableDataAtom applyToDistinctVariableDataAtom(DistinctVariableDataAtom dataAtom) throws ConversionException { DataAtom newDataAtom = applyToDataAtom(dataAtom); if (newDataAtom instanceof DistinctVariableDataAtom) { return (DistinctVariableDataAtom) newDataAtom; } /** * Checks if new data atom can be converted into a DistinctVariableDataAtom */ if (newDataAtom.getArguments().size() == newDataAtom.getVariables().size()) { return ATOM_FACTORY.getDistinctVariableDataAtom(newDataAtom.getPredicate(), (ImmutableList<Variable>)newDataAtom.getArguments()); } else { throw new ConversionException("The substitution has transformed a DistinctVariableDataAtom into" + "a non-DistinctVariableDataAtom: " + newDataAtom); } }
/** * Renames the projected variables */ private DistinctVariableOnlyDataAtom transformProjectionAtom(DistinctVariableOnlyDataAtom atom) { ImmutableList<Variable> newArguments = atom.getArguments().stream() .map(renamingSubstitution::applyToVariable) .collect(ImmutableCollectors.toList()); return atomFactory.getDistinctVariableOnlyDataAtom(atom.getPredicate(), newArguments); }
@Override public void visit(SWRLObjectPropertyAtom node) { //we consider only namedOwlObjectProperty example not an object property expression such as inv(p) if(!node.getPredicate().isAnonymous()){ IRI propertyIRI = rdfFactory.createIRI(node.getPredicate().asOWLObjectProperty().toStringID()); terms = new ArrayList<Term>(); //get terms for datalog for(SWRLArgument argument: node.getAllArguments()){ argument.accept(this); } //TODO: check if it a head or a body function = atomFactory.getMutableTripleBodyAtom(terms.get(0), propertyIRI, terms.get(1)); } else{ notSupported=false; errors.add(node.toString()); } }
public static AtomPredicate createAtomPredicateFromRelation(RelationDefinition r) { return ATOM_FACTORY.getAtomPredicate(extractPredicateName(r), r.getAttributes().size()); }
List<Term> terms = childmapping.getHeadTerms(); Function newMappingHead = !childproperty.isInverse() ? atomFactory.getMutableTripleHeadAtom(terms.get(0), currentPredicate, terms.get(2)) : atomFactory.getMutableTripleHeadAtom(terms.get(2), currentPredicate, terms.get(0));
atom = atomFactory.getMutableTripleAtom(sTerm, pTerm, oTerm); atom = atomFactory.getMutableTripleAtom(sTerm, pTerm, oTerm); atom = atomFactory.getMutableTripleAtom(sTerm, pTerm, oTerm);
AtomPredicate atomPredicate = (datalogAtomPredicate instanceof AtomPredicate) ? (AtomPredicate) datalogAtomPredicate : ATOM_FACTORY.getAtomPredicate(datalogAtomPredicate); DistinctVariableOnlyDataAtom dataAtom = ATOM_FACTORY.getDistinctVariableOnlyDataAtom(atomPredicate, argListBuilder.build()); ImmutableSubstitution<ImmutableTerm> substitution = SUBSTITUTION_FACTORY.getSubstitution(bindingBuilder.build());
/** * Renames the projected variables */ @Override protected DistinctVariableOnlyDataAtom transformProjectionAtom(DistinctVariableOnlyDataAtom atom) { ImmutableList<Variable> newArguments = atom.getArguments().stream() .map(renamingSubstitution::applyToVariable) .collect(ImmutableCollectors.toList()); return ATOM_FACTORY.getDistinctVariableOnlyDataAtom(atom.getPredicate(), newArguments); } }
private DataAtom computeNewRightAtom(AtomPredicate predicate, ImmutableList<? extends VariableOrGroundTerm> rightArguments, ImmutableList<Integer> conflictingRightArgumentIndexes, VariableGenerator variableGenerator) { ImmutableList<VariableOrGroundTerm> newArguments = IntStream.range(0, rightArguments.size()) .boxed() .map(i -> conflictingRightArgumentIndexes.contains(i) ? variableGenerator.generateNewVariable() : rightArguments.get(i)) .collect(ImmutableCollectors.toList()); return ATOM_FACTORY.getDataAtom(predicate, newArguments); }
@Override public void visit(SWRLDataPropertyAtom node) { //we consider only namedOwlDataProperty if(!node.getPredicate().isAnonymous()){ //get predicate for datalog IRI propertyIRI = rdfFactory.createIRI(node.getPredicate().asOWLDataProperty().toStringID()); terms = new ArrayList<Term>(); //get terms for datalog for(SWRLArgument argument: node.getAllArguments()){ argument.accept(this); } //TODO: check if it a head or a body function = atomFactory.getMutableTripleBodyAtom(terms.get(0), propertyIRI, terms.get(1)); } else{ notSupported=false; errors.add(node.toString()); } }
private DataAtom<AtomPredicate> translate(ObjectPropertyExpression property, String x, String y) { Variable varX = termFactory.getVariable(x); Variable varY = termFactory.getVariable(y); if (property.isInverse()) return atomFactory.getIntensionalTripleAtom(varY, property.getIRI(), varX); else return atomFactory.getIntensionalTripleAtom(varX, property.getIRI(), varY); }