[TYPO3-semantic] Serialisation of Query for DAM - JSON-LD

[Jochen Rau]

Hi Fabien.

I have taken some of the criterias shown in the linked image and translated them into a SPARQL query:

--- 8< ---------------- (SPARQL Begin)
PREFIX rdf: <http://xmlns.com/foaf/0.1/>
PREFIX sp: <http://spinrdf.org/sp#>
PREFIX dc: <http://purl.org/dc/elements/1.1/>
PREFIX dam: <http://typo3.org/ontology/dam/>
PREFIX ex: <http://example.org/>

SELECT *
WHERE {
	?resource rdf:type dam:Image .
	FILTER NOT EXISTS { ?resource dc:creator ex:John_Doe }
	?resource dc:title ?title . FILTER regex(?title, "foo")
	{ ?resource dam:category ex:FirstCategory }
	UNION
	{ ?resource dam:category ex:SecondCategory }
	UNION
	{ ?resource dam:category ex:ThirdCategory }
	?resource dam:fileSize ?size . FILTER (?size < 100)
}
--- 8< ---------------- (SPARQL Begin)

The query translates into RDF using the SPIN vocabulary (see http://spinrdf.org/sp.html#sp-Optional, http://spinservices.org/spinrdfconverter.html):

--- 8< ---------------- (Turtle Begin)
@prefix dc:      <http://purl.org/dc/elements/1.1/> .
@prefix ex:      <http://example.org/> .
@prefix rdfs:    <http://www.w3.org/2000/01/rdf-schema#> .
@prefix sp:      <http://spinrdf.org/sp#> .
@prefix spin:    <http://spinrdf.org/sp#> .
@prefix dam:     <http://typo3.org/ontology/dam/> .
@prefix xsd:     <http://www.w3.org/2001/XMLSchema#> .
@prefix owl:     <http://www.w3.org/2002/07/owl#> .
@prefix rdf:     <http://xmlns.com/foaf/0.1/> .

[]    a       sp:Select ;
      sp:where ([ sp:object dam:Image ;
                  sp:predicate rdf:type ;
                  sp:subject spin:_resource
                ] [ a       sp:Filter ;
                  sp:expression
                          [ a       sp:notExists ;
                            sp:elements ([ sp:object ex:John_Doe ;
                                        sp:predicate dc:creator ;
                                        sp:subject spin:_resource
                                      ])
                          ]
                ] [ sp:object spin:_title ;
                  sp:predicate dc:title ;
                  sp:subject spin:_resource
                ] [ a       sp:Filter ;
                  sp:expression
                          [ a       sp:regex ;
                            sp:arg1 spin:_title ;
                            sp:arg2 "foo"
                          ]
                ] [ a       sp:Union ;
                  sp:elements (([ sp:object ex:FirstCategory ;
                                sp:predicate dam:category ;
                                sp:subject spin:_resource
                              ]) ([ sp:object ex:SecondCategory ;
                                sp:predicate dam:category ;
                                sp:subject spin:_resource
                              ]) ([ sp:object ex:ThirdCategory ;
                                sp:predicate dam:category ;
                                sp:subject spin:_resource
                              ]))
                ] [ sp:object spin:_size ;
                  sp:predicate dam:fileSize ;
                  sp:subject spin:_resource
                ] [ a       sp:Filter ;
                  sp:expression
                          [ a       sp:lt ;
                            sp:arg1 spin:_size ;
                            sp:arg2 100
                          ]
                ]) .
--- 8< ---------------- (Turtle End)

A (simplified) translation of the WHERE part into JSON-LD (http://json-ld.org/) would be:

--- 8< ---------------- (JSON-LD Begin)
[{
    "sp:object": "dam:Image",
    "sp:predicate": "rdf:type",
    "sp:subject": "spin:_resource"
}, {
    "rdf:type": "sp:Filter",
    "sp:expression": {
        "rdf:type": "sp:notExists",
        "sp:elements": [{
            "sp:object": "ex:John_Doe",
            "sp:predicate": "dc:creator",
            "sp:subject": "spin:_resource"
        }]
    }
}, {
    "sp:object": "spin:_title",
    "sp:predicate": "dc:title",
    "sp:subject": "spin:_resource"
}, {
    "rdf:type": "sp:Filter",
    "sp:expression": {
        "rdf:type": "sp:regex",
        "sp:arg1": "spin:_title",
        "sp:arg2": "foo"
    }
}, {
    "rdf:type": "sp:Union",
    "sp:elements": [
        [{
            "sp:object": "ex:FirstCategory",
            "sp:predicate": "dam:category",
            "sp:subject": "spin:_resource"
        }],
        [{
            "sp:object": "ex:SecondCategory",
            "sp:predicate": "dam:category",
            "sp:subject": "spin:_resource"
        }],
        [{
            "sp:object": "ex:ThirdCategory",
            "sp:predicate": "dam:category",
            "sp:subject": "spin:_resource"
        }]
    ]
}]
--- 8< ---------------- (JSON-LD End)

This seems to be very complex. But there are some adavantages:
- We can easily transform the triple pattern back to a SPARQL query (reusable and future-proof).
- It is based on W3C standards (Recommendation/Member Submission).
- We can use all the tools available for RDF/SPARQL to check syntax or to serialize data.

Hope that helps. Let me know if you need additional information.

Jochen

-- 
Every nit picked is a bug fixed