sparql 3.1.6 → 3.2.1

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

@@ -6,8 +6,13 @@ module SPARQL; module Algebra
     #
     # The COPY operation is a shortcut for inserting all data from an input graph into a destination graph. Data from the input graph is not affected, but data from the destination graph, if any, is removed before insertion.
     #
-    # @example
-    #   (copy silent <iri> to default)
+    # [37]  Copy                    ::= 'COPY' 'SILENT'? GraphOrDefault 'TO' GraphOrDefault
+    #
+    # @example SPARQL Grammar
+    #   COPY SILENT GRAPH <http://www.example.com/g1> TO DEFAULT
+    #
+    # @example SSE
+    #   (update (copy silent <http://www.example.com/g1> default))
     #
     # @see https://www.w3.org/TR/sparql11-update/#copy
     class Copy < Operator
@@ -59,6 +64,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]
+        
+        "COPY " + args.to_sparql(**options)
+      end
     end # Copy
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,12 +3,47 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `count` set function.
     #
-    # @example
-    #    (prefix ((: <http://www.example.org>))
-    #      (project (?C)
-    #        (extend ((?C ??.0))
-    #          (group () ((??.0 (count ?O)))
-    #            (bgp (triple ?S ?P ?O))))))
+    # [127] Aggregate::= 'COUNT' '(' 'DISTINCT'? ( '*' | Expression ) ')' ...
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://www.example.org/>
+    #   SELECT (COUNT(?O) AS ?C)
+    #   WHERE { ?S ?P ?O }
+    #
+    # @example SSE
+    #   (prefix ((: <http://www.example.org/>))
+    #     (project (?C)
+    #       (extend ((?C ??.0))
+    #         (group () ((??.0 (count ?O)))
+    #           (bgp (triple ?S ?P ?O))))))
+    #
+    # @example SPARQL Grammar (count(*))
+    #   PREFIX : <http://www.example.org>
+    #   
+    #   SELECT (COUNT(*) AS ?C)
+    #   WHERE { ?S ?P ?O }
+    #
+    # @example SSE (count(*))
+    #   (prefix
+    #    ((: <http://www.example.org>))
+    #    (project (?C)
+    #     (extend ((?C ??.0))
+    #      (group () ((??.0 (count)))
+    #       (bgp (triple ?S ?P ?O))))))
+    #
+    # @example SPARQL Grammar (count(distinct *))
+    #   PREFIX : <http://www.example.org>
+    #   
+    #   SELECT (COUNT(DISTINCT *) AS ?C)
+    #   WHERE { ?S ?P ?O }
+    #
+    # @example SSE (count(distinct *))
+    #   (prefix
+    #    ((: <http://www.example.org>))
+    #    (project (?C)
+    #     (extend ((?C ??.0))
+    #      (group () ((??.0 (count distinct)))
+    #       (bgp (triple ?S ?P ?O))))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#defn_aggCount
     class Count < Operator
@@ -22,9 +57,20 @@ module SPARQL; module Algebra
       # @param  [Enumerable<Array<RDF::Term>>] enum
       #   enum of evaluated operand
       # @return [RDF::Literal::Integer] The number of non-error terms in the multiset
-      def apply(enum)
+      def apply(enum, **options)
         RDF::Literal(enum.length)
       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
+        "COUNT(#{'DISTINCT ' if distinct}#{args.empty? ? '*' : args.to_sparql(**options)})"
+      end
     end # Count
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -8,8 +8,13 @@ module SPARQL; module Algebra
     #
     # This is a no-op for RDF.rb implementations, unless the graph exists
     #
-    # @example
-    #   (create silent <graph>)
+    # [34]  Create                  ::= 'CREATE' 'SILENT'? GraphRef
+    #
+    # @example SPARQL Grammar
+    #   CREATE SILENT GRAPH <http://example.org/g1>
+    #
+    # @example SSE
+    #   (update (create silent <http://example.org/g1>))
     #
     # @see https://www.w3.org/TR/sparql11-update/#create
     class Create < Operator
@@ -43,6 +48,19 @@ module SPARQL; module Algebra
         end
         queryable
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        silent = operands.first == :silent
+        str = "CREATE "
+        str << "SILENT " if operands.first == :silent
+        str << "GRAPH " if operands.last.is_a?(RDF::URI)
+        str << operands.last.to_sparql(**options)
+      end
     end # Create
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -73,7 +73,7 @@ module SPARQL; module Algebra
     # @example Dataset with two default data sources
     #
     #     (prefix ((: <http://example/>))
-    #       (dataset (<data-g1.ttl> <data-g1.ttl)
+    #       (dataset (<data-g1.ttl> <data-g2.ttl)
     #         (bgp (triple ?s ?p ?o))))
     #
     #     is effectively re-written to the following:
@@ -101,7 +101,21 @@ module SPARQL; module Algebra
     #       (filter ((= ?g <data-g1.ttl>) || (= ?g <data-g2.ttl>))
     #         (graph ?g (bgp (triple ?s ?p ?o))))))
     #
-    # @example Dataset with multiple named graphs
+    #
+    # @example SPARQL Grammar
+    #   BASE     <http://example.org/>
+    #   PREFIX : <http://example.com/>
+    #   
+    #   SELECT * 
+    #   FROM <data-g1.ttl>
+    #   { ?s ?p ?o }
+    #
+    # @example SSE
+    #   (base <http://example.org/>
+    #    (prefix ((: <http://example.com/>))
+    #     (dataset (<data-g1.ttl>)
+    #      (bgp (triple ?s ?p ?o)))))
+    #
     # @see https://www.w3.org/TR/sparql11-query/#specifyingDataset
     class Dataset < Binary
       include Query
@@ -158,6 +172,17 @@ module SPARQL; module Algebra
         aggregate.default(*default_datasets.select {|name| queryable.has_graph?(name)})
         aggregate.query(operands.last, depth: options[:depth].to_i + 1, **options, &base)
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # Extracts datasets
+      #
+      # @return [String]
+      def to_sparql(**options)
+        operands.last.to_sparql(datasets: operands.first, **options)
+      end
     end # Dataset
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,13 +3,23 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `datatype` operator.
     #
-    # @example
+    # [121] BuiltInCall ::= ... | 'DATATYPE' '(' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX  xsd: <http://www.w3.org/2001/XMLSchema#>
+    #   PREFIX  : <http://example.org/things#>
+    #   SELECT  ?x ?v
+    #   WHERE
+    #       { ?x :p ?v . 
+    #         FILTER ( datatype(?v) = xsd:double ) .
+    #       }
+    #
+    # @example SSE
     #   (prefix ((xsd: <http://www.w3.org/2001/XMLSchema#>)
-    #            (rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>)
-    #            (: <http://example.org/>))
-    #     (project (?s)
-    #       (filter (= (datatype (xsd:double ?v)) xsd:double)
-    #         (bgp (triple ?s :p ?v)))))
+    #            (: <http://example.org/things#>))
+    #    (project (?x ?v)
+    #     (filter (= (datatype ?v) xsd:double)
+    #      (bgp (triple ?x :p ?v)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-datatype
     class Datatype < Operator::Unary
@@ -27,12 +37,21 @@ module SPARQL; module Algebra
       #   a typed or simple literal
       # @return [RDF::URI] the datatype IRI, or `xsd:string` for simple literals
       # @raise  [TypeError] if the operand is not a typed or simple literal
-      def apply(literal)
+      def apply(literal, **options)
         case literal
           when RDF::Literal then literal.datatype
           else raise TypeError, "expected an RDF::Literal, but got #{literal.inspect}"
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "DATATYPE(#{operands.last.to_sparql(**options)})"
+      end
     end # Datatype
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,11 +3,20 @@ module SPARQL; module Algebra
     ##
     # The SPARQL logical `day` operator.
     #
-    # @example
-    #     (prefix ((: <http://example.org/>))
-    #       (project (?s ?x)
-    #         (extend ((?x (day ?date)))
-    #           (bgp (triple ?s :date ?date)))))
+    # [121] BuiltInCall ::= ... | 'DAY' '(' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   SELECT ?s (DAY(?date) AS ?x) WHERE {
+    #     ?s :date ?date
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.org/>))
+    #    (project (?s ?x)
+    #     (extend ((?x (day ?date)))
+    #      (bgp (triple ?s :date ?date)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-day
     class Day < Operator::Unary
@@ -22,10 +31,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.day)
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "DAY(#{operands.last.to_sparql(**options)})"
+      end
     end # Day
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -6,8 +6,24 @@ module SPARQL; module Algebra
     #
     # The DELETE operation is a form of the DELETE/INSERT operation having no INSERT section
     #
-    # @example
-    #   (delete ((triple ?s ?p ?o))))
+    # [42]  DeleteClause            ::= 'DELETE' QuadPattern
+    #
+    # @example SPARQL Grammar
+    #   PREFIX     : <http://example.org/> 
+    #   PREFIX foaf: <http://xmlns.com/foaf/0.1/> 
+    #   
+    #   DELETE { ?s ?p ?o }
+    #   WHERE  { :a foaf:knows ?s . ?s ?p ?o }
+    #
+    # @example SSE
+    #   (prefix ((: <http://example.org/>)
+    #            (foaf: <http://xmlns.com/foaf/0.1/>))
+    #    (update
+    #     (modify
+    #      (bgp
+    #       (triple :a foaf:knows ?s)
+    #       (triple ?s ?p ?o))
+    #      (delete ((triple ?s ?p ?o))))))
     #
     # @see https://www.w3.org/TR/sparql11-update/#delete
     class Delete < Operator::Unary
@@ -52,6 +68,17 @@ module SPARQL; module Algebra
         end
         queryable
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this term.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "DELETE {\n" +
+          operands.first.to_sparql(as_statement: true, delimiter: " .\n", **options) +
+          "\n}"
+      end
     end # Delete
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -6,8 +6,18 @@ module SPARQL; module Algebra
     #
     # The DELETE DATA operation removes some triples, given inline in the request, if the respective graphs in the Graph Store contain those
     #
-    # @example
-    #   (deleteData ((triple :a foaf:knows :c)))
+    # [39]  DeleteData              ::= 'DELETE DATA' QuadData
+    #
+    # @example SPARQL Grammar
+    #   PREFIX     : <http://example.org/> 
+    #   PREFIX foaf: <http://xmlns.com/foaf/0.1/> 
+    #   DELETE DATA {
+    #     :a foaf:knows :b .
+    #   }
+    #
+    # @example SSE
+    #   (prefix ((: <http://example.org/>) (foaf: <http://xmlns.com/foaf/0.1/>))
+    #    (update (deleteData ((triple :a foaf:knows :b)))))
     #
     # @see https://www.w3.org/TR/sparql11-update/#deleteData
     class DeleteData < Operator::Unary
@@ -36,6 +46,17 @@ module SPARQL; module Algebra
         end
         queryable
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this term.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "DELETE DATA {\n" +
+          operands.first.to_sparql(as_statement: true, top_level: false, delimiter: ". \n", **options) +
+          "\n}"
+      end
     end # DeleteData
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -6,8 +6,19 @@ module SPARQL; module Algebra
     #
     # The DELETE WHERE operation is a shortcut form for the DELETE/INSERT operation where bindings matched by the WHERE clause are used to define the triples in a graph that will be deleted.
     #
-    # @example
-    #   (deleteWhere ((triple :a foaf:knows ?b))
+    # [40]  DeleteWhere             ::= 'DELETE WHERE' QuadPattern
+    #
+    # @example SPARQL Grammar
+    #   PREFIX     : <http://example.org/> 
+    #   PREFIX foaf: <http://xmlns.com/foaf/0.1/> 
+    #   DELETE WHERE { :a foaf:knows ?b }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.org/>)
+    #     (foaf: <http://xmlns.com/foaf/0.1/>))
+    #    (update
+    #     (deleteWhere ((triple :a foaf:knows ?b)))))
     #
     # @see https://www.w3.org/TR/sparql11-update/#deleteWhere
     class DeleteWhere < Operator::Unary
@@ -52,6 +63,17 @@ module SPARQL; module Algebra
         end
         queryable
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this term.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "DELETE WHERE {\n" +
+          operands.first.to_sparql(as_statement: true, top_level: false, delimiter: ". \n", **options) +
+          "\n}"
+      end
     end # DeleteWhere
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,7 +3,15 @@ module SPARQL; module Algebra
     ##
     # The SPARQL descending sort operator.
     #
-    # @example
+    # [24]  OrderCondition          ::= ( ( 'ASC' | 'DESC' ) BrackettedExpression ) | ( Constraint | Var )
+    #
+    # @example SPARQL Grammar
+    #   PREFIX foaf:    <http://xmlns.com/foaf/0.1/>
+    #   SELECT ?name
+    #   WHERE { ?x foaf:name ?name }
+    #   ORDER BY DESC(?name)
+    #
+    # @example SSE
     #   (prefix ((foaf: <http://xmlns.com/foaf/0.1/>))
     #     (project (?name)
     #       (order ((desc ?name))
@@ -12,6 +20,17 @@ module SPARQL; module Algebra
     # @see https://www.w3.org/TR/sparql11-query/#modOrderBy
     class Desc < Operator::Asc
       NAME = :desc
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # Provides order to descendant query.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "DESC(#{operands.last.to_sparql(**options)})"
+      end
     end # Desc
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -5,10 +5,16 @@ module SPARQL; module Algebra
     #
     # Generages a graph across specified terms using {RDF::Queryable}`#concise_bounded_description`.
     #
-    # @example
-    #   (prefix ((exOrg: <http://org.example.com/employees#>))
-    #     (describe (?x)
-    #       (bgp (triple ?x exOrg:employeeId "1234"))))
+    # [11]  DescribeQuery           ::= 'DESCRIBE' ( VarOrIri+ | '*' ) DatasetClause* WhereClause? SolutionModifier ValuesClause
+    #
+    # @example SPARQL Grammar
+    #   BASE <http://example.org/>
+    #   DESCRIBE <u> ?u WHERE { <x> <q> ?u . }
+    #
+    # @example SSE
+    #   (base <http://example.org/>
+    #    (describe (<u> ?u)
+    #     (bgp (triple <x> <q> ?u))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#describe
     class Describe < Operator::Binary
@@ -66,6 +72,23 @@ module SPARQL; module Algebra
       def query_yields_statements?
         true
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this term.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        str = "DESCRIBE "
+        str << if operands[0].empty?
+          "*"
+        else
+          operands[0].map { |e| e.to_sparql(**options) }.join(" ")
+        end
+
+        str << "\n"
+        str << operands[1].to_sparql(top_level: true, project: nil, **options)
+      end
     end # Construct
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,9 +3,17 @@ module SPARQL; module Algebra
     ##
     # The SPARQL GraphPattern `distinct` operator.
     #
-    # @example
-    #   (prefix ((xsd: <http://www.w3.org/2001/XMLSchema#>)
-    #            (: <http://example/>))
+    # [9] SelectClause ::= 'SELECT' ( 'DISTINCT' | 'REDUCED' )? ( ( Var | ( '(' Expression 'AS' Var ')' ) )+ | '*' )
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
+    #   SELECT DISTINCT ?v
+    #   WHERE { ?x ?p ?v }
+    #
+    # @example SSE
+    #   (prefix ((: <http://example.org/>)
+    #            (xsd: <http://www.w3.org/2001/XMLSchema#>))
     #     (distinct
     #       (project (?v)
     #         (bgp (triple ?x ?p ?v)))))
@@ -36,6 +44,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(distinct: true, **options)
+      end
     end # Distinct
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,8 +3,23 @@ module SPARQL; module Algebra
     ##
     # The SPARQL numeric `divide` operator.
     #
-    # @example
-    #   (/ 4 2)
+    # [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-divide
     class Divide < Operator::Binary
@@ -21,7 +36,7 @@ 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)
             # For xsd:decimal and xsd:integer operands, if the divisor is
@@ -38,6 +53,15 @@ module SPARQL; module Algebra
           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 # Divide
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -8,8 +8,20 @@ module SPARQL; module Algebra
     #
     # Equivalent to `clear` in this implementation
     #
-    # @example
-    #   (drop default)
+    # [33]  Drop                    ::= 'DROP' 'SILENT'? GraphRefAll
+    #
+    # @example SPARQL Grammar (SILENT DEFAULT)
+    #   DROP SILENT DEFAULT
+    #
+    # @example SSE (SILENT DEFAULT)
+    #   (update
+    #    (drop silent default))
+    #
+    # @example SPARQL Grammar (IRI)
+    #   DROP GRAPH <http://example.com/>
+    #
+    # @example SSE (IRI)
+    #   (update (drop <http://example.com/>))
     #
     # @see https://www.w3.org/TR/sparql11-update/#drop
     class Drop < Operator
@@ -34,7 +46,6 @@ module SPARQL; module Algebra
       def execute(queryable, **options)
         debug(options) {"Drop"}
         silent = operands.first == :silent
-        silent = operands.first == :silent
         operands.shift if silent
 
         raise ArgumentError, "drop expected operand to be 'default', 'named', 'all', or an IRI" unless operands.length == 1
@@ -61,6 +72,19 @@ module SPARQL; module Algebra
 
         queryable
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        silent = operands.first == :silent
+        str = "DROP "
+        str << "SILENT " if operands.first == :silent
+        str << "GRAPH " if operands.last.is_a?(RDF::URI)
+        str << operands.last.to_sparql(**options)
+      end
     end # Drop
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -5,8 +5,19 @@ module SPARQL; module Algebra
     ##
     # The SPARQL logical `abs` operator.
     #
-    # @example
-    #   (encode_for_uri ?x)
+    # [121] BuiltInCall ::= ... | 'ENCODE_FOR_URI' '(' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   SELECT ?s ?str (ENCODE_FOR_URI(?str) AS ?encoded) WHERE {
+    #     ?s :str ?str
+    #   }
+    #
+    # @example SSE
+    #   (prefix ((: <http://example.org/>))
+    #    (project (?s ?str ?encoded)
+    #     (extend ((?encoded (encode_for_uri ?str)))
+    #      (bgp (triple ?s :str ?str)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-encode
     # @see https://www.w3.org/TR/xpath-functions/#func-abs
@@ -27,12 +38,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(CGI.escape(operand.to_s))
           else raise TypeError, "expected an RDF::Literal, but got #{operand.inspect}"
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "ENCODE_FOR_URI(#{operands.last.to_sparql(**options)})"
+      end
     end # EncodeForURI
   end # Operator
 end; end # SPARQL::Algebra