Module: Sequel

### Home Classes Methods

### In Files

- lib/sequel/adapters/ado.rb
- lib/sequel/adapters/ado/access.rb
- lib/sequel/adapters/ado/mssql.rb
- lib/sequel/adapters/amalgalite.rb
- lib/sequel/adapters/cubrid.rb
- lib/sequel/adapters/db2.rb
- lib/sequel/adapters/dbi.rb
- lib/sequel/adapters/do.rb
- lib/sequel/adapters/do/mysql.rb
- lib/sequel/adapters/do/postgres.rb
- lib/sequel/adapters/do/sqlite3.rb
- lib/sequel/adapters/firebird.rb
- lib/sequel/adapters/ibmdb.rb
- lib/sequel/adapters/informix.rb
- lib/sequel/adapters/jdbc.rb
- lib/sequel/adapters/jdbc/as400.rb
- lib/sequel/adapters/jdbc/cubrid.rb
- lib/sequel/adapters/jdbc/db2.rb
- lib/sequel/adapters/jdbc/derby.rb
- lib/sequel/adapters/jdbc/firebirdsql.rb
- lib/sequel/adapters/jdbc/h2.rb
- lib/sequel/adapters/jdbc/hsqldb.rb
- lib/sequel/adapters/jdbc/informix-sqli.rb
- lib/sequel/adapters/jdbc/jdbcprogress.rb
- lib/sequel/adapters/jdbc/jtds.rb
- lib/sequel/adapters/jdbc/mssql.rb
- lib/sequel/adapters/jdbc/mysql.rb
- lib/sequel/adapters/jdbc/oracle.rb
- lib/sequel/adapters/jdbc/postgresql.rb
- lib/sequel/adapters/jdbc/sqlanywhere.rb
- lib/sequel/adapters/jdbc/sqlite.rb
- lib/sequel/adapters/jdbc/sqlserver.rb
- lib/sequel/adapters/jdbc/transactions.rb
- lib/sequel/adapters/mock.rb
- lib/sequel/adapters/mysql.rb
- lib/sequel/adapters/mysql2.rb
- lib/sequel/adapters/odbc.rb
- lib/sequel/adapters/odbc/mssql.rb
- lib/sequel/adapters/oracle.rb
- lib/sequel/adapters/postgres.rb
- lib/sequel/adapters/shared/access.rb
- lib/sequel/adapters/shared/cubrid.rb
- lib/sequel/adapters/shared/db2.rb
- lib/sequel/adapters/shared/firebird.rb
- lib/sequel/adapters/shared/informix.rb
- lib/sequel/adapters/shared/mssql.rb
- lib/sequel/adapters/shared/mysql.rb
- lib/sequel/adapters/shared/mysql_prepared_statements.rb
- lib/sequel/adapters/shared/oracle.rb
- lib/sequel/adapters/shared/postgres.rb
- lib/sequel/adapters/shared/progress.rb
- lib/sequel/adapters/shared/sqlanywhere.rb
- lib/sequel/adapters/shared/sqlite.rb
- lib/sequel/adapters/sqlanywhere.rb
- lib/sequel/adapters/sqlite.rb
- lib/sequel/adapters/swift.rb
- lib/sequel/adapters/swift/mysql.rb
- lib/sequel/adapters/swift/postgres.rb
- lib/sequel/adapters/swift/sqlite.rb
- lib/sequel/adapters/utils/emulate_offset_with_reverse_and_count.rb
- lib/sequel/adapters/utils/emulate_offset_with_row_number.rb
- lib/sequel/adapters/utils/pg_types.rb
- lib/sequel/adapters/utils/replace.rb
- lib/sequel/adapters/utils/stored_procedures.rb
- lib/sequel/adapters/tinytds.rb
- lib/sequel/ast_transformer.rb
- lib/sequel/core.rb
- lib/sequel/database.rb
- lib/sequel/database/connecting.rb
- lib/sequel/database/dataset.rb
- lib/sequel/database/dataset_defaults.rb
- lib/sequel/database/features.rb
- lib/sequel/database/logging.rb
- lib/sequel/database/misc.rb
- lib/sequel/database/query.rb
- lib/sequel/database/schema_generator.rb
- lib/sequel/database/schema_methods.rb
- lib/sequel/database/transactions.rb
- lib/sequel/dataset.rb
- lib/sequel/dataset/actions.rb
- lib/sequel/dataset/features.rb
- lib/sequel/dataset/graph.rb
- lib/sequel/dataset/misc.rb
- lib/sequel/dataset/mutation.rb
- lib/sequel/dataset/placeholder_literalizer.rb
- lib/sequel/dataset/prepared_statements.rb
- lib/sequel/dataset/query.rb
- lib/sequel/dataset/sql.rb
- lib/sequel/deprecated.rb
- lib/sequel/exceptions.rb
- lib/sequel/extensions/_pretty_table.rb
- lib/sequel/extensions/arbitrary_servers.rb
- lib/sequel/extensions/columns_introspection.rb
- lib/sequel/extensions/connection_validator.rb
- lib/sequel/extensions/constraint_validations.rb
- lib/sequel/extensions/current_datetime_timestamp.rb
- lib/sequel/extensions/dataset_source_alias.rb
- lib/sequel/extensions/date_arithmetic.rb
- lib/sequel/extensions/empty_array_ignore_nulls.rb
- lib/sequel/extensions/error_sql.rb
- lib/sequel/extensions/eval_inspect.rb
- lib/sequel/extensions/filter_having.rb
- lib/sequel/extensions/from_block.rb
- lib/sequel/extensions/graph_each.rb
- lib/sequel/extensions/hash_aliases.rb
- lib/sequel/extensions/looser_typecasting.rb
- lib/sequel/extensions/meta_def.rb
- lib/sequel/extensions/migration.rb
- lib/sequel/extensions/mssql_emulate_lateral_with_apply.rb
- lib/sequel/extensions/named_timezones.rb
- lib/sequel/extensions/null_dataset.rb
- lib/sequel/extensions/pagination.rb
- lib/sequel/extensions/pg_array.rb
- lib/sequel/extensions/pg_array_ops.rb
- lib/sequel/extensions/pg_enum.rb
- lib/sequel/extensions/pg_hstore.rb
- lib/sequel/extensions/pg_hstore_ops.rb
- lib/sequel/extensions/pg_inet.rb
- lib/sequel/extensions/pg_interval.rb
- lib/sequel/extensions/pg_json.rb
- lib/sequel/extensions/pg_json_ops.rb
- lib/sequel/extensions/pg_loose_count.rb
- lib/sequel/extensions/pg_range.rb
- lib/sequel/extensions/pg_range_ops.rb
- lib/sequel/extensions/pg_row.rb
- lib/sequel/extensions/pg_row_ops.rb
- lib/sequel/extensions/pg_static_cache_updater.rb
- lib/sequel/extensions/pretty_table.rb
- lib/sequel/extensions/query.rb
- lib/sequel/extensions/query_literals.rb
- lib/sequel/extensions/round_timestamps.rb
- lib/sequel/extensions/schema_caching.rb
- lib/sequel/extensions/schema_dumper.rb
- lib/sequel/extensions/select_remove.rb
- lib/sequel/extensions/sequel_3_dataset_methods.rb
- lib/sequel/extensions/server_block.rb
- lib/sequel/extensions/set_overrides.rb
- lib/sequel/extensions/split_array_nil.rb
- lib/sequel/extensions/thread_local_timezones.rb
- lib/sequel/extensions/to_dot.rb
- lib/sequel/model.rb
- lib/sequel/model/associations.rb
- lib/sequel/model/base.rb
- lib/sequel/model/dataset_module.rb
- lib/sequel/model/default_inflections.rb
- lib/sequel/model/errors.rb
- lib/sequel/model/exceptions.rb
- lib/sequel/model/inflections.rb
- lib/sequel/model/plugins.rb
- lib/sequel/plugins/accessed_columns.rb
- lib/sequel/plugins/active_model.rb
- lib/sequel/plugins/after_initialize.rb
- lib/sequel/plugins/association_autoreloading.rb
- lib/sequel/plugins/association_dependencies.rb
- lib/sequel/plugins/association_pks.rb
- lib/sequel/plugins/association_proxies.rb
- lib/sequel/plugins/auto_validations.rb
- lib/sequel/plugins/blacklist_security.rb
- lib/sequel/plugins/boolean_readers.rb
- lib/sequel/plugins/caching.rb
- lib/sequel/plugins/class_table_inheritance.rb
- lib/sequel/plugins/column_conflicts.rb
- lib/sequel/plugins/column_select.rb
- lib/sequel/plugins/composition.rb
- lib/sequel/plugins/constraint_validations.rb
- lib/sequel/plugins/csv_serializer.rb
- lib/sequel/plugins/dataset_associations.rb
- lib/sequel/plugins/defaults_setter.rb
- lib/sequel/plugins/delay_add_association.rb
- lib/sequel/plugins/dirty.rb
- lib/sequel/plugins/eager_each.rb
- lib/sequel/plugins/error_splitter.rb
- lib/sequel/plugins/force_encoding.rb
- lib/sequel/plugins/hook_class_methods.rb
- lib/sequel/plugins/input_transformer.rb
- lib/sequel/plugins/insert_returning_select.rb
- lib/sequel/plugins/instance_filters.rb
- lib/sequel/plugins/instance_hooks.rb
- lib/sequel/plugins/json_serializer.rb
- lib/sequel/plugins/lazy_attributes.rb
- lib/sequel/plugins/list.rb
- lib/sequel/plugins/many_through_many.rb
- lib/sequel/plugins/pg_row.rb
- lib/sequel/plugins/many_to_one_pk_lookup.rb
- lib/sequel/plugins/modification_detection.rb
- lib/sequel/plugins/mssql_optimistic_locking.rb
- lib/sequel/plugins/nested_attributes.rb
- lib/sequel/plugins/optimistic_locking.rb
- lib/sequel/plugins/pg_array_associations.rb
- lib/sequel/plugins/pg_typecast_on_load.rb
- lib/sequel/plugins/prepared_statements.rb
- lib/sequel/plugins/prepared_statements_associations.rb
- lib/sequel/plugins/prepared_statements_safe.rb
- lib/sequel/plugins/prepared_statements_with_pk.rb
- lib/sequel/plugins/rcte_tree.rb
- lib/sequel/plugins/schema.rb
- lib/sequel/plugins/scissors.rb
- lib/sequel/plugins/serialization.rb
- lib/sequel/plugins/sharding.rb
- lib/sequel/plugins/serialization_modification_detection.rb
- lib/sequel/plugins/single_table_inheritance.rb
- lib/sequel/plugins/skip_create_refresh.rb
- lib/sequel/plugins/split_values.rb
- lib/sequel/plugins/static_cache.rb
- lib/sequel/plugins/string_stripper.rb
- lib/sequel/plugins/subclasses.rb
- lib/sequel/plugins/table_select.rb
- lib/sequel/plugins/tactical_eager_loading.rb
- lib/sequel/plugins/timestamps.rb
- lib/sequel/plugins/touch.rb
- lib/sequel/plugins/tree.rb
- lib/sequel/plugins/typecast_on_load.rb
- lib/sequel/plugins/unlimited_update.rb
- lib/sequel/plugins/update_or_create.rb
- lib/sequel/plugins/update_primary_key.rb
- lib/sequel/plugins/update_refresh.rb
- lib/sequel/plugins/validate_associated.rb
- lib/sequel/plugins/validation_class_methods.rb
- lib/sequel/plugins/validation_helpers.rb
- lib/sequel/plugins/xml_serializer.rb
- lib/sequel/sql.rb
- lib/sequel/timezones.rb
- lib/sequel/version.rb

### Namespace

- MODULE Sequel::ADO
- MODULE Sequel::Access
- MODULE Sequel::Amalgalite
- MODULE Sequel::ArbitraryServers
- MODULE Sequel::ColumnsIntrospection
- MODULE Sequel::ConnectionValidator
- MODULE Sequel::ConstraintValidations
- MODULE Sequel::CoreRefinements
- MODULE Sequel::Cubrid
- MODULE Sequel::CurrentDateTimeTimestamp
- MODULE Sequel::DB2
- MODULE Sequel::DBI
- MODULE Sequel::DataObjects
- MODULE Sequel::DatabaseQuery
- MODULE Sequel::DatasetPagination
- MODULE Sequel::DatasetPrinter
- MODULE Sequel::DatasetQuery
- MODULE Sequel::Deprecation
- MODULE Sequel::EmptyArrayIgnoreNulls
- MODULE Sequel::EmulateOffsetWithReverseAndCount
- MODULE Sequel::EmulateOffsetWithRowNumber
- MODULE Sequel::ErrorSQL
- MODULE Sequel::EvalInspect
- MODULE Sequel::FilterHaving
- MODULE Sequel::Firebird
- MODULE Sequel::GraphEach
- MODULE Sequel::HashAliases
- MODULE Sequel::IBMDB
- MODULE Sequel::Inflections
- MODULE Sequel::Informix
- MODULE Sequel::JDBC
- MODULE Sequel::LooserTypecasting
- MODULE Sequel::MSSQL
- MODULE Sequel::Metaprogramming
- MODULE Sequel::Mock
- MODULE Sequel::MySQL
- MODULE Sequel::Mysql2
- MODULE Sequel::NamedTimezones
- MODULE Sequel::ODBC
- MODULE Sequel::Oracle
- MODULE Sequel::Plugins
- MODULE Sequel::Postgres
- MODULE Sequel::PrettyTable
- MODULE Sequel::Progress
- MODULE Sequel::QueryLiterals
- MODULE Sequel::SQL
- MODULE Sequel::SQLite
- MODULE Sequel::Schema
- MODULE Sequel::SchemaCaching
- MODULE Sequel::SchemaDumper
- MODULE Sequel::SelectRemove
- MODULE Sequel::Sequel3DatasetMethods
- MODULE Sequel::ServerBlock
- MODULE Sequel::SetOverrides
- MODULE Sequel::SqlAnywhere
- MODULE Sequel::Swift
- MODULE Sequel::ThreadLocalTimezones
- MODULE Sequel::ThreadedServerBlock
- MODULE Sequel::Timezones
- MODULE Sequel::TinyTDS
- MODULE Sequel::UnthreadedServerBlock
- CLASS Sequel::ASTTransformer
- CLASS Sequel::BasicObject
- CLASS Sequel::BeforeHookFailed
- CLASS Sequel::ConnectionPool
- CLASS Sequel::Database
- CLASS Sequel::DatabaseError
- CLASS Sequel::Dataset
- CLASS Sequel::Error
- CLASS Sequel::HookFailed
- CLASS Sequel::IntegerMigrator
- CLASS Sequel::LiteralString
- CLASS Sequel::Migration
- CLASS Sequel::MigrationAlterTableReverser
- CLASS Sequel::MigrationDSL
- CLASS Sequel::MigrationReverser
- CLASS Sequel::Migrator
- CLASS Sequel::Model
- CLASS Sequel::Qualifier
- CLASS Sequel::SQLTime
- CLASS Sequel::ShardedSingleConnectionPool
- CLASS Sequel::ShardedThreadedConnectionPool
- CLASS Sequel::SimpleMigration
- CLASS Sequel::SingleConnectionPool
- CLASS Sequel::ThreadedConnectionPool
- CLASS Sequel::TimestampMigrator
- CLASS Sequel::ToDot
- CLASS Sequel::Unbinder
- CLASS Sequel::ValidationFailed

### Methods

- ::Model
- ::condition_specifier?
- ::connect
- ::convert_exception_class
- ::core_extensions?
- ::extension
- ::identifier_input_method=
- ::identifier_output_method=
- ::inflections
- ::json_parser_error_class
- ::migration
- ::object_to_json
- ::parse_json
- ::quote_identifiers=
- ::recursive_map
- ::require
- ::single_threaded=
- ::split_symbol
- ::string_to_date
- ::string_to_datetime
- ::string_to_time
- ::synchronize
- ::transaction
- ::version
- ::virtual_row

### Included Modules

- Sequel::SQL::Constants

### 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.12.0.txt
- 4.13.0.txt
- 4.14.0.txt
- 4.15.0.txt
- 4.16.0.txt
- 4.17.0.txt
- 4.18.0.txt
- 4.19.0.txt
- 4.2.0.txt
- 4.20.0.txt
- 4.21.0.txt
- 4.22.0.txt
- 4.23.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::Amalgalite
- Sequel::Amalgalite::Database
- Sequel::Amalgalite::Dataset
- Sequel::Amalgalite::SequelTypeMap
- Sequel::ArbitraryServers
- Sequel::BasicObject
- Sequel::BeforeHookFailed
- Sequel::ColumnsIntrospection
- Sequel::ConnectionPool
- Sequel::ConnectionPool::ClassMethods
- Sequel::ConnectionValidator
- Sequel::ConnectionValidator::Retry
- Sequel::ConstraintValidations
- Sequel::ConstraintValidations::AlterTableGeneratorMethods
- Sequel::ConstraintValidations::CreateTableGeneratorMethods
- Sequel::ConstraintValidations::Generator
- 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::DatasetClass
- Sequel::Database::FromBlock
- Sequel::Database::ResetIdentifierMangling
- Sequel::Database::SplitAlterTable
- Sequel::DatabaseError
- Sequel::DatabaseQuery
- Sequel::Dataset
- Sequel::Dataset::ArgumentMapper
- Sequel::Dataset::DatasetSourceAlias
- 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::RoundTimestamps
- 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::ErrorSQL
- Sequel::EvalInspect
- Sequel::FilterHaving
- Sequel::Firebird
- Sequel::Firebird::Database
- Sequel::Firebird::DatabaseMethods
- Sequel::Firebird::Dataset
- Sequel::Firebird::DatasetMethods
- 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::Statement
- Sequel::Inflections
- Sequel::Informix
- Sequel::Informix::Database
- Sequel::Informix::DatabaseMethods
- Sequel::Informix::Dataset
- Sequel::Informix::DatasetMethods
- Sequel::IntegerMigrator
- 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::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::Mysql2
- Sequel::Mysql2::Database
- Sequel::Mysql2::Dataset
- Sequel::NamedTimezones
- Sequel::NamedTimezones::DatabaseMethods
- Sequel::ODBC
- Sequel::ODBC::Database
- Sequel::ODBC::Dataset
- Sequel::ODBC::MSSQL
- Sequel::ODBC::MSSQL::DatabaseMethods
- Sequel::ODBC::MSSQL::Dataset
- Sequel::Oracle
- Sequel::Oracle::Database
- Sequel::Oracle::DatabaseMethods
- Sequel::Oracle::Dataset
- Sequel::Oracle::Dataset::ArgumentMapper
- Sequel::Oracle::DatasetMethods
- Sequel::Plugins
- Sequel::Plugins::AccessedColumns
- Sequel::Plugins::AccessedColumns::InstanceMethods
- 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::ColumnConflicts
- Sequel::Plugins::ColumnConflicts::ClassMethods
- Sequel::Plugins::ColumnConflicts::InstanceMethods
- Sequel::Plugins::ColumnSelect
- Sequel::Plugins::ColumnSelect::ClassMethods
- 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::CsvSerializer
- Sequel::Plugins::CsvSerializer::ClassMethods
- Sequel::Plugins::CsvSerializer::DatasetMethods
- Sequel::Plugins::CsvSerializer::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::DelayAddAssociation
- Sequel::Plugins::DelayAddAssociation::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::InsertReturningSelect
- Sequel::Plugins::InsertReturningSelect::ClassMethods
- Sequel::Plugins::InsertReturningSelect::InstanceMethods
- Sequel::Plugins::InstanceFilters
- 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::ModificationDetection
- Sequel::Plugins::ModificationDetection::ClassMethods
- Sequel::Plugins::ModificationDetection::InstanceMethods
- 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::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::SplitValues
- Sequel::Plugins::SplitValues::ClassMethods
- Sequel::Plugins::SplitValues::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::UpdateRefresh
- Sequel::Plugins::UpdateRefresh::InstanceMethods
- Sequel::Plugins::ValidateAssociated
- Sequel::Plugins::ValidateAssociated::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::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::DatasetMethods
- Sequel::Postgres::DatasetMethods::PreparedStatementMethods
- Sequel::Postgres::EnumDatabaseMethods
- 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::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::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::PatternMatchMethods
- 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::Wrapper
- Sequel::SQLTime
- Sequel::SQLite
- Sequel::SQLite::Database
- Sequel::SQLite::DatabaseMethods
- Sequel::SQLite::Dataset
- Sequel::SQLite::Dataset::ArgumentMapper
- Sequel::SQLite::DatasetMethods
- Sequel::Schema
- Sequel::Schema::AlterTableGenerator
- Sequel::Schema::CreateTableGenerator
- Sequel::Schema::Generator
- Sequel::SchemaCaching
- Sequel::SchemaDumper
- Sequel::SelectRemove
- Sequel::Sequel3DatasetMethods
- 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::ToDot
- Sequel::ToDot::DatasetMethods
- Sequel::Unbinder
- Sequel::UnthreadedServerBlock
- Sequel::ValidationFailed
- String
- String::Inflections
- Array
- FalseClass
- Hash
- NilClass
- Numeric
- Object
- PGconn
- PGresult
- Range
- Symbol
- TrueClass

No matching classes.

# Sequel

Top level module for Sequel

There are some module methods that are added via metaprogramming, one for each supported adapter. For example:

    DB = Sequel.sqlite # Memory database
    DB = Sequel.sqlite('blog.db')
    DB = Sequel.postgres('database_name', :user=>'user',
           :password=>'password', :host=>'host', :port=>5432,
           :max_connections=>10)

If a block is given to these methods, it is passed the opened Database object, which is closed (disconnected) when the block exits, just like a block passed to connect. For example:

    Sequel.sqlite('blog.db'){|db| puts db[:users].count}

For a more expanded introduction, see the README. For a quicker introduction, see the cheat sheet.

### Constants

ADAPTER_MAP

  Hash of adapters that have been used. The key is the adapter scheme symbol, and the value is the Database subclass.

AdapterNotFound

  Error raised when the adapter requested doesn't exist or can't be loaded.

BeforeHookFailed

  Alias for HookFailed, kept for backwards compatibility

COLUMN_REF_RE1
COLUMN_REF_RE2
COLUMN_REF_RE3
CheckConstraintViolation

  Error raised when Sequel determines a database check constraint has been violated.

ConstraintViolation

  Generic error raised when Sequel determines a database constraint has been violated.

DATABASES

  Array of all databases to which Sequel has connected. If you are developing an application that can connect to an arbitrary number of databases, delete the database objects from this or they will not get garbage collected.

DEFAULT_INFLECTIONS_PROC

  Proc that is instance evaled to create the default inflections for both the model inflector and the inflector extension.

DatabaseConnectionError

  Error raised when the Sequel is unable to connect to the database with the connection parameters it was given.

DatabaseDisconnectError

  Error raised by adapters when they determine that the connection to the database has been lost. Instructs the connection pool code to remove that connection from the pool so that other connections can be acquired automatically.

DatabaseError

  Generic error raised by the database adapters, indicating a problem originating from the database server. Usually raised because incorrect SQL syntax is used.

ForeignKeyConstraintViolation

  Error raised when Sequel determines a database foreign key constraint has been violated.

InvalidOperation

  Error raised on an invalid operation, such as trying to update or delete a joined or grouped dataset.

InvalidValue

  Error raised when attempting an invalid type conversion.

MAJOR

  The major version of Sequel. Only bumped for major changes.

MINOR

  The minor version of Sequel. Bumped for every non-patch level release, generally around once a month.

MassAssignmentRestriction

  Raised when a mass assignment method is called in strict mode with either a restricted column or a column without a setter method.

NoExistingObject

  Exception class raised when `require_modification` is set and an UPDATE or DELETE statement to modify the dataset doesn't modify a single row.

NoMatchingRow

  Error raised when the user requests a record via the first! or similar method, and the dataset does not yield any rows.

NotNullConstraintViolation

  Error raised when Sequel determines a database NOT NULL constraint has been violated.

OPTS

  Frozen hash used as the default options hash for most options.

PoolTimeout

  Error raised when the connection pool cannot acquire a database connection before the timeout.

PoolTimeoutError
Rollback

  Error that you should raise to signal a rollback of the current transaction. The transaction block will catch this exception, rollback the current transaction, and won't reraise it (unless a reraise is requested).

SPLIT_SYMBOL_CACHE
SerializationFailure

  Error raised when Sequel determines a serialization failure/deadlock in the database.

TINY

  The tiny version of Sequel. Usually 0, only bumped for bugfix releases that fix regressions from previous versions.

UnbindDuplicate

  Error raised when unbinding a dataset that has multiple different values for a given variable.

UndefinedAssociation

  Raised when an undefined association is used when eager loading.

UniqueConstraintViolation

  Error raised when Sequel determines a database unique constraint has been violated.

VERSION

  The version of Sequel you are using, as a string (e.g. "2.11.0")

### Attributes

cache_anonymous_models[RW]

Whether to cache the anonymous models created by Sequel::Model(). This is required for reloading them correctly (avoiding the superclass mismatch). True by default for backwards compatibility.

convert_two_digit_years[RW]

Sequel converts two digit years in `Date`s and `DateTime`s by default, so 01/02/03 is interpreted at January 2nd, 2003, and 12/13/99 is interpreted as December 13, 1999. You can override this to treat those dates as January 2nd, 0003 and December 13, 0099, respectively, by:

    Sequel.convert_two_digit_years = false

datetime_class[RW]

Sequel can use either `Time` or `DateTime` for times returned from the database. It defaults to `Time`. To change it to `DateTime`:

    Sequel.datetime_class = DateTime

For ruby versions less than 1.9.2, `Time` has a limited range (1901 to 2038), so if you use datetimes out of that range, you need to switch to `DateTime`. Also, before 1.9.2, `Time` can only handle local and UTC times, not other timezones. Note that `Time` and `DateTime` objects have a different API, and in cases where they implement the same methods, they often implement them differently (e.g. + using seconds on `Time` and days on `DateTime`).

### Public Class Methods

Model(source) click to toggle source

Lets you create a Model subclass with its dataset already set. `source` should be an instance of one of the following classes:

Database | Sets the database for this model to `source`. Generally only useful when subclassing directly from the returned class, where the name of the subclass sets the table name (which is combined with the `Database` in `source` to create the dataset to use)
Dataset | Sets the dataset for this model to `source`.
other | Sets the table name for this model to `source`. The class will use the default database for model classes in order to create the dataset.

The purpose of this method is to set the dataset/database automatically for a model class, if the table name doesn't match the implicit name. This is neater than using set_dataset inside the class, doesn't require a bogus query for the schema.

    # Using a symbol
    class Comment < Sequel::Model(:something)
      table_name # => :something
    end

    # Using a dataset
    class Comment < Sequel::Model(DB1[:something])
      dataset # => DB1[:something]
    end

    # Using a database
    class Comment < Sequel::Model(DB1)
      dataset # => DB1[:comments]
    end

    # File lib/sequel/model.rb, line 37
    def self.Model(source)
      if cache_anonymous_models && (klass = Model::ANONYMOUS_MODEL_CLASSES_MUTEX.synchronize{Model::ANONYMOUS_MODEL_CLASSES[source]})
        return klass
      end
      klass = if source.is_a?(Database)
        c = Class.new(Model)
        c.db = source
        c
      else
        Class.new(Model).set_dataset(source)
      end
      Model::ANONYMOUS_MODEL_CLASSES_MUTEX.synchronize{Model::ANONYMOUS_MODEL_CLASSES[source] = klass} if cache_anonymous_models
      klass
    end

condition_specifier?(obj) click to toggle source

Returns true if the passed object could be a specifier of conditions, false otherwise. Currently, Sequel considers hashes and arrays of two element arrays as condition specifiers.

    Sequel.condition_specifier?({}) # => true
    Sequel.condition_specifier?([[1, 2]]) # => true
    Sequel.condition_specifier?([]) # => false
    Sequel.condition_specifier?([1]) # => false
    Sequel.condition_specifier?(1) # => false

    # File lib/sequel/core.rb, line 62
    def self.condition_specifier?(obj)
      case obj
      when Hash
        true
      when Array
        !obj.empty? && !obj.is_a?(SQL::ValueList) && obj.all?{|i| i.is_a?(Array) && (i.length == 2)}
      else
        false
      end
    end

connect(*args, &block) click to toggle source

Creates a new database object based on the supplied connection string and optional arguments. The specified scheme determines the database class used, and the rest of the string specifies the connection options. For example:

    DB = Sequel.connect('sqlite:/') # Memory database
    DB = Sequel.connect('sqlite://blog.db') # ./blog.db
    DB = Sequel.connect('sqlite:///blog.db') # /blog.db
    DB = Sequel.connect('postgres://user:password@host:port/database_name')
    DB = Sequel.connect('sqlite:///blog.db', :max_connections=>10)

If a block is given, it is passed the opened `Database` object, which is closed when the block exits. For example:

    Sequel.connect('sqlite://blog.db'){|db| puts db[:users].count}

For details, see the "Connecting to a Database" guide. To set up a master/slave or sharded database connection, see the "Master/Slave Databases and Sharding" guide.

    # File lib/sequel/core.rb, line 94
    def self.connect(*args, &block)
      Database.connect(*args, &block)
    end

convert_exception_class(exception, klass) click to toggle source

Convert the `exception` to the given class. The given class should be `Sequel::Error` or a subclass. Returns an instance of `klass` with the message and backtrace of `exception`.

    # File lib/sequel/core.rb, line 107
    def self.convert_exception_class(exception, klass)
      return exception if exception.is_a?(klass)
      e = klass.new("#{exception.class}: #{exception.message}")
      e.wrapped_exception = exception
      e.set_backtrace(exception.backtrace)
      e
    end

core_extensions?() click to toggle source

Assume the core extensions are not loaded by default, if the core_extensions extension is loaded, this will be overridden.

    # File lib/sequel/core.rb, line 100
    def self.core_extensions?
      false
    end

extension(*extensions) click to toggle source

Load all Sequel extensions given. Extensions are just files that exist under `sequel/extensions` in the load path, and are just required. Generally, extensions modify the behavior of `Database` and/or `Dataset`, but Sequel ships with some extensions that modify other classes that exist for backwards compatibility. In some cases, requiring an extension modifies classes directly, and in others, it just loads a module that you can extend other classes with. Consult the documentation for each extension you plan on using for usage.

    Sequel.extension(:schema_dumper)
    Sequel.extension(:pagination, :query)

    # File lib/sequel/core.rb, line 125
    def self.extension(*extensions)
      extensions.each{|e| Kernel.require "sequel/extensions/#{e}"}
    end

identifier_input_method=(value) click to toggle source

Set the method to call on identifiers going into the database. This affects the literalization of identifiers by calling this method on them before they are input. Sequel upcases identifiers in all SQL strings for most databases, so to turn that off:

    Sequel.identifier_input_method = nil

to downcase instead:

    Sequel.identifier_input_method = :downcase

Other String instance methods work as well.

    # File lib/sequel/core.rb, line 140
    def self.identifier_input_method=(value)
      Database.identifier_input_method = value
    end

identifier_output_method=(value) click to toggle source

Set the method to call on identifiers coming out of the database. This affects the literalization of identifiers by calling this method on them when they are retrieved from the database. Sequel downcases identifiers retrieved for most databases, so to turn that off:

    Sequel.identifier_output_method = nil

to upcase instead:

    Sequel.identifier_output_method = :upcase

Other String instance methods work as well.

    # File lib/sequel/core.rb, line 156
    def self.identifier_output_method=(value)
      Database.identifier_output_method = value
    end

inflections() click to toggle source

Yield the Inflections module if a block is given, and return the Inflections module.

    # File lib/sequel/model/inflections.rb, line 4
    def self.inflections
      yield Inflections if block_given?
      Inflections
    end

json_parser_error_class() click to toggle source

The exception classed raised if there is an error parsing JSON. This can be overridden to use an alternative json implementation.

    # File lib/sequel/core.rb, line 162
    def self.json_parser_error_class
      JSON::ParserError
    end

migration(&block) click to toggle source

The preferred method for writing Sequel migrations, using a DSL:

    Sequel.migration do
      up do
        create_table(:artists) do
          primary_key :id
          String :name
        end
      end

      down do
        drop_table(:artists)
      end
    end

Designed to be used with the `Migrator` class, part of the `migration` extension.

    # File lib/sequel/extensions/migration.rb, line 281
    def self.migration(&block)
      MigrationDSL.create(&block)
    end

object_to_json(obj, *args) click to toggle source

Convert given object to json and return the result. This can be overridden to use an alternative json implementation.

    # File lib/sequel/core.rb, line 168
    def self.object_to_json(obj, *args)
      obj.to_json(*args)
    end

parse_json(json) click to toggle source

Parse the string as JSON and return the result. This can be overridden to use an alternative json implementation.

    # File lib/sequel/core.rb, line 174
    def self.parse_json(json)
      JSON.parse(json, :create_additions=>false)
    end

quote_identifiers=(value) click to toggle source

Set whether to quote identifiers for all databases by default. By default, Sequel quotes identifiers in all SQL strings, so to turn that off:

    Sequel.quote_identifiers = false

    # File lib/sequel/core.rb, line 182
    def self.quote_identifiers=(value)
      Database.quote_identifiers = value
    end

recursive_map(array, converter) click to toggle source

Convert each item in the array to the correct type, handling multi-dimensional arrays. For each element in the array or subarrays, call the converter, unless the value is nil.

    # File lib/sequel/core.rb, line 189
    def self.recursive_map(array, converter)
      array.map do |i|
        if i.is_a?(Array)
          recursive_map(i, converter)
        elsif i
          converter.call(i)
        end
      end
    end

require(files, subdir=nil) click to toggle source

Require all given `files` which should be in the same or a subdirectory of this file. If a `subdir` is given, assume all `files` are in that subdir. This is used to ensure that the files loaded are from the same version of Sequel as this file.

    # File lib/sequel/core.rb, line 203
    def self.require(files, subdir=nil)
      Array(files).each{|f| super("#{File.dirname(__FILE__).untaint}/#{"#{subdir}/" if subdir}#{f}")}
    end

single_threaded=(value) click to toggle source

Set whether Sequel is being used in single threaded mode. By default, Sequel uses a thread-safe connection pool, which isn't as fast as the single threaded connection pool, and also has some additional thread safety checks. If your program will only have one thread, and speed is a priority, you should set this to true:

    Sequel.single_threaded = true

    # File lib/sequel/core.rb, line 214
    def self.single_threaded=(value)
      @single_threaded = value
      Database.single_threaded = value
    end

split_symbol(sym) click to toggle source

Splits the symbol into three parts. Each part will either be a string or nil.

For columns, these parts are the table, column, and alias. For tables, these parts are the schema, table, and alias.

    # File lib/sequel/core.rb, line 229
    def self.split_symbol(sym)
      unless v = Sequel.synchronize{SPLIT_SYMBOL_CACHE[sym]}
        v = case s = sym.to_s
        when COLUMN_REF_RE1
          [$1.freeze, $2.freeze, $3.freeze].freeze
        when COLUMN_REF_RE2
          [nil, $1.freeze, $2.freeze].freeze
        when COLUMN_REF_RE3
          [$1.freeze, $2.freeze, nil].freeze
        else
          [nil, s.freeze, nil].freeze
        end
        Sequel.synchronize{SPLIT_SYMBOL_CACHE[sym] = v}
      end
      v
    end

string_to_date(string) click to toggle source

Converts the given `string` into a `Date` object.

    Sequel.string_to_date('2010-09-10') # Date.civil(2010, 09, 10)

    # File lib/sequel/core.rb, line 249
    def self.string_to_date(string)
      begin
        Date.parse(string, Sequel.convert_two_digit_years)
      rescue => e
        raise convert_exception_class(e, InvalidValue)
      end
    end

string_to_datetime(string) click to toggle source

Converts the given `string` into a `Time` or `DateTime` object, depending on the value of `Sequel.datetime_class`.

    Sequel.string_to_datetime('2010-09-10 10:20:30') # Time.local(2010, 09, 10, 10, 20, 30)

    # File lib/sequel/core.rb, line 261
    def self.string_to_datetime(string)
      begin
        if datetime_class == DateTime
          DateTime.parse(string, convert_two_digit_years)
        else
          datetime_class.parse(string)
        end
      rescue => e
        raise convert_exception_class(e, InvalidValue)
      end
    end

string_to_time(string) click to toggle source

Converts the given `string` into a `Sequel::SQLTime` object.

    v = Sequel.string_to_time('10:20:30') # Sequel::SQLTime.parse('10:20:30')
    DB.literal(v) # => '10:20:30'

    # File lib/sequel/core.rb, line 277
    def self.string_to_time(string)
      begin
        SQLTime.parse(string)
      rescue => e
        raise convert_exception_class(e, InvalidValue)
      end
    end

synchronize(&block) click to toggle source

Unless in single threaded mode, protects access to any mutable global data structure in Sequel. Uses a non-reentrant mutex, so calling code should be careful.

    # File lib/sequel/core.rb, line 293
    def self.synchronize(&block)
      @single_threaded ? yield : @data_mutex.synchronize(&block)
    end

transaction(dbs, opts=OPTS, &block) click to toggle source

Uses a transaction on all given databases with the given options. This:

    Sequel.transaction([DB1, DB2, DB3]){...}

is equivalent to:

    DB1.transaction do
      DB2.transaction do
        DB3.transaction do
          ...
        end
      end
    end

except that if Sequel::Rollback is raised by the block, the transaction is rolled back on all databases instead of just the last one.

Note that this method cannot guarantee that all databases will commit or rollback. For example, if DB3 commits but attempting to commit on DB2 fails (maybe because foreign key checks are deferred), there is no way to uncommit the changes on DB3. For that kind of support, you need to have two-phase commit/prepared transactions (which Sequel supports on some databases).

    # File lib/sequel/core.rb, line 328
    def self.transaction(dbs, opts=OPTS, &block)
      unless opts[:rollback]
        rescue_rollback = true
        opts = Hash[opts].merge!(:rollback=>:reraise)
      end
      pr = dbs.reverse.inject(block){|bl, db| proc{db.transaction(opts, &bl)}}
      if rescue_rollback
        begin
          pr.call
        rescue Sequel::Rollback
          nil
        end
      else
        pr.call
      end
    end

version() click to toggle source

The version of Sequel you are using, as a string (e.g. "2.11.0")

    # File lib/sequel/version.rb, line 15
    def self.version
      VERSION
    end

virtual_row(&block) click to toggle source

If the supplied block takes a single argument, yield an `SQL::VirtualRow` instance to the block argument. Otherwise, evaluate the block in the context of a `SQL::VirtualRow` instance.

    Sequel.virtual_row{a} # Sequel::SQL::Identifier.new(:a)
    Sequel.virtual_row{|o| o.a{}} # Sequel::SQL::Function.new(:a)

    # File lib/sequel/core.rb, line 352
    def self.virtual_row(&block)
      vr = VIRTUAL_ROW
      case block.arity
      when -1, 0
        vr.instance_exec(&block)
      else
        block.call(vr)
      end
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.