class Sequel::Model::Associations::OneToManyAssociationReflection

Constants

FINALIZE_SETTINGS

Public Instance Methods

apply_eager_graph_limit_strategy(strategy, ds) click to toggle source

Support a correlated subquery limit strategy when using eager_graph.

    # File lib/sequel/model/associations.rb
964 def apply_eager_graph_limit_strategy(strategy, ds)
965   case strategy
966   when :correlated_subquery
967     apply_correlated_subquery_limit_strategy(ds)
968   else
969     super
970   end
971 end
associated_object_keys() click to toggle source

The keys in the associated model's table related to this association

    # File lib/sequel/model/associations.rb
974 def associated_object_keys
975   self[:keys]
976 end
can_have_associated_objects?(obj) click to toggle source

one_to_many associations can only have associated objects if none of the :keys options have a nil value.

    # File lib/sequel/model/associations.rb
980 def can_have_associated_objects?(obj)
981   !self[:primary_keys].any?{|k| obj.get_column_value(k).nil?}
982 end
cloneable?(ref) click to toggle source

one_to_many and one_to_one associations can be clones

    # File lib/sequel/model/associations.rb
985 def cloneable?(ref)
986   ref[:type] == :one_to_many || ref[:type] == :one_to_one
987 end
default_key() click to toggle source

Default foreign key name symbol for key in associated table that points to current table's primary key.

    # File lib/sequel/model/associations.rb
991 def default_key
992   :"#{underscore(demodulize(self[:model].name))}_id"
993 end
finalize_settings() click to toggle source
     # File lib/sequel/model/associations.rb
 998 def finalize_settings
 999   FINALIZE_SETTINGS
1000 end
handle_silent_modification_failure?() click to toggle source

Handle silent failure of add/remove methods if raise_on_save_failure is false.

     # File lib/sequel/model/associations.rb
1003 def handle_silent_modification_failure?
1004   self[:raise_on_save_failure] == false
1005 end
predicate_key() click to toggle source

The hash key to use for the eager loading predicate (left side of IN (1, 2, 3))

     # File lib/sequel/model/associations.rb
1008 def predicate_key
1009   cached_fetch(:predicate_key){qualify_assoc(self[:key])}
1010 end
Also aliased as: qualified_key
primary_key() click to toggle source

The column in the current table that the key in the associated table references.

     # File lib/sequel/model/associations.rb
1014 def primary_key
1015   self[:primary_key]
1016 end
qualified_key()
Alias for: predicate_key
qualified_primary_key() click to toggle source

primary_key qualified by the current table

     # File lib/sequel/model/associations.rb
1019 def qualified_primary_key
1020   cached_fetch(:qualified_primary_key){qualify_cur(primary_key)}
1021 end
reciprocal_array?() click to toggle source

Whether the reciprocal of this association returns an array of objects instead of a single object, false for a one_to_many association.

     # File lib/sequel/model/associations.rb
1025 def reciprocal_array?
1026   false
1027 end
remove_before_destroy?() click to toggle source

Destroying one_to_many associated objects automatically deletes the foreign key.

     # File lib/sequel/model/associations.rb
1030 def remove_before_destroy?
1031   false
1032 end
remove_should_check_existing?() click to toggle source

The one_to_many association needs to check that an object to be removed already is associated.

     # File lib/sequel/model/associations.rb
1035 def remove_should_check_existing?
1036   true
1037 end
set_reciprocal_to_self?() click to toggle source

One to many associations set the reciprocal to self when loading associated records.

     # File lib/sequel/model/associations.rb
1040 def set_reciprocal_to_self?
1041   true
1042 end

Private Instance Methods

apply_correlated_subquery_limit_strategy(ds) click to toggle source

Use a correlated subquery to limit the dataset. Note that this will not work correctly if the associated dataset uses qualified identifers in the WHERE clause, as they would reference the containing query instead of the subquery.

     # File lib/sequel/model/associations.rb
1049 def apply_correlated_subquery_limit_strategy(ds)
1050   table = ds.first_source_table
1051   table_alias = ds.first_source_alias
1052   primary_key = associated_class.primary_key
1053   key = self[:key]
1054   cs_alias = :t1
1055   cs = associated_dataset.
1056     from(Sequel.as(table, :t1)).
1057     select(*qualify(cs_alias, primary_key)).
1058     where(Array(qualify(cs_alias, key)).zip(Array(qualify(table_alias, key)))).
1059     limit(*limit_and_offset)
1060   ds.where(qualify(table_alias, primary_key)=>cs)
1061 end
apply_filter_by_associations_limit_strategy(ds) click to toggle source

Support correlated subquery strategy when filtering by limited associations.

     # File lib/sequel/model/associations.rb
1064 def apply_filter_by_associations_limit_strategy(ds)
1065   case filter_by_associations_limit_strategy
1066   when :correlated_subquery
1067     apply_correlated_subquery_limit_strategy(ds)
1068   else
1069     super
1070   end
1071 end
filter_by_associations_conditions_associated_keys() click to toggle source
     # File lib/sequel/model/associations.rb
1073 def filter_by_associations_conditions_associated_keys
1074   qualify(associated_class.table_name, self[:keys])
1075 end
filter_by_associations_conditions_key() click to toggle source
     # File lib/sequel/model/associations.rb
1077 def filter_by_associations_conditions_key
1078   qualify(self[:model].table_name, self[:primary_key_column])
1079 end
filter_by_associations_limit_alias_key() click to toggle source
     # File lib/sequel/model/associations.rb
1081 def filter_by_associations_limit_alias_key
1082   Array(filter_by_associations_limit_key)
1083 end
filter_by_associations_limit_aliases() click to toggle source
     # File lib/sequel/model/associations.rb
1085 def filter_by_associations_limit_aliases
1086   filter_by_associations_limit_alias_key.map(&:column)
1087 end
filter_by_associations_limit_key() click to toggle source
     # File lib/sequel/model/associations.rb
1089 def filter_by_associations_limit_key
1090   qualify(associated_class.table_name, associated_class.primary_key)
1091 end
predicate_key_methods() click to toggle source
     # File lib/sequel/model/associations.rb
1093 def predicate_key_methods
1094   self[:primary_keys]
1095 end
reciprocal_association?(assoc_reflect) click to toggle source
     # File lib/sequel/model/associations.rb
1097 def reciprocal_association?(assoc_reflect)
1098   super && self[:keys] == assoc_reflect[:keys] && primary_key == assoc_reflect.primary_key
1099 end
reciprocal_type() click to toggle source

The reciprocal type of a one_to_many association is a many_to_one association.

     # File lib/sequel/model/associations.rb
1102 def reciprocal_type
1103   :many_to_one
1104 end
true_eager_graph_limit_strategy() click to toggle source

Support automatic use of correlated subqueries if :ruby option is best available option, the database supports them, and either the associated class has a non-composite primary key or the database supports multiple columns in IN.

     # File lib/sequel/model/associations.rb
1109 def true_eager_graph_limit_strategy
1110   r = super
1111   ds = associated_dataset
1112   if r == :ruby && ds.supports_limits_in_correlated_subqueries? && (Array(associated_class.primary_key).length == 1 || ds.supports_multiple_column_in?) && (!offset || ds.supports_offsets_in_correlated_subqueries?)
1113     :correlated_subquery
1114   else
1115     r
1116   end
1117 end