Class: ROM::Relation::Loaded

Inherits:
Object
  • Object
show all
Includes:
Enumerable
Defined in:
lib/rom/relation/loaded.rb

Overview

Materializes a relation and exposes interface to access the data.

This relation type is returned when a lazy relation is called

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(source, collection = source.to_a) ⇒ Loaded

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Returns a new instance of Loaded.



38
39
40
41
 
# File 'lib/rom/relation/loaded.rb', line 38

def initialize(source, collection = source.to_a)
  @source = source
  @collection = collection
end

Instance Attribute Details

#collection ⇒ Object (readonly)

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Materialized relation

Returns:

  • (Object) 


35
36
37
 
# File 'lib/rom/relation/loaded.rb', line 35

def collection
  @collection
end

#source ⇒ Relation (readonly)

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Source relation

Returns:



28
29
30
 
# File 'lib/rom/relation/loaded.rb', line 28

def source
  @source
end

Instance Method Details

#each {|Hash| ... } ⇒ Object

Yield relation tuples

Yields:

  • (Hash) 


48
49
50
51
 
# File 'lib/rom/relation/loaded.rb', line 48

def each
  return to_enum unless block_given?
  collection.each { |tuple| yield(tuple) }
end

#empty? ⇒ TrueClass, FalseClass

Return if loaded relation is empty

Returns:

  • (TrueClass, FalseClass) 


123
124
125
 
# File 'lib/rom/relation/loaded.rb', line 123

def empty?
  collection.empty?
end

#new(collection) ⇒ Object

Return a loaded relation with a new collection



130
131
132
 
# File 'lib/rom/relation/loaded.rb', line 130

def new(collection)
  self.class.new(source, collection)
end

#one ⇒ Object

Returns a single tuple from the relation if there is one.

Raises:



59
60
61
62
63
64
65
66
67
68
 
# File 'lib/rom/relation/loaded.rb', line 59

def one
  if collection.count > 1
    raise(
      TupleCountMismatchError,
      'The relation consists of more than one tuple'
    )
  else
    collection.first
  end
end

#one! ⇒ Object

Like [one], but additionally raises an error if the relation is empty.

Raises:



76
77
78
79
80
81
 
# File 'lib/rom/relation/loaded.rb', line 76

def one!
  one || raise(
    TupleCountMismatchError,
    'The relation does not contain any tuples'
  )
end

#pluck(key) ⇒ Array

Return a list of values under provided key

Examples:

all_users = rom.relations[:users].call
all_users.pluck(:name)
# ["Jane", "Joe"]

Parameters:

  • key (Symbol) —

    The key name

Returns:

  • (Array)

Raises:

  • KeyError when provided key doesn’t exist in any of the tuples



97
98
99
 
# File 'lib/rom/relation/loaded.rb', line 97

def pluck(key)
  map { |tuple| tuple.fetch(key) }
end

#primary_keys ⇒ Array

Pluck primary key values

This method *may not work* with adapters that don’t provide relations that have primary key configured

Examples:

users = rom.relations[:users].call
users.primary_keys
# [1, 2, 3]

Returns:

  • (Array) 


114
115
116
 
# File 'lib/rom/relation/loaded.rb', line 114

def primary_keys
  pluck(source.primary_key)
end