Java BindingSet類代碼示例

import org.openrdf.query.BindingSet; //導入依賴的package包/類
private QueryResult runQuery()
		throws IOException, QueryEvaluationException,
		       QueryResultParseException, TupleQueryResultHandlerException,
			   QueryResultHandlerException {
	TestResultHandler noninf = new TestResultHandler();
	TestResultHandler actual = new TestResultHandler();
	TestResultHandler expect = new TestResultHandler();
	parser.setQueryResultHandler(expect);
	parser.parseQueryResult(getResource(expected));
	nonInfQuery.evaluate(noninf);
	query.evaluate(actual);
	Multiset<BindingSet> noninfset = noninf.getSolutions();
	Multiset<BindingSet> expectset = expect.getSolutions();
	Multiset<BindingSet> actualset = actual.getSolutions();
	return new QueryResult(expectset, actualset, noninfset);
}
 

import org.openrdf.query.BindingSet; //導入依賴的package包/類
/**
 * Execute a SELECT SPARQL query against the graph
 * 
 * @param qs
 *            SELECT SPARQL query
 * @return list of solutions, each containing a hashmap of bindings
 */
public List runSPARQL(String qs) {
	try {
		RepositoryConnection con = therepository.getConnection();
		try {
			TupleQuery query = con.prepareTupleQuery(org.openrdf.query.QueryLanguage.SPARQL, qs);
			TupleQueryResult qres = query.evaluate();
			ArrayList reslist = new ArrayList();
			while (qres.hasNext()) {
				BindingSet b = qres.next();
				Set names = b.getBindingNames();
				HashMap hm = new HashMap();
				for (Object n : names) {
					hm.put((String) n, b.getValue((String) n));
				}
				reslist.add(hm);
			}
			return reslist;
		} finally {
			con.close();
		}
	} catch (Exception e) {
		e.printStackTrace();
	}
	return null;
}
 

import org.openrdf.query.BindingSet; //導入依賴的package包/類
/**
 * Binding set to vertex property (for Vertex elements).
 */
private final <V> Function<BindingSet, VertexProperty<V>> 
vertexProperty(final BlazeVertex v) {
    return bs -> {

        log.debug(() -> bs);
        final Literal val = (Literal) bs.getValue("val");
        final BigdataBNode sid = (BigdataBNode) bs.getValue("vp");
        final BigdataStatement stmt = sid.getStatement();
        final URI key = stmt.getPredicate();
        final String vpId = vertexPropertyId(stmt);
        final BlazeProperty<V> prop = 
                new BlazeProperty<>(BlazeGraph.this, v, key, val);
        final BlazeVertexProperty<V> bvp = 
                new BlazeVertexProperty<>(prop, vpId, sid);
        return bvp;

    };
}
 

import org.openrdf.query.BindingSet; //導入依賴的package包/類
/**
 * {@inheritDoc}
 * 
 * Logs the query at INFO and logs the optimized AST at TRACE.
 */
@Override
protected Stream<BindingSet> _select( 
        final String queryStr, final String extQueryId) {

    logQuery(queryStr);
    return Code.wrapThrow(() -> {
        final BigdataSailTupleQuery query = (BigdataSailTupleQuery) 
                cxn().prepareTupleQuery(QueryLanguage.SPARQL, queryStr);
        setMaxQueryTime(query);
        final UUID queryId = setupQuery(query.getASTContainer(), 
                                        QueryType.SELECT, extQueryId);
        
        sparqlLog.trace(() -> "optimized AST:\n"+query.optimize());
        
        /*
         * Result is closed automatically by GraphStreamer.
         */
        final TupleQueryResult result = query.evaluate();
        final Optional<Runnable> onClose = 
                Optional.of(() -> finalizeQuery(queryId));
        return new GraphStreamer<>(result, onClose).stream();
    });
    
}
 

import org.openrdf.query.BindingSet; //導入依賴的package包/類
@Override
public void handleTuple( BindingSet set, ValueFactory fac ) {
	URI pred = fac.createURI( set.getValue( "p" ).stringValue() );
	Value val = set.getValue( "o" );

	// for baseuri, we need the subject, not the object
	// and also, we use the VOID_DS as the key elsewhere in the code
	if ( RDF.TYPE.equals( pred ) ) {
		pred = SEMTOOL.Database;
		val = set.getValue( "db" );
	}
	else if ( pred.getNamespace().equals( DC.NAMESPACE ) ) {
		// silently handle the old DC namespace (ignore our DC-specific URIs)
		if ( !( MetadataConstants.DCT_CREATED.equals( pred )
				|| MetadataConstants.DCT_MODIFIED.equals( pred ) ) ) {
			pred = fac.createURI( DCTERMS.NAMESPACE, pred.getLocalName() );
		}
	}

	result.put( pred, val );
}
 

import org.openrdf.query.BindingSet; //導入依賴的package包/類
private Model rebuildConceptProps( List<URI> concepts ) {
	String cimplosion = Utility.implode( concepts );

	// now see what properties are on concepts and edges
	String query = "SELECT DISTINCT ?type ?prop WHERE {\n"
			+ "  ?s ?prop ?propval . FILTER ( isLiteral( ?propval ) )\n"
			+ "  ?s a|rdfs:subClassOf+ ?type .\n"
			+ "  FILTER ( ?prop != rdfs:label ) .\n"
			+ "} VALUES ?type { " + cimplosion + " }";

	ModelQueryAdapter mqa = new ModelQueryAdapter( query ) {

		@Override
		public void handleTuple( BindingSet set, ValueFactory fac ) {
			URI type = URI.class.cast( set.getValue( "type" ) );
			URI prop = URI.class.cast( set.getValue( "prop" ) );
			result.add( type, prop, Constants.ANYNODE );
		}
	};

	return engine.queryNoEx( mqa );
}
 

import org.openrdf.query.BindingSet; //導入依賴的package包/類
@Test
public void testSailStrategy() throws Exception {
    insertDataFile(Resources.getResource("data.ttl"), "http://example.org#");
    insertDataFile(Resources.getResource("university.ttl"), "http://example.org#");
    insertDataFile(Resources.getResource("owlrl.ttl"), "http://example.org#");
    Set<BindingSet> solutions = executeQuery(Resources.getResource("query.sparql"));
    Set<BindingSet> expected = new HashSet<>();
    Assert.assertEquals(expected, solutions);
    conf.setUseAggregationPipeline(false);
    ForwardChainSpinTool tool = new ForwardChainSpinTool();
    ToolRunner.run(conf, tool, new String[] {});
    solutions = executeQuery(Resources.getResource("query.sparql"));
    expected.add(new ListBindingSet(Arrays.asList("X", "Y"),
        VF.createURI(EX, "Alice"), VF.createURI(EX, "Department1")));
    Assert.assertEquals(expected, solutions);
    Assert.assertEquals(24, tool.getNumInferences());
}
 

import org.openrdf.query.BindingSet; //導入依賴的package包/類
@Override
    public CloseableIteration<BindingSet, QueryEvaluationException> evaluate(TupleExpr expr, BindingSet bindings) throws QueryEvaluationException {
        if (expr instanceof QueryRoot) {
            if (displayQueryPlan) {
//                System.out.println("Tables: ");
//                System.out.println("--SPO: \t" + RdfCloudTripleStoreConstants.TBL_SPO);
//                System.out.println("--PO: \t" + RdfCloudTripleStoreConstants.TBL_PO);
//                System.out.println("--OSP: \t" + RdfCloudTripleStoreConstants.TBL_OSP);
                logger.info("=================== Rya Query ===================");
                for (String str : expr.toString().split("\\r?\\n")) {
                    logger.info(str);
                }
                logger.info("================= End Rya Query =================");
            }
        }
        return super.evaluate(expr, bindings);
    }
 

import org.openrdf.query.BindingSet; //導入依賴的package包/類
private Set<BindingSet> getBindingSetsFromKafka(final String topicName) {
    KafkaConsumer<String, BindingSet> consumer = null;

    try {
        consumer = makeBindingSetConsumer(topicName);
        final ConsumerRecords<String, BindingSet> records = consumer.poll(20000);  // Wait up to 20 seconds for a result to be published.

        final Set<BindingSet> bindingSets = new HashSet<>();
        records.forEach(x -> bindingSets.add(x.value()));

        return bindingSets;

    } catch (final Exception e) {
        throw new RuntimeException(e);
    } finally {
        if (consumer != null) {
            consumer.close();
        }
    }
}
 

import org.openrdf.query.BindingSet; //導入依賴的package包/類
@Override
protected boolean accept(BindingSet bindings) throws QueryEvaluationException {
  try {
    // Limit the bindings to the ones that are in scope for this filter
    QueryBindingSet scopeBindings = new QueryBindingSet(bindings);

    // FIXME J1 scopeBindingNames should include bindings from superquery if the filter
    // is part of a subquery. This is a workaround: we should fix the settings of
    // scopeBindingNames,
    // rather than skipping the limiting of bindings.
    if (!(filter.getParentNode() instanceof SubQueryValueOperator)) {
      scopeBindings.retainAll(scopeBindingNames);
    }

    return strategy.isTrue(filter.getCondition(), scopeBindings);
  } catch (ValueExprEvaluationException e) {
    // failed to evaluate condition
    return false;
  }
}
 

import org.openrdf.query.BindingSet; //導入依賴的package包/類
/***
 * Prints the query results of result.
 * @param result
 * @throws QueryEvaluationException
 */
public static void printTupleQueryResult(TupleQueryResult result) throws QueryEvaluationException 
{
	while (result.hasNext()) 
	{ /*
									 * iterate over the result and print the
									 * bindings.
									 */
		BindingSet bindingSet = result.next();
		Value valueOfX = bindingSet.getValue("x");
		Value valueOfY = bindingSet.getValue("y");
		System.out.print("value of ?x " + valueOfX + " ++++++ ");
		System.out.println("value of ?y " + valueOfY);
	}
	
}
 

import org.openrdf.query.BindingSet; //導入依賴的package包/類
@SuppressWarnings("unchecked")
@Override
protected <T> Stream<T> doSparql(@Nullable final Long timeout, final Class<T> type,
        final String expression, final Set<URI> defaultGraphs, final Set<URI> namedGraphs)
        throws Exception {

    final String path = Protocol.PATH_SPARQL;
    final String query = query(//
            Protocol.PARAMETER_QUERY, expression, //
            Protocol.PARAMETER_DEFAULT_GRAPH, defaultGraphs, //
            Protocol.PARAMETER_NAMED_GRAPH, namedGraphs);
    GenericType<?> responseType;
    if (type == Statement.class) {
        responseType = Protocol.STREAM_OF_STATEMENTS;
    } else if (type == BindingSet.class) {
        responseType = Protocol.STREAM_OF_TUPLES;
    } else if (type == Boolean.class) {
        responseType = Protocol.STREAM_OF_BOOLEANS;
    } else {
        throw new Error("Unexpected result type: " + type);
    }
    return (Stream<T>) invoke(HttpMethod.GET, path, query, null, null, responseType,
            timeout);
}
 

import org.openrdf.query.BindingSet; //導入依賴的package包/類
@Override
void doEvaluate(final Session session, final BindingSet input,
        final MapBindingSet output) throws Throwable {

    final URI id = (URI) Statements.parseValue(this.id.instantiate(input),
            Namespaces.DEFAULT);

    long numTriples = 0L;
    try {
        final Stream<Record> stream = session.retrieve(this.layer).ids(id)
                .properties(this.properties).exec();
        numTriples = Record.encode(stream, ImmutableList.of(this.layer)).count();
        if (numTriples == 0) {
            LOGGER.warn("No results for LOOKUP request, layer "
                    + TestUtil.format(this.layer) + ", id " + id);
        }

    } catch (final Throwable ex) {
        throw new RuntimeException("Failed LOOKUP " + TestUtil.format(this.layer)
                + ", id " + TestUtil.format(id) + ", properties " + this.properties,
                ex);
    } finally {
        output.addBinding("size", FACTORY.createLiteral(numTriples));
    }
}
 

import org.openrdf.query.BindingSet; //導入依賴的package包/類
@Override
public String convert(final BindingSet bindingSet, final VariableOrder varOrder) {
    requireNonNull(bindingSet);
    requireNonNull(varOrder);

    // Convert each Binding to a String.
    final List<String> bindingStrings = new ArrayList<>();
    for(final String varName : varOrder) {
        if(bindingSet.hasBinding(varName)) {
            // Add a value to the binding set.
            final Value value = bindingSet.getBinding(varName).getValue();
            final RyaType ryaValue = RdfToRyaConversions.convertValue(value);
            final String bindingString = ryaValue.getData() + TYPE_DELIM + ryaValue.getDataType();
            bindingStrings.add(bindingString);
        } else {
            // Add a null value to the binding set.
            bindingStrings.add(NULL_VALUE_STRING);
        }
    }

    // Join the bindings using the binding delim.
    return Joiner.on(BINDING_DELIM).join(bindingStrings);
}
 

import org.openrdf.query.BindingSet; //導入依賴的package包/類
@Test
public void testMultiConstruct() throws Exception {
    // Insert data
    URI alice = VF.createURI("urn:Alice");
    URI bob = VF.createURI("urn:Bob");
    URI eve = VF.createURI("urn:Eve");
    URI friend = VF.createURI("urn:friend");
    URI knows = VF.createURI("urn:knows");
    URI person = VF.createURI("urn:Person");
    insert(alice, friend, bob);
    insert(bob, knows, eve);
    insert(eve, knows, alice);
    // Define query and expected results
    final String query = "CONSTRUCT {\n"
            + "    ?x rdf:type owl:Thing .\n"
            + "    ?x rdf:type <urn:Person> .\n"
            + "} WHERE { ?x <urn:knows> ?y }";
    final Multiset<BindingSet> expected = HashMultiset.create();
    List<String> varNames = Arrays.asList("subject", "predicate", "object");
    expected.add(new ListBindingSet(varNames, bob, RDF.TYPE, OWL.THING));
    expected.add(new ListBindingSet(varNames, bob, RDF.TYPE, person));
    expected.add(new ListBindingSet(varNames, eve, RDF.TYPE, OWL.THING));
    expected.add(new ListBindingSet(varNames, eve, RDF.TYPE, person));
    // Test query
    testPipelineQuery(query, expected);
}