sparql 3.1.8 → 3.2.3

data/lib/sparql/algebra/expression.rb

@@ -6,6 +6,19 @@ module SPARQL; module Algebra
   module Expression
     include RDF::Util::Logger
 
+    # Operators for which `:triple` denotes a pattern, not a builtin
+    PATTERN_PARENTS = [
+      Operator::BGP,
+      Operator::Construct,
+      Operator::Delete,
+      Operator::DeleteData,
+      Operator::DeleteWhere,
+      Operator::Graph,
+      Operator::Insert,
+      Operator::InsertData,
+      Operator::Path,
+    ].freeze
+
     ##
     # @example
     #   Expression.parse('(isLiteral 3.1415)')
@@ -66,9 +79,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
 
@@ -82,20 +97,27 @@ module SPARQL; module Algebra
     #   any additional options (see {Operator#initialize})
     # @return [Expression]
     # @raise  [TypeError] if any of the operands is invalid
-    def self.new(sse, **options)
+    def self.new(sse, parent_operator: nil, **options)
       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
           debug(options) {"Map array elements #{sse}"}
-          sse.map {|s| self.new(s, depth: options[:depth].to_i + 1, **options)}
+          sse.map {|s| self.new(s, parent_operator: parent_operator, depth: options[:depth].to_i + 1, **options)}
         else
           debug(options) {"No operator found for #{sse.first}"}
           sse.map do |s|
             s.is_a?(Array) ?
-              self.new(s, depth: options[:depth].to_i + 1) :
+              self.new(s, parent_operator: parent_operator, depth: options[:depth].to_i + 1) :
               s
           end
         end
@@ -105,7 +127,7 @@ module SPARQL; module Algebra
         debug(options) {"Operator=#{operator.inspect}, Operand=#{operand.inspect}"}
         case operand
           when Array
-            self.new(operand, depth: options[:depth].to_i + 1, **options)
+            self.new(operand, parent_operator: operator, depth: options[:depth].to_i + 1, **options)
           when Operator, Variable, RDF::Term, RDF::Query, Symbol
             operand
           when TrueClass, FalseClass, Numeric, String, DateTime, Date, Time
@@ -115,11 +137,22 @@ 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)
+        # Due to confusiong over (triple) and special-case for (qtriple)
+        if operator == RDF::Query::Pattern
+          options = options.merge(quoted: true) if sse.first == :qtriple
+        elsif operator == Operator::Triple && PATTERN_PARENTS.include?(parent_operator)
+          operator = RDF::Query::Pattern
+        end
+        operator.new(*operands, parent_operator: operator, **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 +196,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.
     #
@@ -190,7 +234,7 @@ module SPARQL; module Algebra
     #
     # @param [RDF::URI] datatype
     #   Datatype to evaluate, one of:
-    #   xsd:integer, xsd:decimal xsd:float, xsd:double, xsd:string, xsd:boolean, or xsd:dateTime
+    #   xsd:integer, xsd:decimal xsd:float, xsd:double, xsd:string, xsd:boolean, xsd:dateTime, xsd:duration, xsd:dayTimeDuration, xsd:yearMonthDuration
     # @param [RDF::Term] value
     #   Value, which should be a typed literal, where the type must be that specified
     # @raise [TypeError] if datatype is not a URI or value cannot be cast to datatype
@@ -198,7 +242,7 @@ module SPARQL; module Algebra
     # @see https://www.w3.org/TR/sparql11-query/#FunctionMapping
     def self.cast(datatype, value)
       case datatype
-      when RDF::XSD.dateTime
+      when RDF::XSD.date, RDF::XSD.time, RDF::XSD.dateTime
         case value
         when RDF::Literal::DateTime, RDF::Literal::Date, RDF::Literal::Time
           RDF::Literal.new(value, datatype: datatype)
@@ -207,6 +251,15 @@ module SPARQL; module Algebra
         else
           RDF::Literal.new(value.value, datatype: datatype, validate: true)
         end
+      when RDF::XSD.duration, RDF::XSD.dayTimeDuration, RDF::XSD.yearMonthDuration
+        case value
+        when RDF::Literal::Duration, RDF::Literal::DayTimeDuration, RDF::Literal::YearMonthDuration
+          RDF::Literal.new(value, datatype: datatype, validate: true, canonicalize: true)
+        when RDF::Literal::Numeric, RDF::Literal::Boolean, RDF::URI, RDF::Node
+          raise TypeError, "Value #{value.inspect} cannot be cast as #{datatype}"
+        else
+          RDF::Literal.new(value.value, datatype: datatype, validate: true, canonicalize: true)
+        end
       when RDF::XSD.float, RDF::XSD.double
         case value
         when RDF::Literal::Boolean

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
 
   ##
@@ -121,6 +124,14 @@ class Array
   end
   def constant?; !(variable?); end
 
+  ##
+  # The variables used in this array.
+  #
+  # @return [Hash{Symbol => RDF::Query::Variable}]
+  def variables
+    self.inject({}) {|hash, o| o.respond_to?(:variables) ? hash.merge(o.variables) : hash}
+  end
+
   ##
   # Does this contain any nodes?
   #
@@ -216,15 +227,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 +280,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,13 +340,22 @@ 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
   # Transform Statement Pattern into an SXP
   # @return [Array]
   def to_sxp_bin
-    [ (has_graph? ? :quad : :triple),
+    [ (has_graph? ? :quad : (quoted? ? :qtriple : :triple)),
       (:inferred if inferred?),
       subject,
       predicate,
@@ -361,9 +367,21 @@ 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(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.
+  #
   # @return [String]
-  def to_sxp
-    to_sxp_bin.to_sxp
+  def to_sparql(**options)
+    str = to_triple.map {|term| term.to_sparql(**options)}.join(" ")
+    quoted? ? ('<<' + str + '>>') : str
   end
 
   ##
@@ -411,6 +429,40 @@ 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 do |e|
+      e.to_sparql(top_level: false, **options) + " . \n"
+    end.join("")
+    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(**options)
+        pp = RDF::Query::Variable.new(as).to_sparql(**options)
+        str << "\nBIND (" << v << " AS " << pp << ") ."
+      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
@@ -26,6 +37,15 @@ module SPARQL; module Algebra
           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/adjust.rb

@@ -0,0 +1,69 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL `adjust` operator.
+    #
+    # [121] BuiltInCall ::= ... | 'ADJUST' '(' Expression ',' Expression ')'
+    #
+    # @example SPARQL Grammar
+    #   PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
+    #   SELECT ?id (ADJUST(?d, ?tz) AS ?adjusted) WHERE {
+    #     VALUES (?id ?tz ?d) {
+    #       (1 "-PT10H"^^xsd:dayTimeDuration "2002-03-07"^^xsd:date)
+    #     }
+    #   }
+    #
+    # @example SSE
+    #   (prefix ((xsd: <http://www.w3.org/2001/XMLSchema#>))
+    #    (project (?id ?adjusted)
+    #     (extend ((?adjusted (adjust ?d ?tz)))
+    #      (table (vars ?id ?tz ?d)
+    #       (row
+    #        (?id 1)
+    #        (?tz "-PT10H"^^xsd:dayTimeDuration)
+    #        (?d "2002-03-07"^^xsd:date))))))
+    #
+    # @see https://www.w3.org/TR/sparql11-query/#func-abs
+    # @see https://www.w3.org/TR/xpath-functions/#func-abs
+    class Adjust < Operator::Binary
+      include Evaluatable
+
+      NAME = [:adjust]
+
+      ##
+      # Returns the first operand adjusted by the dayTimeDuration of the second operand
+      # 
+      # @param  [RDF::Literal::Temporal] operand
+      #   the operand
+      # @param  [RDF::Literal, String] duration
+      #   the dayTimeDuration or an empty string.
+      # @return [RDF::Literal] literal of same type
+      # @raise  [TypeError] if the operand is not a numeric value
+      def apply(operand, duration, **options)
+        case operand
+        when RDF::Literal::Temporal
+          case duration
+          when RDF::Literal::DayTimeDuration
+            operand.adjust_to_timezone(duration)
+          when RDF::Literal
+            raise TypeError, "expected second operand to be an empty literal, but got #{duration.inspect}" unless duration.to_s.empty?
+            operand.adjust_to_timezone(nil)
+          else
+            raise TypeError, "expected second operand to be an RDF::Literal::DayTimeDuration, but got #{duration.inspect}"
+          end
+        else
+          raise TypeError, "expected first operand to be an RDF::Literal::Temporal, but got #{operand.inspect}"
+        end
+      end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "ADJUST(#{operands.to_sparql(delimiter: ', ', **options)})"
+      end
+    end # Abs
+  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

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

@@ -3,7 +3,15 @@ module SPARQL; module Algebra
     ##
     # The SPARQL ascending sort operator.
     #
-    # @example
+    # [24]  OrderCondition          ::= ( ( 'ASC' | 'DESC' ) BrackettedExpression ) | ( Constraint | Var )
+    #
+    # @example SPARQL Query
+    #   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))
@@ -27,6 +35,17 @@ module SPARQL; module Algebra
       def evaluate(bindings, **options)
         operand(0).evaluate(bindings, depth: options[:depth].to_i + 1, **options)
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # Provides order to descendant query.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "ASC(#{operands.last.to_sparql(**options)})"
+      end
     end # Asc
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -5,7 +5,13 @@ module SPARQL; module Algebra
     #
     # Applications can use the ASK form to test whether or not a query pattern has a solution. No information is returned about the possible query solutions, just whether or not a solution exists.
     #
-    # @example
+    # [12]  AskQuery                ::= 'ASK' DatasetClause* WhereClause ValuesClause
+    #
+    # @example SPARQL Query
+    #   PREFIX :    <http://example/>
+    #   ASK  { :x :p  ?x }
+    #
+    # @example SSE
     #   (prefix ((: <http://example/>))
     #     (ask
     #       (bgp (triple :x :p ?x))))
@@ -41,6 +47,16 @@ module SPARQL; module Algebra
       def query_yields_boolean?
         true
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this term.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "ASK\n" +
+        operands.first.to_sparql(top_level: true, project: nil, **options)
+      end
     end # Ask
   end # Operator
 end; end # SPARQL::Algebra