### Home Classes Methods

### In Files

- lib/sequel/model/associations.rb

### Parent

Hash

### Methods

- #_add_method
- #_remove_all_method
- #_remove_method
- #_setter_method
- #add_method
- #apply_dataset_changes
- #apply_distinct_on_eager_limit_strategy
- #apply_eager_dataset_changes
- #apply_eager_graph_limit_strategy
- #apply_eager_limit_strategy
- #apply_ruby_eager_limit_strategy
- #apply_window_function_eager_limit_strategy
- #assign_singular?
- #associated_class
- #associated_dataset
- #association_dataset_for
- #association_dataset_proc
- #association_method
- #can_have_associated_objects?
- #cloneable?
- #dataset_method
- #dataset_need_primary_key?
- #delete_row_number_column
- #eager_graph_lazy_dataset?
- #eager_graph_limit_strategy
- #eager_limit_strategy
- #eager_load_results
- #eager_loader_key
- #eager_loading_predicate_key
- #eager_loading_use_associated_key?
- #filter_by_associations_add_conditions?
- #filter_by_associations_conditions_expression
- #handle_silent_modification_failure?
- #initialize_association_cache
- #limit_and_offset
- #need_associated_primary_key?
- #placeholder_loader
- #predicate_key_values
- #predicate_keys
- #qualify
- #qualify_assoc
- #qualify_cur
- #reciprocal
- #reciprocal_array?
- #remove_all_method
- #remove_before_destroy?
- #remove_method
- #remove_should_check_existing?
- #returns_array?
- #select
- #set_reciprocal_to_self?
- #setter_method
- #slice_range

### Included Modules

- Sequel::Inflections

### Files

- CHANGELOG
- MIT-LICENSE
- README.rdoc
- active_record.rdoc
- advanced_associations.rdoc
- association_basics.rdoc
- bin_sequel.rdoc
- cheat_sheet.rdoc
- code_order.rdoc
- core_extensions.rdoc
- dataset_basics.rdoc
- dataset_filtering.rdoc
- extensions.rdoc
- mass_assignment.rdoc
- migration.rdoc
- model_hooks.rdoc
- model_plugins.rdoc
- mssql_stored_procedures.rdoc
- object_model.rdoc
- opening_databases.rdoc
- postgresql.rdoc
- prepared_statements.rdoc
- querying.rdoc
- reflection.rdoc
- 1.0.txt
- 1.1.txt
- 1.3.txt
- 1.4.0.txt
- 1.5.0.txt
- 2.0.0.txt
- 2.1.0.txt
- 2.10.0.txt
- 2.11.0.txt
- 2.12.0.txt
- 2.2.0.txt
- 2.3.0.txt
- 2.4.0.txt
- 2.5.0.txt
- 2.6.0.txt
- 2.7.0.txt
- 2.8.0.txt
- 2.9.0.txt
- 3.0.0.txt
- 3.1.0.txt
- 3.10.0.txt
- 3.11.0.txt
- 3.12.0.txt
- 3.13.0.txt
- 3.14.0.txt
- 3.15.0.txt
- 3.16.0.txt
- 3.17.0.txt
- 3.18.0.txt
- 3.19.0.txt
- 3.2.0.txt
- 3.20.0.txt
- 3.21.0.txt
- 3.22.0.txt
- 3.23.0.txt
- 3.24.0.txt
- 3.25.0.txt
- 3.26.0.txt
- 3.27.0.txt
- 3.28.0.txt
- 3.29.0.txt
- 3.3.0.txt
- 3.30.0.txt
- 3.31.0.txt
- 3.32.0.txt
- 3.33.0.txt
- 3.34.0.txt
- 3.35.0.txt
- 3.36.0.txt
- 3.37.0.txt
- 3.38.0.txt
- 3.39.0.txt
- 3.4.0.txt
- 3.40.0.txt
- 3.41.0.txt
- 3.42.0.txt
- 3.43.0.txt
- 3.44.0.txt
- 3.45.0.txt
- 3.46.0.txt
- 3.47.0.txt
- 3.48.0.txt
- 3.5.0.txt
- 3.6.0.txt
- 3.7.0.txt
- 3.8.0.txt
- 3.9.0.txt
- 4.0.0.txt
- 4.1.0.txt
- 4.10.0.txt
- 4.11.0.txt
- 4.2.0.txt
- 4.3.0.txt
- 4.4.0.txt
- 4.5.0.txt
- 4.6.0.txt
- 4.7.0.txt
- 4.8.0.txt
- 4.9.0.txt
- schema_modification.rdoc
- security.rdoc
- sharding.rdoc
- sql.rdoc
- testing.rdoc
- thread_safety.rdoc
- transactions.rdoc
- validations.rdoc
- virtual_rows.rdoc

### Class/Module Index

Quicksearch

- Sequel
- Sequel::ADO
- Sequel::ADO::Access
- Sequel::ADO::Access::AdoSchema
- Sequel::ADO::Access::AdoSchema::Column
- Sequel::ADO::Access::DatabaseMethods
- Sequel::ADO::Access::Dataset
- Sequel::ADO::Database
- Sequel::ADO::Dataset
- Sequel::ADO::MSSQL
- Sequel::ADO::MSSQL::DatabaseMethods
- Sequel::ADO::MSSQL::Dataset
- Sequel::ASTTransformer
- Sequel::Access
- Sequel::Access::DatabaseMethods
- Sequel::Access::DatasetMethods
- Sequel::AdapterNotFound
- Sequel::Amalgalite
- Sequel::Amalgalite::Database
- Sequel::Amalgalite::Dataset
- Sequel::Amalgalite::SequelTypeMap
- Sequel::ArbitraryServers
- Sequel::BasicObject
- Sequel::BeforeHookFailed
- Sequel::CheckConstraintViolation
- Sequel::ColumnsIntrospection
- Sequel::ConnectionPool
- Sequel::ConnectionPool::ClassMethods
- Sequel::ConnectionValidator
- Sequel::ConnectionValidator::Retry
- Sequel::ConstraintValidations
- Sequel::ConstraintValidations::AlterTableGeneratorMethods
- Sequel::ConstraintValidations::CreateTableGeneratorMethods
- Sequel::ConstraintValidations::Generator
- Sequel::ConstraintViolation
- Sequel::CoreRefinements
- Sequel::Cubrid
- Sequel::Cubrid::Database
- Sequel::Cubrid::DatabaseMethods
- Sequel::Cubrid::Dataset
- Sequel::Cubrid::DatasetMethods
- Sequel::CurrentDateTimeTimestamp
- Sequel::CurrentDateTimeTimestamp::DatasetMethods
- Sequel::CurrentDateTimeTimestamp::DateTime
- Sequel::CurrentDateTimeTimestamp::Time
- Sequel::DB2
- Sequel::DB2::DB2Error
- Sequel::DB2::Database
- Sequel::DB2::DatabaseMethods
- Sequel::DB2::Dataset
- Sequel::DB2::DatasetMethods
- Sequel::DBI
- Sequel::DBI::Database
- Sequel::DBI::Dataset
- Sequel::DataObjects
- Sequel::DataObjects::Database
- Sequel::DataObjects::Dataset
- Sequel::DataObjects::MySQL
- Sequel::DataObjects::MySQL::DatabaseMethods
- Sequel::DataObjects::MySQL::Dataset
- Sequel::DataObjects::Postgres
- Sequel::DataObjects::Postgres::DatabaseMethods
- Sequel::DataObjects::SQLite
- Sequel::DataObjects::SQLite::DatabaseMethods
- Sequel::Database
- Sequel::Database::FromBlock
- Sequel::Database::ResetIdentifierMangling
- Sequel::Database::SplitAlterTable
- Sequel::DatabaseConnectionError
- Sequel::DatabaseDisconnectError
- Sequel::DatabaseError
- Sequel::DatabaseQuery
- Sequel::Dataset
- Sequel::Dataset::ArgumentMapper
- Sequel::Dataset::NullDataset
- Sequel::Dataset::Nullifiable
- Sequel::Dataset::Pagination
- Sequel::Dataset::PlaceholderLiteralizer
- Sequel::Dataset::PlaceholderLiteralizer::Argument
- Sequel::Dataset::PlaceholderLiteralizer::Recorder
- Sequel::Dataset::PreparedStatementMethods
- Sequel::Dataset::Query
- Sequel::Dataset::Replace
- Sequel::Dataset::SplitArrayNil
- Sequel::Dataset::StoredProcedureMethods
- Sequel::Dataset::StoredProcedures
- Sequel::Dataset::UnnumberedArgumentMapper
- Sequel::DatasetPagination
- Sequel::DatasetPrinter
- Sequel::DatasetQuery
- Sequel::Deprecation
- Sequel::EmptyArrayIgnoreNulls
- Sequel::EmulateOffsetWithReverseAndCount
- Sequel::EmulateOffsetWithRowNumber
- Sequel::Error
- Sequel::Error::AdapterNotFound
- Sequel::Error::InvalidOperation
- Sequel::Error::InvalidValue
- Sequel::Error::PoolTimeoutError
- Sequel::Error::Rollback
- Sequel::ErrorSQL
- Sequel::EvalInspect
- Sequel::FilterHaving
- Sequel::Firebird
- Sequel::Firebird::Database
- Sequel::Firebird::DatabaseMethods
- Sequel::Firebird::Dataset
- Sequel::Firebird::DatasetMethods
- Sequel::ForeignKeyConstraintViolation
- Sequel::GraphEach
- Sequel::HashAliases
- Sequel::HookFailed
- Sequel::IBMDB
- Sequel::IBMDB::Connection
- Sequel::IBMDB::Connection::Error
- Sequel::IBMDB::Database
- Sequel::IBMDB::Dataset
- Sequel::IBMDB::Dataset::CallableStatementMethods
- Sequel::IBMDB::Dataset::PreparedStatementMethods
- Sequel::IBMDB::Statement
- Sequel::Inflections
- Sequel::Informix
- Sequel::Informix::Database
- Sequel::Informix::DatabaseMethods
- Sequel::Informix::Dataset
- Sequel::Informix::DatasetMethods
- Sequel::IntegerMigrator
- Sequel::InvalidOperation
- Sequel::InvalidValue
- Sequel::JDBC
- Sequel::JDBC::AS400
- Sequel::JDBC::AS400::DatabaseMethods
- Sequel::JDBC::AS400::Dataset
- Sequel::JDBC::Cubrid
- Sequel::JDBC::Cubrid::DatabaseMethods
- Sequel::JDBC::DB2
- Sequel::JDBC::DB2::DatabaseMethods
- Sequel::JDBC::DB2::Dataset
- Sequel::JDBC::Database
- Sequel::JDBC::Dataset
- Sequel::JDBC::Dataset::PreparedStatementMethods
- Sequel::JDBC::Dataset::StoredProcedureMethods
- Sequel::JDBC::Derby
- Sequel::JDBC::Derby::DatabaseMethods
- Sequel::JDBC::Derby::Dataset
- Sequel::JDBC::Firebird
- Sequel::JDBC::Firebird::DatabaseMethods
- Sequel::JDBC::H2
- Sequel::JDBC::H2::DatabaseMethods
- Sequel::JDBC::H2::Dataset
- Sequel::JDBC::HSQLDB
- Sequel::JDBC::HSQLDB::DatabaseMethods
- Sequel::JDBC::HSQLDB::Dataset
- Sequel::JDBC::Informix
- Sequel::JDBC::Informix::DatabaseMethods
- Sequel::JDBC::JTDS
- Sequel::JDBC::JTDS::DatabaseMethods
- Sequel::JDBC::JTDS::Dataset
- Sequel::JDBC::JavaLang
- Sequel::JDBC::JavaSQL
- Sequel::JDBC::JavaxNaming
- Sequel::JDBC::MSSQL
- Sequel::JDBC::MSSQL::DatabaseMethods
- Sequel::JDBC::MySQL
- Sequel::JDBC::MySQL::DatabaseMethods
- Sequel::JDBC::Oracle
- Sequel::JDBC::Oracle::DatabaseMethods
- Sequel::JDBC::Oracle::Dataset
- Sequel::JDBC::Postgres
- Sequel::JDBC::Postgres::DatabaseMethods
- Sequel::JDBC::Postgres::Dataset
- Sequel::JDBC::Progress
- Sequel::JDBC::Progress::DatabaseMethods
- Sequel::JDBC::SQLServer
- Sequel::JDBC::SQLServer::DatabaseMethods
- Sequel::JDBC::SQLServer::DatabaseMethods::MetadataDatasetMethods
- Sequel::JDBC::SQLite
- Sequel::JDBC::SQLite::DatabaseMethods
- Sequel::JDBC::SqlAnywhere
- Sequel::JDBC::SqlAnywhere::DatabaseMethods
- Sequel::JDBC::SqlAnywhere::Dataset
- Sequel::JDBC::Transactions
- Sequel::JDBC::TypeConvertor
- Sequel::LiteralString
- Sequel::LooserTypecasting
- Sequel::MSSQL
- Sequel::MSSQL::DatabaseMethods
- Sequel::MSSQL::DatasetMethods
- Sequel::MSSQL::EmulateLateralWithApply
- Sequel::Metaprogramming
- Sequel::Migration
- Sequel::MigrationAlterTableReverser
- Sequel::MigrationDSL
- Sequel::MigrationReverser
- Sequel::Migrator
- Sequel::Migrator::Error
- Sequel::Migrator::NotCurrentError
- Sequel::Mock
- Sequel::Mock::Connection
- Sequel::Mock::Database
- Sequel::Mock::Dataset
- Sequel::Model
- Sequel::Model::Associations
- Sequel::Model::Associations::AssociationDatasetMethods
- Sequel::Model::Associations::AssociationReflection
- Sequel::Model::Associations::ClassMethods
- Sequel::Model::Associations::DatasetMethods
- Sequel::Model::Associations::EagerGraphLoader
- Sequel::Model::Associations::InstanceMethods
- Sequel::Model::Associations::ManyToManyAssociationReflection
- Sequel::Model::Associations::ManyToOneAssociationReflection
- Sequel::Model::Associations::OneThroughOneAssociationReflection
- Sequel::Model::Associations::OneToManyAssociationReflection
- Sequel::Model::Associations::OneToOneAssociationReflection
- Sequel::Model::Associations::SingularAssociationReflection
- Sequel::Model::ClassMethods
- Sequel::Model::DatasetMethods
- Sequel::Model::DatasetModule
- Sequel::Model::Errors
- Sequel::Model::InstanceMethods
- Sequel::MySQL
- Sequel::MySQL::Database
- Sequel::MySQL::DatabaseMethods
- Sequel::MySQL::Dataset
- Sequel::MySQL::DatasetMethods
- Sequel::MySQL::PreparedStatements
- Sequel::MySQL::PreparedStatements::DatabaseMethods
- Sequel::MySQL::PreparedStatements::DatasetMethods
- Sequel::MySQL::PreparedStatements::DatasetMethods::CallableStatementMethods
- Sequel::MySQL::PreparedStatements::DatasetMethods::PreparedStatementMethods
- Sequel::MySQL::PreparedStatements::DatasetMethods::StoredProcedureMethods
- Sequel::Mysql2
- Sequel::Mysql2::Database
- Sequel::Mysql2::Dataset
- Sequel::NamedTimezones
- Sequel::NamedTimezones::DatabaseMethods
- Sequel::NoExistingObject
- Sequel::NoMatchingRow
- Sequel::NotNullConstraintViolation
- Sequel::ODBC
- Sequel::ODBC::Database
- Sequel::ODBC::Dataset
- Sequel::ODBC::MSSQL
- Sequel::ODBC::MSSQL::DatabaseMethods
- Sequel::ODBC::MSSQL::Dataset
- Sequel::OpenBase
- Sequel::OpenBase::Database
- Sequel::OpenBase::Dataset
- Sequel::Oracle
- Sequel::Oracle::Database
- Sequel::Oracle::DatabaseMethods
- Sequel::Oracle::Dataset
- Sequel::Oracle::Dataset::ArgumentMapper
- Sequel::Oracle::Dataset::BindArgumentMethods
- Sequel::Oracle::Dataset::PreparedStatementMethods
- Sequel::Oracle::DatasetMethods
- Sequel::Plugins
- Sequel::Plugins::ActiveModel
- Sequel::Plugins::ActiveModel::ClassMethods
- Sequel::Plugins::ActiveModel::Errors
- Sequel::Plugins::ActiveModel::InstanceMethods
- Sequel::Plugins::AfterInitialize
- Sequel::Plugins::AfterInitialize::ClassMethods
- Sequel::Plugins::AfterInitialize::InstanceMethods
- Sequel::Plugins::AssociationAutoreloading
- Sequel::Plugins::AssociationDependencies
- Sequel::Plugins::AssociationDependencies::ClassMethods
- Sequel::Plugins::AssociationDependencies::InstanceMethods
- Sequel::Plugins::AssociationPks
- Sequel::Plugins::AssociationPks::ClassMethods
- Sequel::Plugins::AssociationPks::InstanceMethods
- Sequel::Plugins::AssociationProxies
- Sequel::Plugins::AssociationProxies::AssociationProxy
- Sequel::Plugins::AssociationProxies::ClassMethods
- Sequel::Plugins::AutoValidations
- Sequel::Plugins::AutoValidations::ClassMethods
- Sequel::Plugins::AutoValidations::InstanceMethods
- Sequel::Plugins::BlacklistSecurity
- Sequel::Plugins::BlacklistSecurity::ClassMethods
- Sequel::Plugins::BlacklistSecurity::InstanceMethods
- Sequel::Plugins::BlacklistSecurity::InstanceMethods::ExceptionList
- Sequel::Plugins::BooleanReaders
- Sequel::Plugins::BooleanReaders::ClassMethods
- Sequel::Plugins::Caching
- Sequel::Plugins::Caching::ClassMethods
- Sequel::Plugins::Caching::InstanceMethods
- Sequel::Plugins::ClassTableInheritance
- Sequel::Plugins::ClassTableInheritance::ClassMethods
- Sequel::Plugins::ClassTableInheritance::InstanceMethods
- Sequel::Plugins::Composition
- Sequel::Plugins::Composition::ClassMethods
- Sequel::Plugins::Composition::InstanceMethods
- Sequel::Plugins::ConstraintValidations
- Sequel::Plugins::ConstraintValidations::ClassMethods
- Sequel::Plugins::ConstraintValidations::DatabaseMethods
- Sequel::Plugins::ConstraintValidations::InstanceMethods
- Sequel::Plugins::DatasetAssociations
- Sequel::Plugins::DatasetAssociations::ClassMethods
- Sequel::Plugins::DatasetAssociations::DatasetMethods
- Sequel::Plugins::DefaultsSetter
- Sequel::Plugins::DefaultsSetter::ClassMethods
- Sequel::Plugins::DefaultsSetter::InstanceMethods
- Sequel::Plugins::Dirty
- Sequel::Plugins::Dirty::InstanceMethods
- Sequel::Plugins::EagerEach
- Sequel::Plugins::EagerEach::DatasetMethods
- Sequel::Plugins::ErrorSplitter
- Sequel::Plugins::ErrorSplitter::InstanceMethods
- Sequel::Plugins::ForceEncoding
- Sequel::Plugins::ForceEncoding::ClassMethods
- Sequel::Plugins::ForceEncoding::InstanceMethods
- Sequel::Plugins::HookClassMethods
- Sequel::Plugins::HookClassMethods::ClassMethods
- Sequel::Plugins::HookClassMethods::InstanceMethods
- Sequel::Plugins::InputTransformer
- Sequel::Plugins::InputTransformer::ClassMethods
- Sequel::Plugins::InputTransformer::InstanceMethods
- Sequel::Plugins::InstanceFilters
- Sequel::Plugins::InstanceFilters::Error
- Sequel::Plugins::InstanceFilters::InstanceMethods
- Sequel::Plugins::InstanceHooks
- Sequel::Plugins::InstanceHooks::InstanceMethods
- Sequel::Plugins::JsonSerializer
- Sequel::Plugins::JsonSerializer::ClassMethods
- Sequel::Plugins::JsonSerializer::DatasetMethods
- Sequel::Plugins::JsonSerializer::InstanceMethods
- Sequel::Plugins::JsonSerializer::Literal
- Sequel::Plugins::LazyAttributes
- Sequel::Plugins::LazyAttributes::ClassMethods
- Sequel::Plugins::LazyAttributes::InstanceMethods
- Sequel::Plugins::List
- Sequel::Plugins::List::ClassMethods
- Sequel::Plugins::List::InstanceMethods
- Sequel::Plugins::ManyThroughMany
- Sequel::Plugins::ManyThroughMany::ClassMethods
- Sequel::Plugins::ManyThroughMany::DatasetMethods
- Sequel::Plugins::ManyThroughMany::ManyThroughManyAssociationReflection
- Sequel::Plugins::ManyThroughMany::OneThroughManyAssociationReflection
- Sequel::Plugins::ManyToOnePkLookup
- Sequel::Plugins::MssqlOptimisticLocking
- Sequel::Plugins::MssqlOptimisticLocking::ClassMethods
- Sequel::Plugins::MssqlOptimisticLocking::InstanceMethods
- Sequel::Plugins::NestedAttributes
- Sequel::Plugins::NestedAttributes::ClassMethods
- Sequel::Plugins::NestedAttributes::InstanceMethods
- Sequel::Plugins::OptimisticLocking
- Sequel::Plugins::OptimisticLocking::ClassMethods
- Sequel::Plugins::OptimisticLocking::Error
- Sequel::Plugins::OptimisticLocking::InstanceMethods
- Sequel::Plugins::PgArrayAssociations
- Sequel::Plugins::PgArrayAssociations::ClassMethods
- Sequel::Plugins::PgArrayAssociations::DatasetMethods
- Sequel::Plugins::PgArrayAssociations::ManyToPgArrayAssociationReflection
- Sequel::Plugins::PgArrayAssociations::PgArrayToManyAssociationReflection
- Sequel::Plugins::PgRow
- Sequel::Plugins::PgRow::ClassMethods
- Sequel::Plugins::PgRow::DatabaseMethods
- Sequel::Plugins::PgRow::InstanceMethods
- Sequel::Plugins::PgTypecastOnLoad
- Sequel::Plugins::PgTypecastOnLoad::ClassMethods
- Sequel::Plugins::PgTypecastOnLoad::InstanceMethods
- Sequel::Plugins::PreparedStatements
- Sequel::Plugins::PreparedStatements::ClassMethods
- Sequel::Plugins::PreparedStatements::InstanceMethods
- Sequel::Plugins::PreparedStatementsAssociations
- Sequel::Plugins::PreparedStatementsAssociations::InstanceMethods
- Sequel::Plugins::PreparedStatementsSafe
- Sequel::Plugins::PreparedStatementsSafe::ClassMethods
- Sequel::Plugins::PreparedStatementsSafe::InstanceMethods
- Sequel::Plugins::PreparedStatementsWithPk
- Sequel::Plugins::PreparedStatementsWithPk::ClassMethods
- Sequel::Plugins::PreparedStatementsWithPk::DatasetMethods
- Sequel::Plugins::RcteTree
- Sequel::Plugins::Schema
- Sequel::Plugins::Schema::ClassMethods
- Sequel::Plugins::Scissors
- Sequel::Plugins::Scissors::ClassMethods
- Sequel::Plugins::Serialization
- Sequel::Plugins::Serialization::ClassMethods
- Sequel::Plugins::Serialization::InstanceMethods
- Sequel::Plugins::SerializationModificationDetection
- Sequel::Plugins::SerializationModificationDetection::InstanceMethods
- Sequel::Plugins::Sharding
- Sequel::Plugins::Sharding::ClassMethods
- Sequel::Plugins::Sharding::DatasetMethods
- Sequel::Plugins::Sharding::InstanceMethods
- Sequel::Plugins::SingleTableInheritance
- Sequel::Plugins::SingleTableInheritance::ClassMethods
- Sequel::Plugins::SingleTableInheritance::InstanceMethods
- Sequel::Plugins::SkipCreateRefresh
- Sequel::Plugins::SkipCreateRefresh::InstanceMethods
- Sequel::Plugins::StaticCache
- Sequel::Plugins::StaticCache::ClassMethods
- Sequel::Plugins::StaticCache::InstanceMethods
- Sequel::Plugins::StringStripper
- Sequel::Plugins::StringStripper::ClassMethods
- Sequel::Plugins::Subclasses
- Sequel::Plugins::Subclasses::ClassMethods
- Sequel::Plugins::TableSelect
- Sequel::Plugins::TableSelect::ClassMethods
- Sequel::Plugins::TacticalEagerLoading
- Sequel::Plugins::TacticalEagerLoading::DatasetMethods
- Sequel::Plugins::TacticalEagerLoading::InstanceMethods
- Sequel::Plugins::Timestamps
- Sequel::Plugins::Timestamps::ClassMethods
- Sequel::Plugins::Timestamps::InstanceMethods
- Sequel::Plugins::Touch
- Sequel::Plugins::Touch::ClassMethods
- Sequel::Plugins::Touch::InstanceMethods
- Sequel::Plugins::Tree
- Sequel::Plugins::Tree::ClassMethods
- Sequel::Plugins::Tree::InstanceMethods
- Sequel::Plugins::Tree::SingleRoot
- Sequel::Plugins::Tree::SingleRoot::ClassMethods
- Sequel::Plugins::Tree::SingleRoot::InstanceMethods
- Sequel::Plugins::Tree::TreeMultipleRootError
- Sequel::Plugins::TypecastOnLoad
- Sequel::Plugins::TypecastOnLoad::ClassMethods
- Sequel::Plugins::TypecastOnLoad::InstanceMethods
- Sequel::Plugins::UnlimitedUpdate
- Sequel::Plugins::UnlimitedUpdate::InstanceMethods
- Sequel::Plugins::UpdateOrCreate
- Sequel::Plugins::UpdateOrCreate::ClassMethods
- Sequel::Plugins::UpdatePrimaryKey
- Sequel::Plugins::UpdatePrimaryKey::InstanceMethods
- Sequel::Plugins::ValidationClassMethods
- Sequel::Plugins::ValidationClassMethods::ClassMethods
- Sequel::Plugins::ValidationClassMethods::ClassMethods::Generator
- Sequel::Plugins::ValidationClassMethods::InstanceMethods
- Sequel::Plugins::ValidationHelpers
- Sequel::Plugins::ValidationHelpers::InstanceMethods
- Sequel::Plugins::XmlSerializer
- Sequel::Plugins::XmlSerializer::ClassMethods
- Sequel::Plugins::XmlSerializer::DatasetMethods
- Sequel::Plugins::XmlSerializer::InstanceMethods
- Sequel::PoolTimeout
- Sequel::Postgres
- Sequel::Postgres::Adapter
- Sequel::Postgres::AlterTableGenerator
- Sequel::Postgres::ArrayOp
- Sequel::Postgres::ArrayOpMethods
- Sequel::Postgres::CreateTableGenerator
- Sequel::Postgres::Database
- Sequel::Postgres::DatabaseMethods
- Sequel::Postgres::Dataset
- Sequel::Postgres::Dataset::ArgumentMapper
- Sequel::Postgres::Dataset::BindArgumentMethods
- Sequel::Postgres::Dataset::PreparedStatementMethods
- Sequel::Postgres::DatasetMethods
- Sequel::Postgres::DatasetMethods::PreparedStatementMethods
- Sequel::Postgres::ExclusionConstraintViolation
- Sequel::Postgres::HStore
- Sequel::Postgres::HStore::DatabaseMethods
- Sequel::Postgres::HStore::Parser
- Sequel::Postgres::HStoreOp
- Sequel::Postgres::HStoreOpMethods
- Sequel::Postgres::InetDatabaseMethods
- Sequel::Postgres::InetDatasetMethods
- Sequel::Postgres::IntervalDatabaseMethods
- Sequel::Postgres::IntervalDatabaseMethods::Parser
- Sequel::Postgres::IntervalDatasetMethods
- Sequel::Postgres::JSONArray
- Sequel::Postgres::JSONArrayBase
- Sequel::Postgres::JSONBArray
- Sequel::Postgres::JSONBHash
- Sequel::Postgres::JSONBOp
- Sequel::Postgres::JSONBaseOp
- Sequel::Postgres::JSONDatabaseMethods
- Sequel::Postgres::JSONHash
- Sequel::Postgres::JSONHashBase
- Sequel::Postgres::JSONOp
- Sequel::Postgres::JSONOpMethods
- Sequel::Postgres::LooseCount
- Sequel::Postgres::PGArray
- Sequel::Postgres::PGArray::Creator
- Sequel::Postgres::PGArray::DatabaseMethods
- Sequel::Postgres::PGArray::JSONCreator
- Sequel::Postgres::PGArray::Parser
- Sequel::Postgres::PGRange
- Sequel::Postgres::PGRange::DatabaseMethods
- Sequel::Postgres::PGRange::DatasetMethods
- Sequel::Postgres::PGRange::Parser
- Sequel::Postgres::PGRow
- Sequel::Postgres::PGRow::ArrayRow
- Sequel::Postgres::PGRow::DatabaseMethods
- Sequel::Postgres::PGRow::HashRow
- Sequel::Postgres::PGRow::Parser
- Sequel::Postgres::PGRow::Splitter
- Sequel::Postgres::PGRowOp
- Sequel::Postgres::PGRowOp::ExpressionMethods
- Sequel::Postgres::RangeOp
- Sequel::Postgres::RangeOpMethods
- Sequel::Postgres::StaticCacheUpdater
- Sequel::PrettyTable
- Sequel::Progress
- Sequel::Progress::DatabaseMethods
- Sequel::Progress::DatasetMethods
- Sequel::Qualifier
- Sequel::QueryLiterals
- Sequel::Rollback
- Sequel::SQL
- Sequel::SQL::AliasMethods
- Sequel::SQL::AliasedExpression
- Sequel::SQL::BitwiseMethods
- Sequel::SQL::Blob
- Sequel::SQL::BooleanConstant
- Sequel::SQL::BooleanExpression
- Sequel::SQL::BooleanMethods
- Sequel::SQL::Builders
- Sequel::SQL::CaseExpression
- Sequel::SQL::Cast
- Sequel::SQL::CastMethods
- Sequel::SQL::ColumnAll
- Sequel::SQL::ComplexExpression
- Sequel::SQL::ComplexExpressionMethods
- Sequel::SQL::Constant
- Sequel::SQL::Constants
- Sequel::SQL::DateAdd
- Sequel::SQL::DateAdd::DatasetMethods
- Sequel::SQL::DelayedEvaluation
- Sequel::SQL::EmulatedFunction
- Sequel::SQL::Expression
- Sequel::SQL::Function
- Sequel::SQL::GenericExpression
- Sequel::SQL::Identifier
- Sequel::SQL::InequalityMethods
- Sequel::SQL::JoinClause
- Sequel::SQL::JoinOnClause
- Sequel::SQL::JoinUsingClause
- Sequel::SQL::NegativeBooleanConstant
- Sequel::SQL::NumericExpression
- Sequel::SQL::NumericMethods
- Sequel::SQL::OperatorBuilders
- Sequel::SQL::OrderMethods
- Sequel::SQL::OrderedExpression
- Sequel::SQL::PlaceholderLiteralString
- Sequel::SQL::QualifiedIdentifier
- Sequel::SQL::QualifyingMethods
- Sequel::SQL::StringConcatenationMethods
- Sequel::SQL::StringExpression
- Sequel::SQL::StringMethods
- Sequel::SQL::Subscript
- Sequel::SQL::SubscriptMethods
- Sequel::SQL::ValueList
- Sequel::SQL::VirtualRow
- Sequel::SQL::Window
- Sequel::SQL::WindowFunction
- Sequel::SQL::Wrapper
- Sequel::SQLTime
- Sequel::SQLite
- Sequel::SQLite::Database
- Sequel::SQLite::DatabaseMethods
- Sequel::SQLite::Dataset
- Sequel::SQLite::Dataset::ArgumentMapper
- Sequel::SQLite::Dataset::BindArgumentMethods
- Sequel::SQLite::Dataset::PreparedStatementMethods
- Sequel::SQLite::DatasetMethods
- Sequel::Schema
- Sequel::Schema::AlterTableGenerator
- Sequel::Schema::CreateTableGenerator
- Sequel::Schema::Generator
- Sequel::SchemaCaching
- Sequel::SchemaDumper
- Sequel::SelectRemove
- Sequel::Sequel3DatasetMethods
- Sequel::SerializationFailure
- Sequel::ServerBlock
- Sequel::SetOverrides
- Sequel::ShardedSingleConnectionPool
- Sequel::ShardedThreadedConnectionPool
- Sequel::SimpleMigration
- Sequel::SingleConnectionPool
- Sequel::SqlAnywhere
- Sequel::SqlAnywhere::Database
- Sequel::SqlAnywhere::DatabaseMethods
- Sequel::SqlAnywhere::Dataset
- Sequel::SqlAnywhere::DatasetMethods
- Sequel::SqlAnywhere::SQLAnywhereException
- Sequel::Swift
- Sequel::Swift::Database
- Sequel::Swift::Dataset
- Sequel::Swift::MySQL
- Sequel::Swift::MySQL::DatabaseMethods
- Sequel::Swift::MySQL::Dataset
- Sequel::Swift::Postgres
- Sequel::Swift::Postgres::DatabaseMethods
- Sequel::Swift::SQLite
- Sequel::Swift::SQLite::DatabaseMethods
- Sequel::Swift::SQLite::Dataset
- Sequel::ThreadLocalTimezones
- Sequel::ThreadedConnectionPool
- Sequel::ThreadedServerBlock
- Sequel::TimestampMigrator
- Sequel::Timezones
- Sequel::TinyTDS
- Sequel::TinyTDS::Database
- Sequel::TinyTDS::Dataset
- Sequel::TinyTDS::Dataset::ArgumentMapper
- Sequel::TinyTDS::Dataset::PreparedStatementMethods
- Sequel::ToDot
- Sequel::ToDot::DatasetMethods
- Sequel::UnbindDuplicate
- Sequel::Unbinder
- Sequel::UndefinedAssociation
- Sequel::UniqueConstraintViolation
- Sequel::UnthreadedServerBlock
- Sequel::ValidationFailed
- String
- String::Inflections
- Array
- FalseClass
- Hash
- NilClass
- Numeric
- Object
- PGconn
- PGresult
- Range
- Symbol
- TrueClass

No matching classes.

# Sequel::Model::Associations::AssociationReflection

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.

### Constants

ASSOCIATION_DATASET_PROC

### Public Instance Methods

_add_method() click to toggle source

Name symbol for the _add internal association method

    # File lib/sequel/model/associations.rb, line 22
    def _add_method
      :"_add_#{singularize(self[:name])}"
    end

_remove_all_method() click to toggle source

Name symbol for the _remove_all internal association method

    # File lib/sequel/model/associations.rb, line 27
    def _remove_all_method
      :"_remove_all_#{self[:name]}"
    end

_remove_method() click to toggle source

Name symbol for the _remove internal association method

    # File lib/sequel/model/associations.rb, line 32
    def _remove_method
      :"_remove_#{singularize(self[:name])}"
    end

_setter_method() click to toggle source

Name symbol for the _setter association method

    # File lib/sequel/model/associations.rb, line 37
    def _setter_method
      :"_#{self[:name]}="
    end

add_method() click to toggle source

Name symbol for the add association method

    # File lib/sequel/model/associations.rb, line 42
    def add_method
      :"add_#{singularize(self[:name])}"
    end

apply_dataset_changes(ds) click to toggle source

Apply all non-instance specific changes to the given dataset and return it.

    # File lib/sequel/model/associations.rb, line 64
    def apply_dataset_changes(ds)
      ds.extend(AssociationDatasetMethods)
      ds.association_reflection = self
      self[:extend].each{|m| ds.extend(m)}
      ds = ds.select(*select) if select
      if c = self[:conditions]
        ds = (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.where(*c) : ds.where(c)
      end
      ds = ds.order(*self[:order]) if self[:order]
      ds = ds.limit(*self[:limit]) if self[:limit]
      ds = ds.limit(1) if limit_to_single_row?
      ds = ds.eager(*self[:eager]) if self[:eager]
      ds = ds.distinct if self[:distinct]
      ds
    end

apply_distinct_on_eager_limit_strategy(ds) click to toggle source

Use DISTINCT ON and ORDER BY clauses to limit the results to the first record with matching keys.

    # File lib/sequel/model/associations.rb, line 117
    def apply_distinct_on_eager_limit_strategy(ds)
      keys = predicate_key
      ds.distinct(*keys).order_prepend(*keys)
    end

apply_eager_dataset_changes(ds) click to toggle source

Apply all non-instance specific changes and the eager_block option to the given dataset and return it.

    # File lib/sequel/model/associations.rb, line 82
    def apply_eager_dataset_changes(ds)
      ds = apply_dataset_changes(ds)
      if block = self[:eager_block]
        ds = block.call(ds)
      end
      ds
    end

apply_eager_graph_limit_strategy(strategy, ds) click to toggle source

Apply the eager graph limit strategy to the dataset to graph into the current dataset, or return the dataset unmodified if no SQL limit strategy is needed.

    # File lib/sequel/model/associations.rb, line 92
    def apply_eager_graph_limit_strategy(strategy, ds)
      case strategy
      when :distinct_on
        apply_distinct_on_eager_limit_strategy(ds.order_prepend(*self[:order]))
      when :window_function
        apply_window_function_eager_limit_strategy(ds.order_prepend(*self[:order])).select(*ds.columns)
      else
        ds
      end
    end

apply_eager_limit_strategy(ds, strategy=eager_limit_strategy) click to toggle source

Apply an eager limit strategy to the dataset, or return the dataset unmodified if it doesn't need an eager limit strategy.

    # File lib/sequel/model/associations.rb, line 105
    def apply_eager_limit_strategy(ds, strategy=eager_limit_strategy)
      case strategy
      when :distinct_on
        apply_distinct_on_eager_limit_strategy(ds)
      when :window_function
        apply_window_function_eager_limit_strategy(ds)
      else
        ds
      end
    end

apply_ruby_eager_limit_strategy(rows) click to toggle source

If the ruby eager limit strategy is being used, slice the array using the slice range to return the object(s) at the correct offset/limit.

    # File lib/sequel/model/associations.rb, line 143
    def apply_ruby_eager_limit_strategy(rows)
      if eager_limit_strategy == :ruby
        name = self[:name]
        if returns_array?
          range = slice_range
          rows.each{|o| o.associations[name] = o.associations[name][range] || []}
        elsif slice_range
          offset = slice_range.begin
          rows.each{|o| o.associations[name] = o.associations[name][offset]}
        end
      end
    end

apply_window_function_eager_limit_strategy(ds) click to toggle source

Use a window function to limit the results of the eager loading dataset.

    # File lib/sequel/model/associations.rb, line 123
    def apply_window_function_eager_limit_strategy(ds)
      rn = ds.row_number_column
      limit, offset = limit_and_offset
      ds = ds.unordered.select_append{|o| o.row_number{}.over(:partition=>predicate_key, :order=>ds.opts[:order]).as(rn)}.from_self
      ds = if !returns_array?
        ds.where(rn => offset ? offset+1 : 1)
      elsif offset
        offset += 1
        if limit
          ds.where(rn => (offset...(offset+limit)))
        else
          ds.where{SQL::Identifier.new(rn) >= offset}
        end
      else
        ds.where{SQL::Identifier.new(rn) <= limit}
      end
    end

assign_singular?() click to toggle source

Whether the associations cache should use an array when storing the associated records during eager loading.

    # File lib/sequel/model/associations.rb, line 158
    def assign_singular?
      !returns_array?
    end

associated_class() click to toggle source

The class associated to the current model class via this association

    # File lib/sequel/model/associations.rb, line 52
    def associated_class
      cached_fetch(:class){constantize(self[:class_name])}
    end

associated_dataset() click to toggle source

The dataset associated via this association, with the non-instance specific changes already applied. This will be a joined dataset if the association requires joining tables.

    # File lib/sequel/model/associations.rb, line 59
    def associated_dataset
      cached_fetch(:_dataset){apply_dataset_changes(_associated_dataset)}
    end

association_dataset_for(object) click to toggle source

Return an dataset that will load the appropriate associated objects for the given object using this association.

    # File lib/sequel/model/associations.rb, line 195
    def association_dataset_for(object)
      associated_dataset.where(predicate_keys.zip(predicate_key_values(object)))
    end

association_dataset_proc() click to toggle source

Proc used to create the association dataset method.

    # File lib/sequel/model/associations.rb, line 201
    def association_dataset_proc
      ASSOCIATION_DATASET_PROC
    end

association_method() click to toggle source

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

    # File lib/sequel/model/associations.rb, line 47
    def association_method
      self[:name]
    end

can_have_associated_objects?(obj) click to toggle source

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.

    # File lib/sequel/model/associations.rb, line 165
    def can_have_associated_objects?(obj)
      true
    end

cloneable?(ref) click to toggle source

Whether you are able to clone from the given association type to the current association type, true by default only if the types match.

    # File lib/sequel/model/associations.rb, line 171
    def cloneable?(ref)
      ref[:type] == self[:type]
    end

dataset_method() click to toggle source

Name symbol for the dataset association method

    # File lib/sequel/model/associations.rb, line 176
    def dataset_method
      :"#{self[:name]}_dataset"
    end

dataset_need_primary_key?() click to toggle source

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

    # File lib/sequel/model/associations.rb, line 181
    def dataset_need_primary_key?
      true
    end

delete_row_number_column(ds=associated_dataset) click to toggle source

Return the symbol used for the row number column if the window function eager limit strategy is being used, or nil otherwise.

    # File lib/sequel/model/associations.rb, line 187
    def delete_row_number_column(ds=associated_dataset)
      if eager_limit_strategy == :window_function
        ds.row_number_column
      end
    end

eager_graph_lazy_dataset?() click to toggle source

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.

    # File lib/sequel/model/associations.rb, line 288
    def eager_graph_lazy_dataset?
      true
    end

eager_graph_limit_strategy(strategy) click to toggle source

The eager_graph limit strategy to use for this dataset

    # File lib/sequel/model/associations.rb, line 206
    def eager_graph_limit_strategy(strategy)
      if self[:limit] || !returns_array?
        strategy = strategy[self[:name]] if strategy.is_a?(Hash)
        case strategy
        when true
          true_eager_graph_limit_strategy
        when Symbol
          strategy
        else
          if returns_array? || offset
            :ruby
          end
        end
      end
    end

eager_limit_strategy() click to toggle source

The eager limit strategy to use for this dataset.

    # File lib/sequel/model/associations.rb, line 223
    def eager_limit_strategy
      cached_fetch(:_eager_limit_strategy) do
        if self[:limit] || !returns_array?
          case s = cached_fetch(:eager_limit_strategy){default_eager_limit_strategy}
          when true
            true_eager_limit_strategy
          else
            s
          end
        end
      end
    end

eager_load_results(eo, &block) click to toggle source

Eager load the associated objects using the hash of eager options, yielding each row to the block.

    # File lib/sequel/model/associations.rb, line 238
    def eager_load_results(eo, &block)
      rows = eo[:rows]
      initialize_association_cache(rows) unless eo[:initialize_rows] == false
      strategy = eager_limit_strategy
      cascade = eo[:associations]

      if eo[:eager_block] || eo[:loader] == false
        strategy = true_eager_graph_limit_strategy if strategy == :union
        objects = apply_eager_limit_strategy(eager_loading_dataset(eo), strategy).all
        cascade = nil
      elsif strategy == :union
        objects = []
        ds = associated_dataset
        ds = self[:eager_block].call(ds) if self[:eager_block]
        loader = union_eager_loader
        joiner = " UNION ALL "
        eo[:id_map].keys.each_slice(subqueries_per_union).each do |slice|
          objects.concat(ds.with_sql(slice.map{|k| loader.sql(*k)}.join(joiner)).to_a)
        end
      else
        objects = placeholder_eager_loader.all(eo[:id_map].keys)
      end

      if cascade && !(cascade = associated_dataset.send(:eager_options_for_associations, [cascade])).empty?
        associated_eager_dataset.send(:eager_load, objects, cascade)
      end

      objects.each(&block)
      apply_ruby_eager_limit_strategy(rows)
    end

eager_loader_key() click to toggle source

The key to use for the key hash when eager loading

    # File lib/sequel/model/associations.rb, line 270
    def eager_loader_key
      self[:eager_loader_key]
    end

eager_loading_predicate_key() click to toggle source

Alias of predicate_key, only for backwards compatibility.

    # File lib/sequel/model/associations.rb, line 281
    def eager_loading_predicate_key
      predicate_key
    end

eager_loading_use_associated_key?() click to toggle source

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

    # File lib/sequel/model/associations.rb, line 276
    def eager_loading_use_associated_key?
      false
    end

filter_by_associations_add_conditions?() click to toggle source

Whether additional conditions should be added when using the filter by associations support.

    # File lib/sequel/model/associations.rb, line 294
    def filter_by_associations_add_conditions?
      self[:conditions] || self[:eager_block] || self[:limit]
    end

filter_by_associations_conditions_expression(obj) click to toggle source

The expression to use for the additional conditions to be added for the filter by association support, when the association itself is filtered. Works by using a subquery to test that the objects passed also meet the association filter criteria.

    # File lib/sequel/model/associations.rb, line 302
    def filter_by_associations_conditions_expression(obj)
      ds = filter_by_associations_conditions_dataset.where(filter_by_associations_conditions_subquery_conditions(obj))
      {filter_by_associations_conditions_key=>ds}
    end

handle_silent_modification_failure?() click to toggle source

Whether to handle silent modification failure when adding/removing associated records, false by default.

    # File lib/sequel/model/associations.rb, line 309
    def handle_silent_modification_failure?
      false
    end

initialize_association_cache(objects) click to toggle source

Initialize the associations cache for the current association for the given objects.

    # File lib/sequel/model/associations.rb, line 314
    def initialize_association_cache(objects)
      name = self[:name]
      if assign_singular?
        objects.each{|object| object.associations[name] = nil}
      else
        objects.each{|object| object.associations[name] = []}
      end
    end

limit_and_offset() click to toggle source

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

    # File lib/sequel/model/associations.rb, line 324
    def limit_and_offset
      if (v = self[:limit]).is_a?(Array)
        v
      else
        [v, nil]
      end
    end

need_associated_primary_key?() click to toggle source

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

    # File lib/sequel/model/associations.rb, line 334
    def need_associated_primary_key?
      false
    end

placeholder_loader() click to toggle source

A placeholder literalizer that can be used to lazily load the association. If one can't be used, returns nil.

    # File lib/sequel/model/associations.rb, line 340
    def placeholder_loader
      if use_placeholder_loader?
        cached_fetch(:placeholder_loader) do
          Sequel::Dataset::PlaceholderLiteralizer.loader(associated_dataset) do |pl, ds|
            ds.where(*predicate_keys.map{|k| SQL::BooleanExpression.new(:'=', k, pl.arg)})
          end
        end
      end
    end

predicate_key_values(object) click to toggle source

The values that predicate_keys should match for objects to be associated.

    # File lib/sequel/model/associations.rb, line 356
    def predicate_key_values(object)
      predicate_key_methods.map{|k| object.send(k)}
    end

predicate_keys() click to toggle source

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

    # File lib/sequel/model/associations.rb, line 351
    def predicate_keys
      cached_fetch(:predicate_keys){Array(predicate_key)}
    end

qualify(table, col) click to toggle source

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.

    # File lib/sequel/model/associations.rb, line 363
    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) click to toggle source

Qualify col with the associated model's table name.

    # File lib/sequel/model/associations.rb, line 375
    def qualify_assoc(col)
      qualify(associated_class.table_name, col)
    end

qualify_cur(col) click to toggle source

Qualify col with the current model's table name.

    # File lib/sequel/model/associations.rb, line 380
    def qualify_cur(col)
      qualify(self[:model].table_name, col)
    end

reciprocal() click to toggle source

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.

    # File lib/sequel/model/associations.rb, line 390
    def reciprocal
      cached_fetch(:reciprocal) 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
          cached_set(:reciprocal_type, possible_recips.first[:type]) if reciprocal_type.is_a?(Array)
          possible_recips.first[:name]
        end
      end
    end

reciprocal_array?() click to toggle source

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

    # File lib/sequel/model/associations.rb, line 409
    def reciprocal_array?
      true
    end

remove_all_method() click to toggle source

Name symbol for the remove_all_ association method

    # File lib/sequel/model/associations.rb, line 414
    def remove_all_method
      :"remove_all_#{self[:name]}"
    end

remove_before_destroy?() click to toggle source

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

    # File lib/sequel/model/associations.rb, line 420
    def remove_before_destroy?
      true
    end

remove_method() click to toggle source

Name symbol for the remove_ association method

    # File lib/sequel/model/associations.rb, line 425
    def remove_method
      :"remove_#{singularize(self[:name])}"
    end

remove_should_check_existing?() click to toggle source

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

    # File lib/sequel/model/associations.rb, line 430
    def remove_should_check_existing?
      false
    end

returns_array?() click to toggle source

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

    # File lib/sequel/model/associations.rb, line 436
    def returns_array?
      true
    end

select() click to toggle source

The columns to select when loading the association.

    # File lib/sequel/model/associations.rb, line 441
    def select
      self[:select]
    end

set_reciprocal_to_self?() click to toggle source

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

    # File lib/sequel/model/associations.rb, line 447
    def set_reciprocal_to_self?
      false
    end

setter_method() click to toggle source

Name symbol for the setter association method

    # File lib/sequel/model/associations.rb, line 452
    def setter_method
      :"#{self[:name]}="
    end

slice_range() click to toggle source

The range used for slicing when using the :ruby eager limit strategy.

    # File lib/sequel/model/associations.rb, line 457
    def slice_range
      limit, offset = limit_and_offset
      if limit || offset
        (offset||0)..(limit ? (offset||0)+limit-1 : -1)
      end
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.