Method: LD::Patch::Algebra::Bind#execute

Defined in:
lib/ld/patch/algebra/bind.rb

#execute(queryable, options = {}) ⇒ RDF::Query::Solutions

Maps the value to a single output term by executing the path and updates bindings with var set to that output term

Parameters:

  • queryable (RDF::Queryable) —

    the graph or repository to write

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

    any additional options

Options Hash (options):

  • :bindings (RDF::Query::Solutions)

Returns:

  • (RDF::Query::Solutions) —

    A single solution including passed bindings with var bound to the solution.

Raises:

  • (Error) —

    If path does not evaluate to a single term or if unbound variables are used.

See Also:



69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
 
# File 'lib/ld/patch/algebra/bind.rb', line 69

def execute(queryable, options = {})
  debug(options) {"Bind"}
  bindings = options.fetch(:bindings)
  solution = bindings.first
  var, value, path = operands

  # Bind variables to path
  if value.variable?
    raise LD::Patch::Error.new("Operand uses unbound variable #{value.inspect}", code: 400) unless solution.bound?(value)
    value = solution[value]
  end

  path = path.dup.replace_vars! do |v|
    raise Error, "Operand uses unbound variable #{v.inspect}" unless solution.bound?(v)
    solution[v]
  end
  results = path.execute(queryable, terms: [value])
  raise LD::Patch::Error, "Bind path bound to #{results.length} terms, expected just one" unless results.length == 1
  RDF::Query::Solutions.new [solution.merge(var.to_sym => results.first.path)]
end