Module: Sequel

Classes and Modules

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::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::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::OpenBase
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::Swift
Module Sequel::ThreadLocalTimezones
Module Sequel::ThreadedServerBlock
Module Sequel::Timezones
Module Sequel::TinyTDS
Module Sequel::UnthreadedServerBlock
Class Sequel::ASTTransformer
Class Sequel::AdapterNotFound
Class Sequel::BasicObject
Class Sequel::CheckConstraintViolation
Class Sequel::ConnectionPool
Class Sequel::ConstraintViolation
Class Sequel::Database
Class Sequel::DatabaseConnectionError
Class Sequel::DatabaseDisconnectError
Class Sequel::DatabaseError
Class Sequel::Dataset
Class Sequel::Error
Class Sequel::ForeignKeyConstraintViolation
Class Sequel::HookFailed
Class Sequel::IntegerMigrator
Class Sequel::InvalidOperation
Class Sequel::InvalidValue
Class Sequel::LiteralString
Class Sequel::Migration
Class Sequel::MigrationAlterTableReverser
Class Sequel::MigrationDSL
Class Sequel::MigrationReverser
Class Sequel::Migrator
Class Sequel::Model
Class Sequel::NoExistingObject
Class Sequel::NoMatchingRow
Class Sequel::NotImplemented
Class Sequel::NotNullConstraintViolation
Class Sequel::PoolTimeout
Class Sequel::Qualifier
Class Sequel::Rollback
Class Sequel::SQLTime
Class Sequel::SerializationFailure
Class Sequel::ShardedSingleConnectionPool
Class Sequel::ShardedThreadedConnectionPool
Class Sequel::SimpleMigration
Class Sequel::SingleConnectionPool
Class Sequel::ThreadedConnectionPool
Class Sequel::TimestampMigrator
Class Sequel::ToDot
Class Sequel::UnbindDuplicate
Class Sequel::Unbinder
Class Sequel::UndefinedAssociation
Class Sequel::UniqueConstraintViolation
Class Sequel::ValidationFailed

Constants

SQLITE_TYPES	=	{}	Hash with string keys and callable values for converting SQLite types.
MYSQL_TYPES	=	{}	Hash with integer keys and callable values for converting MySQL types.
STRING_TYPES	=	[18, 19, 25, 1042, 1043]	Type OIDs for string types used by PostgreSQL. These types don‘t have conversion procs associated with them (since the data is already in the form of a string).
PG_NAMED_TYPES	=	{} unless defined?(PG_NAMED_TYPES)	Hash with type name strings/symbols and callable values for converting PostgreSQL types. Non-builtin types that don‘t have fixed numbers should use this to register conversion procs.
PG_TYPES	=	{} unless defined?(PG_TYPES)	Hash with integer keys and callable values for converting PostgreSQL types.
ADAPTER_MAP	=	{}	Hash of adapters that have been used. The key is the adapter scheme symbol, and the value is the Database subclass.
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 do plural(/$/, 's')	Proc that is instance evaled to create the default inflections for both the model inflector and the inflector extension.
BeforeHookFailed	=	HookFailed	Deprecated alias for HookFailed, kept for backwards compatibility
MAJOR	=	3	The major version of Sequel. Only bumped for major changes.
MINOR	=	48	The minor version of Sequel. Bumped for every non-patch level release, generally around once a month.
TINY	=	0	The tiny version of Sequel. Usually 0, only bumped for bugfix releases that fix regressions from previous versions.
VERSION	=	[MAJOR, MINOR, TINY].join('.')	The version of Sequel you are using, as a string (e.g. "2.11.0")
COLUMN_REF_RE1	=	/\A((?:(?!__).)+)__((?:(?!___).)+)___(.+)\z/.freeze
COLUMN_REF_RE2	=	/\A((?:(?!___).)+)___(.+)\z/.freeze
COLUMN_REF_RE3	=	/\A((?:(?!__).)+)__(.+)\z/.freeze

Attributes

autoid

[W]

Set the autogenerated primary key integer to be returned when running an insert query. Argument types supported:

nil :	Return nil for all inserts
Integer :	Starting integer for next insert, with futher inserts getting an incremented value
Array :	First insert gets the first value in the array, second gets the second value, etc.
Proc :	Called with the insert SQL query, uses the value returned
Class :	Should be an Exception subclass, will create a new instance an raise it wrapped in a DatabaseError.

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.

columns

[W]

Set the columns to set in the dataset when the dataset fetches rows. Argument types supported:

nil :

Set no columns

Array of Symbols: Used for all datasets Array (otherwise): First retrieval gets the first value in the

                   array, second gets the second value, etc.

Proc :

Called with the select SQL query, uses the value returned, which should be an array of symbols

convert_invalid_date_time

[RW]

Whether to convert invalid date time values by default.

Only applies to Sequel::Database instances created after this has been set.

convert_two_digit_years

[RW]

Sequel converts two digit years in Dates and DateTimes 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).

empty_array_handle_nulls

[R]

Sets whether or not to attempt to handle NULL values correctly when given an empty array. By default:

  DB[:a].filter(:b=>[])
  # SELECT * FROM a WHERE (b != b)
  DB[:a].exclude(:b=>[])
  # SELECT * FROM a WHERE (b = b)

However, some databases (e.g. MySQL) will perform very poorly with this type of query. You can set this to false to get the following behavior:

  DB[:a].filter(:b=>[])
  # SELECT * FROM a WHERE 1 = 0
  DB[:a].exclude(:b=>[])
  # SELECT * FROM a WHERE 1 = 1

This may not handle NULLs correctly, but can be much faster on some databases.

fetch

[W]

Set the hashes to yield by execute when retrieving rows. Argument types supported:

nil :	Yield no rows
Hash :	Always yield a single row with this hash
Array of Hashes :	Yield separately for each hash in this array
Array (otherwise) :	First retrieval gets the first value in the array, second gets the second value, etc.
Proc :	Called with the select SQL query, uses the value returned, which should be a hash or array of hashes.
Class :	Should be an Exception subclass, will create a new instance an raise it wrapped in a DatabaseError.

numrows

[W]

Set the number of rows to return from update or delete. Argument types supported:

nil :	Return 0 for all updates and deletes
Integer :	Used for all updates and deletes
Array :	First update/delete gets the first value in the array, second gets the second value, etc.
Proc :	Called with the update/delete SQL query, uses the value returned.
Class :	Should be an Exception subclass, will create a new instance an raise it wrapped in a DatabaseError.

server_version [RW] Mock the server version, useful when using the shared adapters

Public Class methods

Model(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

Methods

Included Modules

Classes and Modules

Constants

Attributes

Public Class methods

Public Instance methods