sparql 1.0.8 → 1.1.0p0

data/lib/sparql/grammar/parser11.rb

@@ -180,7 +180,7 @@ module SPARQL::Grammar
          |MAX|MD5|MINUTES|MIN|MONTH|NOW|RAND|REPLACE|ROUND|SAMPLE|SECONDS|SEPARATOR
          |SHA1|SHA224|SHA256|SHA384|SHA512
          |STRAFTER|STRBEFORE|STRDT|STRENDS|STRLANG|STRLEN|STRSTARTS|STRUUID|SUBSTR|STR|SUM
-         |TIMEZONE|TZ|UCASE|URI|UUID|YEAR
+         |TIMEZONE|TZ|UCASE|UNDEF|URI|UUID|YEAR
          |isBLANK|isIRI|isURI|isLITERAL|isNUMERIC|sameTerm
         }x
         add_prod_datum(token.value.downcase.to_sym, token.value.downcase.to_sym)
@@ -191,19 +191,24 @@ module SPARQL::Grammar
 
     # Productions
     # [2]  	Query	  ::=  	Prologue
-    #                     ( SelectQuery | ConstructQuery | DescribeQuery | AskQuery ) ValuesClause
+    #                     ( SelectQuery | ConstructQuery | DescribeQuery | AskQuery )
     production(:Query) do |input, data, callback|
-      if data[:query]
-        query = data[:query].first
-        if data[:PrefixDecl]
-          pfx = data[:PrefixDecl].shift
-          data[:PrefixDecl].each {|p| pfx.merge!(p)}
-          pfx.operands[1] = query
-          query = pfx
-        end
-        query = SPARQL::Algebra::Expression[:base, data[:BaseDecl].first, query] if data[:BaseDecl]
-        add_prod_datum(:query, query)
+      return unless data[:query]
+
+      query = data[:query].first
+
+      # Add prefix
+      if data[:PrefixDecl]
+        pfx = data[:PrefixDecl].shift
+        data[:PrefixDecl].each {|p| pfx.merge!(p)}
+        pfx.operands[1] = query
+        query = pfx
       end
+
+      # Add base
+      query = SPARQL::Algebra::Expression[:base, data[:BaseDecl].first, query] if data[:BaseDecl]
+
+      add_prod_datum(:query, query)
     end
 
     # [4]  	Prologue	  ::=  	( BaseDecl | PrefixDecl )*
@@ -233,13 +238,17 @@ module SPARQL::Grammar
       end
     end
 
-    # [7]  	SelectQuery	  ::=  	SelectClause DatasetClause* WhereClause SolutionModifier
+    # [7]  	SelectQuery	  ::=  	SelectClause DatasetClause* WhereClause SolutionModifier ValuesClause
     production(:SelectQuery) do |input, data, callback|
       query = merge_modifiers(data)
       add_prod_datum :query, query
     end
 
     # [8]  	SubSelect	  ::=  	SelectClause WhereClause SolutionModifier
+    production(:SubSelect) do |input, data, callback|
+      query = merge_modifiers(data)
+      add_prod_datum :query, query
+    end
 
     # [9]  	SelectClause	  ::=  	'SELECT' ( 'DISTINCT' | 'REDUCED' )? ( ( Var | ( '(' Expression 'AS' Var ')' ) )+ | '*' )
 
@@ -256,6 +265,7 @@ module SPARQL::Grammar
     #                            'WHERE' '{' TriplesTemplate? '}'
     #                            SolutionModifier
     #                          )
+    #                          ValuesClause
     production(:ConstructQuery) do |input, data, callback|
       data[:query] ||= [SPARQL::Algebra::Operator::BGP.new(*data[:pattern])]
       query = merge_modifiers(data)
@@ -264,14 +274,14 @@ module SPARQL::Grammar
     end
 
     # [11]  	DescribeQuery	  ::=  	'DESCRIBE' ( VarOrIri+ | '*' )
-    #                             DatasetClause* WhereClause? SolutionModifier
+    #                             DatasetClause* WhereClause? SolutionModifier ValuesClause
     production(:DescribeQuery) do |input, data, callback|
       query = merge_modifiers(data)
       to_describe = data[:VarOrIri] || []
       add_prod_datum :query, SPARQL::Algebra::Expression[:describe, to_describe, query]
     end
 
-    # [12]  	AskQuery	  ::=  	'ASK' DatasetClause* WhereClause
+    # [12]  	AskQuery	  ::=  	'ASK' DatasetClause* WhereClause ValuesClause
     production(:AskQuery) do |input, data, callback|
       query = merge_modifiers(data)
       add_prod_datum :query, SPARQL::Algebra::Expression[:ask, query]
@@ -311,8 +321,9 @@ module SPARQL::Grammar
     end
 
     # [21]  	HavingClause	  ::=  	'HAVING' HavingCondition+
-    #production(:GroupClause) do |input, data, callback|
-    #end
+    production(:HavingClause) do |input, data, callback|
+      add_prod_datum(:having, data[:Constraint])
+    end
 
     # [23]  	OrderClause	  ::=  	'ORDER' 'BY' OrderCondition+
     production(:OrderClause) do |input, data, callback|
@@ -353,6 +364,19 @@ module SPARQL::Grammar
       add_prod_datum(:offset, data[:literal])
     end
 
+    # [28]  ValuesClause	          ::= ( 'VALUES' DataBlock )?
+    production(:ValuesClause) do |input, data, callback|
+      debug("ValuesClause") {"vars: #{data[:Var].inspect}, row: #{data[:row].inspect}"}
+      if data[:row]
+        add_prod_datum :ValuesClause, SPARQL::Algebra::Expression.for(:table,
+          data[:Var].to_a.unshift(:vars),
+          *data[:row]
+        )
+      else
+        add_prod_datum :ValuesClause, SPARQL::Algebra::Expression.for(:table, :empty)
+      end
+    end
+
     # [54]  	GroupGraphPatternSub	  ::=  	TriplesBlock?
     #                                             ( GraphPatternNotTriples '.'? TriplesBlock? )*
     production(:GroupGraphPatternSub) do |input, data, callback|
@@ -411,6 +435,8 @@ module SPARQL::Grammar
         add_prod_datum(:query, SPARQL::Algebra::Expression.for(:leftjoin, lhs, *data[:leftjoin]))
       elsif data[:query] && !lhs.empty?
         add_prod_datum(:query, SPARQL::Algebra::Expression.for(:join, lhs, *data[:query]))
+      elsif data[:minus]
+        add_prod_datum(:query, SPARQL::Algebra::Expression.for(:minus, lhs, *data[:minus]))
       elsif data[:query]
         add_prod_datum(:query, data[:query])
       else
@@ -447,6 +473,60 @@ module SPARQL::Grammar
       add_prod_datum :extend, [data[:Expression].unshift(data[:Var].first)]
     end
 
+    # [61]  InlineData	            ::= 'VALUES' DataBlock
+    production(:InlineData) do |input, data, callback|
+      debug("InlineData") {"vars: #{data[:Var].inspect}, row: #{data[:row].inspect}"}
+      add_prod_datum :query, SPARQL::Algebra::Expression.for(:table,
+        data[:Var].unshift(:vars),
+        *data[:row]
+      )
+    end
+
+    # [63]  InlineDataOneVar	      ::= Var '{' DataBlockValue* '}'
+    production(:InlineDataOneVar) do |input, data, callback|
+      add_prod_datum :Var, data[:Var]
+
+      data[:DataBlockValue].each do |d|
+        add_prod_datum :row, [[:row, data[:Var].dup << d]]
+      end
+    end
+
+    # [64]  InlineDataFull	        ::= ( NIL | '(' Var* ')' )
+    #                                '{' ( '(' DataBlockValue* ')' | NIL )* '}'
+    production(:InlineDataFull) do |input, data, callback|
+      vars = data[:Var]
+      add_prod_datum :Var, vars
+
+      if data[:NIL].to_a.length > 1
+        add_prod_data :row, [:row]
+      else
+        data[:DataBlockValue].to_a.each do |ds|
+          r = [:row]
+          ds.each_with_index do |d, i|
+            r << [vars[i], d] if d
+          end
+          add_prod_data :row, r unless r.empty?
+        end
+      end
+    end
+
+    # _InlineDataFull_8	        ::=  '(' DataBlockValue* ')'
+    production(:_InlineDataFull_8) do |input, data, callback|
+      add_prod_data :DataBlockValue, data[:DataBlockValue].map {|v| v unless v == :undef}
+    end
+
+    # [65]  DataBlockValue	        ::= iri | RDFLiteral | NumericLiteral | BooleanLiteral | 'UNDEF'
+    production(:DataBlockValue) do |input, data, callback|
+      add_prod_datum :DataBlockValue, data.values.first
+    end
+
+    # [66]  MinusGraphPattern       ::= 'MINUS' GroupGraphPattern
+    production(:MinusGraphPattern) do |input, data, callback|
+      expr = nil
+      query = data[:query] ? data[:query].first : SPARQL::Algebra::Operator::BGP.new
+      add_prod_data(:minus, query)
+    end
+
     # [67]  	GroupOrUnionGraphPattern	  ::=  	GroupGraphPattern
     #                                           ( 'UNION' GroupGraphPattern )*
     production(:GroupOrUnionGraphPattern) do |input, data, callback|
@@ -665,10 +745,10 @@ module SPARQL::Grammar
       if data[:_Compare_Numeric]
         add_prod_datum(:Expression, SPARQL::Algebra::Expression.for(data[:_Compare_Numeric].insert(1, *data[:Expression])))
       elsif data[:in]
-        expr = (data[:Expression] + data[:in]).reject {|v| v == RDF.nil}
+        expr = (data[:Expression] + data[:in]).reject {|v| v.equal?(RDF.nil)}
         add_prod_datum(:Expression, SPARQL::Algebra::Expression.for(expr.unshift(:in)))
       elsif data[:notin]
-        expr = (data[:Expression] + data[:notin]).reject {|v| v == RDF.nil}
+        expr = (data[:Expression] + data[:notin]).reject {|v| v.equal?(RDF.nil)}
         add_prod_datum(:Expression, SPARQL::Algebra::Expression.for(expr.unshift(:notin)))
       else
         # NumericExpression with no comparitor
@@ -753,7 +833,7 @@ module SPARQL::Grammar
         if e.is_a?(RDF::Literal::Numeric)
           add_prod_datum(:Expression, -e) # Simple optimization to match ARQ generation
         else
-          add_prod_datum(:Expression, SPARQL::Algebra::Expression[:minus, e])
+          add_prod_datum(:Expression, SPARQL::Algebra::Expression[:"-", e])
         end
       else
         add_prod_datum(:Expression, data[:Expression])
@@ -898,7 +978,7 @@ module SPARQL::Grammar
     production(:Aggregate) do |input, data, callback|
       if aggregate_rule = data.keys.detect {|k| AGGREGATE_RULES.include?(k)}
         parts = [aggregate_rule]
-        parts << [:separator, data[:string].first] if data[:separator] && data[:string]
+        parts << [:separator, RDF::Literal(data[:string].first)] if data[:separator] && data[:string]
         parts << :distinct if data[:DISTINCT_REDUCED]
         parts << data[:Expression].first if data[:Expression]
         add_prod_data(aggregate_rule, SPARQL::Algebra::Expression.for(parts))
@@ -1038,7 +1118,7 @@ module SPARQL::Grammar
     # @param [Symbol, #to_s] prod The starting production for the parser.
     #   It may be a URI from the grammar, or a symbol representing the local_name portion of the grammar URI.
     # @return [Array]
-    # @see http://www.w3.org/2001/sw/DataAccess/rq23/rq24-algebra.html
+    # @see http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
     # @see http://axel.deri.ie/sparqltutorial/ESWC2007_SPARQL_Tutorial_unit2b.pdf
     def parse(prod = START)
       ll1_parse(@input, prod.to_sym, @options.merge(:branch => BRANCH,
@@ -1048,7 +1128,7 @@ module SPARQL::Grammar
         case context
         when :trace
           level, lineno, depth, *args = data
-          message = "#{args.join(': ')}"
+          message = args.to_sse
           d_str = depth > 100 ? ' ' * 100 + '+' : ' ' * depth
           str = "[#{lineno}](#{level})#{d_str}#{message}"
           case @options[:debug]
@@ -1314,27 +1394,93 @@ module SPARQL::Grammar
     #
     # @see http://www.w3.org/TR/sparql11-query/#convertGroupAggSelectExpressions
     def merge_modifiers(data)
+      debug("merge modifiers") {data.inspect}
       query = data[:query] ? data[:query].first : SPARQL::Algebra::Operator::BGP.new
 
       vars = data[:Var] || []
       order = data[:order] ? data[:order].first : []
+      extensions = data.fetch(:extend, [])
+      having = data.fetch(:having, [])
+      values = data.fetch(:ValuesClause, []).first
+
+      # extension variables must not appear in projected variables.
+      # Add them to the projection otherwise
+      extensions.each do |(var, expr)|
+        raise Error, "Extension variable #{var} also in SELECT" if vars.map(&:to_s).include?(var.to_s)
+        vars << var
+      end
+
+      # If any extension contains an aggregate, and there is now group, implicitly group by 1
+      if !data[:group] &&
+         extensions.any? {|(var, function)| function.aggregate?} ||
+         having.any? {|c| c.aggregate? }
+        debug {"Implicit group"}
+        data[:group] = [[]]
+      end
 
       # Add datasets and modifiers in order
       if data[:group]
-        query = SPARQL::Algebra::Expression[:group, data[:group].first, query]
-      end
+        group_vars = data[:group].first
+
+        # For creating temporary variables
+        agg = 0
+
+        # Find aggregated varirables in extensions
+        aggregates = []
+        aggregated_vars = extensions.map do |(var, function)|
+          var if function.aggregate?
+        end.compact
+
+        # Common function for replacing aggregates with temporary variables,
+        # as defined in http://www.w3.org/TR/2013/REC-sparql11-query-20130321/#convertGroupAggSelectExpressions
+        aggregate_expression = lambda do |expr|
+          # Replace unaggregated variables in expr
+          # - For each unaggregated variable V in X
+          expr.replace_vars! do |v|
+            aggregated_vars.include?(v) ? v : SPARQL::Algebra::Expression[:sample, v]
+          end
+
+          # Replace aggregates in expr as above
+          expr.replace_aggregate! do |function|
+            if avf = aggregates.detect {|(v, f)| f == function}
+              avf.first
+            else
+              # Allocate a temporary variable for this function, and retain the mapping for outside the group
+              av = RDF::Query::Variable.new(".#{agg}")
+              av.distinguished = false
+              agg += 1
+              aggregates << [av, function]
+              av
+            end
+          end
+        end
+
+        # If there are extensions, they are aggregated if necessary and bound
+        # to temporary variables
+        extensions.map! do |(var, expr)|
+          [var, aggregate_expression.call(expr)]
+        end
 
-      if data[:extend] # FIXME: needed?
-        # extension variables must not appear in projected variables.
-        # Add them to the projection otherwise
-        data[:extend].each do |(var, expr)|
-          raise Error, "Extension variable #{var} also in SELECT" if vars.map(&:to_s).include?(var.to_s)
-          vars << var
+        # Having clauses
+        having.map! do |expr|
+          aggregate_expression.call(expr)
         end
 
-        query = SPARQL::Algebra::Expression[:extend, data[:extend], query]
+        query = if aggregates.empty?
+          SPARQL::Algebra::Expression[:group, group_vars, query]
+        else
+          SPARQL::Algebra::Expression[:group, group_vars, aggregates, query]
+        end
+      end
+
+      if values
+        query = query ? SPARQL::Algebra::Expression[:join, query, values] : values
       end
 
+      query = SPARQL::Algebra::Expression[:extend, extensions, query] unless extensions.empty?
+
+      query = SPARQL::Algebra::Expression[:filter, *having, query] unless having.empty?
+
       query = SPARQL::Algebra::Expression[:order, data[:order].first, query] unless order.empty?
 
       query = SPARQL::Algebra::Expression[:project, vars, query] unless vars.empty?

data/lib/sparql/grammar/terminals11.rb

@@ -105,7 +105,7 @@ module SPARQL::Grammar
                  |SELECT|SEPARATOR|SERVICE
                  |SHA1|SHA224|SHA256|SHA384|SHA512
                  |STRAFTER|STRBEFORE|STRDT|STRENDS|STRLANG|STRLEN|STRSTARTS|STRUUID|SUBSTR|STR|SUM
-                 |TIMEZONE|TO|TZ|UCASE|UNDEF|UNION|URI|USING|UUID
+                 |TIMEZONE|TO|TZ|UCASE|UNDEF|UNION|URI|USING|UUID|VALUES
                  |WHERE|WITH|YEAR
                  |isBLANK|isIRI|isURI|isLITERAL|isNUMERIC|sameTerm
                  |true
@@ -129,7 +129,7 @@ module SPARQL::Grammar
       SHA1 SHA224 SHA256 SHA384 SHA512
       STRAFTER STRBEFORE STRDT STRENDS STRLANG STRLEN STRSTARTS STRUUID SUBSTR STR SUM
       TIMEZONE TO TZ UCASE UNDEF UNION URI USING UUID
-      WHERE WITH YEAR
+      VALUES WHERE WITH YEAR
       isBLANK isIRI isURI isLITERAL isNUMERIC sameTerm
       true false
     } + [

data/lib/sparql/grammar.rb

@@ -205,7 +205,5 @@ module SPARQL
     def self.tokenize(query, options = {}, &block)
       Lexer.tokenize(query, options, &block)
     end
-    
-    class SPARQL_GRAMMAR < RDF::Vocabulary("http://www.w3.org/2000/10/swap/grammar/sparql#"); end
   end # Grammar
 end # SPARQL

data/lib/sparql/results.rb

@@ -7,6 +7,8 @@ module SPARQL
       :json => 'application/sparql-results+json',
       :html => 'text/html',
       :xml  => 'application/sparql-results+xml',
+      :csv => 'text/csv',
+      :tsv => 'text/tab-separated-values'
     }
     
     ##
@@ -112,6 +114,57 @@ module SPARQL
         end
       end
     end
+
+    ##
+    # Generate Solutions as CSV
+    # @return [String]
+    # @see http://www.w3.org/TR/rdf-sparql-json-res/#results
+    def to_csv
+      require 'csv' unless defined?(::CSV)
+      bnode_map = {}
+      bnode_gen = "_:a"
+      CSV.generate(:row_sep => "\r\n") do |csv|
+        csv << variable_names.to_a
+        self.each do |solution|
+          csv << variable_names.map do |n|
+            case term = solution[n]
+            when RDF::Node then bnode_map[term] ||=
+              begin
+                this = bnode_gen
+                bnode_gen = bnode_gen.succ
+                this
+              end
+            else
+              solution[n].to_s
+            end
+          end
+        end
+      end
+    end
+    ##
+    # Generate Solutions as TSV
+    # @return [String]
+    # @see http://www.w3.org/TR/rdf-sparql-json-res/#results
+    def to_tsv
+      require 'csv' unless defined?(::CSV)
+      bnode_map = {}
+      bnode_gen = "_:a"
+      results = [
+        variable_names.map {|v| "?#{v}"}.join("\t")
+      ] + self.map do |solution|
+        variable_names.map do |n|
+          case term = solution[n]
+          when RDF::Literal::Integer, RDF::Literal::Decimal, RDF::Literal::Double
+            term.canonicalize.to_s
+          when nil
+            ""
+          else
+            RDF::NTriples.serialize(term)
+          end
+        end.join("\t")
+      end
+      results.join("\n") + "\n"
+    end
   end
   
   ##
@@ -189,6 +242,8 @@ module SPARQL
       when :json  then solutions.to_json
       when :xml   then solutions.to_xml
       when :html  then solutions.to_html
+      when :csv   then solutions.to_csv
+      when :tsv   then solutions.to_tsv
       else
         raise RDF::WriterError, "Unknown format #{(format || content_type).inspect} for #{solutions.class}"
       end