sparql 3.1.6 → 3.2.1

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

@@ -3,9 +3,23 @@ module SPARQL; module Algebra
     ##
     # The SPARQL numeric `multiply` operator.
     #
-    # @example
-    #   (* ?x ?y)
-    #   (multiply ?x ?y)
+    # [117] MultiplicativeExpression::= UnaryExpression ( '*' UnaryExpression | '/' UnaryExpression )*
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   SELECT ?s WHERE {
+    #     ?s :p ?o .
+    #     ?s2 :p ?o2 .
+    #     FILTER(?o * ?o2 = 4) .
+    #   }
+    #
+    # @example SSE
+    #   (prefix ((: <http://example.org/>))
+    #    (project (?s)
+    #     (filter (= (* ?o ?o2) 4)
+    #      (bgp
+    #       (triple ?s :p ?o)
+    #       (triple ?s2 :p ?o2)))))
     #
     # @see https://www.w3.org/TR/xpath-functions/#func-numeric-multiply
     class Multiply < Operator::Binary
@@ -22,13 +36,22 @@ module SPARQL; module Algebra
       #   a numeric literal
       # @return [RDF::Literal::Numeric]
       # @raise  [TypeError] if either operand is not a numeric literal
-      def apply(left, right)
+      def apply(left, right, **options)
         case
           when left.is_a?(RDF::Literal::Numeric) && right.is_a?(RDF::Literal::Numeric)
             left * right
           else raise TypeError, "expected two RDF::Literal::Numeric operands, but got #{left.inspect} and #{right.inspect}"
         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 # Multiply
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,9 +3,20 @@ module SPARQL; module Algebra
     ##
     # The SPARQL numeric unary `-` (negation) operator.
     #
-    # @example
-    #   (- ?x)
-    #   (negate ?x)
+    # [118] UnaryExpression ::=	... | '-' PrimaryExpression 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   SELECT ?s WHERE {
+    #     ?s :p ?o .
+    #     FILTER(-?o = -2) .
+    #   }
+    #
+    # @example SSE
+    #   (prefix ((: <http://example.org/>))
+    #    (project (?s)
+    #     (filter (= (- ?o) -2)
+    #      (bgp (triple ?s :p ?o)))))
     #
     # @see https://www.w3.org/TR/xpath-functions/#func-numeric-unary-minus
     class Negate < Operator::Unary
@@ -20,12 +31,21 @@ module SPARQL; module Algebra
       #   a numeric literal
       # @return [RDF::Literal::Numeric]
       # @raise  [TypeError] if the operand is not a numeric literal
-      def apply(term)
+      def apply(term, **options)
         case term
           when RDF::Literal::Numeric then -term
           else raise TypeError, "expected an RDF::Literal::Numeric, but got #{term.inspect}"
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "(-#{operands.to_sparql(**options)})"
+      end
     end # Negate
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,9 +3,21 @@ module SPARQL; module Algebra
     ##
     # The SPARQL logical `not` operator.
     #
-    # @example
-    #   (! ?x)
-    #   (not ?x)
+    # [118] UnaryExpression ::=	... | '!' PrimaryExpression 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX  : <http://example.org/ns#>
+    #   SELECT  ?a
+    #   WHERE {
+    #     ?a :p ?v . 
+    #     FILTER ( ! ?v ) .
+    #   }
+    #
+    # @example SSE
+    #   (prefix ((: <http://example.org/ns#>))
+    #    (project (?a)
+    #     (filter (! ?v)
+    #      (bgp (triple ?a :p ?v)))))
     #
     # @see https://www.w3.org/TR/xpath-functions/#func-not
     class Not < Operator::Unary
@@ -23,13 +35,22 @@ module SPARQL; module Algebra
       #   the operand
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if the operand could not be coerced to a boolean literal
-      def apply(operand)
+      def apply(operand, **options)
         case bool = boolean(operand)
           when RDF::Literal::Boolean
             RDF::Literal(bool.false?)
           else super
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "(!" + operands.first.to_sparql(**options) + ")"
+      end
     end # Not
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,6 +3,19 @@ module SPARQL; module Algebra
     ##
     # The SPARQL relational `!=` (not equal) comparison operator.
     #
+    # [114] RelationalExpression    ::= NumericExpression ('!=' NumericExpression)?
+    #
+    # @example SPARQL Grammar
+    #   PREFIX  xsd: <http://www.w3.org/2001/XMLSchema#>
+    #   PREFIX  : <http://example.org/things#>
+    #   SELECT  ?x
+    #   WHERE { ?x :p ?v . FILTER ( ?v != 1 ) }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((xsd: <http://www.w3.org/2001/XMLSchema#>) (: <http://example.org/things#>))
+    #    (project (?x) (filter (!= ?v 1) (bgp (triple ?x :p ?v)))))
+    #
     # @see https://www.w3.org/TR/sparql11-query/#OperatorMapping
     # @see https://www.w3.org/TR/sparql11-query/#func-RDFterm-equal
     class NotEqual < Equal
@@ -12,13 +25,15 @@ module SPARQL; module Algebra
       # Returns `true` if the operands are not equal; returns `false`
       # otherwise.
       #
+      # Comparing unknown datatypes might have different lexical forms but be the same value.
+      #
       # @param  [RDF::Term] term1
       #   an RDF term
       # @param  [RDF::Term] term2
       #   an RDF term
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if either operand is not an RDF term
-      def apply(term1, term2)
+      def apply(term1, term2, **options)
         RDF::Literal(super.false?)
       end
     end # NotEqual

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

@@ -5,12 +5,23 @@ module SPARQL; module Algebra
     #
     # There is a filter operator EXISTS that takes a graph pattern. EXISTS returns `true`/`false` depending on whether the pattern matches the dataset given the bindings in the current group graph pattern, the dataset and the active graph at this point in the query evaluation. No additional binding of variables occurs. The `NOT EXISTS` form translates into `fn:not(EXISTS{...})`.
     #
-    # @example
-    #    (prefix ((ex: <http://www.example.org/>))
-    #      (filter (exists
-    #                 (filter (notexists (bgp (triple ?s ?p ex:o2)))
-    #                   (bgp (triple ?s ?p ex:o1))))
-    #        (bgp (triple ?s ?p ex:o))))
+    # [126] NotExistsFunc           ::= 'NOT' 'EXISTS' GroupGraphPattern
+    #
+    # @example SPARQL Grammar
+    #   PREFIX ex: <http://www.w3.org/2009/sparql/docs/tests/data-sparql11/negation#>
+    #   SELECT ?animal { 
+    #     ?animal a ex:Animal 
+    #     FILTER NOT EXISTS { ?animal a ex:Insect } 
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((ex: <http://www.w3.org/2009/sparql/docs/tests/data-sparql11/negation#>))
+    #    (project (?animal)
+    #     (filter
+    #      (notexists
+    #       (bgp (triple ?animal a ex:Insect)))
+    #      (bgp (triple ?animal a ex:Animal)))) )
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-abs
     # @see https://www.w3.org/TR/xpath-functions/#func-abs
@@ -34,6 +45,19 @@ module SPARQL; module Algebra
         queryable = options[:queryable]
         operand(0).execute(queryable, solutions: solutions, **options).empty?
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @param [Boolean] top_level (true)
+      #   Treat this as a top-level, generating SELECT ... WHERE {}
+      # @return [String]
+      def to_sparql(top_level: true, **options)
+        "NOT EXISTS {\n" +
+          operands.last.to_sparql(top_level: false, **options) +
+          "\n}"
+      end
     end # NotExists
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -5,8 +5,13 @@ module SPARQL; module Algebra
     #
     # Used for filters with more than one expression.
     #
-    # @example
-    #   (ask (filter (notin ?o 1 2) (bgp)))
+    # [114] RelationalExpression    ::= NumericExpression ('NOT' 'IN' ExpressionList)?
+    #
+    # @example SPARQL Grammar
+    #   ASK { FILTER(2 NOT IN ()) }
+    #
+    # @example SSE
+    #   (ask (filter (notin 2) (bgp)))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-notin
     class NotIn < Operator
@@ -58,6 +63,18 @@ module SPARQL; module Algebra
         else RDF::Literal::TRUE
         end
       end
-    end # Exprlist
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "(" + operands.first.to_sparql(**options) +
+        " NOT IN (" +
+        operands[1..-1].map {|e| e.to_sparql(**options)}.join(", ") +
+        "))"
+      end
+    end # NotIn
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,8 +3,18 @@ module SPARQL; module Algebra
     ##
     # The SPARQL Property Path `notoneof` (NegatedPropertySet) operator.
     #
-    # @example
-    #   (notoneof ex:p1 ex:p2)
+    # [96]  PathOneInPropertySet ::= iri | 'a' | '^' ( iri | 'a' )
+    #
+    # @example SPARQL Grammar
+    #   PREFIX ex:	<http://www.example.org/schema#>
+    #   PREFIX in:	<http://www.example.org/instance#>
+    #   ASK { in:a !(ex:p1|ex:p2) ?x }
+    #
+    # @example SSE
+    #   (prefix ((ex: <http://www.example.org/schema#>)
+    #           (in: <http://www.example.org/instance#>))
+    #    (ask
+    #     (path in:a (notoneof ex:p1 ex:p2) ?x)))
     #
     # @see https://www.w3.org/TR/sparql11-query/#eval_negatedPropertySet
     class NotOneOf < Operator
@@ -46,6 +56,15 @@ module SPARQL; module Algebra
           block.call(solution)
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "!(" + operands.to_sparql(delimiter: ' | ', **options) + ')'
+      end
     end # NotOneOf
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -7,11 +7,21 @@ module SPARQL; module Algebra
     #
     # Returns an XSD dateTime value for the current query execution. All calls to this function in any one query execution must return the same value. The exact moment returned is not specified.
     #
-    # @example
-    #     (prefix ((xsd: <http://www.w3.org/2001/XMLSchema#>))
-    #       (ask (filter (= (datatype ?n) xsd:dateTime)
-    #         (extend ((?n (now)))
-    #           (bgp)))))
+    # [121] BuiltInCall ::= ... | 'NOW' NIL 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
+    #   ASK {
+    #     BIND(NOW() AS ?n)
+    #     FILTER(DATATYPE(?n) = xsd:dateTime)
+    #   }
+    #
+    # @example SSE
+    #   (prefix ((xsd: <http://www.w3.org/2001/XMLSchema#>))
+    #    (ask
+    #     (filter (= (datatype ?n) xsd:dateTime)
+    #      (extend ((?n (now)))
+    #       (bgp)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-now
     class Now < Operator::Nullary
@@ -23,9 +33,18 @@ module SPARQL; module Algebra
       # Returns an XSD dateTime value for the current query execution. All calls to this function in any one query execution must return the same value. The exact moment returned is not specified.
       #
       # @return [RDF::Literal::Double] random value
-      def apply
+      def apply(**options)
         RDF::Literal(DateTime.now)
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "NOW()"
+      end
     end # Now
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -5,6 +5,29 @@ module SPARQL; module Algebra
     #
     # If triple is an RDF-star triple, the function returns the object of this triple. Passing anything other than an RDF-star triple is an error.
     #
+    # [121] BuiltInCall ::= ... | 'OBJECT' '(' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.com/ns#>
+    #   SELECT * {
+    #     ?t :source :g
+    #     FILTER(isTriple(?t))
+    #     FILTER(SUBJECT(?t) = :s)
+    #     FILTER(PREDICATE(?t) = :p)
+    #     FILTER(OBJECT(?t) = :o)
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.com/ns#>))
+    #    (filter
+    #     (exprlist
+    #      (isTRIPLE ?t)
+    #      (= (subject ?t) :s)
+    #      (= (predicate ?t) :p)
+    #      (= (object ?t) :o))
+    #     (bgp (triple ?t :source :g))) )
+    #
     # @see https://w3c.github.io/rdf-star/rdf-star-cg-spec.html#object
     class Object < Operator::Unary
       include Evaluatable
@@ -18,10 +41,19 @@ module SPARQL; module Algebra
       #   the operand
       # @return [RDF::Literal]
       # @raise  [TypeError] if the operand is not a statement
-      def apply(operand)
+      def apply(operand, **options)
         raise TypeError, "expected an RDF::Statement, but got #{operand.inspect}" unless operand.is_a?(RDF::Statement)
         operand.object
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "OBJECT(" + operands.last.to_sparql(**options) + ")"
+      end
     end # Object
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,9 +3,23 @@ module SPARQL; module Algebra
     ##
     # The SPARQL logical `or` operator.
     #
-    # @example
-    #   (|| ?x ?y)
-    #   (or ?x ?y)
+    # [111] ConditionalOrExpression ::= ConditionalAndExpression ( '||' ConditionalAndExpression )*
+    #
+    # @example SPARQL Grammar
+    #   PREFIX  xsd: <http://www.w3.org/2001/XMLSchema#>
+    #   PREFIX  : <http://example.org/ns#>
+    #   SELECT  ?a
+    #   WHERE {
+    #     ?a :p ?v . 
+    #     FILTER ("false"^^xsd:boolean || ?v) .
+    #   }
+    #
+    # @example SSE
+    #   (prefix ((xsd: <http://www.w3.org/2001/XMLSchema#>)
+    #            (: <http://example.org/ns#>))
+    #    (project (?a)
+    #     (filter (|| false ?v)
+    #      (bgp (triple ?a :p ?v)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-logical-or
     # @see https://www.w3.org/TR/sparql11-query/#evaluation
@@ -63,6 +77,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 # Or
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,12 +3,64 @@ module SPARQL; module Algebra
     ##
     # The SPARQL GraphPattern `order` operator.
     #
-    # @example
+    # [23]  OrderClause             ::= 'ORDER' 'BY' OrderCondition+
+    #
+    # @example SPARQL Grammar
+    #   PREFIX foaf:    <http://xmlns.com/foaf/0.1/>
+    #   SELECT ?name
+    #   WHERE { ?x foaf:name ?name }
+    #   ORDER BY ASC(?name)
+    #
+    # @example SSE
     #   (prefix ((foaf: <http://xmlns.com/foaf/0.1/>))
     #     (project (?name)
     #       (order ((asc ?name))
     #         (bgp (triple ?x foaf:name ?name)))))
     #
+    # @example SPARQL Grammar (with builtin)
+    #   PREFIX : <http://example.org/>
+    #   SELECT ?s WHERE {
+    #     ?s :p ?o .
+    #   }
+    #   ORDER BY str(?o)
+    #
+    # @example SSE (with builtin)
+    #   (prefix ((: <http://example.org/>))
+    #    (project (?s)
+    #     (order ((str ?o))
+    #      (bgp (triple ?s :p ?o)))))
+    #
+    # @example SPARQL Grammar (with bracketed expression)
+    #   PREFIX : <http://example.org/>
+    #   SELECT ?s WHERE {
+    #     ?s :p ?o1 ; :q ?o2 .
+    #   } ORDER BY (?o1 + ?o2)
+    #
+    # @example SSE (with bracketed expression)
+    #   (prefix
+    #    ((: <http://example.org/>))
+    #    (project (?s)
+    #     (order ((+ ?o1 ?o2))
+    #      (bgp
+    #       (triple ?s :p ?o1)
+    #       (triple ?s :q ?o2)))))
+    #
+    # @example SPARQL Grammar (with function call)
+    #   PREFIX :      <http://example.org/ns#>
+    #   PREFIX xsd:   <http://www.w3.org/2001/XMLSchema#>
+    #   SELECT *
+    #   { ?s ?p ?o }
+    #   ORDER BY 
+    #     DESC(?o+57) xsd:string(?o) ASC(?s)
+    #
+    # @example SSE (with function call)
+    #   (prefix ((: <http://example.org/ns#>)
+    #            (xsd: <http://www.w3.org/2001/XMLSchema#>))
+    #    (order ((desc (+ ?o 57))
+    #            (xsd:string ?o)
+    #            (asc ?s))
+    #     (bgp (triple ?s ?p ?o))))
+    #
     # @see https://www.w3.org/TR/sparql11-query/#modOrderBy
     class Order < Operator::Binary
       include Query
@@ -40,7 +92,13 @@ module SPARQL; module Algebra
             memo = begin
               a_eval = op.evaluate(a, queryable: queryable, depth: options[:depth].to_i + 1, **options) rescue nil
               b_eval = op.evaluate(b, queryable: queryable, depth: options[:depth].to_i + 1, **options) rescue nil
-              comp = Operator::Compare.evaluate(a_eval, b_eval).to_i
+              comp = begin
+                Operator::Compare.evaluate(a_eval, b_eval, order_by: true).to_s.to_i
+              rescue TypeError
+                # Type sError is effectively zero
+                debug(options) {"(order) rescue(#{$!}): #{a_eval.inspect}, #{b_eval.inspect}"}
+                RDF::Literal(0)
+              end
               comp = -comp if op.is_a?(Operator::Desc)
               comp
             end if memo == 0
@@ -50,6 +108,17 @@ module SPARQL; module Algebra
         @solutions.each(&block) if block_given?
         @solutions
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # Provides order to descendant query.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        operands.last.to_sparql(order_ops: operands.first, **options)
+      end
     end # Order
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,8 +3,23 @@ module SPARQL; module Algebra
     ##
     # The SPARQL Property Path `path` operator.
     #
-    # @example
-    #   (path :a (path+ :p) ?z)
+    # [88]  Path ::= PathAlternative
+    #
+    # @example SPARQL Grammar
+    #   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/#sparqlTranslatePathExpressions
     class Path < Operator::Ternary
@@ -45,6 +60,18 @@ module SPARQL; module Algebra
         @solutions.each(&block) if block_given?
         @solutions
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @param [Boolean] top_level (true)
+      #   Treat this as a top-level, generating SELECT ... WHERE {}
+      # @return [String]
+      def to_sparql(top_level: true, **options)
+        str = operands.to_sparql(top_level: false, **options) + " ."
+        top_level ? Operator.to_sparql(str, **options) : str
+      end
     end # Path
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,8 +3,18 @@ module SPARQL; module Algebra
     ##
     # The SPARQL Property Path `path?` (ZeroOrOnePath) operator.
     #
-    # @example
-    #   (path? :p)
+    # [91]  PathElt                 ::= PathPrimary PathMod?
+    # [93]  PathMod                 ::= '*' | '?' | '+'
+    
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example/> 
+    #   SELECT * WHERE {
+    #     :a (:p/:p)? ?t
+    #   } 
+    #
+    # @example SSE
+    #   (prefix ((: <http://example/>))
+    #    (path :a (path? (seq :p :p)) ?t))
     #
     # @see https://www.w3.org/TR/sparql11-query/#defn_evalPP_ZeroOrOnePath
     class PathOpt < Operator::Unary
@@ -107,6 +117,15 @@ module SPARQL; module Algebra
         solutions.each(&block) if block_given?
         solutions
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "(#{operands.first.to_sparql(**options)})?"
+      end
     end # PathOpt
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,8 +3,18 @@ module SPARQL; module Algebra
     ##
     # The SPARQL Property Path `path+` (OneOrMorePath) operator.
     #
-    # @example
-    #   (path+ :p)
+    # [91]  PathElt                 ::= PathPrimary PathMod?
+    # [93]  PathMod                 ::= '*' | '?' | '+'
+    
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example/> 
+    #   SELECT * WHERE {
+    #     :a :p+ ?z
+    #   } 
+    #
+    # @example SSE
+    #   (prefix ((: <http://example/>))
+    #    (path :a (path+ :p) ?z))
     #
     # @see https://www.w3.org/TR/sparql11-query/#defn_evalPP_OneOrMorePath
     class PathPlus < Operator::Unary
@@ -94,6 +104,15 @@ module SPARQL; module Algebra
         solutions.each(&block) if block_given? # Only at top-level
         solutions
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "(#{operands.first.to_sparql(**options)})+"
+      end
     end # PathPlus
   end # Operator
 end; end # SPARQL::Algebra