sparql 3.1.6 → 3.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 383f162fe715a1ff7eebb78e095a77f1e1823d29045c673b57c5bf68acbcb70f
-  data.tar.gz: fc7f7ea801e556ee25a77dd340ea7268a7a5d0c39ee9bf2686cb71e887a58446
+  metadata.gz: e9bcab10eb6706316b68b44a0fd917d7b735b18a8353b51e49ef124fc966176d
+  data.tar.gz: 6da59b4e90fd1b7a7d80c42d941f7c27f6bf95892d17302caf16a13809b03afa
 SHA512:
-  metadata.gz: 662583eb75d9cca1a34d8d8299cee4eb7e97dc6d3251982300a077c888523bd63f8350be3ce1fed753692e2f26d056afd7381f26ac8115f6b72a7e8f2e89296e
-  data.tar.gz: 8cb4ee544f52b9599fb1d5dc6ac3b8a68a7755caded5b3baef706222565c9b59511e69f0921c2b00ece9f3fd22aebff543caa37c93a6d45b02a9e8211660931d
+  metadata.gz: d2f99aee7d5b9482bbd653333eeefd215da872291993a2ba138ed9bcfc3f92812672cd1508dfbd11a729d527c9724f0a80ec816c5c84fd2df9933b4b91b5a296
+  data.tar.gz: 41a11caf8e85ca4bd01213bb0c0c236314560338dbd2825bd2437afbf4fd9855b994150737dbcad00838dc5ac50e368d72e5bfe2e516566a6319f824bdcacc56

data/README.md

@@ -23,8 +23,7 @@ This is a [Ruby][] implementation of [SPARQL][] for [RDF.rb][].
   * Compatible with any [Rack][] or [Sinatra][] application and any Rack-based framework.
   * Helper method for describing [SPARQL Service Description][SSD]
 * Implementation Report: {file:etc/earl.html EARL}
-* Compatible with Ruby >= 2.2.2.
-* Compatible with older Ruby versions with the help of the [Backports][] gem.
+* Compatible with Ruby >= 2.6.
 * Supports Unicode query strings both on all versions of Ruby.
 * Provisional support for [SPARQL-star][].
 
@@ -248,27 +247,27 @@ a full set of RDF formats.
 ### Querying a repository with a SPARQL query
 
     queryable = RDF::Repository.load("etc/doap.ttl")
-    sse = SPARQL.parse("SELECT * WHERE { ?s ?p ?o }")
-    queryable.query(sse) do |result|
+    query = SPARQL.parse("SELECT * WHERE { ?s ?p ?o }")
+    queryable.query(query) do |result|
       result.inspect
     end
 
 ### Executing a SPARQL query against a repository
 
     queryable = RDF::Repository.load("etc/doap.ttl")
-    sse = SPARQL.parse("SELECT * WHERE { ?s ?p ?o }")
-    sse.execute(queryable) do |result|
+    query = SPARQL.parse("SELECT * WHERE { ?s ?p ?o }")
+    query.execute(queryable) do |result|
       result.inspect
     end
 
 ### Updating a repository
 
     queryable = RDF::Repository.load("etc/doap.ttl")
-    sse = SPARQL.parse(%(
+    update = SPARQL.parse(%(
       PREFIX doap: <http://usefulinc.com/ns/doap#>
       INSERT DATA { <https://rubygems> doap:implements <http://www.w3.org/TR/sparql11-update/>}
     ), update: true)
-    sse.execute(queryable)
+    update.execute(queryable)
 
 ### Rendering solutions as JSON, XML, CSV, TSV or HTML
     queryable = RDF::Repository.load("etc/doap.ttl")
@@ -277,8 +276,15 @@ a full set of RDF formats.
 
 ### Parsing a SPARQL query string to SSE
 
-    sse = SPARQL.parse("SELECT * WHERE { ?s ?p ?o }")
-    sse.to_sxp #=> (bgp (triple ?s ?p ?o))
+    query = SPARQL.parse("SELECT * WHERE { ?s ?p ?o }")
+    query.to_sxp #=> (bgp (triple ?s ?p ?o))
+
+### Parsing a SSE to SPARQL query or update string to SPARQL
+
+    # Note: if the SSE uses extension functions, they either must be XSD casting functions, or custom functions which are registered extensions. (See [SPARQL Extension Functions](#sparql-extension-functions))
+
+    query = SPARQL::Algebra.parse(%{(bgp (triple ?s ?p ?o))})
+    sparql = query.to_sparql #=> "SELECT * WHERE { ?s ?p ?o }"
 
 ### Command line processing
 
@@ -289,6 +295,10 @@ a full set of RDF formats.
     sparql parse etc/input.rq
     sparql parse -e "SELECT * WHERE { ?s ?p ?o }"
 
+    # Generate SPARQL Query from SSE
+    sparql parse --sse etc/input.sse --format sparql
+    sparql parse --sse --format sparql -e "(dataset (<http://usefulinc.com/ns/doap>) (bgp (triple ?s ?p ?o))))"
+
     # Run query using SSE input
     sparql execute --dataset etc/doap.ttl --sse etc/input.sse
     sparql execute --sse -e "(dataset (<etc/doap.ttl>) (bgp (triple ?s ?p ?o))))"
@@ -368,19 +378,19 @@ Full documentation available on [Rubydoc.info][SPARQL doc]
 
 ## Dependencies
 
-* [Ruby](https://ruby-lang.org/) (>= 2.2.2)
-* [RDF.rb](https://rubygems.org/gems/rdf) (~> 3.0)
-* [SPARQL::Client](https://rubygems.org/gems/sparql-client) (~> 3.0)
-* [SXP](https://rubygems.org/gems/sxp) (~> 1.0)
-* [Builder](https://rubygems.org/gems/builder) (>= 3.0.0)
-* [JSON](https://rubygems.org/gems/json) (>= 1.8.2)
-* Soft dependency on [Linked Data][] (>= 3.0)
-* Soft dependency on [Nokogiri](https://rubygems.org/gems/nokogiri) (>= 1.7)
+* [Ruby](https://ruby-lang.org/) (>= 2.6)
+* [RDF.rb](https://rubygems.org/gems/rdf) (~> 3.2)
+* [SPARQL::Client](https://rubygems.org/gems/sparql-client) (~> 3.1)
+* [SXP](https://rubygems.org/gems/sxp) (~> 1.2)
+* [Builder](https://rubygems.org/gems/builder) (~> 3.2)
+* [JSON](https://rubygems.org/gems/json) (~> 2.6)
+* Soft dependency on [Linked Data][] (>= 3.1)
+* Soft dependency on [Nokogiri](https://rubygems.org/gems/nokogiri) (~> 1.12)
   Falls back to REXML for XML parsing Builder for XML serializing. Nokogiri is much more efficient
-* Soft dependency on [Equivalent XML](https://rubygems.org/gems/equivalent-xml) (>= 0.3.0)
+* Soft dependency on [Equivalent XML](https://rubygems.org/gems/equivalent-xml) (>= 0.6)
   Equivalent XML performs more efficient comparisons of XML Literals when Nokogiri is included
-* Soft dependency on [Rack][] (>= 2.0)
-* Soft dependency on [Sinatra][] (>= 2.0)
+* Soft dependency on [Rack][] (~> 2.2)
+* Soft dependency on [Sinatra][] (~> 2.1)
 
 ## Installation
 
@@ -450,7 +460,6 @@ A copy of the [SPARQL 1.0 tests][] and [SPARQL 1.1 tests][] are also included in
 [RDF.rb]:           https://rubydoc.info/github/ruby-rdf/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
-[Backports]:        https://rubygems.org/gems/backports
 [Linked Data]:      https://rubygems.org/gems/linkeddata
 [SPARQL doc]:       https://rubydoc.info/github/ruby-rdf/sparql/frames
 [SPARQL XML]:       https://www.w3.org/TR/rdf-sparql-XMLres/

data/VERSION

@@ -1 +1 @@
-3.1.6
+3.2.1

data/bin/sparql

@@ -1,6 +1,7 @@
 #!/usr/bin/env ruby
 require 'rubygems'
 $:.unshift("../../lib", __FILE__)
+require 'logger'
 require 'sparql'
 begin
   require 'linkeddata'
@@ -44,9 +45,18 @@ def run(input, **options)
     SPARQL::Grammar.parse(input, **options)
   end
 
-  puts ("\nSSE:\n" + query.to_sse) if options[:debug] || options[:to_sse]
+  puts ("\nSSE:\n" + query.to_sse) if options[:debug]
 
-  unless options[:to_sse]
+  if options[:parse_only]
+    case options[:format]
+    when :sparql
+      puts ("\nSPARQL:\n" + query.to_sparql)
+    when nil, :sse
+      puts ("\nSSE:\n" + query.to_sse)
+    else
+      $stderr.puts "Unknown output format for parsing: #{options[:format]}. Use 'sse' or 'sparql'"
+    end
+  else
     res = query.execute(options[:dataset], logger: options[:logger])
     display_results(res, **options)
   end
@@ -97,7 +107,7 @@ def usage
   puts "      --dataset:            File containing RDF graph or dataset"
   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 "      --format:             Output format for results (json, xml, csv, tsv, html, sparql, sse, or another RDF format)"
   puts "      --port,-p             Port on which to run server; defaults to 9292"
   puts "      --sse:                Query input is in SSE format"
   puts "      --update:             Process query as a SPARQL Update"
@@ -150,7 +160,7 @@ end
 
 case cmd
 when 'execute', 'parse'
-  options[:to_sse] = true if cmd == 'parse'
+  options[:parse_only] = true if cmd == 'parse'
   input ||= ARGV.empty? ? $stdin.read : RDF::Util::File.open_file(ARGV.first).read
   run(input, **options)
 when 'query'

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

@@ -66,9 +66,11 @@ module SPARQL; module Algebra
     #
     # @param  [Array] sse
     #   a SPARQL S-Expression (SSE) form
+    # @param  [Hash{Symbol => Object}] options
+    #   any additional options (see {Operator#initialize})
     # @return [Expression]
-    def self.for(*sse)
-      self.new(sse)
+    def self.for(*sse, **options)
+      self.new(sse, **options)
     end
     class << self; alias_method :[], :for; end
 
@@ -86,6 +88,13 @@ module SPARQL; module Algebra
       raise ArgumentError, "invalid SPARQL::Algebra::Expression form: #{sse.inspect}" unless sse.is_a?(Array)
 
       operator = Operator.for(sse.first, sse.length - 1)
+
+      # If we don't find an operator, and sse.first is an extension IRI, use a function call
+      if !operator && sse.first.is_a?(RDF::URI) && self.extension?(sse.first)
+        operator = Operator.for(:function_call, sse.length)
+        sse.unshift(:function_call)
+      end
+
       unless operator
         return case sse.first
         when Array
@@ -115,11 +124,16 @@ module SPARQL; module Algebra
       end
 
       debug(options) {"#{operator.inspect}(#{operands.map(&:inspect).join(',')})"}
+      logger = options[:logger]
       options.delete_if {|k, v| [:debug, :logger, :depth, :prefixes, :base_uri, :update, :validate].include?(k) }
       begin
         operator.new(*operands, **options)
       rescue ArgumentError => e
-        error(options) {"Operator=#{operator.inspect}: #{e}"}
+        if logger
+          logger.error("Operator=#{operator.inspect}: #{e}")
+        else
+          raise "Operator=#{operator.inspect}: #{e}"
+        end
       end
     end
 
@@ -163,6 +177,17 @@ module SPARQL; module Algebra
       @extensions ||= {}
     end
 
+    ##
+    # Is an extension function available?
+    #
+    # It's either a registered extension, or an XSD casting function
+    #
+    # @param [RDF::URI] function
+    # @return [Boolean]
+    def self.extension?(function)
+      function.to_s.start_with?(RDF::XSD.to_s) || self.extensions[function]
+    end
+
     ##
     # Invoke an extension function.
     #

data/lib/sparql/algebra/extensions.rb

@@ -43,6 +43,15 @@ class Object
   def deep_dup
     dup
   end
+
+  ##
+  #
+  # Returns a partial SPARQL grammar for this term.
+  #
+  # @return [String]
+  def to_sparql(**options)
+    to_sxp(**options)
+  end
 end
 
 ##
@@ -57,20 +66,14 @@ class Array
   end
 
   ##
-  # Evaluates the array using the given variable `bindings`.
   #
-  # In this case, the Array has two elements, the first of which is
-  # an XSD datatype, and the second is the expression to be evaluated.
-  # The result is cast as a literal of the appropriate type
+  # Returns a partial SPARQL grammar for this array.
   #
-  # @param  [RDF::Query::Solution] bindings
-  #   a query solution containing zero or more variable bindings
-  # @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)})
+  # @param [String] delimiter (" ")
+  #   If the first element is an IRI, treat it as an extension function
+  # @return [String]
+  def to_sparql(delimiter: " ",  **options)
+    map {|e| e.to_sparql(**options)}.join(delimiter)
   end
 
   ##
@@ -216,15 +219,6 @@ end
 ##
 # Extensions for Ruby's `Hash` class.
 class Hash
-  ##
-  # 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
-
   ##
   # A duplicate of this hash.
   #
@@ -278,24 +272,19 @@ module RDF::Term
   # @see SPARQL::Algebra::Expression#optimize
   def optimize(**options)
     optimized = self.deep_dup
-    optimized.lexical = nil if optimized.respond_to?(:lexical=)
-    optimized
+    #optimized.lexical = nil if optimized.respond_to?(:lexical=)
+    #optimized
   end
-end # RDF::Term
 
-class RDF::Literal::Double
   ##
-  # Returns the SXP representation of this object.
+  #
+  # Returns a partial SPARQL grammar for this term.
   #
   # @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
+  def to_sparql(**options)
+    to_sxp(**options)
   end
-end
+end # RDF::Term
 
 # Override RDF::Queryable to execute against SPARQL::Algebra::Query elements as well as RDF::Query and RDF::Pattern
 module RDF::Queryable
@@ -343,6 +332,15 @@ module RDF::Queryable
       query_without_sparql(pattern, **options, &block)
     end
   end
+
+  ##
+  #
+  # Returns a partial SPARQL grammar for this term.
+  #
+  # @return [String]
+  def to_sparql(**options)
+    raise NotImplementedError, "SPARQL::Algebra '#{first}' operator not implemented"
+  end
 end
 
 class RDF::Statement
@@ -361,9 +359,31 @@ class RDF::Statement
   ##
   # Returns an S-Expression (SXP) representation
   #
+  # @param [Hash{Symbol => RDF::URI}] prefixes (nil)
+  # @param [RDF::URI] base_uri (nil)
   # @return [String]
-  def to_sxp
-    to_sxp_bin.to_sxp
+  def to_sxp(prefixes: nil, base_uri: nil)
+    to_sxp_bin.to_sxp(prefixes: prefixes, base_uri: base_uri)
+  end
+
+  ##
+  #
+  # 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
   end
 
   ##
@@ -411,6 +431,38 @@ class RDF::Query
     end
   end
 
+  ##
+  #
+  # Returns a partial SPARQL grammar for this query.
+  #
+  # @param [Boolean] top_level (true)
+  #   Treat this as a top-level, generating SELECT ... WHERE {}
+  # @param [Array<Operator>] filter_ops ([])
+  #   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 = "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)
+    else
+      # Filters
+      filter_ops.each do |op|
+        str << "\nFILTER (#{op.to_sparql(**options)}) ."
+      end
+
+      # 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) << ") ."
+      end
+      str = "{#{str}}" unless filter_ops.empty? && extensions.empty?
+      str
+    end
+  end
+
   ##
   # Binds the pattern to a solution, making it no longer variable if all variables are resolved to bound variables
   #
@@ -462,11 +514,11 @@ class RDF::Query
   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
+        #if term.respond_to?(:lexical=)
+        #  term.dup.instance_eval {@lexical = nil; self}
+        #else
           term
-        end
+        #end
       end
       RDF::Query::Pattern.from(components, **pattern.options)
     end
@@ -530,11 +582,15 @@ class RDF::Query::Variable
     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
+  ##
+  #
+  # Returns a partial SPARQL grammar for this term.
+  #
+  # The Non-distinguished form (`??xxx`) is not part of the grammar, so replace with a blank-node
+  #
+  # @return [String]
+  def to_sparql(**options)
+    self.distinguished? ? super : "_:_nd#{self.name}"
   end
 end # RDF::Query::Variable
 
@@ -576,5 +632,13 @@ class RDF::Query::Solution
   def to_sxp_bin
     to_a.to_sxp_bin
   end
-  def to_sxp; to_sxp_bin; end
+
+  # Transform Solution into an SXP
+  #
+  # @param [Hash{Symbol => RDF::URI}] prefixes (nil)
+  # @param [RDF::URI] base_uri (nil)
+  # @return [String]
+  def to_sxp(prefixes: nil, base_uri: nil)
+    to_sxp_bin.to_sxp(prefixes: prefixes, base_uri: base_uri)
+  end
 end # RDF::Query::Solution

data/lib/sparql/algebra/operator/abs.rb

@@ -3,8 +3,19 @@ module SPARQL; module Algebra
     ##
     # The SPARQL logical `abs` operator.
     #
-    # @example
-    #   (abs ?x)
+    # [121] BuiltInCall ::= ... | 'ABS' '(' Expression ')'
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   SELECT * WHERE {
+    #     ?s :num ?num
+    #     FILTER(ABS(?num) >= 2)
+    #   }
+    #
+    # @example SSE
+    #   (prefix ((: <http://example.org/>))
+    #    (filter (>= (abs ?num) 2)
+    #     (bgp (triple ?s :num ?num))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-abs
     # @see https://www.w3.org/TR/xpath-functions/#func-abs
@@ -20,12 +31,21 @@ module SPARQL; module Algebra
       #   the operand
       # @return [RDF::Literal] literal of same type
       # @raise  [TypeError] if the operand is not a numeric value
-      def apply(operand)
+      def apply(operand, **options)
         case operand
           when RDF::Literal::Numeric then operand.abs
           else raise TypeError, "expected an RDF::Literal::Numeric, but got #{operand.inspect}"
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "ABS(#{operands.first.to_sparql(**options)})"
+      end
     end # Abs
   end # Operator
 end; end # SPARQL::Algebra

data/lib/sparql/algebra/operator/add.rb

@@ -6,8 +6,15 @@ module SPARQL; module Algebra
     #
     # The ADD operation is a shortcut for inserting all data from an input graph into a destination graph. Data from the input graph is not affected, and initial data from the destination graph, if any, is kept intact.
     #
-    # @example
-    #   (add default <a>)
+    # [35]	Add	::=	"ADD" "SILENT"? GraphOrDefault "TO" GraphOrDefault
+    #
+    # @example SPARQL Update
+    #   PREFIX : <http://example.org/>
+    #   ADD DEFAULT TO :g1
+    #
+    # @example SSE
+    #   (prefix ((: <http://example.org/>))
+    #    (update (add default :g1)))
     #
     # @see https://www.w3.org/TR/sparql11-update/#add
     class Add < Operator
@@ -51,6 +58,18 @@ module SPARQL; module Algebra
         end
         queryable
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        *args, last = operands.dup
+        args += [:TO, last]
+        
+        "ADD " + args.to_sparql(**options)
+      end
     end # Add
   end # Operator
 end; end # SPARQL::Algebra

data/lib/sparql/algebra/operator/alt.rb

@@ -7,8 +7,23 @@ module SPARQL; module Algebra
     #
     #     eval(Path(X, alt(P,Q), Y)) = Union(eval(Path(X, P, Y)), eval(Path(X, Q, Y)))
     #
-    # @example
-    #   (alt a b)
+    # [89] PathAlternative ::= PathSequence ( '|' PathSequence )*
+    #
+    # @example SPARQL Query
+    #   PREFIX :  <http://www.example.org/>
+    #   SELECT ?t
+    #   WHERE {
+    #     :a :p1|:p2/:p3|:p4 ?t
+    #   }
+    #
+    # @example SSE
+    #   (prefix ((: <http://www.example.org/>))
+    #    (project (?t)
+    #     (path :a
+    #      (alt
+    #       (alt :p1 (seq :p2 :p3))
+    #       :p4)
+    #      ?t)))
     #
     # @see https://www.w3.org/TR/sparql11-query/#defn_evalPP_alternative
     class Alt < Operator::Binary
@@ -57,6 +72,15 @@ module SPARQL; module Algebra
         query = Union.new(qa, qb)
         queryable.query(query, depth: options[:depth].to_i + 1, **options, &block)
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "(#{operands.first.to_sparql(**options)}|#{operands.last.to_sparql(**options)})"
+      end
     end # Alt
   end # Operator
 end; end # SPARQL::Algebra

data/lib/sparql/algebra/operator/and.rb

@@ -3,9 +3,22 @@ module SPARQL; module Algebra
     ##
     # The SPARQL logical `and` operator.
     #
-    # @example
-    #   (&& ?x ?y)
-    #   (and ?x ?y)
+    # [112] ConditionalAndExpression::= ValueLogical ( '&&' ValueLogical )*
+    #
+    # @example SPARQL Grammar
+    #   PREFIX  xsd: <http://www.w3.org/2001/XMLSchema#>
+    #   PREFIX  : <http://example.org/ns#>
+    #   SELECT  ?a
+    #   WHERE { ?a :p ?v . 
+    #     FILTER ("true"^^xsd:boolean && ?v) .
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((xsd: <http://www.w3.org/2001/XMLSchema#>) (: <http://example.org/ns#>))
+    #    (project (?a)
+    #     (filter (&& true ?v)
+    #      (bgp (triple ?a :p ?v)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-logical-and
     # @see https://www.w3.org/TR/sparql11-query/#evaluation
@@ -60,6 +73,15 @@ module SPARQL; module Algebra
         else                              RDF::Literal(left && right)
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "(#{operands.first.to_sparql(**options)} && #{operands.last.to_sparql(**options)})"
+      end
     end # And
   end # Operator
 end; end # SPARQL::Algebra