Class: RDF::N3::Algebra::List::In

Inherits:
RDF::N3::Algebra::ListOperator show all
Defined in:
lib/rdf/n3/algebra/list/in.rb

Overview

Iff the object is a list and the subject is in that list, then this is true.

Examples:

{ 1 list:in  (  1 2 3 4 5 ) } => { :test4a a :SUCCESS }.

Constant Summary collapse

NAME = 
:listIn
URI = 
RDF::N3::List.in

Instance Attribute Summary

Attributes included from Enumerable

#existentials, #universals

Instance Method Summary collapse

Methods inherited from RDF::N3::Algebra::ListOperator

#as_literal, #input_operand, #resolve, #validate

Methods included from Builtin

#each, #evaluate, #hash, #input_operand, #rank, #to_uri

Instance Method Details

#execute(queryable, solutions:, **options) ⇒ RDF::Query::Solutions

Evaluates this operator using the given variable bindings. If the first operand is a variable, it creates a solution for each element in the list.

Parameters:

  • queryable (RDF::Queryable) —

    the graph or repository to query

  • solutions (RDF::Query::Solutions) —

    solutions for chained queries

Returns:

  • (RDF::Query::Solutions) 


20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
# File 'lib/rdf/n3/algebra/list/in.rb', line 20

def execute(queryable, solutions:, **options)
  RDF::Query::Solutions(solutions.map do |solution|
    subject = operand(0).evaluate(solution.bindings, formulae: formulae) || operand(0)
    # Might be a variable or node evaluating to a list in queryable, or might be a list with variables
    list = operand(1).evaluate(solution.bindings, formulae: formulae)
    next unless list
    # If it evaluated to a BNode, re-expand as a list
    list = RDF::N3::List.try_list(list, queryable).evaluate(solution.bindings, formulae: formulae)

    log_debug(NAME) {"subject: #{subject.to_sxp}, list: #{list.to_sxp}"}
    unless list.list? && list.valid?
      log_error(NAME) {"operand is not a list: #{list.to_sxp}"}
      next
    end

    if subject.variable?
      # Bind all list entries to this solution, creates an array of solutions
      list.to_a.map do |term|
        solution.merge(subject.to_sym => term)
      end
    elsif list.to_a.include?(subject)
      solution
    else
      nil
    end
  end.flatten.compact.uniq)
end