sequel 3.21.0 → 3.24.0

data/CHANGELOG

@@ -1,3 +1,115 @@
+=== 3.24.0 (2011-06-01)
+
+* Add prepared_statements_association plugin, for using prepared statements by default for regular association loading (jeremyevans)
+
+* Add prepared_statements_safe plugin, for making prepared statement use with models more safe (jeremyevans)
+
+* Add prepared_statements_with_pk plugin, for using prepared statements for dataset lookups by primary key (jeremyevans)
+
+* Fix bug in emulated prepared statement support not supporting nil or false as bound values (jeremyevans)
+
+* Add Dataset#unbind for unbinding values from a dataset, for use with creating prepared statements (jeremyevans)
+
+* Add prepared_statements plugin for using prepared statements for updates, inserts, deletes, and lookups by primary key (jeremyevans)
+
+* Make Dataset#[] for model datasets consider a single integer argument as a lookup by primary key (jeremyevans)
+
+* Add Dataset#with_pk for model datasets, for finding first record with matching primary key value (jeremyevans)
+
+* Add defaults_setter plugin for setting default values when initializing model instances (jeremyevans)
+
+* Add around hooks (e.g. around_save) to Sequel::Model (jeremyevans)
+
+* Add Model#initialize_set private method to ease extension writing (jeremyevans)
+
+* Only typecast bit fields to booleans on MSSQL, the MySQL bit type is a bitfield, not a boolean (jeremyevans)
+
+* Set SQL_AUTO_IS_NULL=0 by default when connecting to MySQL via the swift and jdbc adapters (jeremyevans)
+
+* Fix bug in multiple column IN/NOT IN emulation when a model dataset is used (jeremyevans)
+
+* Add support for filtering and excluding by association datasets (jeremyevans)
+
+* Fix literalization of boolean values in filters on SQLite and MSSQL (jeremyevans)
+
+* Add support for filtering and excluding by multiple associations (jeremyevans)
+
+* Add support for inverting some SQL::Constant instances such as TRUE, FALSE, NULL, and NOTNULL (jeremyevans)
+
+* Add support for excluding by associations to model datasets (jeremyevans)
+
+* The Sequel::Postgres.use_iso_date_format setting now only affects future Database objects (jeremyevans)
+
+* Add Sequel::Postgres::PG_NAMED_TYPES hash for extensions to register type conversions for non-standard types (jeremyevans, pvh)
+
+* Make create_table? use IF NOT EXISTS instead of using SELECT to determine existence, if supported (jeremyevans)
+
+* Fix bug in association_pks plugin when associated table has a different primary key column name (jfirebaugh)
+
+* Fix limiting rows when connecting to DB2 (semmons99)
+
+* Exclude columns from tables in the INFORMATION_SCHEMA when parsing table schema on JDBC (jeremyevans)
+
+* Fix limiting rows when connecting to Microsoft Access (jeremyevans)
+
+* Add Database#views for getting an array of symbols of view names for the database (jeremyevans, christian.michon)
+
+* Make Datbase#tables no longer include view names on MySQL (jeremyevans)
+
+* Convert Java CLOB objects to ruby strings when using the JDBC JTDS subadapter (christian.michon)
+
+* If Thread#kill is called on a thread with an open transaction, roll the transaction back on ruby 1.8 and rubinius (jeremyevans)
+
+* Split informix adapter into shared/specific parts, add JDBC informix subadapter (jeremyevans)
+
+=== 3.23.0 (2011-05-02)
+
+* Migrate issue tracker from Google Code to GitHub Issues (jeremyevans)
+
+* Add support for filtering by associations to model datasets (jeremyevans)
+
+* Don't call insert_select when saving a model that doesn't select all columns of the table (jeremyevans)
+
+* Fix bug when using :select=>[] option for a many_to_many association (jeremyevans)
+
+* Add a columns_introspection extension that attempts to skip database queries by introspecting selected columns (jeremyevans)
+
+* When combining old integer migrations and new timestamp migrations, make sure old integer migrations are all applied first (jeremyevans)
+
+* Support dynamic callbacks to customize regular association loading at query time (jeremyevans)
+
+* Support cascading of eager loading with dynamic callbacks for both eager and eager_graph (jeremyevans)
+
+* Make the xml_serializer plugin handle namespaced models by using __ instead of / as a separator (jeremyevans)
+
+* Allow the :eager_grapher association proc to accept a single hash instead of 3 arguments (jfirebaugh)
+
+* Support dynamic callbacks to customize eager loading at query time (jfirebaugh, jeremyevans)
+
+* Fix bug in the identity_map plugin for many_to_one associations when the association reflection hadn't been filled in yet (funny-falcon)
+
+* Add serialization_modification_detection plugin for detecting changes in serialized columns (jeremyevans) (#333)
+
+=== 3.22.0 (2011-04-01)
+
+* Add disconnect detection to tinytds adapter, though correct behavior may require an update to tiny_tds (cult_hero)
+
+* Add Dataset/Database#mssql_unicode_strings accessor when connecting to MSSQL to control string literalization (semmons99, jeremyevans)
+
+* Fix ODBC::Time instance handling in the odbc adapter (jeremyevans)
+
+* Use Sequel.application_timezone when connecting in the oracle adapter to set the connection's session's timezone (jmthomas)
+
+* In the ADO adapter, assume access to SQL Server if a :conn_string option is given that doesn't indicate Access/Jet (damir.si) (#332)
+
+* Use the correct class when loading instances for descendents of model classes that use single table inheritance (jeremyevans)
+
+* Support for COLLATE in column definitions (jfirebaugh)
+
+* Don't use a schema when creating a temporary table (jeremyevans)
+
+* Make migrator work correctly when a default_schema is set (jeremyevans) (#331)
+
 === 3.21.0 (2011-03-01)
 
 * Make symbol splitting (:table__column___alias) work correctly for identifiers that are not in the \w character class (authorNari)

data/README.rdoc

@@ -20,7 +20,7 @@ toolkit for Ruby.
 * {Website}[http://sequel.rubyforge.org]
 * {Blog}[http://sequel.heroku.com]
 * {Source code}[http://github.com/jeremyevans/sequel]
-* {Bug tracking}[http://code.google.com/p/ruby-sequel/issues/list]
+* {Bug tracking}[http://github.com/jeremyevans/sequel/issues]
 * {Google group}[http://groups.google.com/group/sequel-talk]
 * {RDoc}[http://sequel.rubyforge.org/rdoc]
 
@@ -685,6 +685,20 @@ Associations can be eagerly loaded via +eager+ and the <tt>:eager</tt> associati
 
 In addition to using +eager+, you can also use +eager_graph+, which will use a single query to get the object and all associated objects.  This may be necessary if you want to filter or order the result set based on columns in associated tables.  It works with cascading as well, the syntax is exactly the same.  Note that using eager_graph to eagerly load multiple *_to_many associations will cause the result set to be a cartesian product, so you should be very careful with your filters when using it in that case.
 
+You can dynamically customize the eagerly loaded dataset by using using a proc.  This proc is passed the dataset used for eager loading, and should return a modified copy of that dataset:
+
+  # Eagerly load only replies containing 'foo'
+  Post.eager(:replies=>proc{|ds| ds.filter(text.like('%foo%'))}).all
+
+This also works when using +eager_graph+, in which case the proc is called with dataset to graph into the current dataset:
+
+  Post.eager_graph(:replies=>proc{|ds| ds.filter(text.like('%foo%'))}).all
+
+You can dynamically customize eager loads for both +eager+ and +eager_graph+ while also cascading, by making the value a single entry hash with the proc as a key, and the cascaded associations as the value:
+
+  # Eagerly load only replies containing 'foo', and the person and tags for those replies
+  Post.eager(:replies=>{proc{|ds| ds.filter(text.like('%foo%'))}=>[:person, :tags]}).all
+
 === Extending the underlying dataset
 
 The obvious way to add table-wide logic is to define class methods to the model class definition. That way you can define subsets of the underlying dataset, change the ordering, or perform actions on multiple records:

data/doc/association_basics.rdoc

@@ -293,32 +293,6 @@ Examples:
   @artist.remove_album(@album)
   @artist.remove_all_albums
 
-== Dataset Method
-
-In addition to the above methods, associations also add a instance method
-ending in +_dataset+ that returns a dataset representing the objects in the associated table:
-
-  @album.artist_id
-  # 10
-  @album.artist_dataset
-  # SELECT * FROM artists WHERE (id = 10)
-  
-  @artist.id
-  # 20
-  @artist.albums_dataset
-  # SELECT * FROM albums WHERE (artist_id = 20)
-
-The association dataset is just like any other Sequel dataset, in that
-it can be further filtered, ordered, etc.:
-
-  @artist.albums_dataset.
-   filter(:name.like('A%')).
-   order(:copies_sold).
-   limit(10)
-  # SELECT * FROM albums
-  # WHERE ((artist_id = 20) AND (name LIKE 'A%'))
-  # ORDER BY copies_sold LIMIT 10
-
 == Caching
 
 Associations are cached after being retrieved:
@@ -352,13 +326,150 @@ instance method:
   @album.artists # [<Artist ...>, ...]
   @album.associations[:artists] # [<Artist ...>, ...]
 
-Note that while the association method caches associated objects, if you
-retrieve access through the association dataset directly, the results
-will not be cached:
+== Dataset Method
+
+In addition to the above methods, associations also add a instance method
+ending in +_dataset+ that returns a dataset representing the objects in the associated table:
+
+  @album.artist_id
+  # 10
+  @album.artist_dataset
+  # SELECT * FROM artists WHERE (id = 10)
+  
+  @artist.id
+  # 20
+  @artist.albums_dataset
+  # SELECT * FROM albums WHERE (artist_id = 20)
+
+The association dataset is just like any other Sequel dataset, in that
+it can be further filtered, ordered, etc.:
+
+  @artist.albums_dataset.
+   filter(:name.like('A%')).
+   order(:copies_sold).
+   limit(10)
+  # SELECT * FROM albums
+  # WHERE ((artist_id = 20) AND (name LIKE 'A%'))
+  # ORDER BY copies_sold LIMIT 10
+
+Records retrieved using the +_dataset+ method are not cached in the
+associations cache.
 
   @album.artists_dataset.all # [<Artist ...>, ...]
   @album.associations[:artists] # nil
 
+== Dynamic Association Modification
+
+Similar to the +_dataset+ method, you can provide a block to the association
+method to customize the dataset that will be used to retrieve the records.  So
+you can apply a filter in either of these two ways:
+
+  @artist.albums_dataset.filter(:name.like('A%'))
+  @artist.albums{|ds| ds.filter(:name.like('A%'))}
+
+While they both apply the same filter, using the +_dataset+ method does not
+apply any of the association callbacks or handle association reciprocals (see
+below for details about callbacks and reciprocals).  Using a block instead handles
+all those things, and also caches its results in the associations cache (ignoring
+any previously cached value).
+
+Note that if you are using ruby 1.8.6, you can't pass a block to the association
+method, you have to pass a proc as an argument:
+
+  @artist.albums(proc{|ds| ds.filter(:name.like('A%'))})
+
+== Filtering By Associations
+
+In addition to using the association method to get associated objects, you
+can also use associated objects in filters.  For example, while to get
+all albums for a given artist, you would usually do:
+
+  @artist.albums
+  # or @artist.albums_dataset for a dataset
+
+You can also do the following:
+
+  Album.filter(:artist=>@artist).all
+  # or leave off the .all for a dataset
+
+For filtering by a single association, this isn't very useful.  However, unlike
+using the association method, using a filter allows you to filter by multiple
+associations:
+
+  Album.filter(:artist=>@artist, :publisher=>@publisher)
+
+This will return all albums by that artist and published by that publisher.
+This isn't possible using just the association method approach, though you
+can combine the approaches:
+
+  @artist.albums_dataset.filter(:publisher=>@publisher)
+
+This doesn't just work for +many_to_one+ associations, it also works for
++one_to_one+, +one_to_many+, and +many_to_many+ associations:
+
+  Album.one_to_one :album_info
+  # The album related to that AlbumInfo instance
+  Album.filter(:album_info=>AlbumInfo[2])
+
+  Album.one_to_many :tracks
+  # The album related to that Track instance
+  Album.filter(:tracks=>Track[3])
+
+  Album.many_to_many :tags
+  # All albums related to that Tag instance
+  Album.filter(:tags=>Tag[4])
+
+Note that for +one_to_many+ and +many_to_many+ associations, you still
+use the plural form even though only a single model object is given.
+
+You can also exclude by associations:
+
+  Album.exclude(:artist=>@artist).all
+  
+This will return all albums not by that artist.
+
+You can also provide an array with multiple model objects:
+
+  Album.filter(:artist=>[@artist1, @artist2]).all
+
+Similar to using an array of integers or strings, this will return
+all albums whose artist is one of those two artists.  You can also
+use +exclude+ if you want all albums not by either of those artists:
+
+  Album.exclude(:artist=>[@artist1, @artist2]).all
+
+If you are using a +one_to_many+ or +many_to_many+ association, you
+may want to return records where the records matches all of multiple
+records, instead of matching any of them.  For example:
+
+  Album.filter(:tags=>[@tag1, @tag2])
+  
+This matches albums that are associated with either @tag1 or @tag2 or
+both.  If you only want ones that you are associated with both, you can
+use separate filter calls:
+
+  Album.filter(:tags=>@tag1).filter(:tags=>@tag2)
+
+Or the the array form of condition specifiers:
+
+  Album.filter([[:tags, @tag1], [:tags, @tag2]])
+
+These will return albums associated with both @tag1 and @tag2.
+
+You can also provide a dataset value when filtering by associations:
+
+  Album.filter(:artist=>Artist.filter(:name.like('A%'))).all
+
+This will return all albums whose artist starts with 'A'. Like
+the other forms, this can be inverted:
+
+  Album.exclude(:artist=>Artist.filter(:name.like('A%'))).all
+ 
+This will return all albums whose artist does not start with 'A'.
+
+Note that filtering by associations only works correctly for simple
+associations (ones without conditions).
+
 == Name Collisions
 
 Because associations create instance methods, it's possible to override
@@ -1221,22 +1332,30 @@ a JOIN USING or NATURAL JOIN for the graph:
 ==== :eager_grapher
 
 Sets up a custom grapher to use when eager loading the objects via eager_graph.
-This is the eager_graph analogue to the :eager_loader option.
+This is the eager_graph analogue to the :eager_loader option. This isn't generally
+needed, as one of the other eager_graph related association options is usually sufficient.
+
+If specified, should be a proc that accepts one or three three arguments.
+If the proc takes one argument, it will be given a hash with the following keys:
 
-If specified, should be a proc that accepts three three arguments: a dataset,
-an alias to use for the table to graph for this association, and the alias that
-was used for the current table (since you can cascade associations). Should
-return a modified copy of the dataset with the association graphed into it.
+:self :: The dataset that is doing the eager loading
+:table_alias :: An alias to use for the table to graph for this association.
+:implicit_qualifier :: The alias that was used for the current table (since you can cascade associations).
+:callback :: A callback proc used to dynamically modify the dataset to graph into the
+             current dataset, before such graphing is done. This is nil if no callback
+             proc is used.
+
+If the proc takes three arguments, it gets passed the :self, :association_alias,
+and :table_alias values. The 3 argument procs are allowed for backwards
+compatibility, and it is recommended to use the 1 argument proc format
+for new code.
 
   Artist.one_to_many :self_title_albums, :class=>:Album,
-   :eager_grapher=>(proc do |ds, ta, iq|
-    ds.graph(Album, {:artist_id=>:id, :name=>:name},
-      :table_alias=>ta, :implicit_qualifier=>iq)
+   :eager_grapher=>(proc do |eo|
+    eo[:self].graph(Album, {:artist_id=>:id, :name=>:name},
+      :table_alias=>eo[:table_alias], :implicit_qualifier=>eo[:implicit_qualifier])
   end)
 
-This isn't generally needed, as one of the other eager_graph related
-association options is usually sufficient.
-
 ==== :order_eager_graph
 
 Whether to add the order to the dataset's order when graphing via eager_graph.

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,51 @@ 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 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.  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+. 
 
 == Running Hooks
 
@@ -98,7 +108,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 +117,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 +193,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 +204,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/prepared_statements.rdoc

@@ -5,7 +5,7 @@ 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:
 
-* PostgreSQL (using the pg driver, requires type specifiers)
+* PostgreSQL (using the pg driver, may require type specifiers)
 * MySQL (prepared statements only, as the ruby mysql driver doesn't support
   bound variables)
 * SQLite
@@ -13,6 +13,10 @@ the following databases:
 
 Support on other databases 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
 
 Generally, when using prepared statements (and certainly when using bound
@@ -74,9 +78,9 @@ 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.  This is easy if you have
 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
+can 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.
 
@@ -87,7 +91,7 @@ statements are cached per connection.
 
 === MySQL
 
-The MySQL ruby driver does not support bound variables, so the the bound
+The MySQL ruby driver does not support bound variables, so the bound
 variable methods fall back to string interpolation.  It uses server side
 prepared statements.
 

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.