A Graph is a data structure consisting of nodes and arcs (also called edges) connecting these nodes. The nodes of a graph usually represent things and the edges represent relationships between things. The edges may be directed and may have attributes or labels qualifying the relationship.
A Directed Graph is a graph where the lines connecting the nodes have a direction. For example, a web site can be represented as a graph where each page is a node and each link is an arc. The arcs (links) are directed because A linking to B does not mean B linking to A.
RDF, the Resource Definition Framework, provides a formalism for representing arbitrary, structured, semi-structured or ad hoc data about anything that can be identified with a URI. RDF has been developed as a maximally flexible formalism for describing resources on the web but can be applied to any knowledge representation task.
RDF represents nodes of a graph (subjects) by URIs. Anything described by RDF must have a URI, whether this is accessible on the web or not. Also all attributes of a URI (predicates) must also have URIs. The value of an attribute (object) can be a URI or a scalar value such as a string or a number. Thus, an RDF graph is a collection of triples each consisting of a subject URI, a predicate URI and of an object. These form a directed graph where the arcs start with subject URIs, are labeled with predicate URIs and end up pointing to object URIs or scalar values.
A Triple is a unit of RDF Data (a graph) comprised of three pieces of information: Subject (S), Predicate (P), and Object (O). Where S and O are nodes and P the node connector (also called edge or arc). Since RDF is based on a directed graph data model the edges always point from "Subject" to the "Object" as illustrated below:
(Subject) -- Predicate -->(Object)
A Named Graph is simply a collection of RDF triples which is named by a graph URI.
"Triple Store" is the common name given to a database management system for RDF Data. These systems provide data management and data access via APIs and query languages to RDF Data.
In actuality, many Triple Stores are in fact Quad Stores, due to the need to maintain RDF Data provenance within the data management system. Any Triple Store that supports Named Graph functionality is more than likely a Quad Store. (Virtuoso is a Quad Store -- and in fact should be considered a Column Store, as Quads may need to be extended further for various reasons.)
You can import, export, and render RDF data in a number of ways:
- By hand
- Via HTTP/WebDAV GET and PUT
- Transformation of XML to RDF via XSLT (e.g. using approaches such as GRDDL)
- Transformation of SQL Data to RDF through Virtualization
SPARQL is the emerging query language for RDF data. SPARQL allows specifying a set of triple patterns that must be matched by data in one or more graphs. The results of a SPARQL query resemble a SQL result set or alternately can represent a new RDF graph. The basic unit of a query is a triple pattern that may consist of constants and variables corresponding to a triple's subject, predicate and object. Using the same variable name in more than one triple patterns specifies a join.
The Virtuoso database functionality realm that handles the management of RDF Data. It supports N3 / N-Triples and RDF/XML RDF Data Serializations. It also supports the SPARQL Query Language, Query Protocol, and XML Query Results Serialization.
Virtuoso provides several load or data import functions that insert data into the triple store. These include:
- Copy RDF files into WebDAV after mounting Virtuoso's WebDAV repository via your operating systems WebDAV filesystem mount feature
- Upload RDF files via the OpenLink Data Spaces Briefcase (Virtuoso automatically generates Triple Statements from WebDAV metadata)
- Virtuoso developers can use the Function:
RDF_EXP_LOAD_RDFXML()that parses RDF/XML, Turtle, or N3 / N-Triples RDF graphs and then generates appropriate Triples Statements in Triple Store (the system table:
- Direct insertion of rows into the
RDF_QUADtable for nodes (
RDF_QUAD_URI) or literal values (
- Mapping of Relational data from native or 3rd party heterogeneous data sources into RDF resulting in the generation of Triple Statements for Relational Entities
Via the following mechanisms:
- SPARQL Query Service Interface (which processes SPARQL requests from SPARQL Protocol supporting clients over HTTP)
- All SQL Interfaces to Virtuoso (which includes ODBC, JDBC, OLEDB, ADO.NET, and XMLA)
- Virtuoso Stored Procedures and Functions
If an RDF type corresponds to a SQL data type, the data is stored as a native instance of the SQL type in question. For strings with language tags and other RDF data that has no direct SQL counterpart, a special representation preserving the RDF semantic is used.
- RDF Database and SPARQL
- Data Representation
- RDF Views -- Mapping Relational Data to RDF
- RDF Inference in Virtuoso
- RDF and SPARQL API and SQL