A set of RdfTriples
for RDF (ResourceDescriptionFramework
) can be given a fairly straightforward representation in a relational database.
- RDF is appealing because, at the cost of permitting me to make nonsensical assertions, it permits me to make assertions of kinds that were not foreseen by the designer of the schema used by the data management system used by my application. For many developers it appears that one must make a "trade-off" between flexibility and data integrity."
- Each triple is effectively
- a composite key consisting of
- a subject identifier
- a predicate identifier
- an object identifier
- In RDF, these identifiers are URIs (UniformResourceIdentifier)
- "One goal of the Web, since its inception, has been to build a global community in which any party can share information with any other party. To achieve this goal, the Web makes use of a single global identification system: the URI. URIs are a cornerstone of Web architecture, providing identification that is common across the Web." —Architecture of the WorldWideWeb, Volume One, section 2
- For many developers it appears that one must make a "trade-off" between flexibility and data integrity.
It seems to me this reflects a weakness in one's ability to declare data integrity constraints in the common relational systems, not a necessary
trade off between flexibility and integrity.
I'd want to use typed objects, predictates, and subjects. Objects and subjects of a predicate may be classified (e.g. colours, emotions, identifiers, etc.) Predicates can be typed as functions (e.g. identifier->colour->bool). The types themselves are metadata that can also be included in the database and indexed to the need. (<identifier>,PredicateOfType?
,<property | constraint>), etc. You do need a little information to bootstrap the system, such as how constraints specified upon classes are applied in the database, and either proving or testing whether they continue to apply before and after transactions.
In any case, data integrity constraints in most complex languages are handled by a good typing system. Even the English language uses classifications to the point that we reject statements about green or furious triangles. Why not do the same here? We can't expect sense out of computers where we don't allow it to be programmed into them.
Please see SemanticWebLayerCake for a discussion of this issue. The issue of the classification of the predicates can be handled by an RdfSchema. One example of this is DublinCore, which defines commonly used terms such as title. I think that the issue of trust has to be handled in a layer of software which sits on top of RDF and contains meanings expressed in ontologies such as OWL (WebOntologyLanguage). There can then be a layer with a capability of reasoning about the data.