sparql 3.1.6 → 3.2.1

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

@@ -3,7 +3,15 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `langMatches` operator.
     #
-    # @example
+    # [121] BuiltInCall ::= ... | 'LANGMATCHES' '(' Expression ',' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/#>
+    #   
+    #   SELECT *
+    #   { :x ?p ?v . FILTER langMatches(lang(?v), "en-GB") . }
+    #
+    # @example SSE
     #   (prefix ((: <http://example.org/#>))
     #     (filter (langMatches (lang ?v) "en-GB")
     #       (bgp (triple :x ?p ?v))))
@@ -27,7 +35,7 @@ module SPARQL; module Algebra
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if either operand is unbound
       # @raise  [TypeError] if either operand is not a simple literal
-      def apply(language_tag, language_range)
+      def apply(language_tag, language_range, **options)
         raise TypeError, "expected a plain RDF::Literal for language_tag, but got #{language_tag.inspect}" unless language_tag.is_a?(RDF::Literal) && language_tag.simple?
         language_tag = language_tag.to_s.downcase
 
@@ -48,6 +56,19 @@ module SPARQL; module Algebra
             RDF::Literal(language_tag.start_with?(language_range + '-'))
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "langMatches(" +
+          operands.first.to_sparql(**options) +
+          ", " +
+          operands.last.to_sparql(**options) +
+          ")"
+      end
     end # LangMatches
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,8 +3,19 @@ module SPARQL; module Algebra
     ##
     # The SPARQL logical `lcase` operator.
     #
-    # @example
-    #   (lcase ?x)
+    # [121] BuiltInCall ::= ... | 'LCASE' '(' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   SELECT ?s (LCASE(?str) AS ?lstr) WHERE {
+    #     ?s :str ?str
+    #   }
+    #
+    # @example SSE
+    #   (prefix ((: <http://example.org/>))
+    #    (project (?s ?lstr)
+    #     (extend ((?lstr (lcase ?str)))
+    #      (bgp (triple ?s :str ?str)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-lcase
     # @see https://www.w3.org/TR/xpath-functions/#func-lcase
@@ -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 literal value
-      def apply(operand)
+      def apply(operand, **options)
         case operand
           when RDF::Literal then RDF::Literal(operand.to_s.downcase, datatype: operand.datatype, language: operand.language)
           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)
+        "LCASE(" + operands.last.to_sparql(**options) + ")"
+      end
     end # LCase
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,7 +3,19 @@ module SPARQL; module Algebra
     ##
     # The SPARQL GraphPattern `leftjoin` operator.
     #
-    # @example
+    # [57]  OptionalGraphPattern    ::= 'OPTIONAL' GroupGraphPattern
+    #
+    # @example SPARQL Grammar
+    #   PREFIX :    <http://example/>
+    #   SELECT * { 
+    #     ?x :p ?v .
+    #     OPTIONAL { 
+    #       ?y :q ?w .
+    #       FILTER(?v=2)
+    #     }
+    #   }
+    #
+    # @example SSE
     #   (prefix ((: <http://example/>))
     #     (leftjoin
     #       (bgp (triple ?x :p ?v))
@@ -112,6 +124,35 @@ module SPARQL; module Algebra
           expr ? LeftJoin.new(ops[0], ops[1], expr) : LeftJoin.new(ops[0], ops[1])
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @param [Boolean] top_level (true)
+      #   Treat this as a top-level, generating SELECT ... WHERE {}
+      # @param [Hash{Symbol => Operator}] extensions
+      #   Variable bindings
+      # @param [Array<Operator>] filter_ops ([])
+      #   Filter Operations
+      # @return [String]
+      def to_sparql(top_level: true, filter_ops: [], extensions: {}, **options)
+        str = "{\n" + operands[0].to_sparql(top_level: false, extensions: {}, **options)
+        str << 
+          "\nOPTIONAL {\n" +
+          operands[1].to_sparql(top_level: false, extensions: {}, **options)
+        case operands[2]
+        when SPARQL::Algebra::Operator::Exprlist
+          operands[2].operands.each do |op|
+            str << "\nFILTER (" + op.to_sparql(**options) + ")"
+          end
+        when nil
+        else
+          str << "\nFILTER (" + operands[2].to_sparql(**options) + ")"
+        end
+        str << "\n}}"
+        top_level ? Operator.to_sparql(str, filter_ops: filter_ops, extensions: extensions, **options) : str
+      end
     end # LeftJoin
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,8 +3,18 @@ module SPARQL; module Algebra
     ##
     # The SPARQL relational `<` (less than) comparison operator.
     #
-    # @example
-    #   (< ?x ?y)
+    # [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/xpath-functions/#func-compare
@@ -24,8 +34,8 @@ module SPARQL; module Algebra
       #   a literal
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if either operand is not a literal
-      def apply(left, right)
-        super
+      def apply(left, right, **options)
+        RDF::Literal(super == RDF::Literal(-1))
       end
     end # LessThan
   end # Operator

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

@@ -3,8 +3,18 @@ module SPARQL; module Algebra
     ##
     # The SPARQL relational `<=` (less than or equal) comparison operator.
     #
-    # @example
-    #   (<= ?x ?y)
+    # [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/xpath-functions/#func-compare
@@ -24,8 +34,8 @@ module SPARQL; module Algebra
       #   a literal
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if either operand is not a literal
-      def apply(left, right)
-        super
+      def apply(left, right, **options)
+        RDF::Literal(super <= RDF::Literal(0))
       end
     end # LessThanOrEqual
   end # Operator

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

@@ -6,8 +6,14 @@ module SPARQL; module Algebra
     #
     # The LOAD operation reads an RDF document from a IRI and inserts its triples into the specified graph in the Graph Store. The specified destination graph should be created if required; again, implementations providing an update service over a fixed set of graphs must return with failure for a request that would create a disallowed graph. If the destination graph already exists, then no data in that graph will be removed.
     #
-    # @example
-    #   (load <remote> <g>)
+    #
+    # [31]  Load                    ::= 'LOAD' 'SILENT'? iri ( 'INTO' GraphRef )?
+    #
+    # @example SPARQL Grammar
+    #   LOAD <http://example.org/remote> INTO GRAPH <http://example.org/g> ;
+    #
+    # @example SSE
+    #   (update (load <http://example.org/remote> <http://example.org/g>))
     #
     # @see https://www.w3.org/TR/sparql11-update/#load
     class Load < Operator
@@ -43,6 +49,23 @@ module SPARQL; module Algebra
       ensure
         queryable
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        silent = operands.first == :silent
+        ops = silent ? operands[1..-1] : operands
+        location, name = ops
+
+        str = "LOAD "
+        str << "SILENT " if silent
+        str << location.to_sparql(**options)
+        str << " INTO GRAPH " + name.to_sparql(**options) if name
+        str
+      end
     end # Load
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,7 +3,14 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `max` set function.
     #
-    # @example
+    # [127] Aggregate::= ... | 'MAX' '(' 'DISTINCT'? Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://www.example.org/>
+    #   SELECT (MAX(?o) AS ?max)
+    #   WHERE { ?s ?p ?o }
+    #
+    # @example SSE
     #    (prefix ((: <http://www.example.org/>))
     #      (project (?max)
     #        (extend ((?max ??.0))
@@ -31,7 +38,7 @@ module SPARQL; module Algebra
       # @param  [Enumerable<Array<RDF::Term>>] enum
       #   enum of evaluated operand
       # @return [RDF::Literal] The maximum value of the terms
-      def apply(enum)
+      def apply(enum, **options)
         # FIXME: we don't actually do anything with distinct
         operands.shift if distinct = (operands.first == :distinct)
         if enum.empty?
@@ -42,6 +49,17 @@ module SPARQL; module Algebra
           raise TypeError, "Maximum of non-literals: #{enum.flatten}"
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        distinct = operands.first == :distinct
+        args = distinct ? operands[1..-1] : operands
+        "MAX(#{'DISTINCT ' if distinct}#{args.to_sparql(**options)})"
+      end
     end # Max
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -7,11 +7,19 @@ module SPARQL; module Algebra
     #
     # Returns the MD5 checksum, as a hex digit string, calculated on the UTF-8 representation of the simple literal or lexical form of the `xsd:string`. Hex digits `SHOULD` be in lower case.
     #
-    # @example
-    #     (prefix ((: <http://example.org/>))
-    #       (project (?hash)
-    #         (extend ((?hash (md5 ?l)))
-    #           (bgp (triple :s1 :str ?l)))))
+    # [121] BuiltInCall ::= ... | 'MD5' '(' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   SELECT (MD5(?l) AS ?hash) WHERE {
+    #    :s1 :str ?l
+    #   }
+    #
+    # @example SSE
+    #   (prefix ((: <http://example.org/>))
+    #     (project (?hash)
+    #       (extend ((?hash (md5 ?l)))
+    #         (bgp (triple :s1 :str ?l)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-md5
     class MD5 < Operator::Unary
@@ -26,11 +34,20 @@ 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, but got #{operand.inspect}" unless operand.literal?
         raise TypeError, "expected simple literal or xsd:string, but got #{operand.inspect}" unless (operand.datatype || RDF::XSD.string) == RDF::XSD.string
         RDF::Literal(Digest::MD5.new.hexdigest(operand.to_s))
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "MD5(" + operands.to_sparql(**options) + ")"
+      end
     end # MD5
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,12 +3,19 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `min` set function.
     #
-    # @example
+    # [127] Aggregate::= ... | 'MIN' '(' 'DISTINCT'? Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://www.example.org/>
+    #   SELECT (MIN(?o) AS ?min)
+    #   WHERE { ?s :dec ?o }
+    #
+    # @example SSE
     #    (prefix ((: <http://www.example.org/>))
-    #      (project (?max)
+    #      (project (?min)
     #        (extend ((?min ??.0))
     #          (group () ((??.0 (min ?o)))
-    #            (bgp (triple ?s ?p ?o))))))
+    #            (bgp (triple ?s :dec ?o))))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#defn_aggMin
     class Min < Operator
@@ -31,7 +38,7 @@ module SPARQL; module Algebra
       # @param  [Enumerable<Array<RDF::Term>>] enum
       #   enum of evaluated operand
       # @return [RDF::Literal] The maximum value of the terms
-      def apply(enum)
+      def apply(enum, **options)
         # FIXME: we don't actually do anything with distinct
         operands.shift if distinct = (operands.first == :distinct)
         if enum.empty?
@@ -42,6 +49,17 @@ module SPARQL; module Algebra
           raise TypeError, "Minumuim of non-literals: #{enum.flatten}"
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        distinct = operands.first == :distinct
+        args = distinct ? operands[1..-1] : operands
+        "MIN(#{'DISTINCT ' if distinct}#{args.to_sparql(**options)})"
+      end
     end # Min
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,13 +3,42 @@ 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)))
+    #
+    # @example SPARQL Grammar (inline filter)
+    #   PREFIX :    <http://example/>
+    #   SELECT (?s1 AS ?subset) (?s2 AS ?superset)
+    #   WHERE {
+    #       ?s2 a :Set .
+    #       ?s1 a :Set .
+    #       FILTER(?s1 != ?s2)
+    #       MINUS {
+    #           ?s1 a :Set .
+    #           ?s2 a :Set .
+    #           FILTER(?s1 != ?s2)
+    #       }
+    #   }
+    # 
+    # @example SSE (inline filter)
+    #   (prefix ((: <http://example/>))
+    #    (project (?subset ?superset)
+    #     (extend ((?subset ?s1) (?superset ?s2))
+    #      (filter (!= ?s1 ?s2)
+    #       (minus
+    #        (bgp (triple ?s2 a :Set) (triple ?s1 a :Set))
+    #        (filter (!= ?s1 ?s2)
+    #         (bgp
+    #          (triple ?s1 a :Set)
+    #          (triple ?s2 a :Set))))))))
     #
     # @see https://www.w3.org/TR/xpath-functions/#func-numeric-unary-minus
     # @see https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
@@ -66,6 +95,35 @@ module SPARQL; module Algebra
         @operands = ops
         self
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @param [Hash{Symbol => Operator}] extensions
+      #   Variable bindings
+      # @param [Array<Operator>] filter_ops ([])
+      #   Filter Operations
+      # @param [Boolean] top_level (true)
+      #   Treat this as a top-level, generating SELECT ... WHERE {}
+      # @return [String]
+      def to_sparql(top_level: true, filter_ops: [], extensions: {}, **options)
+        lhs, *rhs = operands
+        str = "{\n" + lhs.to_sparql(top_level: false, extensions: {}, **options)
+
+        # Any accrued filters go here.
+        filter_ops.each do |op|
+          str << "\nFILTER (#{op.to_sparql(**options)}) ."
+        end
+
+        rhs.each do |minus|
+          str << "\nMINUS {\n"
+          str << minus.to_sparql(top_level: false, extensions: {}, **options)
+          str << "\n}"
+        end
+        str << "}"
+        top_level ? Operator.to_sparql(str, extensions: extensions, **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