import org.apache.jena.query.DatasetFactory; //导入依赖的package包/类
@Before
public void init() throws Exception {

    // For some reason, this is necessary after upgrating to Camel 2.19.
    // Otherwise, it looks like the context doesn't start(!??)
    context.start();
    dataset = DatasetFactory.create();

    // Create two named graphs with triples. Verify that they're non-empty from the start.
    final Model a = ModelFactory.createDefaultModel();
    final Model b = ModelFactory.createDefaultModel();

    a.add(a.getResource("test:something"), a.getProperty("test:prop"), a.getResource("test:whatever"));
    b.add(b.getResource("test:somethingElse"), b.getProperty("test:prop"), b.getResource("test:whatever"));

    dataset.addNamedModel("test:unaffected", a);
    dataset.addNamedModel(SERVICE_DOC_URI, b);
}
 

import org.apache.jena.query.DatasetFactory; //导入依赖的package包/类
public static void main(String ...args) {
    // -- Base dataset 
    DatasetGraph dsgBase = DatasetGraphFactory.createTxnMem();

    // -- Destination for changes.
    // Text form of output.  
    OutputStream out = System.out;
    // Create an RDFChanges that writes to "out".
    RDFChanges changeLog = RDFPatchOps.textWriter(out);

    // Combined datasetgraph and changes. 
    DatasetGraph dsg = RDFPatchOps.changes(dsgBase, changeLog);

    // Wrap in the Dataset API
    Dataset ds = DatasetFactory.wrap(dsg);

    // --------
    // Do something. Read in data.ttl inside a transaction.
    // (data.ttl is in src/main/resources/)
    Txn.executeWrite(ds,
        ()->RDFDataMgr.read(dsg, "data.ttl")
        );
}
 

import org.apache.jena.query.DatasetFactory; //导入依赖的package包/类
@Test
public void testRulesets() {
    MarkLogicDatasetGraph infTestDsg = getMarkLogicDatasetGraph();
    Dataset ds = DatasetFactory.wrap(infTestDsg);
    String query = "prefix : <http://example.org/> select ?o where { :r3 a ?o }";
    QueryExecution exec = QueryExecutionFactory.create(query, ds);
    ResultSet results = exec.execSelect();

    List<String> subjects = project(results, "o");
    assertEquals("No inference, got back list of size 1", 1,
            subjects.size());

    infTestDsg.withRulesets(SPARQLRuleset.RDFS);
    // MarkLogicQuery inferringQuery = MarkLogicQuery.create(query);
    // inferringQuery.setRulesets(SPARQLRuleset.RDFS);
    exec = QueryExecutionFactory.create(query, ds);
    results = exec.execSelect();
    subjects = project(results, "o");
    System.out.println(subjects);
    assertEquals("Using RDFs got back two class assertions", 2,
            subjects.size());

}
 

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

    MarkLogicDatasetGraph baseTest = getMarkLogicDatasetGraph();
    Dataset ds = DatasetFactory.wrap(baseTest);
    String query = "select ?o where { <r3> a ?o }";
    QueryExecution exec = QueryExecutionFactory.create(query, ds);
    ResultSet results = exec.execSelect();
    List<String> subjects = project(results, "o");
    assertEquals("No base, got back list of size 0", 0, subjects.size());

    Query q = QueryFactory.create(query, "http://example.org/");
    exec = QueryExecutionFactory.create(q, ds);
    results = exec.execSelect();
    subjects = project(results, "o");
    assertEquals("No base, got back list of size 1", 1, subjects.size());

}
 

import org.apache.jena.query.DatasetFactory; //导入依赖的package包/类
@Test
public void testUpdateAction() {
    DatasetGraph gs = getMarkLogicDatasetGraph();
    UpdateRequest update = new UpdateRequest();
    update.add("INSERT DATA { <s2> <p1> <o1> }");
    update.add("DROP ALL")
            .add("CREATE GRAPH <http://example/update1>")
            .add("BASE <http://example.org/> INSERT DATA { GRAPH <http://example.org/update2> { <s1> <p1> <o1>  } }")
            .add("BASE <http://example.org/> INSERT DATA { GRAPH <http://example.org/update3> { <s1> <p1> <o1>  } }");

    UpdateAction.execute(update, gs);

    QueryExecution askQuery = QueryExecutionFactory
            .create("BASE <http://example.org/> ASK WHERE { GRAPH <update3> { <s1> <p1> <o1>  }}",
                    DatasetFactory.wrap(gs));
    assertTrue("update action must update database.", askQuery.execAsk());

}
 

import org.apache.jena.query.DatasetFactory; //导入依赖的package包/类
@Test
public void testStringAskQuery() {
	String file = datasource + "tigers.ttl";
	// Read triples into dataset
	RDFDataMgr.read(markLogicDatasetGraph, file);
	markLogicDatasetGraph.sync();
	dataSet = DatasetFactory.create(markLogicDatasetGraph);

	String query1 = "PREFIX  bb: <http://marklogic.com/baseball/players#>" + " ASK " + " WHERE" + " {" + " ?id bb:lastname  ?name ."
			+ " FILTER  EXISTS { ?id bb:country ?countryname }" + " }";
	QueryExecution queryExec = QueryExecutionFactory.create(query1, dataSet);
	Boolean result = queryExec.execAsk();
	assertFalse(result);

	String query2 = "PREFIX  bb: <http://marklogic.com/baseball/players#>" + "PREFIX  r: <http://marklogic.com/baseball/rules#>"
			+ " ASK WHERE" + " {" + " ?id bb:team r:Tigers." + " ?id bb:position \"pitcher\"." + " }";
	queryExec = QueryExecutionFactory.create(query2, dataSet);
	assertTrue(queryExec.execAsk());
	markLogicDatasetGraph.close();
	markLogicDatasetGraph = MarkLogicDatasetGraphFactory.createDatasetGraph(writerClient);

}
 

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

	String file = datasource + "tigers.ttl";
	// Read triples into dataset
	RDFDataMgr.read(markLogicDatasetGraph, file);
	markLogicDatasetGraph.sync();
	Graph g = markLogicDatasetGraph.getDefaultGraph();
	Node newgraph = NodeFactory.createURI("http://marklogic.com/Graph1");
	markLogicDatasetGraph.addGraph(newgraph, g);
	dataSet = DatasetFactory.create(markLogicDatasetGraph);

	String query1 = "ASK FROM <http://marklogic.com/Graph1>" + " WHERE" + " {" + " ?player ?team <#Tigers>." + " }";
	QueryExecution queryExec = QueryExecutionFactory.create(query1, dataSet);
	Boolean result = queryExec.execAsk();
	assertFalse(result);

	String query2 = "PREFIX  bb: <http://marklogic.com/baseball/players#>" + "PREFIX  r: <http://marklogic.com/baseball/rules#>"
			+ " ASK WHERE" + " {" + " ?id bb:team r:Tigers." + " ?id bb:position \"pitcher\"." + " }";
	queryExec = QueryExecutionFactory.create(query2, dataSet);
	assertTrue(queryExec.execAsk());

}
 

import org.apache.jena.query.DatasetFactory; //导入依赖的package包/类
public static void main(String...argv)
{
    Dataset ds = null ;
    
    // Read a TriG file into quad storage in-memory.
    ds = RDFDataMgr.loadDataset("data.trig") ;
    
    // read some (more) data into a dataset graph.
    RDFDataMgr.read(ds, "data2.trig") ;
    
    // Create a dataset,
    Dataset ds2 = DatasetFactory.createTxnMem() ;
    // read in data, indicating the syntax in case the remote end does not
    // correctly provide the HTTP content type.
    RDFDataMgr.read(ds2, "http://host/data2.unknown", TRIG) ;
}
 

import org.apache.jena.query.DatasetFactory; //导入依赖的package包/类
public static void main(String []args)
{
    // Create an empty GraphStore (has an empty default graph and no named graphs) 
    Dataset dataset = DatasetFactory.createTxnMem() ;
    
    // ---- Read and update script in one step.
    UpdateAction.readExecute("update.ru", dataset) ;
    
    // ---- Reset.
    UpdateAction.parseExecute("DROP ALL", dataset) ;
    
    // ---- Read the update script, then execute, in separate two steps
    UpdateRequest request = UpdateFactory.read("update.ru") ;
    UpdateAction.execute(request, dataset) ;

    // Write in debug format.
    System.out.println("# Debug format");
    SSE.write(dataset) ;
    
    System.out.println();
    
    System.out.println("# N-Quads: S P O G") ;
    RDFDataMgr.write(System.out, dataset, Lang.NQUADS) ;
}
 

import org.apache.jena.query.DatasetFactory; //导入依赖的package包/类
public static void main(String []args)
{
    Dataset dataset = DatasetFactory.createTxnMem() ;
    
    UpdateRequest request = UpdateFactory.create() ;
    
    request.add(new UpdateDrop(Target.ALL)) ;
    request.add(new UpdateCreate("http://example/g2")) ;
    request.add(new UpdateLoad("file:etc/update-data.ttl", "http://example/g2")) ;
    UpdateAction.execute(request, dataset) ;
    
    System.out.println("# Debug format");
    SSE.write(dataset) ;
    
    System.out.println();
    
    System.out.println("# N-Quads: S P O G") ;
    RDFDataMgr.write(System.out, dataset, Lang.NQUADS) ;
}
 

import org.apache.jena.query.DatasetFactory; //导入依赖的package包/类
@Before
public void setUp() {
    Model defaultModel = ModelFactory.createDefaultModel();
    defaultModel.add(
            ResourceFactory.createResource("http://rdfunit.aksw.org"),
            OWL.sameAs,
            ResourceFactory.createResource("http://dbpedia.org/resource/Cool")
    );

    Model namedModel = ModelFactory.createDefaultModel();
    namedModel.add(
            ResourceFactory.createResource("http://rdfunit.aksw.org"),
            OWL.sameAs,
            ResourceFactory.createResource("http://dbpedia.org/resource/Super")
    );
    dataset = DatasetFactory.create(defaultModel);

    dataset.addNamedModel("http://rdfunit.aksw.org", namedModel);
}
 

import org.apache.jena.query.DatasetFactory; //导入依赖的package包/类
@Override
public void process(ProcessingContext<Corpus> ctx, Corpus corpus) throws ModuleException {
	RDFExportResolvedObjects resObj = getResolvedObjects();
	Logger logger = getLogger(ctx);
	EvaluationContext evalCtx = new EvaluationContext(logger);

	int count = 0;
	for (Element elt : Iterators.loop(resObj.files.evaluateElements(evalCtx, corpus))) {
		fillModel(ctx, evalCtx, elt);
		count += resObj.model.size();
		String fn = resObj.fileName.evaluateString(evalCtx, elt);
		OutputFile f = new OutputFile(outDir, fn);
		TargetStream ts = new FileTargetStream(charset, f);
		try (OutputStream out = ts.getOutputStream()) {
			writeModel(ctx, out, resObj.model);
			resObj.model.removeAll();
		}
		catch (IOException e) {
			resObj.model.close();
			rethrow(e);
		}
	}
	logger.info("wrote " + count + " statements");
	if (startServer) {
		Dataset ds = DatasetFactory.assemble(resObj.model);
		FusekiEmbeddedServer server = FusekiEmbeddedServer.create().add("alvisnlp", ds).build();
		server.start();
	}
}
 

import org.apache.jena.query.DatasetFactory; //导入依赖的package包/类
/**
 * ServiceNodeWriter.
 *
 * @param serviceURI       String
 * @param servicePredicate String
 * @param serviceType      String
 */
ServiceNodeWriter(final String serviceURI, final String servicePredicate,
                  final String serviceType) {
    final Model model = ModelFactory.createDefaultModel();
    final Resource s = model.createResource(getIdentitySubject());
    final Property p = model.createProperty(servicePredicate);
    final Resource o = model.createResource(serviceURI);
    model.add(s, p, o);

    final Dataset dataset = DatasetFactory.create(model);
    dataset.addNamedModel("http://iiif.service", model);
    this.serviceNode = new ByteArrayOutputStream();
    RDFDataMgr.write(this.serviceNode, model, Lang.NTRIPLES);
}
 

import org.apache.jena.query.DatasetFactory; //导入依赖的package包/类
private Model createExpModelForChallengeTask(Model model, String challengeTaskUri, String systemUri) {
    Dataset dataset = DatasetFactory.create();
    dataset.addNamedModel("http://temp.org/challenge", model);
    String query = SparqlQueries.getCreateExperimentFromTaskQuery(Constants.NEW_EXPERIMENT_URI, challengeTaskUri,
            systemUri, "http://temp.org/challenge");
    if (query == null) {
        LOGGER.error("Couldn't load SPARQL query to create an RDF model for a new experiment. Returning null.");
        return null;
    }
    QueryExecution qe = QueryExecutionFactory.create(query, dataset);
    return qe.execConstruct();
}
 

import org.apache.jena.query.DatasetFactory; //导入依赖的package包/类
public DummyStorage(String configGraphFile, String privateGraphFile, String publicGraphFile) {
    super(null);
    dataset = DatasetFactory.create();
    Model model = configGraphFile != null ? loadModel(configGraphFile) : ModelFactory.createDefaultModel();
    dataset.addNamedModel(Constants.CHALLENGE_DEFINITION_GRAPH_URI, model);
    model = privateGraphFile != null ? loadModel(privateGraphFile) : ModelFactory.createDefaultModel();
    dataset.addNamedModel(Constants.PRIVATE_RESULT_GRAPH_URI, model);
    model = publicGraphFile != null ? loadModel(publicGraphFile) : ModelFactory.createDefaultModel();
    dataset.addNamedModel(Constants.PUBLIC_RESULT_GRAPH_URI, model);
}
 

import org.apache.jena.query.DatasetFactory; //导入依赖的package包/类
public static void main(String ...args) {
    // -- Base dataset 
    DatasetGraph dsgBase = DatasetGraphFactory.createTxnMem();

    // -- Destination for changes.
    // Text form of output.  
    OutputStream out = System.out;
    // Create an RDFChanges that writes to "out".
    RDFChanges changeLog = RDFPatchOps.textWriter(out);


    // ---- Collect up changes. 
    //RDFPatchOps.collect();
    RDFChangesCollector rcc = new RDFChangesCollector();
    DatasetGraph dsg = RDFPatchOps.changes(dsgBase, rcc);
    Dataset ds = DatasetFactory.wrap(dsg);
    Txn.executeWrite(ds,
                     ()->RDFDataMgr.read(dsg, "data.ttl")
                     );
    // Again - different bnodes.
    // Note all changes are recorded - even if they have no effect
    // (e.g the prefix, the triple "ex:s ex:p ex:o").
    Txn.executeWrite(ds,
                     ()->RDFDataMgr.read(dsg, "data.ttl")
                     );
    
    // Collected (in-memory) patch.
    RDFPatch patch = rcc.getRDFPatch();
    // Write it.
    patch.apply(changeLog);
}
 

import org.apache.jena.query.DatasetFactory; //导入依赖的package包/类
private DeltaConnection(DataState dataState, DatasetGraph basedsg, DeltaLink link, TxnSyncPolicy syncTxnBegin) {
    Objects.requireNonNull(dataState, "DataState");
    Objects.requireNonNull(link, "DeltaLink");
    //Objects.requireNonNull(basedsg, "base DatasetGraph");
    if ( basedsg instanceof DatasetGraphChanges )
        FmtLog.warn(this.getClass(), "[%s] DatasetGraphChanges passed into %s", dataState.getDataSourceId() ,Lib.className(this));
    this.state = dataState;
    this.base = basedsg;
    this.datasourceId = dataState.getDataSourceId();
    this.datasourceName = dataState.getDatasourceName();
    this.dLink = link;
    this.valid = true;
    this.syncTxnBegin = syncTxnBegin;
    if ( basedsg == null ) {
        this.target = null;
        this.managed = null;
        this.managedDataset = null;
        this.managedNoEmpty = null;
        this.managedNoEmptyDataset = null;
        return;
    }
    
    // Where to put incoming changes. 
    this.target = new RDFChangesApply(basedsg);
    // Where to send outgoing changes.
    RDFChanges monitor = createRDFChanges(datasourceId);
    this.managed = new DatasetGraphChanges(basedsg, monitor, null, syncer(syncTxnBegin));
    this.managedDataset = DatasetFactory.wrap(managed);
    // ----
    RDFChanges monitor1 = new RDFChangesSuppressEmpty(monitor);
    this.managedNoEmpty = new DatasetGraphChanges(basedsg, monitor1, null, syncer(syncTxnBegin));
    this.managedNoEmptyDataset = DatasetFactory.wrap(managedNoEmpty);
}
 

import org.apache.jena.query.DatasetFactory; //导入依赖的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.DatasetFactory; //导入依赖的package包/类
@Before
public void setupDataset() {
    ds = DatasetFactory
            .wrap(getMarkLogicDatasetGraph("testdata/testData.trig"));
    // ds =
    // DatasetFactory.create(getJenaDatasetGraph("testdata/testData.trig"));
}
 

import org.apache.jena.query.DatasetFactory; //导入依赖的package包/类
@Before
public void setupDataset() {
    dsg = getMarkLogicDatasetGraph("testdata/testData.trig");

    ds = DatasetFactory.wrap(dsg);

    String tripleDocOne =

    "<semantic-document>\n"
            + "<title>First Title</title>\n"
            + "<size>100</size>\n"
            + "<sem:triples xmlns:sem=\"http://marklogic.com/semantics\">"
            + "<sem:triple><sem:subject>http://example.org/r9928</sem:subject>"
            + "<sem:predicate>http://example.org/p3</sem:predicate>"
            + "<sem:object datatype=\"http://www.w3.org/2001/XMLSchema#int\">1</sem:object></sem:triple>"
            + "</sem:triples>\n" + "</semantic-document>";

    String tripleDocTwo =

    "<semantic-document>\n"
            + "<title>Second Title</title>\n"
            + "<size>500</size>\n"
            + "<sem:triples xmlns:sem=\"http://marklogic.com/semantics\">"
            + "<sem:triple><sem:subject>http://example.org/r9929</sem:subject>"
            + "<sem:predicate>http://example.org/p3</sem:predicate>"
            + "<sem:object datatype=\"http://www.w3.org/2001/XMLSchema#int\">2</sem:object></sem:triple>"
            + "</sem:triples>\n" + "</semantic-document>";

    XMLDocumentManager docMgr = writerClient.newXMLDocumentManager();
    docMgr.write("/directory1/doc1.xml",
            new StringHandle().with(tripleDocOne));
    docMgr.write("/directory2/doc2.xml",
            new StringHandle().with(tripleDocTwo));
    qmgr = writerClient.newQueryManager();

}