Class: Sequel::Model::Associations::AssociationReflection

Inherits:
Hash
  • Object
show all
Includes:
Inflections
Defined in:
lib/sequel/model/associations.rb

Overview

AssociationReflection is a Hash subclass that keeps information on Sequel::Model associations. It provides methods to reduce internal code duplication. It should not be instantiated by the user.

Constant Summary

Constants included from Inflections

Inflections::CAMELIZE_CONVERT_REGEXP, Inflections::CAMELIZE_MODULE_REGEXP, Inflections::DASH, Inflections::DEMODULIZE_CONVERT_REGEXP, Inflections::EMPTY_STRING, Inflections::SLASH, Inflections::UNDERSCORE, Inflections::UNDERSCORE_CONVERT_REGEXP1, Inflections::UNDERSCORE_CONVERT_REGEXP2, Inflections::UNDERSCORE_CONVERT_REPLACE, Inflections::UNDERSCORE_MODULE_REGEXP, Inflections::VALID_CONSTANT_NAME_REGEXP

Instance Method Summary collapse

Methods included from Inflections

clear, irregular, plural, singular, uncountable

Methods inherited from Hash

#&, #case, #hstore, #pg_json, #sql_expr, #sql_negate, #sql_or, #|, #~

Instance Method Details

#_add_method ⇒ Object

Name symbol for the _add internal association method



21
22
23
 
# File 'lib/sequel/model/associations.rb', line 21

def _add_method
  :"_add_#{singularize(self[:name])}"
end

#_dataset_method ⇒ Object

Name symbol for the _dataset association method



26
27
28
 
# File 'lib/sequel/model/associations.rb', line 26

def _dataset_method
  :"_#{self[:name]}_dataset"
end

#_remove_all_method ⇒ Object

Name symbol for the _remove_all internal association method



31
32
33
 
# File 'lib/sequel/model/associations.rb', line 31

def _remove_all_method
  :"_remove_all_#{self[:name]}"
end

#_remove_method ⇒ Object

Name symbol for the _remove internal association method



36
37
38
 
# File 'lib/sequel/model/associations.rb', line 36

def _remove_method
  :"_remove_#{singularize(self[:name])}"
end

#_setter_method ⇒ Object

Name symbol for the _setter association method



41
42
43
 
# File 'lib/sequel/model/associations.rb', line 41

def _setter_method
  :"_#{self[:name]}="
end

#add_method ⇒ Object

Name symbol for the add association method



46
47
48
 
# File 'lib/sequel/model/associations.rb', line 46

def add_method
  :"add_#{singularize(self[:name])}"
end

#associated_class ⇒ Object

The class associated to the current model class via this association



56
57
58
 
# File 'lib/sequel/model/associations.rb', line 56

def associated_class
  cached_fetch(:class){constantize(self[:class_name])}
end

#association_method ⇒ Object

Name symbol for association method, the same as the name of the association.



51
52
53
 
# File 'lib/sequel/model/associations.rb', line 51

def association_method
  self[:name]
end

#can_have_associated_objects?(obj) ⇒ Boolean

Whether this association can have associated objects, given the current object. Should be false if obj cannot have associated objects because the necessary key columns are NULL.



63
64
65
 
# File 'lib/sequel/model/associations.rb', line 63

def can_have_associated_objects?(obj)
  true
end

#dataset_method ⇒ Object

Name symbol for the dataset association method



68
69
70
 
# File 'lib/sequel/model/associations.rb', line 68

def dataset_method
  :"#{self[:name]}_dataset"
end

#dataset_need_primary_key? ⇒ Boolean

Whether the dataset needs a primary key to function, true by default.



73
74
75
 
# File 'lib/sequel/model/associations.rb', line 73

def dataset_need_primary_key?
  true
end

#eager_graph_lazy_dataset? ⇒ Boolean

Whether to eagerly graph a lazy dataset, true by default. If this is false, the association won’t respect the :eager_graph option when loading the association for a single record.



117
118
119
 
# File 'lib/sequel/model/associations.rb', line 117

def eager_graph_lazy_dataset?
  true
end

#eager_limit_strategy ⇒ Object

The eager limit strategy to use for this dataset.



78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
 
# File 'lib/sequel/model/associations.rb', line 78

def eager_limit_strategy
  cached_fetch(:_eager_limit_strategy) do
    if self[:limit]
      case s = cached_fetch(:eager_limit_strategy){self[:model].default_eager_limit_strategy || :ruby}
      when true
        ds = associated_class.dataset
        if ds.supports_window_functions?
          :window_function
        else
          :ruby
        end
      else
        s
      end
    else
      nil
    end
  end
end

#eager_loader_key ⇒ Object

The key to use for the key hash when eager loading



99
100
101
 
# File 'lib/sequel/model/associations.rb', line 99

def eager_loader_key
  self[:eager_loader_key]
end

#eager_loading_predicate_key ⇒ Object

Alias of predicate_key, only for backwards compatibility.



110
111
112
 
# File 'lib/sequel/model/associations.rb', line 110

def eager_loading_predicate_key
  predicate_key
end

#eager_loading_use_associated_key? ⇒ Boolean

By default associations do not need to select a key in an associated table to eagerly load.



105
106
107
 
# File 'lib/sequel/model/associations.rb', line 105

def eager_loading_use_associated_key?
  false
end

#limit_and_offset ⇒ Object

The limit and offset for this association (returned as a two element array).



122
123
124
125
126
127
128
 
# File 'lib/sequel/model/associations.rb', line 122

def limit_and_offset
  if (v = self[:limit]).is_a?(Array)
    v
  else
    [v, nil]
  end
end

#need_associated_primary_key? ⇒ Boolean

Whether the associated object needs a primary key to be added/removed, false by default.



132
133
134
 
# File 'lib/sequel/model/associations.rb', line 132

def need_associated_primary_key?
  false
end

#predicate_keys ⇒ Object

The keys to use for loading of the regular dataset, as an array.



137
138
139
 
# File 'lib/sequel/model/associations.rb', line 137

def predicate_keys
  cached_fetch(:predicate_keys){Array(predicate_key)}
end

#qualify(table, col) ⇒ Object

Qualify col with the given table name. If col is an array of columns, return an array of qualified columns. Only qualifies Symbols and SQL::Identifier values, other values are not modified.



144
145
146
147
148
149
150
151
152
153
 
# File 'lib/sequel/model/associations.rb', line 144

def qualify(table, col)
  transform(col) do |k|
    case k
    when Symbol, SQL::Identifier
      SQL::QualifiedIdentifier.new(table, k)
    else
      Sequel::Qualifier.new(self[:model].dataset, table).transform(k)
    end
  end
end

#qualify_assoc(col) ⇒ Object

Qualify col with the associated model’s table name.



156
157
158
 
# File 'lib/sequel/model/associations.rb', line 156

def qualify_assoc(col)
  qualify(associated_class.table_name, col)
end

#qualify_cur(col) ⇒ Object

Qualify col with the current model’s table name.



161
162
163
 
# File 'lib/sequel/model/associations.rb', line 161

def qualify_cur(col)
  qualify(self[:model].table_name, col)
end

#reciprocal ⇒ Object

Returns the reciprocal association variable, if one exists. The reciprocal association is the association in the associated class that is the opposite of the current association. For example, Album.many_to_one :artist and Artist.one_to_many :albums are reciprocal associations. This information is to populate reciprocal associations. For example, when you do this_artist.add_album(album) it sets album.artist to this_artist.



171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
 
# File 'lib/sequel/model/associations.rb', line 171

def reciprocal
  cached_fetch(:reciprocal) do
    r_types = Array(reciprocal_type)
    keys = self[:keys]
    recip = nil
    associated_class.all_association_reflections.each do |assoc_reflect|
      if r_types.include?(assoc_reflect[:type]) && assoc_reflect[:keys] == keys && assoc_reflect.associated_class == self[:model]
        cached_set(:reciprocal_type, assoc_reflect[:type])
        recip = assoc_reflect[:name]
        break
      end
    end
    recip
  end
end

#reciprocal_array? ⇒ Boolean

Whether the reciprocal of this association returns an array of objects instead of a single object, true by default.



189
190
191
 
# File 'lib/sequel/model/associations.rb', line 189

def reciprocal_array?
  true
end

#remove_all_method ⇒ Object

Name symbol for the remove_all_ association method



194
195
196
 
# File 'lib/sequel/model/associations.rb', line 194

def remove_all_method
  :"remove_all_#{self[:name]}"
end

#remove_before_destroy? ⇒ Boolean

Whether associated objects need to be removed from the association before being destroyed in order to preserve referential integrity.



200
201
202
 
# File 'lib/sequel/model/associations.rb', line 200

def remove_before_destroy?
  true
end

#remove_method ⇒ Object

Name symbol for the remove_ association method



205
206
207
 
# File 'lib/sequel/model/associations.rb', line 205

def remove_method
  :"remove_#{singularize(self[:name])}"
end

#remove_should_check_existing? ⇒ Boolean

Whether to check that an object to be disassociated is already associated to this object, false by default.



210
211
212
 
# File 'lib/sequel/model/associations.rb', line 210

def remove_should_check_existing?
  false
end

#returns_array? ⇒ Boolean

Whether this association returns an array of objects instead of a single object, true by default.



216
217
218
 
# File 'lib/sequel/model/associations.rb', line 216

def returns_array?
  true
end

#select ⇒ Object

The columns to select when loading the association.



221
222
223
 
# File 'lib/sequel/model/associations.rb', line 221

def select
  self[:select]
end

#set_reciprocal_to_self? ⇒ Boolean

Whether to set the reciprocal association to self when loading associated records, false by default.



227
228
229
 
# File 'lib/sequel/model/associations.rb', line 227

def set_reciprocal_to_self?
  false
end

#setter_method ⇒ Object

Name symbol for the setter association method



232
233
234
 
# File 'lib/sequel/model/associations.rb', line 232

def setter_method
  :"#{self[:name]}="
end