in section Abstract

in section Status of This document

in section Table of Contents

in section Appendices

in section Issues

in section Introduction

in section Document Conventions

in section Making Simple Queries

in section Writing a Simple Query

in section Initial Definitions

**Definition:** RDF Term

let I be the set of all IRIs.

let RDF-L be the set of all
RDF Literals

let RDF-B be the set of all
blank nodes in RDF graphs

The set of RDF Terms, RDF-T, is I union RDF-L union RDF-B.

**Definition:** Query Variable

A query variable is a member of the set V where V is infinite and disjoint from RDF-T.

**Definition:** Graph Pattern

A Graph Pattern is one of:

**Definition:**
SPARQL Query

A SPARQL query is a tuple (GP, DS, SM, R) where:

- GP is a graph pattern
- DS is an RDF Dataset
- SM is a set of solution modifiers
- R is a result form

The graph pattern of a query is called the query pattern.

**Definition:**
Triple Pattern

A triple pattern
is member of the set:

(RDF-T union V) x (I union V)
x (RDF-T union V)

in section Pattern Solutions

**Definition:**
Pattern Solution

A pattern solution is a substitution function from a subset of the set of variables to the set of RDF terms, RDF-T.

The result of replacing every v in a graph pattern P by S(v) is written S(P).

If variable v is not in the domain of S then S(v) is defined to be v.

**Definition:**
Query Solution

Given query Q = (GP, DS, SM, R) then S is a query solution of Q if S is a pattern solution for GP matching dataset DS.

in section Basic Graph Patterns

**Definition:**
Basic Graph Pattern

A Basic Graph Pattern is a set of Triple Patterns.

A basic graph pattern matches on graph G with solution S if S(GP) is an RDF graph and is subgraph of G.

in section Multiple Matches

in section Blank Nodes

in section Other Syntactic Forms

in section Working with RDF Literals

in section Matching RDF Literals

in section Value Constraints

in section Value Constraints – Definition

**Definition:**
Value Constraint

A value constraint is a boolean-valued expression of variables and RDF Terms.

For value constraint C, a solution S matches C if S(C) is true.

S(C) is the substitution of variables mentioned in C.

in section Graph Patterns

in section Group Graph Patterns

**Definition:**
Group Graph Pattern

A group graph pattern GP is a set of graph patterns,
GP_{i}.

A solution of Group Graph Pattern GP on graph G
is any solution S such that, for every element GP_{i} of GP, S is a solution
of GP_{i}.

in section Unbound variables

in section Including Optional Values

in section Optional Pattern Matching

in section Constraints in Optional Pattern Matching

in section Multiple Optional Graph Patterns

in section Optional Matching – Formal Definition

An optional graph pattern is a combination of a pair of graph patterns. The second pattern modifies the solution of the first pattern but does not fail matching of the overall optional graph pattern.

If Opt(A, B) is an optional graph pattern, where A and B are graph patterns, then S is a solution of optional graph pattern if S is a solution of A and of B otherwise if S is a solution to A, but not to A and B.

in section Nested Optional Graph Patterns

in section Matching Alternatives

in section Joining Patterns with UNION

in section Union Matching – Formal Definition

**Definition:**
Union Graph Pattern

A union graph pattern is a set of graph patterns
GP_{i}.

A union graph pattern matches a graph G with solution S if there is some GP_{i} such that GP_{i}
matches G with solution S.

in section RDF Dataset

**Definition:**
RDF Dataset

An RDF dataset is a set:

{ G, (<u_{1}>, G_{1}), (<u_{2}>, G_{2}), . . . (<u_{n}>, G_{n}) }

where G
and each G_{i} are graphs, and each <u_{i}> is an IRI. Each <u_{i}>
is distinct.

G is called the default graph. (<u_{1}>, G_{i}) are
called named graphs.

There may be no named graphs.

A graph pattern P, where P is not an RDF Dataset Graph Pattern, matches an RDF dataset DS with solution S if P matches G (the default graph of DS) with solution S.

If D is a dataset {G, (<u1> G1), ...}, and P is a graph pattern then S is a pattern solution of GRAPH(g, P) if either of:

- g is an IRI where g = <u
_{i}> for some i, and S is pattern solution of P on dataset {G_{i}, (<u1> G1), ...} - g is a variable, S maps the variable g to <u
_{i}> and S is a pattern solution of P on {G_{i}, (<u1> G1), ...}

in section Examples of RDF Datasets

in section Querying the Dataset

in section Accessing Graph Names

in section Restricting by Graph IRI

in section Restricting by Bound Variables

in section Named and Default Graphs

in section Specifying RDF Datasets

in section Specifying the Default Graph

in section Specifying Named Graphs

in section Combining FROM and FROM NAMED

in section Query Result Forms

in section Solution Sequences and Result Forms

**Definition:**
Solution Sequence

A solution sequence S is a list of solutions.

S = ( S_{1}, S_{2}, . . . , S_{n})

The solution sequence from matching the query pattern is an unordered collection formed from the solutions of the query pattern.

**Definition:**
Solution Sequence Modifier

A solution sequence modifier is one of:

- Projection modifier
- Distinct modifier
- Order modifier
- Limit modifier
- Offset modifier

If SM is set of modifiers, and QS is the collection of solutions of a query, we write SM(QS) for the sequence formed by applying SM to the solution sequence formed from QS.

in section Projection

**Definition:**
Projection

The projection of solution QS over a set
of variables VS is the solution

project(QS_{i}, VS) = { (v, QS_{i}(v)) | v in VS }

For a solution sequence S = ( S_{1}, S_{2}, . . . , S_{n}) and a finite set of variables VS,

project(S, VS) = { (project(S_{i}, VS) | i = 1,2, . . . n }

in section DISTINCT

**Definition:**
Distinct Solution Sequence

A Distinct Solution Sequence has no two solutions the same.

For a solution sequence S = ( S_{1}, S_{2}, . . . , S_{n}),
then write set(S) is the set of solution sequences in S.

distinct(S) = (S_{i} | S_{i} != S_{j} for all i
!= j) and set(distinct(S)) = set(S)

in section ORDER BY

**Definition:**
Ordered Solution Sequence

A ordered solution sequence is a solution sequence where the sequence is partially ordered with respect to some ordering condition.

A solution sequence S = ( S_{1}, S_{2}, . . . , S_{n})
is ordered with respect to an ordering condition C if, for S_{i}, S_{J},
then i < j if C orders S_{i} before S_{j}.

in section LIMIT

**Definition:**
Limited Solution Sequence

A Limited Solution Sequence has at most a given, fixed number of members.

The limit of solution sequence S = (S_{1}, S_{2}, . . . , S_{n})
is

limit(S,m) =

(S_{1}, S_{2}, . . . , S_{m})
if n > m

(S_{1}, S_{2}, . . . , S_{n})
if n <= m

in section OFFSET

**Definition:**
Offset Solution Sequence

An Offset Solution Sequence with respect to another solution sequence S, is one which starts at a given index of S.

For solution sequence S = (S_{1}, S_{2}, . . . , S_{n}),
the offset solution sequence

offset(S, k), k >= 0 is

(Sk, Sk+1, . . ., S_{n}) if n >= k

(), the empty sequence, if k > n

in section Selecting Variables

**Definition:**
SELECT

Given Q = (GP, DS, SM, SELECT VS) where

- GP is a graph pattern
- DS is an RDF Dataset
- SM is a set of solution modifiers
- VS is a set of variables

then, if QS is the set of solutions formed by matching dataset DS with graph pattern GP, the SELECT result is project(SM(QS), VS)

in section Constructing an Output Graph

**Definition:**
Graph Template

A graph template is a set of triple patterns.

If T = { t_{j} | j = 1,2 ... m } is a graph template and S is a
solution then S(t_{j}) is an RDF triple if all variables in t_{j}
are in the domain of S. S(t_{j}) is empty otherwise.

Write S(T) for the union of S(t_{j}).

**Definition:**
CONSTRUCT

Let Q = (GP, DS, SM, CONSTRUCT T) where

- GP is a graph pattern
- DS is an RDF Dataset
- SM is a set of solution modifiers
- T is a set of triple patterns

then, if QS is the set of solutions formed by matching dataset DS with
graph pattern GP, then write SM(QS) = { S_{i} | i = 1,2 ... n }.

The CONSTRUCT result is the RDF graph
formed by the RDF merge
of each S_{i}(T).

in section Descriptions of Resources

**Definition:**
DESCRIBE

Let Q = (GP, DS, SM, DESCRIBE V) where

- GP is a graph pattern
- DS is an RDF Dataset
- SM is a set of solution modifiers
- V is a set of variables VS and IRIs U

then, if QS is the set of solutions formed by matching dataset DS with
graph pattern GP, the DESCRIBE result is an RDF graph formed by information relating
elements of

U union project(SM(QS), VS).

This definition intentionally does not proscribe the nature of the relevant information.

in section Asking "yes or no" questions

**Definition:**
ASK

Let Q = (GP, DS, SM, ASK) where

- GP is a graph pattern
- DS is an RDF Dataset
- SM is a set of solution modifiers

and QS is the set of solutions formed by matching dataset DS with graph pattern GP then the ASK result is true if SM(QS) is not empty, otherwise it is false.

in section Testing Values

in section Operand Data Types

in section Type Promotion

in section SPARQL Functions and Operators

in section Invocation

in section Effective Boolean Value

in section Operator Mapping

in section Operators introduced in SPARQL

in section SPARQL Constructor Functions

in section Extensible Value Testing

in section A. SPARQL Grammar

in section B. References

in section C. Change Log

$Revision: 1.4 $ of $Date: 2005/07/21 19:15:35 $

generated from $Id: Overview.html,v 1.435 2005/07/21 19:14:05 connolly Exp $

via defns.xsl$Id: defns.xsl,v 1.13 2005/07/21 17:41:27 connolly Exp $

See also the editor's draft and the live transformation.