How can I use Fuseki as a database, and use JAVA API to update?

[chenkuncloud]

That's what I want to do:
I want to use Fuseki to store RDF data, possibly update in real time, and open up SPARQL Endpoint to outside.
For Jena's Java APIs, I was also going to use Jena Model, but I found that it can't be accessed by multiple applications at the same time, and has no SPARQL Endpoint.
For Fuseki, I learned that, I have to update RDF data through SPARQL or file, but this would involve a lot of escape trouble in the text, and it would be complicated to write the code. At the same time, HTTP would also increase the performance overhead.
It feels less convenient to use than Virtuoso, because it provides VirtGraph:

VirtGraph graph = new VirtGraph(graphName, "jdbc:virtuoso://xxx:1111", "dba", "xxx");
VirtModel model = new VirtModel(graph);
model.add(...);

I wonder if I missed something about Jena? How can I use Jena properly as a database?

[afs]

See also discussion on issue: #1243

---

The SPARQL answer is the SPARQL Graph Store Protocol (GSP): https://www.w3.org/TR/sparql11-http-rdf-update/. With this, the application can fetch the whole graph (GET), work on it locally and then replace the original (PUT - replace original). This is a standard mechanism and all triple stores should offer it.

To work with a remote graph in the model style, needs a custom protocol to handle blank nodes correctly.

It assumes a manageable size of the graph but in a different way, so does a model view of remote data where the only access primitive is "listStatements". To find data can require several "listStatements", which is several round-trips to the database and some of which may pull back a lot of data (the "client-side join" issue common in various NoSQL systems).

So if the graph is small enough, get it locally, update and put back. If it is large, consider using tools aimed at larger scale data working with many triples at the same time i.e. SPARQL. The RDFConnection API handles all the protocol escaping issues. RDFConnection also has the Graph Store Protocol operations - fetch is GSP GET, putModel is GSP PUT.

SPARQL requests can be built programmatically. Some of the work needed to set them up can be reduced templating, then the API term operations are available. Simple example to add a triple:

    public static void main(String...args) throws Exception {
        try ( RDFConnection conn = RDFConnectionRemote.service("http://localhost:3030/ds").build() ) {
            conn.newUpdate()
                .update("INSERT {?s ?p ?o} WHERE {}")
                .substitution("s", ResourceFactory.createResource("http://example/s"))
                .substitution("p", ResourceFactory.createResource("http://example/p"))
                .substitution("o", ResourceFactory.createResource("http://example/o"))
                .execute();
        }

(caveat blank nodes).

[chenkuncloud]

Hi,

This is very helpful to me.

With it, I can use Fuseki as a database to store RDF data, and use RDFConnection API to query or update. It's very convenient.

Thank you.