class Sequel::Model::Associations::ManyToOneAssociationReflection

def ambiguous_reciprocal_type?

and which is not known in advance.
Reciprocals of many_to_one associations could be either one_to_many or one_to_one, 
def ambiguous_reciprocal_type?
  true
end

def can_have_associated_objects?(obj)

the :keys options have a nil value.
many_to_one associations can only have associated objects if none of 
def can_have_associated_objects?(obj)
  !self[:keys].any?{|k| obj.get_column_value(k).nil?}
end

def dataset_need_primary_key?

Whether the dataset needs a primary key to function, false for many_to_one associations. 
def dataset_need_primary_key?
  false
end

def default_key

the given association's table's primary key.
Default foreign key name symbol for foreign key in current model's table that points to 
def default_key
  :"#{self[:name]}_id"
end

def eager_graph_lazy_dataset?

only if the key is nil.
Whether to eagerly graph a lazy dataset, true for many_to_one associations 
def eager_graph_lazy_dataset?
  self[:key].nil?
end

def eager_graph_limit_strategy(_)

many_to_one associations don't need an eager_graph limit strategy 
def eager_graph_limit_strategy(_)
  nil
end

def eager_limit_strategy

many_to_one associations don't need an eager limit strategy 
def eager_limit_strategy
  nil
end

def filter_by_associations_conditions_associated_keys 

def filter_by_associations_conditions_associated_keys
  qualify(associated_class.table_name, primary_keys)
end

def filter_by_associations_conditions_key 

def filter_by_associations_conditions_key
  qualify(self[:model].table_name, self[:key_column])
end

def filter_by_associations_limit_strategy

many_to_one associations don't need a filter by associations limit strategy 
def filter_by_associations_limit_strategy
  nil
end

def finalize_settings 

def finalize_settings
  FINALIZE_SETTINGS
end

def limit_to_single_row?

explicitly do not have a key.
many_to_one associations do not need to be limited to a single row if they 
def limit_to_single_row?
  super && self[:key]
end

def possible_reciprocal_types

a one_to_many or a one_to_one association.
The reciprocal type of a many_to_one association is either 
def possible_reciprocal_types
  [:one_to_many, :one_to_one]
end

def predicate_key

The expression to use on the left hand side of the IN lookup when eager loading 
def predicate_key
  cached_fetch(:predicate_key){qualified_primary_key}
end

def predicate_key_methods 

def predicate_key_methods
  self[:keys]
end

def primary_key

The column(s) in the associated table that the key in the current table references (either a symbol or an array). 
def primary_key
 cached_fetch(:primary_key){associated_class.primary_key || raise(Error, "no primary key specified for #{associated_class.inspect}")}
end

def primary_key_method

to get the value to use for the foreign keys.
The method symbol or array of method symbols to call on the associated object 
def primary_key_method
 cached_fetch(:primary_key_method){primary_key}
end

def primary_key_methods

to get the value to use for the foreign keys.
The array of method symbols to call on the associated object 
def primary_key_methods
 cached_fetch(:primary_key_methods){Array(primary_key_method)}
end

def primary_keys

The columns in the associated table that the key in the current table references (always an array). 
def primary_keys
 cached_fetch(:primary_keys){Array(primary_key)}
end

def qualified_primary_key

#primary_key qualified by the associated table 
def qualified_primary_key
  cached_fetch(:qualified_primary_key){self[:qualify] == false ? primary_key : qualify_assoc(primary_key)}
end

def reciprocal_array?

True only if the reciprocal is a one_to_many association. 
def reciprocal_array?
  !set_reciprocal_to_self?
end

def reciprocal_association?(assoc_reflect)

Whether the given association reflection is possible reciprocal 
def reciprocal_association?(assoc_reflect)
  super && self[:keys] == assoc_reflect[:keys] && primary_key == assoc_reflect.primary_key
end

def reciprocal_type

to try to figure out which.
a one_to_many or a one_to_one association, look in the associated class
The reciprocal type of a many_to_one association is either 
def reciprocal_type
  cached_fetch(:reciprocal_type) do
    possible_recips = []
    associated_class.all_association_reflections.each do |assoc_reflect|
      if reciprocal_association?(assoc_reflect)
        possible_recips << assoc_reflect
      end
    end
    if possible_recips.length == 1
      possible_recips.first[:type]
    else
      possible_reciprocal_types
    end
  end
end

def returns_array?

false for a many_to_one association.
Whether this association returns an array of objects instead of a single object, 
def returns_array?
  false
end

def set_reciprocal_to_self?

True only if the reciprocal is a one_to_one association. 
def set_reciprocal_to_self?
  reciprocal
  reciprocal_type == :one_to_one
end