sequel 3.43.0 → 3.44.0

data/spec/core/mock_adapter_spec.rb

@@ -439,8 +439,9 @@ describe "Sequel Mock Adapter" do
     end
   end
 
-  specify "should automatically set version for postgres" do
+  specify "should automatically set version for postgres and mssql" do
     Sequel.mock(:host=>'postgres').server_version.should == 90103
+    Sequel.mock(:host=>'mssql').server_version.should == 10000000
   end
 
   specify "should stub out the primary_key method for postgres" do

data/spec/core/schema_generator_spec.rb

@@ -19,6 +19,10 @@ describe Sequel::Schema::Generator do
     @columns, @indexes, @constraints = @generator.columns, @generator.indexes, @generator.constraints
   end
   
+  it "should respond to everything" do
+    @generator.respond_to?(:foo).should be_true
+  end if RUBY_VERSION >= '1.9'
+
   it "should primary key column first" do
     @columns.first[:name].should == :id
     @columns.first[:primary_key].should == true

data/spec/core/schema_spec.rb

@@ -1219,14 +1219,20 @@ describe "Database#create_view" do
     @db.create_view :test, @db[:items].select(:a, :b).order(:c)
     @db.sqls.should == ['CREATE VIEW test AS SELECT a, b FROM items ORDER BY c']
     @db.create_or_replace_view :sch__test, "SELECT * FROM xyz"
-    @db.sqls.should == ['CREATE OR REPLACE VIEW sch.test AS SELECT * FROM xyz']
+    @db.sqls.should == ['DROP VIEW sch.test', 'CREATE VIEW sch.test AS SELECT * FROM xyz']
   end
 
   specify "should construct proper SQL with dataset" do
     @db.create_or_replace_view :test, @db[:items].select(:a, :b).order(:c)
-    @db.sqls.should == ['CREATE OR REPLACE VIEW test AS SELECT a, b FROM items ORDER BY c']
+    @db.sqls.should == ['DROP VIEW test', 'CREATE VIEW test AS SELECT a, b FROM items ORDER BY c']
     @db.create_or_replace_view Sequel.identifier(:test), @db[:items].select(:a, :b).order(:c)
-    @db.sqls.should == ['CREATE OR REPLACE VIEW test AS SELECT a, b FROM items ORDER BY c']
+    @db.sqls.should == ['DROP VIEW test', 'CREATE VIEW test AS SELECT a, b FROM items ORDER BY c']
+  end
+
+  specify "should use CREATE OR REPLACE VIEW if such syntax is supported" do
+    def @db.supports_create_or_replace_view?() true end
+    @db.create_or_replace_view :test, @db[:items]
+    @db.sqls.should == ['CREATE OR REPLACE VIEW test AS SELECT * FROM items']
   end
 end
 

data/spec/extensions/association_dependencies_spec.rb

@@ -33,13 +33,13 @@ describe "AssociationDependencies plugin" do
   specify "should allow destroying associated one_to_one associated object" do
     @Artist.add_association_dependencies :first_album=>:destroy
     @Artist.load(:id=>2, :name=>'Ar').destroy
-    MODEL_DB.sqls.should == ['SELECT * FROM albums WHERE ((albums.artist_id = 2) AND (position = 1)) LIMIT 1', 'DELETE FROM albums WHERE id = 1', 'DELETE FROM artists WHERE id = 2']
+    MODEL_DB.sqls.should == ['SELECT * FROM albums WHERE ((position = 1) AND (albums.artist_id = 2)) LIMIT 1', 'DELETE FROM albums WHERE id = 1', 'DELETE FROM artists WHERE id = 2']
   end
 
   specify "should allow deleting associated one_to_one associated object" do
     @Artist.add_association_dependencies :first_album=>:delete
     @Artist.load(:id=>2, :name=>'Ar').destroy
-    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE ((albums.artist_id = 2) AND (position = 1))', 'DELETE FROM artists WHERE id = 2']
+    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE ((position = 1) AND (albums.artist_id = 2))', 'DELETE FROM artists WHERE id = 2']
   end
 
   specify "should allow destroying associated one_to_many objects" do
@@ -57,7 +57,7 @@ describe "AssociationDependencies plugin" do
   specify "should allow nullifying associated one_to_one objects" do
     @Artist.add_association_dependencies :first_album=>:nullify
     @Artist.load(:id=>2, :name=>'Ar').destroy
-    MODEL_DB.sqls.should == ['UPDATE albums SET artist_id = NULL WHERE ((artist_id = 2) AND (position = 1))', 'DELETE FROM artists WHERE id = 2']
+    MODEL_DB.sqls.should == ['UPDATE albums SET artist_id = NULL WHERE ((position = 1) AND (artist_id = 2))', 'DELETE FROM artists WHERE id = 2']
   end
 
   specify "should allow nullifying associated one_to_many objects" do

data/spec/extensions/columns_introspection_spec.rb

@@ -25,10 +25,10 @@ end
 
 describe "columns_introspection extension" do
   before do
-    @db = MODEL_DB
+    @db = Sequel.mock
     @ds = @db[:a]
     @ds.extend(Sequel::ColumnsIntrospection.dup) # dup to allow multiple places in class hierarchy
-    @db.reset
+    @db.sqls
   end
 
   specify "should not issue a database query if the columns are already loaded" do
@@ -74,6 +74,32 @@ describe "columns_introspection extension" do
     @db.sqls.length.should == 0
   end
 
+  specify "should handle selecting * from a single subselect with no joins without a database query if the subselect's columns can be handled" do
+    @ds.select(:x).from_self.columns.should == [:x]
+    @db.sqls.length.should == 0
+    @ds.select(:x).from_self.from_self.columns.should == [:x]
+    @db.sqls.length.should == 0
+  end
+
+  specify "should handle selecting * from a single table with no joins without a database query if the database has cached schema columns for the table" do
+    @db.instance_variable_set(:@schemas, "a"=>[[:x, {}]])
+    @ds.columns.should == [:x]
+    @db.sqls.length.should == 0
+  end
+
+  specify "should issue a database query for multiple subselects or joins" do
+    @ds.from(@ds.select(:x), @ds.select(:y)).columns
+    @db.sqls.length.should == 1
+    @ds.select(:x).from_self.natural_join(:a).columns
+    @db.sqls.length.should == 1
+  end
+
+  specify "should issue a database query when common table expressions are used" do
+    @db.instance_variable_set(:@schemas, "a"=>[[:x, {}]])
+    @ds.with(:a, @ds).columns
+    @db.sqls.length.should == 1
+  end
+
   specify "should issue a database query if the wildcard is selected" do
     @ds.columns
     @db.sqls.length.should == 1

data/spec/extensions/eager_each_spec.rb

@@ -30,5 +30,4 @@ describe "Sequel::Plugins::EagerEach" do
     a.map{|c| c.associations[:children]}.should == [[@c.load(:id=>3, :parent_id=>1), @c.load(:id=>4, :parent_id=>1)], [@c.load(:id=>5, :parent_id=>2), @c.load(:id=>6, :parent_id=>2)]]
     @c.db.sqls.should == ['SELECT items.id, items.parent_id, children.id AS children_id, children.parent_id AS children_parent_id FROM items LEFT OUTER JOIN items AS children ON (children.parent_id = items.id)']
   end
-
 end

data/spec/extensions/identity_map_spec.rb

@@ -282,9 +282,10 @@ describe "Sequel::Plugins::IdentityMap" do
 
   it "should work correctly when eagerly loading many_to_many associations with composite keys" do
     @c1.columns :id, :id2
-    @c2.columns :id
+    @c2.columns :id, :id2
     @c1.set_primary_key :id, :id2
-    @c1.many_to_many :artists, :class=>@c2, :left_key=>[:album_id1, :album_id2], :right_key=>:artist_id, :join_table=>:aa
+    @c2.set_primary_key :id, :id2
+    @c1.many_to_many :artists, :class=>@c2, :left_key=>[:album_id1, :album_id2], :right_key=>[:artist_id1, :artist_id2], :join_table=>:aa
     @c1.dataset._fetch = [{:id=>1, :id2=>4}, {:id=>2, :id2=>5}, {:id=>3, :id2=>6}]
     @c2.dataset._fetch = [ {:id=>1, :x_foreign_key_0_x=>1, :x_foreign_key_1_x=>4}, {:id=>1, :x_foreign_key_0_x=>2, :x_foreign_key_1_x=>5}, {:id=>2, :x_foreign_key_0_x=>1, :x_foreign_key_1_x=>4}, {:id=>2, :x_foreign_key_0_x=>2, :x_foreign_key_1_x=>5}, {:id=>3, :x_foreign_key_0_x=>1, :x_foreign_key_1_x=>4}, {:id=>3, :x_foreign_key_0_x=>1, :x_foreign_key_1_x=>4}]
 

data/spec/extensions/migration_spec.rb

@@ -55,6 +55,12 @@ describe "Migration.apply" do
     m.apply(@db, :up).should == nil
     m.apply(@db, :down).should == nil
   end
+
+  specify "should respond to the methods the database responds to" do
+    m = Sequel::Migration.new(Sequel.mock)
+    m.respond_to?(:foo).should be_false
+    m.respond_to?(:execute).should be_true
+  end if RUBY_VERSION >= '1.9'
 end
 
 describe "SimpleMigration#apply" do

data/spec/extensions/prepared_statements_associations_spec.rb

@@ -92,7 +92,7 @@ describe "Sequel::Plugins::AssociationPks" do
   specify "should run a regular query if :conditions option is used when defining the association" do
     @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id, :conditions=>{:a=>1} 
     @Artist.load(:id=>1).albums
-    @db.sqls.should == ["SELECT * FROM albums WHERE ((albums.artist_id = 1) AND (a = 1))"]
+    @db.sqls.should == ["SELECT * FROM albums WHERE ((a = 1) AND (albums.artist_id = 1))"]
   end
 
   specify "should run a regular query if :dataset option is used when defining the association" do
@@ -106,6 +106,6 @@ describe "Sequel::Plugins::AssociationPks" do
     @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id, :conditions=>{:a=>1} 
     @Artist.one_to_many :oalbums, :clone=>:albums
     @Artist.load(:id=>1).oalbums
-    @db.sqls.should == ["SELECT * FROM albums WHERE ((albums.artist_id = 1) AND (a = 1))"]
+    @db.sqls.should == ["SELECT * FROM albums WHERE ((a = 1) AND (albums.artist_id = 1))"]
   end
 end

data/spec/extensions/rcte_tree_spec.rb

@@ -49,8 +49,8 @@ describe Sequel::Model, "rcte_tree" do
 
   it "should use the correct SQL for lazy associations with :conditions option" do
     @c.plugin :rcte_tree, :conditions => {:i => 1}
-    @o.parent_dataset.sql.should == 'SELECT * FROM nodes WHERE ((nodes.id = 1) AND (i = 1)) LIMIT 1'
-    @o.children_dataset.sql.should == 'SELECT * FROM nodes WHERE ((nodes.parent_id = 2) AND (i = 1))'
+    @o.parent_dataset.sql.should == 'SELECT * FROM nodes WHERE ((i = 1) AND (nodes.id = 1)) LIMIT 1'
+    @o.children_dataset.sql.should == 'SELECT * FROM nodes WHERE ((i = 1) AND (nodes.parent_id = 2))'
     @o.ancestors_dataset.sql.should == 'WITH t AS (SELECT * FROM nodes WHERE ((id = 1) AND (i = 1)) UNION ALL SELECT nodes.* FROM nodes INNER JOIN t ON (t.parent_id = nodes.id) WHERE (i = 1)) SELECT * FROM t AS nodes WHERE (i = 1)'
     @o.descendants_dataset.sql.should == 'WITH t AS (SELECT * FROM nodes WHERE ((parent_id = 2) AND (i = 1)) UNION ALL SELECT nodes.* FROM nodes INNER JOIN t ON (t.id = nodes.parent_id) WHERE (i = 1)) SELECT * FROM t AS nodes WHERE (i = 1)'
   end

data/spec/extensions/single_table_inheritance_spec.rb

@@ -158,6 +158,9 @@ describe Sequel::Model, "#sti_key" do
       StiTest2.create.kind.should == 4
       StiTest3.create.kind.should == 5
       StiTest4.create.kind.should == 6
+
+      class ::StiTest5 < ::StiTest4; end
+      StiTest5.create.kind.should == nil
     end
 
     it "should infer key_map from model_map if provided as a hash" do

data/spec/extensions/tactical_eager_loading_spec.rb

@@ -25,7 +25,7 @@ describe "Sequel::Plugins::TacticalEagerLoading" do
     Object.send(:remove_const, :TaticalEagerLoadingModel)
   end
 
-  it "Dataset#all should set the retrieved_by and reteived_with attributes" do
+  it "Dataset#all should set the retrieved_by and retrieved_with attributes" do
     ts = @c.all
     ts.map{|x| [x.retrieved_by, x.retrieved_with]}.should == [[@ds,ts], [@ds,ts], [@ds,ts], [@ds,ts]]
   end

data/spec/extensions/validation_class_methods_spec.rb

@@ -138,6 +138,14 @@ describe Sequel::Model do
     o.valid?.should == false
     o.errors.full_messages.should == ['blah is not cool']
   end
+
+  specify "should have the validates block have appropriate respond_to?" do
+    c = nil
+    @c.validates{c = respond_to?(:foo)}
+    c.should be_false
+    @c.validates{c = respond_to?(:length_of)}
+    c.should be_true
+  end if RUBY_VERSION >= '1.9'
 end
 
 describe Sequel::Model do

data/spec/integration/associations_test.rb

@@ -51,8 +51,8 @@ shared_examples_for "eager limit strategies" do
   end
   
   specify "should correctly handle limits and offsets when eager loading many_to_many associations" do
-    if @els == {:eager_limit_strategy=>:correlated_subquery} && Sequel.guarded?(:derby)
-      pending("Derby errors with correlated subqueries on many_to_many associations")
+    if @els == {:eager_limit_strategy=>:correlated_subquery} && Sequel.guarded?(:derby, :mssql)
+      pending("correlated subqueries on many_to_many associations not supported")
     end
     Album.many_to_many :first_two_tags, {:clone=>:first_two_tags}.merge(@els) if @els
     Album.many_to_many :second_two_tags, {:clone=>:second_two_tags}.merge(@els) if @els
@@ -76,8 +76,8 @@ shared_examples_for "eager limit strategies" do
   end
   
   specify "should correctly handle limits and offsets when eager loading many_through_many associations" do
-    if @els == {:eager_limit_strategy=>:correlated_subquery} && Sequel.guarded?(:derby)
-      pending("Derby errors with correlated subqueries on many_through_many associations")
+    if @els == {:eager_limit_strategy=>:correlated_subquery} && Sequel.guarded?(:derby, :mssql)
+      pending("correlated subqueries on many_through_many associations not supported")
     end
     Artist.many_through_many :first_two_tags, {:clone=>:first_two_tags}.merge(@els) if @els
     Artist.many_through_many :second_two_tags, {:clone=>:second_two_tags}.merge(@els) if @els

data/spec/integration/database_test.rb

@@ -1,28 +1,76 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
 
 describe Sequel::Database do
+  before do
+    @db = INTEGRATION_DB
+  end
+
   specify "should provide disconnect functionality" do
-    INTEGRATION_DB.disconnect
-    INTEGRATION_DB.pool.size.should == 0
-    INTEGRATION_DB.test_connection
-    INTEGRATION_DB.pool.size.should == 1
+    @db.disconnect
+    @db.pool.size.should == 0
+    @db.test_connection
+    @db.pool.size.should == 1
   end
 
   specify "should provide disconnect functionality after preparing a statement" do
-    INTEGRATION_DB.create_table!(:items){Integer :i}
-    INTEGRATION_DB[:items].prepare(:first, :a).call
-    INTEGRATION_DB.disconnect
-    INTEGRATION_DB.pool.size.should == 0
-    INTEGRATION_DB.drop_table?(:items)
+    @db.create_table!(:items){Integer :i}
+    @db[:items].prepare(:first, :a).call
+    @db.disconnect
+    @db.pool.size.should == 0
+    @db.drop_table?(:items)
   end
 
   specify "should raise Sequel::DatabaseError on invalid SQL" do
-    proc{INTEGRATION_DB << "SELECT"}.should raise_error(Sequel::DatabaseError)
+    proc{@db << "SELECT"}.should raise_error(Sequel::DatabaseError)
+  end
+
+  describe "constraint violations" do
+    before do
+      @db.drop_table?(:test2, :test)
+    end
+    after do
+      @db.drop_table?(:test2, :test)
+    end
+
+    cspecify "should raise Sequel::UniqueConstraintViolation when a unique constraint is violated", [:jdbc, :sqlite], [:db2] do
+      @db.create_table!(:test){String :a, :unique=>true, :null=>false}
+      @db[:test].insert('1')
+      proc{@db[:test].insert('1')}.should raise_error(Sequel::UniqueConstraintViolation)
+      @db[:test].insert('2')
+      proc{@db[:test].update(:a=>'1')}.should raise_error(Sequel::UniqueConstraintViolation)
+    end
+
+    cspecify "should raise Sequel::CheckConstraintViolation when a check constraint is violated", :mysql, :sqlite, [:db2] do
+      @db.create_table!(:test){String :a; check Sequel.~(:a=>'1')}
+      proc{@db[:test].insert('1')}.should raise_error(Sequel::CheckConstraintViolation)
+      @db[:test].insert('2')
+      proc{@db[:test].insert('1')}.should raise_error(Sequel::CheckConstraintViolation)
+    end
+
+    cspecify "should raise Sequel::ForeignKeyConstraintViolation when a foreign key constraint is violated", [:jdbc, :sqlite], [:db2]  do
+      @db.create_table!(:test, :engine=>:InnoDB){primary_key :id}
+      @db.create_table!(:test2, :engine=>:InnoDB){foreign_key :tid, :test}
+      proc{@db[:test2].insert(:tid=>1)}.should raise_error(Sequel::ForeignKeyConstraintViolation)
+      @db[:test].insert
+      @db[:test2].insert(:tid=>1)
+      proc{@db[:test2].where(:tid=>1).update(:tid=>3)}.should raise_error(Sequel::ForeignKeyConstraintViolation)
+      proc{@db[:test].where(:id=>1).delete}.should raise_error(Sequel::ForeignKeyConstraintViolation)
+    end
+
+    cspecify "should raise Sequel::NotNullConstraintViolation when a not null constraint is violated", [:jdbc, :sqlite], [:db2] do
+      @db.create_table!(:test){Integer :a, :null=>false}
+      proc{@db[:test].insert(:a=>nil)}.should raise_error(Sequel::NotNullConstraintViolation)
+      unless @db.database_type == :mysql
+        # Broken mysql silently changes NULL here to 0, and doesn't raise an exception.
+        @db[:test].insert(2)
+        proc{@db[:test].update(:a=>nil)}.should raise_error(Sequel::NotNullConstraintViolation)
+      end
+    end
   end
 
   specify "should store underlying wrapped exception in Sequel::DatabaseError" do
     begin
-      INTEGRATION_DB << "SELECT"
+      @db << "SELECT"
     rescue Sequel::DatabaseError=>e
       if defined?(Java::JavaLang::Exception)
         (e.wrapped_exception.is_a?(Exception) || e.wrapped_exception.is_a?(Java::JavaLang::Exception)).should be_true
@@ -33,20 +81,20 @@ describe Sequel::Database do
   end
 
   specify "should not have the connection pool swallow non-StandardError based exceptions" do
-    proc{INTEGRATION_DB.pool.hold{raise Interrupt, "test"}}.should raise_error(Interrupt)
+    proc{@db.pool.hold{raise Interrupt, "test"}}.should raise_error(Interrupt)
   end
 
   specify "should be able to disconnect connections more than once without exceptions" do
-    conn = INTEGRATION_DB.synchronize{|c| c}
-    INTEGRATION_DB.disconnect
-    INTEGRATION_DB.disconnect_connection(conn)
-    INTEGRATION_DB.disconnect_connection(conn)
+    conn = @db.synchronize{|c| c}
+    @db.disconnect
+    @db.disconnect_connection(conn)
+    @db.disconnect_connection(conn)
   end
 
   cspecify "should provide ability to check connections for validity", [:do, :postgres] do
-    conn = INTEGRATION_DB.synchronize{|c| c}
-    INTEGRATION_DB.valid_connection?(conn).should be_true
-    INTEGRATION_DB.disconnect
-    INTEGRATION_DB.valid_connection?(conn).should be_false
+    conn = @db.synchronize{|c| c}
+    @db.valid_connection?(conn).should be_true
+    @db.disconnect
+    @db.valid_connection?(conn).should be_false
   end
 end

data/spec/integration/dataset_test.rb

@@ -98,6 +98,28 @@ describe "Simple Dataset operations" do
     @ds.all.should == [{:id=>1, :number=>10}]
   end
 
+  specify "should iterate over records as they come in" do
+    called = false
+    @ds.each{|row| called = true; row.should == {:id=>1, :number=>10}}
+    called.should == true
+  end
+
+  specify "should support iterating over large numbers of records with paged_each" do
+    (2..100).each{|i| @ds.insert(:number=>i*10)}
+
+    rows = []
+    @ds.order(:number).paged_each(:rows_per_fetch=>5){|row| rows << row}
+    rows.should == (1..100).map{|i| {:id=>i, :number=>i*10}}
+
+    rows = []
+    @ds.order(:number).paged_each(:rows_per_fetch=>3){|row| rows << row}
+    rows.should == (1..100).map{|i| {:id=>i, :number=>i*10}}
+
+    rows = []
+    @ds.order(:number).limit(50, 25).paged_each(:rows_per_fetch=>3){|row| rows << row}
+    rows.should == (26..75).map{|i| {:id=>i, :number=>i*10}}
+  end
+
   specify "should fetch all results correctly" do
     @ds.all.should == [{:id=>1, :number=>10}]
   end
@@ -170,6 +192,32 @@ describe "Simple Dataset operations" do
     @ds.where(:id=>@ds.select(:id).order(:id).limit(2, 1)).all.should == [{:id=>2, :number=>20}]
   end
   
+  specify "should fetch correctly when using limit and offset in a from_self" do
+    @ds.insert(:number=>20)
+    ds = @ds.order(:id).limit(1, 1).from_self
+    ds.all.should == [{:number=>20, :id=>2}]
+    ds.columns.should == [:id, :number]
+    @ds.order(:id).limit(1, 1).columns.should == [:id, :number]
+  end
+
+  specify "should fetch correctly when using nested limit and offset in a from_self" do
+    @ds.insert(:number=>20)
+    @ds.insert(:number=>30)
+    ds = @ds.order(:id).limit(2, 1).from_self.reverse_order(:number).limit(1, 1)
+    ds.all.should == [{:number=>20, :id=>2}]
+    ds.columns.should == [:id, :number]
+    @ds.order(:id).limit(2, 1).from_self.reverse_order(:number).limit(1, 1).columns.should == [:id, :number]
+
+    ds = @ds.order(:id).limit(3, 1).from_self.limit(2, 1).from_self.limit(1, 1)
+    ds.all.should == []
+    ds.columns.should == [:id, :number]
+
+    @ds.insert(:number=>40)
+    ds = @ds.order(:id).limit(3, 1).from_self.reverse_order(:number).limit(2, 1).from_self.reverse_order(:id).limit(1, 1)
+    ds.all.should == [{:number=>20, :id=>2}]
+    ds.columns.should == [:id, :number]
+  end
+
   specify "should alias columns correctly" do
     @ds.select(:id___x, :number___n).first.should == {:x=>1, :n=>10}
   end

data/spec/integration/schema_test.rb

@@ -274,6 +274,30 @@ describe "Database schema modifiers" do
     @db[:items2].all.should == [{:number=>10}]
   end
   
+  describe "views" do
+    before do
+      @db.drop_view(:items_view) rescue nil
+      @db.create_table(:items){Integer :number}
+      @ds.insert(:number=>1)
+      @ds.insert(:number=>2)
+    end
+    after do
+      @db.drop_view(:items_view)
+    end
+
+    specify "should create views correctly" do
+      @db.create_view(:items_view, @ds.where(:number=>1))
+      @db[:items_view].map(:number).should == [1]
+    end
+
+    specify "should create or replace views correctly" do
+      @db.create_or_replace_view(:items_view, @ds.where(:number=>1))
+      @db[:items_view].map(:number).should == [1]
+      @db.create_or_replace_view(:items_view, @ds.where(:number=>2))
+      @db[:items_view].map(:number).should == [2]
+    end
+  end
+  
   specify "should handle create table in a rolled back transaction" do
     @db.drop_table?(:items)
     @db.transaction(:rollback=>:always){@db.create_table(:items){Integer :number}}
@@ -298,7 +322,7 @@ describe "Database schema modifiers" do
   specify "should create temporary tables without raising an exception" do
     @db.create_table!(:items, :temp=>true){Integer :number}
   end
-  
+
   specify "should have create_table? only create the table if it doesn't already exist" do
     @db.create_table!(:items){String :a}
     @db.create_table?(:items){String :b}