@Override public Iterator<Tuple<NodeId>> find(NodeId... ids) { return nodeTupleTable.find(ids) ; }
Iterator<Tuple<NodeId>> iter = unionGraph ? SolverLib.unionGraph(ntt) : ntt.find(gnid, null, null, null) ; for ( ; iter.hasNext(); )
@Override public Iterator<Tuple<Node>> find(Node... nodes) { return nodeTupleTable.find(nodes) ; }
Iterator<Tuple<NodeId>> iter = unionGraph ? SolverLib.unionGraph(ntt) : ntt.find(gnid, null, null, null) ; for ( ; iter.hasNext(); )
@Override public Iterator<Tuple<NodeId>> find(Tuple<NodeId> tuple) { return nodeTupleTable.find(tuple) ; }
@Override public Iterator<Tuple<Node>> find(Node... nodes) { nodes = push(Node.class, prefix, nodes) ; return nodeTupleTable.find(nodes) ; }
@Override public Iterator<Tuple<NodeId>> find(NodeId... ids) { ids = push(NodeId.class, prefixId, ids) ; return nodeTupleTable.find(ids) ; }
@Override public Iterator<Tuple<NodeId>> find(Tuple<NodeId> ids) { NodeId[] ids2 = push(NodeId.class, prefixId, ids) ; return nodeTupleTable.find(ids2) ; }
@Override public Set<String> graphNames() { Iterator<Tuple<Node>> iter = nodeTupleTable.find((Node)null, null, null) ; Set <String> x = new HashSet<>() ; for ( ; iter.hasNext() ; ) x.add(iter.next().get(0).getURI()) ; Iter.close(iter) ; return x ; }
public static Iterator<Tuple<NodeId>> unionGraph(NodeTupleTable ntt) { Iterator<Tuple<NodeId>> iter = ntt.find((NodeId)null, null, null, null) ; iter = Iter.map(iter, quadsToAnyTriples) ; //iterMatches = Iter.distinct(iterMatches) ; // This depends on the way indexes are choose and // the indexing pattern. It assumes that the index // chosen ends in G so same triples are adjacent // in a union query. /// See TupleTable.scanAllIndex that ensures this. iter = Iter.distinctAdjacent(iter) ; return iter ; }
@Override public synchronized String readByURI(String graphName, String uriStr) { Node g = NodeFactory.createURI(graphName) ; Node u = NodeFactory.createURI(uriStr) ; Iterator<Tuple<Node>> iter = nodeTupleTable.find(g, null, u) ; if ( ! iter.hasNext() ) return null ; Node prefix = iter.next().get(1) ; Iter.close(iter) ; return prefix.getLiteralLexicalForm() ; }
@Override public synchronized String readPrefix(String graphName, String prefix) { Node g = NodeFactory.createURI(graphName) ; Node p = NodeFactory.createLiteral(prefix) ; Iterator<Tuple<Node>> iter = nodeTupleTable.find(g, p, null) ; try { if ( ! iter.hasNext() ) return null ; Tuple<Node> t = iter.next() ; Node uri = t.get(2) ; return uri.getURI() ; } finally { Iter.close(iter) ; } }
@Override public synchronized void loadPrefixMapping(String graphName, PrefixMapping pmap) { Node g = NodeFactory.createURI(graphName) ; Iterator<Tuple<Node>> iter = nodeTupleTable.find(g, null, null) ; for ( ; iter.hasNext() ; ) { Tuple<Node> t = iter.next(); String prefix = t.get(1).getLiteralLexicalForm() ; String uri = t.get(2).getURI() ; pmap.setNsPrefix(prefix, uri) ; } Iter.close(iter) ; }
@Override public synchronized Map<String, String> readPrefixMap(String graphName) { Map<String, String> map = new HashMap<>() ; // One class of problem from mangled databases // (non-transactional, not shutdown cleanly) // ends up with NPE access to the node table from // the prefix index. As prefixes are "nice extras", we // keep calm and carry on in the face of exceptions. Node g = NodeFactory.createURI(graphName) ; Iterator<Tuple<Node>> iter = nodeTupleTable.find(g, null, null) ; for ( ; iter.hasNext() ; ) { try { Tuple<Node> t = iter.next(); String prefix = t.get(1).getLiteralLexicalForm() ; String uri = t.get(2).getURI() ; map.put(prefix, uri) ; } catch (Exception ex) { Log.warn(this, "Mangled prefix map: graph name="+graphName, ex) ; } } Iter.close(iter) ; return map ; }
/** Remove by pattern */ private synchronized void removeAll(Node g, Node p, Node uri) { Iterator<Tuple<Node>> iter = nodeTupleTable.find(g, p, uri) ; List<Tuple<Node>> list = Iter.toList(iter) ; // Materialize. Iter.close(iter) ; for ( Tuple<Node> tuple : list ) nodeTupleTable.deleteRow(tuple.get(0), tuple.get(1), tuple.get(2)) ; }
/** Find whether a specific graph name is in the quads table. */ public static QueryIterator testForGraphName(DatasetGraphTDB ds, Node graphNode, QueryIterator input, Predicate<Tuple<NodeId>> filter, ExecutionContext execCxt) { NodeId nid = TDBInternal.getNodeId(ds, graphNode) ; boolean exists = !NodeId.isDoesNotExist(nid) ; if ( exists ) { // Node exists but is it used in the quad position? NodeTupleTable ntt = ds.getQuadTable().getNodeTupleTable() ; // Don't worry about abortable - this iterator should be fast // (with normal indexing - at least one G???). // Either it finds a starting point, or it doesn't. We are only // interested in the first .hasNext. Iterator<Tuple<NodeId>> iter1 = ntt.find(nid, NodeId.NodeIdAny, NodeId.NodeIdAny, NodeId.NodeIdAny) ; if ( filter != null ) iter1 = Iter.filter(iter1, filter) ; exists = iter1.hasNext() ; } if ( exists ) return input ; else { input.close() ; return QueryIterNullIterator.create(execCxt) ; } }
private StatsResults statsForGraph(NodeId gid) { Iterator<Tuple<NodeId>> iter = quads.find(gid, null, null, null) ; StatsCollectorNodeId stats = new StatsCollectorNodeId(nt) ; for ( ; iter.hasNext(); ) { Tuple<NodeId> t = iter.next() ; stats.record(t.get(0), t.get(1), t.get(2), t.get(3)) ; } return stats.results() ; }
private StatsResults statsForGraph(NodeId gid) { Iterator<Tuple<NodeId>> iter = quads.find(gid, null, null, null) ; StatsCollectorNodeId stats = new StatsCollectorNodeId(nt) ; for ( ; iter.hasNext(); ) { Tuple<NodeId> t = iter.next() ; stats.record(t.get(0), t.get(1), t.get(2), t.get(3)) ; } return stats.results() ; }
/** Find all the graph names in the quads table. */ public static QueryIterator graphNames(DatasetGraphTDB ds, Node graphNode, QueryIterator input, Predicate<Tuple<NodeId>> filter, ExecutionContext execCxt) { List<Abortable> killList = new ArrayList<>() ; Iterator<Tuple<NodeId>> iter1 = ds.getQuadTable().getNodeTupleTable().find(NodeId.NodeIdAny, NodeId.NodeIdAny, NodeId.NodeIdAny, NodeId.NodeIdAny) ; if ( filter != null ) iter1 = Iter.filter(iter1, filter) ; Iterator<NodeId> iter2 = Iter.map(iter1, (t) -> t.get(0)) ; iter2 = makeAbortable(iter2, killList) ; Iterator<NodeId> iter3 = Iter.distinct(iter2) ; iter3 = makeAbortable(iter3, killList) ; Iterator<Node> iter4 = NodeLib.nodes(ds.getQuadTable().getNodeTupleTable().getNodeTable(), iter3) ; final Var var = Var.alloc(graphNode) ; Iterator<Binding> iterBinding = Iter.map(iter4, node -> BindingFactory.binding(var, node)) ; // Not abortable. return new QueryIterTDB(iterBinding, killList, input, execCxt) ; }
return Iter.nullIterator() ; Iterator<Tuple<NodeId>> iterMatches = nodeTupleTable.find(asTuple(ids)) ;