sparql 3.1.8 → 3.2.3

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

@@ -3,7 +3,18 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `str` operator.
     #
-    # @example
+    # [121] BuiltInCall ::= ... | 'STR' '(' 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 ( str(?v) = "1" ) .
+    #       }
+    #
+    # @example SSE
     #   (prefix ((xsd: <http://www.w3.org/2001/XMLSchema#>)
     #            (: <http://example.org/things#>))
     #     (project (?x ?v)
@@ -30,6 +41,15 @@ module SPARQL; module Algebra
           else raise TypeError, "expected an RDF::Literal or RDF::URI, but got #{term.inspect}"
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "str(" + operands.first.to_sparql(**options) + ")"
+      end
     end # Str
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,8 +3,22 @@ module SPARQL; module Algebra
     ##
     # A SPARQL `strafter` operator.
     #
-    # @example
-    #   (strafter ?x ?y)
+    # [121] BuiltInCall ::= ... | 'STRAFTER' '(' Expression ',' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
+    #   SELECT ?s (STRAFTER(?str,"e") AS ?suffix) WHERE {
+    #     ?s :str ?str
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.org/>)
+    #     (xsd: <http://www.w3.org/2001/XMLSchema#>))
+    #    (project (?s ?suffix)
+    #     (extend ((?suffix (strafter ?str "e")))
+    #      (bgp (triple ?s :str ?str)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-strafter
     # @see https://www.w3.org/TR/xpath-functions/#func-substring-after
@@ -52,6 +66,15 @@ module SPARQL; module Algebra
           RDF::Literal(parts.last, datatype: left.datatype, language: left.language)
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "STRAFTER(" + operands.to_sparql(delimiter: ', ', **options) + ")"
+      end
     end # StrAfter
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,8 +3,22 @@ module SPARQL; module Algebra
     ##
     # A SPARQL `strbefore` operator.
     #
-    # @example
-    #   (strbefore ?x ?y)
+    # [121] BuiltInCall ::= ... | 'STRBEFORE' '(' Expression ',' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
+    #   SELECT ?s (STRBEFORE(?str,"s") AS ?prefix) WHERE {
+    #     ?s :str ?str
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.org/>)
+    #     (xsd: <http://www.w3.org/2001/XMLSchema#>))
+    #    (project (?s ?prefix)
+    #     (extend ((?prefix (strbefore ?str "s")))
+    #      (bgp (triple ?s :str ?str)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-strbefore
     # @see https://www.w3.org/TR/xpath-functions/#func-substring-before
@@ -54,6 +68,15 @@ module SPARQL; module Algebra
           RDF::Literal(parts.first, language: left.language, datatype: left.datatype)
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "STRBEFORE(" + operands.to_sparql(delimiter: ', ', **options) + ")"
+      end
     end # StrBefore
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,7 +3,19 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `strdt` operator.
     #
-    # @example
+    # [121] BuiltInCall ::= ... | 'STRDT' '(' Expression ',' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
+    #   SELECT ?s (STRDT(?str,xsd:string) AS ?str1) WHERE {
+    #     ?s :str ?str
+    #     FILTER(LANGMATCHES(LANG(?str), "en"))
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.org/>) (xsd: <http://www.w3.org/2001/XMLSchema#>))
     #     (project (?s ?str1)
     #       (extend ((?str1 (strdt ?str xsd:string)))
     #         (filter (langMatches (lang ?str) "en")
@@ -28,6 +40,15 @@ module SPARQL; module Algebra
         raise TypeError, "Literal #{value.inspect} is not simple" unless value.simple?
         RDF::Literal.new(value.to_s, datatype: datatypeIRI)
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "STRDT(" + operands.to_sparql(delimiter: ', ', **options) + ")"
+      end
     end # StrDT
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -1,10 +1,23 @@
 module SPARQL; module Algebra
   class Operator
     ##
-    # A SPARQL `contains` operator.
+    # A SPARQL `strends` operator.
     #
-    # @example
-    #   (strends ?x ?y)
+    # [121] BuiltInCall ::= ... | 'STRENDS' '(' Expression ',' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   SELECT ?s ?str WHERE {
+    #     ?s :str ?str
+    #     FILTER STRENDS(?str, "a")
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.org/>))
+    #    (project (?s ?str)
+    #     (filter (strends ?str "a")
+    #      (bgp (triple ?s :str ?str)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-strends
     # @see https://wwww.w3.org/TR/xpath-functions/#func-ends-with
@@ -41,6 +54,15 @@ module SPARQL; module Algebra
         else RDF::Literal::FALSE
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "STRENDS(" + operands.to_sparql(delimiter: ', ', **options) + ")"
+      end
     end # StrEnds
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,12 +3,21 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `strlang` operator.
     #
-    # @example
-    #     (prefix ((: <http://example.org/>))
-    #       (project (?s ?s2)
-    #         (extend ((?s2 (strlang ?str "en-US")))
-    #           (filter (langMatches (lang ?str) "en")
-    #             (bgp (triple ?s :str ?str))))))
+    # [121] BuiltInCall ::= ... | 'STRLANG' '(' Expression ',' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   SELECT ?s (STRLANG(?str,"en-US") AS ?s2) WHERE {
+    #     ?s :str ?str
+    #     FILTER(LANGMATCHES(LANG(?str), "en"))
+    #   }
+    #
+    # @example SSE
+    #   (prefix ((: <http://example.org/>))
+    #     (project (?s ?s2)
+    #       (extend ((?s2 (strlang ?str "en-US")))
+    #         (filter (langMatches (lang ?str) "en")
+    #           (bgp (triple ?s :str ?str))))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-strlang
     class StrLang < Operator::Binary
@@ -29,6 +38,15 @@ module SPARQL; module Algebra
         raise TypeError, "Literal #{value.inspect} is not simple" unless value.simple?
         RDF::Literal.new(value.to_s, language: langTag.to_s)
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "STRLANG(" + operands.to_sparql(delimiter: ', ', **options) + ")"
+      end
     end # StrLang
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,8 +3,20 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `strlen` operator.
     #
-    # @example
-    #   (strlen ?x)
+    # [121] BuiltInCall ::= ... 'STRLEN' '(' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   SELECT ?str (STRLEN(?str) AS ?len) WHERE {
+    #     ?s :str ?str
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.org/>))
+    #    (project (?str ?len)
+    #     (extend ((?len (strlen ?str)))
+    #      (bgp (triple ?s :str ?str)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-strlen
     # @see https://www.w3.org/TR/xpath-functions/#func-string-length
@@ -29,6 +41,15 @@ module SPARQL; module Algebra
         raise TypeError, "expected a plain RDF::Literal, but got #{operand.inspect}" unless operand.literal? && operand.plain?
         RDF::Literal(operand.to_s.length)
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "STRLEN(" + operands.to_sparql(delimiter: ', ', **options) + ")"
+      end
     end # StrLen
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,8 +3,22 @@ module SPARQL; module Algebra
     ##
     # A SPARQL `strstarts` operator.
     #
-    # @example
-    #   (strstarts ?x ?y)
+    # [121] BuiltInCall ::= ... | 'STRSTARTS' '(' Expression ',' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+
+    #   SELECT ?s ?str WHERE {
+    #     ?s :str ?str
+    #     FILTER STRSTARTS(?str, "a")
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.org/>))
+    #    (project (?s ?str)
+    #     (filter (strstarts ?str "a")
+    #      (bgp (triple ?s :str ?str)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-strstarts
     # @see https://www.w3.org/TR/xpath-functions/#func-starts-with
@@ -41,6 +55,15 @@ module SPARQL; module Algebra
         else RDF::Literal::FALSE
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "STRSTARTS(" + operands.to_sparql(delimiter: ', ', **options) + ")"
+      end
     end # StrStarts
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,16 +3,27 @@ require 'securerandom'
 module SPARQL; module Algebra
   class Operator
     ##
-    # The SPARQL `uuid` function.
+    # [121] BuiltInCall ::= ... | 'STRUUID' NIL 
     #
-    # @example
-    #     (prefix ((: <http://example.org/>)
-    #              (xsd: <http://www.w3.org/2001/XMLSchema#>))
-    #       (project (?length)
-    #         (extend ((?length (strlen ?uuid)))
-    #           (filter (&& (isLiteral ?uuid) (regex ?uuid "^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$" "i"))
-    #             (extend ((?uuid (struuid)))
-    #               (bgp))))))
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
+    #   SELECT (STRLEN(?uuid) AS ?length)
+    #   WHERE {
+    #     BIND(STRUUID() AS ?uuid)
+    #     FILTER(ISLITERAL(?uuid) && REGEX(?uuid, "^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$", "i"))
+    #   }
+    #
+    # @example SSE
+    #   (prefix ((: <http://example.org/>) (xsd: <http://www.w3.org/2001/XMLSchema#>))
+    #    (project (?length)
+    #     (extend ((?length (strlen ?uuid)))
+    #      (filter
+    #       (&&
+    #        (isLiteral ?uuid)
+    #        (regex ?uuid "^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$" "i"))
+    #       (extend ((?uuid (struuid)))
+    #        (bgp))))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-struuid
     class StrUUID < Operator::Nullary
@@ -27,6 +38,15 @@ module SPARQL; module Algebra
       def apply(**options)
         RDF::Literal(SecureRandom.uuid)
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "STRUUID(" + operands.to_sparql(delimiter: ', ', **options) + ")"
+      end
     end # StrUUID
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -7,6 +7,29 @@ module SPARQL; module Algebra
     #
     # If triple is an RDF-star triple, the function returns the subject of this triple. Passing anything other than an RDF-star triple is an error.
     #
+    # [121] BuiltInCall ::= ... | 'SUBJECT' '(' 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#subject
     class Subject < Operator::Unary
       include Evaluatable
@@ -24,6 +47,15 @@ module SPARQL; module Algebra
         raise TypeError, "expected an RDF::Statement, but got #{operand.inspect}" unless operand.is_a?(RDF::Statement)
         operand.subject
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "SUBJECT(" + operands.last.to_sparql(**options) + ")"
+      end
     end # Subject
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,8 +3,20 @@ module SPARQL; module Algebra
     ##
     # A SPARQL `substr` operator.
     #
-    # @example
-    #   (substr ?x ?y)
+    # [123] SubstringExpression ::= 'SUBSTR' '(' Expression ',' Expression ( ',' Expression )? ')'
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   SELECT ?s ?str (SUBSTR(?str,1,1) AS ?substr)
+    #   WHERE {
+    #     ?s :str ?str
+    #   }
+    #
+    # @example SSE
+    #   (prefix ((: <http://example.org/>))
+    #    (project (?s ?str ?substr)
+    #     (extend ((?substr (substr ?str 1 1)))
+    #      (bgp (triple ?s :str ?str)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-substr
     # @see https://www.w3.org/TR/xpath-functions/#func-substring
@@ -75,6 +87,15 @@ module SPARQL; module Algebra
       def to_sxp_bin
         [NAME] + operands.reject {|o| o.to_s == ""}
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "SUBSTR(" + operands.to_sparql(delimiter: ', ', **options) + ")"
+      end
     end # SubStr
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -2,8 +2,25 @@ module SPARQL; module Algebra
   class Operator
     ##
     # The SPARQL numeric `subtract` operator.
-    #   (- ?x ?y)
-    #   (subtract ?x ?y)
+    #
+    # [116] AdditiveExpression ::=	MultiplicativeExpression ( '-' MultiplicativeExpression )?
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   SELECT ?s WHERE {
+    #     ?s :p ?o .
+    #     ?s2 :p ?o2 .
+    #     FILTER(?o - ?o2 = 3) .
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.org/>))
+    #    (project (?s)
+    #     (filter (= (- ?o ?o2) 3)
+    #      (bgp
+    #       (triple ?s :p ?o)
+    #       (triple ?s2 :p ?o2)))))
     #
     # @see https://www.w3.org/TR/xpath-functions/#func-numeric-subtract
     class Subtract < Operator::Binary
@@ -14,19 +31,32 @@ module SPARQL; module Algebra
       ##
       # Returns the arithmetic difference of the operands.
       #
-      # @param  [RDF::Literal::Numeric] left
+      # @param  [RDF::Literal::Numeric, RDF::Literal::Temporal] left
       #   a numeric literal
-      # @param  [RDF::Literal::Numeric] right
+      # @param  [RDF::Literal::Numeric, RDF::Literal::Temporal, RDF::Literal::Duration] right
       #   a numeric literal
-      # @return [RDF::Literal::Numeric]
-      # @raise  [TypeError] if either operand is not a numeric literal
+      # @return [RDF::Literal::Numeric, RDF::Literal::Temporal, RDF::Literal::Duration]
+      # @raise  [TypeError] if either operand is neither a numeric nor a temporal literal
       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}"
+          when left.is_a?(RDF::Literal::Temporal) && right.is_a?(RDF::Literal::Temporal)
+            left - right
+          when left.is_a?(RDF::Literal::Temporal) && right.is_a?(RDF::Literal::Duration)
+            left - right
+          else raise TypeError, "expected two RDF::Literal::Numeric, Temporal operands, or a Temporal and a Duration, 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 # Subtract
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,12 +3,19 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `sum` set function.
     #
-    # @example
-    #    (prefix ((: <http://www.example.org/>))
-    #      (project (?sum)
-    #        (extend ((?sum ??.0))
-    #          (group () ((??.0 (sum ?o)))
-    #            (bgp (triple ?s :dec ?o))))))
+    # [127] Aggregate::= ... | 'SUM' '(' 'DISTINCT'? Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://www.example.org/>
+    #   SELECT (SUM(?o) AS ?sum)
+    #   WHERE { ?s :dec ?o }
+    #
+    # @example SSE
+    #   (prefix ((: <http://www.example.org/>))
+    #     (project (?sum)
+    #       (extend ((?sum ??.0))
+    #         (group () ((??.0 (sum ?o)))
+    #           (bgp (triple ?s :dec ?o))))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#defn_aggSum
     class Sum < Operator
@@ -33,6 +40,17 @@ module SPARQL; module Algebra
           raise TypeError, "Averaging non-numeric types: #{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
+        "SUM(#{'DISTINCT ' if distinct}#{args.to_sparql(**options)})"
+      end
     end # Sum
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -6,13 +6,59 @@ module SPARQL; module Algebra
     # This is used to provide inline values. Each row becomes
     # a solution.
     #
-    # @example
-    #    (table (vars ?book ?title)
-    #      (row (?title "SPARQL Tutorial"))
-    #      (row (?book :book2)))
+    # [28]  ValuesClause            ::= ( 'VALUES' DataBlock )?
+    #
+    # @example SPARQL Grammar (ValuesClause)
+    #   PREFIX dc:   <http://purl.org/dc/elements/1.1/> 
+    #   PREFIX :     <http://example.org/book/> 
+    #   PREFIX ns:   <http://example.org/ns#> 
+    #   SELECT ?book ?title ?price {
+    #      ?book dc:title ?title ;
+    #            ns:price ?price .
+    #   }
+    #   VALUES ?book { :book1 }
+    #
+    # @example SSE (ValuesClause)
+    #   (prefix ((dc: <http://purl.org/dc/elements/1.1/>)
+    #            (: <http://example.org/book/>)
+    #            (ns: <http://example.org/ns#>))
+    #    (project (?book ?title ?price)
+    #     (join
+    #      (bgp (triple ?book dc:title ?title) (triple ?book ns:price ?price))
+    #      (table (vars ?book) (row (?book :book1)))) ))
+    #
+    # @example SPARQL Grammar (empty query no values)
+    #    SELECT * { } VALUES () { }
+    #
+    # @example SSE (empty query no values)
+    #    (join (bgp) (table empty))
+    #
+    # [61]  InlineData              ::= 'VALUES' DataBlock
+    #
+    # @example SPARQL Grammar (InlineData)
+    #   PREFIX dc:   <http://purl.org/dc/elements/1.1/> 
+    #   PREFIX :     <http://example.org/book/> 
+    #   PREFIX ns:   <http://example.org/ns#> 
+    #   
+    #   SELECT ?book ?title ?price
+    #   {
+    #      VALUES ?book { :book1 }
+    #      ?book dc:title ?title ;
+    #            ns:price ?price .
+    #   }
+    #
+    # @example SSE (InlineData)
+    #   (prefix ((dc: <http://purl.org/dc/elements/1.1/>)
+    #            (: <http://example.org/book/>)
+    #            (ns: <http://example.org/ns#>))
+    #    (project (?book ?title ?price)
+    #     (join
+    #      (table (vars ?book) (row (?book :book1)))
+    #      (bgp (triple ?book dc:title ?title) (triple ?book ns:price ?price))) ))
     #
     # @example empty table
     #     (table unit)
+    #
     # @see https://www.w3.org/TR/2013/REC-sparql11-query-20130321/#inline-data
     class Table < Operator
       include Query
@@ -43,9 +89,44 @@ module SPARQL; module Algebra
           end
           @solutions << RDF::Query::Solution.new(bindings)
         end
+        @solutions.variable_names = self.variables.keys
         @solutions.each(&block) if block_given?
         @solutions
       end
+    
+      ##
+      # In-scope variables for a table are the variables operand
+      #
+      # @return [Hash{Symbol => RDF::Query::Variable}]
+      def variables
+        in_scope = operands.first.is_a?(Array) ? operands.first[1..-1] : []
+        in_scope.inject({}) {|memo, v| memo.merge(v.variables)}
+      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 = "VALUES (#{Array(operands.first)[1..-1].map { |e| e.to_sparql(**options) }.join(' ')}) {\n"
+        operands[1..-1].each do |row|
+          line = '('
+          row[1..-1].each do |col|
+            v = col[1].to_sparql(**options)
+            line << v + ' '
+          end
+          line = line.chomp(' ')
+          line << ")\n"
+
+          str << line
+        end
+
+        str << "}\n"
+        top_level ? Operator.to_sparql(str, **options) : str
+      end
     end # Table
   end # Operator
 end; end # SPARQL::Algebra