sparql 3.2.0 → 3.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ecbe9289bf43f7fa28940a82545ec08b19c54d8bdf64693934405e83ddb4cc53
-  data.tar.gz: 24ab0942be18a9d9d281452ba9a7195dcad2a31755bda6d84afe4f49fe7c34c1
+  metadata.gz: 932897287930ea7265a07628e73c13a06b02b9e0d1572b578356166d3c8fe70a
+  data.tar.gz: 9d17310bc07080475780c8acccbe57acb4bbeb40e3f66ab7b74a09b15ccf0863
 SHA512:
-  metadata.gz: 89a77c749eb99b0fe83f27d5f413556ac2f6cf22af7e06b8e0588155bbf5a50eb053b1f87ffe11a13b5fd873d5fcaaee1166cdf336aacd3029380898a82da382
-  data.tar.gz: 13be95c405b9fdf7e678bc9bbaf6dcc45075a692a08e1762deacc0779948996fdc992376f3a564644f50270282c76a759023d7393e28db07ec7828a73324a948
+  metadata.gz: e701784500aece828b2cfd41eb0af78a809bda575eed047158e962ff38678d524b179c0c3faef21fc5b5724894ada3066637b608778a1809fdc7b9bda2ffe2a2
+  data.tar.gz: 77c2520a5f4923a1fe27d589ea6a09b6f5a36fa9c17b564184f206971204fec6988b0941c350e10d812ccfd9b0934e6ae629b82207abfaabf8d7bcc3a380ab33

data/README.md

@@ -1,6 +1,6 @@
-# SPARQL for RDF.rb
+# SPARQL Query and Update library for Ruby
 
-This is a [Ruby][] implementation of [SPARQL][] for [RDF.rb][].
+An implementation of [SPARQL][] for [RDF.rb][].
 
 [![Gem Version](https://badge.fury.io/rb/sparql.png)](https://badge.fury.io/rb/sparql)
 [![Build Status](https://github.com/ruby-rdf/sparql/workflows/CI/badge.svg?branch=develop)](https://github.com/ruby-rdf/sparql/actions?query=workflow%3ACI)
@@ -17,11 +17,13 @@ This is a [Ruby][] implementation of [SPARQL][] for [RDF.rb][].
   or HTML.
 * SPARQL CONSTRUCT or DESCRIBE serialized based on Format, Extension of Mime Type
   using available RDF Writers (see [Linked Data][])
-* SPARQL Client for accessing remote SPARQL endpoints.
-* SPARQL Update
+* SPARQL Client for accessing remote SPARQL endpoints (via [sparql-client](https://github.com/ruby-rdf/sparql-client)).
+* [SPARQL 1.1 Protocol][] (via {SPARQL::Server}).
+* [SPARQL 1.1 Update][]
 * [Rack][] and [Sinatra][] middleware to perform [HTTP content negotiation][conneg] for result formats
   * Compatible with any [Rack][] or [Sinatra][] application and any Rack-based framework.
   * Helper method for describing [SPARQL Service Description][SSD]
+  * Helper method for setting up datasets as part of the [SPARQL 1.1 Protocol][].
 * Implementation Report: {file:etc/earl.html EARL}
 * Compatible with Ruby >= 2.6.
 * Supports Unicode query strings both on all versions of Ruby.
@@ -29,11 +31,12 @@ This is a [Ruby][] implementation of [SPARQL][] for [RDF.rb][].
 
 ## Description
 
-The {SPARQL} gem implements [SPARQL 1.1 Query][], and [SPARQL 1.1 Update][], and provides [Rack][] and [Sinatra][] middleware to provide results using [HTTP Content Negotiation][conneg].
+The {SPARQL} gem implements [SPARQL 1.1 Query][], and [SPARQL 1.1 Update][], and provides [Rack][] and [Sinatra][] middleware to provide results using [HTTP Content Negotiation][conneg] and to support [SPARQL 1.1 Protocol][].
 
 * {SPARQL::Grammar} implements a [SPARQL 1.1 Query][] and [SPARQL 1.1 Update][] parser generating [SPARQL S-Expressions (SSE)][SSE].
 * {SPARQL::Algebra} executes SSE against Any `RDF::Graph` or `RDF::Repository`, including compliant [RDF.rb][] repository adaptors such as [RDF::DO][] and [RDF::Mongo][].
 * {Rack::SPARQL} and {Sinatra::SPARQL} provide middleware components to format results using an appropriate format based on [HTTP content negotiation][conneg].
+* {SPARQL::Server} implements the [SPARQL 1.1 Protocol][] using {Sinatra::SPARQL}.
 
 ### [SPARQL 1.1 Query][] Extensions and Limitations
 The {SPARQL} gem uses the [SPARQL 1.1 Query][] {file:etc/sparql11.html EBNF grammar}, which provides much more capability than [SPARQL 1.0][], but has a few limitations:
@@ -62,17 +65,22 @@ The gem also includes the following [SPARQL 1.1 Update][] operations:
 Not supported:
 
 * [Federated Query][SPARQL 1.1 Federated Query],
-* [Entailment Regimes][SPARQL 1.1 Entailment Regimes],
-* [Protocol][SPARQL 1.1 Protocol], and
-* [Graph Store HTTP Protocol][SPARQL 1.1 Graph Store HTTP Protocol]
-
-either in this, or related gems.
+* [Entailment Regimes][SPARQL 1.1 Entailment Regimes], and
+* [Graph Store HTTP Protocol][SPARQL 1.1 Graph Store HTTP Protocol] but the closely related [Linked Data Platform][] implemented in [rdf-ldp](https://github.com/ruby-rdf/rdf-ldp) supports these use cases.
 
 ### Updates for RDF 1.1
 Starting with version 1.1.2, the SPARQL gem uses the 1.1 version of the [RDF.rb][], which adheres to [RDF 1.1 Concepts](https://www.w3.org/TR/rdf11-concepts/) rather than [RDF 1.0](https://www.w3.org/TR/rdf-concepts/). The main difference is that there is now no difference between a _Simple Literal_ (a literal with no datatype or language) and a Literal with datatype _xsd:string_; this causes some minor differences in the way in which queries are understood, and when expecting different results.
 
 Additionally, queries now take a block, or return an `Enumerator`; this is in keeping with much of the behavior of [RDF.rb][] methods, including `Queryable#query`, and with version 1.1 or [RDF.rb][], Query#execute. As a consequence, all queries which used to be of the form `query.execute(repository)` may equally be called as `repository.query(query)`. Previously, results were returned as a concrete class implementing `RDF::Queryable` or `RDF::Query::Solutions`, these are now `Enumerators`.
 
+### SPARQL 1.2
+The gem supports some of the extensions proposed by the [SPARQL 1.2 Community Group](https://github.com/w3c/sparql-12). In particular, the following extensions are now implemented:
+
+* [SEP-0002: better support for Durations, Dates, and Times](https://github.com/w3c/sparql-12/blob/main/SEP/SEP-0002/sep-0002.md)
+  * This includes full support for `xsd:date`, `xsd:time`, `xsd:duration`, `xsd:dayTimeDuration`, and `xsd:yearMonthDuration` along with associated XPath/XQuery functions including a new `ADJUST` builtin. (**Note: This feature is subject to change or elimination as the standards process progresses.**)
+* [SEP-0003: Property paths with a min/max hop](https://github.com/w3c/sparql-12/blob/main/SEP/SEP-0003/sep-0003.md)
+  * This includes support for non-counting path forms such as `rdf:rest{1,3}` to match the union of paths `rdf:rest`, `rdf:rest/rdf:rest`, and `rdf:rest/rdf:rest/rdf:rest`.  (**Note: This feature is subject to change or elimination as the standards process progresses.**)
+
 ### SPARQL Extension Functions
 Extension functions may be defined, which will be invoked during query evaluation. For example:
 
@@ -95,6 +103,10 @@ Then, use the function in a query:
 
 See {SPARQL::Algebra::Expression.register_extension} for details.
 
+### Variable Pre-binding
+
+A call to execute a parsed query can include pre-bound variables, which cause queries to be executed with matching variables bound as defined. Variable pre-binding can be done using a Hash structure, or a Query Solution.  See [Query with Binding example](#query-with-binding) and {SPARQL::Algebra::Query#execute}.
+
 ### SPARQLStar (SPARQL-star)
 
 The gem supports [SPARQL-star][] where patterns may include sub-patterns recursively, for a kind of Reification.
@@ -162,44 +174,31 @@ Note that results can be serialized only when the format supports [RDF-star][].
 
 #### SPARQL results
 
-The SPARQL results formats are extended to serialize embedded triples as described for [RDF4J](https://rdf4j.org/documentation/programming/rdfstar/):
+The SPARQL results formats are extended to serialize quoted triples as described for [RDF4J](https://rdf4j.org/documentation/programming/rdfstar/):
 
     {
       "head" : {
-        "vars" : [
-          "a",
-          "b",
-          "c"
-        ]
+        "vars" : ["a", "b", "c"]
       },
       "results" : {
         "bindings": [
           { "a" : {
               "type" : "triple",
               "value" : {
-                "s" : {
-                  "type" : "uri",
-                  "value" : "http://example.org/bob"
-                },
-                "p" : {
-                  "type" : "uri",
-                  "value" : "http://xmlns.com/foaf/0.1/name"
-                },
+                "s" : {"value" : "http://example.org/bob", "type": "uri"},
+                "p" : {"value" : "http://xmlns.com/foaf/0.1/name", "type": "uri"},
                 "o" : {
-                  "datatype" : "http://www.w3.org/2001/XMLSchema#integer",
+                  "value" : "23",
                   "type" : "literal",
-                  "value" : "23"
+                  "datatype" : "http://www.w3.org/2001/XMLSchema#integer"
                 }
               }
             },
-            "b": { 
-              "type": "uri",
-              "value": "http://example.org/certainty"
-            },
+            "b": {"value": "http://example.org/certainty", "type": "uri"},
             "c" : {
-              "datatype" : "http://www.w3.org/2001/XMLSchema#decimal",
+              "value" : "0.9",
               "type" : "literal",
-              "value" : "0.9"
+              "datatype" : "http://www.w3.org/2001/XMLSchema#decimal"
             }
           }
         ]
@@ -214,17 +213,23 @@ You would typically return an instance of `RDF::Graph`, `RDF::Repository` or an
 from your Rack application, and let the `Rack::SPARQL::ContentNegotiation` middleware
 take care of serializing your response into whatever format the HTTP
 client requested and understands.
+Content negotiation also transforms `application/x-www-form-urlencoded` to either `application/sparql-query`
+or `application/sparql-update` as appropriate for [SPARQL 1.1 Protocol][].
 
 {Sinatra::SPARQL} is a thin Sinatra-specific wrapper around the
 {Rack::SPARQL} middleware, which implements SPARQL
  content negotiation for Rack applications. {Sinatra::SPARQL} also supports
- [SPARQL 1.1 Service Description][].
+ [SPARQL 1.1 Service Description][] (via {Sinatra::SPARQL::Helpers.service_description} and protocol-based dataset mangement via {Sinatra::SPARQL::Helpers.dataset} for `default-graph-uri` and `named-graph-uri` The `using-graph-uri` and `using-named-graph-uri` query parameters are managed through {SPARQL::Algebra::Operator::Modify#execute}.
 
 The middleware queries [RDF.rb][] for the MIME content types of known RDF
 serialization formats, so it will work with whatever serialization extensions
 that are currently available for RDF.rb. (At present, this includes support
 for N-Triples, N-Quads, Turtle, RDF/XML, RDF/JSON, JSON-LD, RDFa, TriG and TriX.)
 
+### Server
+
+A simple [Sinatra][]-based server is implemented in {SPARQL::Server.application} using {Rack::SPARQL} and {Sinatra::SPARQL} completes the implementation of [SPARQL 1.1 Protocol][] and can be used to compose a server including other capabilities.
+
 ### Remote datasets
 
 A SPARQL query containing `FROM` or `FROM NAMED` (also `UPDATE` or `UPDATE NAMED`) will load the referenced IRI unless the repository already contains a graph with that same IRI. This is performed using [RDF.rb][] `RDF::Util::File.open_file` passing HTTP Accept headers for various available RDF formats. For best results, require [Linked Data][] to enable a full set of RDF formats in the `GET` request. Also, consider overriding `RDF::Util::File.open_file` with an implementation with support for HTTP Get headers (such as `Net::HTTP`).
@@ -281,9 +286,25 @@ a full set of RDF formats.
 
 ### Parsing a SSE to SPARQL query or update string to SPARQL
 
+    # Note: if the SSE uses extension functions, they either must be XSD casting functions, or custom functions which are registered extensions. (See [SPARQL Extension Functions](#sparql-extension-functions))
+
     query = SPARQL::Algebra.parse(%{(bgp (triple ?s ?p ?o))})
     sparql = query.to_sparql #=> "SELECT * WHERE { ?s ?p ?o }"
 
+### Query with Binding
+
+    bindings = {page: RDF::URI("https://greggkellogg.net/")}
+    queryable = RDF::Repository.load("etc/doap.ttl")
+    query = SPARQL.parse(%(
+      PREFIX foaf: <http://xmlns.com/foaf/0.1/>
+      SELECT ?person
+      WHERE {
+        ?person foaf:homepage ?page .
+      }
+    ))
+    solutions = query.execute(queryable, bindings: bindings)
+    solutions.to_sxp #=> (((person <https://greggkellogg.net/foaf#me>)))
+
 ### Command line processing
 
     sparql execute --dataset etc/doap.ttl etc/from_default.rq
@@ -433,7 +454,7 @@ This repository uses [Git Flow](https://github.com/nvie/gitflow) to mange develo
 ## License
 
 This is free and unencumbered public domain software. For more information,
-see <https://unlicense.org/> or the accompanying {file:UNLICENSE} file.
+see <https://unlicense.org/> or the accompanying {file:UNLICENSE}.
 
 A copy of the [SPARQL EBNF][] and derived parser files are included in the repository, which are not covered under the UNLICENSE. These files are covered via the [W3C Document License](https://www.w3.org/Consortium/Legal/2002/copyright-documents-20021231).
 
@@ -452,14 +473,14 @@ A copy of the [SPARQL 1.0 tests][] and [SPARQL 1.1 tests][] are also included in
 [SPARQL 1.0 tests]:https://www.w3.org/2001/sw/DataAccess/tests/
 [SPARQL 1.1 tests]: https://www.w3.org/2009/sparql/docs/tests/
 [SSE]:              https://jena.apache.org/documentation/notes/sse.html
-[SXP]:              https://www.rubydoc.info/github/dryruby/sxp
+[SXP]:              https://dryruby.github.io/sxp
 [grammar]:          https://www.w3.org/TR/sparql11-query/#grammar
 [RDF 1.1]:          https://www.w3.org/TR/rdf11-concepts
-[RDF.rb]:           https://rubydoc.info/github/ruby-rdf/rdf
+[RDF.rb]:           https://ruby-rdf.github.io/rdf
 [RDF-star]:             https://w3c.github.io/rdf-star/rdf-star-cg-spec.html
 [SPARQL-star]:          https://w3c.github.io/rdf-star/rdf-star-cg-spec.html#sparql-query-language
 [Linked Data]:      https://rubygems.org/gems/linkeddata
-[SPARQL doc]:       https://rubydoc.info/github/ruby-rdf/sparql/frames
+[SPARQL doc]:       https://ruby-rdf.github.io/sparql/frames
 [SPARQL XML]:       https://www.w3.org/TR/rdf-sparql-XMLres/
 [SPARQL JSON]:      https://www.w3.org/TR/rdf-sparql-json-res/
 [SPARQL EBNF]:      https://www.w3.org/TR/sparql11-query/#sparqlGrammar
@@ -479,4 +500,4 @@ A copy of the [SPARQL 1.0 tests][] and [SPARQL 1.1 tests][] are also included in
 [SPARQL 1.1 Entailment Regimes]:                https://www.w3.org/TR/sparql11-entailment/
 [SPARQL 1.1 Protocol]:                          https://www.w3.org/TR/sparql11-protocol/
 [SPARQL 1.1 Graph Store HTTP Protocol]:         https://www.w3.org/TR/sparql11-http-rdf-update/
-
+[Linked Data Platform]: https://www.w3.org/TR/ldp/

data/VERSION

@@ -1 +1 @@
-3.2.0
+3.2.4

data/bin/sparql

@@ -63,39 +63,10 @@ def run(input, **options)
 end
 
 def server(options)
-  require 'sinatra/sparql'
-  repository = options.fetch(:dataset, RDF::Repository.new)
-
-  app = Sinatra.new do
-    register Sinatra::SPARQL
-    set :repository, repository
-
-    before do
-      options[:logger].info "#{request.request_method} [#{request.path_info}], " +
-        params.merge(Accept: request.accept.map(&:to_s)).map {|k,v| "#{k}=#{v}" unless k.to_s == "content"}.join(" ")
-    end
-
-    get '/' do
-      if params["query"]
-        query = params["query"].to_s.match(/^http:/) ? RDF::Util::File.open_file(params["query"]) : ::CGI.unescape(params["query"].to_s)
-        SPARQL.execute(query, settings.repository)
-      else
-        settings.sparql_options.replace(standard_prefixes: true)
-        settings.sparql_options.merge!(:prefixes => {
-          ssd: "http://www.w3.org/ns/sparql-service-description#",
-          void: "http://rdfs.org/ns/void#"
-        })
-        service_description(repo: settings.repository, endpoint: url)
-      end
-    end
-
-    post '/' do
-      SPARQL.execute(params['query'], settings.repository)
-    end
-  end
+  app = SPARQL::Server.application(**options)
   Rack::Server.start(app: app, Port: options.fetch(:port, 9292))
 rescue LoadError
-  $stderr.puts "Running SPARQL server requires Rack to be in environment: #{$!.message}"
+  $stderr.puts "Running SPARQL server requires Rack and Sinatra to be in environment: #{$!.message}"
 end
 
 def usage

data/lib/rack/sparql/conneg.rb

@@ -39,15 +39,36 @@ module Rack; module SPARQL
     # If result is `RDF::Literal::Boolean`, `RDF::Query::Results`, or `RDF::Enumerable`
     # The result is serialized using {SPARQL::Results}
     #
-    # Inserts ordered content types into the environment as `ORDERED_CONTENT_TYPES` if an Accept header is present
+    # Inserts ordered content types into the environment as `ORDERED_CONTENT_TYPES` if an Accept header is present.
+    #
+    # Normalizes `application/x-www-form-urlencoded` to either `application/sparql-query` or `application/sparql-update` forms.
     #
     # @param  [Hash{String => String}] env
     # @return [Array(Integer, Hash, #each)]
     # @see    https://www.rubydoc.info/github/rack/rack/Rack/Runtime#call-instance_method
     def call(env)
       env['ORDERED_CONTENT_TYPES'] = parse_accept_header(env['HTTP_ACCEPT']) if env.has_key?('HTTP_ACCEPT')
+      # Normalize application/x-www-form-urlencoded to application/sparql-query or application/sparql-update
+      if env['REQUEST_METHOD'] == 'POST' && env.fetch('CONTENT_TYPE', 'application/x-www-form-urlencoded').to_s.start_with?('application/x-www-form-urlencoded')
+        content = env['rack.input'].read
+        params = Rack::Utils.parse_query(content)
+        if query = params.delete('query')
+          return [406, {"Content-Type" => "text/plain"}, ["Multiple query parameters"]] unless query.is_a?(String)
+          env['rack.input'] = StringIO.new(query)
+          env['CONTENT_TYPE'] = 'application/sparql-query'
+          env['QUERY_STRING'] = Rack::Utils.build_query(params)
+        elsif update = params.delete('update')
+          return [406, {"Content-Type" => "text/plain"}, ["Multiple update parameters"]] unless update.is_a?(String)
+          env['rack.input'] = StringIO.new(update)
+          env['CONTENT_TYPE'] = 'application/sparql-update'
+          env['QUERY_STRING'] = Rack::Utils.build_query(params)
+        else
+          env['rack.input'].rewind # never mind
+        end
+      end
       response = app.call(env)
       body = response[2].respond_to?(:body) ? response[2].body : response[2]
+      body = body.first if body.is_a?(Array) && body.length == 1 && body.first.is_a?(RDF::Literal::Boolean)
       case body
       when RDF::Enumerable, RDF::Query::Solutions, RDF::Literal::Boolean
         response[2] = body  # Put it back in the response, it might have been a proxy

data/lib/sinatra/sparql/extensions.rb

@@ -11,7 +11,7 @@ class Sinatra::Response
 
     # Rack::Response#finish sometimes returns self as response body. We don't want that.
     status, headers, result = super
-    result = body if result == self
+    result = body if self == result
     [status, headers, result]
   end
 end

data/lib/sinatra/sparql.rb

@@ -1,6 +1,7 @@
 require 'sinatra/base'
 require 'sinatra/sparql/extensions'
 require 'rack/sparql'
+require 'rdf/aggregate_repo'
 
 module Sinatra
   ##
@@ -13,6 +14,7 @@ module Sinatra
     ##
     # Helper methods.
     module Helpers
+
       ##
       # This is useful when a GET request is performed against a SPARQL endpoint and no query is performed. Provide a set of datasets, including a default dataset along with optional triple count, dump location, and description of the dataset.
       #
@@ -36,23 +38,36 @@ module Sinatra
       
         node = RDF::Node.new
         g << [node, RDF.type, sd.join("#Service")]
-        g << [node, sd.join("#endpoint"), options[:endpoint] || url("/sparql")]
+        g << [node, sd.join("#endpoint"), RDF::URI(url(options.fetch(:endpoint, "/sparql")))]
+        g << [node, sd.join("#supportedLanguage"), sd.join("#SPARQL10Query")]
         g << [node, sd.join("#supportedLanguage"), sd.join("#SPARQL11Query")]
+        g << [node, sd.join("#supportedLanguage"), sd.join("#SPARQL11Update")]
+        g << [node, sd.join("#supportedLanguage"), RDF::URI('http://www.w3.org/ns/rdf-star#SPARQLStarQuery')]
+        g << [node, sd.join("#supportedLanguage"), RDF::URI('http://www.w3.org/ns/rdf-star#SPARQLStarUpdate')]
       
+        # Input formats
+        RDF::Reader.map(&:format).select(&:to_uri).each do |format|
+          g << [node, sd.join("#inputFormat"), format.to_uri]
+        end
+
         # Result formats, both RDF and SPARQL Results.
-        # FIXME: We should get this from the avaliable serializers
-        g << [node, sd.join("#resultFormat"), RDF::URI("http://www.w3.org/ns/formats/RDF_XML")]
-        g << [node, sd.join("#resultFormat"), RDF::URI("http://www.w3.org/ns/formats/Turtle")]
-        g << [node, sd.join("#resultFormat"), RDF::URI("http://www.w3.org/ns/formats/RDFa")]
-        g << [node, sd.join("#resultFormat"), RDF::URI("http://www.w3.org/ns/formats/N-Triples")]
-        g << [node, sd.join("#resultFormat"), RDF::URI("http://www.w3.org/ns/formats/SPARQL_Results_XML")]
-        g << [node, sd.join("#resultFormat"), RDF::URI("http://www.w3.org/ns/formats/SPARQL_Results_JSON")]
-        g << [node, sd.join("#resultFormat"), RDF::URI("http://www.w3.org/ns/formats/SPARQL_Results_CSV")]
-        g << [node, sd.join("#resultFormat"), RDF::URI("http://www.w3.org/ns/formats/SPARQL_Results_TSV")]
-      
+        %w(
+          http://www.w3.org/ns/formats/SPARQL_Results_XML
+          http://www.w3.org/ns/formats/SPARQL_Results_JSON
+          http://www.w3.org/ns/formats/SPARQL_Results_CSV
+          http://www.w3.org/ns/formats/SPARQL_Results_TSV
+        ).each do |uri|
+          g << [node, sd.join("#resultFormat"), uri]
+        end
+
+        RDF::Writer.map(&:format).select(&:to_uri).each do |format|
+          g << [node, sd.join("#resultFormat"), format.to_uri]
+        end
+
         # Features
         g << [node, sd.join("#feature"), sd.join("#DereferencesURIs")]
-      
+        #g << [node, sd.join("#feature"), sd.join("#BasicFederatedQuery")]
+
         # Datasets
         ds = RDF::Node.new
         g << [node, sd.join("#defaultDataset"), ds]
@@ -86,6 +101,36 @@ module Sinatra
         end
         g
       end
+
+      ##
+      # This either creates a merge repo, or uses the standard repository for performing the query, based on the parameters passed (`default-graph-uri` and `named-graph-uri`).
+      # Loads from the datasource, unless a graph named by
+      # the datasource URI already exists in the repository.
+      #
+      # @return [RDF::Dataset]
+      # @see Algebra::Operator::Dataset
+      def dataset(**options)
+        logger = options.fetch(:logger, ::Logger.new(false))
+        repo = settings.repository
+        if %i(default-graph-uri named-graph-uri).any? {|k| options.key?(k)}        
+          default_datasets = Array(options[:"default-graph-uri"]).map {|u| RDF::URI(u)}
+          named_datasets = Array(options[:"named-graph-uri"]).map {|u| RDF::URI(u)}
+
+          (default_datasets + named_datasets).each do |uri|
+            load_opts = {logger: logger, graph_name: uri, base_uri: uri}
+            unless repo.has_graph?(uri)
+              logger.debug(options) {"=> load #{uri}"}
+              repo.load(uri.to_s, **load_opts)
+            end
+          end
+
+          # Create an aggregate based on queryable having just the bits we want
+          aggregate = RDF::AggregateRepo.new(repo)
+          named_datasets.each {|name| aggregate.named(name) if repo.has_graph?(name)}
+          aggregate.default(*default_datasets.select {|name| repo.has_graph?(name)})
+          aggregate
+        end || settings.repository
+      end
     end
 
     ##

data/lib/sparql/algebra/expression.rb

@@ -6,6 +6,19 @@ module SPARQL; module Algebra
   module Expression
     include RDF::Util::Logger
 
+    # Operators for which `:triple` denotes a pattern, not a builtin
+    PATTERN_PARENTS = [
+      Operator::BGP,
+      Operator::Construct,
+      Operator::Delete,
+      Operator::DeleteData,
+      Operator::DeleteWhere,
+      Operator::Graph,
+      Operator::Insert,
+      Operator::InsertData,
+      Operator::Path,
+    ].freeze
+
     ##
     # @example
     #   Expression.parse('(isLiteral 3.1415)')
@@ -66,9 +79,11 @@ module SPARQL; module Algebra
     #
     # @param  [Array] sse
     #   a SPARQL S-Expression (SSE) form
+    # @param  [Hash{Symbol => Object}] options
+    #   any additional options (see {Operator#initialize})
     # @return [Expression]
-    def self.for(*sse)
-      self.new(sse)
+    def self.for(*sse, **options)
+      self.new(sse, **options)
     end
     class << self; alias_method :[], :for; end
 
@@ -82,20 +97,27 @@ module SPARQL; module Algebra
     #   any additional options (see {Operator#initialize})
     # @return [Expression]
     # @raise  [TypeError] if any of the operands is invalid
-    def self.new(sse, **options)
+    def self.new(sse, parent_operator: nil, **options)
       raise ArgumentError, "invalid SPARQL::Algebra::Expression form: #{sse.inspect}" unless sse.is_a?(Array)
 
       operator = Operator.for(sse.first, sse.length - 1)
+
+      # If we don't find an operator, and sse.first is an extension IRI, use a function call
+      if !operator && sse.first.is_a?(RDF::URI) && self.extension?(sse.first)
+        operator = Operator.for(:function_call, sse.length)
+        sse.unshift(:function_call)
+      end
+
       unless operator
         return case sse.first
         when Array
           debug(options) {"Map array elements #{sse}"}
-          sse.map {|s| self.new(s, depth: options[:depth].to_i + 1, **options)}
+          sse.map {|s| self.new(s, parent_operator: parent_operator, depth: options[:depth].to_i + 1, **options)}
         else
           debug(options) {"No operator found for #{sse.first}"}
           sse.map do |s|
             s.is_a?(Array) ?
-              self.new(s, depth: options[:depth].to_i + 1) :
+              self.new(s, parent_operator: parent_operator, depth: options[:depth].to_i + 1) :
               s
           end
         end
@@ -105,7 +127,7 @@ module SPARQL; module Algebra
         debug(options) {"Operator=#{operator.inspect}, Operand=#{operand.inspect}"}
         case operand
           when Array
-            self.new(operand, depth: options[:depth].to_i + 1, **options)
+            self.new(operand, parent_operator: operator, depth: options[:depth].to_i + 1, **options)
           when Operator, Variable, RDF::Term, RDF::Query, Symbol
             operand
           when TrueClass, FalseClass, Numeric, String, DateTime, Date, Time
@@ -115,11 +137,22 @@ module SPARQL; module Algebra
       end
 
       debug(options) {"#{operator.inspect}(#{operands.map(&:inspect).join(',')})"}
+      logger = options[:logger]
       options.delete_if {|k, v| [:debug, :logger, :depth, :prefixes, :base_uri, :update, :validate].include?(k) }
       begin
-        operator.new(*operands, **options)
+        # Due to confusion over (triple) and special-case for (qtriple)
+        if operator == RDF::Query::Pattern
+          options = options.merge(quoted: true) if sse.first == :qtriple
+        elsif operator == Operator::Triple && PATTERN_PARENTS.include?(parent_operator)
+          operator = RDF::Query::Pattern
+        end
+        operator.new(*operands, parent_operator: operator, **options)
       rescue ArgumentError => e
-        error(options) {"Operator=#{operator.inspect}: #{e}"}
+        if logger
+          logger.error("Operator=#{operator.inspect}: #{e}")
+        else
+          raise "Operator=#{operator.inspect}: #{e}"
+        end
       end
     end
 
@@ -163,6 +196,17 @@ module SPARQL; module Algebra
       @extensions ||= {}
     end
 
+    ##
+    # Is an extension function available?
+    #
+    # It's either a registered extension, or an XSD casting function
+    #
+    # @param [RDF::URI] function
+    # @return [Boolean]
+    def self.extension?(function)
+      function.to_s.start_with?(RDF::XSD.to_s) || self.extensions[function]
+    end
+
     ##
     # Invoke an extension function.
     #
@@ -190,7 +234,7 @@ module SPARQL; module Algebra
     #
     # @param [RDF::URI] datatype
     #   Datatype to evaluate, one of:
-    #   xsd:integer, xsd:decimal xsd:float, xsd:double, xsd:string, xsd:boolean, or xsd:dateTime
+    #   xsd:integer, xsd:decimal xsd:float, xsd:double, xsd:string, xsd:boolean, xsd:dateTime, xsd:duration, xsd:dayTimeDuration, xsd:yearMonthDuration
     # @param [RDF::Term] value
     #   Value, which should be a typed literal, where the type must be that specified
     # @raise [TypeError] if datatype is not a URI or value cannot be cast to datatype
@@ -198,7 +242,7 @@ module SPARQL; module Algebra
     # @see https://www.w3.org/TR/sparql11-query/#FunctionMapping
     def self.cast(datatype, value)
       case datatype
-      when RDF::XSD.dateTime
+      when RDF::XSD.date, RDF::XSD.time, RDF::XSD.dateTime
         case value
         when RDF::Literal::DateTime, RDF::Literal::Date, RDF::Literal::Time
           RDF::Literal.new(value, datatype: datatype)
@@ -207,6 +251,15 @@ module SPARQL; module Algebra
         else
           RDF::Literal.new(value.value, datatype: datatype, validate: true)
         end
+      when RDF::XSD.duration, RDF::XSD.dayTimeDuration, RDF::XSD.yearMonthDuration
+        case value
+        when RDF::Literal::Duration, RDF::Literal::DayTimeDuration, RDF::Literal::YearMonthDuration
+          RDF::Literal.new(value, datatype: datatype, validate: true, canonicalize: true)
+        when RDF::Literal::Numeric, RDF::Literal::Boolean, RDF::URI, RDF::Node
+          raise TypeError, "Value #{value.inspect} cannot be cast as #{datatype}"
+        else
+          RDF::Literal.new(value.value, datatype: datatype, validate: true, canonicalize: true)
+        end
       when RDF::XSD.float, RDF::XSD.double
         case value
         when RDF::Literal::Boolean