Web: "Hypertext Markup Language (HTML) is enough to present it to humans."

<div id="42">Douglas Adams created The Hitchhiker's Guide to the Galaxy <i>(sometimes referred to as <b>HG2G</b>)</i> finally in the United Kingdom in 1979.</div>

Semantic Web: "why not also send statements to enable machines to process it?"

(Douglas Adams, created, The Hitchhiker's Guide to the Galaxy)

Java 17 developers can use the latest Jena library.
Add the dependency to your Maven POM project.

<dependency>
    <groupId>org.apache.jena</groupId>
    <artifactId>jena-core</artifactId>
    <version>4.7.0</version>
</dependency>

Java 8 developers can use the Jena library version 3.17.0.

<dependency>
    <groupId>org.apache.jena</groupId>
    <artifactId>jena-core</artifactId>
    <version>3.17.0</version>
</dependency>

Python 3 developers can use the rdflib library.
Install the dependency with the package installer for Python (pip).

$ pip install rdflib

import org.apache.jena.rdf.model.Model;
import org.apache.jena.rdf.model.ModelFactory;

Model model = ModelFactory.createDefaultModel();

from rdflib import Graph

g = Graph()

import org.apache.jena.rdf.model.ResourceFactory;
import org.apache.jena.rdf.model.Resource;
import org.apache.jena.rdf.model.Property;

Resource subject = ResourceFactory.createResource("https://en.wikipedia.org/wiki/Douglas_Adams"); //or model.createResource
Property predicate = ResourceFactory.createProperty("http://wordnet-rdf.princeton.edu/id/01643749-v"); //or model.createProperty
Resource object = ResourceFactory.createResource("https://en.wikipedia.org/wiki/The_Hitchhiker%27s_Guide_to_the_Galaxy_(novel)");

from rdflib import URIRef

subject = URIRef('https://en.wikipedia.org/wiki/Douglas_Adams')
predicate = URIRef('http://wordnet-rdf.princeton.edu/id/01643749-v')
obj = URIRef('https://en.wikipedia.org/wiki/The_Hitchhiker%27s_Guide_to_the_Galaxy_(novel)')

import java.util.UUID;

Resource res = ResourceFactory.createResource("urn:uuid:" + UUID.randomUUID().toString());

import uuid

res = URIRef('urn:uuid:' + str(uuid.uuid4()))

model.add(subject, predicate, object);
model.remove(subject, predicate, object);

g.add((subject, predicate, obj))
g.remove((subject, predicate, obj))

import org.apache.jena.rdf.model.Literal;

Property label = ResourceFactory.createProperty("http://www.w3.org/2000/01/rdf-schema#label");
Literal name = ResourceFactory.createPlainLiteral("Douglas Adams"); //or model.createLiteral
model.add(subject, label, name);

from rdflib import Literal

label = URIRef('http://www.w3.org/2000/01/rdf-schema#label')
name = Literal('Douglas Adams')
g.add((subject, label, name))

import org.apache.jena.datatypes.xsd.XSDDatatype;

Literal publicationDate = ResourceFactory.createTypedLiteral("1979-10-12", XSDDatatype.XSDdate); //or model.createTypedLiteral
Literal japaneseName = ResourceFactory.createLangLiteral("ダグラス・アダムズ", "ja"); //or model.createLiteral

from rdflib.namespace import XSD

publicationDate = Literal("1979-10-12", datatype=XSD.date)
japaneseName = Literal('ダグラス・アダムズ', lang='ja')

for(Statement stmt : model.listStatements().toSet()) {
    System.out.println(stmt);
}

for(Statement stmt : model.listStatements(subject, null, (RDFNode) null).toSet()) {
    System.out.println(stmt);
}

for s, p, o in g:
    print(s, p, o)

for s, p, o in g.triples((subject, None, None)):
    print(s, p, o)

<dependency>
    <groupId>org.apache.jena</groupId>
    <artifactId>jena-arq</artifactId>
    <version>4.7.0</version>
</dependency>

import org.apache.jena.query.QueryExecution;
import org.apache.jena.query.QueryExecutionFactory;
import org.apache.jena.query.QuerySolution;
import org.apache.jena.query.ResultSet;
import org.apache.jena.query.ResultSetFormatter;

QueryExecution qe = QueryExecutionFactory.create(queryStr, model);
ResultSet rs = qe.execSelect();
for(QuerySolution qs : ResultSetFormatter.toList(rs)) {
    System.out.println(qs);
}
//or ResultSetFormatter.out(rs)

rs = g.query(queryStr)

for qs in rs:
    print(qs)

import org.apache.jena.shared.PrefixMapping;
import org.apache.jena.vocabulary.XSD;

model.setNsPrefix("wiki", "https://en.wikipedia.org/wiki/");
model.setNsPrefix("wn", "http://wordnet-rdf.princeton.edu/id/");
model.setNsPrefix("xsd", XSD.NS);

//contains frequently used prefixes
PrefixMapping standard = PrefixMapping.Standard;

//CURIE <-> URI
String uri = model.expandPrefix("wiki:Douglas_Adams");
String curie = model.shortForm("https://en.wikipedia.org/wiki/Douglas_Adams");

g.bind("wiki", URIRef("https://en.wikipedia.org/wiki/"))
g.bind("wn", URIRef("http://wordnet-rdf.princeton.edu/id/"))
g.bind("xsd", XSD)

StringWriter sw = new StringWriter();
model.write(sw, "TTL"); //or "NT", "JSON-LD", "N3", "RDF/XML"
System.out.println(sw.toString());

model.read(new FileReader(new File("data.ttl")), null, "TTL");

print(g.serialize(format='ttl')) # or 'nt', 'json-ld', 'n3', 'pretty-xml'

g.parse('data.ttl', format='ttl')

import org.apache.jena.sparql.util.NodeFactoryExtra;
import org.apache.jena.graph.Node;
import org.apache.jena.rdf.model.RDFNode;

Node node = NodeFactoryExtra.parseNode("\"literal\"^^<urn:type>");
RDFNode rdfNode = model.asRDFNode(node);

private static String toString(RDFNode rdfNode) {
    boolean r = rdfNode.isResource();
    return (r?"<":"") + rdfNode.asNode().toString(true) + (r?">":"");
}

import org.apache.jena.query.Dataset;
import org.apache.jena.query.DatasetFactory;

Dataset dataset = DatasetFactory.create();

dataset.getDefaultModel().add(s, p, o);

dataset.getNamedModel("urn:graph:g1").add(s, p, o);

import org.apache.jena.riot.Lang;
import org.apache.jena.riot.RDFDataMgr;

RDFDataMgr.write(sw, dataset, Lang.NQ);

import org.apache.jena.system.Txn;

Dataset datasetTxn = DatasetFactory.createTxnMem();

Txn.executeRead(datasetTxn, () -> {
    datasetTxn.getDefaultModel().listStatements();
});
Txn.executeWrite(datasetTxn, () -> {
    datasetTxn.getDefaultModel().add(s,p,o);
});
int i = Txn.calculateRead(datasetTxn, () -> {
    return datasetTxn.getDefaultModel().listStatements().toList().get(0).getInt();
});
boolean b = Txn.calculateWrite(datasetTxn, () -> {
    datasetTxn.getDefaultModel().add(s,p,o);
    return true;
});

<dependency>
    <groupId>org.apache.jena</groupId>
    <artifactId>jena-tdb2</artifactId>
    <version>4.7.0</version>
</dependency>

import org.apache.jena.tdb2.TDB2Factory;

Dataset tdb = TDB2Factory.connectDataset("tdb2");

tdb.executeRead(() -> {
    boolean result = QueryExecutionFactory.create("ASK { ?s ?p \"l\" }", dataset).execAsk();
});

tdb.executeWrite(() -> {
    dataset.getDefaultModel().removeAll(s, p, null);
});

tdb.close();

By the way, the connectDataset method creates (if not existing yet) in a folder named tdb2 files on disk (*.bpt, *.dat and *.idn) to store the following maps for fast subject, predicate, object and graph retrieval.

• SPO
• OSP
• POS
• SPOG
• OSPG
• POSG
• GOSP
• GPOS
• GSPO
• GPU (is Graph->Prefix->URI)

Resource douglasAdams = ResourceFactory.createResource("https://en.wikipedia.org/wiki/Douglas_Adams");

model.add(douglasAdams, RDF.type, FOAF.Person);
model.add(douglasAdams, RDF.type, OWL2.NamedIndividual);
model.add(douglasAdams, RDFS.label, "Douglas Adams");
model.add(douglasAdams, RDFS.comment, "An English author, screenwriter, essayist, humorist, satirist and dramatist.");
model.add(douglasAdams, DC.title, "Douglas Adams");

douglasAdams = URIRef("https://en.wikipedia.org/wiki/Douglas_Adams")

g.add((douglasAdams, RDF.type, FOAF.Person))
g.add((douglasAdams, RDF.type, OWL.NamedIndividual))
g.add((douglasAdams, RDFS.label, Literal("Douglas Adams")))
g.add((douglasAdams, RDFS.comment, Literal("An English author, screenwriter, essayist, humorist, satirist and dramatist.")))
g.add((douglasAdams, DC.title, Literal("Douglas Adams")))

@prefix dbo:	<http://dbpedia.org/ontology/> .
@prefix dbr:	<http://dbpedia.org/resource/> .
dbr:Douglas_Adams dbo:birthName "Douglas Noel Adams"@en ;
    dbo:birthDate	"1952-03-11"^^xsd:date ;
    dbo:birthPlace	dbr:Cambridge , dbr:Cambridgeshire ;

    dbo:deathDate	"2001-05-11"^^xsd:date ;
    dbo:deathPlace	<http://dbpedia.org/resource/Montecito,_California> ;

    dbo:restingPlace	dbr:Highgate_Cemetery , dbr:London ;

    dbo:occupation	dbr:Author , dbr:Screenwriter , dbr:Essay ,
        dbr:List_of_humorists , dbr:List_of_satirists_and_satires , dbr:Playwright .

Jena supports RDF-star. You need Jena ARQ library for RDF I/O technology (RIOT) to parse and write RDF-star. It is supported in the following formats:

• Turtle-star, just use "TTL"
• N-Triples-star, just use "NT"

Unfortunately, Version 3.17.0 does not support the {| ... |} annotation syntax.

StringWriter sw = new StringWriter();
model.write(sw, "TTL"); //or "NT"
System.out.println(sw.toString());

model.read(new FileReader(new File("data.ttl")), null, "TTL");

In rdflib there seems to be an ongoing implementation.

Jena provides a general purpose rule engine. For working with inferred statements use the InfModel interface. The rule language in Jena follows a certain syntax. In the example, we apply the rule that every person is also a resource in RDF, yet more complex rules can easily be defined, also including builtin functions.

import org.apache.jena.reasoner.rulesys.GenericRuleReasoner;
import org.apache.jena.reasoner.rulesys.Rule;
import org.apache.jena.rdf.model.InfModel;

String rules =
    "@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>.\n" +
    "@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>.\n" +
    "@prefix foaf: <http://xmlns.com/foaf/0.1/>.\n" +
    "[ruleA: (?s rdf:type foaf:Person) -> (?s rdf:type rdfs:Resource)]";
GenericRuleReasoner reasoner = new GenericRuleReasoner(Rule.parseRules(rules));
InfModel infModel = ModelFactory.createInfModel(reasoner, model);
Model raw = infModel.getRawModel();
Model deduced = infModel.getDeductionsModel();

In rdflib there seems to be no rule engine implementation. As an alternative in Python, you may consider PyKE (Python Knowledge Engine). However, this requires to mediate between RDF and PyKE.

If logging is enabled, we can reproduce how certain statements are derived.

import org.apache.jena.reasoner.Derivation;
import org.apache.jena.reasoner.rulesys.RuleDerivation;

reasoner.setDerivationLogging(true);

Iterator<Derivation> iter = infModel.getDerivation(ResourceFactory.createStatement(
    douglasAdams,
    RDF.type,
    RDFS.Resource));
while(iter.hasNext()) {
    RuleDerivation ruleDerivation = (RuleDerivation) iter.next();
    System.out.println(
            ruleDerivation.getRule() + " " +
            ruleDerivation.getMatches() + " " +
            ruleDerivation.getConclusion()
    );
}

InfModel rdfsInfModel = ModelFactory.createRDFSModel(model);

RML Mapper is a Java implementation of an RML engine. Since it includes old Jena dependencies, we exclude them.

<dependency>
    <groupId>be.ugent.rml</groupId>
    <artifactId>rmlmapper</artifactId>
    <version>4.9.0</version>
    <exclusions>
        <exclusion>
            <groupId>org.apache.jena</groupId>
            <artifactId>apache-jena-libs</artifactId>
        </exclusion>
        <exclusion>
            <groupId>com.github.rdfhdt</groupId>
            <artifactId>hdt-java</artifactId>
        </exclusion>
    </exclusions>
</dependency>

In rdflib there seems to be no RML engine implementation. As an alternative in Python, you may consider pyrml.

RML is also expressed with RDF (there is also a YAML syntax and an editor). Since RML is an extension of R2RML (mapping ralational databases), its concepts are often reused.

@prefix rr: <http://www.w3.org/ns/r2rml#>.
@prefix rml: <http://semweb.mmlab.be/ns/rml#>.
@prefix ql: <http://semweb.mmlab.be/ns/ql#>.
@prefix xsd: <http://www.w3.org/2001/XMLSchema#>.
@prefix foaf: <http://xmlns.com/foaf/0.1/>.

RML's basic idea is to refer to logical sources and define how subjects and their prediate-objects shall be mapped. Use templates with variable references {…} or direct references. We use BlankNode syntax […] to define resources without giving them URIs.

In Java we use RML Mapper to perform the mapping.

import be.ugent.rml.Executor;
import be.ugent.rml.functions.FunctionLoader;
import be.ugent.rml.records.RecordsFactory;
import be.ugent.rml.store.QuadStore;
import be.ugent.rml.store.RDF4JStore;
import org.eclipse.rdf4j.rio.RDFFormat;

RDF4JStore rmlStore = new RDF4JStore();
rmlStore.read(new FileInputStream(mappingFile), null, RDFFormat.TURTLE);
RecordsFactory factory = new RecordsFactory(mappingFile.getParentFile().getAbsolutePath());
QuadStore outputStore = new RDF4JStore();
FunctionLoader functionLoader = new FunctionLoader();
Executor executor = new Executor(rmlStore, factory, functionLoader, outputStore, null);
QuadStore qs = executor.execute(null);
qs.write(new FileWriterWithEncoding(outFile, StandardCharsets.UTF_8), "turtle");

First, we implement a static method in Java in a separate project and build a JAR file functions-1.0.0-SNAPSHOT.jar.

package de.uni.kl.dfki.mschroeder.tutorial.semtec;

import java.time.LocalDateTime;

public class Functions {

    public static Integer getYear(Integer age) {
        return LocalDateTime.now().getYear() - age;
    }

}

Second, we have to describe the function using the Function Ontology (FnO). This definition can be automatically generated using Java reflections.

@prefix fnoi:  <https://w3id.org/function/vocabulary/implementation#> .
@prefix fno:   <https://w3id.org/function/ontology#> .
@prefix fnom:  <https://w3id.org/function/vocabulary/mapping#> .
@prefix fnml:  <http://semweb.mmlab.be/ns/fnml#> .
@prefix xsd:   <http://www.w3.org/2001/XMLSchema#> .
@prefix rdfs:  <http://www.w3.org/2000/01/rdf-schema#> .

<java:de.uni.kl.dfki.mschroeder.tutorial.semtec.Functions.getYear>
        a            fno:Function ;
        rdfs:label   "getYear" ;
        fno:expects  ( <java:parameter.integer.0> ) ;
        fno:returns  ( <java:return.integer> ) .

<java:de.uni.kl.dfki.mschroeder.tutorial.semtec.Functions>
        a                fnoi:JavaClass ;
        <http://usefulinc.com/ns/doap#download-page>
                "functions/target/functions-1.0.0-SNAPSHOT.jar" ; # note: has to be an absolute path
        fnoi:class-name  "de.uni.kl.dfki.mschroeder.tutorial.semtec.Functions" .

[ a                   fno:Mapping ;
  fno:function        <java:de.uni.kl.dfki.mschroeder.tutorial.semtec.Functions.getYear> ;
  fno:implementation  <java:de.uni.kl.dfki.mschroeder.tutorial.semtec.Functions> ;
  fno:methodMapping   [ a                 fnom:StringMethodMapping ;
                        fnom:method-name  "getYear"
                      ]
] .

<java:parameter.integer.0>
        a              fno:Parameter ;
        rdfs:label     "Input Integer 0" ;
        fno:predicate  <java:parameter.predicate.integer.0> ;
        fno:required   true ;
        fno:type       xsd:int .

<java:return.integer>
        a              fno:Output ;
        rdfs:label     "Output Integer" ;
        fno:predicate  <java:return.predicate.integer> ;
        fno:type       xsd:int .

The function definition has to be loaded.

QuadStore fnoQuadStore = new RDF4JStore();
fnoQuadStore.read(new FileInputStream(fnoFile), null, RDFFormat.TURTLE);
FunctionLoader functionLoader = new FunctionLoader(fnoQuadStore);

This way we can use it in the mapping.

@prefix dbo: <https://dbpedia.org/ontology/> .
@prefix :    <file://data/HG2G-csv-fno.rml.ttl#>.

:mapping a rr:TriplesMap;
    rml:logicalSource [
        rml:source "HG2G.csv" ;
        rml:referenceFormulation ql:CSV
    ];
    rr:subjectMap [
        rr:template "file://data/HG2G.csv.ttl#{id}";
        rr:class foaf:Person
    ];
    rr:predicateObjectMap [
        rr:predicate dbo:birthYear;
        rr:objectMap [
            a fnml:FunctionMap ;
            fnml:functionValue  [
                rr:predicateObjectMap  [
                    rr:predicate  fno:executes ;
                    rr:object     <java:de.uni.kl.dfki.mschroeder.tutorial.semtec.Functions.getYear>
                ] ;
                rr:predicateObjectMap [
                    rr:predicate  <java:parameter.predicate.integer.0> ;
                    rr:objectMap  [ rml:reference  "age" ]
                ]
            ] ;
            rr:datatype xsd:int
        ]
    ].

The open source library RDF Delta implements a patching mechanism for RDF in its RDF Patch module. Since it includes old Jena dependencies, we exclude them. Version 0.8.2 is the latest version compatible with Java 8.

<dependency>
    <groupId>org.seaborne.rdf-delta</groupId>
    <artifactId>rdf-patch</artifactId>
    <version>0.8.2</version>
    <exclusions>
       <exclusion>
            <groupId>org.apache.jena</groupId>
            <artifactId>apache-jena-libs</artifactId>
        </exclusion>
    </exclusions>
</dependency>

In rdflib there seems to be no library which supports patching RDF.

import org.seaborne.patch.changes.RDFChangesCollector;
import org.seaborne.patch.RDFPatchOps;
import org.seaborne.patch.RDFPatch;
import org.seaborne.patch.items.ChangeItem;
import org.apache.jena.graph.NodeFactory;

RDFChangesCollector collector = new RDFChangesCollector();
Graph observedGraph = RDFPatchOps.changes(model.getGraph(), collector);
Model observedModel = ModelFactory.createModelForGraph(observedGraph);

collector.header("authKey", NodeFactory.createLiteral("43538d81-4027-4106-9a5f-063405827d82"));

observedModel.removeAll(graphEmbeddings, hasSuperTopic, null);
observedModel.add(graphEmbeddings, hasSuperTopic, artificialIntelligence);
observedModel.removeAll(graphEmbeddings, SKOS.prefLabel, null);
observedModel.add(graphEmbeddings, SKOS.prefLabel, "Graph Embeddings");

//I/O
String patchSyntax = RDFPatchOps.str(collector.getRDFPatch());
System.out.println(patchSyntax);
RDFPatchStored patch = (RDFPatchStored) RDFPatchOps.read(new ByteArrayInputStream(patchSyntax.getBytes()));
List<ChangeItem> changeItems = patch.getActions();

To implement a Triple Pattern Fragments servers, developers can consult the unofficial draft of the Triple Pattern Fragments specification. Given a dataset hosted on a server, a (possibly paginated) fragment is an RDF document response to a triple pattern request by a client. A fragment response basically consists of two parts:

Meta Data

Meta data consists of information about the dataset (e.g. how it is queried) and the fragment (e.g. name, size, pagination). To state this, the vocabulary of Hypermedia-Driven Web APIs (Hydra) [References in Java] and the Vocabulary of Interlinked Datasets (VoID) is used.

Data

The (possibly paginated) actual triples which match a given triple pattern.

To implement a server, the micro framework Spark is used in the example below. Of cause any HttpServlet implementation can alternatively be used, for example Jetty.

<dependency>
    <groupId>com.sparkjava</groupId>
    <artifactId>spark-core</artifactId>
    <version>2.9.3</version>
</dependency>

A Triple Pattern Fragments server has to provide only one HTTP GET route to let clients query fragments. The major part of the source code is about forming the fragment's meta data. Since meta data is passed in a separate RDF graph (data in default graph), the RDF serialization format TriG is used. Optional authentication information can be passed in the request's header.

import org.apache.jena.graph.Node;
import org.apache.jena.query.Dataset;
import org.apache.jena.query.DatasetFactory;
import org.apache.jena.rdf.model.Model;
import org.apache.jena.rdf.model.ModelFactory;
import org.apache.jena.rdf.model.Property;
import org.apache.jena.rdf.model.Resource;
import org.apache.jena.riot.Lang;
import org.apache.jena.riot.RDFDataMgr;
import org.apache.jena.sparql.util.NodeFactoryExtra;
import org.apache.jena.sparql.vocabulary.FOAF;
import org.apache.jena.vocabulary.RDF;
import org.apache.jena.vocabulary.RDFS;
import org.apache.jena.vocabulary.VOID;
import spark.Request;
import spark.Response;
import spark.Spark;

public static void main(String[] args) {
    Spark.port(8081);
    Spark.get("/fragment", TriplePatternFragments::getFragment);
    Spark.awaitInitialization();
}

private static Object getFragment(Request req, Response resp) {
    //meta data
    Model metadata = ModelFactory.createDefaultModel();
    Resource metadataGraph = metadata.createResource(req.url() + "#metadata");
    Resource fragment = metadata.createResource(req.url());
    Resource hydraSearch = metadata.createResource();
    Map<String, Property> hydraMap = new HashMap<>();
    hydraMap.put("s", RDF.subject);
    hydraMap.put("p", RDF.predicate);
    hydraMap.put("o", RDF.object);

    //the primary topic of the meta data graph is the fragment
    metadata.add(metadataGraph, FOAF.primaryTopic, fragment);

    Resource dataset = metadata.createResource("http://localhost:8081/fragment#dataset");
    metadata.add(dataset, RDF.type, VOID.Dataset);
    metadata.add(dataset, RDF.type, Hydra.Collection);
    //the fragment is a subset of the whole dataset
    metadata.add(dataset, VOID.subset, fragment);
    //explain how the dataset can be searched
    metadata.add(dataset, Hydra.search, hydraSearch);
    //explain the template to search
    metadata.add(hydraSearch, Hydra.template, "http://localhost:8081/fragment{?s,p,o}");
    //map URL query param keys to RDF properties
    for(Entry<String, Property> entry : hydraMap.entrySet()) {
        Resource mapping = metadata.createResource();
        metadata.add(hydraSearch, Hydra.mapping, mapping);
        metadata.add(mapping, Hydra.variable, entry.getKey());
        metadata.add(mapping, Hydra.property, entry.getValue());
    }

    String s = req.queryParams("s");
    String p = req.queryParams("p");
    String o = req.queryParams("o");
    Model dataModel = evaluateTriplePattern(s, p, o);

    //meta data about the fragment
    metadata.add(fragment, RDF.type, Hydra.PartialCollectionView);
    //a fragment's subset is itself
    metadata.add(fragment, VOID.subset, fragment);
    long totalTriples = dataModel.size();
    metadata.addLiteral(fragment, VOID.triples, totalTriples);
    metadata.addLiteral(fragment, Hydra.totalItems, totalTriples);

    Dataset ds = DatasetFactory.create();
    ds.getDefaultModel().setNsPrefix("hydra", Hydra.NS);
    ds.getDefaultModel().setNsPrefix("rdf", RDF.uri);
    ds.getDefaultModel().setNsPrefix("void", VOID.NS);
    //graph about meta data
    ds.addNamedModel(metadataGraph.getURI(), metadata);
    //default graph is data graph
    ds.setDefaultModel(dataModel);

    //write in trig format
    StringWriter trigSW = new StringWriter();
    RDFDataMgr.write(trigSW, ds, Lang.TRIG);
    resp.type("application/trig;charset=utf-8");
    resp.header("Access-Control-Allow-Origin", "*");
    return trigSW.toString();
}

The evaluateTriplePattern method is the procedure which actually evaluates a triple pattern (s,p,o) and returns matching RDF triples. Since object o can also be a literal (indicated by a starting quote), we have to parse it using regular expression.

import java.util.regex.Matcher;
import java.util.regex.Pattern;

private static final Pattern STRINGPATTERN = Pattern.compile("^\"(.*)\"(?:@(.*)|\\^\\^<?([^<>]*)>?)?$");

private static Model evaluateTriplePattern(String s, String p, String o) {
    Model dataModel = ModelFactory.createDefaultModel();

    Resource subject = null;
    Property predicate = null;
    RDFNode object = null;
    if(s != null) {
        subject = dataModel.createResource(s);
    }
    if(p != null) {
        predicate = dataModel.createProperty(p);
    }
    if(o != null) {
        if(o.charAt(0) == '\"') {
            Matcher matcher = STRINGPATTERN.matcher(o);
            if (matcher.matches()) {
                String label   = matcher.group(1);
                String langTag = matcher.group(2);
                String typeURI = matcher.group(3);

                if (langTag != null)
                    object = dataModel.createLiteral(label, langTag);
                else if (typeURI != null)
                    object = dataModel.createTypedLiteral(label, typeURI);
                else
                    object = dataModel.createLiteral(label);

            } else {
                throw new RuntimeException("Literal parsing failed for " + o);
            }
        } else {
            object = dataModel.createResource(o);
        }
    }

    //TODO match subject, predicate, object and fill dataModel

    return dataModel;
}
                        

A similar implemention can be archived with flask and rdflib. There is also a Python implementation on GitHub.