public static Graph fetchData(QueryExecutionFactory qef, ResourceShape shape, Node node) { MappedConcept<Graph> mc = ResourceShape.createMappedConcept(shape, null, false); LookupService<Node, Graph> ls = LookupServiceUtils.createLookupService(qef, mc); Map<Node, Graph> map = ls.fetchMap(Collections.singleton(node)); // if(map.size() > 1) { // throw new RuntimeException("Should not happen"); // } Graph result = map.isEmpty() ? null : map.values().iterator().next(); return result; }
@Override public Flowable<Entry<K, V>> call() throws Exception { Flowable<Entry<K, V>> result = base.apply(keys); return result; } }
default List<V> fetchList(Iterable<K> keys) { List<V> result = requestList(keys).blockingGet(); return result; } }
default Map<K, V> fetchMap(Iterable<K> keys) { Map<K, V> result = requestMap(keys).blockingGet(); return result; }
LookupService<Node, Set<Triplet<Node, Node>>> s = lsls.mapValues((k, e) -> {
@Override public void apply(Model input) { QueryExecutionFactory qef = new QueryExecutionFactoryModel(input); List<Resource> resources = ServiceUtils.fetchListResources(qef, concept); Map<Resource, Model> extra = lookupService.fetchMap(resources); for(Entry<Resource, Model> entry : extra.entrySet()) { Model m = entry.getValue(); input.add(m); } } }
@Override public Flowable<Entry<K, O>> apply(Iterable<K> keys) { Flowable<Entry<K, I>> base = delegate.apply(keys); Flowable<Entry<K, O>> result = transform.apply(base); return result; } }
@Override public void apply(DatasetGraph input) { QueryExecutionFactory qef = new QueryExecutionFactoryDatasetGraph(input, false); List<Node> nodes = ServiceUtils.fetchList(qef, concept); Map<Node, DatasetGraph> extra = lookupService.fetchMap(nodes); for(Entry<Node, DatasetGraph> entry : extra.entrySet()) { DatasetGraph m = entry.getValue(); Iterator<Quad> it = m.find(); while(it.hasNext()) { Quad quad = it.next(); input.add(quad); } } } }
/** * Requests a map. * * The 'Single' result type can be seen as representing the request. * * @param keys * @return */ default Single<Map<K, V>> requestMap(Iterable<K> keys) { Single<Map<K, V>> result = apply(keys) .toMap(Entry::getKey, Entry::getValue); return result; }
public static void processHopQuery(HopQuery hopQuery, Collection<Node> sourceNodes, Map<Node, DatasetGraph> result, QueryExecutionFactory defaultQef, Multimap<Node, Node> back) { QueryExecutionFactory qef = hopQuery.getQef(); qef = (qef == null ? defaultQef : qef); MappedQuery<DatasetGraph> mappedQuery = hopQuery.getMappedQuery(); LookupService<Node, DatasetGraph> ls = LookupServiceUtils.createLookupService(qef, mappedQuery); ls = LookupServicePartition.create(ls, chunkSize); Map<Node, DatasetGraph> tmpMap = ls.fetchMap(sourceNodes); Map<Node, DatasetGraph> map; if(back != null) { map = new HashMap<Node, DatasetGraph>(); for(Entry<Node, DatasetGraph> entry : tmpMap.entrySet()) { Node tmpNode = entry.getKey(); DatasetGraph datasetGraph = entry.getValue(); Collection<Node> keys = back.get(tmpNode); for(Node key : keys) { map.put(key, datasetGraph); } } } else { map = tmpMap; } DatasetGraphUtils.mergeInPlace(result, map); }
@Override public Flowable<Entry<K, V>> apply(Iterable<K> t) { List<K> keys = Streams.stream(t) .filter(key -> filter.test(key)) .collect(Collectors.toList()); return delegate.apply(keys); } }
@Override public Flowable<Entry<K, W>> apply(Iterable<K> keys) { Flowable<Entry<K, V>> tmp = base.apply(keys); Flowable<Entry<K, W>> result = tmp.map(e-> Maps.immutableEntry(e.getKey(), fn.apply(e.getKey(), e.getValue()))); // Map<K, W> result = tmp.entrySet().stream() // .collect(Collectors.toMap( // e -> e.getKey(), // e -> fn.apply(e.getKey(), e.getValue()), // (u, v) -> { throw new IllegalStateException(String.format("Duplicate key %s", u)); }, // LinkedHashMap::new)); // // // //Maps.transformValues(tmp, GuavaFunctionWrapper.wrap(fn)); return result; }
@Override public Flowable<Entry<K, V>> apply(Iterable<K> keys) { Map<K, V> cachedEntries = cache.getAllPresent(keys); Set<K> remaining = Sets.difference(Sets.newHashSet(keys), cachedEntries.keySet()); Flowable<Entry<K, V>> result = Flowable .fromIterable(cachedEntries.entrySet()) .concatWith(base.apply(remaining)); return result; }
Map<Node, List<Node>> map = ls.fetchMap(sourceNodes);
@Override public Flowable<Entry<KI, V>> apply(Iterable<KI> keys) { Iterable<KO> kos = Iterables.transform(keys, to); Flowable<Entry<KO, V>> tmp = delegate.apply(kos); Flowable<Entry<KI, V>> result = tmp.map(entry -> { KI ki = from.apply(entry); V v = entry.getValue(); return Maps.immutableEntry(ki, v); }); // Map<KI, V> result = new LinkedHashMap<KI, V>(); // for(Entry<KO, V> entry : tmp.entrySet()) { // KI ki = from.apply(entry); // V v = entry.getValue(); // result.put(ki, v); // } return result; }
public static void main(String[] args) { QueryExecutionFactory sparqlService = new QueryExecutionFactoryHttp("http://dbpedia.org/sparql", "http://dbpedia.org"); Var var = Var.alloc("s"); Query query = QueryFactory.create("Prefix geo: <http://www.w3.org/2003/01/geo/wgs84_pos#> Prefix dbpo: <http://dbpedia.org/ontology/> Select ?s ?w { ?s a dbpo:Castle ; geo:geometry ?w }"); LookupService<Node, Table> ls = new LookupServiceSparqlQuery(sparqlService, query, var); ls = LookupServicePartition.create(ls, 1); ls = LookupServiceCacheMem.create(ls); List<Node> keys = new ArrayList<Node>(); keys.add(NodeFactory.createURI("http://dbpedia.org/resource/Marksburg")); keys.add(NodeFactory.createURI("http://dbpedia.org/resource/Rosenburg")); Map<Node, Table> map = ls.fetchMap(keys); System.out.println(map); } }
default Single<List<V>> requestList(Iterable<K> keys) { Single<List<V>> result = apply(keys) .map(Entry::getValue) .toList(); return result; }
public static Map<Node, RDFNode> fetch(Prologue prologue, SparqlService sparqlService, ShapeExposable shapeSupplier, Collection<Node> nodes) { //RdfType type = typeFactory.forJavaType(clazz); ResourceShapeBuilder builder = new ResourceShapeBuilder(prologue); shapeSupplier.exposeShape(builder); ResourceShape shape = builder.getResourceShape(); // TODO The lookup service should deal with empty concepts //Graph result; Map<Node, RDFNode> result; if(!shape.isEmpty()) { QueryExecutionFactory qef = sparqlService.getQueryExecutionFactory(); LookupService<Node, Graph> ls = MapServiceResourceShape.createLookupService(qef, shape); Map<Node, Graph> map = ls.fetchMap(nodes); result = map.entrySet().stream() .collect(Collectors.toMap( Entry::getKey, e -> { Model m = ModelFactory.createModelForGraph(e.getValue()); RDFNode r = ModelUtils.convertGraphNodeToRDFNode(e.getKey(), m); return r; })); } else { result = Collections.emptyMap(); } return result; }