SPARQL 1.1

The core query language extends SPARQL 1.0 with new capabilities for complex data manipulation.

• Aggregates: Use functions like COUNT, SUM, AVG, MIN, and MAX with GROUP BY for analytical queries.
• Subqueries: Nest SELECT queries within other queries for modular logic.
• Property Paths: Concise syntax for navigating graph patterns using operators like / (sequence), | (alternative), * (zero-or-more), and + (one-or-more). Example: :person :knows+ :influencer finds all paths of any length.
• Negation: Filter results using FILTER NOT EXISTS and MINUS to exclude specific graph patterns.
• Assignment: Create new values in results with the BIND keyword.

A standardized language for modifying RDF graph stores, enabling full CRUD operations.

• Insert Data: INSERT DATA { :alice :knows :bob . } adds triples.
• Delete Data: DELETE DATA { :alice :knows :bob . } removes specific triples.
• Load: LOAD <http://example.com/data.ttl> imports remote RDF documents.
• Modify Operations: Combine DELETE and INSERT in a single operation with WHERE clause patterns for conditional updates. Example: Replacing a manager relationship.
• Clear/Drop: CLEAR GRAPH <http://example.com/graph> or DROP ALL for managing graph store contents.

The SERVICE keyword enables federated querying, distributing a single query across multiple remote SPARQL endpoints.

• Syntax: SELECT * WHERE { SERVICE <https://dbpedia.org/sparql> { ?s ?p ?o } }
• Use Case: Integrate data from disparate sources (e.g., query internal product data alongside public DBpedia entities) without pre-loading all data into a single triplestore.
• Optimization: The query engine handles communication, merging results, and can push filters to remote services. Performance depends on network latency and remote endpoint capabilities.

Defines how a SPARQL query processor applies semantic reasoning over RDF Schema (RDFS) or Web Ontology Language (OWL) ontologies.

• Simple Entailment: Basic pattern matching with no inference.
• RDFS Entailment: Infers triples based on RDFS semantics (e.g., rdfs:subClassOf, rdfs:subPropertyOf). A query for ?s a :Employee will also return instances of subclasses like :Manager.
• OWL Direct & RDF-Based Entailment: Applies different levels of OWL reasoning. This allows queries to return implicit knowledge derived from complex ontological axioms, integrating querying with a semantic reasoning engine.

Standardizes how SPARQL queries and updates are transmitted over HTTP, enabling interoperability between clients and servers.

• Operations: Defines HTTP methods and parameters for query (GET/POST), update (POST), and fetching the service description.
• Response Formats: Specifies standard MIME types for results: application/sparql-results+json or +xml for SELECT/ASK, and text/turtle or application/rdf+xml for CONSTRUCT/DESCRIBE.
• Service Description: A machine-readable description of a SPARQL endpoint's features, supported entailment regimes, and functions, accessible via a GET request to the endpoint URL.

Greatly expands the function library for manipulating values within query patterns and filters.

• String Functions: SUBSTR, STRSTARTS, CONCAT, REPLACE, STRLEN.
• Numeric Functions: ABS, ROUND, RAND.
• Date/Time Functions: YEAR, MONTH, HOUR from xsd:dateTime values.
• Type Casting & Conversion: STR, URI, xsd:integer, xsd:dateTime.
• Hash Functions: MD5, SHA1, SHA256 for generating checksums.
• XPath Constructors: Functions for handling RDF literals with XML Schema datatypes.

The foundational query for retrieving data from an RDF graph. It uses a WHERE clause to specify a graph pattern of triples to match.

Example: Find all employees and their job titles.

sparqlCopy
PREFIX ex: <http://example.org/>
SELECT ?employee ?title
WHERE {
  ?employee ex:jobTitle ?title .
}

• PREFIX: Defines a shorthand for long URIs.
• SELECT: Specifies the variables to return.
• WHERE: Contains the triple patterns to match.
• The dot (.): Separates triple patterns, implying a conjunction (AND).

Refines results and handles missing data. FILTER restricts results using boolean expressions. OPTIONAL matches patterns without failing the entire query if no match is found.

Example: Find employees in the Engineering department, optionally returning their manager.

sparqlCopy
PREFIX ex: <http://example.org/>
SELECT ?employee ?manager
WHERE {
  ?employee ex:department "Engineering" .
  ?employee ex:name ?name .
  OPTIONAL { ?employee ex:reportsTo ?manager . }
  FILTER (regex(?name, "^J", "i"))
}

• FILTER (regex(...)): Uses a regular expression to find names starting with 'J' (case-insensitive).
• OPTIONAL: The ?manager variable will be bound if the relationship exists, else it remains unbound.

Groups results and applies aggregate functions like COUNT, SUM, AVG, MIN, and MAX.

Example: Count the number of employees per department.

sparqlCopy
PREFIX ex: <http://example.org/>
SELECT ?dept (COUNT(?emp) AS ?empCount)
WHERE {
  ?emp ex:department ?dept .
}
GROUP BY ?dept
ORDER BY DESC(?empCount)

• GROUP BY ?dept: Creates a result group for each unique department value.
• (COUNT(?emp) AS ?empCount): Counts employees per group and assigns the result to a new variable.
• ORDER BY DESC(...): Orders the final results by the count, highest first.

A SPARQL 1.1 feature for concise expression of graph traversals and paths of arbitrary length, using operators like / (sequence), | (alternative), * (zero or more), and + (one or more).

Example: Find all employees who report to ex:CTO directly or indirectly.

sparqlCopy
PREFIX ex: <http://example.org/>
SELECT ?subordinate
WHERE {
  ?subordinate ex:reportsTo+ ex:CTO .
}

• ex:reportsTo+: The + operator matches one or more reportsTo relationships, finding the entire reporting chain.
• ex:reportsTo*: Would also include the CTO themselves (zero steps).
• ex:reportsTo/ex:manages: Would match a two-step path.

SPARQL 1.1 extends the language with update operations to modify the RDF dataset. INSERT DATA adds triples, DELETE DATA removes them, and DELETE/INSERT (with WHERE) performs conditional updates.

Example: Promote an employee to a new role.

sparqlCopy
PREFIX ex: <http://example.org/>
DELETE { ex:Alice ex:title "Engineer" . }
INSERT { ex:Alice ex:title "Senior Engineer" . }
WHERE {
  ex:Alice ex:title "Engineer" .
}

• DELETE/INSERT: The WHERE clause finds the specific triple to modify.
• INSERT DATA: For unconditional insertion of static triples.
• Updates are executed within a transaction to ensure atomicity.