sequel 3.10.0 → 3.11.0

data/doc/dataset_basics.rdoc

@@ -0,0 +1,106 @@
+= Dataset Basics 
+
+== Introduction
+
+Datasets are probably the thing that separate Sequel from other database libraries.  While most database libraries have specific support for updating all records or only a single record, Sequel's ability to represent SQL queries themselves as objects is what gives Sequel most of its power.  However, if you haven't been exposed to the dataset concept before, it can be a little disorienting.  This document aims to give a basic introduction to datasets and how to use them.
+
+== What a Dataset Represents
+
+A Dataset can be thought of representing one of two concepts:
+
+* An SQL query
+* An abstract set of rows and some related behavior
+
+The first concept is more easily understood, so you should probably start with that assumption.
+
+== Basics
+
+The most basic dataset is the simple selection of all columns in a table:
+
+  ds = DB[:posts]
+  # SELECT * FROM posts
+  
+Here, DB represents your Sequel::Database object, and ds is your dataset, with the SQL query it represents below it.
+
+One of the core dataset ideas that should be understood is that datasets use a functional style of modification, in which methods called on the dataset return modified copies of the dataset, they don't modify the dataset themselves:
+
+  ds2 = ds.filter(:id=>1)
+  ds2
+  # SELECT * FROM posts WHERE id = 1
+  ds
+  # SELECT * FROM posts
+  
+Note how ds itself is not modified.  This is because ds.filter returns a modified copy of ds, instead of modifying ds itself.  This makes using datasets both thread safe and easy to chain:
+
+  # Thread safe:
+  100.times do |i|
+    Thread.new do
+      ds.filter(:id=>i).first
+    end
+  end
+  
+  # Easy to chain:
+  ds3 = ds.select(:id, :name).order(:name).filter{id < 100}
+  # SELECT id, name FROM posts WHERE id < 100 ORDER BY name
+
+Thread safety you don't really need to worry about, but chainability is core to how Sequel is generally used.  Almost all dataset methods that affect the SQL produced return modified copies of the receiving dataset.
+
+Another important thing to realize is that dataset methods that return modified datasets do not execute the dataset's code on the database.  Only dataset methods that return or yield results will execute the code on the database:
+
+  # No SQL queries sent:
+  ds3 = ds.select(:id, :name).order(:name).filter{id < 100}
+  
+  # Until you call a method that returns results
+  results = ds3.all
+  
+One important consequence of this API style is that if you use a method chain that includes both methods that return modified copies and a method that executes the SQL, the method that executes the SQL should generally be the last method in the chain:
+
+  # Good
+  ds.select(:id, :name).order(:name).filter{id < 100}.all
+  
+  # Bad
+  ds.all.select(:id, :name).order(:name).filter{id < 100}
+  
+This is because all will return an array of hashes, and select, order, and filter are dataset methods, not array methods.
+
+== Methods
+
+Most Dataset methods that users will use can be broken down into two types:
+
+* Methods that return modified datasets
+* Methods that execute code on the database
+
+=== Methods that return modified datasets
+
+Most dataset methods fall into this category, which can be further broken down by the clause they affect:
+
+SELECT:: select, select_all, select_append, select_more
+FROM:: from, from_self
+JOIN:: join, join_table, 
+WHERE:: where, filter, exclude, and, or, grep, invert, unfiltered
+GROUP:: group, group_by, group_and_count, ungrouped
+HAVING:: having, filter, exclude, and, or, grep, invert, unfiltered
+ORDER:: order, order_by, order_more, reverse, reverse_order, unordered
+LIMIT:: limit
+compounds:: union, intersect, except
+locking:: for_update, lock_style
+common table expressions:: with, with_recursive
+qualification:: qualify, qualify_to, qualify_to_first_source
+inserting:: set_defaults, set_overrides
+other:: clone, distinct, naked, server, with_sql
+
+=== Methods that execute code on the database
+
+Most other dataset methods commonly used will execute the dataset's SQL on the database:
+
+SELECT (All Records):: all, each, map, to_hash, select_map, select_order_map, select_hash, to_csv
+SELECT (First Record):: first, last, get, []
+SELECT (Aggregates):: count, avg, max, min, sum, range, interval
+INSERT:: insert, <<, import, multi_insert, insert_multiple
+UPDATE:: update, set, []=
+DELETE:: delete
+other:: columns, columns!, truncate
+
+=== Other methods
+
+See the Sequel::Dataset RDoc for other methods that are less commonly used.

data/doc/opening_databases.rdoc

@@ -49,8 +49,8 @@ unless the first argument is a hash. So the following statements are equivalent
 == Passing a block to either method
 
 Both the Sequel.connect method and the specialized adapter methods take a block.  If you
-provide a block to the method, Sequel will open the connection and pass it as an argument
-to the block.  When the block is exited, Sequel will disconnect the database connection.
+provide a block to the method, Sequel will create a Database object and pass it as an argument
+to the block.  When the block returns, Sequel will disconnect the database connection.
 For example:
 
   Sequel.connect('sqlite://blog.db'){|db| puts db[:users].count}  
@@ -67,11 +67,13 @@ These options are shared by all adapters unless otherwise noted.
 * :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 the single-threaded (non-thread safe) connection pool
+* :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)
@@ -92,14 +94,24 @@ on WIN32OLE library, so it isn't usable on other operating systems (except
 possibly through WINE, but that's fairly unlikely).
 
 The following options are supported:
-* :driver - The driver to use.  The default if not specified is 'SQL Server'.
-* :command_timeout - Sets the time in seconds to wait while attempting
-  to execute a command before cancelling the attempt and generating
-  an error. Specifically, it sets the ADO CommandTimeout property.
-  If this property is not set, the default of 30 seconds is used.
-* :conn_string - The full ADO connection string.  If this is provided,
-  the general connection options are ignored.
-* :provider - Sets the Provider of this ADO connection (for example, "SQLOLEDB")
+
+:command_timeout :: Sets the time in seconds to wait while attempting
+                    to execute a command before cancelling the attempt and generating
+                    an error. Specifically, it sets the ADO CommandTimeout property.
+                    If this property is not set, the default of 30 seconds is used.
+:driver :: The driver to use in the ADO connection string.  If not provided, a default
+           of "SQL Server" is used.
+:conn_string :: The full ADO connection string.  If this is provided,
+                the usual options are ignored.
+:provider :: Sets the Provider of this ADO connection (for example, "SQLOLEDB").
+             If you don't specify a provider, the default one used by WIN32OLE
+             has major problems, such as creating a new native database connection
+             for every query, which breaks things such as transactions and temporary tables.
+
+Pay special attention to the :provider option, as without specifying a provider,
+many things will be broken.  The SQLNCLI10 provider appears to work well if you
+are connecting to Microsoft SQL Server, but it is not the default as that would
+break backwards compatability.
 
 === amalgalite 
 
@@ -188,9 +200,9 @@ 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, and MSSQL.  All except Oracle and MSSQL can load the
-JDBC gem, for those you need to have the .jar in your CLASSPATH
-or load the Java class manually.
+Oracle, MSSQL, JTDS, and AS400.  All except Oracle, MSSQL, and AS400 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.
 
 You just use the JDBC connection string directly, which can be specified
 via the string given to Sequel.connect or via the :uri, :url, or :database options.
@@ -198,12 +210,27 @@ Sequel does no preprocessing of the string, it passes it directly to JDBC.
 So if you have problems getting a connection string to work, look up the JDBC
 documentation.
 
-Example connections strings:
+Note that when using a JDBC adapter, the best way to use Sequel
+is via Sequel.connect, NOT Sequel.jdbc.  Use the JDBC connection
+string when connecting, which will be in a different format than
+the native connection string.  The connection string should start
+with 'jdbc:'.  For PostgreSQL, use 'jdbc:postgresql:', and for
+SQLite you do not need 2 preceding slashes for the database name
+(use no preceding slashes for a relative path, and one preceding
+slash for an absolute path).
+
+Example connection strings:
 
   jdbc:sqlite::memory:
   jdbc:postgresql://localhost/database?user=username
   jdbc:mysql://localhost/test?user=root&password=root
   jdbc:h2:mem:
+  jdbc:sqlserver://localhost;database=sequel_test;integratedSecurity=true
+  jdbc:jtds:sqlserver://localhost/sequel_test;user=sequel_test;password=sequel_test
+  
+You can also use JNDI connection strings:
+
+  jdbc:jndi:java:comp/env/jndi_resource_name
 
 The following additional options are supported:
 
@@ -214,7 +241,7 @@ The following additional options are supported:
 
 === mysql 
 
-The MySQL adapter does not support the pure-ruby MySQL adapter that ships with
+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:
@@ -222,6 +249,8 @@ 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.

data/doc/querying.rdoc

@@ -0,0 +1,210 @@
+= Querying in Sequel
+
+This guide is based on http://guides.rubyonrails.org/active_record_querying.html
+
+== Purpose of this Guide
+
+Sequel is a simple to use, very flexible, and powerful database library
+that supports a wide variety of different querying methods.  This guide
+aims to be a gentle introduction to Sequel's querying support.
+
+While you can easily use raw SQL with Sequel, a large part of the
+advantage you get from using Sequel is Sequel's ability to abstract
+SQL from you and give you a much nicer interface.
+
+== Setup
+
+Some examples in this guide assume you will be using Sequel::Model
+for modeling, but most should work with plain datasets.  The examples
+specific to Sequel::Model will have [Sequel::Model] in the heading.
+
+Many of the examples in this guide will refer to the following model
+classes:
+
+  # All classes use :id as the primary key column
+  
+  class Artist < Sequel::Model
+    one_to_many :albums
+    one_to_one :address
+  end
+  
+  class Album < Sequel::Model
+    many_to_one :artist
+    one_to_many :tracks
+    many_to_many :tags
+  end
+  
+  class Address < Sequel::Model
+    many_to_one :artist
+  end
+  
+  class Tag < Sequel::Model
+    many_to_many :albums
+  end
+  
+  class Track < Sequel::Model
+    many_to_one :album
+  end
+
+If you want to play with the code examples, here's some Sequel code
+that will set up the database structure for you:
+
+  DB.create_table(:artists) do
+    primary_key :id
+    String :name
+  end
+  
+  DB.create_table(:albums) do
+    primary_key :id
+    foreign_key :artist_id, :artists
+    String :name
+  end
+  
+  DB.create_table(:addresses) do
+    primary_key :id
+    foreign_key :artist_id, :artists, :unique=>true
+    String :street
+    String :city
+    String :state
+    String :zip
+  end
+  
+  DB.create_table(:tags) do
+    primary_key :id
+    String :tag
+  end
+  
+  DB.create_table(:albums_tags) do
+    foreign_key :album_id, :albums
+    foreign_key :tag_id, :tags
+  end
+  
+  DB.create_table(:tracks) do
+    primary_key :id
+    foreign_key :album_id, :albums
+    Integer :number
+    String :name
+  end
+  
+== Retrieving Objects
+
+Sequel provides a few separate methods for retrieving objects from the
+database.  The underlying method is Sequel::Dataset#each, which yields each
+row as the Sequel::Database provides it.  However, while Dataset#each can and
+often is used directly, in many cases there is a more convenient retrieval
+method you can use.
+
+=== Sequel::Dataset
+
+If you are new to Sequel and aren't familiar with Sequel, you should probably
+read the {"Dataset Basics" guide}[link:files/doc/dataset_basics_rdoc.html],
+then come back here.
+
+=== Retrieving a Single Object
+
+Sequel offers quite a few ways to to retrieve a single object.
+
+==== Using a Primary Key [Sequel::Model]
+
+The <tt>Sequel::Model.[]</tt> is the easiest method to use to find a model instance
+by its primary key value:
+
+  # Find artist with primary key (id) 1
+  artist = Artist[1]
+  # SQL: SELECT * FROM artists WHERE id = 1
+  => #<Artist @values={:name=>"YJM", :id=>1}>
+
+If there is no record with the given primary key, nil will be returned.
+
+==== Using +first+
+
+If you just want the first record in the dataset,
+<tt>Sequel::Dataset#first</tt> is probably the most obvious method to use:
+
+  artist = Artist.first
+  # SQL: SELECT * FROM artists LIMIT 1
+  => #<Artist @values={:name=>"YJM", :id=>1}>
+
+Any options you pass to +first+ will be used as a filter:
+
+  artist = Artist.first(:name => 'YJM')
+  # SQL: SELECT * FROM artists WHERE (name = 'YJM') LIMIT 1
+  => #<Artist @values={:name=>"YJM", :id=>1}>
+  
+  artist = Artist.first(:name.like('Y%'))
+  # SQL: SELECT * FROM artists WHERE (name LIKE 'Y%') LIMIT 1
+  => #<Artist @values={:name=>"YJM", :id=>1}>
+  
+<tt>Sequel::Dataset#[]</tt> is basically an alias for +first+, except it
+requires an argument:
+
+  DB[:artists][:name => 'YJM']
+  # SQL: SELECT * FROM artists WHERE (name = 'YJM') LIMIT 1
+  => {:name=>"YJM", :id=>1}
+
+Note that while Model.[] allows you to pass a primary key directly,
+Dataset#[] does not.
+
+==== Using +last+
+
+If you want the last record in the dataset,
+<tt>Sequel::Dataset#last</tt> is an obvious method to use.  Note first
+that last requires that the dataset be ordered.  Without an order, any
+object can be considered the first as well as the last.
+
+  artist = Artist.order(:name).last
+  # SQL: SELECT * FROM artists ORDER BY name DESC LIMIT 1
+  => #<Artist @values={:name=>"YJM", :id=>1}>
+
+Note that all +last+ does is reverse the order of the dataset and then
+call +first+.  This is why +last+ raises a Sequel::Error if there is no
+order on the dataset, because otherwise it would provide the same record
+as +first+, and most users would fine that confusing.
+
+Note that +last+ is not necessarily going to give you the last record
+in the dataset unless you give the dataset an unambiguous order.
+
+==== Retrieving a Single Column Value
+
+Sometimes, intead of wanting an entire row, you only want the value of
+a specific column.  For this <tt>Sequel::Dataset#get</tt> is the method
+you want:
+
+  artist_name = Artist.get(:name)
+  # SQL: SELECT name FROM artists LIMIT 1
+  => "YJM"
+
+=== Retrieving Multiple Objects
+
+==== As a Array of Hashes or Model Objects
+
+In many cases, you want an array of all of the rows associated with the
+dataset, in which case <tt>Sequel::Dataset#all</tt> is the method you
+want to use:
+
+  artists = Artist.all
+  # SQL: SELECT * FROM artists
+  => [#<Artist @values={:name=>"YJM", :id=>1}>,
+      #<Artist @values={:name=>"AS", :id=>2}>]
+
+==== Using an Enumerable Interface
+
+<tt>Sequel::Dataset</tt> uses an Enumerable Interface, so it provides a
+method named each that yields hashes or model objects as they are retrieved
+from the database:
+
+  Artist.each{|x| p x.name}
+  # SQL: SELECT * FROM artists
+  "YJM"
+  "AS"
+
+This means that all of the methods in the Enumerable module are available,
+such as +map+:
+
+  artist_names = Artist.map{|x| x.name}
+  # SQL: SELECT * FROM artists
+  => ["YJM", "AS"]
+
+==== As an Array of Column Values
+
+At 1.2.2 in Rails Guide

data/doc/release_notes/3.11.0.txt

@@ -0,0 +1,254 @@
+= New Features
+
+* A few new features were added to query logging.  Sequel now
+  includes execution time when logging queries.  Queries that
+  raise exceptions are now logged at ERROR level.  You can now
+  set the log_warn_duration attribute on the Database instance
+  and queries that take longer than that will be logged at WARN 
+  level.  By using different log levels, you can now only log
+  queries that raise errors, or only log queries that take a long
+  time.
+
+    # The default - Log all successful queries at INFO level
+    DB.log_warn_duration = nil
+
+    # Log all successful queries at WARN level
+    DB.log_warn_duration = 0
+
+    # Log successful queries that take the database more than half a
+    # second at WARN level, other successful queries at INFO level
+    DB.log_warn_duration = 0.5
+
+  All adapters included with Sequel have been modified to support
+  the new logging API.  The previous API is still available, so
+  any external adapters should still work, though switching to the
+  new logging API is encouraged.
+  
+* Sequel::Model now has a require_modification flag.  If not set
+  explicitly, it is enabled by default if the dataset provides an
+  accurate number of rows matched by an update or delete statement.  
+  When this setting is enabled, Sequel will raise an exception if
+  you attempt to update or delete a model object and it doesn't end
+  up affecting exactly one row.  For example:
+
+    DB.create_table(:as){primary_key :id}
+    class A < Sequel::Model; end
+    a = A.create
+
+    # delete object from database
+    a.delete
+
+    a.require_modification = false
+    a.save # no error!
+    a.delete # no error!
+
+    a.require_modification = true
+    a.save # Sequel::NoExistingObject exception raised
+    a.delete # Sequel::NoExistingObject exception raised
+
+  Like many other Sequel::Model settings, this can be set on a
+  global, per class, and per instance level:
+
+    Sequel::Model.require_modification = false # global
+    Album.require_modification = true # class
+    album.require_modification = false # instance
+
+* An instance_filters plugin was added to the list of built in
+  plugins, allowing you to add arbitrary filters when updating or
+  destroying an instance.  This allows you to continue using models
+  when previously you would have had to drop down to using datasets
+  to get the desired behavior:
+
+    class Item < Sequel::Model
+      plugin :instance_filters
+    end
+    
+    # These are two separate objects that represent the same
+    # database row. 
+    i1 = Item.first(:id=>1, :delete_allowed=>false)
+    i2 = Item.first(:id=>1, :delete_allowed=>false)
+    
+    # Add an instance filter to the object. This filter is in effect
+    # until the object is successfully updated or deleted.
+    i1.instance_filter(:delete_allowed=>true)
+    
+    # Attempting to delete the object where the filter doesn't
+    # match any rows raises an error.
+    i1.delete # raises Sequel::Error
+    
+    # The other object that represents the same row has no
+    # instance filters, and can be updated normally.
+    i2.update(:delete_allowed=>true)
+    
+    # Even though the filter is now still in effect, since the
+    # database row has been updated to allow deleting,
+    # delete now works.
+    i1.delete
+
+* An :after_connect database option is now supported.  If provided,
+  the option value should be a proc that takes a single argument.
+  It will be called with the underlying connection object before
+  connection object is added to the connection pool, allowing you
+  to set per connection options in a thread-safe manner.
+
+  This is useful for customizations you want set on every connection
+  that Sequel doesn't already support.  For example, on PostgreSQL
+  if you wanted to set the schema search_path on every connection:
+                  
+    DB = Sequel.postgres('dbname', :after_connect=>(proc do |conn|
+      conn.execute('SET search_path TO schema1,schema2')
+    end))
+
+* A :test database option is now supported.  If set to true, it
+  automatically calls test_connection to make sure a connection can
+  be made before returning a Database instance.  For backwards
+  compatibility reasons, this is not set to true by default, but it
+  is possible that the default will change in a future version of
+  Sequel.
+
+* The Dataset#select_append method was added, which always appends
+  to the existing selected columns.  It operates identically to
+  select_more, except in the case that no columns are currently
+  selected:
+
+    ds = DB[:a]
+    # SELECT * FROM items
+    ds.select_more({:id=>DB[:b].select(:a_id)}.as(:in_b))
+    # SELECT id IN (SELECT a_id FROM b) AS in_b FROM a
+    ds.select_append({:id=>DB[:b].select(:a_id)}.as(:in_b))
+    # SELECT *, id IN (SELECT a_id FROM b) AS in_b FROM a
+
+* The Dataset#provides_accurate_rows_matched? method was added which
+  allows you to see if the dataset will return the actual number of
+  rows matched/affected by an update or delete call.
+
+* Sequel will now emulate DISTINCT ON support using GROUP BY on
+  MySQL.  On MySQL, GROUP BY is similar to DISTINCT ON, except that
+  the order of returned rows is not deterministic.
+
+* Support for connecting to Microsoft SQL Server using the JTDS JDBC
+  driver was added to the jdbc adapter.
+
+* JDNI connection strings are now supported in the JDBC adapter.
+
+* The JDBC adapter should now work in situations where driver
+  auto-loading has problems, just as when using Tomcat or Trinidad.
+
+* Sequel's JDBC adapter schema parsing now supports a :scale option,
+  useful for numeric/decimal columns.
+
+* Sequel's schema parsing on Microsoft SQL Server now supports
+  :column_size and :scale options.
+
+* When connecting to SQLite, a Database#sqlite_version method is
+  available that gives you the SQLite version as an integer (e.g.
+  30613 for 3.6.13).
+
+= Other Improvements
+
+* Sequel no longer raises an error if you give Dataset#filter or
+  related method an empty argument such as {}, [], or ''. This allows
+  code such as the following to work:
+
+    h = {}
+    h[:name] = name if name
+    h[:number] = number if number
+    ds = ds.filter(h)
+    
+  Before, this would raise an error if both name and number were
+  nil. 
+
+* Numeric and decimal columns with a 0 scale are now treated as
+  integer columns by the model typecasting code, since such columns
+  cannot store non-integer values.
+
+* Calling Database#disconnect when using the single threaded
+  connection pool no longer raises an error if there is no current
+  connection.
+
+* When using the :ignore_index_errors options to
+  Database#create_table, correctly swallow errors raised by Sequel
+  due to the adapter not supporting the given index type.
+  
+* The JDBC adapter no longer leaks ResultSets when retrieving
+  metadata.
+
+* You can now connect to PostgreSQL when using ruby 1.9 with the
+  -Ku switch.
+
+* When using the native MySQL adapter, only tinyint(1) columns are
+  now returned as booleans when using the convert_tinyint_to_bool
+  setting (the default).  Previously, all tinyint columns would
+  be converted to booleans if the setting was enabled.
+
+* Correctly handle inserts returning the autogenerated keys when
+  using MySQL JDBC Driver version 5.1.12 with the jdbc adapter.
+
+* The native MySQL adapter now supports :config_default_group and
+  :config_local_infile options.
+
+* When connecting to SQLite, you can provide the :auto_vacuum,
+  :foreign_keys, :synchronous, and :temp_store options for
+  making the appropriate PRAGMA setting on the database in a
+  thread-safe manner.  The previous thread-unsafe PRAGMA setting
+  methods are available, but their use is discouraged.
+
+* Sequel will not enable savepoints when connecting to SQLite
+  unless the version is 3.6.8 or greater.
+
+* Using limit with distinct now works correctly on Microsoft SQL
+  Server.
+  
+* Database#rename_table now works correctly on Microsoft SQL Server.
+
+* If you specify an explicit :provider when using the ADO adapter,
+  transactions will now work correctly.  The default :provider uses
+  a new native connection for each query, so it cannot work with
+  transactions, or things like temporary tables.
+
+* If you specify an explicit :provider when connecting to Microsoft
+  SQL Server using the ADO adapter (e.g. SQLNCLI10 or SQLNCLI),
+  Sequel is now able to provide an accurate number of rows modified
+  and deleted.
+
+* Using set_column_allow_null with a decimal column with a precision
+  and scale now works correctly when connecting to Microsoft SQL
+  Server.
+
+* You can now connect to Microsoft SQL Server using the dbi adapter.
+
+* Sequel now recognizes the NUMBER database type as a synonym for
+  NUMERIC and DECIMAL, which may help some Oracle users.
+
+* Transactions can now be rolled back correctly when connecting to
+  Oracle via JDBC.
+
+* The active_model plugin now supports ActiveModel 3.0.0beta2.
+
+* Many documentation improvements were made, including the addition
+  of a dataset basics guide, an association basics guide, an expanded
+  virtual row guide, and the separation of the Sequel::Dataset RDoc
+  page into sections.  Additional, the RDoc class/method
+  documentation now contains links to the appropriate guides.
+
+= Backwards Compatibility
+
+* When connecting to SQLite, Sequel now automatically sets the
+  foreign_keys PRAGMA to true, which will make SQLite 3.6.19+ use
+  database enforced foreign key constraints.  If you do not want
+  the database to enforce the foreign key constraints, you should
+  use the :foreign_keys=>false option when connecting to the
+  database.
+
+* Sequel no longer creates #{plugin_name}_opts class, instance, and
+  dataset methods for each plugin loaded.  No built-in plugin used
+  them, and I couldn't find an external plugin that did either.
+
+* The Model#associations method is no longer available if the 
+  default Associations plugin is not loaded due to the 
+  SEQUEL_NO_ASSOCIATIONS constant or environment variable being set.
+
+* DISTINCT ON support is turned off by default, and only enabled when
+  using PostgreSQL, since that appears to be the only database that
+  supports it.  Previously, it was enabled by default and most common
+  adapters turned it off.