mdesalvo/rdfsharp

Lightweight and friendly .NET library for realizing Semantic Web applications

RDFSharp

RDFSharp has a modular structure made up of 3 layers:

RDFSharp.Model

• Create and manage RDF models (resources, literals, triples, graphs, namespaces, ...)
• Exchange them using standard RDF formats (N-Triples, TriX, Turtle, RDF/Xml)
• Create and validate SHACL shapes (shape graphs, shapes, targets, constraints, reports, ...)

RDFSharp.Store

• Create and manage RDF stores for context-aware modeling of RDF data (contexts, quadruples, ...)
• Exchange them using standard RDF formats (N-Quads, TriX, TriG)
• Pick a store extension to save and query RDF data on many supported providers

RDFSharp.Query

• Create and execute SPARQL queries on graphs, stores, federations and SPARQL endpoints
• Create and execute SPARQL operations on graphs, stores and SPARQL UPDATE endpoints

---

An additional layer is available for working in native and powerful way with OWL2 ontologies

rdfsharp's Issues

Incorrect parsing of quadruples from SQL-based stores

Incorrect validation of language tag against RFC3066

Revise regexes to parse language tags, in order to eliminate typos and logical errors.

Namespace prefix should also support "-" character

Order of projection variables in SPARQL SELECT query must be deterministic

Do not use NumberStyles when parsing decimals in SPARQL IsNumeric filter

Use of NumberStyles formats when parsing decimals in SPARQL IsNumeric filter may prevent many legal numeric representations from being accepted by the filter

Add support for prefix declaration in string representation of queries

In order to shorten the string representation of queries, support for declaration of prefixes should be added.

Unescaped control chars in TriX cause uncompliant XML

Control characters (except for "\t", "\n" and "\r" which are safe) should be escaped with Unicode "\uXXXX" repreentation in order to not generate uncompliant XML

Add configuration to support the upcoming RDFOracleStore implementation

Just add the "InternalsVisibleTo" directive in order to support the upcoming RDFOracleStore implementation

Incorrect evaluation of ground property paths

It should be avoided the ability to build ground property paths, since Mirella does not support evaluation of ground patterns.

Feature request: Read N-Quads

Currently only Write N-Quads

Incorrect evaluation of disjoint Exists/NotExists filter

When there aren't common variables between an Exists/NotExists filter and the query, a boolean invariant behavior should be adopted by the filter: TRUE for Exists, FALSE for NotExists.

Suggestion: decouple (de)serialization

Hi, I've noticed a number of tight couplings in your library which make it harder to work with. One such coupling is that of serialization with file access. In my case, I have an ontology as text in a stream and I want to deserialize it so that I can convert it to another format, but the library only supports deserialization from a file. A better approach would be to separate deserialization using some kind of reader/writer implementation, or simply just using streams, and then the deserialization could be used in scenarios where the text comes from the database, from an HTTP call or otherwise.

SPARQL variable name should not contain reserved characters ('?', '$')

Incorrect comparison logics driving RDFComparisonFilter;

Incorrect removal of items from collection of literals

There is an unwanted "break" instruction which causes incorrect exit from the cycle contained in the removal routine of RDFCollection.

Crash in queries having patterns with more than one occurrence of the same variable

This pattern "?S ?S http://test1/test2/ ." will make queries crash because of multiple occurrences of the same "?S" variable.

Support reading of Turtle

This is the most long-awaited feature of the library: we should be able to read Turtle files!

Add support for modeling SPARQL EXISTS filter

Algebra of Mirella engine would gain added value through support for EXISTS filter.

Deserialization of XML ignores presence of DTD

Incorrect validation of typed literals of "xsd:NormalizedString" datatype

Validation condition for "xsd:NormalizedString" typed literals is wrong.

ID of RDFPatternGroup should be based only on PatternGroupName

Not based on the entire ToString(), but only on the name property which is unique within a query

Add support for IN filter

Pretty easy to implement, this common filter give added value to Mirella engine, which lacks this feature.

Incorrect escape of some Unicode characters and "\" character in N-Triples and N-Quads

Characters "\b" and "\f" are not escaped in N-triples and N-Quads, they should be rendered with "\uXXXX" representation. The character "" is not escaped, it should be rendered as "".

Missing OWL vocabulary terms

OWL vocabulary does not contain the "AllDifferent" and "distinctMembers" terms

Documentation missing

Would have been nice with a sample code to demonstrate how this works.

Doc

Great work,
but I think it needs documentation or example to know who it is working

thanks

Avoid automatic "\r -> \n" normalization done by XmlReader in TriX

Character "\r" is automatically replaced with "\n" by XmlReader, this is not acceptable.

Incorrect escape of "\" character in Turtle

Character "" is not escaped as "" in Turtle, so output is not well formed.

Reverse lookup to prefix.cc service fails when uri ends with "#"

Reverse lookup for uris ending with "#" cause the prefix.cc service to fail. This char can be safely trimmed.

Incorrect string representation of SPARQL Datatype filter

There is an exceeding ")" closed parenthesis in the ToString() representation of RDFDatatypeFilter

Support SQL Server connection string

SQL Server ctor should be able to take a single connection string, in order to give control over the connection parameters. This would also lead to automatically gain support for SQL Azure.

String representation of SPARQL FILTER should not end with "."

Turtle serializer crashes on empty graph

Add support for SPARQL aggregators

A new kind of SPARQL object must be realized with the goal of grouping query results on a specified set of columns (variables) and then computing aggregations on these groups (SUM, MIN, MAX, AVG, COUNT).

Unquoted Turtle literals cannot contain carriage return

Add support for modeling SPARQL NOT EXISTS filter

Algebra of Mirella engine would gain added value through support for NOT EXISTS filter.

Missing validation for "xsd:QName" typed literals;

This validation is missing.

https://www.w3.org/XML/1998/namespace# breaks xml compatibility

Hi Marco, firstly thanks for all your hard work. One problem I ran in to however when attempting to load an OWL file written in XML was an exception being thrown due to the base uri for the namespace 'xml' being set to 'https://www.w3.org/XML/1998/namespace#' (from the static XML class located in RDFVocabulary.cs) instead of 'https://www.w3.org/XML/1998/namespace' without the hash symbol.
As stated in the text readable document located at that uri "The namespace whose name is http://www.w3.org/XML/1998/namespace is bound by definition to the prefix xml: according to Namespaces in XML"

Incorrect visibility of singleton instance of RDFNamespaceRegister;

Singleton instance of RDFNamespaceRegister should be public, with internal setter. At the moment it is internal, so it cannot be retrieved by consumers for iteration.

Please consider adding a demo project

As someone without previous experience with RDF, this project is pretty mysterious. I came here because I have a project in mind, I came across RDF while researching its prerequisites, and I'd be happy to work in C#. However as a neophite I'm not actually 100% sure what this library does. A demo project with a small writeup describing what that demo is doing would go a long way towards illustrating what RDFSharp can do.

Thanks!

Incorrect abbreviation of predicates in Turtle writer

Under some circumstances, invalid QNames are generated for abbreviation of predicates in Turtle writer.

Add support for querying remote SPARQL endpoint

Since we have full support for SPARQL XML Query Results standard, we should be able to send the string representation of SPARQL queries to remote SPARQL endpoints and then parse the result directly in our structures. This would give RDFSharp applications the ability to connect to LinkedData sources.

Migration to netstandard2.0

It is now time to switch to a modern target platform, which has been identified in netstandard2.0

Incorrect generation of automatic namespaces in RDF/XML writer

There are glitches in the generation of automatic namespaces in RDF/XML writer.

Add support for SPARQL subquery

It is now time to add support for modeling subqueries: we have all the capabilities at their place in the code, with the needed abstractions recently introduced.

Incorrect string representation of SPARQL NOT FILTER

RDFSharp.RDFSQLiteStore?

What happened to this?

Insufficient capability of fraction of second in "xsd:DateTime" and "xsd:Time" literals;

Actual "FFF" mask should be expanded to "FFFFFFF" in order to accept more precise literals.

Add basic support for SPARQL property paths

Towards a progressive implementation of SPARQL 1.1 features, basic support for property paths should be introduced. At least ability to chain sequence and alternatives, with parenthesis to group.

Wrong serialization of empty collection

An empty collection should be equivalent to rdf:Nil, so it shouldn't be reified as a standard collection having rdf:first/rdf:rest triples pointing to rdf:Nil.