Java TripleMatch类代码示例

import com.hp.hpl.jena.graph.TripleMatch; //导入依赖的package包/类
@Override
protected ExtendedIterator<Triple> graphBaseFind(TripleMatch tm)
{
    try
    {
        // this is very odd behavior -- clean up a bit
        return context.find(
                tm.getMatchSubject() != null ? tm.getMatchSubject() : ((Triple)tm).getSubject(),
                tm.getMatchPredicate() != null ? tm.getMatchPredicate() : ((Triple)tm).getPredicate(),
                tm.getMatchObject() != null ? tm.getMatchObject() : ((Triple)tm).getObject());
    }
    catch (IOException e)
    {
        log.error("", e);
        throw new QueryException(e);
    }
}
 

import com.hp.hpl.jena.graph.TripleMatch; //导入依赖的package包/类
@Override
protected ExtendedIterator<Triple> graphBaseFind(final TripleMatch pattern) {
	try {
		final byte [][] identifiers = 
			(name == null)
				? dictionary.asIdentifiers(
						pattern.getMatchSubject(), 
						pattern.getMatchPredicate(), 
						pattern.getMatchObject())
				: dictionary.asIdentifiers(
						pattern.getMatchSubject(), 
						pattern.getMatchPredicate(), 
						pattern.getMatchObject(), 
						name);		
		return WrappedIterator.createNoRemove(dictionary.asTripleIterator(query(identifiers)));
	} catch (StorageLayerException exception) {
		LOGGER.error(MessageCatalog._00010_DATA_ACCESS_LAYER_FAILURE, exception);
		return EMPTY_TRIPLES_ITERATOR;
	}
}
 

import com.hp.hpl.jena.graph.TripleMatch; //导入依赖的package包/类
/**
 * Overloaded to reuse and update the cache.
 */
@Override
public ExtendedIterator<Triple> graphBaseFind(TripleMatch m) {
	List<Triple> cached = queryCache.get(m);
	if (cached != null) {
           return WrappedIterator.create(cached.iterator());
	}
	ExtendedIterator<Triple> it = super.graphBaseFind(m);
	final List<Triple> list = it.toList();
	queryCache.put(m, list);
	return WrappedIterator.create(list.iterator());
}
 

import com.hp.hpl.jena.graph.TripleMatch; //导入依赖的package包/类
@Override
public ExtendedIterator<Triple> graphBaseFind(TripleMatch m) {
	checkOpen();
	Triple t = m.asTriple();
	if (log.isDebugEnabled()) {
		log.debug("Find: " + PrettyPrinter.toString(t, getPrefixMapping()));
	}
	FindQuery query = new FindQuery(t, mapping.getTripleRelations(), 
			new ExecutionContext(mapping.getContext(), this, null, null));
	ExtendedIterator<Triple> result = TripleQueryIter.create(query.iterator());
	result = result.andThen(mapping.getAdditionalTriples().find(t));
	return result;
   }
 

import com.hp.hpl.jena.graph.TripleMatch; //导入依赖的package包/类
@Override
public ExtendedIterator<Triple> graphBaseFind(TripleMatch m) {
	checkOpen();
	Triple t = m.asTriple();
	if (log.isDebugEnabled()) {
		log.debug("Find: " + PrettyPrinter.toString(t, getPrefixMapping()));
	}
	FindQuery query = new FindQuery(t, mapping.compiledPropertyBridges(), null);
	ExtendedIterator<Triple> result = TripleQueryIter.create(query.iterator());
	if (mapping.configuration().getServeVocabulary()) {
		result = result.andThen(mapping.getVocabularyModel().getGraph().find(t));
	}
	return result;
   }
 

import com.hp.hpl.jena.graph.TripleMatch; //导入依赖的package包/类
@Override
public ExtendedIterator<Triple> graphBaseFind(final TripleMatch pattern) {
	try  {
		return WrappedIterator.createNoRemove(dao.query(pattern));
	} catch (StorageLayerException exception) {
		LOGGER.error(MessageCatalog._00010_DATA_ACCESS_LAYER_FAILURE, exception);
		return EMPTY_TRIPLES_ITERATOR;
	}
}
 

import com.hp.hpl.jena.graph.TripleMatch; //导入依赖的package包/类
@Override
protected ExtendedIterator graphBaseFind(TripleMatch m) {
  int length = 0;
  Node s = m.getMatchSubject();
  Node p = m.getMatchPredicate();
  Node o = m.getMatchObject();

  if (s == null || s.equals(Node.ANY)) {
    s = Node.createVariable("s");
    length++;
  }
  if (p == null || p.equals(Node.ANY)) {
    p = Node.createVariable("p");
    length++;
  }
  if (o == null || o.equals(Node.ANY)) {
    o = Node.createVariable("o");
    length++;
  }

  // Check not already a variable.
      
  Node[] variables = new Node[length];
  int i = 0;
      
  if (s.isVariable()) variables[i++] = s;  
  if (p.isVariable()) variables[i++] = p;
  if (o.isVariable()) variables[i++] = o;
      
  Triple t = new Triple(s,p,o) ;
  com.hp.hpl.jena.graph.query.Query graphQuery = new com.hp.hpl.jena.graph.query.Query();
  graphQuery.addMatch(t);
  BindingQueryPlan plan = queryHandler().prepareBindings(graphQuery, variables);
  ExtendedIterator iter = plan.executeBindings(); // Of domains
  return new AnswerBindingIterator(iter, variables, t);
}
 

import com.hp.hpl.jena.graph.TripleMatch; //导入依赖的package包/类
/**
 * @param  match       the Jena triple matcher
 * @return an RDF::Pattern instance
 */
public RubyObject newPattern(TripleMatch match) {
  return newTriple(
    newValue(match.getMatchSubject()),
    newValue(match.getMatchPredicate()),
    newValue(match.getMatchObject())
  );
}
 

import com.hp.hpl.jena.graph.TripleMatch; //导入依赖的package包/类
@Override
protected boolean removeEldestEntry(Map.Entry<TripleMatch,List<Triple>> eldest) {
    return size() > MAX_ENTRIES;
}
 

import com.hp.hpl.jena.graph.TripleMatch; //导入依赖的package包/类
@Override
	protected ExtendedIterator<Triple> graphBaseFind(TripleMatch m) {
		
		Node s = m.getMatchSubject() ;
		Var sVar = null ;
		if ( s == null )
		{
			sVar = Var.alloc("s") ;
			s = sVar ;
		}
		
		Node p = m.getMatchPredicate() ;
		Var pVar = null ;
		if ( p == null )
		{
			pVar = Var.alloc("p") ;
			p = pVar ;
		}
		
		Node o = m.getMatchObject() ;
		Var oVar = null ;
		if ( o == null )
		{
			oVar = Var.alloc("o") ;
			o = oVar ;
		}
		
		Triple triple = new Triple(s, p ,o) ;
		
		BasicPattern pattern = new BasicPattern() ;
		pattern.add(triple) ;
		ElementTriplesBlock element = new ElementTriplesBlock(pattern);
		Query query = new Query();
		query.setQuerySelectType(); 
		query.setQueryResultStar(true);
		query.setQueryPattern(element);
//		query.setDistinct(true);
		
		boolean resNotEmpty = true;
		query.setLimit(tripleSliceSize);
		long offsetCounter = 0;
		Set<Triple> triples = new HashSet<Triple>() ;
		while (resNotEmpty) {
			long offset = tripleSliceSize * offsetCounter++;
			query.setOffset(offset);
			QueryExecution qe = QueryExecutionFactory.sparqlService(serviceURI, query);
			logger.debug(query.serialize());
	
			ResultSet res = qe.execSelect();
			if (!res.hasNext()) resNotEmpty = false;
			
			while(res.hasNext()) {
				QuerySolution sol = res.nextSolution();
				Node subj;
				if (s.isVariable()) {
					subj = sol.get("s").asNode();
				} else {
					subj= s;
				}
				
				Node pred;
				if (p.isVariable()) {
					pred = sol.get("p").asNode();
				} else {
					pred = p;
				}
				
				Node obj;
				if (o.isVariable()) {
					obj = sol.get("o").asNode();
				} else {
					obj = o;
				}
				Triple resTriple = new Triple(subj, pred, obj);
				
				triples.add(resTriple);
			}
			qe.close();
		}
		return WrappedIterator.createNoRemove(triples.iterator()) ;
	}
 

import com.hp.hpl.jena.graph.TripleMatch; //导入依赖的package包/类
/**
 * Find the given triple(s) from the graph. 
 */
@Override
public ExtendedIterator<Triple> find(TripleMatch triple) {
	return find(triple.getMatchSubject(),triple.getMatchPredicate(), triple.getMatchObject());
}
 

import com.hp.hpl.jena.graph.TripleMatch; //导入依赖的package包/类
@Override
public ExtendedIterator<Triple> find(TripleMatch arg0) {
	// TODO Auto-generated method stub
	return null;
}
 

import com.hp.hpl.jena.graph.TripleMatch; //导入依赖的package包/类
@Override
public GraphDAO<Triple, TripleMatch> getGraphDAO(final Node name) {
	return new SolrGraphDAO(indexer, searcher, name, addCommitWithinMsecs, deleteCommitWithinMsecs);
}
 

import com.hp.hpl.jena.graph.TripleMatch; //导入依赖的package包/类
public RDFSimpleJoinBolt(String joinAttribute, TripleMatch attr, Fields outputFields) {
		this.outputFields = outputFields;
		this.joinAttribute = joinAttribute;
//		this.left = new ArrayList<Graph>();
//		this.right = new ArrayList<Graph>();
	}
 

import com.hp.hpl.jena.graph.TripleMatch; //导入依赖的package包/类
/** 
    Answer an ExtendedIterator returning all the triples from this store that
    match the pattern <code>m = (S, P, O)</code>.
    
    <p>Because the node-to-triples maps index on each of subject, predicate,
    and (non-literal) object, concrete S/P/O patterns can immediately select
    an appropriate map. Because the match for literals must be by sameValueAs,
    not equality, the optimisation is not applied for literals. [This is probably a
    Bad Thing for strings.]
    
    <p>Practice suggests doing the predicate test <i>last</i>, because there are
    "usually" many more statements than predicates, so the predicate doesn't
    cut down the search space very much. By "practice suggests" I mean that
    when the order went, accidentally, from S/O/P to S/P/O, performance on
    (ANY, P, O) searches on largish models with few predicates declined
    dramatically - specifically on the not-galen.owl ontology.
*/
public ExtendedIterator<Triple> find( TripleMatch tm )
    {
    Triple t = tm.asTriple();
    Node pm = t.getPredicate();
    Node om = t.getObject();
    Node sm = t.getSubject();
        
    if (sm.isConcrete())
        return new StoreTripleIterator( parent, subjects.iterator( sm, pm, om ), subjects, predicates, objects );
    else if (om.isConcrete())
        return new StoreTripleIterator( parent, objects.iterator( om, sm, pm ), objects, subjects, predicates );
    else if (pm.isConcrete())
        return new StoreTripleIterator( parent, predicates.iterator( pm, om, sm ), predicates, subjects, objects );
    else
        return new StoreTripleIterator( parent, subjects.iterateAll(), subjects, predicates, objects );
    }