Class: SPARQL::Algebra::Operator::Order

Inherits:
Binary show all
Includes:
Query
Defined in:
lib/sparql/algebra/operator/order.rb

Overview

The SPARQL GraphPattern order operator.

[23] OrderClause ::= ‘ORDER’ ‘BY’ OrderCondition+

Examples:

SPARQL Grammar

PREFIX foaf:    <http://xmlns.com/foaf/0.1/>
SELECT ?name
WHERE { ?x foaf:name ?name }
ORDER BY ASC(?name)

SSE

(prefix ((foaf: <http://xmlns.com/foaf/0.1/>))
  (project (?name)
    (order ((asc ?name))
      (bgp (triple ?x foaf:name ?name)))))

SPARQL Grammar (with builtin)

PREFIX : <http://example.org/>
SELECT ?s WHERE {
  ?s :p ?o .
}
ORDER BY str(?o)

SSE (with builtin)

(prefix ((: <http://example.org/>))
 (project (?s)
  (order ((str ?o))
   (bgp (triple ?s :p ?o)))))

SPARQL Grammar (with bracketed expression)

PREFIX : <http://example.org/>
SELECT ?s WHERE {
  ?s :p ?o1 ; :q ?o2 .
} ORDER BY (?o1 + ?o2)

SSE (with bracketed expression)

(prefix
 ((: <http://example.org/>))
 (project (?s)
  (order ((+ ?o1 ?o2))
   (bgp
    (triple ?s :p ?o1)
    (triple ?s :q ?o2)))))

SPARQL Grammar (with function call)

PREFIX :      <http://example.org/ns#>
PREFIX xsd:   <http://www.w3.org/2001/XMLSchema#>
SELECT *
{ ?s ?p ?o }
ORDER BY 
  DESC(?o+57) xsd:string(?o) ASC(?s)

SSE (with function call)

(prefix ((: <http://example.org/ns#>)
         (xsd: <http://www.w3.org/2001/XMLSchema#>))
 (order ((desc (+ ?o 57))
         (xsd:string ?o)
         (asc ?s))
  (bgp (triple ?s ?p ?o))))

See Also:

Constant Summary collapse

NAME = 
[:order]

Constants inherited from Binary

Binary::ARITY

Constants inherited from SPARQL::Algebra::Operator

ARITY, IsURI, URI

Constants included from Expression

Expression::PATTERN_PARENTS

Instance Attribute Summary

Attributes included from Query

#solutions

Attributes inherited from SPARQL::Algebra::Operator

#operands

Instance Method Summary collapse

Methods included from Query

#each_solution, #empty?, #failed?, #graph_name=, #matched?, #query_yields_boolean?, #query_yields_solutions?, #query_yields_statements?, #unshift, #variables

Methods inherited from Binary

#initialize

Methods inherited from SPARQL::Algebra::Operator

#aggregate?, arity, #base_uri, base_uri, base_uri=, #bind, #boolean, #constant?, #deep_dup, #each_descendant, #eql?, #evaluatable?, evaluate, #executable?, #first_ancestor, for, #initialize, #inspect, #ndvars, #node?, #operand, #optimize, #optimize!, #parent, #parent=, #prefixes, prefixes, prefixes=, #rewrite, #to_binary, to_sparql, #to_sxp, #to_sxp_bin, #validate!, #variable?, #variables, #vars

Methods included from Expression

cast, #constant?, #evaluate, extension, extension?, extensions, for, #invalid?, new, #node?, open, #optimize, #optimize!, parse, register_extension, #to_sxp_bin, #valid?, #validate!, #variable?

Constructor Details

This class inherits a constructor from SPARQL::Algebra::Operator::Binary

Instance Method Details

#execute(queryable, **options) {|solution| ... } ⇒ RDF::Query::Solutions

Executes this query on the given queryable graph or repository. Orders a solution set returned by executing operand(1) using an array of expressions and/or variables specified in operand(0)

Parameters:

  • queryable (RDF::Queryable) —

    the graph or repository to query

  • options (Hash{Symbol => Object}) —

    any additional keyword options

Yields:

  • (solution) —

    each matching solution

Yield Parameters:

Yield Returns:

  • (void) —

    ignored

Returns:

See Also:



86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
 
# File 'lib/sparql/algebra/operator/order.rb', line 86

def execute(queryable, **options, &block)

  debug(options) {"Order"}
  @solutions = queryable.query(operands.last, **options.merge(depth: options[:depth].to_i + 1)).order do |a, b|
    operand(0).inject(0) do |memo, op|
      debug(options) {"(order) #{op.inspect}"}
      memo = begin
        a_eval = op.evaluate(a, queryable: queryable, **options.merge(depth: options[:depth].to_i + 1)) rescue nil
        b_eval = op.evaluate(b, queryable: queryable, **options.merge(depth: options[:depth].to_i + 1)) rescue nil
        comp = begin
          Operator::Compare.evaluate(a_eval, b_eval, order_by: true).to_s.to_i
        rescue TypeError
          # Type sError is effectively zero
          debug(options) {"(order) rescue(#{$!}): #{a_eval.inspect}, #{b_eval.inspect}"}
          RDF::Literal(0)
        end
        comp = -comp if op.is_a?(Operator::Desc)
        comp
      end if memo == 0
      memo
    end
  end
  @solutions.each(&block) if block_given?
  @solutions
end

#to_sparql(**options) ⇒ String

Returns a partial SPARQL grammar for this operator.

Provides order to descendant query.

Returns:

  • (String) 


119
120
121
 
# File 'lib/sparql/algebra/operator/order.rb', line 119

def to_sparql(**options)
  operands.last.to_sparql(order_ops: operands.first, **options)
end