Comment construire des requêtes SPARQL en java?

Est-il une bibliothèque, qui est capable de construire des requêtes SPARQL par programmation comme le CriteriaBuilder en JPA ou de construire les requêtes comme avec un PreparedStatement pour SQL?

Similaire (par SQL): Façon la plus propre à construire une chaîne SQL en Java

OriginalL'auteur Martin Schlagnitweit | 2011-08-30

Vous pouvez créer des requêtes par programmation à Iéna à l'aide de deux méthodes: la syntaxe ou de l'algèbre. Il y a un introduction dans le jena wiki.

À l'aide de l'algèbre, vous feriez quelque chose comme:

Op op;
BasicPattern pat = new BasicPattern();                 //Make a pattern
pat.add(pattern);                                      //Add our pattern match
op = new OpBGP(pat);                                   //Make a BGP from this pattern
op = OpFilter.filter(e, op);                           //Filter that pattern with our expression
op = new OpProject(op, Arrays.asList(Var.alloc("s"))); //Reduce to just ?s
Query q = OpAsQuery.asQuery(op);                       //Convert to a query
q.setQuerySelectType();                                //Make is a select query

(prises à partir de la page du wiki)

Ce n'est pas CriteriaBuilder (et il n'était pas destiné à être), mais il est certains de la façon dont il. Vous OpJoin plutôt que ET OpUnion quand vous voulez, OU, etc. Les points de douleur sont des expressions de mon expérience: vous avez probablement envie de les analyser à partir d'une chaîne.

OriginalL'auteur user205512

Les versions récentes de Jena ont ajouté un StringBuilder API de style pour la construction de la requête de mise à jour de chaînes et de paramétrer si désiré.

Cette classe est appelée ParameterizedSparqlString, voici un exemple d'utilisation pour créer une requête:

ParameterizedSparqlString queryStr = new ParameterizedSparqlString();
queryStr.setNSPrefix("sw", "http://skunkworks.example.com/redacted#");
queryStr.append("SELECT ?a ?b ?c ?d");
queryStr.append("{");
queryStr.append("   ?rawHit sw:key");
queryStr.appendNode(someKey);
queryStr.append(".");
queryStr.append("  ?rawHit sw:a ?a .");
queryStr.append("  ?rawHit sw:b ?b .");
queryStr.append("  ?rawHit sw:c ?c . ");
queryStr.append("  ?rawHit sw:d ?d .");
queryStr.append("} ORDER BY DESC(d)");

Query q = queryStr.asQuery();

Avertissement - je suis le développeur qui ont contribué à cette fonctionnalité de Jena

Voir Quelle est la meilleure façon de parametize requêtes SPARQL? pour plus de discussion sur le fait de faire cela à travers différentes Api.

OriginalL'auteur RobV

J'ai mis en place SPARQL Java - une sorte de DSL pour l'écriture de requêtes SPARQL en Java.

Il résout le problème avec l'IDE de l'auto de mise en forme contenant la concaténation des chaînes de requête SPARQL et des choses comme ça.

Comme par exemple:

String shortQuery = Q.prefix("books", "http://example.org/books#")
            .select("?book ?authorName", new where() {
                {
                    $("?book books:author ?author");
                    $("?author books:authorName ?authorName");
                }
            }).get();

OriginalL'auteur Heiner Reinhardt

3

J'ai récemment commencé à utiliser de la Sésame générateur de requêtes. Il semble prometteur sauf qu'il ne fournit pas beaucoup de documentation et j'ai eu du mal à trouver des exemples. Ici est simple exemple de ce qui peut vous aider à obtenir commencé:
```
ParsedTupleQuery query = QueryBuilderFactory
            .select("pubProperty", "pubPropertyValue")
                .group()
                    .atom(cmResource(resourceId), LinkPublicationsTransformation.REFERENCE_URI, "pubUri")
                    .atom("pubUri", "pubProperty", "pubPropertyValue")
                    .filter(isLiteral("pubPropertyValue"))
                .closeGroup()
            .query();
```
Il suffit de noter que isLiteral et cmResource sont mon propre peu statique des classes d'assistance. isLiteral signifie new IsLiteral(new Var("...")) par exemple, où le dernier de créer une URI avec mon très utilisé préfixe.

Vous pourriez être également intéressé par SPARQLQueryRenderer qui peut se transformer en ParsedQuery en String qui peut être pratique pour un usage ultérieur.

Si vous vous retrouvez à l'aide de String(Builder) approche de ce que je vous décourager de faire avoir au moins un coup d'oeil sur RenderUtils de sesame-queryrendered qui a toutes les méthodes pratiques pour ajouter < > autour d'Uri, d'échapper les caractères spéciaux etc.

OriginalL'auteur Jan Zyka

La Sésame cadre propose un Référentiel de l'API qui est assez similaire à JDBC - il vous permet de créer un objet de Requête et de les injecter variable, fixations avant de l'exécuter:

String query = "SELECT * WHERE {?X ?P ?Y }";
TupleQuery preparedQuery = conn.prepareQuery(QuerLanguage.SPARQL, query);
preparedQuery.setBinding("X", someValue);
...
TupleQueryResult result = preparedQuery.evaluate();

OriginalL'auteur Jeen Broekstra

1

Jena fournit un QueryBuilder dans les Extras paquet.

https://jena.apache.org/documentation/extras/querybuilder/index.html

Il fait ce que vous voulez.

OriginalL'auteur cWarren
0

Vous pouvez utiliser le Jena Sémantique Cadre (SPARQL documentation). Jetez aussi un oeil à cette question relative à la. Malheureusement, sa syntaxe est plus proche de SQL PreparedStatement que de la JPA.

mais la syntaxe utilisée sur la question est la chose que je veux éviter
Ok. J'ai mal compris votre question. J'ai trouvé d'autres liens à parler d'une bibliothèque appelée "Empire" qui est une JPA-comme l'interface qui utilise SPARQL sous les couvertures (weblog.clarkparsia.com/2010/01/11/empire-05) mais je n'ai pas été en mesure de trouver le code source sur github.
J'ai enfin trouvé sur github.com/mhgrove/Empire, mais je n'ai jamais utilisé avant. J'espère que ça répond à vos besoins, malgré qu'il semble difficile de commencer à l'utiliser: weblog.clarkparsia.com/2010/05/07/...

OriginalL'auteur Guido
0

Je viens de sortir une version bêta du projet à cet effet, appelé Spanqit.

J'ai cherché pour des raisons de lisibilité et d'une interface intuitive, pour exemple, voici quelques exemple Spanqit syntaxe pour la création d'une requête:
```
query.prefix(foaf).select(name)
    .where(x.has(foaf.iri("name"), name))
    .orderBy(name)
    .limit(5)
    .offset(10);
```
Check it out, et n'hésitez pas à commenter et suggérer des améliorations!

Semble bon, je vais vérifier
Un peu de chance? J'aimerais des commentaires!
Jusqu'à maintenant, mais merci pour le rappel. Je vais la tester au plus vite
Ce projet a été adopté par la Fondation Eclipse projet RDF4J, consultez la documentation ici: docs.rdf4j.org/sparqlbuilder

OriginalL'auteur anqit

Vous devez vous connecter pour publier un commentaire.