class SPARQL::Client::Query

A SPARQL query builder.

@example Iterating over all found solutions

query.each_solution { |solution| puts solution.inspect }

Attributes

form[R]

The form of the query.

@return [:select, :ask, :construct, :describe] @see www.w3.org/TR/sparql11-query/#QueryForms

options[R]

@return [Hash{Symbol => Object}]

Public Class Methods

ask(**options) click to toggle source

Creates a boolean `ASK` query.

@example ASK WHERE { ?s ?p ?o . }

Query.ask.where([:s, :p, :o])

@param [Hash{Symbol => Object}] options (see {#initialize}) @return [Query] @see www.w3.org/TR/sparql11-query/#ask

# File lib/sparql/client/query.rb, line 31
def self.ask(**options)
  self.new(:ask, **options)
end
construct(*patterns, **options) click to toggle source

Creates a graph `CONSTRUCT` query.

@example CONSTRUCT { ?s ?p ?o . } WHERE { ?s ?p ?o . }

Query.construct([:s, :p, :o]).where([:s, :p, :o])

@param [Array<RDF::Query::Pattern, Array>] patterns @return [Query]

@overload self.construct(*variables, **options)

@param  [Array<RDF::Query::Pattern, Array>] patterns
@param  [Hash{Symbol => Object}] options (see {#initialize})
@return [Query]

@see www.w3.org/TR/sparql11-query/#construct

# File lib/sparql/client/query.rb, line 91
def self.construct(*patterns, **options)
  self.new(:construct, **options).construct(*patterns) # FIXME
end
describe(*variables, **options) click to toggle source

Creates a `DESCRIBE` query.

@example DESCRIBE * WHERE { ?s ?p ?o . }

Query.describe.where([:s, :p, :o])

@param [Array<Symbol, RDF::URI>] variables @return [Query]

@overload self.describe(*variables, **options)

@param  [Array<Symbol, RDF::URI>] variables
@param  [Hash{Symbol => Object}] options (see {#initialize})
@return [Query]

@see www.w3.org/TR/sparql11-query/#describe

# File lib/sparql/client/query.rb, line 73
def self.describe(*variables, **options)
  self.new(:describe, **options).describe(*variables)
end
new(form = :ask, **options, &block) click to toggle source

@param [Symbol, to_s] form @overload self.construct(*variables, **options)

@param  [Symbol, #to_s]          form
@param  [Hash{Symbol => Object}] options (see {Client#initialize})
@option options [Hash{Symbol => Symbol}] :count
  Contents are symbols relating a variable described within the query,
  to the projected variable.

@yield [query] @yieldparam [Query]

Calls superclass method
# File lib/sparql/client/query.rb, line 106
def initialize(form = :ask, **options, &block)
  @subqueries = []
  @form = form.respond_to?(:to_sym) ? form.to_sym : form.to_s.to_sym
  super([], **options, &block)
end
select(*variables, **options) click to toggle source

Creates a tuple `SELECT` query.

@example `SELECT * WHERE { ?s ?p ?o . }`

Query.select.where([:s, :p, :o])

@example `SELECT ?s WHERE {?s ?p ?o .}`

Query.select(:s).where([:s, :p, :o])

@example `SELECT COUNT(?uri as ?c) WHERE {?uri a owl:Class}`

Query.select(count: {uri: :c}).where([:uri, RDF.type, RDF::OWL.Class])

@param [Array<Symbol>] variables @return [Query]

@overload self.select(*variables, **options)

@param  [Array<Symbol>]          variables
@param  [Hash{Symbol => Object}] options (see {#initialize})
@return [Query]

@see www.w3.org/TR/sparql11-query/#select

# File lib/sparql/client/query.rb, line 55
def self.select(*variables, **options)
  self.new(:select, **options).select(*variables)
end

Public Instance Methods

asc(var) click to toggle source

@example SELECT * WHERE { ?s ?p ?o . } ORDER BY ASC(?o)

query.select.where([:s, :p, :o]).order.asc(:o)
query.select.where([:s, :p, :o]).asc(:o)

@param [Array<Symbol, String>] var @return [Query] @see www.w3.org/TR/sparql11-query/#modOrderBy

# File lib/sparql/client/query.rb, line 266
def asc(var)
  (options[:order_by] ||= []) << {var => :asc}
  self
end
ask() click to toggle source

@example ASK WHERE { ?s ?p ?o . }

query.ask.where([:s, :p, :o])

@return [Query] @see www.w3.org/TR/sparql11-query/#ask

# File lib/sparql/client/query.rb, line 118
def ask
  @form = :ask
  self
end
build_patterns(patterns) click to toggle source

@private

# File lib/sparql/client/query.rb, line 623
def build_patterns(patterns)
  patterns.map {|pattern| RDF::Query::Pattern.from(pattern)}
end
construct(*patterns) click to toggle source

@example CONSTRUCT { ?s ?p ?o . } WHERE { ?s ?p ?o . }

query.construct([:s, :p, :o]).where([:s, :p, :o])

@param [Array<RDF::Query::Pattern, Array>] patterns @return [Query] @see www.w3.org/TR/sparql11-query/#construct

# File lib/sparql/client/query.rb, line 166
def construct(*patterns)
  options[:template] = build_patterns(patterns)
  self
end
desc(var) click to toggle source

@example SELECT * WHERE { ?s ?p ?o . } ORDER BY DESC(?o)

query.select.where([:s, :p, :o]).order.desc(:o)
query.select.where([:s, :p, :o]).desc(:o)

@param [Array<Symbol, String>] var @return [Query] @see www.w3.org/TR/sparql11-query/#modOrderBy

# File lib/sparql/client/query.rb, line 279
def desc(var)
  (options[:order_by] ||= []) << {var => :desc}
  self
end
describe(*variables) click to toggle source

@example DESCRIBE * WHERE { ?s ?p ?o . }

query.describe.where([:s, :p, :o])

@param [Array<Symbol>] variables @return [Query] @see www.w3.org/TR/sparql11-query/#describe

# File lib/sparql/client/query.rb, line 152
def describe(*variables)
  @values = variables.map { |var|
    [var, var.is_a?(RDF::URI) ? var : RDF::Query::Variable.new(var)]
  }
  self
end
distinct(state = true) click to toggle source

@example SELECT DISTINCT ?s WHERE { ?s ?p ?o . }

query.select(:s).distinct.where([:s, :p, :o])

@return [Query] @see www.w3.org/TR/sparql11-query/#modDuplicates

# File lib/sparql/client/query.rb, line 304
def distinct(state = true)
  options[:distinct] = state
  self
end
each_solution(&block) click to toggle source

Enumerates over each matching query solution.

@yield [solution] @yieldparam [RDF::Query::Solution] solution @return [Enumerator]

Calls superclass method
# File lib/sparql/client/query.rb, line 672
def each_solution(&block)
  @solutions = result
  super
end
each_statement(&block) click to toggle source

@yield [statement] @yieldparam [RDF::Statement] @return [Enumerator]

# File lib/sparql/client/query.rb, line 663
def each_statement(&block)
  result.each_statement(&block)
end
execute() click to toggle source

@return [Object]

# File lib/sparql/client/query.rb, line 685
def execute
  raise NotImplementedError
end
expects_statements?() click to toggle source

@return expects_statements?

# File lib/sparql/client/query.rb, line 617
def expects_statements?
  [:construct, :describe].include?(form)
end
false?() click to toggle source

@return [Boolean]

# File lib/sparql/client/query.rb, line 649
def false?
  !true?
end
filter(string) click to toggle source

@example ASK WHERE { ?s ?p ?o . FILTER(regex(?s, 'Abiline, Texas')) }

query.ask.where([:s, :p, :o]).filter("regex(?s, 'Abiline, Texas')")

@return [Query]

# File lib/sparql/client/query.rb, line 631
def filter(string)
  ((options[:filters] ||= []) << Filter.new(string)) if string and not string.empty?
  self
end
from(uri) click to toggle source

@example SELECT * FROM <a> WHERE { ?s ?p ?o . }

query.select.from(RDF::URI.new(a)).where([:s, :p, :o])

@param [RDF::URI] uri @return [Query] @see www.w3.org/TR/sparql11-query/#specifyingDataset

# File lib/sparql/client/query.rb, line 178
def from(uri)
  options[:from] = uri
  self
end
graph(graph_uri_or_var) click to toggle source

@example SELECT * WHERE { GRAPH ?g { ?s ?p ?o . } }

query.select.graph(:g).where([:s, :p, :o])

@param [RDF::Value] graph_uri_or_var @return [Query] @see www.w3.org/TR/sparql11-query/#queryDataset

# File lib/sparql/client/query.rb, line 326
def graph(graph_uri_or_var)
  options[:graph] = case graph_uri_or_var
    when Symbol then RDF::Query::Variable.new(graph_uri_or_var)
    when String then RDF::URI(graph_uri_or_var)
    when RDF::Value then graph_uri_or_var
    else raise ArgumentError
  end
  self
end
group(*variables) click to toggle source

@example SELECT ?s WHERE { ?s ?p ?o . } GROUP BY ?s

query.select(:s).where([:s, :p, :o]).group_by(:s)

@param [Array<Symbol, String>] variables @return [Query] @see www.w3.org/TR/sparql11-query/#groupby

# File lib/sparql/client/query.rb, line 291
def group(*variables)
  options[:group_by] = variables
  self
end
Also aliased as: group_by
group_by(*variables)
Alias for: group
inspect() click to toggle source

Returns a developer-friendly representation of this query.

@return [String]

# File lib/sparql/client/query.rb, line 836
def inspect
  sprintf("#<%s:%#0x(%s)>", self.class.name, __id__, to_s)
end
inspect!() click to toggle source

Outputs a developer-friendly representation of this query to `stderr`.

@return [void]

# File lib/sparql/client/query.rb, line 827
def inspect!
  warn(inspect)
  self
end
limit(length) click to toggle source

@example SELECT * WHERE { ?s ?p ?o . } LIMIT 10

query.select.where([:s, :p, :o]).limit(10)

@param [Integer, to_i] length @return [Query] @see www.w3.org/TR/sparql11-query/#modResultLimit

# File lib/sparql/client/query.rb, line 354
def limit(length)
  slice(nil, length)
end
minus(*patterns, &block) click to toggle source

@example SELECT * WHERE { ?book dc:title ?title . MINUS { ?book dc11:title ?title } }

query.select.where([:book, RDF::Vocab::DC.title, :title]).
  minus([:book, RDF::Vocab::DC11.title, :title])

@example SELECT * WHERE { ?book dc:title ?title MINUS { ?book dc11:title ?title . FILTER(langmatches(lang(?title), 'EN')) } }

query1 = SPARQL::Client::Query.select.
  where([:book, RDF::Vocab::DC11.title, :title]).
  filter("langmatches(?title, 'en')")
query.select.where([:book, RDF::Vocab::DC.title, :title]).minus(query1)

The block form can be used for more complicated queries, using the `select` form (note, use either block or argument forms, not both):

@example SELECT * WHERE { ?book dc:title ?title MINUS { ?book dc11:title ?title . FILTER(langmatches(lang(?title), 'EN'))} }

query1 = SPARQL::Client::Query.select.where([:book, RDF::Vocab::DC11.title, :title]).filter("langmatches(?title, 'en')")
query.select.where([:book, RDF::Vocab::DC.title, :title]).minus do |q|
  q.select.
    where([:book, RDF::Vocab::DC11.title, :title]).
    filter("langmatches(?title, 'en')")
end

@param [Array<RDF::Query::Pattern, Array>] patterns

splat of zero or more patterns followed by zero or more queries.

@yield [query]

Yield form with or without argument; without an argument, evaluates within the query.

@yieldparam [SPARQL::Client::Query] query used for adding select clauses. @return [Query] @see www.w3.org/TR/sparql11-query/#optionals

# File lib/sparql/client/query.rb, line 525
def minus(*patterns, &block)
  options[:minuses] ||= []

  if block_given?
    raise ArgumentError, "#minus requires either arguments or a block, not both." unless patterns.empty?
    # Evaluate calls in a new query instance
    query = self.class.select
    case block.arity
      when 1 then block.call(query)
      else query.instance_eval(&block)
    end
    options[:minuses] << query
  elsif patterns.all? {|p| p.is_a?(SPARQL::Client::Query)}
    # With argument form, all must be patterns or queries
    options[:minuses] += patterns
  elsif patterns.all? {|p| p.is_a?(Array)}
    # With argument form, all must be patterns, or queries
    options[:minuses] << self.class.select.where(*patterns)
  else
    raise ArgumentError, "#minus arguments are triple patters or queries, not both."
  end

  self
end
offset(start) click to toggle source

@example SELECT * WHERE { ?s ?p ?o . } OFFSET 100

query.select.where([:s, :p, :o]).offset(100)

@param [Integer, to_i] start @return [Query] @see www.w3.org/TR/sparql11-query/#modOffset

# File lib/sparql/client/query.rb, line 343
def offset(start)
  slice(start, nil)
end
optional(*patterns, &block) click to toggle source

@example SELECT * WHERE { ?s ?p ?o . OPTIONAL { ?s a ?o . ?s <purl.org/dc/terms/abstract> ?o . } }

query.select.where([:s, :p, :o]).
  optional([:s, RDF.type, :o], [:s, RDF::Vocab::DC.abstract, :o])

The block form can be used for adding filters:

@example ASK WHERE { ?s ?p ?o . OPTIONAL { ?s ?p ?o . FILTER(regex(?s, 'Abiline, Texas'))} }

query.ask.where([:s, :p, :o]).optional([:s, :p, :o]) do
  filter("regex(?s, 'Abiline, Texas')")
end

@param [Array<RDF::Query::Pattern, Array>] patterns

splat of zero or more patterns followed by zero or more queries.

@yield [query]

Yield form with or without argument; without an argument, evaluates within the query.

@yieldparam [SPARQL::Client::Query] query used for creating filters on the optional patterns. @return [Query] @see www.w3.org/TR/sparql11-query/#optionals

# File lib/sparql/client/query.rb, line 426
def optional(*patterns, &block)
  (options[:optionals] ||= []) << build_patterns(patterns)

  if block_given?
    # Steal options[:filters]
    query_filters = options[:filters]
    options[:filters] = []
    case block.arity
      when 1 then block.call(self)
      else instance_eval(&block)
    end
    options[:optionals].last.concat(options[:filters])
    options[:filters] = query_filters
  end

  self
end
order(*variables) click to toggle source

@example SELECT * WHERE { ?s ?p ?o . } ORDER BY ?o

query.select.where([:s, :p, :o]).order(:o)
query.select.where([:s, :p, :o]).order_by(:o)

@example SELECT * WHERE { ?s ?p ?o . } ORDER BY ?o ?p

query.select.where([:s, :p, :o]).order_by(:o, :p)

@example SELECT * WHERE { ?s ?p ?o . } ORDER BY ASC(?o) DESC(?p)

query.select.where([:s, :p, :o]).order_by(o: :asc, p: :desc)

@param [Array<Symbol, String>] variables @return [Query] @see www.w3.org/TR/sparql11-query/#modOrderBy

# File lib/sparql/client/query.rb, line 251
def order(*variables)
  options[:order_by] = variables
  self
end
Also aliased as: order_by
order_by(*variables)
Alias for: order
prefix(val) click to toggle source

@overload prefix(prefix: uri)

@example PREFIX dc: <http://purl.org/dc/elements/1.1/> PREFIX foaf: <http://xmlns.com/foaf/0.1/> SELECT * WHERE \{ ?s ?p ?o . \}
  query.select.
    prefix(dc: RDF::URI("http://purl.org/dc/elements/1.1/")).
    prefix(foaf: RDF::URI("http://xmlns.com/foaf/0.1/")).
    where([:s, :p, :o])

@param [RDF::URI] uri
@param [Symbol, String] prefix
@return [Query]

@overload prefix(string)

@example PREFIX dc: <http://purl.org/dc/elements/1.1/> PREFIX foaf: <http://xmlns.com/foaf/0.1/> SELECT * WHERE \{ ?s ?p ?o . \}
  query.select.
    prefix("dc: <http://purl.org/dc/elements/1.1/>").
    prefix("foaf: <http://xmlns.com/foaf/0.1/>").
    where([:s, :p, :o])

@param [string] string
@return [Query]

@see www.w3.org/TR/sparql11-query/#prefNames

# File lib/sparql/client/query.rb, line 393
def prefix(val)
  options[:prefixes] ||= []
  if val.kind_of? String
    options[:prefixes] << val
  elsif val.kind_of? Hash
    val.each do |k, v|
      options[:prefixes] << "#{k}: <#{v}>"
    end
  else
    raise ArgumentError, "prefix must be a kind of String or a Hash"
  end
  self
end
reduced(state = true) click to toggle source

@example SELECT REDUCED ?s WHERE { ?s ?p ?o . }

query.select(:s).reduced.where([:s, :p, :o])

@return [Query] @see www.w3.org/TR/sparql11-query/#modDuplicates

# File lib/sparql/client/query.rb, line 315
def reduced(state = true)
  options[:reduced] = state
  self
end
result() click to toggle source

@return [Object]

# File lib/sparql/client/query.rb, line 679
def result
  @result ||= execute
end
select(*variables) click to toggle source

@example `SELECT * WHERE { ?s ?p ?o . }`

query.select.where([:s, :p, :o])

@example `SELECT ?s WHERE {?s ?p ?o .}`

query.select(:s).where([:s, :p, :o])

@example `SELECT COUNT(?uri as ?c) WHERE {?uri a owl:Class}`

query.select(count: {uri: :c}).where([:uri, RDF.type, RDF::OWL.Class])

@param [Array<Symbol>, Hash{Symbol => RDF::Query::Variable}] variables @return [Query] @see www.w3.org/TR/sparql11-query/#select

# File lib/sparql/client/query.rb, line 136
def select(*variables)
  @values = if variables.length == 1 && variables.first.is_a?(Hash)
    variables.to_a
  else
    variables.map { |var| [var, RDF::Query::Variable.new(var)] }
  end
  self
end
slice(start, length) click to toggle source

@example SELECT * WHERE { ?s ?p ?o . } OFFSET 100 LIMIT 10

query.select.where([:s, :p, :o]).slice(100, 10)

@param [Integer, to_i] start @param [Integer, to_i] length @return [Query]

# File lib/sparql/client/query.rb, line 365
def slice(start, length)
  options[:offset] = start.to_i if start
  options[:limit] = length.to_i if length
  self
end
solutions() click to toggle source

@return [Enumerable<RDF::Query::Solution>]

# File lib/sparql/client/query.rb, line 655
def solutions
  result
end
to_s() click to toggle source

Returns the string representation of this query.

@return [String]

# File lib/sparql/client/query.rb, line 693
def to_s
  buffer = [form.to_s.upcase]

  case form
    when :select, :describe
      only_count = values.empty? && options[:count]
      buffer << 'DISTINCT' if options[:distinct] and not only_count
      buffer << 'REDUCED'  if options[:reduced]
      buffer << ((values.empty? and not options[:count]) ? '*' : values.map { |v| SPARQL::Client.serialize_value(v[1]) }.join(' '))
      if options[:count]
        options[:count].each do |var, count|
          buffer << '( COUNT(' + (options[:distinct] ? 'DISTINCT ' : '') +
            (var.is_a?(String) ? var : "?#{var}") + ') AS ' + (count.is_a?(String) ? count : "?#{count}") + ' )'
        end
      end
    when :construct
      buffer << '{'
      buffer += SPARQL::Client.serialize_patterns(options[:template])
      buffer << '}'
  end

  buffer << "FROM #{SPARQL::Client.serialize_value(options[:from])}" if options[:from]

  unless patterns.empty? && form == :describe
    buffer += self.to_s_ggp.unshift('WHERE')
  end

  options.fetch(:unions, []).each do |query|
    buffer += query.to_s_ggp.unshift('UNION')
  end

  if options[:group_by]
    buffer << 'GROUP BY'
    buffer += options[:group_by].map { |var| var.is_a?(String) ? var : "?#{var}" }
  end

  if options[:order_by]
    buffer << 'ORDER BY'
    options[:order_by].map { |elem|
      case elem
        # .order_by({ var1: :asc, var2: :desc})
        when Hash
          elem.each { |key, val|
            # check provided values
            if !key.is_a?(Symbol)
              raise ArgumentError, 'keys of hash argument must be a Symbol'
            elsif !val.is_a?(Symbol) || (val != :asc && val != :desc)
              raise ArgumentError, 'values of hash argument must either be `:asc` or `:desc`'
            end
            buffer << "#{val == :asc ? 'ASC' : 'DESC'}(?#{key})"
          }
        # .order_by([:var1, :asc], [:var2, :desc])
        when Array
          # check provided values
          if elem.length != 2
            raise ArgumentError, 'array argument must specify two elements'
          elsif !elem[0].is_a?(Symbol)
            raise ArgumentError, '1st element of array argument must contain a Symbol'
          elsif !elem[1].is_a?(Symbol) || (elem[1] != :asc && elem[1] != :desc)
            raise ArgumentError, '2nd element of array argument must either be `:asc` or `:desc`'
          end
          buffer << "#{elem[1] == :asc ? 'ASC' : 'DESC'}(?#{elem[0]})"
        # .order_by(:var1, :var2)
        when Symbol
          buffer << "?#{elem}"
        # .order_by('ASC(?var1) DESC(?var2)')
        when String
          buffer << elem
        else
          raise ArgumentError, 'argument provided to `order()` must either be an Array, Symbol or String'
      end
    }
  end

  buffer << "OFFSET #{options[:offset]}" if options[:offset]
  buffer << "LIMIT #{options[:limit]}"   if options[:limit]
  options[:prefixes].reverse.each { |e| buffer.unshift("PREFIX #{e}") } if options[:prefixes]

  buffer.join(' ')
end
to_s_ggp() click to toggle source

Serialize a Group Graph Pattern @private

# File lib/sparql/client/query.rb, line 776
def to_s_ggp
  buffer = ["{"]

  if options[:graph]
    buffer << 'GRAPH ' + SPARQL::Client.serialize_value(options[:graph])
    buffer << '{'
  end

  @subqueries.each do |sq|
    buffer << "{ #{sq.to_s} } ."
  end

  buffer += SPARQL::Client.serialize_patterns(patterns)
  if options[:optionals]
    options[:optionals].each do |patterns|
      buffer << 'OPTIONAL {'
      buffer += SPARQL::Client.serialize_patterns(patterns)
      buffer << '}'
    end
  end
  if options[:filters]
    buffer += options[:filters].map(&:to_s)
  end
  if options[:values]
    vars = options[:values].first.map {|var| SPARQL::Client.serialize_value(var)}
    buffer << "VALUES (#{vars.join(' ')}) {"
    options[:values][1..-1].each do |data_block_value|
      buffer << '('
      buffer << data_block_value.map do |value|
        value.nil? ? 'UNDEF' : SPARQL::Client.serialize_value(value)
      end.join(' ')
      buffer << ')'
    end
    buffer << '}'
  end
  if options[:graph]
    buffer << '}' # GRAPH
  end

  options.fetch(:minuses, []).each do |query|
    buffer += query.to_s_ggp.unshift('MINUS')
  end

  buffer << '}'
  buffer
end
true?() click to toggle source

@return [Boolean]

# File lib/sparql/client/query.rb, line 638
def true?
  case result
    when TrueClass, FalseClass then result
    when RDF::Literal::Boolean then result.true?
    when Enumerable then !result.empty?
    else false
  end
end
union(*patterns, &block) click to toggle source

@example SELECT * WHERE { ?book dc:title ?title } UNION { ?book dc11:title ?title }

query.select.where([:book, RDF::Vocab::DC.title, :title]).
  union([:book, RDF::Vocab::DC11.title, :title])

@example SELECT * WHERE { ?book dc:title ?title } UNION { ?book dc11:title ?title . FILTER(langmatches(lang(?title), 'EN'))}

query1 = SPARQL::Client::Query.select.
  where([:book, RDF::Vocab::DC11.title, :title]).
  filter("langmatches(?title, 'en')")
query.select.where([:book, RDF::Vocab::DC.title, :title]).union(query1)

The block form can be used for more complicated queries, using the `select` form (note, use either block or argument forms, not both):

@example SELECT * WHERE { ?book dc:title ?title } UNION { ?book dc11:title ?title . FILTER(langmatches(lang(?title), 'EN'))}

query1 = SPARQL::Client::Query.select.where([:book, RDF::Vocab::DC11.title, :title]).filter("langmatches(?title, 'en')")
query.select.where([:book, RDF::Vocab::DC.title, :title]).union do |q|
  q.select.
    where([:book, RDF::Vocab::DC11.title, :title]).
    filter("langmatches(?title, 'en')")
end

@param [Array<RDF::Query::Pattern, Array>] patterns

splat of zero or more patterns followed by zero or more queries.

@yield [query]

Yield form with or without argument; without an argument, evaluates within the query.

@yieldparam [SPARQL::Client::Query] query used for adding select clauses. @return [Query] @see www.w3.org/TR/sparql11-query/#optionals

# File lib/sparql/client/query.rb, line 472
def union(*patterns, &block)
  options[:unions] ||= []

  if block_given?
    raise ArgumentError, "#union requires either arguments or a block, not both." unless patterns.empty?
    # Evaluate calls in a new query instance
    query = self.class.select
    case block.arity
      when 1 then block.call(query)
      else query.instance_eval(&block)
    end
    options[:unions] << query
  elsif patterns.all? {|p| p.is_a?(SPARQL::Client::Query)}
    # With argument form, all must be patterns or queries
    options[:unions] += patterns
  elsif patterns.all? {|p| p.is_a?(Array)}
    # With argument form, all must be patterns, or queries
    options[:unions] << self.class.select.where(*patterns)
  else
    raise ArgumentError, "#union arguments are triple patters or queries, not both."
  end

  self
end
values(*args) click to toggle source

Specify inline data for a query

@overload values

Values returned from previous query.

@return [Array<Array(key, RDF::Value)>]

@overload values(vars, *data)

@example single variable with multiple values
  query.select
   .where([:s, RDF::URI('http://purl.org/dc/terms/title'), :title])
   .values(:title, "This title", "Another title")

@example multiple variables with multiple values
  query.select
   .where([:s, RDF::URI('http://purl.org/dc/terms/title'), :title],
          [:s, RDF.type, :type])
   .values([:type, :title],
           [RDF::URI('http://pcdm.org/models#Object'), "This title"],
           [RDF::URI('http://pcdm.org/models#Collection', 'Another title'])

@example multiple variables with UNDEF
  query.select
   .where([:s, RDF::URI('http://purl.org/dc/terms/title'), :title],
          [:s, RDF.type, :type])
   .values([:type, :title],
           [nil "This title"],
           [RDF::URI('http://pcdm.org/models#Collection', nil])

@param [Symbol, Array<Symbol>] vars
@param [Array<RDF::Term, String, nil>] *data
@return [Query]
# File lib/sparql/client/query.rb, line 583
def values(*args)
  return @values if args.empty?
  vars, *data = *args
  vars = Array(vars).map {|var| RDF::Query::Variable.new(var)}
  if vars.length == 1
    # data may be a in array form or simple form
    if data.any? {|d| d.is_a?(Array)} && !data.all? {|d| d.is_a?(Array)}
      raise ArgumentError, "values data must all be in array form or all simple"
    end
    data = data.map {|d| Array(d)}
  end

  # Each data value must be an array with the same number of entries as vars
  unless data.all? {|d| d.is_a?(Array) && d.all? {|dd| dd.is_a?(RDF::Value) || dd.is_a?(String) || dd.nil?}}
    raise ArgumentError, "values data must each be an array of terms, strings, or nil"
  end

  # Turn strings into Literals
  data = data.map do |d|
    d.map do |nil_literal_or_term|
      case nil_literal_or_term
      when nil then nil
      when String then RDF::Literal(nil_literal_or_term)
      when RDF::Value then nil_literal_or_term
      else raise ArgumentError
      end
    end
  end
  options[:values] = [vars, *data]
  self
end
where(*patterns_queries, &block) click to toggle source

@example SELECT * WHERE { ?s ?p ?o . }

query.select.where([:s, :p, :o])
query.select.whether([:s, :p, :o])

@example SELECT * WHERE { { SELECT * WHERE { ?s ?p ?o . } } . ?s ?p ?o . }

subquery = query.select.where([:s, :p, :o])
query.select.where([:s, :p, :o], subquery)

@example SELECT * WHERE { { SELECT * WHERE { ?s ?p ?o . } } . ?s ?p ?o . }

query.select.where([:s, :p, :o]) do |q|
  q.select.where([:s, :p, :o])
end

Block form can be used for chaining calls in addition to creating sub-select queries.

@example SELECT * WHERE { ?s ?p ?o . } ORDER BY ?o

query.select.where([:s, :p, :o]) do
  order(:o)
end

@param [Array<RDF::Query::Pattern, Array>] patterns_queries

splat of zero or more patterns followed by zero or more queries.

@yield [query]

Yield form with or without argument; without an argument, evaluates within the query.

@yieldparam [SPARQL::Client::Query] query Actually a delegator to query. Methods other than `#select` are evaluated against `self`. For `#select`, a new Query is created, and the result added as a subquery. @return [Query] @see www.w3.org/TR/sparql11-query/#GraphPattern

# File lib/sparql/client/query.rb, line 211
def where(*patterns_queries, &block)
  subqueries, patterns = patterns_queries.partition {|pq| pq.is_a? SPARQL::Client::Query}
  @patterns += build_patterns(patterns)
  @subqueries += subqueries

  if block_given?
    decorated_query = WhereDecorator.new(self)
    case block.arity
      when 1 then block.call(decorated_query)
      else decorated_query.instance_eval(&block)
    end
  end
  self
end
Also aliased as: whether
whether(*patterns_queries, &block)
Alias for: where