Class: RDF::Query::Pattern

Inherits:
Statement show all
Defined in:
vendor/bundler/ruby/2.7.0/bundler/gems/rdf-n3-edf63ce7750f/lib/rdf/n3/refinements.rb,
vendor/bundler/ruby/2.7.0/bundler/gems/rdf-n3-edf63ce7750f/lib/rdf/n3/extensions.rb,
vendor/bundler/ruby/2.7.0/bundler/gems/rdf-2fcab3c7bbb9/lib/rdf/query/pattern.rb,
vendor/bundler/ruby/2.7.0/bundler/gems/sparql-8509b1578e69/lib/sparql/algebra/extensions.rb

Overview

An RDF query pattern.

Since:

  • 0.3.0

Instance Attribute Summary collapse

Attributes inherited from Statement

#graph_name, #id, #object, #predicate, #subject

Instance Method Summary collapse

Methods inherited from Statement

#==, #===, #[], #[]=, add_entailment, #asserted?, #canonicalize, #canonicalize!, #complete?, #embedded?, #entail, #has_graph?, #has_object?, #has_predicate?, #has_subject?, #hash, #incomplete?, #inferred?, #invalid?, #node?, #optimize, #quoted?, #reified, #statement?, #to_h, #to_quad, #to_sxp, #to_triple, #valid_extended?, #validate!, #variable?

Methods included from Resource

new, #resource?

Methods included from Term

#<=>, #==, #aggregate?, #as_datetime, #as_number, #compatible?, #escape, #optimize, #sameTerm?, #term?, #to_base, #to_term

Methods included from SPARQL::Algebra::Expression

cast, #constant?, extension, extensions, for, #invalid?, new, #node?, open, #optimize, #optimize!, parse, register_extension, #validate!, #variable?

Methods included from Value

#anonymous?, #canonicalize, #canonicalize!, #constant?, #formula?, #graph?, #inspect, #inspect!, #invalid?, #iri?, #list?, #literal?, #node?, #resource?, #start_with?, #statement?, #term?, #to_ndvar, #to_nquads, #to_ntriples, #to_rdf, #to_term, #type_error, #uri?, #validate!, #variable?

Constructor Details

#initialize(options = {}) ⇒ Pattern #initialize(subject, predicate, object, options = {}) ⇒ Pattern

Note:

Statement treats symbols as interned Node instances, in a RDF::Query::Pattern, they are treated as Variable.

Returns a new instance of Pattern.

Overloads:

Since:

  • 0.3.0



39
40
41
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-2fcab3c7bbb9/lib/rdf/query/pattern.rb', line 39

def initialize(subject = nil, predicate = nil, object = nil, options = {})
  super
end

Instance Attribute Details

#costNumeric

The estimated cost of this pattern (for query optimization).

Returns:

  • (Numeric)

Since:

  • 0.3.0



72
73
74
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-2fcab3c7bbb9/lib/rdf/query/pattern.rb', line 72

def cost
  @cost
end

#optionsHash (readonly)

Any additional options for this pattern.

Returns:

Since:

  • 0.3.0



66
67
68
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-2fcab3c7bbb9/lib/rdf/query/pattern.rb', line 66

def options
  @options
end

Instance Method Details

#bind(solution) ⇒ self

Binds the pattern to a solution, making it no longer variable if all variables are resolved to bound variables

Parameters:

Returns:

  • (self)

Since:

  • 0.3.0



291
292
293
294
295
296
297
298
299
300
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-2fcab3c7bbb9/lib/rdf/query/pattern.rb', line 291

def bind(solution)
  self.to_quad.each_with_index do |term, index|
    if term.is_a?(Variable) && solution[term]
      self[index] = solution[term] 
    elsif term.is_a?(Pattern)
      term.bind(solution)
    end
  end
  self
end

#binding_countInteger

Returns the number of bindings in this pattern.

Returns:

Since:

  • 0.3.0



314
315
316
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-2fcab3c7bbb9/lib/rdf/query/pattern.rb', line 314

def binding_count
  bindings.size
end

#bindingsHash{Symbol => RDF::Term}

Returns all bindings in this pattern.

Returns:

Since:

  • 0.3.0



322
323
324
325
326
327
328
329
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-2fcab3c7bbb9/lib/rdf/query/pattern.rb', line 322

def bindings
  bindings = {}
  bindings.merge!(subject.bindings)    if subject && subject.variable?
  bindings.merge!(predicate.bindings)  if predicate && predicate.variable?
  bindings.merge!(object.bindings)     if object && object.variable?
  bindings.merge!(graph_name.bindings) if graph_name && graph_name.variable?
  bindings
end

#bindings?Boolean

Returns true if this pattern contains bindings.

Returns:

  • (Boolean)

    true or false

Since:

  • 0.3.0



306
307
308
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-2fcab3c7bbb9/lib/rdf/query/pattern.rb', line 306

def bindings?
  !bindings.empty?
end

#blank?Boolean

Returns true if this is a blank pattern, with all terms being nil.

Returns:

  • (Boolean)

    true or false

Since:

  • 0.3.0



79
80
81
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-2fcab3c7bbb9/lib/rdf/query/pattern.rb', line 79

def blank?
  subject.nil? && predicate.nil? && object.nil? && graph_name.nil?
end

#bound?Boolean

Returns true if all variables in this pattern are bound.

Returns:

  • (Boolean)

    true or false

Since:

  • 0.3.0



335
336
337
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-2fcab3c7bbb9/lib/rdf/query/pattern.rb', line 335

def bound?
  !variables.empty? && variables.values.all?(&:bound?)
end

#bound_variablesHash{Symbol => Variable}

Returns all bound variables in this pattern.

Returns:

Since:

  • 0.3.0



343
344
345
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-2fcab3c7bbb9/lib/rdf/query/pattern.rb', line 343

def bound_variables
  variables.reject { |name, variable| variable.unbound? }
end

#eql?(other) ⇒ Boolean

Checks pattern equality against a statement, considering nesting.

  • A pattern which has a pattern as a subject or an object, matches a statement having a statement as a subject or an object using #eql?.

Parameters:

Returns:

  • (Boolean)

See Also:

Since:

  • 0.3.0



191
192
193
194
195
196
197
198
199
200
201
202
203
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-n3-edf63ce7750f/lib/rdf/n3/extensions.rb', line 191

def eql?(other)
  return false unless other.is_a?(RDF::Statement) && (self.graph_name || false) == (other.graph_name || false)

  [:subject, :predicate, :object].each do |part|
    case o = self.send(part)
    when RDF::Query::Pattern, RDF::List
      return false unless o.eql?(other.send(part))
    else
      return false unless o == other.send(part)
    end
  end
  true
end

#evaluate(bindings, formulae:, **options) ⇒ RDF::Statement, RDF::N3::Algebra::Formula

Evaluates the pattern using the given variable bindings by cloning the pattern replacing variables with their bindings recursively. If the resulting pattern is constant, it is cast as a statement.

Parameters:

Returns:

See Also:

  • SPARQL::Algebra::Expression.evaluate


16
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-n3-edf63ce7750f/lib/rdf/n3/refinements.rb', line 16

def evaluate(bindings, formulae:, **options); end

#execute(queryable, bindings = {}) {|statement| ... } ⇒ Enumerable<RDF::Query::Pattern>

Executes this query pattern on the given queryable object.

Values are matched using using Queryable#query_pattern.

If the optional bindings are given, variables will be substituted with their values when executing the query.

To match triples only in the default graph, set graph_name to false.

Examples:

Pattern.new(:s, :p, :o).execute(RDF::Repository.load('etc/doap.nt'))

Parameters:

Yields:

  • (statement)

    each matching statement

Yield Parameters:

  • statement (RDF::Statement)

    an RDF statement matching this pattern

Returns:

See Also:

Since:

  • 0.3.0



167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-2fcab3c7bbb9/lib/rdf/query/pattern.rb', line 167

def execute(queryable, bindings = {}, &block)
  query = {
    subject:    subject.is_a?(Variable)     && bindings[subject.to_sym]     ? bindings[subject.to_sym]    : subject,
    predicate:  predicate.is_a?(Variable)   && bindings[predicate.to_sym]   ? bindings[predicate.to_sym]  : predicate,
    object:     object.is_a?(Variable)      && bindings[object.to_sym]      ? bindings[object.to_sym]     : object,
    graph_name: graph_name.is_a?(Variable)  && bindings[graph_name.to_sym]  ? bindings[graph_name.to_sym] : graph_name,
  }.delete_if{|k,v| v.nil?}

  # Do all the variable terms refer to distinct variables?
  variables = self.variables
  if variable_count == variables.size
    # If so, we can just let the repository implementation handle
    # everything and yield matching statements directly:
    queryable.query(query, &block)

  # No, some terms actually refer to the same variable...
  else
    # Considering embedding, figure out if variables that may appear more than once resolve to the same value.
    vars = variables.keys
    queryable.query(query).select do |statement|
      if vars.all? {|var| self.var_values(var, statement).uniq.size == 1}
        yield statement if block_given?
        true
      end
    end
  end
end

#has_variables?Boolean Also known as: variables?

Returns true if this pattern contains any variables.

Returns:

  • (Boolean)

    true or false

Since:

  • 0.3.0



88
89
90
91
92
93
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-2fcab3c7bbb9/lib/rdf/query/pattern.rb', line 88

def has_variables?
  subject    && subject.variable? ||
  predicate  && predicate.variable? ||
  object     && object.variable? ||
  graph_name && graph_name.variable?
end

#ndvarsArray<RDF::Query::Variable>

Return the non-destinguished variables contained within this pattern

Returns:

Since:

  • 0.3.0



472
473
474
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/sparql-8509b1578e69/lib/sparql/algebra/extensions.rb', line 472

def ndvars
  vars.reject(&:distinguished?)
end

#optional?Boolean

Returns true if this is an optional pattern.

Examples:

Pattern.new(:s, :p, :o).optional?                     #=> false
Pattern.new(:s, :p, :o, optional: true).optional?  #=> true

Returns:

  • (Boolean)

    true or false

Since:

  • 0.3.0



105
106
107
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-2fcab3c7bbb9/lib/rdf/query/pattern.rb', line 105

def optional?
  !!options[:optional]
end

#orig_initialize!Object

Overrides #initialize! to turn blank nodes into non-distinguished variables, if the :ndvars option is set.



167
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-n3-edf63ce7750f/lib/rdf/n3/extensions.rb', line 167

alias_method :orig_initialize!, :initialize!

#solution(statement) ⇒ RDF::Query::Solution

Returns a query solution constructed by binding any variables in this pattern with the corresponding terms in the given statement.

Examples:

pattern = Pattern.new(:s, :p, :o)
solution = pattern.solution(statement)

pattern[:s] #=> statement.subject
pattern[:p] #=> statement.predicate
pattern[:o] #=> statement.object

Parameters:

Returns:

Since:

  • 0.3.0



211
212
213
214
215
216
217
218
219
220
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-2fcab3c7bbb9/lib/rdf/query/pattern.rb', line 211

def solution(statement)
  RDF::Query::Solution.new do |solution|
    solution[subject.to_sym]    = statement.subject    if subject.is_a?(Variable)
    solution[predicate.to_sym]  = statement.predicate  if predicate.is_a?(Variable)
    solution[object.to_sym]     = statement.object     if object.is_a?(Variable)
    solution[graph_name.to_sym] = statement.graph_name if graph_name.is_a?(Variable)
    solution.merge!(subject.solution(statement.subject)) if subject.respond_to?(:solution)
    solution.merge!(object.solution(statement.object)) if object.respond_to?(:solution)
  end
end

#to_sString

Returns a string representation of this pattern.

Returns:

Since:

  • 0.3.0



367
368
369
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-2fcab3c7bbb9/lib/rdf/query/pattern.rb', line 367

def to_s
  (optional? ? 'OPTIONAL ' : '') + super
end

#to_sxp_binArray

Transform Query Pattern into an SXP

Returns:

Since:

  • 0.3.0



207
208
209
210
211
212
213
214
215
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-n3-edf63ce7750f/lib/rdf/n3/extensions.rb', line 207

def to_sxp_bin
  [ :triple,
    (:inferred if inferred?),
    subject,
    predicate,
    object,
    graph_name
  ].compact.map(&:to_sxp_bin)
end

#unbound?Boolean

Returns true if all variables in this pattern are unbound.

Returns:

  • (Boolean)

    true or false

Since:

  • 0.3.0



351
352
353
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-2fcab3c7bbb9/lib/rdf/query/pattern.rb', line 351

def unbound?
  !variables.empty? && variables.values.all?(&:unbound?)
end

#unbound_variablesHash{Symbol => Variable}

Returns all unbound variables in this pattern.

Returns:

Since:

  • 0.3.0



359
360
361
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-2fcab3c7bbb9/lib/rdf/query/pattern.rb', line 359

def unbound_variables
  variables.reject { |name, variable| variable.bound? }
end

#valid?Boolean

Is this pattern composed only of valid components?

Returns:

  • (Boolean)

    true or false

Since:

  • 0.3.0



5
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-n3-edf63ce7750f/lib/rdf/n3/refinements.rb', line 5

def valid?; end

#var_values(var, statement) ⇒ Array<RDF::Term>

Returns all values the statement in the same pattern position

Parameters:

Returns:

Since:

  • 0.3.0



250
251
252
253
254
255
256
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-2fcab3c7bbb9/lib/rdf/query/pattern.rb', line 250

def var_values(var, statement)
  [:subject, :predicate, :object, :graph_name].map do |position|
    po = self.send(position)
    so = statement.send(position)
    po.var_values(var, so) if po.respond_to?(:var_values)
  end.flatten.compact
end

#variable_countInteger Also known as: cardinality, arity

Returns the number of variables in this pattern.

Note: this does not count distinct variables, and will therefore e.g. return 3 even if two terms are actually the same variable.

Returns:

Since:

  • 0.3.0



265
266
267
268
269
270
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-2fcab3c7bbb9/lib/rdf/query/pattern.rb', line 265

def variable_count
  [subject, predicate, object, graph_name].inject(0) do |memo, term|
    memo += (term.is_a?(Variable) ? 1 :
             (term.respond_to?(:variable_count) ? term.variable_count : 0))
  end
end

#variable_terms(name = nil) ⇒ Array<Symbol>

Deprecated.

use #var_values instead

Returns the variable terms in this pattern.

Examples:

Pattern.new(RDF::Node.new, :p, 123).variable_terms    #=> [:predicate]

Parameters:

  • name (Symbol, #to_sym) (defaults to: nil)

    an optional variable name

Returns:

Since:

  • 0.3.0



233
234
235
236
237
238
239
240
241
242
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-2fcab3c7bbb9/lib/rdf/query/pattern.rb', line 233

def variable_terms(name = nil)
  warn "[DEPRECATION] RDF::Query::Pattern#variable_terms is deprecated and will be removed in a future version.\n" +
       "Called from #{Gem.location_of_caller.join(':')}"
  terms = []
  terms << :subject    if subject.is_a?(Variable)    && (!name || name.eql?(subject.name))
  terms << :predicate  if predicate.is_a?(Variable)  && (!name || name.eql?(predicate.name))
  terms << :object     if object.is_a?(Variable)     && (!name || name.eql?(object.name))
  terms << :graph_name if graph_name.is_a?(Variable) && (!name || name.eql?(graph_name.name))
  terms
end

#variablesHash{Symbol => Variable}

Returns all variables in this pattern.

Note: this returns a hash containing distinct variables only.

Returns:

Since:

  • 0.3.0



280
281
282
283
284
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-2fcab3c7bbb9/lib/rdf/query/pattern.rb', line 280

def variables
  [subject, predicate, object, graph_name].inject({}) do |memo, term|
    term && term.variable? ? memo.merge(term.variables) : memo
  end
end

#varsArray<RDF::Query::Variable>

Return the variables contained within this pattern

Returns:

Since:

  • 0.3.0



479
480
481
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/sparql-8509b1578e69/lib/sparql/algebra/extensions.rb', line 479

def vars
  variables.values
end