module Sequel::Model::Associations::ClassMethods

Each kind of association adds a number of instance methods to the model class which are specialized according to the association type and optional parameters given in the definition. Example:

class Project < Sequel::Model
  many_to_one :portfolio
  # or: one_to_one :portfolio
  one_to_many :milestones
  # or: many_to_many :milestones
end

The project class now has the following instance methods:

portfolio: Returns the associated portfolio.
portfolio=(obj): Sets the associated portfolio to the object, but the change is not persisted until you save the record (for many_to_one associations).
portfolio_dataset: Returns a dataset that would return the associated portfolio, only useful in fairly specific circumstances.
milestones: Returns an array of associated milestones
add_milestone(obj): Associates the passed milestone with this object.
remove_milestone(obj): Removes the association with the passed milestone.
remove_all_milestones: Removes associations with all associated milestones.
milestones_dataset: Returns a dataset that would return the associated milestones, allowing for further filtering/limiting/etc.

If you want to override the behavior of the add_/remove_/remove_all_/ methods or the association setter method, use the :adder, :remover, :clearer, and/or :setter options. These options override the default behavior.

By default the classes for the associations are inferred from the association name, so for example the Project#portfolio will return an instance of Portfolio, and Project#milestones will return an array of Milestone instances. You can use the :class option to change which class is used.

Association definitions are also reflected by the class, e.g.:

Project.associations
=> [:portfolio, :milestones]
Project.association_reflection(:portfolio)
=> #<Sequel::Model::Associations::ManyToOneAssociationReflection Project.many_to_one :portfolio>

Associations should not have the same names as any of the columns in the model’s current table they reference. If you are dealing with an existing schema that has a column named status, you can’t name the association status, you’d have to name it foo_status or something else. If you give an association the same name as a column, you will probably end up with an association that doesn’t work, or a SystemStackError.

For a more in depth general overview, as well as a reference guide, see the Association Basics guide. For examples of advanced usage, see the Advanced Associations guide.

Attributes

association_reflections [R]

All association reflections defined for this model (default: {}).

autoreloading_associations [R]

Hash with column symbol keys and arrays of many_to_one association symbols that should be cleared when the column value changes.

cache_associations [RW]

Whether association metadata should be cached in the association reflection. If not cached, it will be computed on demand. In general you only want to set this to false when using code reloading. When using code reloading, setting this will make sure that if an associated class is removed or modified, this class will not have a reference to the previous class.

default_association_options [RW]

The default options to use for all associations. This hash is merged into the association reflection hash for all association reflections.

default_association_type_options [RW]

The default options to use for all associations of a given type. This is a hash keyed by association type symbol. If there is a value for the association type symbol key, the resulting hash will be merged into the association reflection hash for all association reflections of that type.

default_eager_limit_strategy [RW]

The default :eager_limit_strategy option to use for limited or offset associations (default: true, causing Sequel to use what it considers the most appropriate strategy).

Public Instance Methods

all_association_reflections ()

Source

     # File lib/sequel/model/associations.rb
1793 def all_association_reflections
1794   association_reflections.values
1795 end

Array of all association reflections for this model class

associate (type, name, opts = OPTS, &block)

Source

     # File lib/sequel/model/associations.rb
2038 def associate(type, name, opts = OPTS, &block)
2039   raise(Error, 'invalid association type') unless assoc_class = Sequel.synchronize{ASSOCIATION_TYPES[type]}
2040   raise(Error, 'Model.associate name argument must be a symbol') unless name.is_a?(Symbol)
2041 
2042   # dup early so we don't modify opts
2043   orig_opts = opts.dup
2044 
2045   if opts[:clone]
2046     cloned_assoc = association_reflection(opts[:clone])
2047     remove_class_name = orig_opts[:class] && !orig_opts[:class_name]
2048     orig_opts = cloned_assoc[:orig_opts].merge(orig_opts)
2049     orig_opts.delete(:class_name) if remove_class_name
2050   end
2051 
2052   opts = Hash[default_association_options]
2053   if type_options = default_association_type_options[type]
2054     opts.merge!(type_options)
2055   end
2056   opts.merge!(orig_opts)
2057   opts.merge!(:type => type, :name => name, :cache=>({} if cache_associations), :model => self)
2058 
2059   opts[:block] = block if block
2060   opts[:instance_specific] = true if orig_opts[:dataset]
2061   if !opts.has_key?(:instance_specific) && (block || orig_opts[:block])
2062     # It's possible the association is instance specific, in that it depends on
2063     # values other than the foreign key value.  This needs to be checked for
2064     # in certain places to disable optimizations.
2065     opts[:instance_specific] = _association_instance_specific_default(name)
2066   end
2067   if (orig_opts[:instance_specific] || orig_opts[:dataset]) && !opts.has_key?(:allow_eager) && !opts[:eager_loader]
2068     # For associations explicitly marked as instance specific, or that use the
2069     # :dataset option, where :allow_eager is not set, and no :eager_loader is
2070     # provided, disallow eager loading.  In these cases, eager loading is
2071     # unlikely to work.  This is not done for implicit setting of :instance_specific,
2072     # because implicit use is done by default for all associations with blocks,
2073     # and the vast majority of associations with blocks use the block for filtering
2074     # in a manner compatible with eager loading.
2075     opts[:allow_eager] = false
2076   end
2077   opts = assoc_class.new.merge!(opts)
2078 
2079   if opts[:clone] && !opts.cloneable?(cloned_assoc)
2080     raise(Error, "cannot clone an association to an association of different type (association #{name} with type #{type} cloning #{opts[:clone]} with type #{cloned_assoc[:type]})")
2081   end
2082 
2083   opts[:use_placeholder_loader] = !opts[:instance_specific] && !opts[:eager_graph] unless opts.include?(:use_placeholder_loader)
2084   opts[:eager_block] = opts[:block] unless opts.include?(:eager_block)
2085   opts[:graph_join_type] ||= :left_outer
2086   opts[:order_eager_graph] = true unless opts.include?(:order_eager_graph)
2087   conds = opts[:conditions]
2088   opts[:graph_alias_base] ||= name
2089   opts[:graph_conditions] = conds if !opts.include?(:graph_conditions) and Sequel.condition_specifier?(conds)
2090   opts[:graph_conditions] = opts.fetch(:graph_conditions, []).to_a
2091   opts[:graph_select] = Array(opts[:graph_select]) if opts[:graph_select]
2092   [:before_add, :before_remove, :after_add, :after_remove, :after_load, :before_set, :after_set].each do |cb_type|
2093     opts[cb_type] = Array(opts[cb_type]) if opts[cb_type]
2094   end
2095 
2096   if opts[:extend]
2097     opts[:extend] = Array(opts[:extend])
2098     opts[:reverse_extend] = opts[:extend].reverse
2099   end
2100 
2101   late_binding_class_option(opts, opts.returns_array? ? singularize(name) : name)
2102   
2103   # Remove :class entry if it exists and is nil, to work with cached_fetch
2104   opts.delete(:class) unless opts[:class]
2105 
2106   opts[:_hash] = [self, name].hash
2107 
2108   def_association(opts)
2109       
2110   orig_opts.delete(:clone)
2111   opts[:orig_class] = orig_opts[:class] || orig_opts[:class_name]
2112   orig_opts.merge!(:class_name=>opts[:class_name], :class=>opts[:class], :block=>opts[:block])
2113   opts[:orig_opts] = orig_opts
2114   # don't add to association_reflections until we are sure there are no errors
2115   association_reflections[name] = opts
2116 end

Associates a related model with the current model. The following types are supported:

:many_to_one: Foreign key in current model’s table points to associated model’s primary key. Each associated model object can be associated with more than one current model objects. Each current model object can be associated with only one associated model object.
:one_to_many: Foreign key in associated model’s table points to this model’s primary key. Each current model object can be associated with more than one associated model objects. Each associated model object can be associated with only one current model object.
:one_through_one: Similar to many_to_many in terms of foreign keys, but only one object is associated to the current object through the association. Provides only getter methods, no setter or modification methods.
:one_to_one: Similar to one_to_many in terms of foreign keys, but only one object is associated to the current object through the association. The methods created are similar to many_to_one, except that the one_to_one setter method saves the passed object.
:many_to_many: A join table is used that has a foreign key that points to this model’s primary key and a foreign key that points to the associated model’s primary key. Each current model object can be associated with many associated model objects, and each associated model object can be associated with many current model objects.

The following options can be supplied:

Multiple Types¶ ↑

:adder: Proc used to define the private add* method for doing the database work to associate the given object to the current object (*_to_many assocations). Set to nil to not define a add_* method for the association.
:after_add: Symbol, Proc, or array of both/either specifying a callback to call after a new item is added to the association.
:after_load: Symbol, Proc, or array of both/either specifying a callback to call after the associated record(s) have been retrieved from the database.
:after_remove: Symbol, Proc, or array of both/either specifying a callback to call after an item is removed from the association.
:after_set: Symbol, Proc, or array of both/either specifying a callback to call after an item is set using the association setter method.
:allow_eager: If set to false, you cannot load the association eagerly via eager or eager_graph
:allow_eager_graph: If set to false, you cannot load the association eagerly via eager_graph.
:allow_filtering_by: If set to false, you cannot use the association when filtering
:before_add: Symbol, Proc, or array of both/either specifying a callback to call before a new item is added to the association.
:before_remove: Symbol, Proc, or array of both/either specifying a callback to call before an item is removed from the association.
:before_set: Symbol, Proc, or array of both/either specifying a callback to call before an item is set using the association setter method.
:cartesian_product_number: the number of joins completed by this association that could cause more than one row for each row in the current table (default: 0 for many_to_one, one_to_one, and one_through_one associations, 1 for one_to_many and many_to_many associations).
:class: The associated class or its name as a string or symbol. If not given, uses the association’s name, which is camelized (and singularized unless the type is :many_to_one, :one_to_one, or one_through_one). If this is specified as a string or symbol, you must specify the full class name (e.g. “::SomeModule::MyModel”).
:class_namespace: If :class is given as a string or symbol, sets the default namespace in which to look for the class. class: 'Foo', class_namespace: 'Bar' looks for ::Bar::Foo.)
:clearer: Proc used to define the private remove_all* method for doing the database work to remove all objects associated to the current object (*_to_many assocations). Set to nil to not define a remove_all_* method for the association.
:clone: Merge the current options and block into the options and block used in defining the given association. Can be used to DRY up a bunch of similar associations that all share the same options such as :class and :key, while changing the order and block used.
:conditions: The conditions to use to filter the association, can be any argument passed to where. This option is not respected when using eager_graph or association_join, unless it is hash or array of two element arrays. Consider also specifying the :graph_block option if the value for this option is not a hash or array of two element arrays and you plan to use this association in eager_graph or association_join.
:dataset: A proc that is used to define the method to get the base dataset to use (before the other options are applied). If the proc accepts an argument, it is passed the related association reflection. It is a best practice to always have the dataset accept an argument and use the argument to return the appropriate dataset.
:distinct: Use the DISTINCT clause when selecting associating object, both when lazy loading and eager loading via .eager (but not when using .eager_graph).
:eager: The associations to eagerly load via eager when loading the associated object(s).
:eager_block: If given, use the block instead of the default block when eagerly loading. To not use a block when eager loading (when one is used normally), set to nil.
:eager_graph: The associations to eagerly load via eager_graph when loading the associated object(s). many_to_many associations with this option cannot be eagerly loaded via eager.
:eager_grapher: A proc to use to implement eager loading via eager_graph, overriding the default. Takes an options hash with at least the entries :self (the receiver of the eager_graph call), :table_alias (the alias to use for table to graph into the association), and :implicit_qualifier (the alias that was used for the current table). Should return a copy of the dataset with the association graphed into it.
:eager_limit_strategy: Determines the strategy used for enforcing limits and offsets when eager loading associations via the eager method.
:eager_loader: A proc to use to implement eager loading, overriding the default. Takes a single hash argument, with at least the keys: :rows, which is an array of current model instances, :associations, which is a hash of dependent associations, :self, which is the dataset doing the eager loading, :eager_block, which is a dynamic callback that should be called with the dataset, and :id_map, which is a mapping of key values to arrays of current model instances. In the proc, the associated records should be queried from the database and the associations cache for each record should be populated.
:eager_loader_key: A symbol for the key column to use to populate the key_hash for the eager loader. Can be set to nil to not populate the key_hash.
:eager_loading_predicate_transform: A callable object with which to transform the predicate key values used when eager loading. Called with two arguments, the array of predicate key values, and a the reflection for the association being eager loaded.
:extend: A module or array of modules to extend the dataset with.
:filter_limit_strategy: Determines the strategy used for enforcing limits and offsets when filtering by limited associations. Possible options are :window_function, :distinct_on, or :correlated_subquery depending on association type and database type.
:graph_alias_base: The base name to use for the table alias when eager graphing. Defaults to the name of the association. If the alias name has already been used in the query, Sequel will create a unique alias by appending a numeric suffix (e.g. alias_0, alias_1, …) until the alias is unique.
:graph_block: The block to pass to join_table when eagerly loading the association via eager_graph.
:graph_conditions: The additional conditions to use on the SQL join when eagerly loading the association via eager_graph. Should be a hash or an array of two element arrays. If not specified, the :conditions option is used if it is a hash or array of two element arrays.
:graph_join_type: The type of SQL join to use when eagerly loading the association via eager_graph. Defaults to :left_outer.
:graph_only_conditions: The conditions to use on the SQL join when eagerly loading the association via eager_graph, instead of the default conditions specified by the foreign/primary keys. This option causes the :graph_conditions option to be ignored.
:graph_order: the order to use when using eager_graph, instead of the default order. This should be used in the case where :order contains an identifier qualified by the table’s name, which may not match the alias used when eager graphing. By setting this to the unqualified identifier, it will be automatically qualified when using eager_graph.
:graph_select: A column or array of columns to select from the associated table when eagerly loading the association via eager_graph. Defaults to all columns in the associated table.
:graph_use_association_block: Makes eager_graph consider the association block. Without this, eager_graph ignores the bock and only use the :graph_* options.
:instance_specific: Marks the association as instance specific. Should be used if the association block uses instance specific state, or transient state (accessing current date/time, etc.).
:limit: Limit the number of records to the provided value. Use an array with two elements for the value to specify a limit (first element) and an offset (second element).
:methods_module: The module that methods the association creates will be placed into. Defaults to the module containing the model’s columns.
:no_association_method: Do not add a method for the association. This can save memory if the association method is never used.
:no_dataset_method: Do not add a method for the association dataset. This can save memory if the dataset method is never used.
:order: the column(s) by which to order the association dataset. Can be a singular column symbol or an array of column symbols.
:order_eager_graph: Whether to add the association’s order to the graphed dataset’s order when graphing via eager_graph. Defaults to true, so set to false to disable.
:read_only: Do not add a setter method (for many_to_one or one_to_one associations), or add_/remove_/remove_all_ methods (for one_to_many and many_to_many associations).
:reciprocal: the symbol name of the reciprocal association, if it exists. By default, Sequel will try to determine it by looking at the associated model’s assocations for a association that matches the current association’s key(s). Set to nil to not use a reciprocal.
:remover: Proc used to define the private remove* method for doing the database work to remove the association between the given object and the current object (*_to_many assocations). Set to nil to not define a remove_* method for the association.
:select: the columns to select. Defaults to the associated class’s table_name.* in an association that uses joins, which means it doesn’t include the attributes from the join table. If you want to include the join table attributes, you can use this option, but beware that the join table attributes can clash with attributes from the model table, so you should alias any attributes that have the same name in both the join table and the associated table.
:setter: Proc used to define the private _*= method for doing the work to setup the assocation between the given object and the current object (*_to_one associations). Set to nil to not define a setter method for the association.
:subqueries_per_union: The number of subqueries to use in each UNION query, for eager loading limited associations using the default :union strategy.
:use_placeholder_loader: Whether to use a placeholder loader when eager loading the association. Can be set to false to disable the use of a placeholder loader if one would be used by default.
:validate: Set to false to not validate when implicitly saving any associated object.

:many_to_one¶ ↑

:key: foreign key in current model’s table that references associated model’s primary key, as a symbol. Defaults to :“#{name}_id”. Can use an array of symbols for a composite key association.
:key_column: Similar to, and usually identical to, :key, but :key refers to the model method to call, where :key_column refers to the underlying column. Should only be used if the model method differs from the foreign key column, in conjunction with defining a model alias method for the key column.
:primary_key: column in the associated table that :key option references, as a symbol. Defaults to the primary key of the associated table. Can use an array of symbols for a composite key association.
:primary_key_method: the method symbol or array of method symbols to call on the associated object to get the foreign key values. Defaults to :primary_key option.
:qualify: Whether to use qualified primary keys when loading the association. The default is true, so you must set to false to not qualify. Qualification rarely causes problems, but it’s necessary to disable in some cases, such as when you are doing a JOIN USING operation on the column on Oracle.

:one_to_many and :one_to_one¶ ↑

:key: foreign key in associated model’s table that references current model’s primary key, as a symbol. Defaults to :“#{self.name.underscore}_id”. Can use an array of symbols for a composite key association.
:key_method: the method symbol or array of method symbols to call on the associated object to get the foreign key values. Defaults to :key option.
:primary_key: column in the current table that :key option references, as a symbol. Defaults to primary key of the current table. Can use an array of symbols for a composite key association.
:primary_key_column: Similar to, and usually identical to, :primary_key, but :primary_key refers to the model method call, where :primary_key_column refers to the underlying column. Should only be used if the model method differs from the primary key column, in conjunction with defining a model alias method for the primary key column.
:raise_on_save_failure: Do not raise exceptions for hook or validation failures when saving associated objects in the add/remove methods (return nil instead) [one_to_many only].

:many_to_many and :one_through_one¶ ↑

:graph_join_table_block: The block to pass to join_table for the join table when eagerly loading the association via eager_graph.
:graph_join_table_conditions: The additional conditions to use on the SQL join for the join table when eagerly loading the association via eager_graph. Should be a hash or an array of two element arrays.
:graph_join_table_join_type: The type of SQL join to use for the join table when eagerly loading the association via eager_graph. Defaults to the :graph_join_type option or :left_outer.
:graph_join_table_only_conditions: The conditions to use on the SQL join for the join table when eagerly loading the association via eager_graph, instead of the default conditions specified by the foreign/primary keys. This option causes the :graph_join_table_conditions option to be ignored.
:join_table: name of table that includes the foreign keys to both the current model and the associated model, as a symbol. Defaults to the name of current model and name of associated model, pluralized, underscored, sorted, and joined with ‘_’.
:join_table_block: proc that can be used to modify the dataset used in the add/remove/remove_all methods. Should accept a dataset argument and return a modified dataset if present.
:join_table_db: When retrieving records when using lazy loading or eager loading via eager, instead of a join between to the join table and the associated table, use a separate query for the join table using the given Database object.
:left_key: foreign key in join table that points to current model’s primary key, as a symbol. Defaults to :“#{self.name.underscore}_id”. Can use an array of symbols for a composite key association.
:left_primary_key: column in current table that :left_key points to, as a symbol. Defaults to primary key of current table. Can use an array of symbols for a composite key association.
:left_primary_key_column: Similar to, and usually identical to, :left_primary_key, but :left_primary_key refers to the model method to call, where :left_primary_key_column refers to the underlying column. Should only be used if the model method differs from the left primary key column, in conjunction with defining a model alias method for the left primary key column.
:right_key: foreign key in join table that points to associated model’s primary key, as a symbol. Defaults to :“#{name.to_s.singularize}_id”. Can use an array of symbols for a composite key association.
:right_primary_key: column in associated table that :right_key points to, as a symbol. Defaults to primary key of the associated table. Can use an array of symbols for a composite key association.
:right_primary_key_method: the method symbol or array of method symbols to call on the associated object to get the foreign key values for the join table. Defaults to :right_primary_key option.
:uniq: Adds a after_load callback that makes the array of objects unique.

association_reflection (name)

Source

     # File lib/sequel/model/associations.rb
2119 def association_reflection(name)
2120   association_reflections[name]
2121 end

The association reflection hash for the association of the given name.

associations ()

Source

     # File lib/sequel/model/associations.rb
2124 def associations
2125   association_reflections.keys
2126 end

Array of association name symbols

eager_load_results (opts, eo, &block)

Source

     # File lib/sequel/model/associations.rb
2129 def eager_load_results(opts, eo, &block)
2130   opts.eager_load_results(eo, &block)
2131 end

Eager load the association with the given eager loader options.

finalize_associations ()

Source

     # File lib/sequel/model/associations.rb
2148 def finalize_associations
2149   @association_reflections.each_value(&:finalize)
2150 end

Finalize all associations such that values that are looked up dynamically in associated classes are set statically. As this modifies the associations, it must be done before calling freeze.

freeze ()

Source

     # File lib/sequel/model/associations.rb
2134 def freeze
2135   @association_reflections.freeze.each_value(&:freeze)
2136   @autoreloading_associations.freeze.each_value(&:freeze)
2137   @default_association_options.freeze
2138   @default_association_type_options.freeze
2139   @default_association_type_options.each_value(&:freeze)
2140 
2141   super
2142 end

Freeze association related metadata when freezing model class.

Calls superclass method

many_to_many (name, opts=OPTS, &block)

Source

     # File lib/sequel/model/associations.rb
2153 def many_to_many(name, opts=OPTS, &block)
2154   associate(:many_to_many, name, opts, &block)
2155 end

Shortcut for adding a many_to_many association, see associate

many_to_one (name, opts=OPTS, &block)

Source

     # File lib/sequel/model/associations.rb
2158 def many_to_one(name, opts=OPTS, &block)
2159   associate(:many_to_one, name, opts, &block)
2160 end

Shortcut for adding a many_to_one association, see associate

one_through_one (name, opts=OPTS, &block)

Source

     # File lib/sequel/model/associations.rb
2163 def one_through_one(name, opts=OPTS, &block)
2164   associate(:one_through_one, name, opts, &block)
2165 end

Shortcut for adding a one_through_one association, see associate

one_to_many (name, opts=OPTS, &block)

Source

     # File lib/sequel/model/associations.rb
2168 def one_to_many(name, opts=OPTS, &block)
2169   associate(:one_to_many, name, opts, &block)
2170 end

Shortcut for adding a one_to_many association, see associate

one_to_one (name, opts=OPTS, &block)

Source

     # File lib/sequel/model/associations.rb
2173 def one_to_one(name, opts=OPTS, &block)
2174   associate(:one_to_one, name, opts, &block)
2175 end

Shortcut for adding a one_to_one association, see associate

Private Instance Methods

_association_instance_specific_default (_)

Source

     # File lib/sequel/model/associations.rb
2184 def _association_instance_specific_default(_)
2185   true
2186 end

The default value for the instance_specific option, if the association could be instance specific and the :instance_specific option is not specified.

association_module (opts=OPTS)

Source

     # File lib/sequel/model/associations.rb
2190 def association_module(opts=OPTS)
2191   opts.fetch(:methods_module, overridable_methods_module)
2192 end

The module to use for the association’s methods. Defaults to the overridable_methods_module.

association_module_def (name, opts=OPTS, &block)

Source

     # File lib/sequel/model/associations.rb
2197 def association_module_def(name, opts=OPTS, &block)
2198   mod = association_module(opts)
2199   mod.send(:define_method, name, &block)
2200   mod.send(:alias_method, name, name)
2201 end

Add a method to the module included in the class, so the method can be easily overridden in the class itself while allowing for super to be called.

association_module_delegate_def (name, opts, &block)

Source

     # File lib/sequel/model/associations.rb
2207 def association_module_delegate_def(name, opts, &block)
2208   mod = association_module(opts)
2209   mod.send(:define_method, name, &block)
2210   # :nocov:
2211   mod.send(:ruby2_keywords, name) if mod.respond_to?(:ruby2_keywords, true)
2212   # :nocov:
2213   mod.send(:alias_method, name, name)
2214 end

Add a method to the module included in the class, so the method can be easily overridden in the class itself while allowing for super to be called. This method allows passing keywords through the defined methods.

association_module_private_def (name, opts=OPTS, &block)

Source

     # File lib/sequel/model/associations.rb
2217 def association_module_private_def(name, opts=OPTS, &block)
2218   association_module_def(name, opts, &block)
2219   association_module(opts).send(:private, name)
2220 end

Add a private method to the module included in the class.

def_association (opts)

Source

     # File lib/sequel/model/associations.rb
2224 def def_association(opts)
2225   send(:"def_#{opts[:type]}", opts)
2226   def_association_instance_methods(opts)
2227 end

Delegate to the type-specific association method to setup the association, and define the association instance methods.

def_association_instance_methods (opts)

Source

     # File lib/sequel/model/associations.rb
2237 def def_association_instance_methods(opts)
2238   # Always set the method names in the association reflection, even if they
2239   # are not used, for backwards compatibility.
2240   opts[:dataset_method] = :"#{opts[:name]}_dataset"
2241   if opts.returns_array?
2242     sname = singularize(opts[:name])
2243     opts[:_add_method] = :"_add_#{sname}"
2244     opts[:add_method] = :"add_#{sname}"
2245     opts[:_remove_method] = :"_remove_#{sname}"
2246     opts[:remove_method] = :"remove_#{sname}"
2247     opts[:_remove_all_method] = :"_remove_all_#{opts[:name]}"
2248     opts[:remove_all_method] = :"remove_all_#{opts[:name]}"
2249   else
2250     opts[:_setter_method] = :"_#{opts[:name]}="
2251     opts[:setter_method] = :"#{opts[:name]}="
2252   end
2253 
2254   association_module_def(opts.dataset_method, opts){_dataset(opts)} unless opts[:no_dataset_method]
2255   if opts[:block]
2256     opts[:block_method] = Plugins.def_sequel_method(association_module(opts), "#{opts[:name]}_block", 1, &opts[:block])
2257   end
2258   opts[:dataset_opt_arity] = opts[:dataset].arity == 0 ? 0 : 1
2259   opts[:dataset_opt_method] = Plugins.def_sequel_method(association_module(opts), "#{opts[:name]}_dataset_opt", opts[:dataset_opt_arity], &opts[:dataset])
2260   def_association_method(opts) unless opts[:no_association_method]
2261 
2262   return if opts[:read_only]
2263 
2264   if opts[:setter] && opts[:_setter]
2265     # This is backwards due to backwards compatibility
2266     association_module_private_def(opts[:_setter_method], opts, &opts[:setter])
2267     association_module_def(opts[:setter_method], opts, &opts[:_setter])
2268   end
2269 
2270   if adder = opts[:adder]
2271     association_module_private_def(opts[:_add_method], opts, &adder)
2272     association_module_delegate_def(opts[:add_method], opts){|o,*args| add_associated_object(opts, o, *args)}
2273   end
2274 
2275   if remover = opts[:remover]
2276     association_module_private_def(opts[:_remove_method], opts, &remover)
2277     association_module_delegate_def(opts[:remove_method], opts){|o,*args| remove_associated_object(opts, o, *args)}
2278   end
2279 
2280   if clearer = opts[:clearer]
2281     association_module_private_def(opts[:_remove_all_method], opts, &clearer)
2282     association_module_delegate_def(opts[:remove_all_method], opts){|*args| remove_all_associated_objects(opts, *args)}
2283   end
2284 end

Define all of the association instance methods for this association.

def_association_method (opts)

Source

     # File lib/sequel/model/associations.rb
2230 def def_association_method(opts)
2231   association_module_def(opts.association_method, opts) do |dynamic_opts=OPTS, &block|
2232     load_associated_objects(opts, dynamic_opts, &block)
2233   end
2234 end

Adds the association method to the association methods module.

def_many_to_many (opts)

Source

     # File lib/sequel/model/associations.rb
2287 def def_many_to_many(opts)
2288   one_through_one = opts[:type] == :one_through_one
2289   left = (opts[:left_key] ||= opts.default_left_key)
2290   lcks = opts[:left_keys] = Array(left)
2291   right = (opts[:right_key] ||= opts.default_right_key)
2292   rcks = opts[:right_keys] = Array(right)
2293   left_pk = (opts[:left_primary_key] ||= self.primary_key)
2294   opts[:eager_loader_key] = left_pk unless opts.has_key?(:eager_loader_key)
2295   lcpks = opts[:left_primary_keys] = Array(left_pk)
2296   lpkc = opts[:left_primary_key_column] ||= left_pk
2297   lpkcs = opts[:left_primary_key_columns] ||= Array(lpkc)
2298   raise(Error, "mismatched number of left keys: #{lcks.inspect} vs #{lcpks.inspect}") unless lcks.length == lcpks.length
2299   if opts[:right_primary_key]
2300     rcpks = Array(opts[:right_primary_key])
2301     raise(Error, "mismatched number of right keys: #{rcks.inspect} vs #{rcpks.inspect}") unless rcks.length == rcpks.length
2302   end
2303   opts[:uses_left_composite_keys] = lcks.length > 1
2304   uses_rcks = opts[:uses_right_composite_keys] = rcks.length > 1
2305   opts[:cartesian_product_number] ||= one_through_one ? 0 : 1
2306   join_table = (opts[:join_table] ||= opts.default_join_table)
2307   opts[:left_key_alias] ||= opts.default_associated_key_alias
2308   opts[:graph_join_table_join_type] ||= opts[:graph_join_type]
2309   if opts[:uniq]
2310     opts[:after_load] ||= []
2311     opts[:after_load].unshift(:array_uniq!)
2312   end
2313   if join_table_db = opts[:join_table_db]
2314     opts[:use_placeholder_loader] = false
2315     opts[:allow_eager_graph] = false
2316     opts[:allow_filtering_by] = false
2317     opts[:eager_limit_strategy] = nil
2318     join_table_ds = join_table_db.from(join_table)
2319     opts[:dataset] ||= proc do |r|
2320       vals = join_table_ds.where(lcks.zip(lcpks.map{|k| get_column_value(k)})).select_map(right)
2321       ds = r.associated_dataset.where(opts.right_primary_key => vals)
2322       if uses_rcks
2323         vals.delete_if{|v| v.any?(&:nil?)}
2324       else
2325         vals.delete(nil)
2326       end
2327       ds = ds.clone(:no_results=>true) if vals.empty?
2328       ds
2329     end
2330     opts[:eager_loader] ||= proc do |eo|
2331       h = eo[:id_map]
2332       assign_singular = opts.assign_singular?
2333       rpk = opts.right_primary_key
2334       name = opts[:name]
2335 
2336       join_map = join_table_ds.where(left=>h.keys).select_hash_groups(right, left)
2337 
2338       if uses_rcks
2339         join_map.delete_if{|v,| v.any?(&:nil?)}
2340       else
2341         join_map.delete(nil)
2342       end
2343 
2344       eo = Hash[eo]
2345 
2346       if join_map.empty?
2347         eo[:no_results] = true
2348       else
2349         join_map.each_value do |vs|
2350           vs.replace(vs.flat_map{|v| h[v]})
2351           vs.uniq!
2352         end
2353 
2354         eo[:loader] = false
2355         eo[:right_keys] = join_map.keys
2356       end
2357 
2358       opts[:model].eager_load_results(opts, eo) do |assoc_record|
2359         rpkv = if uses_rcks
2360           assoc_record.values.values_at(*rpk)
2361         else
2362           assoc_record.values[rpk]
2363         end
2364 
2365         objects = join_map[rpkv]
2366 
2367         if assign_singular
2368           objects.each do |object|
2369             object.associations[name] ||= assoc_record
2370           end
2371         else
2372           objects.each do |object|
2373             object.associations[name].push(assoc_record)
2374           end
2375         end
2376       end
2377     end
2378   else
2379     opts[:dataset] ||= opts.association_dataset_proc
2380     opts[:eager_loader] ||= opts.method(:default_eager_loader)
2381   end
2382   
2383   join_type = opts[:graph_join_type]
2384   select = opts[:graph_select]
2385   use_only_conditions = opts.include?(:graph_only_conditions)
2386   only_conditions = opts[:graph_only_conditions]
2387   conditions = opts[:graph_conditions]
2388   graph_block = opts[:graph_block]
2389   graph_jt_conds = opts[:graph_join_table_conditions] = opts.fetch(:graph_join_table_conditions, []).to_a
2390   use_jt_only_conditions = opts.include?(:graph_join_table_only_conditions)
2391   jt_only_conditions = opts[:graph_join_table_only_conditions]
2392   jt_join_type = opts[:graph_join_table_join_type]
2393   jt_graph_block = opts[:graph_join_table_block]
2394   opts[:eager_grapher] ||= proc do |eo|
2395     ds = eo[:self]
2396     egls = eo[:limit_strategy]
2397     if egls && egls != :ruby
2398       associated_key_array = opts.associated_key_array
2399       orig_egds = egds = eager_graph_dataset(opts, eo)
2400       egds = egds.
2401         inner_join(join_table, rcks.zip(opts.right_primary_keys) + graph_jt_conds, :qualify=>:deep).
2402         select_all(egds.first_source).
2403         select_append(*associated_key_array)
2404       egds = opts.apply_eager_graph_limit_strategy(egls, egds)
2405       ds.graph(egds, associated_key_array.map(&:alias).zip(lpkcs) + conditions, :qualify=>:deep, :table_alias=>eo[:table_alias], :implicit_qualifier=>eo[:implicit_qualifier], :join_type=>eo[:join_type]||join_type, :from_self_alias=>eo[:from_self_alias], :join_only=>eo[:join_only], :select=>select||orig_egds.columns, &graph_block)
2406     else
2407       ds = ds.graph(join_table, use_jt_only_conditions ? jt_only_conditions : lcks.zip(lpkcs) + graph_jt_conds, :select=>false, :table_alias=>ds.unused_table_alias(join_table, [eo[:table_alias]]), :join_type=>eo[:join_type]||jt_join_type, :join_only=>eo[:join_only], :implicit_qualifier=>eo[:implicit_qualifier], :qualify=>:deep, :from_self_alias=>eo[:from_self_alias], &jt_graph_block)
2408       ds.graph(eager_graph_dataset(opts, eo), use_only_conditions ? only_conditions : opts.right_primary_keys.zip(rcks) + conditions, :select=>select, :table_alias=>eo[:table_alias], :qualify=>:deep, :join_type=>eo[:join_type]||join_type, :join_only=>eo[:join_only], &graph_block)
2409     end
2410   end
2411       
2412   return if opts[:read_only]
2413       
2414   if one_through_one
2415     unless opts.has_key?(:setter)
2416       opts[:setter] = proc do |o|
2417         h = {}
2418         lh = lcks.zip(lcpks.map{|k| get_column_value(k)})
2419         jtds = _join_table_dataset(opts).where(lh)
2420 
2421         checked_transaction do
2422           current = jtds.first
2423 
2424           if o
2425             new_values = []
2426             rcks.zip(opts.right_primary_key_methods).each{|k, pk| new_values << (h[k] = o.get_column_value(pk))}
2427           end
2428 
2429           if current
2430             current_values = rcks.map{|k| current[k]}
2431             jtds = jtds.where(rcks.zip(current_values))
2432             if o
2433               if current_values != new_values
2434                 jtds.update(h)
2435               end
2436             else
2437               jtds.delete
2438             end
2439           elsif o
2440             lh.each{|k,v| h[k] = v}
2441             jtds.insert(h)
2442           end
2443         end
2444       end
2445     end
2446     if opts.fetch(:setter, true)
2447       opts[:_setter] = proc{|o| set_one_through_one_associated_object(opts, o)}
2448     end
2449   else 
2450     unless opts.has_key?(:adder)
2451       opts[:adder] = proc do |o|
2452         h = {}
2453         lcks.zip(lcpks).each{|k, pk| h[k] = get_column_value(pk)}
2454         rcks.zip(opts.right_primary_key_methods).each{|k, pk| h[k] = o.get_column_value(pk)}
2455         _join_table_dataset(opts).insert(h)
2456       end
2457     end
2458 
2459     unless opts.has_key?(:remover)
2460       opts[:remover] = proc do |o|
2461         _join_table_dataset(opts).where(lcks.zip(lcpks.map{|k| get_column_value(k)}) + rcks.zip(opts.right_primary_key_methods.map{|k| o.get_column_value(k)})).delete
2462       end
2463     end
2464 
2465     unless opts.has_key?(:clearer)
2466       opts[:clearer] = proc do
2467         _join_table_dataset(opts).where(lcks.zip(lcpks.map{|k| get_column_value(k)})).delete
2468       end
2469     end
2470   end
2471 end

Configures many_to_many and one_through_one association reflection and adds the related association methods

def_many_to_one (opts)

Source

     # File lib/sequel/model/associations.rb
2474 def def_many_to_one(opts)
2475   name = opts[:name]
2476   opts[:key] = opts.default_key unless opts.has_key?(:key)
2477   key = opts[:key]
2478   opts[:eager_loader_key] = key unless opts.has_key?(:eager_loader_key)
2479   cks = opts[:graph_keys] = opts[:keys] = Array(key)
2480   opts[:key_column] ||= key
2481   opts[:graph_keys] = opts[:key_columns] = Array(opts[:key_column])
2482   opts[:qualified_key] = opts.qualify_cur(key)
2483   if opts[:primary_key]
2484     cpks = Array(opts[:primary_key])
2485     raise(Error, "mismatched number of keys: #{cks.inspect} vs #{cpks.inspect}") unless cks.length == cpks.length
2486   end
2487   uses_cks = opts[:uses_composite_keys] = cks.length > 1
2488   opts[:cartesian_product_number] ||= 0
2489 
2490   if !opts.has_key?(:many_to_one_pk_lookup) &&
2491      (opts[:dataset] || opts[:conditions] || opts[:block] || opts[:select] ||
2492       (opts.has_key?(:key) && opts[:key] == nil))
2493     opts[:many_to_one_pk_lookup] = false
2494   end
2495   auto_assocs = @autoreloading_associations
2496   cks.each do |k|
2497     (auto_assocs[k] ||= []) << name
2498   end
2499 
2500   opts[:dataset] ||= opts.association_dataset_proc
2501   opts[:eager_loader] ||= proc do |eo|
2502     h = eo[:id_map]
2503     pk_meths = opts.primary_key_methods
2504 
2505     eager_load_results(opts, eo) do |assoc_record|
2506       hash_key = uses_cks ? pk_meths.map{|k| assoc_record.get_column_value(k)} : assoc_record.get_column_value(opts.primary_key_method)
2507       h[hash_key].each{|object| object.associations[name] = assoc_record}
2508     end
2509   end
2510       
2511   join_type = opts[:graph_join_type]
2512   select = opts[:graph_select]
2513   use_only_conditions = opts.include?(:graph_only_conditions)
2514   only_conditions = opts[:graph_only_conditions]
2515   conditions = opts[:graph_conditions]
2516   graph_block = opts[:graph_block]
2517   graph_cks = opts[:graph_keys]
2518   opts[:eager_grapher] ||= proc do |eo|
2519     ds = eo[:self]
2520     ds.graph(eager_graph_dataset(opts, eo), use_only_conditions ? only_conditions : opts.primary_keys.zip(graph_cks) + conditions, eo.merge(:select=>select, :join_type=>eo[:join_type]||join_type, :qualify=>:deep), &graph_block)
2521   end
2522       
2523   return if opts[:read_only]
2524       
2525   unless opts.has_key?(:setter)
2526     opts[:setter] = proc{|o| cks.zip(opts.primary_key_methods).each{|k, pk| set_column_value(:"#{k}=", (o.get_column_value(pk) if o))}}
2527   end
2528   if opts.fetch(:setter, true)
2529     opts[:_setter] = proc{|o| set_associated_object(opts, o)}
2530   end
2531 end

Configures many_to_one association reflection and adds the related association methods

def_one_through_one (opts)

Source

     # File lib/sequel/model/associations.rb
2660 def def_one_through_one(opts)
2661   def_many_to_many(opts)
2662 end

Alias of def_many_to_many, since they share pretty much the same code.

def_one_to_many (opts)

Source

     # File lib/sequel/model/associations.rb
2534 def def_one_to_many(opts)
2535   one_to_one = opts[:type] == :one_to_one
2536   name = opts[:name]
2537   key = (opts[:key] ||= opts.default_key)
2538   km = opts[:key_method] ||= opts[:key]
2539   cks = opts[:keys] = Array(key)
2540   opts[:key_methods] = Array(opts[:key_method])
2541   primary_key = (opts[:primary_key] ||= self.primary_key)
2542   opts[:eager_loader_key] = primary_key unless opts.has_key?(:eager_loader_key)
2543   cpks = opts[:primary_keys] = Array(primary_key)
2544   pkc = opts[:primary_key_column] ||= primary_key
2545   pkcs = opts[:primary_key_columns] ||= Array(pkc)
2546   raise(Error, "mismatched number of keys: #{cks.inspect} vs #{cpks.inspect}") unless cks.length == cpks.length
2547   uses_cks = opts[:uses_composite_keys] = cks.length > 1
2548   opts[:dataset] ||= opts.association_dataset_proc
2549   opts[:eager_loader] ||= proc do |eo|
2550     h = eo[:id_map]
2551     reciprocal = opts.reciprocal
2552     assign_singular = opts.assign_singular?
2553     delete_rn = opts.delete_row_number_column
2554 
2555     eager_load_results(opts, eo) do |assoc_record|
2556       assoc_record.remove_key!(delete_rn) if delete_rn
2557       hash_key = uses_cks ? km.map{|k| assoc_record.get_column_value(k)} : assoc_record.get_column_value(km)
2558       objects = h[hash_key]
2559       if assign_singular
2560         objects.each do |object| 
2561           unless object.associations[name]
2562             object.associations[name] = assoc_record
2563             assoc_record.associations[reciprocal] = object if reciprocal
2564           end
2565         end
2566       else
2567         objects.each do |object| 
2568           object.associations[name].push(assoc_record)
2569           assoc_record.associations[reciprocal] = object if reciprocal
2570         end
2571       end
2572     end
2573   end
2574   
2575   join_type = opts[:graph_join_type]
2576   select = opts[:graph_select]
2577   use_only_conditions = opts.include?(:graph_only_conditions)
2578   only_conditions = opts[:graph_only_conditions]
2579   conditions = opts[:graph_conditions]
2580   opts[:cartesian_product_number] ||= one_to_one ? 0 : 1
2581   graph_block = opts[:graph_block]
2582   graph_conditions = opts[:_graph_conditions] = use_only_conditions ? only_conditions : cks.zip(pkcs) + conditions
2583   opts[:eager_grapher] ||= proc do |eo|
2584     ds = eo[:self]
2585     graph_limit_strategy = eo[:limit_strategy]
2586     egds = opts.apply_eager_graph_limit_strategy(graph_limit_strategy, eager_graph_dataset(opts, eo))
2587     graph_conditions_true = true if graph_limit_strategy == :lateral_subquery
2588 
2589     ds = ds.graph(egds, graph_conditions_true || graph_conditions, eo.merge(:select=>select, :join_type=>eo[:join_type]||join_type, :qualify=>:deep), &graph_block)
2590     # We only load reciprocals for one_to_many associations, as other reciprocals don't make sense
2591     ds.opts[:eager_graph][:reciprocals][eo[:table_alias]] = opts.reciprocal
2592     ds
2593   end
2594       
2595   return if opts[:read_only]
2596 
2597   save_opts = {:validate=>opts[:validate]}
2598   ck_nil_hash ={}
2599   cks.each{|k| ck_nil_hash[k] = nil}
2600 
2601   if one_to_one
2602     unless opts.has_key?(:setter)
2603       opts[:setter] = proc do |o|
2604         up_ds = _apply_association_options(opts, opts.associated_dataset.where(cks.zip(cpks.map{|k| get_column_value(k)})))
2605 
2606         if (froms = up_ds.opts[:from]) && (from = froms[0]) && (from.is_a?(Sequel::Dataset) || (from.is_a?(Sequel::SQL::AliasedExpression) && from.expression.is_a?(Sequel::Dataset)))
2607           if old = up_ds.first
2608             cks.each{|k| old.set_column_value(:"#{k}=", nil)}
2609           end
2610           save_old = true
2611         end
2612 
2613         if o
2614           if !o.new? && !save_old
2615             up_ds = up_ds.exclude(o.pk_hash)
2616           end
2617           cks.zip(cpks).each{|k, pk| o.set_column_value(:"#{k}=", get_column_value(pk))}
2618         end
2619 
2620         checked_transaction do
2621           if save_old
2622             old.save(save_opts) || raise(Sequel::Error, "invalid previously associated object, cannot save") if old
2623           else
2624             up_ds.skip_limit_check.update(ck_nil_hash)
2625           end
2626 
2627           o.save(save_opts) || raise(Sequel::Error, "invalid associated object, cannot save") if o
2628         end
2629       end
2630     end
2631     if opts.fetch(:setter, true)
2632       opts[:_setter] = proc{|o| set_one_to_one_associated_object(opts, o)}
2633     end
2634   else 
2635     save_opts[:raise_on_failure] = opts[:raise_on_save_failure] != false
2636 
2637     unless opts.has_key?(:adder)
2638       opts[:adder] = proc do |o|
2639         cks.zip(cpks).each{|k, pk| o.set_column_value(:"#{k}=", get_column_value(pk))}
2640         o.save(save_opts)
2641       end
2642     end
2643     
2644     unless opts.has_key?(:remover)
2645       opts[:remover] = proc do |o|
2646         cks.each{|k| o.set_column_value(:"#{k}=", nil)}
2647         o.save(save_opts)
2648       end
2649     end
2650 
2651     unless opts.has_key?(:clearer)
2652       opts[:clearer] = proc do
2653         _apply_association_options(opts, opts.associated_dataset.where(cks.zip(cpks.map{|k| get_column_value(k)}))).update(ck_nil_hash)
2654       end
2655     end
2656   end
2657 end

Configures one_to_many and one_to_one association reflections and adds the related association methods

def_one_to_one (opts)

Source

     # File lib/sequel/model/associations.rb
2665 def def_one_to_one(opts)
2666   def_one_to_many(opts)
2667 end

Alias of def_one_to_many, since they share pretty much the same code.

eager_graph_dataset (opts, eager_options)

Source

     # File lib/sequel/model/associations.rb
2670 def eager_graph_dataset(opts, eager_options)
2671   ds = opts.associated_class.dataset
2672   if eager_options[:limit_strategy] == :lateral_subquery
2673     ds = ds.clone(:eager_options=>eager_options)
2674   end
2675   if opts[:graph_use_association_block] && (b = opts[:block])
2676     ds = b.call(ds)
2677   end
2678   if cb = eager_options[:callback]
2679     ds = cb.call(ds)
2680   end
2681   ds
2682 end

Return dataset to graph into given the association reflection, applying the :callback option if set.

reload_db_schema? ()

Source

     # File lib/sequel/model/associations.rb
2686 def reload_db_schema?
2687   !@cache_associations
2688 end

If not caching associations, reload the database schema by default, ignoring any cached values.