private String extractPredicateIRI(IntermediateQuery mappingAssertion) { AtomPredicate projectionAtomPredicate = mappingAssertion.getProjectionAtom().getPredicate(); if (projectionAtomPredicate.equals(PredicateImpl.QUEST_TRIPLE_PRED)) throw new RuntimeException("TODO: extract the RDF predicate from a triple atom"); else return projectionAtomPredicate.getName(); }
@Override public Optional<IntermediateQuery> getDefinition(AtomPredicate predicate) { IntermediateQuery query = definitions.get(predicate); return query != null && query.getProjectionAtom().getPredicate().getArity() == predicate.getArity()? Optional.of(query): Optional.empty(); }
private Stream<IntermediateQuery> splitRootUnion(IntermediateQuery query) { QueryNode root = query.getRootNode(); return (root instanceof UnionNode)? query.getChildren(root).stream() .map(n -> query.getSubquery( n, query.getProjectionAtom() )): Stream.of(query); } }
@Override public String stringify(IntermediateQuery query) { return query.getProjectionAtom() + "\n" + stringifySubTree(query, query.getRootNode(), ""); }
@Override public String stringify(IntermediateQuery query) { return query.getProjectionAtom() + "\n" + stringifySubTree(query, query.getRootNode(), ""); }
private static boolean projectNullableVariable(IntermediateQuery query) { QueryNode rootNode = query.getRootNode(); return query.getProjectionAtom().getVariableStream() .anyMatch(v -> rootNode.isVariableNullable(query, v)); }
private void validateProjectedVariables(IntermediateQuery query) throws InvalidIntermediateQueryException { ImmutableSet<Variable> projectedVariables = query.getVariables(query.getRootNode()); if (!projectedVariables.equals(query.getProjectionAtom().getVariables())) { throw new InvalidIntermediateQueryException("The variables projected by the root node" + projectedVariables + " do not match the projection atom " + query.getProjectionAtom()); } } }
private void validateProjectedVariables(IntermediateQuery query) throws InvalidIntermediateQueryException { ImmutableSet<Variable> projectedVariables = query.getVariables(query.getRootNode()); if (!projectedVariables.equals(query.getProjectionAtom().getVariables())) { throw new InvalidIntermediateQueryException("The variables projected by the root node" + projectedVariables + " do not match the projection atom " + query.getProjectionAtom()); } } }
@Override public Mapping toRegularMapping() { ImmutableMultimap<AtomPredicate, IntermediateQuery> assertionMultimap = getMappingAssertions().stream() .collect(ImmutableCollectors.toMultimap( q -> q.getProjectionAtom().getPredicate(), q -> q)); ImmutableMap<AtomPredicate, IntermediateQuery> definitionMap = assertionMultimap.asMap().values().stream() .map(queryMerger::mergeDefinitions) .filter(Optional::isPresent) .map(Optional::get) .collect(ImmutableCollectors.toMap( q -> q.getProjectionAtom().getPredicate(), q -> q)); return specFactory.createMapping(mappingMetadata, definitionMap, executorRegistry); }
@Override public IQ convert(IntermediateQuery query) { IQTree tree = convertTree(query, query.getRootNode()); return iqFactory.createIQ(query.getProjectionAtom(), tree); }
private static void insertRootConstructionNode(IntermediateQuery query, QueryTreeComponent treeComponent, ImmutableSubstitution<? extends ImmutableTerm> propagatedSubstitution, IntermediateQueryFactory iqFactory) { ImmutableSet<Variable> projectedVariables = query.getProjectionAtom().getVariables(); ImmutableMap<Variable, ImmutableTerm> newSubstitutionMap = propagatedSubstitution.getImmutableMap().entrySet().stream() .filter(e -> projectedVariables.contains(e.getKey())) .collect(ImmutableCollectors.toMap( Map.Entry::getKey, e -> (ImmutableTerm) e.getValue())); ConstructionNode newRootNode = iqFactory.createConstructionNode(projectedVariables, SUBSTITUTION_FACTORY.getSubstitution(newSubstitutionMap)); treeComponent.insertParent(treeComponent.getRootNode(), newRootNode); }
@Override public IntermediateQuery transform(IntermediateQuery originalQuery) { DistinctVariableOnlyDataAtom transformedProjectionDataAtom = transformProjectionAtom(originalQuery.getProjectionAtom()); IntermediateQueryBuilder builder = convertToBuilderAndTransform(originalQuery, nodeTransformer, transformedProjectionDataAtom); return builder.build(); }
@Override public IntermediateQuery transform(IntermediateQuery originalQuery) { DistinctVariableOnlyDataAtom transformedProjectionDataAtom = transformProjectionAtom(originalQuery.getProjectionAtom()); IntermediateQueryBuilder builder = convertToBuilderAndTransform(originalQuery, nodeTransformer, transformedProjectionDataAtom); return builder.build(); }
@Override public IntermediateQuery optimize(IntermediateQuery query) { /* Contains all (non discarded) variables projected out by some node previously traversed, plus all variables appearing in an (explicit or implicit) condition of some join node already traversed Immutable only for safety (updated in practice). Question: shall we keep it as immutable ? */ return optimizeSubtree( query.getRootNode(), query, query.getProjectionAtom().getVariables()); }
@Override public IntermediateQuery transform(IntermediateQuery query) throws NotFilterableNullVariableException { QueryNode rootNode = query.getRootNode(); ImmutableList<Variable> nullableProjectedVariables = query.getProjectionAtom().getVariables().stream() .filter(v -> rootNode.isVariableNullable(query, v)) .collect(ImmutableCollectors.toList()); if (nullableProjectedVariables.isEmpty()) return query; ImmutableExpression filterCondition = extractFilteringCondition(query, rootNode, nullableProjectedVariables); return constructQuery(query, rootNode, filterCondition); }
@Override public IntermediateQuery transform(IntermediateQuery query) throws NotFilterableNullVariableException { QueryNode rootNode = query.getRootNode(); ImmutableList<Variable> nullableProjectedVariables = query.getProjectionAtom().getVariables().stream() .filter(v -> rootNode.isVariableNullable(query, v)) .collect(ImmutableCollectors.toList()); if (nullableProjectedVariables.isEmpty()) return query; ImmutableExpression filterCondition = extractFilteringCondition(query, rootNode, nullableProjectedVariables); return constructQuery(query, rootNode, filterCondition); }
private boolean isMandatoryRoot(ConstructionNode cn, IntermediateQuery query){ if(cn.equals(query.getRootNode())){ if(!query.getProjectionAtom().getVariables().equals( query.getVariables( query.getChildren(cn).iterator().next() ))){ return true; } } return false; }
@Override public Mapping normalize(Mapping mapping) { Stream<IntermediateQuery> queryStream = mapping.getPredicates().stream() .map(mapping::getDefinition) .filter(Optional::isPresent) .map(Optional::get); ImmutableMap<AtomPredicate, IntermediateQuery> normalizedMappingMap = renameQueries(queryStream) .collect(ImmutableCollectors.toMap( q -> q.getProjectionAtom().getPredicate(), q -> q )); return specificationFactory.createMapping(mapping.getMetadata(), normalizedMappingMap, mapping.getExecutorRegistry()); }
private IntermediateQuery liftUnionsAboveCn(IntermediateQuery query) { if(query.getChildren(query.getRootNode()).isEmpty()){ return query; } IntermediateQueryBuilder builder = iqFactory.createIQBuilder( query.getDBMetadata(), query.getExecutorRegistry() ); lift(builder, query.getRootNode(), Optional.empty(), query, query.getRootNode(), query.getProjectionAtom()); return builder.build(); }
@Override public IntermediateQuery enforceRootCn(IntermediateQuery query) { QueryNode root = query.getRootNode(); if(root instanceof ConstructionNode){ return query; } IntermediateQueryBuilder builder = iqFactory.createIQBuilder( query.getDBMetadata(), query.getExecutorRegistry() ); ConstructionNode rootCn = iqFactory.createConstructionNode(query.getVariables(root)); builder.init(query.getProjectionAtom(), rootCn); builder.addChild(rootCn, root); builder.appendSubtree(root, query); return builder.build(); }