module SPARQL::Algebra::Evaluatable

Mixin for Algebra::Operator sub-classes that evaluate bindings to return a result

@abstract

Public Instance Methods

apply(*operands, **options) click to toggle source

@param [Array<RDF::Term>] operands

evaluated operands

@return [RDF::Term] @abstract

# File lib/sparql/algebra/evaluatable.rb, line 35
def apply(*operands, **options)
  raise NotImplementedError, "#{self.class}#apply(#{operands.map(&:class).join(', ')})"
end
evaluate(bindings, **options) click to toggle source

Evaluates this operator using the given variable `bindings`.

@param [RDF::Query::Solution] bindings

a query solution containing zero or more variable bindings

@param [Hash{Symbol => Object}] options ({})

options passed from query

@return [RDF::Term] @abstract

# File lib/sparql/algebra/evaluatable.rb, line 16
def evaluate(bindings, **options)
  args = operands.map { |operand| operand.evaluate(bindings, depth: options[:depth].to_i + 1, **options) }
  options[:memoize] ? memoize(*args, **options) : apply(*args, **options)
end
memoize(*operands, **options) click to toggle source

@param [Array<RDF::Term>] operands

evaluated operands

@return [RDF::Term] the memoized result

# File lib/sparql/algebra/evaluatable.rb, line 25
def memoize(*operands, **options)
  @cache ||= RDF::Util::Cache.new(options[:memoize].is_a?(Integer) ? options[:memoize] : -1)
  @cache[operands] ||= apply(*operands, **options)
end
replace_aggregate!() { |op| ... } click to toggle source

Recursively re-map operators to replace aggregates with temporary variables returned from the block

@yield agg @yieldparam [SPARQL::Algebra::Aggregate] agg @yieldreturn [RDF::Query::Variable] @return [SPARQL::Algebra::Evaluatable, RDF::Query::Variable] self

# File lib/sparql/algebra/evaluatable.rb, line 68
def replace_aggregate!(&block)
  @operands.map! do |op|
    case
    when op.aggregate?
      yield op
    when op.respond_to?(:replace_aggregate!)
      op.replace_aggregate!(&block) 
    else
      op
    end
  end
  self
end
replace_vars!() { |op| ... } click to toggle source

Replace operators which are variables with the result of the block descending into operators which are also evaluatable

@yield var @yieldparam [RDF::Query::Variable] var @yieldreturn [RDF::Query::Variable, SPARQL::Algebra::Evaluatable] @return [SPARQL::Algebra::Evaluatable] self

# File lib/sparql/algebra/evaluatable.rb, line 47
def replace_vars!(&block)
  @operands.map! do |op|
    case
    when op.is_a?(RDF::Query::Variable)
      yield op
    when op.respond_to?(:replace_vars!)
      op.replace_vars!(&block) 
    else
      op
    end
  end
  self
end