@Override public IntermediateQuery optimize(IntermediateQuery query) { return reshape(query); }
/** * Lift substitutions and query modifiers, and get rid of resulting idle construction nodes. * Then flatten nested unions. */ private IntermediateQuery normalizeIQ(IntermediateQuery query) { try { IntermediateQuery queryAfterBindingLift = bindingLifter.optimize(query); IntermediateQuery queryAfterCNodeCleaning = constructionNodeCleaner.optimize(queryAfterBindingLift); return unionFlattener.optimize(queryAfterCNodeCleaning); }catch (EmptyQueryException e){ throw new IllegalStateException("The query should not be emptied by applying this normalization"); } } }
private IntermediateQuery normalizeIQ(IntermediateQuery intermediateQuery) { IntermediateQuery groundTermFreeQuery = new GroundTermRemovalFromDataNodeReshaper() .optimize(intermediateQuery); log.debug("New query after removing ground terms: \n" + groundTermFreeQuery); IntermediateQuery queryAfterPullOut = new PullOutVariableOptimizer().optimize(groundTermFreeQuery); log.debug("New query after pulling out equalities: \n" + queryAfterPullOut); return queryAfterPullOut; }
/** * Lift substitutions and query modifiers, and get rid of resulting idle construction nodes. * Then flatten nested unions, and enforce non-nullability */ @Override public IntermediateQuery normalize(IntermediateQuery query) { IntermediateQuery queryAfterUnionNormalization; try { IntermediateQuery queryAfterBindingLift = bindingLifter.optimize(query); IntermediateQuery queryAfterCNodeCleaning = constructionNodeCleaner.optimize(queryAfterBindingLift); queryAfterUnionNormalization = mappingUnionNormalizer.optimize(queryAfterCNodeCleaning); } catch (EmptyQueryException e) { throw new DatalogConversionException("The query should not become empty"); } return noNullValueEnforcer.transform(queryAfterUnionNormalization); } }
private IntermediateQuery flattenUnions(IntermediateQuery query) { try { return unionflattener.optimize(query); } catch (EmptyQueryException e) { throw new MappingUnionNormalizationException("This normalization should not empty the query"); } } }
private Stream<IntermediateQuery> lift(IntermediateQuery query) { try { return Stream.of(bindingLiftOptimizer.optimize(query)); } catch (EmptyQueryException e) { return Stream.empty(); } }
@Override public IntermediateQuery optimize(IntermediateQuery query) throws EmptyQueryException { UUID conversionVersion = UUID.randomUUID(); boolean converged; do { UUID oldVersionNumber; do { oldVersionNumber = query.getVersionNumber(); query = leftJoinOptimizer.optimize(query); log.debug("New query after left join optimization: \n" + query.toString()); query = joinOptimizer.optimize(query); log.debug("New query after join optimization: \n" + query.toString()); } while (oldVersionNumber != query.getVersionNumber()); converged = (conversionVersion == query.getVersionNumber()); if (!converged) { query = liftBinding(query); conversionVersion = query.getVersionNumber(); } } while (!converged); return query; }
private Optional<FlattenUnionProposal> evaluateUnionNode(UnionNode node, IntermediateQuery query) { ImmutableList<UnionNode> unionNodesToMerge = getUnionCluster(node, query) .collect(ImmutableCollectors.toList()); return unionNodesToMerge.size() > 1 ? Optional.of(makeFlattenProposal(node, unionNodesToMerge, query)) : Optional.empty(); }
@Override public IntermediateQuery optimize(IntermediateQuery query) throws EmptyQueryException { int oldVersionNumber; do { oldVersionNumber = query.getVersionNumber(); query = leftJoinOptimizer.optimize(query); log.debug("New query after left join optimization: \n" + query.toString()); query = joinOptimizer.optimize(query); log.debug("New query after join optimization: \n" + query.toString()); } while(oldVersionNumber != query.getVersionNumber()); return query; } }
@Override protected Optional<FlattenUnionProposal> evaluateNode(QueryNode node, IntermediateQuery query) { if (node instanceof UnionNode) { return evaluateUnionNode((UnionNode) node, query); } return Optional.empty(); }
private Stream<UnionNode> getUnionCluster(UnionNode focusNode, IntermediateQuery query) { return Stream.concat( Stream.of(focusNode), query.getChildren(focusNode).stream() .filter(n -> n instanceof UnionNode) .flatMap(n -> getUnionCluster((UnionNode) n, query) )); }
@Override public IntermediateQuery optimize(IntermediateQuery query) { try { return pullOutSomeVariables(query); } catch (EmptyQueryException e) { throw new IllegalStateException("Inconsistency: PullOutVariableOptimizer should not empty the query"); } }
@Override protected Optional<TrueNodeRemovalProposal> evaluateNode(QueryNode currentNode, IntermediateQuery currentQuery) { return Optional.of(currentNode). filter(n -> n instanceof TrueNode). map(n -> (TrueNode) n). filter(n -> isRemovableTrueNode(n, currentQuery)). map(TrueNodeRemovalProposalImpl::new); }
private IntermediateQuery reshape(IntermediateQuery query) { Optional<GroundTermRemovalFromDataNodeProposal> optionalProposal = makeProposal(query); if (optionalProposal.isPresent()) { GroundTermRemovalFromDataNodeProposal proposal = optionalProposal.get(); try { query.applyProposal(proposal); return query; } catch (EmptyQueryException e) { throw new IllegalStateException("Inconsistency: GroundTermRemovalFromDataNodeReshaper should empty the query "); } } else { return query; } }
@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 optimize(IntermediateQuery query) throws EmptyQueryException { IQ initialIQ = iqConverter.convert(query); IQ liftedIQ = optimizer.optimize(initialIQ); return iqConverter.convert(liftedIQ, query.getDBMetadata(), query.getExecutorRegistry()); } }
private IntermediateQuery normalizeIQ(IntermediateQuery intermediateQuery) { IntermediateQuery groundTermFreeQuery = new GroundTermRemovalFromDataNodeReshaper() .optimize(intermediateQuery); log.debug("New query after removing ground terms: \n" + groundTermFreeQuery); IntermediateQuery queryAfterPullOut = new PullOutVariableOptimizer().optimize(groundTermFreeQuery); log.debug("New query after pulling out equalities: \n" + queryAfterPullOut); return queryAfterPullOut; }
private Optional<FlattenUnionProposal> evaluateUnionNode(UnionNode node, IntermediateQuery query) { ImmutableList<UnionNode> unionNodesToMerge = getUnionCluster(node, query) .collect(ImmutableCollectors.toList()); return unionNodesToMerge.size() > 1 ? Optional.of(makeFlattenProposal(node, unionNodesToMerge, query)) : Optional.empty(); }
@Override protected Optional<FlattenUnionProposal> evaluateNode(QueryNode node, IntermediateQuery query) { if (node instanceof UnionNode) { return evaluateUnionNode((UnionNode) node, query); } return Optional.empty(); }
private Stream<UnionNode> getUnionCluster(UnionNode focusNode, IntermediateQuery query) { return Stream.concat( Stream.of(focusNode), query.getChildren(focusNode).stream() .filter(n -> n instanceof UnionNode) .flatMap(n -> getUnionCluster((UnionNode) n, query) )); }