sequel 3.21.0 → 3.32.0

data/doc/model_hooks.rdoc

@@ -4,7 +4,7 @@ This guide is based on http://guides.rubyonrails.org/activerecord_validations_ca
 
 == Overview
 
-Model hooks, also known as model callbacks, are used to specify actions that occur at a given point in a model instance's lifecycle, such as before or after the model object is saved, created, updated, destroyed, or validated.
+Model hooks, also known as model callbacks, are used to specify actions that occur at a given point in a model instance's lifecycle, such as before or after the model object is saved, created, updated, destroyed, or validated.  There are also around hooks for all types, which wrap the before hooks, the behavior, and the after hooks.
 
 == Basic Usage
 
@@ -23,41 +23,59 @@ The one important thing to note here is the call to +super+ inside the hook.  Wh
 
 Sequel calls hooks in the following order when saving/creating a new object (one that does not already exist in the database):
 
-* +before_validation+
-* +after_validation+
-* +before_save+
-* +before_create+
-* INSERT QUERY
-* +after_create+
-* +after_save+
+* +around_validation+
+  * +before_validation+
+  * +validate+ method called
+  * +after_validation+
+* +around_save+
+  * +before_save+
+  * +around_create+
+    * +before_create+
+    * INSERT QUERY
+    * +after_create+
+  * +after_save+
 
 Sequel calls hooks in the following order when saving an existing object:
 
-* +before_validation+
-* +after_validation+
-* +before_save+
-* +before_update+
-* UPDATE QUERY
-* +after_update+
-* +after_save+
+* +around_validation+
+  * +before_validation+
+  * +validate+ method called
+  * +after_validation+
+* +around_save+
+  * +before_save+
+  * +around_update+
+    * +before_update+
+    * INSERT QUERY
+    * +after_update+
+  * +after_save+
 
-Note that all of the hook calls are the same, except that +before_create+ and +after_create+ are used for a new object, and +before_update+ and +after_update+ are used for an existing object.  Note that +before_save+ is called in both cases, before either +before_create+ or +before_update+, and that +after_save+ is also called in both cases, after either +after_create+ or +after_update+.
+Note that all of the hook calls are the same, except that +around_create+, +before_create+ and +after_create+ are used for a new object, and +around_update+, +before_update+ and +after_update+ are used for an existing object.  Note that +around_save+, +before_save+, and +after_save+ are called in both cases.
 
 Also note that the validation hooks are not called if the <tt>:validate => false</tt> option is passed to save.  However, the validation hooks are called if you call <tt>Model#valid?</tt> manually:
 
-* +before_validation+
-* VALIDATION HAPPENS
-* +after_validation+
+* +around_validation+
+  * +before_validation+
+  * +validate+ method called
+  * +after_validation+
 
 Sequel calls hooks in the following order when destroying an existing object:
 
-* +before_destroy+
-* DELETE QUERY
-* +after_destroy+
+* +around_destroy+
+  * +before_destroy+
+  * DELETE QUERY
+  * +after_destroy+
 
 Note that these hooks are only called when using <tt>Model#destroy</tt>, they are not called if you use <tt>Model#delete</tt>.
 
-<tt>Sequel::Model</tt> does support one additional hook, +after_intialize+, which is called after the model object has been initalized.  It can be used to set default attribute values for new objects, since by default new <tt>Sequel::Model</tt> objects have no attributes, and the attributes are not filled in until the model object is saved.  You should be careful when you are using +after_initialize+, since it is called for every created record.  So if you run a query that returns 1000 model objects, it will be called 1000 times.
+<tt>Sequel::Model</tt> does support a few additional hooks. One is +after_intialize+, which is called after the model object has been initalized.  It can be used to set default attribute values for new objects, since by default new <tt>Sequel::Model</tt> objects have no attributes, and the attributes are not filled in until the model object is saved.  You should be careful when you are using +after_initialize+, since it is called for every created record.  So if you run a query that returns 1000 model objects, it will be called 1000 times.  If you only want to change the behavior for new records, you can override the +initialize_set+ private method, which is called with the hash passed to +initialize+.
+
+== Transaction-related Hooks
+
+There are four other model hooks that <tt>Sequel::Model</tt> supports, all related to transactions.  These are +after_commit+, +after_rollback+, +after_destroy_commit+, and +after_destroy_rollback+.  +after_commit+ is called after the transaction in which you saved the object commits, only if it commits.  +after_rollback+ is called after the transaction in which you saved the object rolls back, if it rolls back.  +after_destroy_commit+ is called after the transaction in which you destroyed the object commits, if it commits.  +after_destroy_rollback+ is called after the transaction in which you destroyed the object rolls back, if it rolls back.
+
+If you aren't using transactions when saving or destroying model objects, and there isn't a currently open transaction, +after_commit+ and +after_destroy_commit+ will be called after +after_save+ and +after_destroy+, respectively, and +after_rollback+ and +after_destroy_rollback+ won't be called at all.
+
+The purpose of these hooks is dealing with external systems that are interacting with the same database.  For example, let's say you have a model that stores a picture, and you have a background job library that makes thumbnails of all of the pictures.  So when a model object is created, you want to add a background job that will create the thumbnail for the picture.  If you used after_save for this and transactions are being used, you are subject to a race condition where the background job library will check the database table for the record before the transaction that saved the record commits, and it won't be able to see the record's data.  Using after_commit, you are guaranteed that the background job library will not get notified of the record until after the transaction commits and the data is viewable.
 
 == Running Hooks
 
@@ -98,7 +116,7 @@ If you want to insert a row into the model's table without running the creation
 
 == Halting Hook Processing
 
-Sequel uses a convention that if any <tt>before_*</tt> hook method returns false (but not nil), that the action will be canceled.  You can use this to implement validation-like behavior, that will run even if validations are skipped.  For example:
+Sequel uses a convention that if any <tt>before_*</tt> hook method returns false (but not nil), that the action will be canceled and a <tt>Sequel::HookFailed</tt> raised (or +nil+ to be returned by +save+ if +raise_on_save_failure+ is +false+).  You can use this to implement validation-like behavior, that will run even if validations are skipped.  For example:
 
   class Album < Sequel::Model
     def before_save
@@ -107,9 +125,9 @@ Sequel uses a convention that if any <tt>before_*</tt> hook method returns false
     end
   end
 
-While returning false is not really recommended, you should be aware of this behavior so that you do not inadvertently return false.
+While returning false is not really recommended, you should be aware of this behavior so that you do not inadvertently return false.  For around hooks, neglecting to call +super+ halts hook processing in the same way as returning +false+ in a before hook.  You can't halt hook processing in after hooks, since by then the main processing has already taken place.
 
-By default, Sequel runs hooks other than validation hooks inside a transaction, so if you abort the hook by returning false in a before hook or by raising an exception in the hook, Sequel will rollback the transaction.  However, note that the implicit use of transactions when saving and destroying model objects is conditional (it depends on the model instance's +use_transactions+ setting).
+By default, Sequel runs hooks other than validation hooks inside a transaction, so if you abort the hook by returning false in a before hook or by raising an exception in any hook, Sequel will rollback the transaction.  However, note that the implicit use of transactions when saving and destroying model objects is conditional (it depends on the model instance's +use_transactions+ setting and the <tt>:transaction</tt> option passed to save).
 
 == Conditional Hooks
 
@@ -183,6 +201,7 @@ This allows the following general principles to be true:
 
 * before hooks are run in reverse order of inclusion
 * after hooks are run in order of inclusion
+* returning false in any before hook will pass the false value down the hook method chain, halting the hook processing.
 
 So if you define the same before hook in both a model and a plugin that the model uses, the hooks will be called in this order:
 
@@ -193,6 +212,32 @@ So if you define the same before hook in both a model and a plugin that the mode
 
 Again, Sequel does not enforce that, and you are free to call +super+ in an order other than the recommended one (just make sure that you call it).
 
+== Around Hooks
+
+Around hooks should only be used if you cannot accomplish the same results with before and after hooks.  For example, if you want to catch database errors caused by the +INSERT+ or +UPDATE+ query when saving a model object and raise them as validation errors, you cannot use a before or after hook.  You have use an +around_save+ hook:
+
+  class Album < Sequel::Model
+    def around_save
+      super
+    rescue Sequel::DatabaseError => e
+      # parse database error, set error on self, and reraise a Sequel::ValidationFailed
+    end
+  end
+ 
+Likewise, let's say that upon retrieval, you associate an object with a file descriptor, and you want to ensure that the file descriptor is closed after the object is saved to the database.  Let's assume you are always saving the object and you are not using validations.  You could not use an +after_save+ hook safely, since if the database raises an error, the +after_save+ method will not be called.  In this case, an +around_save+ hook is also the correct choice:
+
+  class Album < Sequel::Model
+    def around_save
+      super
+    ensure
+      @file_descriptor.close
+    end
+  end
+
 == +hook_class_methods+
 
-While it's recommended to write your hooks as instance methods, Sequel ships with a +hook_class_methods+ plugin that allows you to define hooks via class methods. It exists mostly for legacy compatibility, but is still supported. 
+While it's recommended to write your hooks as instance methods, Sequel ships with a +hook_class_methods+ plugin that allows you to define hooks via class methods. It exists mostly for legacy compatibility, but is still supported.  However, it does not implement around hooks.
+
+== +instance_hooks+
+
+Sequel also ships with an +instance_hooks+ plugin that allows you to define before and after hooks on a per instance basis.  It's very useful as it allows you to delay action on an instance until before or after saving.  This can be important if you want to modify a group of related objects together (which is how the +nested_attributes+ plugin uses +instance_hooks+).

data/doc/opening_databases.rdoc

@@ -46,6 +46,13 @@ unless the first argument is a hash. So the following statements are equivalent
   DB = Sequel.postgres('blog', :host=>'localhost', :user=>'user', :password=>'password')
   DB = Sequel.postgres(:host=>'localhost', :user=>'user', :password=>'password', :database=>'blog')
 
+Note that using an adapter method forces the use of the specified adapter, not a database type, even
+though some adapters have the same name as the database type.  So if you
+want to connect to SQLite, for example, you can do so using the sqlite, do, dbi, jdbc, odbc, and swift adapters.
+If you want to connect to SQLite on JRuby using the jdbc adapter, you should not use <tt>Sequel.sqlite</tt>
+for example, as that uses the C-based sqlite3 gem. Instead, the <tt>Sequel.jdbc</tt> would be appropriate (though
+as mentioned below, using <tt>Sequel.connect</tt> is recommended instead of <tt>Sequel.jdbc</tt>). 
+
 == Passing a block to either method
 
 Both the Sequel.connect method and the specialized adapter methods take a block.  If you
@@ -59,24 +66,24 @@ For example:
 
 These options are shared by all adapters unless otherwise noted.
 
-* :adapter - The adapter to use
-* :database - The name of the database to which to connect
-* :default_schema - The database schema to use by default.
-* :host - The hostname of the database server to which to connect
-* :logger - An array of SQL loggers to log to
-* :loggers - An array of SQL loggers to log to
-* :password - The password for the user account
-* :servers - A hash with symbol keys and hash or proc values, used with master/slave/partitioned database configurations
-* :single_threaded - Whether to use a single-threaded (non-thread safe) connection pool
-* :test - Whether to test that a valid database connection can be made (false by default)
-* :user - The user account name to use logging in
+:adapter :: The adapter to use
+:database :: The name of the database to which to connect
+:default_schema :: The database schema to use by default.
+:host :: The hostname of the database server to which to connect
+:logger :: An array of SQL loggers to log to
+:loggers :: An array of SQL loggers to log to
+:password :: The password for the user account
+:servers :: A hash with symbol keys and hash or proc values, used with master/slave/partitioned database configurations
+:single_threaded :: Whether to use a single-threaded (non-thread safe) connection pool
+:test :: Whether to test that a valid database connection can be made (false by default)
+:user :: The user account name to use logging in
 
 The following options can be specified and are passed to the the database's internal connection pool.
 
-* :after_connect - A proc called after a new connection is made, with the connection object (default: nil)
-* :max_connections - The maximum size of the connection pool (default: 4 connections on most databases)
-* :pool_sleep_time - The number of seconds to sleep before trying to acquire a connection again (default: 0.001 seconds)
-* :pool_timeout - The number of seconds to wait if a connection cannot be acquired before raising an error (default: 5 seconds)
+:after_connect :: A proc called after a new connection is made, with the connection object (default: nil)
+:max_connections :: The maximum size of the connection pool (default: 4 connections on most databases)
+:pool_sleep_time :: The number of seconds to sleep before trying to acquire a connection again (default: 0.001 seconds)
+:pool_timeout :: The number of seconds to wait if a connection cannot be acquired before raising an error (default: 5 seconds)
 
 == Adapter specific connection options
 
@@ -131,8 +138,8 @@ Amalgalite is an ruby extension that provides self contained access to SQLite,
 so you don't need to install SQLite separately.  As amalgalite is a file backed
 database, the :host, :user, and :password options are not used.
 
-* :database - The name of the database file
-* :timeout - The busy timeout period given in milliseconds
+:database :: The name of the database file
+:timeout :: The busy timeout period given in milliseconds
 
 Without a database argument, assumes a memory database, so you can do:
 
@@ -145,17 +152,15 @@ the sqlite section below for details.
 
 Requires: db2/db2cli
 
-I'm not even sure exactly how this works, or if it works at all (I've never heard from
-anyone who attempted to use it).  It uses the SQL_HANDLE_DBC constant to
-get a handle, and respects the :database, :user, and :password options.  It doesn't
-appear to respect the :host or :port options.
+This is the older DB2 adapter.  It's recommended you try the ibmdb adapter
+instead for new DB2 work, as it is better supported.
 
 === dbi 
 
 Allows access to a multitude of databases via ruby-dbi.  Additional options:
 
-* :db_type - Specifying 'mssql' allows Microsoft SQL Server specific syntax to
-  be used.  Otherwise has no effect.
+:db_type :: Specifying 'mssql' allows Microsoft SQL Server specific syntax to
+            be used.  Otherwise has no effect.
 
 DBI connection strings are a preprocessed a bit, and are specified with a dbi-
 in front of the protocol.  Examples:
@@ -201,6 +206,13 @@ Requires: fb (using code at http://github.com/wishdev/fb)
 
 Does not support the :port option.
 
+=== ibmdb
+
+requires 'ibm_db'
+
+This connects to DB2 using IBM_DB.  This is the recommended adapter if you are
+using a C-based ruby to connect to DB2.
+
 === informix 
 
 Does not support the :host or :port options.  Depending on the configuration of your server
@@ -221,7 +233,7 @@ Requires: java
 Houses Sequel's JDBC support when running on JRuby.
 Support for individual database types is done using sub adapters.
 There are currently subadapters for PostgreSQL, MySQL, SQLite, H2,
-Oracle, MSSQL, JTDS, and AS400.  All except Oracle, MSSQL, and AS400 can load the
+Oracle, MSSQL, JTDS, AS400, and DB2.  All except Oracle, MSSQL, AS400, and DB2 can load the
 jdbc-* gem, for those you need to have the .jar in your CLASSPATH
 or load the Java class manually before calling Sequel.connect.
 
@@ -246,37 +258,51 @@ Example connection strings:
   jdbc:postgresql://localhost/database?user=username
   jdbc:mysql://localhost/test?user=root&password=root
   jdbc:h2:mem:
+  jdbc:hsqldb:mem:mymemdb
+  jdbc:derby:memory:myDb;create=true
   jdbc:sqlserver://localhost;database=sequel_test;integratedSecurity=true
   jdbc:jtds:sqlserver://localhost/sequel_test;user=sequel_test;password=sequel_test
-  
+  jdbc:oracle:thin:user/password@localhost:1521:database
+  jdbc:db2://localhost:3700/database:user=user;password=password;
+  jdbc:firebirdsql:localhost/3050:/path/to/database.fdb
+
 You can also use JNDI connection strings:
 
   jdbc:jndi:java:comp/env/jndi_resource_name
 
 The following additional options are supported:
 
-* :convert_types - If set to false, does not attempt to convert some Java types to ruby types.
-  Setting to false roughly doubles performance when selecting large numbers of rows.
-  Note that you can't provide this option inside the connection string (as that is passed
-  directly to JDBC), you have to pass it as a separate option.
+:convert_types :: If set to false, does not attempt to convert some Java types to ruby types.
+                  Setting to false roughly doubles performance when selecting large numbers of rows.
+                  Note that you can't provide this option inside the connection string (as that is passed
+                  directly to JDBC), you have to pass it as a separate option.
+:login_timeout :: Set the login timeout on the JDBC connection (in seconds).
 
 === mysql 
 
+Requires: mysqlplus (or mysql if mysqlplus is not available)
+
 The MySQL adapter does not support the pure-ruby MySQL adapter that used to ship with
 ActiveRecord, it requires the native adapter.
 
 The following additional options are supported:
 
-* :auto_is_null - If set to true, makes "WHERE primary_key IS NULL" select the last inserted id.
-* :charset - Same as :encoding, :encoding takes precedence.
-* :compress - Whether to compress data sent/received via the socket connection.
-* :config_default_group - The default group to read from the in the MySQL config file.
-* :config_local_infile - If provided, sets the Mysql::OPT_LOCAL_INFILE option on the connection with the given value.
-* :encoding - Specify the encoding/character set to use for the connection.
-* :socket - Can be used to specify a Unix socket file to connect to instead of a TCP host and port.
-* :timeout - Sets the wait_timeout for the connection, defaults to 1 month.
-* :read_timeout - Set the timeout in seconds for reading back results to a query.
-* :connect_timeout - Set the timeout in seconds before a connection attempt is abandoned.
+:auto_is_null :: If set to true, makes "WHERE primary_key IS NULL" select the last inserted id.
+:charset :: Same as :encoding, :encoding takes precedence.
+:compress :: Whether to compress data sent/received via the socket connection.
+:config_default_group :: The default group to read from the in the MySQL config file.
+:config_local_infile :: If provided, sets the Mysql::OPT_LOCAL_INFILE option on the connection with the given value.
+:encoding :: Specify the encoding/character set to use for the connection.
+:socket :: Can be used to specify a Unix socket file to connect to instead of a TCP host and port.
+:timeout :: Sets the wait_timeout for the connection, defaults to 1 month.
+:read_timeout :: Set the timeout in seconds for reading back results to a query.
+:connect_timeout :: Set the timeout in seconds before a connection attempt is abandoned.
+
+=== mysql2
+
+This is a newer MySQL adapter that does typecasting in C, so it is often faster than the
+mysql adapter.  Supports the same additional options as the mysql adapter, except for :compress, and uses
+:timeout instead of :read_timeout and :connect_timeout.
 
 === odbc 
 
@@ -287,8 +313,8 @@ The :database option given ODBC database should be the DSN (Descriptive Service
 
 The :host and :port options are not respected. The following additional options are supported:
 
-* :db_type - Can be specified as 'mssql' or 'progress' to use SQL syntax specific to those databases.
-* :driver - The name of the ODBC driver to utilize.
+:db_type :: Can be specified as 'mssql' or 'progress' to use SQL syntax specific to those databases.
+:driver :: The name of the ODBC driver to utilize.
 
 === openbase 
 
@@ -300,7 +326,11 @@ Requires: oci8
 
 The following additional options are supported:
 
-* :privilege - The Oracle privilege level.
+:autosequence :: Set to true to use Sequel's conventions to guess the sequence to use for datasets.  False
+                 by default.
+:prefetch_rows :: The number of rows to prefetch.  Defaults to 1, a larger number can be specified
+                  and will improve performance when retrieving a large number of rows.
+:privilege :: The Oracle privilege level.
 
 === postgres
 
@@ -311,11 +341,15 @@ The pg library is the best supported, as it supports real bound variables and pr
 
 The following additional options are supported:
 
-* :charset - Same as :encoding, :encoding takes precedence
-* :encoding - Set the client_encoding to the given string
+:charset :: Same as :encoding, :encoding takes precedence
+:encoding :: Set the client_encoding to the given string
+:connect_timeout :: Set the number of seconds to wait for a connection (default 20, only respected
+                    if using the pg library).
 
 === sqlite
 
+Requires: sqlite3
+
 As SQLite is a file-based database, the :host and :port options are ignored, and
 the :database option should be a path to the file.
 
@@ -337,7 +371,7 @@ Examples:
 
 The following additional options are supported:
 
-* :timeout - the busy timeout to use in milliseconds (default: 5000).
+:timeout :: the busy timeout to use in milliseconds (default: 5000).
 
 === swift
 
@@ -353,16 +387,21 @@ Examples:
 
 === tinytds
 
+Requires: tiny_tds
+
 Because the underscore is not a valid character in a URI schema, the adapter
 is named tinytds instead of tiny_tds.  The connection options are passed directly
-to tiny_tds, except that the tiny_tds :dataserver and :username options are set to
-the Sequel :host and :user options.  The :host option should be an entry in the
-freetds.conf file, it's not currently possible to a host not present in the
-freetds.conf file.  Some options that you may want to set are
-:login_timeout, :timeout, :appname, and :encoding, see the tiny_tds README for details.
+to tiny_tds, except that the tiny_tds :username option is set to
+the Sequel :user option.  If you want to use an entry in the freetds.conf file, you
+should specify the :dataserver option with that name as the value.  Some other
+options that you may want to set are :login_timeout, :timeout, :tds_version, :azure,
+:appname, and :encoding, see the tiny_tds README for details.
+
 For highest performance, you should disable any identifier output method when
 using the tinytds adapter, which probably means disabling any identifier input method
 as well.  The default for Microsoft SQL Server is to :downcase identifiers on output
 and :upcase them on input, so the highest performance will require changing the setting
 from the default.
 
+The Sequel tinytds adapter requires tiny_tds >= 0.4.5, and if you are using FreeTDS
+0.91, you must at least be using 0.91rc2 (0.91rc1 does not work).

data/doc/prepared_statements.rdoc

@@ -3,15 +3,22 @@
 Sequel has support for prepared statements and bound variables.  No matter which
 database you are using, the Sequel prepared statement/bound variable API remains
 the same.  There is native support for prepared statements/bound variables on
-the following databases:
+the following adapters:
 
-* PostgreSQL (using the pg driver, requires type specifiers)
-* MySQL (prepared statements only, as the ruby mysql driver doesn't support
-  bound variables)
-* SQLite
-* JDBC
+* ibmdb (prepared statements only)
+* jdbc
+* mysql (prepared statements only)
+* mysql2 (prepared statements only)
+* oracle (requires type specifiers for nil/NULL values)
+* postgres (when using the pg driver, may require type specifiers)
+* sqlite
+* tinytds
 
-Support on other databases is emulated via string interpolation.
+Support on other adapters is emulated via string interpolation.
+
+You can use the prepared_statements model plugin to automatically use prepared
+statements for some common model actions such as saving or deleting a model
+instance, or looking up a model based on a primary key.
 
 == Placeholders
 
@@ -74,20 +81,20 @@ and update queries, the hash to insert/update is passed to +prepare+:
 
 If you are using the ruby-postgres or postgres-pr driver, PostgreSQL uses the
 default emulated support.  If you are using ruby-pg, there is native support,
-but it requires type specifiers most of the time.  This is easy if you have
+but it may require type specifiers on some old versions (generally not anymore).
 direct control over the SQL string, but since Sequel abstracts that, the types
-have to be specified another way.  This is done by adding a __* suffix to the
-placeholder symbol (e.g. :$name__text, which will be compiled to "$1::text"
-in the SQL).  Prepared statements are always server side.
+You can add a __* suffix to the placeholder symbol to specify a type, which
+casts to that type in the SQL (e.g.  :$name__text, which will be compiled to
+"$1::text" in the SQL).  Prepared statements are always server side.
 
 === SQLite
 
 SQLite supports both prepared statements and bound variables.  Prepared
 statements are cached per connection.
 
-=== MySQL
+=== MySQL/Mysql2
 
-The MySQL ruby driver does not support bound variables, so the the bound
+The MySQL/Mysql2 ruby drivers do not support bound variables, so the bound
 variable methods fall back to string interpolation.  It uses server side
 prepared statements.
 
@@ -99,6 +106,26 @@ over JDBC, you can add the prepareThreshold=N parameter to the connection
 string, which will use a server side prepared statement after N calls to
 the prepared statement.
 
+=== TinyTDS
+
+Uses the sp_executesql stored procedure with bound variables, since
+Microsoft SQL Server doesn't support true prepared statements.
+
+=== IBM_DB
+
+DB2 supports both prepared statements and bound variables.  Prepared
+statement objects are cached per connection.
+
+=== Oracle
+
+Oracle supports both prepared statements and bound variables.  Prepared
+statements (OCI8::Cursor objects) are cached per connection.  If you
+ever plan to use a nil/NULL value as a bound variable/prepared statement
+value, you must specify the type in the placeholder using a __* suffix.
+You can use any of the schema types that Sequel supports, such as
+:$name__string or :$num__integer.  Using blobs as bound variables is
+not currently supported.
+
 === All Others
 
 Support is emulated using interpolation.

data/doc/reflection.rdoc

@@ -16,13 +16,19 @@ In some cases, the adapter scheme will be the same as the database to which you
 
 == Tables in the Database
 
-On many database types/adapters, Database#tables exists and gives an array of table name symbols:
+Database#tables gives an array of table name symbols:
+
+  DB.tables # [:table1, :table2, :table3, ...]
+
+== Views in the Database
+
+Database#views and gives an array of view name symbols:
 
   DB.tables # [:table1, :table2, :table3, ...]
 
 == Indexes on a table
 
-On a few database types/adapters, Database#indexes takes a table name gives a hash of index information.  Keys are index names, values are subhashes with the keys :columns and :unique :
+Database#indexes takes a table name gives a hash of index information.  Keys are index names, values are subhashes with the keys :columns and :unique :
 
   DB.indexes(:table1) # {:index1=>{:columns=>[:column1], :unique=>false}, :index2=>{:columns=>[:column2, :column3], :unique=>true}}
 

data/doc/release_notes/3.22.0.txt

@@ -0,0 +1,39 @@
+= New Features
+
+* Support COLLATE in column definitions.  At least MySQL and Microsoft
+  SQL Server support them, and PostgreSQL 9.1 should as well.
+
+* When connecting to Microsoft SQL Server, you can use the
+  mssql_unicode_strings accessor to turn of the default usage
+  of unicode strings (N'') and use regular strings (''). This
+  can improve performance, but changes the behavior.  It's
+  set to true by default for backwards compatibility.  You can
+  change it at both the dataset and database level:
+
+    DB.mssql_unicode_strings = false # default for datasets
+    dataset.mssql_unicode_strings = false # just this dataset
+
+* In the oracle adapter, if Sequel.application_timezone is :utc, set
+  the timezone for the connection to use the 00:00 timezone.
+
+= Other Improvements
+
+* In the single_table_inheritance plugin, correctly handle a
+  multi-level class hierarchy so that loading instances from a
+  middle level of the hierarchy can return instances of subclasses.
+
+* Don't use a schema when creating a temporary table, even if
+  default_schema is set.
+
+* Fix the migrator when a default_schema is used.
+
+* In the ado adapter, assume a connection to SQL Server if the
+  :conn_string is given and doesn't indicate Access/Jet.
+
+* Fix fetching rows in the tinytds adapter when the
+  identifier_output_method is nil.
+
+* The tinytds adapter now checks for disconnect errors, but it might
+  not be reliable until the next release of tiny_tds.
+
+* The odbc adapter now handles ODBC::Time instances correctly.