module Sequel::Timezones

Convert the given Time/DateTime object into the database timezone, used when literalizing objects in an SQL string.

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

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)

You can also pass a single options hash:

DB = Sequel.connect(adapter: 'sqlite', database: './blog.db')

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}

If a block is not given, a reference to this database will be held in Sequel::DATABASES until it is removed manually. This is by design, and used by Sequel::Model to pick the default database. It is recommended to pass a block if you do not want the resulting Database object to remain in memory until the process terminates, or use the keep_reference: false Database option.

For details, see the “Connecting to a Database” guide. To set up a primary/replica or sharded database connection, see the “Primary/Replica Database Configurations and Sharding” guide.

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.

Converts the object to the given output_timezone.

Converts the given object from the given input timezone to the application_timezone using convert_input_timestamp and convert_output_timestamp.

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

The current concurrency primitive, Thread.current by default.

Convert the given object into an object of Sequel.datetime_class in the application_timezone. Used when converting datetime/timestamp columns returned by the database.

Sets the database, application, and typecasting timezones to the given timezone.

The elapsed seconds since the given timer object was created. The timer object should have been created via Sequel.start_timer.

Load all Sequel extensions given. Extensions are just files that exist under sequel/extensions in the load path, and are just required.

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(:blank)
Sequel.extension(:core_extensions, :named_timezones)

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

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

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

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.

For backwards compatibility only. require_relative should be used instead.

Splits the symbol into three parts, if symbol splitting is enabled (not the default). Each part will either be a string or nil. If symbol splitting is disabled, returns an array with the first and third parts being nil, and the second part beind a string version of the symbol.

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

Setting this to true enables Sequel’s historical behavior of splitting symbols on double or triple underscores:

:table__column         # table.column
:column___alias        # column AS alias
:table__column___alias # table.column AS alias

It is only recommended to turn this on for backwards compatibility until such symbols have been converted to use newer Sequel APIs such as:

Sequel[:table][:column]            # table.column
Sequel[:column].as(:alias)         # column AS alias
Sequel[:table][:column].as(:alias) # table.column AS alias

Sequel::Database instances do their own caching of literalized symbols, and changing this setting does not affect those caches. It is recommended that if you want to change this setting, you do so directly after requiring Sequel, before creating any Sequel::Database instances.

Disabling symbol splitting will also disable the handling of double underscores in virtual row methods, causing such methods to yield regular identifers instead of qualified identifiers:

# Sequel.split_symbols = true
Sequel.expr{table__column}  # table.column
Sequel.expr{table[:column]} # table.column

# Sequel.split_symbols = false
Sequel.expr{table__column}  # table__column
Sequel.expr{table[:column]} # table.column

Whether Sequel currently splits symbols into qualified/aliased identifiers.

A timer object that can be passed to Sequel.elapsed_seconds_since to return the number of seconds elapsed.

Converts the given string into a Date object.

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

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)

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'

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. In general, this should only be used around the minimal possible code such as Hash#[], Hash#[]=, Hash#delete, Array#<<, and Array#delete.

If a mutex is given, synchronize access using it. If nil is given, just yield to the block. This is designed for cases where a mutex may or may not be provided.

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).

Convert the given object into an object of Sequel.datetime_class in the application_timezone. Used when typecasting values when assigning them to model datetime attributes.

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)