sparql 3.1.0 → 3.1.6

data/lib/rack/sparql/conneg.rb

@@ -43,7 +43,7 @@ module Rack; module SPARQL
     #
     # @param  [Hash{String => String}] env
     # @return [Array(Integer, Hash, #each)]
-    # @see    http://www.rubydoc.info/github/rack/rack/Rack/Runtime#call-instance_method
+    # @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')
       response = app.call(env)
@@ -89,7 +89,7 @@ module Rack; module SPARQL
     #
     # @param  [String, #to_s] header
     # @return [Array<String>]
-    # @see    http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.1
+    # @see    https://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.1
     def parse_accept_header(header)
       entries = header.to_s.split(',')
       entries.map { |e| accept_entry(e) }.sort_by(&:last).map(&:first)

data/lib/sinatra/sparql.rb

@@ -8,7 +8,7 @@ module Sinatra
   #
   # To override negotiation on Content-Type, set :format in `sparql_options` to a RDF Format class, or symbol identifying a format.
   #
-  # @see http://www.sinatrarb.com/extensions.html
+  # @see https://www.sinatrarb.com/extensions.html
   module SPARQL
     ##
     # Helper methods.
@@ -25,8 +25,8 @@ module Sinatra
       #   URI of the service endpoint, defaults to "/sparql" in the current realm.
       # @return [RDF::Graph]
       #
-      # @see http://www.w3.org/TR/sparql11-service-description
-      # @see http://www.w3.org/TR/void/
+      # @see https://www.w3.org/TR/sparql11-service-description
+      # @see https://www.w3.org/TR/void/
       def service_description(**options)
         repository = options[:repository]
 
@@ -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,16 +1,18 @@
+require 'sxp'
 require 'sparql/extensions'
+require 'sparql/algebra/sxp_extensions'
 
 ##
 # A SPARQL for RDF.rb.
 #
-# @see http://www.w3.org/TR/sparql11-query
+# @see https://www.w3.org/TR/sparql11-query
 module SPARQL
   autoload :Algebra, 'sparql/algebra'
   autoload :Grammar, 'sparql/grammar'
   autoload :Results, 'sparql/results'
   autoload :VERSION, 'sparql/version'
 
-  # @see http://rubygems.org/gems/sparql-client
+  # @see https://rubygems-client
   autoload :Client,  'sparql/client'
 
   ##
@@ -52,12 +54,13 @@ module SPARQL
   #   results = SPARQL.execute("SELECT * WHERE { ?s ?p ?o }", repository)
   #
   # @param  [IO, StringIO, String, #to_s]  query
+  # @param  [RDF::Queryable]  queryable
   # @param  [Hash{Symbol => Object}] options
-  # @option options  [RDF::Queryable]  :queryable
-  # @option options [RDF::URI, String, Array<RDF::URI, String>] :load_datasets
-  #   One or more URIs used to initialize a new instance of `queryable` in the default graph.
+  # @option options [Boolean] :optimize
+  #   Optimize query before execution.
   # @option options [RDF::URI, String, Array<RDF::URI, String>] :default_graph_uri
-  #   One or more URIs used to initialize a new instance of `queryable` in the default graph.
+  # @option options [RDF::URI, String, Array<RDF::URI, String>] :load_datasets
+  #   One or more URIs used to initialize a new instance of `queryable` in the default graph. One or more URIs used to initialize a new instance of `queryable` in the default graph.
   # @option options [RDF::URI, String, Array<RDF::URI, String>] :named_graph_uri
   #   One or more URIs used to initialize the `queryable` as a named graph.
   # @yield  [solution]
@@ -69,13 +72,11 @@ module SPARQL
   # @raise  [SPARQL::MalformedQuery] on invalid input
   def self.execute(query, queryable, **options, &block)
     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

@@ -1,4 +1,4 @@
-require 'rdf' # @see http://rubygems.org/gems/rdf
+require 'rdf' # @see https://rubygems.org/gems/rdf
 require 'rdf/xsd'
 
 module SPARQL
@@ -141,21 +141,21 @@ module SPARQL
   # ## Constructing operator expressions manually
   # 
   #     Operator(:isBlank).new(RDF::Node(:foobar)).to_sxp                        #=> "(isBlank _:foobar)"
-  #     Operator(:isIRI).new(RDF::URI('http://rubygems.org/gems/rdf/')).to_sxp       #=> "(isIRI <http://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(: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.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('http://rubygems.org/gems/rdf/')].to_sxp         #=> "(isIRI <http://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[: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.1415e0)"
+  #     SPARQL::Algebra::Expression[:str, [:datatype, RDF::Literal(3.1415)]].to_sxp               #=> "(str (datatype 3.1415e0))"
   # 
   # ## Constructing operator expressions using SSE strings
   # 
   #     SPARQL::Algebra::Expression.parse('(isBlank _:foobar)')
-  #     SPARQL::Algebra::Expression.parse('(isIRI <http://rubygems.org/gems/rdf/>)')
+  #     SPARQL::Algebra::Expression.parse('(isIRI <https://rubygems.org/gems/rdf/>)')
   #     SPARQL::Algebra::Expression.parse('(isLiteral 3.1415)')
   #     SPARQL::Algebra::Expression.parse('(str (datatype 3.1415))')
   # 
@@ -165,11 +165,6 @@ module SPARQL
   #     Operator(:isIRI).evaluate(RDF::Vocab::DC.title)                                 #=> RDF::Literal::TRUE
   #     Operator(:isLiteral).evaluate(RDF::Literal(3.1415))                      #=> RDF::Literal::TRUE
   # 
-  # ## Optimizing expressions containing constant subexpressions
-  # 
-  #     SPARQL::Algebra::Expression.parse('(sameTerm ?var ?var)').optimize            #=> RDF::Literal::TRUE
-  #     SPARQL::Algebra::Expression.parse('(* -2 (- (* (+ 1 2) (+ 3 4))))').optimize  #=> RDF::Literal(42)
-  # 
   # ## Evaluating expressions on a solution sequence
   # 
   #     # Find all people and their names & e-mail addresses:
@@ -405,8 +400,7 @@ module SPARQL
     def Expression(*sse)
       Expression.for(*sse)
     end
-    alias_method :Expr, :Expression
-    module_function :Expr, :Expression
+    module_function :Expression
 
     ##
     # @example
@@ -417,8 +411,7 @@ module SPARQL
     def Operator(name, arity = nil)
       Operator.for(name, arity)
     end
-    alias_method :Op, :Operator
-    module_function :Op, :Operator
+    module_function :Operator
 
     ##
     # @example
@@ -430,8 +423,7 @@ module SPARQL
     def Variable(name)
       Variable.new(name)
     end
-    alias_method :Var, :Variable
-    module_function :Var, :Variable
+    module_function :Variable
 
     Variable = RDF::Query::Variable
   end # Algebra

data/lib/sparql/algebra/aggregate.rb

@@ -6,8 +6,8 @@ module SPARQL; module Algebra
   # or more operands which are `Enumerable` lists of `RDF::Term`
   # and return a single `RDF::Term` or `TypeError`.
   #
-  # @see http://www.w3.org/TR/sparql11-query/#setFunctions
-  # @see http://www.w3.org/TR/sparql11-query/#aggregates
+  # @see https://www.w3.org/TR/sparql11-query/#setFunctions
+  # @see https://www.w3.org/TR/sparql11-query/#aggregates
   #
   # @abstract
   module Aggregate

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 http://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
 
     ##
@@ -175,8 +173,8 @@ module SPARQL; module Algebra
     # @param [RDF::URI] function
     # @param [Array<RDF::Term>] args splat of args to function
     # @return [RDF::Term]
-    # @see http://www.w3.org/TR/sparql11-query/#extensionFunctions
-    # @see http://www.w3.org/TR/sparql11-query/#FunctionMapping
+    # @see https://www.w3.org/TR/sparql11-query/#extensionFunctions
+    # @see https://www.w3.org/TR/sparql11-query/#FunctionMapping
     def self.extension(function, *args)
       if function.to_s.start_with?(RDF::XSD.to_s)
         self.cast(function, args.first)
@@ -197,7 +195,7 @@ module SPARQL; module Algebra
     #   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
     # @return [RDF::Term]
-    # @see http://www.w3.org/TR/sparql11-query/#FunctionMapping
+    # @see https://www.w3.org/TR/sparql11-query/#FunctionMapping
     def self.cast(datatype, value)
       case datatype
       when RDF::XSD.dateTime
@@ -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
@@ -280,12 +302,26 @@ module SPARQL; module Algebra
     ##
     # Returns an optimized version of this expression.
     #
-    # This is the default implementation, which simply returns `self`.
+    # This is the default implementation, which simply returns a copy of `self`.
     # Subclasses can override this method in order to implement something
     # more useful.
     #
-    # @return [Expression] `self`
-    def optimize
+    # @param  [Hash{Symbol => Object}] options
+    #   any additional options for optimization
+    # @return [Expression] a copy of `self`
+    # @see    RDF::Query#optimize
+    def optimize(**options)
+      self.deep_dup.optimize!(**options)
+    end
+
+    ##
+    # Optimizes this query.
+    #
+    # @param  [Hash{Symbol => Object}] options
+    #   any additional options for optimization
+    # @return [self]
+    # @see    RDF::Query#optimize!
+    def optimize!(**options)
       self
     end
 
@@ -301,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
 
@@ -313,7 +349,7 @@ module SPARQL; module Algebra
     # more useful.
     #
     # @return [Array] `self`
-    # @see    http://openjena.org/wiki/SSE
+    # @see    https://openjena.org/wiki/SSE
     def to_sxp_bin
       self
     end
@@ -349,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
@@ -357,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
@@ -365,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

@@ -27,6 +27,22 @@ class Object
   def to_sse
     SXP::Generator.string(self.to_sxp_bin)
   end
+
+  ##
+  # A duplicate of this object.
+  #
+  # @return [Object] a copy of `self`
+  # @see SPARQL::Algebra::Expression#optimize
+  def optimize(**options)
+    self.deep_dup
+  end
+
+  ##
+  # Default for deep_dup is shallow dup
+  # @return [Object]
+  def deep_dup
+    dup
+  end
 end
 
 ##
@@ -66,11 +82,34 @@ class Array
   # @param  [Hash{Symbol => Object}] options
   # @raise [NotImplementedError]
   #   If an attempt is made to perform an unsupported operation
-  # @see    http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
+  # @see    https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
   def execute(queryable, **options)
     raise NotImplementedError, "SPARQL::Algebra '#{first}' operator not implemented"
   end
 
+  ##
+  # Return an optimized version of this array.
+  #
+  # @return [Array] a copy of `self`
+  # @see SPARQL::Algebra::Expression#optimize
+  def optimize(**options)
+    self.map do |op|
+      op.optimize(**options) if op.respond_to?(:optimize)
+    end
+  end
+
+  ##
+  # Binds the pattern to a solution, making it no longer variable if all variables are resolved to bound variables
+  #
+  # @param [RDF::Query::Solution] solution
+  # @return [self]
+  def bind(solution)
+    map! do |op|
+      op.respond_to?(:bind) ? op.bind(solution) : op
+    end
+    self
+  end
+
   ##
   # Returns `true` if any of the operands are variables, `false`
   # otherwise.
@@ -78,7 +117,7 @@ class Array
   # @return [Boolean] `true` or `false`
   # @see    #constant?
   def variable?
-    any?(&:variable?)
+    any? {|op| op.respond_to?(:variable?) && op.variable?}
   end
   def constant?; !(variable?); end
 
@@ -166,6 +205,12 @@ class Array
     each {|e| e.validate! if e.respond_to?(:validate!)}
     self
   end
+
+  ##
+  # Deep duplicate
+  def deep_dup
+    map(&:deep_dup)
+  end
 end
 
 ##
@@ -179,6 +224,21 @@ class Hash
     to_a.to_sxp_bin
   end
   def to_sxp; to_sxp_bin; end
+
+  ##
+  # A duplicate of this hash.
+  #
+  # @return [Hash] a copy of `self`
+  # @see SPARQL::Algebra::Expression#optimize
+  def optimize(**options)
+    self.deep_dup
+  end
+
+  ##
+  # Deep duplicate
+  def deep_dup
+    inject({}) {|memo, (k, v)| memo.merge(k => v.deep_dup)}
+  end
 end
 
 ##
@@ -210,8 +270,33 @@ module RDF::Term
   def vars
     variable? ? [self] : []
   end
+
+  ##
+  # A duplicate of this term.
+  #
+  # @return [RDF::Term] a copy of `self`
+  # @see SPARQL::Algebra::Expression#optimize
+  def optimize(**options)
+    optimized = self.deep_dup
+    optimized.lexical = nil if optimized.respond_to?(:lexical=)
+    optimized
+  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
@@ -223,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)
@@ -235,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)
@@ -258,19 +343,39 @@ module RDF::Queryable
       query_without_sparql(pattern, **options, &block)
     end
   end
-  
 end
 
 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
+
+  ##
+  # A duplicate of this Statement.
+  #
+  # @return [RDF::Statement] a copy of `self`
+  # @see SPARQL::Algebra::Expression#optimize
+  def optimize(**options)
+    self.dup
+  end
+
+  def executable?; false; end
 end
 
 class RDF::Query
@@ -306,6 +411,16 @@ class RDF::Query
     end
   end
 
+  ##
+  # Binds the pattern to a solution, making it no longer variable if all variables are resolved to bound variables
+  #
+  # @param [RDF::Query::Solution] solution
+  # @return [self]
+  def bind(solution)
+    patterns.each {|p| p.bind(solution)}
+    self
+  end
+
   # Query results in a boolean result (e.g., ASK)
   # @return [Boolean]
   def query_yields_boolean?
@@ -338,25 +453,34 @@ class RDF::Query
     variables.values
   end
 
+  alias_method :optimize_without_expression!, :optimize!
   ##
-  # Returns `true` if this is executable (i.e., contains a graph patterns), `false`
-  # otherwise.
+  # Optimize the query, removing lexical shortcuts in URIs
   #
-  # @return [Boolean] `true` or `false`
+  # @return [self]
+  # @see SPARQL::Algebra::Expression#optimize!
+  def optimize!(**options)
+    @patterns = @patterns.map do |pattern|
+      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, **pattern.options)
+    end
+    self.optimize_without_expression!(**options)
+  end
+
+  ##
+  # Returns `true` as this is executable.
+  #
+  # @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>]
@@ -370,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
 
 ##
@@ -390,6 +520,22 @@ class RDF::Query::Variable
     raise TypeError if bindings.respond_to?(:bound?) && !bindings.bound?(self)
     bindings[name.to_sym]
   end
+
+  ##
+  # Return self
+  #
+  # @return [RDF::Query::Variable] a copy of `self`
+  # @see SPARQL::Algebra::Expression#optimize
+  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
 
 ##
@@ -419,3 +565,16 @@ class RDF::Query::Solutions
   end
   alias_method :filter!, :filter
 end # RDF::Query::Solutions
+
+##
+# Extensions for `RDF::Query::Solution`.
+class RDF::Query::Solution
+  ##
+  # Returns the SXP representation of this object, defaults to `self`.
+  #
+  # @return [String]
+  def to_sxp_bin
+    to_a.to_sxp_bin
+  end
+  def to_sxp; to_sxp_bin; end
+end # RDF::Query::Solution