sparql 3.0.0 → 3.1.3

data/lib/rack/sparql.rb

@@ -18,7 +18,7 @@ module Rack
     # @param  [Hash{Symbol => Object}] options
     # @option options [Boolean]        :overwrite (false)
     # @return [void]
-    def self.register_mime_types!(options = {})
+    def self.register_mime_types!(**options)
       if defined?(Rack::Mime::MIME_TYPES)
         RDF::Format.each do |format|
           if !Rack::Mime::MIME_TYPES.has_key?(file_ext = ".#{format.to_sym}") || options[:overwrite]

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)
@@ -71,7 +71,7 @@ module Rack; module SPARQL
         serialize_options = {}
         serialize_options[:content_types] = env['ORDERED_CONTENT_TYPES'] if env['ORDERED_CONTENT_TYPES']
         serialize_options.merge!(@options)
-        results = ::SPARQL.serialize_results(body, serialize_options)
+        results = ::SPARQL.serialize_results(body, **serialize_options)
         raise RDF::WriterError, "can't serialize results" unless results
         headers = headers.merge(VARY).merge('Content-Type' => results.content_type) # FIXME: don't overwrite existing Vary headers
         [status, headers, [results]]
@@ -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,9 +25,9 @@ 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/
-      def service_description(options = {})
+      # @see https://www.w3.org/TR/sparql11-service-description
+      # @see https://www.w3.org/TR/void/
+      def service_description(**options)
         repository = options[:repository]
 
         g = RDF::Graph.new
@@ -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'
 
   ##
@@ -28,8 +30,8 @@ module SPARQL
   #   a `queryable` object such as an RDF::Graph
   #   or RDF::Repository. 
   # @raise  [Parser::Error] on invalid input
-  def self.parse(query, options = {})
-    query = Grammar::Parser.new(query, options).parse(options[:update] ? :UpdateUnit : :QueryUnit)
+  def self.parse(query, **options)
+    query = Grammar::Parser.new(query, **options).parse(options[:update] ? :UpdateUnit : :QueryUnit)
   end
 
   ##
@@ -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]
@@ -67,8 +70,9 @@ module SPARQL
   # @return [RDF::Graph, Boolean, RDF::Query::Solutions::Enumerator]
   #   Note, results may be used with {SPARQL.serialize_results} to obtain appropriate output encoding.
   # @raise  [SPARQL::MalformedQuery] on invalid input
-  def self.execute(query, queryable, options = {}, &block)
-    query = self.parse(query, options)
+  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)

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:
@@ -372,8 +367,8 @@ module SPARQL
     # @param  [Hash{Symbol => Object}] options
     #   any additional options (see {Operator#initialize})
     # @return [SPARQL::Algebra::Operator]
-    def parse(sse, options = {})
-      Expression.parse(sse, options)
+    def parse(sse, **options)
+      Expression.parse(sse, **options)
     end
     module_function :parse
 
@@ -390,8 +385,8 @@ module SPARQL
     # @yieldparam  [SPARQL::Algebra::Expression] expression
     # @yieldreturn [void] ignored
     # @return [Expression]
-    def open(sse, options = {})
-      Expression.open(sse, options)
+    def open(sse, **options)
+      Expression.open(sse, **options)
     end
     module_function :open
 
@@ -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
@@ -24,12 +24,12 @@ module SPARQL; module Algebra
     # @return [RDF::Term]
     # @raise [TypeError]
     # @abstract
-    def aggregate(solutions = [], options = {})
+    def aggregate(solutions = [], **options)
       operands.shift if distinct = (operands.first == :distinct)
       args_enum = solutions.map do |solution|
         operands.map do |operand|
           begin
-            operand.evaluate(solution, options.merge(depth: options[:depth].to_i + 1))
+            operand.evaluate(solution, depth: options[:depth].to_i + 1, **options)
           rescue TypeError
             # Ignore errors
             nil

data/lib/sparql/algebra/evaluatable.rb

@@ -13,8 +13,8 @@ module SPARQL; module Algebra
     #   options passed from query
     # @return [RDF::Term]
     # @abstract
-    def evaluate(bindings, options = {})
-      args = operands.map { |operand| operand.evaluate(bindings, options.merge(depth: options[:depth].to_i + 1)) }
+    def evaluate(bindings, **options)
+      args = operands.map { |operand| operand.evaluate(bindings, depth: options[:depth].to_i + 1, **options) }
       options[:memoize] ? memoize(*args) : apply(*args)
     end
 

data/lib/sparql/algebra/expression.rb

@@ -19,14 +19,7 @@ module SPARQL; module Algebra
     # @yieldparam  [SPARQL::Algebra::Expression] expression
     # @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'
-      
+    def self.parse(sse, **options, &block)
       sse = sse.encode(Encoding::UTF_8)
       sxp = SXP::Reader::SPARQL.new(sse) do |reader|
         # Set base_uri if we have one
@@ -38,7 +31,7 @@ module SPARQL; module Algebra
       Operator.base_uri = options.delete(:base_uri) if options.has_key?(:base_uri)
       Operator.prefixes = sxp.prefixes || {}
 
-      expression = self.new(sxp_result, options)
+      expression = self.new(sxp_result, **options)
 
       yield(expression) if block_given?
       expression
@@ -57,8 +50,8 @@ module SPARQL; module Algebra
     # @yieldparam  [SPARQL::Algebra::Expression] expression
     # @yieldreturn [void] ignored
     # @return [Expression]
-    def self.open(filename, options = {}, &block)
-      RDF::Util::File.open_file(filename, options) do |file|
+    def self.open(filename, **options, &block)
+      RDF::Util::File.open_file(filename, **options) do |file|
         options[:base_uri] ||= filename
         Expression.parse(file, options, &block)
       end
@@ -87,7 +80,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, **options)
       raise ArgumentError, "invalid SPARQL::Algebra::Expression form: #{sse.inspect}" unless sse.is_a?(Array)
 
       operator = Operator.for(sse.first, sse.length - 1)
@@ -95,7 +88,7 @@ module SPARQL; module Algebra
         return case sse.first
         when Array
           debug(options) {"Map array elements #{sse}"}
-          sse.map {|s| self.new(s, options.merge(depth: options[:depth].to_i + 1))}
+          sse.map {|s| self.new(s, depth: options[:depth].to_i + 1, **options)}
         else
           debug(options) {"No operator found for #{sse.first}"}
           sse.map do |s|
@@ -110,7 +103,7 @@ module SPARQL; module Algebra
         debug(options) {"Operator=#{operator.inspect}, Operand=#{operand.inspect}"}
         case operand
           when Array
-            self.new(operand, options.merge(depth: options[:depth].to_i + 1))
+            self.new(operand, depth: options[:depth].to_i + 1, **options)
           when Operator, Variable, RDF::Term, RDF::Query, Symbol
             operand
           when TrueClass, FalseClass, Numeric, String, DateTime, Date, Time
@@ -175,8 +168,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 +190,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
@@ -280,12 +273,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
 
@@ -313,7 +320,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

data/lib/sparql/algebra/extensions.rb

@@ -4,7 +4,7 @@ require 'json'
 # Extensions for Ruby's `NilClass` class.
 class NilClass
 
-  def evaluate(bindings, options = {})
+  def evaluate(bindings, **options)
     self
   end
 
@@ -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
 
 ##
@@ -52,9 +68,9 @@ class Array
   # @param [Hash{Symbol => Object}] options ({})
   #   options passed from query
   # @return [RDF::Term]
-  # @see {SPARQL::Algebra::Expression.evaluate}
-  def evaluate(bindings, options = {})
-    SPARQL::Algebra::Expression.extension(*self.map {|o| o.evaluate(bindings, options)})
+  # @see SPARQL::Algebra::Expression.evaluate
+  def evaluate(bindings, **options)
+    SPARQL::Algebra::Expression.extension(*self.map {|o| o.evaluate(bindings, **options)})
   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
-  def execute(queryable, options = {})
+  # @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
 
 ##
@@ -191,7 +251,7 @@ module RDF::Term
   # @param [Hash{Symbol => Object}] options ({})
   #   options passed from query
   # @return [RDF::Term]
-  def evaluate(bindings, options = {})
+  def evaluate(bindings, **options)
     self
   end
 
@@ -210,6 +270,17 @@ 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
 
 # Override RDF::Queryable to execute against SPARQL::Algebra::Query elements as well as RDF::Query and RDF::Pattern
@@ -243,7 +314,7 @@ module RDF::Queryable
       solutions = if method(:query_execute).arity == 1
         query_execute(pattern, &block)
       else
-        query_execute(pattern, options, &block)
+        query_execute(pattern, **options, &block)
       end
       after_query(pattern) if respond_to?(:after_query)
 
@@ -252,13 +323,12 @@ module RDF::Queryable
         solutions
       else
         # Return an enumerator
-        enum_for(:query, pattern, options)
+        enum_for(:query, pattern, **options)
       end
     else
-      query_without_sparql(pattern, options, &block)
+      query_without_sparql(pattern, **options, &block)
     end
   end
-  
 end
 
 class RDF::Statement
@@ -271,6 +341,15 @@ class RDF::Statement
       [:triple, subject, predicate, object]
     end
   end
+
+  ##
+  # A duplicate of this Statement.
+  #
+  # @return [RDF::Statement] a copy of `self`
+  # @see SPARQL::Algebra::Expression#optimize
+  def optimize(**options)
+    self.dup
+  end
 end
 
 class RDF::Query
@@ -306,6 +385,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,6 +427,26 @@ class RDF::Query
     variables.values
   end
 
+  alias_method :optimize_without_expression!, :optimize!
+  ##
+  # Optimize the query, removing lexical shortcuts in URIs
+  #
+  # @return [self]
+  # @see SPARQL::Algebra::Expression#optimize!
+  def optimize!(**options)
+    @patterns = @patterns.map do |pattern|
+      components = pattern.to_a.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` if this is executable (i.e., contains a graph patterns), `false`
   # otherwise.
@@ -386,14 +495,18 @@ class RDF::Query::Variable
   #   options passed from query
   # @return [RDF::Term] the value of this variable
   # @raise [TypeError] if the variable is not bound
-  def evaluate(bindings, options = {})
+  def evaluate(bindings, **options)
     raise TypeError if bindings.respond_to?(:bound?) && !bindings.bound?(self)
     bindings[name.to_sym]
   end
 
-  def to_s
-    prefix = distinguished? || name.to_s[0,1] == '.' ? '?' : "??"
-    unbound? ? "#{prefix}#{name}" : "#{prefix}#{name}=#{value}"
+  ##
+  # Return self
+  #
+  # @return [RDF::Query::Variable] a copy of `self`
+  # @see SPARQL::Algebra::Expression#optimize
+  def optimize(**options)
+    self
   end
 end # RDF::Query::Variable
 
@@ -424,3 +537,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