sparql 3.1.2 → 3.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 774ff66fd7f181a0b4aa7eb36c5c3a11c10c7a8c2b02728c358825ab7690e3be
-  data.tar.gz: 7f71db0b80c137af45f57b54ed335ab8d0d327e9c427d0eadb1fc70ae2c4ba62
+  metadata.gz: dcc81f10a741a9060299f9b3f54e1a7a35442fb7b68b7a79b2d1b67e16c0108a
+  data.tar.gz: aa6dd52a91d86b9a981edb5f4d56bdd0da288932ece265578ba773bb289a5fe0
 SHA512:
-  metadata.gz: fa064eb95aa7106739015840d71ea30bf89c853225517aee1d89fefe0f523fda1d3ed62fbf0c5e1f03d7c8fe10ae41dd14d2585754ea51539c86cc918a468313
-  data.tar.gz: 67b69a2e66be71bc5a73d74da3243f10950e56165c971f65536bd800edfd8edc25eb9d198cd84c220ae6f0e58a7819adfc9e2dd45439931449224d57227e240b
+  metadata.gz: 64669164cff7cdd9b1580bba3576247dafff7feef77ab63ba355afb51bded23a8f996ca952332abea8a4d06f8aca4ae5db25702a69748f8577aeedb720c5f788
+  data.tar.gz: d269e6c8edf25e5929876d292290257527f4bfe69def6fbe3e4500283a0ed2418ac4df5420a24fd35f826970ae63c3d679ba998d27184851cc8fe58648521df7

data/README.md

@@ -3,10 +3,9 @@
 This is a [Ruby][] implementation of [SPARQL][] for [RDF.rb][].
 
 [![Gem Version](https://badge.fury.io/rb/sparql.png)](https://badge.fury.io/rb/sparql)
-
-[![Build Status](https://travis-ci.org/ruby-rdf/sparql.png?branch=master)](https://travis-ci.org/ruby-rdf/sparql)
-
-[![Coverage Status](https://coveralls.io/repos/ruby-rdf/sparql/badge.svg)](https://coveralls.io/r/ruby-rdf/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)
+[![Coverage Status](https://coveralls.io/repos/ruby-rdf/sparql/badge.svg?branch=develop)](https://coveralls.io/r/ruby-rdf/sparql?branch=develop)
+[![Gitter chat](https://badges.gitter.im/ruby-rdf/rdf.png)](https://gitter.im/ruby-rdf/rdf)
 
 ## Features
 
@@ -27,7 +26,7 @@ This is a [Ruby][] implementation of [SPARQL][] for [RDF.rb][].
 * Compatible with Ruby >= 2.2.2.
 * Compatible with older Ruby versions with the help of the [Backports][] gem.
 * Supports Unicode query strings both on all versions of Ruby.
-* Provisional support for [SPARQL*][].
+* Provisional support for [SPARQL-star][].
 
 ## Description
 
@@ -97,9 +96,9 @@ Then, use the function in a query:
 
 See {SPARQL::Algebra::Expression.register_extension} for details.
 
-### SPARQLStar (SPARQL*)
+### SPARQLStar (SPARQL-star)
 
-The gem supports [SPARQL*][] where patterns may include sub-patterns recursively, for a kind of Reification.
+The gem supports [SPARQL-star][] where patterns may include sub-patterns recursively, for a kind of Reification.
 
 For example, the following Turtle* file uses a statement as the subject of another statement:
 
@@ -160,7 +159,7 @@ As well as a `CONSTRUCT`:
       <<?bob foaf:age ?age>> ?b ?c .
     }
 
-Note that results can be serialized only when the format supports [RDF*][].
+Note that results can be serialized only when the format supports [RDF-star][].
 
 #### SPARQL results
 
@@ -419,7 +418,9 @@ This repository uses [Git Flow](https://github.com/nvie/gitflow) to mange develo
   list in the the `README`. Alphabetical order applies.
 * Do note that in order for us to merge any non-trivial changes (as a rule
   of thumb, additions larger than about 15 lines of code), we need an
-  explicit [public domain dedication][PDD] on record from you.
+  explicit [public domain dedication][PDD] on record from you,
+  which you will be asked to agree to on the first commit to a repo within the organization.
+  Note that the agreement applies to all repos in the [Ruby RDF](https://github.com/ruby-rdf/) organization.
 
 ## License
 
@@ -437,7 +438,7 @@ A copy of the [SPARQL 1.0 tests][] and [SPARQL 1.1 tests][] are also included in
 [Rack::LinkedData]: https://rubygems.org/gems/rack-linkeddata
 [YARD]:             https://yardoc.org/
 [YARD-GS]:          https://rubydoc.info/docs/yard/file/docs/GettingStarted.md
-[PDD]:              https://lists.w3.org/Archives/Public/public-rdf-ruby/2010May/0013.html
+[PDD]:              https://unlicense.org/#unlicensing-contributions
 [SPARQL]:           https://en.wikipedia.org/wiki/SPARQL
 [SPARQL 1.0]:       https://www.w3.org/TR/sparql11-query/
 [SPARQL 1.0 tests]:https://www.w3.org/2001/sw/DataAccess/tests/
@@ -447,8 +448,8 @@ A copy of the [SPARQL 1.0 tests][] and [SPARQL 1.1 tests][] are also included in
 [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*]:             https://lists.w3.org/Archives/Public/public-rdf-star/
-[SPARQL*]:          https://arxiv.org/pdf/1406.3399.pdf
+[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
 [Backports]:        https://rubygems.org/gems/backports
 [Linked Data]:      https://rubygems.org/gems/linkeddata
 [SPARQL doc]:       https://rubydoc.info/github/ruby-rdf/sparql/frames

data/VERSION

@@ -1 +1 @@
-3.1.2
+3.1.7

data/bin/sparql

@@ -38,7 +38,7 @@ def run(input, **options)
   end
 
   query = if options[:sse]
-    SPARQL::Algebra.parse(input, debug: options[:debug], update: options[:update])
+    SPARQL::Algebra.parse(input, logger: options[:logger], update: options[:update])
   else
     # Only do grammar debugging if we're generating SSE
     SPARQL::Grammar.parse(input, **options)
@@ -47,7 +47,7 @@ def run(input, **options)
   puts ("\nSSE:\n" + query.to_sse) if options[:debug] || options[:to_sse]
 
   unless options[:to_sse]
-    res = query.execute(options[:dataset], debug: options[:debug])
+    res = query.execute(options[:dataset], logger: options[:logger])
     display_results(res, **options)
   end
 end
@@ -60,6 +60,11 @@ def server(options)
     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)
@@ -78,20 +83,19 @@ def server(options)
       SPARQL.execute(params['query'], settings.repository)
     end
   end
-  Rack::Server.start(app: app)
+  Rack::Server.start(app: app, Port: options.fetch(:port, 9292))
 rescue LoadError
   $stderr.puts "Running SPARQL server requires Rack to be in environment: #{$!.message}"
 end
 
 def usage
-  puts "Usage: #{$0} execute [options] query-file         Execute a query against the specified dataset"
-  puts "       #{$0} parse [options] query-file           Parse a query into SPARQL S-Expressions (SSE)"
-  puts "       #{$0} query [options] end-point query-file Run the query against a remote end-point"
-  puts "       #{$0} server [options] dataset-file        Start a server initialized from the specified dataset"
+  puts "Usage: #{File.basename($0)} execute [options] query-file         Execute a query against the specified dataset"
+  puts "       #{File.basename($0)} parse [options] query-file           Parse a query into SPARQL S-Expressions (SSE)"
+  puts "       #{File.basename($0)} query [options] end-point query-file Run the query against a remote end-point"
+  puts "       #{File.basename($0)} server [options] dataset-file        Start a server initialized from the specified dataset"
   puts "Options:"
   puts "      --dataset:            File containing RDF graph or dataset"
   puts "      --debug:              Display detailed debug output"
-  puts "      --debug:              Display detailed debug output"
   puts "      --execute,-e:         Use option argument as the SPARQL input if no query-file given"
   puts "      --format:             Output format for results"
   puts "      --port,-p             Port on which to run server; defaults to 9292"
@@ -116,20 +120,25 @@ opts = GetoptLong.new(
   ["--help", "-?", GetoptLong::NO_ARGUMENT]
 )
 
+logger = Logger.new(STDERR)
+logger.level = Logger::WARN
+logger.formatter = lambda {|severity, datetime, progname, msg| "%5s %s\n" % [severity, msg]}
+
 options = {
   dataset: RDF::Repository.new,
+  logger: logger,
 }
 
 opts.each do |opt, arg|
   case opt
-  when '--dataset'       then options[:dataset].load(arg, rdfstar: :PG)
-  when '--debug'         then options[:debug] = true
+  when '--dataset'       then options[:dataset].load(arg, rdfstar: true)
+  when '--debug'         then options[:debug] = true ; logger.level = Logger::DEBUG
   when '--execute'       then input = arg
   when '--format'        then options[:format] = arg.to_sym
   when '--port'          then options[:port] = arg.to_i
   when '--sse'           then options[:sse] = true
   when '--update'        then options[:update] = true
-  when '--verbose'       then options[:verbose] = true
+  when '--verbose'       then options[:verbose] = true ; logger.level = Logger::INFO
   when "--help"          then usage
   end
 end

data/lib/sinatra/sparql.rb

@@ -103,7 +103,7 @@ module Sinatra
       app.helpers(Sinatra::SPARQL::Helpers)
       app.send(:include, ::SPARQL)
       app.send(:include, ::RDF)
-      app.send(:include, ::LinkedData)
+      app.send(:include, ::LinkedData) if defined?(::LinkedData)
     end
   end
 end

data/lib/sparql.rb

@@ -1,4 +1,6 @@
+require 'sxp'
 require 'sparql/extensions'
+require 'sparql/algebra/sxp_extensions'
 
 ##
 # A SPARQL for RDF.rb.
@@ -72,12 +74,9 @@ module SPARQL
     query = self.parse(query, **options)
     query = query.optimize(**options) if options[:optimize]
     queryable = queryable || RDF::Repository.new
-    
-    case options.fetch(:debug, nil)
-    when TrueClass
-      puts query.to_sxp
-    when Array
-      options[:debug] << query.to_sxp
+
+    if options[:logger]
+      options[:logger].debug("SPARQL.execute") {SXP::Generator.string query.to_sxp_bin}
     end
 
     if options.has_key?(:load_datasets)

data/lib/sparql/algebra.rb

@@ -142,15 +142,15 @@ module SPARQL
   # 
   #     Operator(:isBlank).new(RDF::Node(:foobar)).to_sxp                        #=> "(isBlank _:foobar)"
   #     Operator(:isIRI).new(RDF::URI('https://rubygems.org/gems/rdf/')).to_sxp       #=> "(isIRI <https://rubygems.org/gems/rdf/>)"
-  #     Operator(:isLiteral).new(RDF::Literal(3.1415)).to_sxp                    #=> "(isLiteral 3.1415)"
-  #     Operator(:str).new(Operator(:datatype).new(RDF::Literal(3.1415))).to_sxp #=> "(str (datatype 3.1415))"
+  #     Operator(:isLiteral).new(RDF::Literal(3.1415)).to_sxp                    #=> "(isLiteral 3.1415e0)"
+  #     Operator(:str).new(Operator(:datatype).new(RDF::Literal(3.1415))).to_sxp #=> "(str (datatype 3.1415e0))"
   # 
   # ## Constructing operator expressions using SSE forms
   # 
   #     SPARQL::Algebra::Expression[:isBlank, RDF::Node(:foobar)].to_sxp                          #=> "(isBlank _:foobar)"
   #     SPARQL::Algebra::Expression[:isIRI, RDF::URI('https://rubygems.org/gems/rdf/')].to_sxp         #=> "(isIRI <https://rubygems.org/gems/rdf/>)"
-  #     SPARQL::Algebra::Expression[:isLiteral, RDF::Literal(3.1415)].to_sxp                      #=> "(isLiteral 3.1415)"
-  #     SPARQL::Algebra::Expression[:str, [:datatype, RDF::Literal(3.1415)]].to_sxp               #=> "(str (datatype 3.1415))"
+  #     SPARQL::Algebra::Expression[:isLiteral, RDF::Literal(3.1415)].to_sxp                      #=> "(isLiteral 3.1415e0)"
+  #     SPARQL::Algebra::Expression[:str, [:datatype, RDF::Literal(3.1415)]].to_sxp               #=> "(str (datatype 3.1415e0))"
   # 
   # ## Constructing operator expressions using SSE strings
   # 

data/lib/sparql/algebra/aggregate.rb

@@ -44,7 +44,7 @@ module SPARQL; module Algebra
     #   Enumerable yielding evaluated operands
     # @return [RDF::Term]
     # @abstract
-    def apply(enum)
+    def apply(enum, **options)
       raise NotImplementedError, "#{self.class}#apply(#{operands.map(&:class).join(', ')})"
     end
 

data/lib/sparql/algebra/evaluatable.rb

@@ -15,16 +15,16 @@ module SPARQL; module Algebra
     # @abstract
     def evaluate(bindings, **options)
       args = operands.map { |operand| operand.evaluate(bindings, depth: options[:depth].to_i + 1, **options) }
-      options[:memoize] ? memoize(*args) : apply(*args)
+      options[:memoize] ? memoize(*args, **options) : apply(*args, **options)
     end
 
     ##
     # @param  [Array<RDF::Term>] operands
     #   evaluated operands
     # @return [RDF::Term] the memoized result
-    def memoize(*operands)
+    def memoize(*operands, **options)
       @cache ||= RDF::Util::Cache.new(options[:memoize].is_a?(Integer) ? options[:memoize] : -1)
-      @cache[operands] ||= apply(*operands)
+      @cache[operands] ||= apply(*operands, **options)
     end
 
     ##
@@ -32,7 +32,7 @@ module SPARQL; module Algebra
     #   evaluated operands
     # @return [RDF::Term]
     # @abstract
-    def apply(*operands)
+    def apply(*operands, **options)
       raise NotImplementedError, "#{self.class}#apply(#{operands.map(&:class).join(', ')})"
     end
 

data/lib/sparql/algebra/expression.rb

@@ -4,6 +4,8 @@ module SPARQL; module Algebra
   #
   # @abstract
   module Expression
+    include RDF::Util::Logger
+
     ##
     # @example
     #   Expression.parse('(isLiteral 3.1415)')
@@ -20,13 +22,6 @@ module SPARQL; module Algebra
     # @yieldreturn [void] ignored
     # @return [Expression]
     def self.parse(sse, **options, &block)
-      begin
-        require 'sxp' # @see https://rubygems.org/gems/sxp
-      rescue LoadError
-        abort "SPARQL::Algebra::Expression.parse requires the SXP gem (hint: `gem install sxp')."
-      end
-      require 'sparql/algebra/sxp_extensions'
-      
       sse = sse.encode(Encoding::UTF_8)
       sxp = SXP::Reader::SPARQL.new(sse) do |reader|
         # Set base_uri if we have one
@@ -60,7 +55,7 @@ module SPARQL; module Algebra
     def self.open(filename, **options, &block)
       RDF::Util::File.open_file(filename, **options) do |file|
         options[:base_uri] ||= filename
-        Expression.parse(file, options, &block)
+        Expression.parse(file, **options, &block)
       end
     end
 
@@ -120,9 +115,12 @@ module SPARQL; module Algebra
       end
 
       debug(options) {"#{operator.inspect}(#{operands.map(&:inspect).join(',')})"}
-      options.delete_if {|k, v| [:debug, :depth, :prefixes, :base_uri, :update, :validate].include?(k) }
-      operands << options unless options.empty?
-      operator.new(*operands)
+      options.delete_if {|k, v| [:debug, :logger, :depth, :prefixes, :base_uri, :update, :validate].include?(k) }
+      begin
+        operator.new(*operands, **options)
+      rescue ArgumentError => e
+        error(options) {"Operator=#{operator.inspect}: #{e}"}
+      end
     end
 
     ##
@@ -229,21 +227,45 @@ module SPARQL; module Algebra
         when RDF::Literal::DateTime, RDF::Literal::Date, RDF::Literal::Time, RDF::URI, RDF::Node
           raise TypeError, "Value #{value.inspect} cannot be cast as #{datatype}"
         else
-          RDF::Literal.new(!value.to_s.empty?, datatype: datatype, validate: true)
+          RDF::Literal::Boolean.new(value.value, datatype: datatype, validate: true)
         end
       when RDF::XSD.decimal, RDF::XSD.integer
         case value
         when RDF::Literal::Boolean
           RDF::Literal.new(value.object ? 1 : 0, datatype: datatype)
-        when RDF::Literal::Integer, RDF::Literal::Decimal
-          RDF::Literal.new(value, datatype: datatype)
+        when RDF::Literal::Numeric
+          RDF::Literal.new(value.object, datatype: datatype)
         when RDF::Literal::DateTime, RDF::Literal::Date, RDF::Literal::Time, RDF::URI, RDF::Node
           raise TypeError, "Value #{value.inspect} cannot be cast as #{datatype}"
         else
           RDF::Literal.new(value.value, datatype: datatype, validate: true)
         end
       when RDF::XSD.string
-         RDF::Literal.new(value, datatype: datatype)
+        # Cast to string rules based on https://www.w3.org/TR/xpath-functions/#casting-to-string
+        case value
+        when RDF::Literal::Integer
+          RDF::Literal.new(value.canonicalize.to_s, datatype: datatype)
+        when RDF::Literal::Decimal
+          if value == value.ceil
+            RDF::Literal.new(value.ceil, datatype: datatype)
+          else
+            RDF::Literal.new(value.canonicalize.to_s, datatype: datatype)
+          end
+        when RDF::Literal::Float, RDF::Literal::Double
+          if value.abs >= 0.000001 && value.abs < 1000000
+            # If SV has an absolute value that is greater than or equal to 0.000001 (one millionth) and less than 1000000 (one million), then the value is converted to an xs:decimal and the resulting xs:decimal is converted to an xs:string according to the rules above, as though using an implementation of xs:decimal that imposes no limits on the totalDigits or fractionDigits facets.
+            cast(datatype, RDF::Literal::Decimal.new(value.object))
+          elsif value.object.zero?
+            # If SV has the value positive or negative zero, TV is "0" or "-0" respectively.
+            RDF::Literal.new(value.to_s.start_with?('-') ? '-0' : '0', datatype: datatype)
+          else
+            # If SV is positive or negative infinity, TV is the string "INF" or "-INF" respectively.
+            # In other cases, the result consists of a mantissa, which has the lexical form of an xs:decimal, followed by the letter "E", followed by an exponent which has the lexical form of an xs:integer. Leading zeroes and "+" signs are prohibited in the exponent. For the mantissa, there must be a decimal point, and there must be exactly one digit before the decimal point, which must be non-zero. The "+" sign is prohibited. There must be at least one digit after the decimal point. Apart from this mandatory digit, trailing zero digits are prohibited.
+            RDF::Literal.new(value.canonicalize.to_s, datatype: datatype)
+          end
+        else
+          RDF::Literal.new(value.canonicalize.to_s, datatype: datatype)
+        end
       else
         raise TypeError, "Expected datatype (#{datatype}) to be a recognized XPath function"
       end
@@ -315,7 +337,7 @@ module SPARQL; module Algebra
     # @param [Hash{Symbol => Object}] options ({})
     #   options passed from query
     # @return [Expression] `self`
-    def evaluate(bindings, options = {})
+    def evaluate(bindings, **options)
       self
     end
 
@@ -363,7 +385,7 @@ module SPARQL; module Algebra
     #   @param [String] node processing node
     #   @param [String] message
     #   @param [Hash{Symbol => Object}] options
-    #   @option options [Boolean] :debug output debug messages to $stderr
+    #   @option options [Logger] :logger for logging progress
     #   @option options [Integer] :depth (@productions.length)
     #     Processing depth for indenting message output.
     #   @yieldreturn [String] appended to message, to allow for lazy-evaulation of message
@@ -371,7 +393,7 @@ module SPARQL; module Algebra
     # @overload: May be called with node and an option hash
     #   @param [String] node processing node
     #   @param [Hash{Symbol => Object}] options
-    #   @option options [Boolean] :debug output debug messages to $stderr
+    #   @option options [Logger] :logger for logging progress
     #   @option options [Integer] :depth (@productions.length)
     #     Processing depth for indenting message output.
     #   @yieldreturn [String] appended to message, to allow for lazy-evaulation of message
@@ -379,26 +401,19 @@ module SPARQL; module Algebra
     # @overload: May be called with only options, in which case the block is used to return the output message
     #   @param [String] node processing node
     #   @param [Hash{Symbol => Object}] options
-    #   @option options [Boolean] :debug output debug messages to $stderr
+    #   @option options [Logger] :logger for logging progress
     #   @option options [Integer] :depth (@productions.length)
     #     Processing depth for indenting message output.
     #   @yieldreturn [String] appended to message, to allow for lazy-evaulation of message
-    def self.debug(*args)
+    def self.debug(*args, &block)
       options = args.last.is_a?(Hash) ? args.pop : {}
-      return unless options[:debug]
-      message = args.join(": ")
-      message = message + yield if block_given?
-      depth = options[:depth] || 0
-      case options[:debug]
-      when Array
-        options[:debug] << "#{' ' * depth}#{message}"
-      else
-        $stderr.puts("#{' ' * depth}#{message}")
-      end
+      return unless options[:logger]
+      options[:logger].debug(*args, **options, &block)
     end
     
     def debug(*args, &block)
-      Expression.debug(*args, &block)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      log_debug(*args, **options, &block)
     end
   end # Expression
 end; end # SPARQL::Algebra

data/lib/sparql/algebra/extensions.rb

@@ -283,6 +283,20 @@ module RDF::Term
   end
 end # RDF::Term
 
+class RDF::Literal::Double
+  ##
+  # Returns the SXP representation of this object.
+  #
+  # @return [String]
+  def to_sxp
+    case
+      when nan? then 'nan.0'
+      when infinite? then (infinite? > 0 ? '+inf.0' : '-inf.0')
+      else canonicalize.to_s.downcase
+    end
+  end
+end
+
 # Override RDF::Queryable to execute against SPARQL::Algebra::Query elements as well as RDF::Query and RDF::Pattern
 module RDF::Queryable
   alias_method :query_without_sparql, :query
@@ -294,7 +308,7 @@ module RDF::Queryable
   #
   # @example
   #     queryable.query([nil, RDF::DOAP.developer, nil])
-  #     queryable.query(predicate: RDF::DOAP.developer)
+  #     queryable.query({predicate: RDF::DOAP.developer})
   #
   #     op = SPARQL::Algebra::Expression.parse(%q((bgp (triple ?a doap:developer ?b))))
   #     queryable.query(op)
@@ -306,7 +320,7 @@ module RDF::Queryable
   # @yieldreturn [void] ignored
   # @return [Enumerator]
   # @see    RDF::Queryable#query_pattern
-  def query(pattern, options = {}, &block)
+  def query(pattern, **options, &block)
     raise TypeError, "#{self} is not queryable" if respond_to?(:queryable?) && !queryable?
 
     if pattern.is_a?(SPARQL::Algebra::Operator) && pattern.respond_to?(:execute)
@@ -335,11 +349,21 @@ class RDF::Statement
   # Transform Statement Pattern into an SXP
   # @return [Array]
   def to_sxp_bin
-    if has_graph?
-      [:quad, subject, predicate, object, graph_name]
-    else
-      [:triple, subject, predicate, object]
-    end
+    [ (has_graph? ? :quad : :triple),
+      (:inferred if inferred?),
+      subject,
+      predicate,
+      object,
+      graph_name
+    ].compact.map(&:to_sxp_bin)
+  end
+
+  ##
+  # Returns an S-Expression (SXP) representation
+  #
+  # @return [String]
+  def to_sxp
+    to_sxp_bin.to_sxp
   end
 
   ##
@@ -350,6 +374,8 @@ class RDF::Statement
   def optimize(**options)
     self.dup
   end
+
+  def executable?; false; end
 end
 
 class RDF::Query
@@ -427,6 +453,7 @@ class RDF::Query
     variables.values
   end
 
+  alias_method :optimize_without_expression!, :optimize!
   ##
   # Optimize the query, removing lexical shortcuts in URIs
   #
@@ -434,39 +461,26 @@ class RDF::Query
   # @see SPARQL::Algebra::Expression#optimize!
   def optimize!(**options)
     @patterns = @patterns.map do |pattern|
-      components = pattern.to_a.map do |term|
+      components = pattern.to_quad.map do |term|
         if term.respond_to?(:lexical=)
           term.dup.instance_eval {@lexical = nil; self}
         else
           term
         end
       end
-      RDF::Query::Pattern.from(components)
-    end.sort! do |a, b|
-      (a.cost || 0) <=> (b.cost || 0)
+      RDF::Query::Pattern.from(components, **pattern.options)
     end
-    self
+    self.optimize_without_expression!(**options)
   end
 
   ##
-  # Returns `true` if this is executable (i.e., contains a graph patterns), `false`
-  # otherwise.
+  # Returns `true` as this is executable.
   #
-  # @return [Boolean] `true` or `false`
+  # @return [Boolean] `true`
   def executable?; true; end
 end
 
 class RDF::Query::Pattern
-  # Transform Query Pattern into an SXP
-  # @return [Array]
-  def to_sxp_bin
-    if has_graph?
-      [:quad, subject, predicate, object, graph_name]
-    else
-      [:triple, subject, predicate, object]
-    end
-  end
-
   ##
   # Return the non-destinguished variables contained within this pattern
   # @return [Array<RDF::Query::Variable>]
@@ -480,6 +494,12 @@ class RDF::Query::Pattern
   def vars
     variables.values
   end
+
+  ##
+  # Returns `true` as this is executable.
+  #
+  # @return [Boolean] `true`
+  def executable?; true; end
 end
 
 ##
@@ -509,6 +529,13 @@ class RDF::Query::Variable
   def optimize(**options)
     self
   end
+
+  # Display variable as SXP
+  # @return [Array]
+  def to_sxp
+    prefix = distinguished? ? (existential? ? '$' : '?') : (existential? ? '$$' : '??')
+    unbound? ? "#{prefix}#{name}".to_sym.to_sxp : ["#{prefix}#{name}".to_sym, value].to_sxp
+  end
 end # RDF::Query::Variable
 
 ##