Class: SPARQL::Algebra::Operator::GroupConcat

Inherits:
Operator
  • Object
show all
Includes:
Aggregate
Defined in:
lib/sparql/algebra/operator/group_concat.rb

Overview

The SPARQL groupconcat set function.

GroupConcat is a set function which performs a string concatenation across the values of an expression with a group. The order of the strings is not specified. The separator character used in the concatenation may be given with the scalar argument SEPARATOR.

If all operands are language-tagged strings with the same language (and direction), the result shares the language (and direction).

[127] Aggregate::= ... | 'GROUP_CONCAT' '(' 'DISTINCT'? Expression ( ';' 'SEPARATOR' '=' String )? ')'

Examples:

SPARQL Grammar

SELECT (GROUP_CONCAT(?x) AS ?y) {}

SSE

(project (?y)
 (extend ((?y ??.0))
  (group () ((??.0 (group_concat ?x)))
   (bgp))))

SPARQL Grammar (DISTINCT)

SELECT (GROUP_CONCAT(DISTINCT ?x) AS ?y) {}

SSE (DISTINCT)

(project (?y)
 (extend ((?y ??.0))
  (group () ((??.0 (group_concat distinct ?x)))
   (bgp))))

SPARQL Grammar (SEPARATOR)

SELECT (GROUP_CONCAT(?x; SEPARATOR=';') AS ?y) {}

SSE (SEPARATOR)

(project (?y)
 (extend ((?y ??.0))
  (group () ((??.0 (group_concat (separator ";") ?x)))
   (bgp))))

See Also:

Constant Summary collapse

NAME = 
:group_concat

Instance Method Summary collapse

Methods included from Aggregate

#replace_aggregate!, #replace_vars!

Instance Method Details

#aggregate(solutions = [], **options) ⇒ RDF::Term

This method is abstract.

One, two or three operands, the first may be distinct, the last operand, if it exists, is a separator, defaulting to ' '.

Parameters:

  • solutions (Enumerable<RDF::Query::Solution>) (defaults to: []) —

    ([]) an enumerable set of query solutions

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

    ({}) options passed from query

Returns:

Raises:

  • (TypeError) 


55
56
57
58
59
60
61
62
63
64
65
66
67
 
# File 'lib/sparql/algebra/operator/group_concat.rb', line 55

def aggregate(solutions = [], **options)
  operands.shift if distinct = (operands.first == :distinct)
  sep = operands.length == 2 ? operand(0).last : RDF::Literal(' ')
  args_enum = solutions.map do |solution|
    begin
      operands.last.evaluate(solution, **options.merge(depth: options[:depth].to_i + 1))
    rescue TypeError
      # Ignore errors
      nil
    end
  end
  apply(distinct ? args_enum.uniq : args_enum, sep)
end

#apply(enum, separator, **options) ⇒ RDF::Term

GroupConcat is a set function which performs a string concatenation across the values of an expression with a group. The order of the strings is not specified. The separator character used in the concatenation may be given with the scalar argument SEPARATOR.

Parameters:

Returns:

Raises:

  • (TypeError) —

    If enum is empty



76
77
78
79
80
 
# File 'lib/sparql/algebra/operator/group_concat.rb', line 76

def apply(enum, separator, **options)
  op1_lang = enum.first.language
  lang = op1_lang if op1_lang && enum.all? {|v| v.language == op1_lang}
  RDF::Literal(enum.flatten.map(&:to_s).join(separator.to_s), language: lang)
end

#to_sparql(**options) ⇒ String

Returns a partial SPARQL grammar for this operator.

Returns:

  • (String) 


87
88
89
90
91
92
93
94
95
 
# File 'lib/sparql/algebra/operator/group_concat.rb', line 87

def to_sparql(**options)
  distinct = operands.first == :distinct
  args = distinct ? operands[1..-1] : operands
  separator = args.first.last if args.first.is_a?(Array) && args.first.first == :separator
  args = args[1..-1] if separator
  str = "GROUP_CONCAT(#{'DISTINCT ' if distinct}#{args.to_sparql(delimiter: ', ', **options)}"
  str << "; SEPARATOR=#{separator.to_sparql}" if separator
  str << ")"
end