sequel 2.11.0 → 2.12.0

data/Rakefile

@@ -1,46 +1,45 @@
 require "rake"
 require "rake/clean"
 require "rake/gempackagetask"
-require "spec/rake/spectask"
 begin
   require "hanna/rdoctask"
 rescue LoadError
   require "rake/rdoctask"
 end
-require "fileutils"
-require "lib/sequel_core/version"
-
-include FileUtils
 
 NAME = 'sequel'
-VERS = Sequel.version
-CLEAN.include ["**/.*.sw?", "pkg", ".config", "rdoc", "coverage", "www/public/*.html"]
-RDOC_OPTS = ["--quiet", "--line-numbers", "--inline-source", '--title', \
-  'Sequel: The Database Toolkit for Ruby', '--main', 'README.rdoc']
+VERS = lambda do
+  require "lib/sequel/version"
+  Sequel.version
+end
+CLEAN.include ["**/.*.sw?", "pkg", ".config", "rdoc", "coverage", "www/public/*.html", "www/public/rdoc*"]
+RDOC_DEFAULT_OPTS = ["--quiet", "--line-numbers", "--inline-source", '--title', 'Sequel: The Database Toolkit for Ruby']
+RDOC_OPTS = RDOC_DEFAULT_OPTS + ['--main', 'README.rdoc']
 
 # Gem Packaging and Release
 
-desc "Packages sequel"
-task :package=>[:clean]
 spec = Gem::Specification.new do |s|
   s.name = NAME
   s.rubyforge_project = 'sequel'
-  s.version = VERS
+  s.version = VERS.call
   s.platform = Gem::Platform::RUBY
   s.has_rdoc = true
   s.extra_rdoc_files = ["README.rdoc", "CHANGELOG", "COPYING"] + Dir["doc/*.rdoc"] + Dir['doc/release_notes/*.txt']
-  s.rdoc_options += RDOC_OPTS
+  s.rdoc_options += RDOC_OPTS 
   s.summary = "The Database Toolkit for Ruby"
   s.description = s.summary
   s.author = "Jeremy Evans"
   s.email = "code@jeremyevans.net"
   s.homepage = "http://sequel.rubyforge.org"
   s.required_ruby_version = ">= 1.8.4"
-  s.files = %w(COPYING CHANGELOG README.rdoc Rakefile) + Dir.glob("{bin,doc,spec,lib}/**/*")
+  s.files = %w(COPYING CHANGELOG README.rdoc Rakefile) + Dir["{bin,doc,spec,lib}/**/*"]
   s.require_path = "lib"
   s.bindir = 'bin'
   s.executables << 'sequel'
 end
+
+desc "Packages sequel"
+task :package=>[:clean]
 Rake::GemPackageTask.new(spec) do |p|
   p.need_tar = true
   p.gem_spec = spec
@@ -48,12 +47,7 @@ end
 
 desc "Install sequel gem"
 task :install=>[:package] do
-  sh %{sudo gem install pkg/#{NAME}-#{VERS} --local}
-end
-
-desc "Install sequel gem without RDoc"
-task :install_no_docs=>[:package] do
-  sh %{sudo gem install pkg/#{NAME}-#{VERS} --no-rdoc --no-ri --local}
+  sh %{sudo gem install pkg/#{NAME}-#{VERS.call} --local}
 end
 
 desc "Uninstall sequel gem"
@@ -61,11 +55,11 @@ task :uninstall=>[:clean] do
   sh %{sudo gem uninstall #{NAME}}
 end
 
-desc "Upload sequel and sequel_core gems to rubyforge"
+desc "Upload sequel gem to rubyforge"
 task :release=>[:package] do
   sh %{rubyforge login}
-  sh %{rubyforge add_release sequel #{NAME} #{VERS} pkg/#{NAME}-#{VERS}.tgz}
-  sh %{rubyforge add_file sequel #{NAME} #{VERS} pkg/#{NAME}-#{VERS}.gem} 
+  sh %{rubyforge add_release sequel #{NAME} #{VERS.call} pkg/#{NAME}-#{VERS.call}.tgz}
+  sh %{rubyforge add_file sequel #{NAME} #{VERS.call} pkg/#{NAME}-#{VERS.call}.gem} 
 end
 
 ### RDoc
@@ -78,73 +72,103 @@ end
 
 ### Website
 
-desc "Update Non-RDoc section of sequel.rubyforge.org"
-task :website_base do
+desc "Make local version of website"
+task :website do
   sh %{www/make_www.rb}
-  sh %{scp -r www/public/* rubyforge.org:/var/www/gforge-projects/sequel/}
 end
 
-desc "Update RDoc section of sequel.rubyforge.org"
-task :website_rdoc=>[:rerdoc] do
-  sh %{scp -r rdoc/* rubyforge.org:/var/www/gforge-projects/sequel/rdoc/}
-end
-
-desc "Update sequel.rubyforge.org"
-task :website=>[:website_base, :website_rdoc]
-
-### Specs
+desc "Make rdoc for website"
+task :website_rdoc=>[:website_rdoc_main, :website_rdoc_adapters, :website_rdoc_plugins]
 
-lib_dir = File.join(File.dirname(__FILE__), 'lib')
-fixRUBYLIB = Proc.new{ENV['RUBYLIB'] ? (ENV['RUBYLIB'] += ":#{lib_dir}") : (ENV['RUBYLIB'] = lib_dir)}
-sequel_core_specs = "spec/sequel_core/*_spec.rb"
-sequel_model_specs = "spec/sequel_model/*_spec.rb"
-spec_opts = proc{File.read("spec/spec.opts").split("\n")}
-rcov_opts = proc{File.read("spec/rcov.opts").split("\n")}
-
-desc "Run core and model specs with coverage"
-Spec::Rake::SpecTask.new("spec_coverage") do |t|
-  fixRUBYLIB.call
-  t.spec_files = FileList[sequel_core_specs, sequel_model_specs]
-  t.spec_opts  = spec_opts.call
-  t.rcov_opts  = rcov_opts.call
-  t.rcov = true
+Rake::RDocTask.new(:website_rdoc_main) do |rdoc|
+  rdoc.rdoc_dir = "www/public/rdoc"
+  rdoc.options += RDOC_OPTS
+  rdoc.rdoc_files.add %w"README.rdoc CHANGELOG COPYING lib/*.rb lib/sequel/*.rb lib/sequel/{dataset,database,model}/*.rb doc/*.rdoc doc/release_notes/*.txt"
 end
 
-desc "Run core and model specs"
-task :default => [:spec]
-Spec::Rake::SpecTask.new("spec") do |t|
-  fixRUBYLIB.call
-  t.spec_files = FileList[sequel_core_specs, sequel_model_specs]
-  t.spec_opts  = spec_opts.call
+Rake::RDocTask.new(:website_rdoc_adapters) do |rdoc|
+  rdoc.rdoc_dir = "www/public/rdoc-adapters"
+  rdoc.options += RDOC_DEFAULT_OPTS + %w'--main Sequel'
+  rdoc.rdoc_files.add %w"lib/sequel/adapters/**/*.rb"
 end
 
-desc "Run core specs"
-Spec::Rake::SpecTask.new("spec_core") do |t|
-  fixRUBYLIB.call
-  t.spec_files = FileList[sequel_core_specs]
-  t.spec_opts  = spec_opts.call
+Rake::RDocTask.new(:website_rdoc_plugins) do |rdoc|
+  rdoc.rdoc_dir = "www/public/rdoc-plugins"
+  rdoc.options += RDOC_DEFAULT_OPTS + %w'--main Sequel'
+  rdoc.rdoc_files.add %w"lib/sequel/{extensions,plugins}/**/*.rb"
 end
 
-desc "Run model specs"
-Spec::Rake::SpecTask.new("spec_model") do |t|
-  fixRUBYLIB.call
-  t.spec_files = FileList[sequel_model_specs]
-  t.spec_opts  = spec_opts.call
+desc "Update Non-RDoc section of sequel.rubyforge.org"
+task :website_rf_base=>[:website] do
+  sh %{rsync -rt www/public/*.html rubyforge.org:/var/www/gforge-projects/sequel/}
 end
 
-desc "Run integration tests"
-Spec::Rake::SpecTask.new("integration") do |t|
-  fixRUBYLIB.call
-  t.spec_files = FileList["spec/integration/*_test.rb"]
-  t.spec_opts  = spec_opts.call
+desc "Update sequel.rubyforge.org"
+task :website_rf=>[:website, :website_rdoc] do
+  sh %{rsync -rvt www/public/* rubyforge.org:/var/www/gforge-projects/sequel/}
 end
 
-%w'postgres sqlite mysql informix oracle ado'.each do |adapter|
-  desc "Run #{adapter} specs without coverage"
-  Spec::Rake::SpecTask.new("spec_#{adapter}") do |t|
-    t.spec_files = ["spec/adapters/#{adapter}_spec.rb"]
+### Specs
+
+begin
+  require "spec/rake/spectask"
+
+  spec_opts = lambda do
+    lib_dir = File.join(File.dirname(__FILE__), 'lib')
+    ENV['RUBYLIB'] ? (ENV['RUBYLIB'] += ":#{lib_dir}") : (ENV['RUBYLIB'] = lib_dir)
+    File.read("spec/spec.opts").split("\n")
+  end
+
+  rcov_opts = lambda do
+    [true, File.read("spec/rcov.opts").split("\n")]
+  end
+  
+  desc "Run core and model specs with coverage"
+  Spec::Rake::SpecTask.new("spec_coverage") do |t|
+    t.spec_files = Dir["spec/{core,model}/*_spec.rb"]
+    t.spec_opts  = spec_opts.call
+    t.rcov, t.rcov_opts = rcov_opts.call
+  end
+  
+  desc "Run core and model specs"
+  task :default => [:spec]
+  Spec::Rake::SpecTask.new("spec") do |t|
+    t.spec_files = Dir["spec/{core,model}/*_spec.rb"]
+    t.spec_opts  = spec_opts.call
+  end
+  
+  desc "Run core specs"
+  Spec::Rake::SpecTask.new("spec_core") do |t|
+    t.spec_files = Dir["spec/core/*_spec.rb"]
     t.spec_opts  = spec_opts.call
   end
+  
+  desc "Run model specs"
+  Spec::Rake::SpecTask.new("spec_model") do |t|
+    t.spec_files = Dir["spec/model/*_spec.rb"]
+    t.spec_opts  = spec_opts.call
+  end
+  
+  desc "Run extension/plugin specs"
+  Spec::Rake::SpecTask.new("spec_plugin") do |t|
+    t.spec_files = Dir["spec/extensions/*_spec.rb"]
+    t.spec_opts  = spec_opts.call
+  end
+  
+  desc "Run integration tests"
+  Spec::Rake::SpecTask.new("integration") do |t|
+    t.spec_files = FileList["spec/integration/*_test.rb"]
+    t.spec_opts  = spec_opts.call
+  end
+  
+  %w'postgres sqlite mysql informix oracle ado'.each do |adapter|
+    desc "Run #{adapter} specs without coverage"
+    Spec::Rake::SpecTask.new("spec_#{adapter}") do |t|
+      t.spec_files = ["spec/adapters/#{adapter}_spec.rb"]
+      t.spec_opts  = spec_opts.call
+    end
+  end
+rescue LoadError
 end
 
 desc "check documentation coverage"
@@ -154,13 +178,9 @@ end
 
 ### Statistics
 
-STATS_DIRECTORIES = [
-  %w(Code   lib/),
-  %w(Spec   spec),
-].collect { |name, dir| [ name, "./#{dir}" ] }.select { |name, dir| File.directory?(dir) }
-
 desc "Report code statistics (KLOCs, etc) from the application"
 task :stats do
+  STATS_DIRECTORIES = [%w(Code lib/), %w(Spec spec)].map{|name, dir| [ name, "./#{dir}" ] }.select { |name, dir| File.directory?(dir)}
   require "extra/stats"
   verbose = true
   CodeStatistics.new(*STATS_DIRECTORIES).to_s
@@ -168,5 +188,5 @@ end
 
 desc "Print Sequel version"
 task :version do
-  puts VERS
+  puts VERS.call
 end

data/bin/sequel

@@ -63,7 +63,7 @@ opts.parse!
 
 db = ARGV.shift
 
-if db.blank?
+if db.nil? || db.empty?
   puts opts
   exit 1
 end
@@ -88,6 +88,7 @@ begin
   DB = Sequel.connect(*(db_config ? [db_config] : [db, db_opts]))
   DB.test_connection
   if migrate_dir
+    require 'sequel/extensions/migration'
     Sequel::Migrator.apply(DB, migrate_dir, migrate_ver)
     exit
   end

data/doc/advanced_associations.rdoc

@@ -4,7 +4,7 @@ Sequel::Model has the most powerful and flexible associations of any ruby ORM.
 
   "Extraordinary claims require extraordinary proof" - Carl Sagan
 
-==Background: Sequel::Model association options
+== Background: Sequel::Model association options
 
 There are a bunch of advanced association options that are available to
 handle the other-than-bog-standard cases.  First we'll go over some of
@@ -35,11 +35,10 @@ JOINing to the join table in a many_to_many association).
   condition.  The block is passed the associated table alias, current model
   alias, and array of previous joins.
 - :graph_only_conditions - Use these conditions instead of the standard
-  association conditions. This is necessary when the standard keys it uses are
-  not correct for the association (such as an association that doesn't use
-  primary keys).  You can also use this to have a JOIN USING (array of
-  symbols), or a NATURAL or CROSS JOIN (nil, with the appropriate
-  :graph_join_type).
+  association conditions. This is necessary when you don't want to have an
+  equal condition between the foreign key and primary key of the tables.
+  You can also use this to have a JOIN USING (array of symbols), or a NATURAL
+  or CROSS JOIN (nil, with the appropriate :graph_join_type).
   
 These can be used like this:
 
@@ -55,21 +54,15 @@ These can be used like this:
   Artist.one_to_many :gold_albums, :class=>:Album, \
     :graph_block=>proc{|j,lj,js| :copies_sold.qualify(j) > 500000}
     
-  # Handles the case where the artist is associated to the album by an
-  # artist_name column in the albums table, when name is not the primary key
-  # of the artists table
+  # Handles the case where the to tables are associated by a case insensitive name string
   Artist.one_to_many :albums, :key=>:artist_name, \
-    :graph_only_conditions=>{:artist_name=>:name}
+    :graph_only_conditions=>nil, \
+    :graph_block=>proc{|j,lj,js| {:lower.sql_function(artist_name.qualify(j))=>:lower.sql_function(name.qualify(lj))}}
     
-  # Handles the above case, but where :artist_name is used in both tables,
-  # via a JOIN USING
+  # Handles the case where both key columns have the name artist_name, and you want to use
+  # a JOIN USING
   Artist.one_to_many :albums, :key=>:artist_name, :graph_only_conditions=>[:artist_name]
   
-  # Handles the case where all columns in both tables are uniquely named, except
-  # for the ones that handle associations
-  Artist.one_to_many :albums, :key=>:artist_name, :graph_only_conditions=>nil, \
-    :graph_join_type=>:natural
-
 Remember, using #eager_graph is generally only necessary when you need to
 filter/order based on columns in an associated table, it is recommended to
 use #eager for eager loading if possible.
@@ -91,7 +84,7 @@ associations that are specified by multiple keys, or do multiple
 queries depending on the content of the records (which would be
 necessary for polymorphic associations).  Inside the :eager_loader
 proc, you should get the related objects and populate the
-associations for all objects in the array of records.  The hash
+associations cache for all objects in the array of records.  The hash
 of dependent associations is available for you to cascade the eager
 loading down multiple levels, but it is up to you to use it.  The
 key_hash is a performance enhancement that is used by the default
@@ -113,13 +106,13 @@ give an example:
 Using these options, you can build associations Sequel doesn't natively support,
 and still be able to use the same eager loading features that you are used to.
 
-==ActiveRecord associations
+== ActiveRecord associations
 
 Sequel supports all of associations that ActiveRecord supports, one way or
 another.  Sometimes this requires more code, as Sequel is a toolkit and not
 a swiss army chainsaw.
 
-===Association callbacks
+=== Association callbacks
 
 Sequel supports the same callbacks that ActiveRecord does: :before_add,
 :before_remove, :after_add, and :after_remove. It also supports a
@@ -142,9 +135,9 @@ remove callbacks on the existing object and the add callbacks on the
 new object.  The remove callback calls are placed around the add
 callback calls.
 
-===Association extensions
+=== Association extensions
 
-All associations come with a _dataset method that can be further filtered or
+All associations come with an association_dataset method that can be further filtered or
 otherwise modified:
 
   class Author < Sequel::Model
@@ -159,8 +152,7 @@ association_reflection method:
 
   module FindOrCreate
     def find_or_create(vals)
-      first(vals) || association_reflection.associated_class. \
-        create(vals.merge(association_reflection[:key]=>model_object.id))
+      first(vals) || model.create(vals.merge(association_reflection[:key]=>model_object.id))
     end
   end
   class Author < Sequel::Model
@@ -168,7 +160,7 @@ association_reflection method:
   end
   Author.first.authorships_dataset.find_or_create(:name=>'Blah', :number=>10)
 
-===has_many :through associations
+=== has_many :through associations
 
 many_to_many handles the usual case of a has_many :through with a belongs_to in
 the associated model.  It doesn't break on the case where the join table is a
@@ -291,7 +283,7 @@ in the associations cache for each object, which ActiveRecord won't do for you.
 The reason you would want to do this is that then firm.invoices.first.firm or
 firm.invoices.first.client doesn't do another query to get the firm/client.
 
-===Polymorphic Associations
+=== Polymorphic Associations
 
 Polymorphic associations are really a design flaw.  The only advantage
 polymorphic associations offer is that they require fewer join tables.
@@ -404,13 +396,13 @@ Sequel::Model:
   @asset.attachable = @post
   @asset.attachable = @note
 
-==More advanced associations
+== More advanced associations
 
 So far, we've only shown that Sequel::Model has associations as powerful as
 ActiveRecord's.  Now we will show how Sequel::Model's associations are more
 powerful.
 
-===many_to_one/one_to_many not referencing primary key
+=== many_to_one/one_to_many not referencing primary key
 
 This can now be handled easily in Sequel using the :primary_key association
 option.  However, this example shows how the association was possible before
@@ -469,7 +461,7 @@ design, but sometimes you have to play with the cards you are dealt).
     end
   end
 
-===Joining on multiple keys
+=== Joining on multiple keys
 
 Let's say you have two tables that are associated with each other with multiple
 keys.  For example:
@@ -511,7 +503,7 @@ keys.  For example:
       end)
   end
 
-===Tree - All Ancestors and Descendents
+=== Tree - All Ancestors and Descendents
 
 Let's say you want to store a tree relationship in your database, it's pretty
 simple:
@@ -580,8 +572,7 @@ without knowing the depth of the tree?
     end)
   end
 
-
-===Joining multiple keys to a single key, through a third table
+=== Joining multiple keys to a single key, through a third table
 
 Let's say you have a database, of songs, lyrics, and artists.  Each song
 may or may not have a lyric (most songs are instrumental).  The lyric can be

data/doc/cheat_sheet.rdoc

@@ -7,12 +7,12 @@
 
   DB = Sequel.sqlite('my_blog.db')
   DB = Sequel.connect('postgres://user:password@localhost/my_db')
-  DB = Sequel.mysql('my_db', :user => 'user', :password => 'password', :host => 'localhost')
+  DB = Sequel.postgres('my_db', :user => 'user', :password => 'password', :host => 'localhost')
   DB = Sequel.ado('mydb')
 
 == Open an SQLite memory database
 
-Without a filename argument, the sqlite adapter will setup a new sqlite database in RAM.
+Without a filename argument, the sqlite adapter will setup a new sqlite database in memory.
 
   DB = Sequel.sqlite
 
@@ -26,56 +26,49 @@ Without a filename argument, the sqlite adapter will setup a new sqlite database
 == Using raw SQL
 
   DB << "CREATE TABLE users (name VARCHAR(255) NOT NULL, age INT(3) NOT NULL)"
+  dataset = DB["SELECT age FROM users WHERE name = ?", name]
+  dataset.map(:age)
   DB.fetch("SELECT name FROM users") do |row|
     p r[:name]
   end
-  dataset = DB["SELECT age FROM users WHERE name = ?", name]
-  dataset.print
-  dataset.map(:age)
 
 == Create a dataset
 
   dataset = DB[:items]
-  dataset = DB.dataset.from(:items)
+  dataset = DB.from(:items)
 
 == Most dataset methods are chainable
 
   dataset = DB[:managers].where(:salary => 5000..10000).order(:name, :department)
-  # or
-  dataset = DB.query do
-    from :managers
-    where :salary => 5000..10000
-    order :name, :department
-  end
 
 == Insert rows
 
   dataset.insert(:name => 'Sharon', :grade => 50)
-  dataset << {:name => 'Sharon', :grade => 50} # same effect as above
 
 == Retrieve rows
 
-  dataset.each {|r| p r}
+  dataset.each{|r| p r}
   dataset.all #=> [{...}, {...}, ...]
   dataset.first
-  dataset.order(:name).last # works only for ordered datasets
 
 == Update/Delete rows
 
-  dataset.filter(:active => false).delete
+  dataset.filter(~:active).delete
   dataset.filter('price < ?', 100).update(:active => true)
 
 == Datasets are Enumerable
 
-  dataset.map {|r| r[:name]}
-  dataset.map(:name) # same effect as above
+  dataset.map{|r| r[:name]}
+  dataset.map(:name) # same as above
 
   dataset.inject(0){|sum, r| sum + r[:value]}
+  dataset.sum(:value) # same as above
 
 == Filtering (see also doc/dataset_filtering.rdoc)
 
   dataset.filter(:name => 'abc')
   dataset.filter('name = ?', 'abc')
+
   dataset.filter{|o| o.value > 100}
   dataset.exclude{|o| o.value <= 100}
 
@@ -83,13 +76,13 @@ Without a filename argument, the sqlite adapter will setup a new sqlite database
   dataset.where{|o| (o.value >= 50) & (o.value <= 100)}
 
   dataset.where('value IN ?', [50,75,100])
+  dataset.where(:value=>[50,75,100])
 
-  # Get the first record that matches a condition
-  dataset[:name => 'abc'] # Same as:
   dataset.filter(:name => 'abc').first
+  dataset[:name => 'abc'] # same as above
 
   # Filter using a subquery
-  dataset.filter('price > ?', dataset.select('AVG(price) + 100'))
+  dataset.filter{|o| o.price > dataset.select(o.avg(price) + 100)}
 
 === Advanced filtering using ruby expressions
 
@@ -112,8 +105,8 @@ You can use arithmetic operators and specify SQL functions:
   DB[:items].filter((:x + :y) > :z).sql 
   #=> "SELECT * FROM items WHERE ((x + y) > z)" 
 
-  DB[:items].filter{|o| :price - 100 < o.AVG(:price)}.sql 
-  #=> "SELECT * FROM items WHERE ((price - 100) < AVG(price))" 
+  DB[:items].filter{|o| :price - 100 < o.avg(:price)}.sql 
+  #=> "SELECT * FROM items WHERE ((price - 100) < avg(price))" 
 
 == Ordering
 
@@ -126,16 +119,6 @@ You can use arithmetic operators and specify SQL functions:
   dataset.limit(30) # LIMIT 30
   dataset.limit(30, 10) # LIMIT 30 OFFSET 10
 
-== Pagination
-
-  paginated = dataset.paginate(1, 10) # first page, 10 rows per page
-  paginated.page_count #=> number of pages in dataset
-  paginated.current_page #=> 1
-  paginated.next_page #=> next page number or nil
-  paginated.prev_page #=> previous page number or nil
-  paginated.first_page? #=> true if page number = 1
-  paginated.last_page? #=> true if page number = page_count
-
 == Joins
 
   DB[:items].left_outer_join(:categories, :id => :category_id).sql #=>
@@ -174,7 +157,7 @@ You can use arithmetic operators and specify SQL functions:
   DB.drop_table :items
 
   DB.create_table :test do
-    String :zipcode, :size => 10
+    String :zipcode
     enum :system, :elements => ['mac', 'linux', 'windows']
   end
 
@@ -188,8 +171,8 @@ You can use arithmetic operators and specify SQL functions:
 == Transactions
 
   DB.transaction do
-    dataset << {:first_name => 'Inigo', :last_name => 'Montoya'}
-    dataset << {:first_name => 'Farm', :last_name => 'Boy'}
+    dataset.insert(:first_name => 'Inigo', :last_name => 'Montoya')
+    dataset.insert(:first_name => 'Farm', :last_name => 'Boy')
   end # Either both are inserted or neither are inserted
 
 Database#transaction is re-entrant:
@@ -206,10 +189,10 @@ Transactions are aborted if an error is raised:
     raise "some error occurred"
   end # ROLLBACK issued and the error is re-raised
 
-Transactions can also be aborted by raising Sequel::Error::Rollback:
+Transactions can also be aborted by raising Sequel::Rollback:
 
   DB.transaction do
-    raise(Sequel::Error::Rollback) if something_bad_happened
+    raise(Sequel::Rollback) if something_bad_happened
   end # ROLLBACK issued and no error raised
 
 Miscellaneous:
@@ -217,7 +200,7 @@ Miscellaneous:
   dataset.sql #=> "SELECT * FROM items"
   dataset.delete_sql #=> "DELETE FROM items"
   dataset.where(:name => 'sequel').exists #=> "EXISTS ( SELECT 1 FROM items WHERE name = 'sequel' )"
-  dataset.print #=> pretty table print to $stdout
   dataset.columns #=> array of columns in the result set, does a SELECT
+
+  # Works on PostgreSQL, MySQL, SQLite, and JDBC
   DB.schema(:items) => [[:id, {:type=>:integer, ...}], [:name, {:type=>:string, ...}], ...]
-                       # Works on PostgreSQL, MySQL, SQLite, and JDBC