@Override public Set<Triple> serialize() { Set<Triple> stmtSet = new HashSet<Triple>(); stmtSet.add(getRDF().createTriple(node, getRDF().createIRI("http://www.w3.org/1999/02/22-rdf-syntax-ns#type"), getRDF().createIRI(R2RMLVocabulary.TYPE_JOIN))); stmtSet.add(getRDF().createTriple(node, getRDF().createIRI(R2RMLVocabulary.PROP_CHILD), getRDF().createLiteral(child))); stmtSet.add(getRDF().createTriple(node, getRDF().createIRI(R2RMLVocabulary.PROP_PARENT), getRDF().createLiteral(parent))); return stmtSet; }
private Stream<Quad> getLdfQuads() { return Stream.of( rdf.createQuad(PreferUserManaged, identifier, DC.creator, rdf.createLiteral("User")), rdf.createQuad(PreferUserManaged, rdf.createIRI("ex:foo"), DC.title, rdf.createIRI("ex:title")), rdf.createQuad(PreferUserManaged, identifier, DC.title, rdf.createLiteral("A title")), rdf.createQuad(PreferUserManaged, identifier, DC.title, rdf.createLiteral("Other title")), rdf.createQuad(PreferUserManaged, identifier, type, rdf.createIRI("ex:Type")), rdf.createQuad(PreferUserManaged, rdf.createIRI("ex:foo"), type, rdf.createIRI("ex:Type")), rdf.createQuad(PreferUserManaged, rdf.createIRI("ex:foo"), type, rdf.createIRI("ex:Other")), rdf.createQuad(PreferServerManaged, identifier, DC.created, rdf.createLiteral("2017-04-01T10:15:00Z", XSD.dateTime)), rdf.createQuad(PreferAccessControl, identifier, type, ACL.Authorization), rdf.createQuad(PreferAccessControl, identifier, ACL.mode, ACL.Control)); }
/** * Build a dataset. * @param resource the resource IRI * @param title a title * @param subject a subject * @return a new dataset */ default Dataset buildDataset(final IRI resource, final String title, final String subject) { final Dataset dataset = getInstance().createDataset(); dataset.add(Trellis.PreferUserManaged, resource, DC.title, getInstance().createLiteral(title)); dataset.add(Trellis.PreferUserManaged, resource, DC.subject, getInstance().createIRI(subject)); dataset.add(Trellis.PreferUserManaged, resource, type, SKOS.Concept); return dataset; } }
private static RDFTerm getObject(final String value, final String lang, final String datatype) { if (nonNull(lang)) { return rdf.createLiteral(value, lang); } else if (nonNull(datatype)) { return rdf.createLiteral(value, rdf.createIRI(datatype)); } return rdf.createIRI(value); } }
private List<Quad> auditData(final IRI subject, final Session session, final List<IRI> types) { final List<Quad> data = new ArrayList<>(); final BlankNode bnode = rdf.createBlankNode(); data.add(rdf.createQuad(PreferAudit, subject, PROV.wasGeneratedBy, bnode)); types.forEach(t -> data.add(rdf.createQuad(PreferAudit, bnode, type, t))); data.add(rdf.createQuad(PreferAudit, bnode, PROV.wasAssociatedWith, session.getAgent())); data.add(rdf.createQuad(PreferAudit, bnode, PROV.atTime, rdf.createLiteral(session.getCreated().toString(), XSD.dateTime))); session.getDelegatedBy().ifPresent(delegate -> data.add(rdf.createQuad(PreferAudit, bnode, PROV.actedOnBehalfOf, delegate))); return data; } }
@Test public void removeLanguageTagsCaseInsensitive() throws Exception { // COMMONSRDF-51: Ensure we can remove with any casing // of literal language tag final Literal lower = factory.createLiteral("Hello", "en-gb"); final Literal upper = factory.createLiteral("Hello", "EN-GB"); final Literal mixed = factory.createLiteral("Hello", "en-GB"); final IRI example1 = factory.createIRI("http://example.com/s1"); final IRI greeting = factory.createIRI("http://example.com/greeting"); try (final Graph graph = factory.createGraph()) { graph.add(example1, greeting, upper); // Remove should also honour any case graph.remove(example1, null, mixed); assertFalse(graph.contains(null, greeting, null)); graph.add(example1, greeting, lower); graph.remove(example1, null, upper); // Check with Triple graph.add(factory.createTriple(example1, greeting, mixed)); graph.remove(factory.createTriple(example1, greeting, upper)); assertFalse(graph.contains(null, greeting, null)); } }
private Stream<Quad> fetchQuadsFromTable(final String tableName, final IRI graphName) { final String query = "SELECT subject, predicate, object, lang, datatype " + "FROM " + tableName + " WHERE resource_id = ?"; return jdbi.withHandle(handle -> handle.select(query, data.getId()) .map((rs, ctx) -> rdf.createQuad(graphName, rdf.createIRI(rs.getString(SUBJECT)), rdf.createIRI(rs.getString(PREDICATE)), getObject(rs.getString(OBJECT), rs.getString(LANG), rs.getString(DATATYPE)))) .stream()); }
@Override public IRI getDatatype() { return factory.createIRI("http://www.w3.org/1999/02/22-rdf-syntax-ns#langString"); } @Override
@Override public Set<Triple> serialize() { Set<Triple> stmtSet = new HashSet<Triple>(); stmtSet.add(getRDF().createTriple(node, getRDF().createIRI("http://www.w3.org/1999/02/22-rdf-syntax-ns#type"), getRDF().createIRI(R2RMLVocabulary.TYPE_REF_OBJECT_MAP))); stmtSet.add(getRDF().createTriple(node, getRDF().createIRI(R2RMLVocabulary.PROP_PARENT_TRIPLES_MAP), parent.getNode())); for (Join j : joinList) { stmtSet.add(getRDF().createTriple(node, getRDF().createIRI(R2RMLVocabulary.PROP_JOIN_CONDITION), j.getNode())); stmtSet.addAll(j.serialize()); } return stmtSet; }
@Test public void testToQuad() { final IRI subject = rdf.createIRI("http://example.com/resource"); final Literal object = rdf.createLiteral("title"); final Triple triple = rdf.createTriple(subject, DC.title, object); final Quad quad = rdf.createQuad(Trellis.PreferUserManaged, subject, DC.title, object); assertEquals(quad, toQuad(Trellis.PreferUserManaged).apply(triple), "Incorrect quad from triple!"); }
private Graph createGraph2() { final RDF factory2 = createFactory(); final IRI name = factory2.createIRI("http://xmlns.com/foaf/0.1/name"); final Graph g2 = factory2.createGraph(); final BlankNode b1 = createOwnBlankNode("b1", "bc8d3e45-a08f-421d-85b3-c25b373abf87"); g2.add(b1, name, factory2.createLiteral("Charlie")); final BlankNode b2 = createOwnBlankNode("b2", "2209097a-5078-4b03-801a-6a2d2f50d739"); g2.add(b2, name, factory2.createLiteral("Dave")); final IRI hasChild = factory2.createIRI("http://example.com/hasChild"); // NOTE: Opposite direction of loadGraph1 g2.add(b2, hasChild, b1); return g2; }
@Test public void testCreateTripleBnodeTriple() { final BlankNode subject = factory.createBlankNode(); final IRI predicate = factory.createIRI("http://example.com/pred"); final Literal object = factory.createLiteral("Example", "en"); final Triple triple = factory.createTriple(subject, predicate, object); // bnode equivalence should be OK as we used the same // factory and have not yet inserted Triple into a Graph assertEquals(subject, triple.getSubject()); assertEquals(predicate, triple.getPredicate()); assertEquals(object, triple.getObject()); }
@Test public void testCreateTripleBnodeBnode() { final BlankNode subject = factory.createBlankNode("b1"); final IRI predicate = factory.createIRI("http://example.com/pred"); final BlankNode object = factory.createBlankNode("b2"); final Triple triple = factory.createTriple(subject, predicate, object); // bnode equivalence should be OK as we used the same // factory and have not yet inserted Triple into a Graph assertEquals(subject, triple.getSubject()); assertEquals(predicate, triple.getPredicate()); assertEquals(object, triple.getObject()); }
@Test public void testCreateGraph() throws Exception { try (final Graph graph = factory.createGraph(); final Graph graph2 = factory.createGraph()) { assertEquals("Graph was not empty", 0, graph.size()); graph.add(factory.createBlankNode(), factory.createIRI("http://example.com/"), factory.createBlankNode()); assertNotSame(graph, graph2); assertEquals("Graph was empty after adding", 1, graph.size()); assertEquals("New graph was not empty", 0, graph2.size()); } }
TermMapImpl(RDF rdf, RDFTerm constant) { super(rdf); this.constVal = requireNonNull(constant); if(constant instanceof BlankNode){ throw new IllegalArgumentException("BlankNode cannot be used as constant"); } else if (constant instanceof IRI){ this.termTypeIRI = getRDF().createIRI(R2RMLVocabulary.TERM_IRI); } else {// if (constant instanceof Literal) this.termTypeIRI = getRDF().createIRI(R2RMLVocabulary.TERM_LITERAL); } this.termMapType = TermMapType.CONSTANT_VALUED; setNode(getRDF().createBlankNode()); }
@Test public void testDefaultCreate() { final IRI root = rdf.createIRI("trellis:data/"); final Dataset dataset = rdf.createDataset(); final Metadata metadata = Metadata.builder(existing).container(root).interactionModel(LDP.RDFSource).build(); when(mockResourceService.replace(eq(metadata), eq(dataset))).thenReturn(completedFuture(null)); assertDoesNotThrow(() -> mockResourceService.create(metadata, dataset).toCompletableFuture().join()); verify(mockResourceService).replace(eq(metadata), eq(dataset)); }
@Test(expected = IllegalArgumentException.class) public void testInvalidLiteralLang() throws Exception { factory.createLiteral("Example", "with space"); }
/** * Un-skolemize a blank node. * * @param term the RDF term * @return a blank node, if a previously-skolemized node; otherwise the original term */ default RDFTerm unskolemize(final RDFTerm term) { if (term instanceof IRI) { final String iri = ((IRI) term).getIRIString(); if (iri.startsWith(TRELLIS_BNODE_PREFIX)) { return getInstance().createBlankNode(iri.substring(TRELLIS_BNODE_PREFIX.length())); } } return term; }
/** * Get a mapping function to turn a triple into a quad. * * @param graphName the graph name * @return the mapping function */ public static Function<Triple, Quad> toQuad(final IRI graphName) { return triple -> rdf.createQuad(graphName, triple.getSubject(), triple.getPredicate(), triple.getObject()); }
@Test public void testDatasetConversion() { final Dataset dataset = simpleRdf.createDataset(); dataset.add(simpleRdf.createQuad(PreferUserManaged, subject, SKOS.prefLabel, literal)); dataset.add(simpleRdf.createQuad(PreferUserManaged, subject, type, SKOS.Concept)); dataset.add(simpleRdf.createQuad(PreferUserManaged, subject, DC.subject, AS.Activity)); assertEquals(3L, dataset.size(), "Confirm dataset size"); assertTrue(TriplestoreUtils.asJenaDataset(dataset).containsNamedModel(PreferUserManaged.getIRIString()), "Confirm presence of trellis:PreferUserManaged named graph"); assertNotEquals(TriplestoreUtils.asJenaDataset(dataset).asDatasetGraph(), TriplestoreUtils.asJenaDataset(dataset).asDatasetGraph(), "Confirm dataset has been converted"); }