sparql 3.2.1 → 3.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e9bcab10eb6706316b68b44a0fd917d7b735b18a8353b51e49ef124fc966176d
-  data.tar.gz: 6da59b4e90fd1b7a7d80c42d941f7c27f6bf95892d17302caf16a13809b03afa
+  metadata.gz: 853c52b99bab0b9455b25a81c8c946e5bcb1429dddadf010b66315f1dbafda51
+  data.tar.gz: 90d89877c031476efdaa1d0b119b2a2404925186b4e0b3de99818d75ead76bff
 SHA512:
-  metadata.gz: d2f99aee7d5b9482bbd653333eeefd215da872291993a2ba138ed9bcfc3f92812672cd1508dfbd11a729d527c9724f0a80ec816c5c84fd2df9933b4b91b5a296
-  data.tar.gz: 41a11caf8e85ca4bd01213bb0c0c236314560338dbd2825bd2437afbf4fd9855b994150737dbcad00838dc5ac50e368d72e5bfe2e516566a6319f824bdcacc56
+  metadata.gz: 98816c81664147aa0fa4ccd90ed14461eb51b652b011395f38f044934c2ff335197fbc3d2d7f447771a5b1e46fa24042aef45fd1f95356b91f52bafee48d1a72
+  data.tar.gz: 5545d7ddd245d73382229ed6f9996b24bd66a4285ee18d6295f697202ad5901eb4221cbf2533ef1539b98ccc0c095519e531b541db3e1c4757d813ab888cb9fd

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`).
@@ -286,6 +291,20 @@ a full set of RDF formats.
     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
@@ -435,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).
 
@@ -454,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
@@ -481,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.1
+3.2.3

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)')
@@ -84,7 +97,7 @@ 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)
@@ -99,12 +112,12 @@ module SPARQL; module Algebra
         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
@@ -114,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
@@ -127,7 +140,13 @@ module SPARQL; module Algebra
       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 confusiong 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
         if logger
           logger.error("Operator=#{operator.inspect}: #{e}")
@@ -215,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
@@ -223,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)
@@ -232,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

data/lib/sparql/algebra/extensions.rb

@@ -124,6 +124,14 @@ class Array
   end
   def constant?; !(variable?); end
 
+  ##
+  # The variables used in this array.
+  #
+  # @return [Hash{Symbol => RDF::Query::Variable}]
+  def variables
+    self.inject({}) {|hash, o| o.respond_to?(:variables) ? hash.merge(o.variables) : hash}
+  end
+
   ##
   # Does this contain any nodes?
   #
@@ -347,7 +355,7 @@ class RDF::Statement
   # Transform Statement Pattern into an SXP
   # @return [Array]
   def to_sxp_bin
-    [ (has_graph? ? :quad : :triple),
+    [ (has_graph? ? :quad : (quoted? ? :qtriple : :triple)),
       (:inferred if inferred?),
       subject,
       predicate,
@@ -370,20 +378,10 @@ class RDF::Statement
   #
   # Returns a partial SPARQL grammar for this term.
   #
-  # @param [Boolean] as_statement (false) serialize as < ... >, otherwise TRIPLE(...)
   # @return [String]
-  def to_sparql(as_statement: false, **options)
-    if as_statement
-      to_triple.map do |term|
-        if term.is_a?(::RDF::Statement)
-          "<<" + term.to_sparql(as_statement: true, **options) + ">>"
-        else
-          term.to_sparql(**options)
-        end
-      end.join(" ")
-    else
-      "TRIPLE(#{to_triple.to_sparql(as_statement: true, **options)})"
-    end
+  def to_sparql(**options)
+    str = to_triple.map {|term| term.to_sparql(**options)}.join(" ")
+    quoted? ? ('<<' + str + '>>') : str
   end
 
   ##
@@ -441,7 +439,9 @@ class RDF::Query
   #   Filter Operations
   # @return [String]
   def to_sparql(top_level: true, filter_ops: [], **options)
-    str = @patterns.map { |e| e.to_sparql(as_statement: true, top_level: false, **options) }.join(". \n")
+    str = @patterns.map do |e|
+      e.to_sparql(top_level: false, **options) + " . \n"
+    end.join("")
     str = "GRAPH #{graph_name.to_sparql(**options)} {\n#{str}\n}\n" if graph_name
     if top_level
       SPARQL::Algebra::Operator.to_sparql(str, filter_ops: filter_ops, **options)
@@ -454,9 +454,9 @@ class RDF::Query
       # Extensons
       extensions = options.fetch(:extensions, [])
       extensions.each do |as, expression|
-        v = expression.to_sparql(as_statement: true, **options)
-        v = "<< #{v} >>" if expression.is_a?(RDF::Statement)
-        str << "\nBIND (" << v << " AS " << as.to_sparql(**options) << ") ."
+        v = expression.to_sparql(**options)
+        pp = RDF::Query::Variable.new(as).to_sparql(**options)
+        str << "\nBIND (" << v << " AS " << pp << ") ."
       end
       str = "{#{str}}" unless filter_ops.empty? && extensions.empty?
       str