import org.apache.jena.query.QuerySolutionMap; //导入依赖的package包/类
private void addDefaultMessages(ValidationEngine engine, Resource messageHolder, Resource fallback, Resource result, 
			QuerySolution bindings, QuerySolution solution) {
	boolean found = false;
	for(Statement s : messageHolder.listProperties(SH.message).toList()) {
		if(s.getObject().isLiteral()) {
			QuerySolutionMap map = new QuerySolutionMap();
			map.addAll(bindings);
			map.addAll(solution);
			engine.addResultMessage(result, s.getLiteral(), map);
			found = true;
		}
	}
	if(!found && fallback != null) {
		addDefaultMessages(engine, fallback, null, result, bindings, solution);
	}
}
 

import org.apache.jena.query.QuerySolutionMap; //导入依赖的package包/类
@Override
   protected List<RDFNode> getValueNodes(ValidationEngine validationEngine, Constraint constraint, QuerySolutionMap bindings, RDFNode focusNode) {
	SHConstraintComponent component = constraint.getComponent();
	Resource context = constraint.getContext();
	Resource validatorResource = component.getValidator(SH.JSValidator, context);
	if(SH.PropertyShape.equals(context)) {
		if(component.hasProperty(SH.propertyValidator, validatorResource)) {
			bindings.add("path", constraint.getShapeResource().getRequiredProperty(SH.path).getObject());
			List<RDFNode> valueNodes = new ArrayList<>();
			valueNodes.add(null);
			return valueNodes;
		}
		else {
			return validationEngine.getValueNodes(constraint, focusNode);
		}
	}
	else {
		bindings.add("value", focusNode);
		return Collections.singletonList(focusNode);
	}
}
 

import org.apache.jena.query.QuerySolutionMap; //导入依赖的package包/类
public static void addValueNodes(RDFNode focusNode, Resource path, Collection<RDFNode> results) {
	if(path.isURIResource()) {
		if(focusNode instanceof Resource) {
			StmtIterator it = focusNode.getModel().listStatements((Resource)focusNode, JenaUtil.asProperty(path), (RDFNode)null);
			while(it.hasNext()) {
				results.add(it.next().getObject());
			}
		}
	}
	else {
		String pathString = SHACLPaths.getPathString(path);
		String queryString = "SELECT DISTINCT ?value { $this " + pathString + " ?value }";
		Query query = ARQFactory.get().createQuery(path.getModel(), queryString);
		try(QueryExecution qexec = ARQFactory.get().createQueryExecution(query, focusNode.getModel())) {
			QuerySolutionMap qs = new QuerySolutionMap();
			qs.add("this", focusNode);
			qexec.setInitialBinding(qs);
			ResultSet rs = qexec.execSelect();
			while(rs.hasNext()) {
				results.add(rs.next().get("value"));
			}
		}
	}
}
 

import org.apache.jena.query.QuerySolutionMap; //导入依赖的package包/类
@Override
public void execute(RuleEngine ruleEngine, List<RDFNode> focusNodes, Shape shape) {
	ProgressMonitor monitor = ruleEngine.getProgressMonitor();
	for(RDFNode focusNode : focusNodes) {
		
		if(monitor != null && monitor.isCanceled()) {
			return;
		}

		QuerySolutionMap bindings = new QuerySolutionMap();
		bindings.add(SH.thisVar.getVarName(), focusNode);
		try(QueryExecution qexec = ARQFactory.get().createQueryExecution(query, ruleEngine.getDataset(), bindings)) {
			Model constructed = qexec.execConstruct();
			for(Statement s : constructed.listStatements().toList()) {
				ruleEngine.infer(s.asTriple(), this, shape);
			}
		}
	}
}
 

import org.apache.jena.query.QuerySolutionMap; //导入依赖的package包/类
public QuerySolutionMap getQuerySolutionMap()
{
    QuerySolutionMap qsm = new QuerySolutionMap();
    
    org.spinrdf.model.TemplateCall spinTemplateCall = SPINFactory.asTemplateCall(getTemplate().getQuery());
    if (spinTemplateCall != null)
    {
        qsm = spinTemplateCall.getInitialBinding();
        
        List<org.spinrdf.model.Argument> spinArgs = spinTemplateCall.getTemplate().getArguments(false);
        // add SPIN Arguments that match LDT Arguments (by predicate)
        for (org.spinrdf.model.Argument spinArg : spinArgs)
            if (getTemplate().getParameters().containsKey(spinArg.getPredicate()) && hasArgument(spinArg.getPredicate()))
            {
                Parameter param = getTemplate().getParameters().get(spinArg.getPredicate());
                qsm.add(param.getVarName(), getArgumentProperty(param.getPredicate()).getObject());
            }
    }
            
    return qsm;
}
 

import org.apache.jena.query.QuerySolutionMap; //导入依赖的package包/类
private static List<RDFNode> creatingAgentsFor(Resource r) {
	logger.fine("Finding creator of " + r);
	String queryStr = sparqlPrefixes + "SELECT ?agent WHERE { \n" + " { \n"
			+ "  ?r dct:creator [ \n" + "	    rdfs:member ?agent \n"
			+ "  ] \n" + " } UNION { \n" + "   ?r dct:creator ?agent .\n "
			+ "   FILTER NOT EXISTS { ?agent rdfs:member ?member } \n"
			+ " } \n" + "} \n";
	logger.finer(QueryFactory.create(queryStr).toString());
	QueryExecution qexec = QueryExecutionFactory.create(queryStr,
			r.getModel());
	QuerySolutionMap binding = new QuerySolutionMap();
	binding.add("r", r);
	qexec.setInitialBinding(binding);
	ResultSet select = qexec.execSelect();
	List<RDFNode> agents = new ArrayList<>();

	while (select.hasNext()) {
		RDFNode agent = select.next().get("agent");
		logger.fine("Found: " + agent);
		agents.add(agent);
	}
	return agents;
}
 

import org.apache.jena.query.QuerySolutionMap; //导入依赖的package包/类
private static Resource mboxForAgent(Resource agentResource) {
	logger.fine("Finding mbox of " + agentResource);
	String queryStr = sparqlPrefixes + "SELECT ?mbox WHERE { \n"
			+ "		{ ?agent foaf:mbox ?mbox } \n" + "	UNION  \n"
			+ "		{ ?agent vcard:hasEmail ?mbox } \n" + "	UNION  \n"
			+ "		{ ?agent vcard:email ?email .  \n"
			+ "       BIND(IRI(CONCAT(\"mbox:\", ?email)) AS ?mbox) \n" // legacy
			+ "	    } \n" + "} \n";
	logger.finer(QueryFactory.create(queryStr).toString());
	QueryExecution qexec = QueryExecutionFactory.create(queryStr,
			agentResource.getModel());
	QuerySolutionMap binding = new QuerySolutionMap();
	binding.add("agent", agentResource);
	qexec.setInitialBinding(binding);
	ResultSet select = qexec.execSelect();
	if (select.hasNext()) {
		Resource mbox = select.next().getResource("mbox");
		logger.fine("Found mbox: " + mbox);
		return mbox;
	}
	logger.fine("mbox not found");
	return null;
}
 

import org.apache.jena.query.QuerySolutionMap; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public final Model exec() {
    Dataset inputDataset = DatasetFactory.create();
    QuerySolution initialBindings = new QuerySolutionMap();
    Model initialModel = ModelFactory.createDefaultModel();
    StreamRDF outputStream = new StreamRDFModel(initialModel);
    exec(inputDataset, initialBindings, outputStream);
    return initialModel;
}
 

import org.apache.jena.query.QuerySolutionMap; //导入依赖的package包/类
/**
 * Turns a Binding into a QuerySolutionMap.
 * @param binding  the Binding to convert
 * @return a QuerySolutionMap
 */
public static QuerySolutionMap asQuerySolutionMap(Binding binding) {
	QuerySolutionMap map = new QuerySolutionMap();
	Iterator<Var> vars = binding.vars();
	while(vars.hasNext()) {
		Var var = vars.next();
		Node node = binding.get(var);
		if(node != null) {
			map.add(var.getName(), dummyModel.asRDFNode(node));
		}
	}
	return map;
}
 

import org.apache.jena.query.QuerySolutionMap; //导入依赖的package包/类
/**
 * Calls a given SPARQL function with two arguments.
 *
 * @param function  the URI resource of the function to call
 * @param argument1 the first argument
 * @param argument2 the second argument
 * @param dataset   the Dataset to operate on or null for default
 * @return the result of the function call
 */
public static Node invokeFunction2(Resource function, RDFNode argument1, RDFNode argument2, Dataset dataset) {
    final String expression = "<" + function + ">(?arg1, ?arg2)";
    QuerySolutionMap initialBinding = new QuerySolutionMap();
    if(argument1 != null) {
    	initialBinding.add("arg1", argument1);
    }
    if(argument2 != null) {
    	initialBinding.add("arg2", argument2);
    }
    return invokeExpression(expression, initialBinding, dataset);
}
 

import org.apache.jena.query.QuerySolutionMap; //导入依赖的package包/类
public static Node invokeFunction3(Resource function, RDFNode argument1, RDFNode argument2, RDFNode argument3, Dataset dataset) {
	
    final String expression = "<" + function + ">(?arg1, ?arg2, ?arg3)";
    QuerySolutionMap initialBinding = new QuerySolutionMap();
    initialBinding.add("arg1", argument1);
    if(argument2 != null) {
    	initialBinding.add("arg2", argument2);
    }
	if(argument3 != null) {
		initialBinding.add("arg3", argument3);
	}
    return invokeExpression(expression, initialBinding, dataset);
}
 

import org.apache.jena.query.QuerySolutionMap; //导入依赖的package包/类
@Override
public void addBindings(QuerySolutionMap bindings) {
	for(SHParameter arg : getParameterizable().getParameters()) {
		Statement s = getProperty(arg.getPredicate());
		if(s != null) {
			bindings.add(arg.getVarName(), s.getObject());
		}
	}
}
 

import org.apache.jena.query.QuerySolutionMap; //导入依赖的package包/类
private void executeSPARQL(RuleEngine ruleEngine, List<RDFNode> focusNodes, Shape shape) {
	String queryString = getSPARQL();
	Query query = ARQFactory.get().createQuery(ruleEngine.getDataset().getDefaultModel(), queryString);
	QuerySolutionMap binding = new QuerySolutionMap();
	for(RDFNode focusNode : focusNodes) {
		binding.add(SH.thisVar.getVarName(), focusNode);
		Model c;
		try ( QueryExecution qexec = ARQFactory.get().createQueryExecution(query, ruleEngine.getDataset(), binding) ) {
		    c = qexec.execConstruct();
		}
		for(Triple triple : c.getGraph().find(Node.ANY, Node.ANY, Node.ANY).toList()) {
		    ruleEngine.infer(triple, this, shape);
		}
	}
}
 

import org.apache.jena.query.QuerySolutionMap; //导入依赖的package包/类
/**
 * Gets any locally-defined label for a given property.
 * The labels are expected to be attached to shapes associated with a given
 * context resource (instance).
 * That context resource may for example be the subject of the current UI form.
 * @param property  the property to get the label of
 * @param context  the context instance
 * @return the local label or null if it should fall back to a global label
 */
public static String getLocalPropertyLabel(Resource property, Resource context) {
	QuerySolutionMap binding = new QuerySolutionMap();
	binding.add("arg1", property);
	binding.add("arg2", context);
	try(QueryExecution qexec = ARQFactory.get().createQueryExecution(propertyLabelQuery, property.getModel(), binding)) {
	    ResultSet rs = qexec.execSelect();
	    if(rs.hasNext()) {
	        return rs.next().get("label").asLiteral().getLexicalForm();
	    }
	}
	return null;
}
 

import org.apache.jena.query.QuerySolutionMap; //导入依赖的package包/类
@Test
public void testSelectQuery_withbinding() {

	markLogicDatasetGraph.clear();
	String file = datasource + "property-paths.ttl";
	RDFDataMgr.read(markLogicDatasetGraph, file);
	markLogicDatasetGraph.sync();
	dataSet = DatasetFactory.create(markLogicDatasetGraph);

	StringBuilder queryBuilder = new StringBuilder(128);
	queryBuilder.append(" prefix : <http://learningsparql.com/ns/papers#> ");
	queryBuilder.append(" prefix c: <http://learningsparql.com/ns/citations#>");
	queryBuilder.append(" SELECT ?s");
	queryBuilder.append(" WHERE {  ");
	queryBuilder.append(" ?s ^c:cites :paperK2 . ");
	queryBuilder.append(" FILTER (?s != :paperK2)");
	queryBuilder.append(" } ");
	queryBuilder.append(" ORDER BY ?s ");

	String query = queryBuilder.toString();
	QuerySolutionMap binding = new QuerySolutionMap();
	binding.add("whatcode", ResourceFactory.createPlainLiteral("33333"));
	QueryExecution queryExec = QueryExecutionFactory.create(query, dataSet, binding);

	ResultSet results = queryExec.execSelect();
	assertNotNull(results);
	assertTrue(results.hasNext());
	while (results.hasNext()) {
		QuerySolution qs = results.next();
		System.out.println(qs.toString());
		assertTrue(qs.contains("s"));
		String obtained = qs.get("s").asNode().getURI();
		System.out.println(obtained);
		assertTrue("Expecting subject node to be::http://learningsparql.com/ns/papers#paperJ ",
				qs.get("s").asNode().getURI().equals("http://learningsparql.com/ns/papers#paperJ"));
	}
}
 

import org.apache.jena.query.QuerySolutionMap; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public void exec(
        final Dataset inputDataset,
        final StreamRDF outputStream,
        final List<Var> variables,
        final List<BindingHashMapOverwrite> values,
        final BNodeMap bNodeMap) {
    values.forEach((binding) -> {
        BNodeMap bNodeMap2 = new BNodeMap(bNodeMap, binding);
        templateElementPlans.forEach((el) -> {
            if (el instanceof GenerateTriplesPlanImpl) {
                GenerateTriplesPlanImpl subPlanTriples
                        = (GenerateTriplesPlanImpl) el;
                subPlanTriples.exec(
                        inputDataset, outputStream,
                        binding, bNodeMap2);
            } else if (el instanceof RootPlanImpl) {
                RootPlanImpl rootPlan = (RootPlanImpl) el;
                QuerySolutionMap b = new QuerySolutionMap();
                binding.varsList().forEach((v) -> {
                    Node n = binding.get(v);
                    if (!(n == null)) {
                        if (bNodeMap.contains(n)) {
                            b.add(v.getVarName(), inputDataset
                                    .getDefaultModel()
                                    .asRDFNode(bNodeMap.get(n)));
                        } else {
                            b.add(v.getVarName(), inputDataset
                                    .getDefaultModel()
                                    .asRDFNode(n));
                        }
                    }
                });
                LOG.trace("Entering sub SPARQL-Generate with \n\t" + b);
                rootPlan.exec(inputDataset, b, outputStream, bNodeMap2);
            } else {
                throw new SPARQLGenerateException("should not reach this"
                        + " point");
            }
        });
    });
}
 

import org.apache.jena.query.QuerySolutionMap; //导入依赖的package包/类
@Override
public void executeConstraint(Constraint constraint, ValidationEngine engine, List<RDFNode> focusNodes) {
	
	QuerySolutionMap bindings = new QuerySolutionMap();
	addBindings(constraint, bindings);
	bindings.add(SH.currentShapeVar.getVarName(), constraint.getShapeResource());
	bindings.add(SH.shapesGraphVar.getVarName(), ResourceFactory.createResource(engine.getShapesGraphURI().toString()));
	
	Resource path = constraint.getShapeResource().getPath();
	if(path != null) {
		if(path.isAnon()) {
			String pathString = SHACLPaths.getPathString(JenaUtil.getResourceProperty(constraint.getShapeResource(), SH.path));
			query = SPARQLSubstitutions.substitutePaths(query, pathString, constraint.getShapeResource().getModel());
		}
		else {
			bindings.add(SH.PATHVar.getName(), path);
		}
	}
	
	URI oldShapesGraphURI = HasShapeFunction.getShapesGraph();
	HasShapeFunction.setShapesGraph(engine.getShapesGraphURI());
	
	Model oldNestedResults = HasShapeFunction.getResultsModel();
	Model nestedResults = JenaUtil.createMemoryModel();
	HasShapeFunction.setResultsModel(nestedResults);
	
	try {
		long startTime = System.currentTimeMillis();
		for(RDFNode focusNode : focusNodes) {
			bindings.add(SH.thisVar.getVarName(), focusNode); // Overwrite any previous binding
			QueryExecution qexec = SPARQLSubstitutions.createQueryExecution(query, engine.getDataset(), bindings);
			executeSelectQuery(engine, constraint, nestedResults, focusNode, qexec, bindings);
		}			
		if(ExecStatisticsManager.get().isRecording()) {
			long endTime = System.currentTimeMillis();
			long duration = endTime - startTime;
			String label = getLabel(constraint);
			Iterator<String> varNames = bindings.varNames();
			if(varNames.hasNext()) {
				queryString += "\nBindings:";
				while(varNames.hasNext()) {
					String varName = varNames.next();
					queryString += "\n- ?" + varName + ": " + bindings.get(varName);
				}
			}
			ExecStatistics stats = new ExecStatistics(label, queryString, duration, startTime, constraint.getComponent().asNode());
			ExecStatisticsManager.get().add(Collections.singletonList(stats));
		}
	}
	finally {
		HasShapeFunction.setShapesGraph(oldShapesGraphURI);
		HasShapeFunction.setResultsModel(oldNestedResults);
	}
}
 

import org.apache.jena.query.QuerySolutionMap; //导入依赖的package包/类
@Override
protected void addBindings(Constraint constraint, QuerySolutionMap bindings) {
	constraint.addBindings(bindings);
}
 

import org.apache.jena.query.QuerySolutionMap; //导入依赖的package包/类
@Override
protected void addBindings(Constraint constraint, QuerySolutionMap bindings) {
	// Do nothing
}
 

import org.apache.jena.query.QuerySolutionMap; //导入依赖的package包/类
@Override
public Iterable<RDFNode> executeTarget(Dataset dataset, Resource target,
		SHParameterizableTarget parameterizableTarget) {
	
	boolean nested = SHACLScriptEngineManager.begin();
	JSScriptEngine engine = SHACLScriptEngineManager.getCurrentEngine();

	SHJSExecutable as;
	if(parameterizableTarget != null) {
		as = parameterizableTarget.getParameterizable().as(SHJSExecutable.class);
	}
	else {
		as = target.as(SHJSExecutable.class);
	}
	Model model = dataset.getDefaultModel();
	JSGraph dataJSGraph = new JSGraph(model.getGraph(), engine);
	try {
		engine.executeLibraries(as);
		engine.put(SH.JS_DATA_VAR, dataJSGraph);
		
		QuerySolutionMap bindings = new QuerySolutionMap();
		if(parameterizableTarget != null) {
			parameterizableTarget.addBindings(bindings);
		}

		Object result = engine.invokeFunction(as.getFunctionName(), bindings);
		if(NashornUtil.isArray(result)) {
			List<RDFNode> results = new LinkedList<RDFNode>();
			for(Object obj : NashornUtil.asArray(result)) {
				Node node = JSFactory.getNode(obj);
				results.add(model.asRDFNode(node));
			}
			return results;
		}
	}
	catch(Exception ex) {
		ExceptionUtil.throwUnchecked(ex);
	}
	finally {
		dataJSGraph.close();
		SHACLScriptEngineManager.end(nested);
	}
	return Collections.emptyList();
}