sparql 3.1.5 → 3.2.0

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

@@ -3,13 +3,16 @@ module SPARQL; module Algebra
     ##
     # The SPARQL GraphPattern `minus` operator.
     #
-    # @example
-    #    (prefix ((ex: <http://www.w3.org/2009/sparql/docs/tests/data-sparql11/negation#>))
-    #      (project (?animal)
-    #        (minus
-    #          (bgp (triple ?animal <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> ex:Animal))
-    #          (filter (|| (= ?type ex:Reptile) (= ?type ex:Insect))
-    #            (bgp (triple ?animal <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> ?type))))))
+    # [66]  MinusGraphPattern       ::= 'MINUS' GroupGraphPattern
+    #
+    # @example SPARQL Grammar
+    #   SELECT * { ?s ?p ?o MINUS { ?s ?q ?v } }
+    #
+    # @example SSE
+    #   (minus
+    #    (bgp
+    #     (triple ?s ?p ?o))
+    #    (bgp (triple ?s ?q ?v)))
     #
     # @see https://www.w3.org/TR/xpath-functions/#func-numeric-unary-minus
     # @see https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
@@ -66,6 +69,21 @@ module SPARQL; module Algebra
         @operands = ops
         self
       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.first.to_sparql(top_level: false, **options) + "\n"
+        str << "MINUS {\n"
+        str << operands.last.to_sparql(top_level: false, **options)
+        str << "\n}"
+        top_level ? Operator.to_sparql(str, **options) : str
+      end
     end # Minus
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -5,11 +5,20 @@ module SPARQL; module Algebra
     #
     # Returns the minutes part of the lexical form of `arg`. The value is as given in the lexical form of the XSD dateTime.
     #
-    # @example
-    #     (prefix ((: <http://example.org/>))
-    #       (project (?s ?x)
-    #         (extend ((?x (minutes ?date)))
-    #           (bgp (triple ?s :date ?date)))))
+    # [121] BuiltInCall ::= ... | 'MINUTES' '(' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   SELECT ?s (MINUTES(?date) AS ?x) WHERE {
+    #     ?s :date ?date
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.org/>))
+    #    (project (?s ?x)
+    #     (extend ((?x (minutes ?date)))
+    #      (bgp (triple ?s :date ?date)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-minutes
     class Minutes < Operator::Unary
@@ -24,10 +33,19 @@ module SPARQL; module Algebra
       #   the operand
       # @return [RDF::Literal]
       # @raise  [TypeError] if the operand is not a simple literal
-      def apply(operand)
+      def apply(operand, **options)
         raise TypeError, "expected an RDF::Literal::DateTime, but got #{operand.inspect}" unless operand.is_a?(RDF::Literal::DateTime)
         RDF::Literal(operand.object.minute)
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "MINUTES(#{operands.last.to_sparql(**options)})"
+      end
     end # Minutes
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -6,11 +6,23 @@ module SPARQL; module Algebra
     #
     # Wraps delete/insert
     #
-    # @example
-    #   (modify
-    #     (bgp (triple ?a foaf:knows ?b))
-    #     (delete ((triple ?a foaf:knows ?b)))
-    #     (insert ((triple ?b foaf:knows ?a)))
+    # [41]  Modify ::= ( 'WITH' iri )? ( DeleteClause InsertClause? | InsertClause ) UsingClause* 'WHERE' GroupGraphPattern
+    #
+    # @example SPARQL Grammar
+    #   PREFIX     : <http://example.org/> 
+    #   PREFIX foaf: <http://xmlns.com/foaf/0.1/> 
+    #   DELETE  { ?a foaf:knows ?b }
+    #   INSERT { ?b foaf:knows ?a }
+    #   WHERE { ?a foaf:knows ?b }
+    #
+    # @example SSE
+    #   (prefix ((: <http://example.org/>)
+    #            (foaf: <http://xmlns.com/foaf/0.1/>))
+    #    (update
+    #     (modify
+    #      (bgp (triple ?a foaf:knows ?b))
+    #      (delete ((triple ?a foaf:knows ?b)))
+    #      (insert ((triple ?b foaf:knows ?a)))) ))
     #
     # @see XXX
     class Modify < Operator
@@ -48,6 +60,30 @@ module SPARQL; module Algebra
         end
         queryable
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        if operands.first.is_a?(With)
+          operands.first.to_sparql(**options)
+        else
+          # The content of the WHERE clause, may be USING
+          content = operands.first.to_sparql(top_level: false, **options)
+
+          # DELETE | INSERT | DELETE INSERT
+          str = operands[1..-1].to_sparql(top_level: false, delimiter: "\n", **options) + "\n"
+
+          # Append the WHERE or USING clause
+          str << if operands.first.is_a?(Using)
+            content
+          else
+            Operator.to_sparql(content, project: nil, **options)
+          end
+        end
+      end
     end # Modify
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -5,11 +5,20 @@ module SPARQL; module Algebra
     #
     # Returns the month part of `arg` as an integer.
     #
-    # @example
-    #     (prefix ((: <http://example.org/>))
-    #       (project (?s ?x)
-    #         (extend ((?x (month ?date)))
-    #           (bgp (triple ?s :date ?date)))))
+    # [121] BuiltInCall ::= ... | 'MONTH' '(' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   SELECT ?s (MONTH(?date) AS ?x) WHERE {
+    #     ?s :date ?date
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.org/>))
+    #    (project (?s ?x)
+    #     (extend ((?x (month ?date)))
+    #      (bgp (triple ?s :date ?date)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-month
     class Month < Operator::Unary
@@ -24,10 +33,19 @@ module SPARQL; module Algebra
       #   the operand
       # @return [RDF::Literal]
       # @raise  [TypeError] if the operand is not a simple literal
-      def apply(operand)
+      def apply(operand, **options)
         raise TypeError, "expected an RDF::Literal::DateTime, but got #{operand.inspect}" unless operand.is_a?(RDF::Literal::DateTime)
         RDF::Literal(operand.object.month)
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "MONTH(#{operands.last.to_sparql(**options)})"
+      end
     end # Month
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -6,8 +6,14 @@ module SPARQL; module Algebra
     #
     # The MOVE operation is a shortcut for moving all data from an input graph into a destination graph. The input graph is removed after insertion and data from the destination graph, if any, is removed before insertion.
     #
-    # @example
-    #   (move silent <iri> to default)
+    # [36]  Move                    ::= 'MOVE' 'SILENT'? GraphOrDefault 'TO' GraphOrDefault
+    #
+    # @example SPARQL Grammar
+    #   MOVE SILENT GRAPH <http://www.example.com/g1> TO DEFAULT
+    #
+    # @example SSE
+    #   (update
+    #    (move silent <http://www.example.com/g1> default))
     #
     # @see https://www.w3.org/TR/sparql11-update/#move
     class Move < Operator
@@ -62,6 +68,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]
+        
+        "MOVE " + args.to_sparql(**options)
+      end
     end # Move
   end # Operator
 end; end # SPARQL::Algebra

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:b ^ex:p in:a }
+    #
+    # @example SSE
+    #   (prefix ((ex: <http://www.example.org/schema#>)
+    #            (in: <http://www.example.org/instance#>))
+    #    (ask
+    #     (path in:b (reverse ex:p) in:a)))
     #
     # @see https://www.w3.org/TR/sparql11-query/#eval_negatedPropertySet
     class NotOneOf < Operator

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

@@ -0,0 +1,59 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL `OBJECT` operator.
+    #
+    # 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
+
+      NAME = :object
+
+      ##
+      # Returns the object part of arg.
+      #
+      # @param  [RDF::Statement] operand
+      #   the operand
+      # @return [RDF::Literal]
+      # @raise  [TypeError] if the operand is not a statement
+      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