"WHERE\n" + " { dbp:total dbo:thumbnail ?thumbnail }"); QueryUtils queryUtils = new QueryUtils(); System.out.println(queryUtils.extractOutgoingTriplePatterns(q, q.getProjectVars().get(0))); System.out.println(queryUtils.extractIncomingTriplePatterns(q, q.getProjectVars().get(0))); " }"); System.out.println(queryUtils.removeUnboundObjectVarTriples(q)); + "?o1 <http://dbpedia.org/ontology/timeZone> <http://dbpedia.org/resource/Eastern_Time_Zone> .}"; System.out.println(QueryUtils.getSubjectObjectJoinDepth(QueryFactory.create(query), Var.alloc("s"))); System.out.println(queryUtils.extractOutgoingTriplePatternsTrans(QueryFactory.create(query), Var.alloc("s")));
public Set<Triple> extractIncomingTriplePatternsTrans(Query query, Node node) { return Stream.concat(extractIncomingTriplePatterns(query, node).stream(), extractIncomingTriplePatterns(query, node).stream() .map(tp -> extractIncomingTriplePatternsTrans(query, tp.getSubject())) .flatMap(set -> set.stream())) .collect(Collectors.toSet()); }
public Set<Triple> extractTriplePattern(Query query){ return extractTriplePattern(query, false); }
/** * Returns all triple patterns in given SPARQL query that have the given node either in subject or in object position, i.e. * the ingoing and outgoing triple patterns. * @param query The SPARQL query. * @param node the node * @return */ public Set<Triple> extractTriplePatterns(Query query, Node node){ Set<Triple> triplePatterns = new HashSet<>(); triplePatterns.addAll(extractIncomingTriplePatterns(query, node)); triplePatterns.addAll(extractOutgoingTriplePatterns(query, node)); return triplePatterns; }
public Set<Triple> extractOutgoingTriplePatternsTrans(Query query, Node node) { return Stream.concat(extractOutgoingTriplePatterns(query, node).stream(), extractOutgoingTriplePatterns(query, node).stream() .map(tp -> extractOutgoingTriplePatternsTrans(query, tp.getObject())) .flatMap(set -> set.stream())) .collect(Collectors.toSet()); }
public static DirectedGraph<Node, LabeledEdge> asJGraphT(Query query) { QueryUtils utils = new QueryUtils(); Set<Triple> tps = utils.extractTriplePattern(query); DirectedGraph<Node, LabeledEdge> g = new DefaultDirectedGraph<>(LabeledEdge.class); tps.forEach(tp -> { g.addVertex(tp.getSubject()); g.addVertex(tp.getObject()); g.addEdge(tp.getSubject(), tp.getObject(), new LabeledEdge(tp.getSubject(), tp.getObject(), tp.getPredicate())); }); return g; }
private static void getOptimalCBDStructure(Query query, CBDStructureTree structureTree, Node current, Node parent, String direction) { QueryUtils utils = new QueryUtils(); Set<Triple> tmp = utils.extractOutgoingTriplePatterns(query, current) .stream() .filter(tp -> !direction.equals("in") || !tp.getObject().matches(parent)) .filter(tp -> tp.getObject().isVariable()) .map(Triple::getObject) .forEach(node -> getOptimalCBDStructure(query, outChild, node, current, "out")); tmp = utils.extractIncomingTriplePatterns(query, current) .stream() .filter(tp -> !direction.equals("out") || !tp.getSubject().matches(parent)) .filter(tp -> tp.getSubject().isVariable()) .map(Triple::getSubject) .forEach(node -> getOptimalCBDStructure(query, inChild, node, current, "in"));
public Query removeUnboundObjectVarTriples(Query query) { QueryUtils queryUtils = new QueryUtils(); Set<Triple> outgoingTriplePatterns = queryUtils.extractOutgoingTriplePatternsTrans(query, rootVar); Multimap<Var, Triple> var2OutgoingTriplePatterns = HashMultimap.create(); Set<Triple> incomingTriplePatterns = queryUtils.extractIncomingTriplePatternsTrans(query, rootVar); Multimap<Var, Triple> var2IncomingTriplePatterns = HashMultimap.create();
/** * @param query the query * @return all nodes that occur in triple patterns of the query */ public static Set<Node> getNodes(Query query) { return getTriplePatterns(query).stream() .map(QueryUtils::getNodes) .flatMap(Collection::stream) .collect(Collectors.toSet()); }
private static void dropIsomorphQueries(List<Query> queries) { for(Iterator<Query> it = queries.iterator(); it.hasNext();) { Query q1 = it.next(); Graph<Node, QueryUtils.LabeledEdge> g1 = QueryUtils.asJGraphT(q1); Set<Triple> tp1 = QueryUtils.getTriplePatterns(q1); Set<Node> nodes1 = tp1.stream().flatMap(tp -> getNodes(tp).stream()).filter(n -> !n.isVariable()).collect(Collectors.toSet()); if(!q1.equals(q2)) { Set<Triple> tp2 = QueryUtils.getTriplePatterns(q1); Set<Node> nodes2 = tp1.stream().flatMap(tp -> getNodes(tp).stream()).filter(n -> !n.isVariable()).collect(Collectors.toSet()); if(tp1.size() != tp2.size() || !nodes1.equals(nodes2) ) { Graph<Node, QueryUtils.LabeledEdge> g2 = QueryUtils.asJGraphT(q2);
NodeList questionNodes = doc.getElementsByTagName("question"); QueryUtils triplePatternExtractor = new QueryUtils(); Set<Triple> ingoingTriplePatterns = triplePatternExtractor.extractIncomingTriplePatterns(q, projectVars.get(0).asNode()); hasIngoingLinks = !ingoingTriplePatterns.isEmpty();
public static CBDStructureTree getOptimalCBDStructure(Query query) { CBDStructureTree tree = new CBDStructureTree("root"); Var var = query.getProjectVars().get(0); getOptimalCBDStructure(query, tree, var.asNode(), null, ""); return tree; }
/** * Returns triple patterns for each projection variable v such that v is in subject position. * @param query The SPARQL query. * @return */ public Map<Var,Set<Triple>> extractIncomingTriplePatternsForProjectionVars(Query query){ Map<Var,Set<Triple>> var2TriplePatterns = new HashMap<>(); for (Var var : query.getProjectVars()) { Set<Triple> triplePatterns = new HashSet<>(extractIncomingTriplePatterns(query, var)); var2TriplePatterns.put(var, triplePatterns); } return var2TriplePatterns; }
/** * Returns triple patterns for each projection variable v such that v is in subject position. * @param query The SPARQL query. * @return */ public Map<Var,Set<Triple>> extractOutgoingTriplePatternsForProjectionVars(Query query){ Map<Var,Set<Triple>> var2TriplePatterns = new HashMap<>(); for (Var var : query.getProjectVars()) { Set<Triple> triplePatterns = new HashSet<>(extractOutgoingTriplePatterns(query, var)); var2TriplePatterns.put(var, triplePatterns); } return var2TriplePatterns; }
private static boolean isConnected(Query query) { Graph<Node, QueryUtils.LabeledEdge> g = QueryUtils.asJGraphT(query); return GraphTests.isConnected(g); }
private List<String> filter(List<String> queries, int nrOfQueriesPerDepth) { List<String> subset = new ArrayList<>(); for(int depth = 1; depth <= maxTreeDepth; depth++) { List<String> tmp = new ArrayList<>(); Iterator<String> iterator = queries.iterator(); while(iterator.hasNext() && tmp.size() < nrOfQueriesPerDepth) { String queryString = iterator.next(); Query q = QueryFactory.create(queryString); int subjectObjectJoinDepth = QueryUtils.getSubjectObjectJoinDepth(q, q.getProjectVars().get(0)); if(subjectObjectJoinDepth == (depth - 1)) { tmp.add(queryString); } } subset.addAll(tmp); } return subset; }
Set<Triple> incomingTPs = queryUtils.extractOutgoingTriplePatternsTrans(query, targetVar.asNode());
NodeList questionNodes = doc.getElementsByTagName("question"); QueryUtils triplePatternExtractor = new QueryUtils();
Set<Triple> incomingTPs = queryUtils.extractIncomingTriplePatternsTrans(query, targetVar.asNode());
private Query removeUnboundObjectVarTriples(Query query) { QueryUtils queryUtils = new QueryUtils(); Set<Triple> triplePatterns = queryUtils.extractTriplePattern(query);