sequel 3.32.0 → 3.33.0

data/spec/adapters/sqlite_spec.rb

@@ -139,6 +139,93 @@ describe "An SQLite database" do
   end
 end
 
+describe "SQLite type conversion" do
+  before do
+    @db = SQLITE_DB
+    @integer_booleans = @db.integer_booleans
+    @db.integer_booleans = true
+    @ds = @db[:items]
+    @db.drop_table(:items) rescue nil
+  end
+  after do
+    @db.integer_booleans = @integer_booleans
+    Sequel.datetime_class = Time
+    @db.drop_table(:items)
+  end
+  
+  specify "should handle integers in boolean columns" do
+    @db.create_table(:items){TrueClass :a}
+    @db[:items].insert(false)
+    @db[:items].select_map(:a).should == [false]
+    @db[:items].select_map(:a+:a).should == [0]
+    @db[:items].update(:a=>true)
+    @db[:items].select_map(:a).should == [true]
+    @db[:items].select_map(:a+:a).should == [2]
+  end
+  
+  specify "should handle integers/floats/strings/decimals in numeric/decimal columns" do
+    @db.create_table(:items){Numeric :a}
+    @db[:items].insert(100)
+    @db[:items].select_map(:a).should == [BigDecimal.new('100')]
+    @db[:items].get(:a).should be_a_kind_of(BigDecimal)
+
+    @db[:items].update(:a=>100.1)
+    @db[:items].select_map(:a).should == [BigDecimal.new('100.1')]
+    @db[:items].get(:a).should be_a_kind_of(BigDecimal)
+
+    @db[:items].update(:a=>'100.1')
+    @db[:items].select_map(:a).should == [BigDecimal.new('100.1')]
+    @db[:items].get(:a).should be_a_kind_of(BigDecimal)
+
+    @db[:items].update(:a=>BigDecimal.new('100.1'))
+    @db[:items].select_map(:a).should == [BigDecimal.new('100.1')]
+    @db[:items].get(:a).should be_a_kind_of(BigDecimal)
+  end
+
+  specify "should handle integer/float date columns as julian date" do
+    @db.create_table(:items){Date :a}
+    i = 2455979
+    @db[:items].insert(i)
+    @db[:items].first.should == {:a=>Date.jd(i)}
+    @db[:items].update(:a=>2455979.1)
+    @db[:items].first.should == {:a=>Date.jd(i)}
+  end
+
+  specify "should handle integer/float time columns as seconds" do
+    @db.create_table(:items){Time :a, :only_time=>true}
+    @db[:items].insert(3661)
+    @db[:items].first.should == {:a=>Sequel::SQLTime.create(1, 1, 1)}
+    @db[:items].update(:a=>3661.000001)
+    @db[:items].first.should == {:a=>Sequel::SQLTime.create(1, 1, 1, 1)}
+  end
+
+  specify "should handle integer datetime columns as unix timestamp" do
+    @db.create_table(:items){DateTime :a}
+    i = 1329860756
+    @db[:items].insert(i)
+    @db[:items].first.should == {:a=>Time.at(i)}
+    Sequel.datetime_class = DateTime
+    @db[:items].first.should == {:a=>DateTime.strptime(i.to_s, '%s')}
+  end
+
+  specify "should handle float datetime columns as julian date" do
+    @db.create_table(:items){DateTime :a}
+    i = 2455979.5
+    @db[:items].insert(i)
+    @db[:items].first.should == {:a=>Time.at(1329825600)}
+    Sequel.datetime_class = DateTime
+    @db[:items].first.should == {:a=>DateTime.jd(2455979.5)}
+  end
+
+  specify "should handle integer/float blob columns" do
+    @db.create_table(:items){File :a}
+    @db[:items].insert(1)
+    @db[:items].first.should == {:a=>Sequel::SQL::Blob.new('1')}
+    @db[:items].update(:a=>'1.1')
+    @db[:items].first.should == {:a=>Sequel::SQL::Blob.new(1.1.to_s)}
+  end
+end if SQLITE_DB.adapter_scheme == :sqlite
+
 describe "An SQLite dataset" do
   before do
     @d = SQLITE_DB[:items]

data/spec/core/connection_pool_spec.rb

@@ -787,6 +787,20 @@ shared_examples_for "All connection pools classes" do
     y.should == 123
   end
   
+  specify "should have a reentrent hold method" do
+    o = Object.new
+    c = @class.new({}){o}
+    c.hold do |x|
+      x.should == o
+      c.hold do |x1|
+        x1.should == o
+        c.hold do |x2|
+          x2.should == o
+        end
+      end
+    end
+  end
+  
   specify "should have a servers method that returns an array of shard/server symbols" do
     @class.new({}){123}.servers.should == [:default]
   end

data/spec/core/database_spec.rb

@@ -1396,6 +1396,11 @@ describe "Database#server_opts" do
     opts = {:host=>1, :database=>2, :servers=>{:server1=>2}}
     proc{Sequel::Database.new(opts).send(:server_opts, :server1)}.should raise_error(Sequel::Error)
   end
+
+  specify "should return the general opts merged with given opts if given opts is a Hash" do
+    opts = {:host=>1, :database=>2}
+    Sequel::Database.new(opts).send(:server_opts, :host=>2)[:host].should == 2
+  end
 end
 
 describe "Database#add_servers" do

data/spec/core/mock_adapter_spec.rb

@@ -406,14 +406,26 @@ describe "Sequel Mock Adapter" do
   end
 
   specify "should be able to load dialects based on the database name" do
-    Sequel.mock(:host=>'access').select(Date.new(2011, 12, 13)).sql.should == 'SELECT #2011-12-13#'
-    Sequel.mock(:host=>'db2').select(1).sql.should == 'SELECT 1 FROM "SYSIBM"."SYSDUMMY1"'
-    Sequel.mock(:host=>'firebird')[:a].distinct.limit(1, 2).sql.should == 'SELECT DISTINCT FIRST 1 SKIP 2 * FROM a'
-    Sequel.mock(:host=>'informix')[:a].distinct.limit(1, 2).sql.should == 'SELECT SKIP 2 FIRST 1 DISTINCT * FROM a'
-    Sequel.mock(:host=>'mssql', :quote_identifiers=>true, :identifier_input_method=>:upcase)[:a].full_text_search(:b, 'c').sql.should == "SELECT * FROM [A] WHERE (CONTAINS ([B], 'c'))"
-    Sequel.mock(:host=>'mysql', :quote_identifiers=>true)[:a].full_text_search(:b, 'c').sql.should == "SELECT * FROM `a` WHERE (MATCH (`b`) AGAINST ('c'))"
-    Sequel.mock(:host=>'oracle', :quote_identifiers=>true)[:a].limit(1).sql.should == 'SELECT * FROM (SELECT * FROM "a") "t1" WHERE (ROWNUM <= 1)'
-    Sequel.mock(:host=>'postgres', :quote_identifiers=>true)[:a].full_text_search(:b, 'c').sql.should == "SELECT * FROM \"a\" WHERE (to_tsvector('simple', (COALESCE(\"b\", ''))) @@ to_tsquery('simple', 'c'))"
-    Sequel.mock(:host=>'sqlite', :quote_identifiers=>true)[:a___b].sql.should == "SELECT * FROM `a` AS 'b'"
+    begin
+      qi = class Sequel::Database; @@quote_identifiers; end
+      ii = class Sequel::Database; @@identifier_input_method; end
+      io = class Sequel::Database; @@identifier_output_method; end
+      Sequel.quote_identifiers = nil
+      class Sequel::Database; @@identifier_input_method=nil; end
+      class Sequel::Database; @@identifier_output_method=nil; end
+      Sequel.mock(:host=>'access').select(Date.new(2011, 12, 13)).sql.should == 'SELECT #2011-12-13#'
+      Sequel.mock(:host=>'db2').select(1).sql.should == 'SELECT 1 FROM "SYSIBM"."SYSDUMMY1"'
+      Sequel.mock(:host=>'firebird')[:a].distinct.limit(1, 2).sql.should == 'SELECT DISTINCT FIRST 1 SKIP 2 * FROM "A"'
+      Sequel.mock(:host=>'informix')[:a].distinct.limit(1, 2).sql.should == 'SELECT SKIP 2 FIRST 1 DISTINCT * FROM A'
+      Sequel.mock(:host=>'mssql')[:a].full_text_search(:b, 'c').sql.should == "SELECT * FROM [A] WHERE (CONTAINS ([B], 'c'))"
+      Sequel.mock(:host=>'mysql')[:a].full_text_search(:b, 'c').sql.should == "SELECT * FROM `a` WHERE (MATCH (`b`) AGAINST ('c'))"
+      Sequel.mock(:host=>'oracle')[:a].limit(1).sql.should == 'SELECT * FROM (SELECT * FROM "A") "T1" WHERE (ROWNUM <= 1)'
+      Sequel.mock(:host=>'postgres')[:a].full_text_search(:b, 'c').sql.should == "SELECT * FROM \"a\" WHERE (to_tsvector('simple', (COALESCE(\"b\", ''))) @@ to_tsquery('simple', 'c'))"
+      Sequel.mock(:host=>'sqlite')[:a___b].sql.should == "SELECT * FROM `a` AS 'b'"
+    ensure
+      Sequel.quote_identifiers = qi
+      Sequel::Database.send(:class_variable_set, :@@identifier_input_method, ii)
+      Sequel::Database.send(:class_variable_set, :@@identifier_output_method, io)
+    end
   end
 end

data/spec/extensions/arbitrary_servers_spec.rb

@@ -0,0 +1,114 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+if RUBY_VERSION >= '1.8.7'
+describe "arbtirary servers" do
+  before do
+    @db = Sequel.mock(:servers=>{})
+    @db.pool.extend Sequel::ArbitraryServers
+  end
+
+  specify "should allow arbitrary server options using a hash" do
+    @db.synchronize(:host=>'host1', :database=>'db1') do |c|
+      c.opts[:host].should == 'host1'
+      c.opts[:database].should == 'db1'
+    end
+  end
+
+  specify "should not cache connections to arbitrary servers" do
+    x = nil
+    @db.synchronize(:host=>'host1', :database=>'db1') do |c|
+      x = c
+    end
+    @db.synchronize(:host=>'host1', :database=>'db1') do |c2|
+      c2.should_not equal(x)
+    end
+  end
+
+  specify "should yield same connection correctly when nesting" do
+    @db.synchronize(:host=>'host1', :database=>'db1') do |c|
+      @db.synchronize(:host=>'host1', :database=>'db1') do |c2|
+        c2.should equal(c)
+      end
+    end
+  end
+
+  specify "should disconnect when connection is finished" do
+    x, x1 = nil, nil
+    @db.meta_def(:disconnect_connection){|c| x = c}
+    @db.synchronize(:host=>'host1', :database=>'db1') do |c|
+      x1 = c
+      @db.synchronize(:host=>'host1', :database=>'db1') do |c2|
+        c2.should equal(c)
+      end
+      x.should equal(nil)
+    end
+    x.should equal(x1)
+  end
+
+  specify "should yield different connection correctly when nesting" do
+    @db.synchronize(:host=>'host1', :database=>'db1') do |c|
+      c.opts[:host].should == 'host1'
+      @db.synchronize(:host=>'host2', :database=>'db1') do |c2|
+        c2.opts[:host].should == 'host2'
+        c2.should_not equal(c)
+      end
+    end
+  end
+
+  specify "should respect multithreaded access" do
+    @db.synchronize(:host=>'host1', :database=>'db1') do |c|
+      Thread.new do
+        @db.synchronize(:host=>'host1', :database=>'db1') do |c2|
+          c2.should_not equal(c)
+        end
+      end.join
+    end
+  end
+
+  specify "should work correctly with server_block plugin" do
+    @db.extend Sequel::ServerBlock
+    @db.with_server(:host=>'host1', :database=>'db1') do
+      @db.synchronize do |c|
+        c.opts[:host].should == 'host1'
+        c.opts[:database].should == 'db1'
+        @db.synchronize do |c2|
+          c2.should equal(c)
+        end
+      end
+    end
+  end
+
+
+  specify "should respect multithreaded access with server block plugin" do
+    @db.extend Sequel::ServerBlock
+    q, q1 = Queue.new, Queue.new
+    
+    t = nil
+    @db[:t].all
+    @db.with_server(:host=>'a') do
+      @db[:t].all
+      t = Thread.new do
+        @db[:t].all
+        @db.with_server(:host=>'c') do
+          @db[:t].all
+          @db.with_server(:host=>'d'){@db[:t].all}
+          q.push nil
+          q1.pop
+          @db[:t].all
+        end
+        @db[:t].all
+      end
+      q.pop
+      @db.with_server(:host=>'b'){@db[:t].all}
+      @db[:t].all
+    end
+    @db[:t].all
+    q1.push nil
+    t.join
+    @db.sqls.should == ['SELECT * FROM t', 'SELECT * FROM t -- {:host=>"a"}', 'SELECT * FROM t', 'SELECT * FROM t -- {:host=>"c"}', 'SELECT * FROM t -- {:host=>"d"}',
+      'SELECT * FROM t -- {:host=>"b"}', 'SELECT * FROM t -- {:host=>"a"}', 'SELECT * FROM t', 'SELECT * FROM t -- {:host=>"c"}', 'SELECT * FROM t']
+  end
+end
+else
+  skip_warn "arbitrary_servers plugin: only works on ruby 1.8.7+"
+end

data/spec/extensions/instance_hooks_spec.rb

@@ -229,4 +229,23 @@ describe "InstanceHooks plugin with transactions" do
     @or.destroy.should be_nil
     @db.sqls.should == ['BEGIN', "DELETE FROM items WHERE (id = 1)", 'ad', 'ROLLBACK', 'adr1', 'adr2']
   end
+
+  it "should have *_hook methods return self "do
+    @o.before_destroy_hook{r 1}.should equal(@o)
+    @o.before_validation_hook{r 1}.should equal(@o)
+    @o.before_save_hook{r 1}.should equal(@o)
+    @o.before_update_hook{r 1}.should equal(@o)
+    @o.before_create_hook{r 1}.should equal(@o)
+
+    @o.after_destroy_hook{r 1}.should equal(@o)
+    @o.after_validation_hook{r 1}.should equal(@o)
+    @o.after_save_hook{r 1}.should equal(@o)
+    @o.after_update_hook{r 1}.should equal(@o)
+    @o.after_create_hook{r 1}.should equal(@o)
+    @o.after_commit_hook{r 1}.should equal(@o)
+    @o.after_rollback_hook{r 1}.should equal(@o)
+    @o.after_destroy_commit_hook{r 1}.should equal(@o)
+    @o.after_destroy_rollback_hook{r 1}.should equal(@o)
+  end
+
 end

data/spec/extensions/list_spec.rb

@@ -75,6 +75,37 @@ describe "List plugin" do
       "SELECT * FROM items WHERE ((scope_id = 5) AND (position = 20)) ORDER BY scope_id, position LIMIT 1"]
   end
 
+  it "should have position field set to max+1 when creating if not already set" do
+    @c.dataset._fetch = [[{:pos=>nil}], [{:id=>1, :position=>1}], [{:pos=>1}], [{:id=>2, :position=>2}]]
+    @c.dataset.autoid = 1
+    @c.create.values.should == {:id=>1, :position=>1}
+    @c.create.values.should == {:id=>2, :position=>2}
+    @db.sqls.should == ["SELECT max(position) FROM items LIMIT 1",
+      "INSERT INTO items (position) VALUES (1)", 
+      "SELECT * FROM items WHERE (id = 1) ORDER BY position LIMIT 1",
+      "SELECT max(position) FROM items LIMIT 1",
+      "INSERT INTO items (position) VALUES (2)", 
+      "SELECT * FROM items WHERE (id = 2) ORDER BY position LIMIT 1"]
+  end
+
+  it "should have position field set to max+1 in scope when creating if not already set" do
+    @sc.dataset._fetch = [[{:pos=>nil}], [{:id=>1, :scope_id=>1, :position=>1}], [{:pos=>1}], [{:id=>2, :scope_id=>1, :position=>2}], [{:pos=>nil}], [{:id=>3, :scope_id=>2, :position=>1}]]
+    @sc.dataset.autoid = 1
+    @sc.create(:scope_id=>1).values.should == {:id=>1, :scope_id=>1, :position=>1}
+    @sc.create(:scope_id=>1).values.should == {:id=>2, :scope_id=>1, :position=>2}
+    @sc.create(:scope_id=>2).values.should == {:id=>3, :scope_id=>2, :position=>1}
+    sqls = @db.sqls
+    sqls.slice!(7).should =~ /INSERT INTO items \((scope_id|position), (scope_id|position)\) VALUES \([12], [12]\)/
+    sqls.slice!(4).should =~ /INSERT INTO items \((scope_id|position), (scope_id|position)\) VALUES \([12], [12]\)/
+    sqls.slice!(1).should =~ /INSERT INTO items \((scope_id|position), (scope_id|position)\) VALUES \(1, 1\)/
+    sqls.should == ["SELECT max(position) FROM items WHERE (scope_id = 1) LIMIT 1",
+      "SELECT * FROM items WHERE (id = 1) ORDER BY scope_id, position LIMIT 1",
+      "SELECT max(position) FROM items WHERE (scope_id = 1) LIMIT 1",
+      "SELECT * FROM items WHERE (id = 2) ORDER BY scope_id, position LIMIT 1",
+      "SELECT max(position) FROM items WHERE (scope_id = 2) LIMIT 1",
+      "SELECT * FROM items WHERE (id = 3) ORDER BY scope_id, position LIMIT 1"]
+  end
+
   it "should have last_position return the last position in the list" do
     @c.dataset._fetch  = {:max=>10}
     @o.last_position.should == 10

data/spec/extensions/migration_spec.rb

@@ -311,6 +311,30 @@ describe "Sequel::IntegerMigrator" do
     Sequel::Migrator.apply(@db, @dirname, 0).should == 0
     Sequel::Migrator.apply(@db, @dirname).should == 3
   end
+
+  specify "should use IntegerMigrator if IntegerMigrator.apply called, even for timestamped migration directory" do
+    proc{Sequel::IntegerMigrator.apply(@db, "spec/files/timestamped_migrations")}.should raise_error(Sequel::Migrator::Error)
+  end
+
+  specify "should use transactions by default" do
+    Sequel::Migrator.apply(@db, "spec/files/transaction_migrations")
+    @db.sqls.should == ["CREATE TABLE schema_info (version integer DEFAULT 0 NOT NULL)", "SELECT 1 AS one FROM schema_info LIMIT 1", "INSERT INTO schema_info (version) VALUES (0)", "SELECT version FROM schema_info LIMIT 1", "BEGIN", "CREATE TABLE sm11111 (smc1 integer)", "UPDATE schema_info SET version = 1", "COMMIT", "BEGIN", "CREATE TABLE sm (smc1 integer)", "UPDATE schema_info SET version = 2", "COMMIT"]
+  end
+
+  specify "should not use transactions for migrations that disable it" do
+    Sequel::Migrator.apply(@db, "spec/files/transactionless_migrations")
+    @db.sqls.should == ["CREATE TABLE schema_info (version integer DEFAULT 0 NOT NULL)", "SELECT 1 AS one FROM schema_info LIMIT 1", "INSERT INTO schema_info (version) VALUES (0)", "SELECT version FROM schema_info LIMIT 1", "CREATE TABLE sm11111 (smc1 integer)", "UPDATE schema_info SET version = 1", "CREATE TABLE sm (smc1 integer)", "UPDATE schema_info SET version = 2"]
+  end
+
+  specify "should force transactions if enabled in the migrator" do
+    Sequel::Migrator.run(@db, "spec/files/transactionless_migrations", :use_transactions=>true)
+    @db.sqls.should == ["CREATE TABLE schema_info (version integer DEFAULT 0 NOT NULL)", "SELECT 1 AS one FROM schema_info LIMIT 1", "INSERT INTO schema_info (version) VALUES (0)", "SELECT version FROM schema_info LIMIT 1", "BEGIN", "CREATE TABLE sm11111 (smc1 integer)", "UPDATE schema_info SET version = 1", "COMMIT", "BEGIN", "CREATE TABLE sm (smc1 integer)", "UPDATE schema_info SET version = 2", "COMMIT"]
+  end
+
+  specify "should not use transactions if disabled in the migrator" do
+    Sequel::Migrator.run(@db, "spec/files/transaction_migrations", :use_transactions=>false)
+    @db.sqls.should == ["CREATE TABLE schema_info (version integer DEFAULT 0 NOT NULL)", "SELECT 1 AS one FROM schema_info LIMIT 1", "INSERT INTO schema_info (version) VALUES (0)", "SELECT version FROM schema_info LIMIT 1", "CREATE TABLE sm11111 (smc1 integer)", "UPDATE schema_info SET version = 1", "CREATE TABLE sm (smc1 integer)", "UPDATE schema_info SET version = 2"]
+  end
 end
 
 describe "Sequel::TimestampMigrator" do
@@ -322,6 +346,7 @@ describe "Sequel::TimestampMigrator" do
       define_method(:sequel_migration_version=){|v| sequel_migration_version = v}
 
       def columns
+        super
         case opts[:from].first
         when :schema_info, 'schema_info'
           [:version]
@@ -333,6 +358,7 @@ describe "Sequel::TimestampMigrator" do
       end
 
       def fetch_rows(sql)
+        super
         case opts[:from].first
         when :schema_info, 'schema_info'
           yield({:version=>sequel_migration_version})
@@ -344,6 +370,7 @@ describe "Sequel::TimestampMigrator" do
       end
 
       def insert(h={})
+        super
         case opts[:from].first
         when :schema_info, 'schema_info'
           self.sequel_migration_version = h.values.first
@@ -353,6 +380,7 @@ describe "Sequel::TimestampMigrator" do
       end
 
       def update(h={})
+        super
         case opts[:from].first
         when :schema_info, 'schema_info'
           self.sequel_migration_version = h.values.first
@@ -360,6 +388,7 @@ describe "Sequel::TimestampMigrator" do
       end
 
       def delete
+        super
         case opts[:from].first
         when :schema_migrations, :sm, 'schema_migrations', 'sm'
           self.class::FILES.delete(opts[:where].args.last)
@@ -367,11 +396,14 @@ describe "Sequel::TimestampMigrator" do
       end
     end
     dbc = Class.new(Sequel::Mock::Database) do
-      tables = {}
+      self::Tables = tables= {}
       define_method(:dataset){|*a| dsc.new(self, *a)}
-      define_method(:create_table){|name, *args| tables[name.to_sym] = true}
-      define_method(:drop_table){|*names| names.each{|n| tables.delete(n.to_sym)}}
-      define_method(:table_exists?){|name| tables.has_key?(name.to_sym)}
+      def create_table(name, *args, &block)
+        super
+        self.class::Tables[name.to_sym] = true
+      end
+      define_method(:drop_table){|*names| super(*names); names.each{|n| tables.delete(n.to_sym)}}
+      define_method(:table_exists?){|name| super(name); tables.has_key?(name.to_sym)}
     end
     @db = dbc.new
     @m = Sequel::Migrator
@@ -559,4 +591,29 @@ describe "Sequel::TimestampMigrator" do
     @m.apply(@db, @dir, 0).should == nil
     @m.apply(@db, @dir).should == nil
   end
+
+  specify "should use TimestampMigrator if TimestampMigrator.apply is called even for integer migrations directory" do
+    Sequel::TimestampMigrator.apply(@db, "spec/files/integer_migrations")
+    @db.sqls.should == ["SELECT NULL FROM schema_migrations LIMIT 1", "CREATE TABLE schema_migrations (filename varchar(255) PRIMARY KEY)", "SELECT NULL FROM schema_info LIMIT 1", "SELECT filename FROM schema_migrations ORDER BY filename", "BEGIN", "CREATE TABLE sm1111 (smc1 integer)", "INSERT INTO schema_migrations (filename) VALUES ('001_create_sessions.rb')", "COMMIT", "BEGIN", "CREATE TABLE sm2222 (smc2 integer)", "INSERT INTO schema_migrations (filename) VALUES ('002_create_nodes.rb')", "COMMIT", "BEGIN", "CREATE TABLE sm3333 (smc3 integer)", "INSERT INTO schema_migrations (filename) VALUES ('003_3_create_users.rb')", "COMMIT"]
+  end
+
+  specify "should use transactions by default" do
+    Sequel::TimestampMigrator.apply(@db, "spec/files/transaction_migrations")
+    @db.sqls.should == ["SELECT NULL FROM schema_migrations LIMIT 1", "CREATE TABLE schema_migrations (filename varchar(255) PRIMARY KEY)", "SELECT NULL FROM schema_info LIMIT 1", "SELECT filename FROM schema_migrations ORDER BY filename", "BEGIN", "CREATE TABLE sm11111 (smc1 integer)", "INSERT INTO schema_migrations (filename) VALUES ('001_create_alt_basic.rb')", "COMMIT", "BEGIN", "CREATE TABLE sm (smc1 integer)", "INSERT INTO schema_migrations (filename) VALUES ('002_create_basic.rb')", "COMMIT"]
+  end
+
+  specify "should not use transactions for migrations that disable it" do
+    Sequel::TimestampMigrator.apply(@db, "spec/files/transactionless_migrations")
+    @db.sqls.should == ["SELECT NULL FROM schema_migrations LIMIT 1", "CREATE TABLE schema_migrations (filename varchar(255) PRIMARY KEY)", "SELECT NULL FROM schema_info LIMIT 1", "SELECT filename FROM schema_migrations ORDER BY filename", "CREATE TABLE sm11111 (smc1 integer)", "INSERT INTO schema_migrations (filename) VALUES ('001_create_alt_basic.rb')", "CREATE TABLE sm (smc1 integer)", "INSERT INTO schema_migrations (filename) VALUES ('002_create_basic.rb')"]
+  end
+
+  specify "should force transactions if enabled by the migrator" do
+    Sequel::TimestampMigrator.run(@db, "spec/files/transactionless_migrations", :use_transactions=>true)
+    @db.sqls.should == ["SELECT NULL FROM schema_migrations LIMIT 1", "CREATE TABLE schema_migrations (filename varchar(255) PRIMARY KEY)", "SELECT NULL FROM schema_info LIMIT 1", "SELECT filename FROM schema_migrations ORDER BY filename", "BEGIN", "CREATE TABLE sm11111 (smc1 integer)", "INSERT INTO schema_migrations (filename) VALUES ('001_create_alt_basic.rb')", "COMMIT", "BEGIN", "CREATE TABLE sm (smc1 integer)", "INSERT INTO schema_migrations (filename) VALUES ('002_create_basic.rb')", "COMMIT"]
+  end
+
+  specify "should not use transactions if disabled in the migrator" do
+    Sequel::TimestampMigrator.run(@db, "spec/files/transaction_migrations", :use_transactions=>false)
+    @db.sqls.should == ["SELECT NULL FROM schema_migrations LIMIT 1", "CREATE TABLE schema_migrations (filename varchar(255) PRIMARY KEY)", "SELECT NULL FROM schema_info LIMIT 1", "SELECT filename FROM schema_migrations ORDER BY filename", "CREATE TABLE sm11111 (smc1 integer)", "INSERT INTO schema_migrations (filename) VALUES ('001_create_alt_basic.rb')", "CREATE TABLE sm (smc1 integer)", "INSERT INTO schema_migrations (filename) VALUES ('002_create_basic.rb')"]
+  end
 end