sequel 3.1.0 → 3.2.0

data/spec/core/expression_filters_spec.rb

@@ -1,5 +1,8 @@
 require File.join(File.dirname(__FILE__), 'spec_helper')
 
+Regexp.send(:include, Sequel::SQL::StringMethods)
+String.send(:include, Sequel::SQL::StringMethods)
+
 context "Blockless Ruby Filters" do
   before do
     db = Sequel::Database.new
@@ -48,6 +51,14 @@ context "Blockless Ruby Filters" do
     @d.l(:x => nil).should == '(x IS NULL)'
     @d.l(:x => [1,2,3]).should == '(x IN (1, 2, 3))'
   end
+
+  it "should use = 't' and != 't' OR IS NULL if IS TRUE is not supported" do
+    @d.meta_def(:supports_is_true?){false}
+    @d.l(:x => true).should == "(x = 't')"
+    @d.l(~{:x => true}).should == "((x != 't') OR (x IS NULL))"
+    @d.l(:x => false).should == "(x = 'f')"
+    @d.l(~{:x => false}).should == "((x != 'f') OR (x IS NULL))"
+  end
   
   it "should support != via Hash#~" do
     @d.l(~{:x => 100}).should == '(x != 100)'
@@ -71,6 +82,21 @@ context "Blockless Ruby Filters" do
     @d.l(:x.like('a', 'b')).should == '((x LIKE \'a\') OR (x LIKE \'b\'))'
     @d.l(:x.like(/a/, /b/i)).should == '((x ~ \'a\') OR (x ~* \'b\'))'
     @d.l(:x.like('a', /b/)).should == '((x LIKE \'a\') OR (x ~ \'b\'))'
+
+    @d.l('a'.like(:x)).should == "('a' LIKE x)"
+    @d.l('a'.like(:x, 'b')).should == "(('a' LIKE x) OR ('a' LIKE 'b'))"
+    @d.l('a'.like(:x, /b/)).should == "(('a' LIKE x) OR ('a' ~ 'b'))"
+    @d.l('a'.like(:x, /b/i)).should == "(('a' LIKE x) OR ('a' ~* 'b'))"
+
+    @d.l(/a/.like(:x)).should == "('a' ~ x)"
+    @d.l(/a/.like(:x, 'b')).should == "(('a' ~ x) OR ('a' ~ 'b'))"
+    @d.l(/a/.like(:x, /b/)).should == "(('a' ~ x) OR ('a' ~ 'b'))"
+    @d.l(/a/.like(:x, /b/i)).should == "(('a' ~ x) OR ('a' ~* 'b'))"
+
+    @d.l(/a/i.like(:x)).should == "('a' ~* x)"
+    @d.l(/a/i.like(:x, 'b')).should == "(('a' ~* x) OR ('a' ~* 'b'))"
+    @d.l(/a/i.like(:x, /b/)).should == "(('a' ~* x) OR ('a' ~* 'b'))"
+    @d.l(/a/i.like(:x, /b/i)).should == "(('a' ~* x) OR ('a' ~* 'b'))"
   end
 
   it "should support NOT LIKE via Symbol#like and Symbol#~" do
@@ -79,6 +105,21 @@ context "Blockless Ruby Filters" do
     @d.l(~:x.like('a', 'b')).should == '((x NOT LIKE \'a\') AND (x NOT LIKE \'b\'))'
     @d.l(~:x.like(/a/, /b/i)).should == '((x !~ \'a\') AND (x !~* \'b\'))'
     @d.l(~:x.like('a', /b/)).should == '((x NOT LIKE \'a\') AND (x !~ \'b\'))'
+
+    @d.l(~'a'.like(:x)).should == "('a' NOT LIKE x)"
+    @d.l(~'a'.like(:x, 'b')).should == "(('a' NOT LIKE x) AND ('a' NOT LIKE 'b'))"
+    @d.l(~'a'.like(:x, /b/)).should == "(('a' NOT LIKE x) AND ('a' !~ 'b'))"
+    @d.l(~'a'.like(:x, /b/i)).should == "(('a' NOT LIKE x) AND ('a' !~* 'b'))"
+
+    @d.l(~/a/.like(:x)).should == "('a' !~ x)"
+    @d.l(~/a/.like(:x, 'b')).should == "(('a' !~ x) AND ('a' !~ 'b'))"
+    @d.l(~/a/.like(:x, /b/)).should == "(('a' !~ x) AND ('a' !~ 'b'))"
+    @d.l(~/a/.like(:x, /b/i)).should == "(('a' !~ x) AND ('a' !~* 'b'))"
+
+    @d.l(~/a/i.like(:x)).should == "('a' !~* x)"
+    @d.l(~/a/i.like(:x, 'b')).should == "(('a' !~* x) AND ('a' !~* 'b'))"
+    @d.l(~/a/i.like(:x, /b/)).should == "(('a' !~* x) AND ('a' !~* 'b'))"
+    @d.l(~/a/i.like(:x, /b/i)).should == "(('a' !~* x) AND ('a' !~* 'b'))"
   end
 
   it "should support ILIKE via Symbol#ilike" do
@@ -87,6 +128,21 @@ context "Blockless Ruby Filters" do
     @d.l(:x.ilike('a', 'b')).should == '((x ILIKE \'a\') OR (x ILIKE \'b\'))'
     @d.l(:x.ilike(/a/, /b/i)).should == '((x ~* \'a\') OR (x ~* \'b\'))'
     @d.l(:x.ilike('a', /b/)).should == '((x ILIKE \'a\') OR (x ~* \'b\'))'
+
+    @d.l('a'.ilike(:x)).should == "('a' ILIKE x)"
+    @d.l('a'.ilike(:x, 'b')).should == "(('a' ILIKE x) OR ('a' ILIKE 'b'))"
+    @d.l('a'.ilike(:x, /b/)).should == "(('a' ILIKE x) OR ('a' ~* 'b'))"
+    @d.l('a'.ilike(:x, /b/i)).should == "(('a' ILIKE x) OR ('a' ~* 'b'))"
+
+    @d.l(/a/.ilike(:x)).should == "('a' ~* x)"
+    @d.l(/a/.ilike(:x, 'b')).should == "(('a' ~* x) OR ('a' ~* 'b'))"
+    @d.l(/a/.ilike(:x, /b/)).should == "(('a' ~* x) OR ('a' ~* 'b'))"
+    @d.l(/a/.ilike(:x, /b/i)).should == "(('a' ~* x) OR ('a' ~* 'b'))"
+
+    @d.l(/a/i.ilike(:x)).should == "('a' ~* x)"
+    @d.l(/a/i.ilike(:x, 'b')).should == "(('a' ~* x) OR ('a' ~* 'b'))"
+    @d.l(/a/i.ilike(:x, /b/)).should == "(('a' ~* x) OR ('a' ~* 'b'))"
+    @d.l(/a/i.ilike(:x, /b/i)).should == "(('a' ~* x) OR ('a' ~* 'b'))"
   end
 
   it "should support NOT ILIKE via Symbol#ilike and Symbol#~" do
@@ -95,6 +151,21 @@ context "Blockless Ruby Filters" do
     @d.l(~:x.ilike('a', 'b')).should == '((x NOT ILIKE \'a\') AND (x NOT ILIKE \'b\'))'
     @d.l(~:x.ilike(/a/, /b/i)).should == '((x !~* \'a\') AND (x !~* \'b\'))'
     @d.l(~:x.ilike('a', /b/)).should == '((x NOT ILIKE \'a\') AND (x !~* \'b\'))'
+
+    @d.l(~'a'.ilike(:x)).should == "('a' NOT ILIKE x)"
+    @d.l(~'a'.ilike(:x, 'b')).should == "(('a' NOT ILIKE x) AND ('a' NOT ILIKE 'b'))"
+    @d.l(~'a'.ilike(:x, /b/)).should == "(('a' NOT ILIKE x) AND ('a' !~* 'b'))"
+    @d.l(~'a'.ilike(:x, /b/i)).should == "(('a' NOT ILIKE x) AND ('a' !~* 'b'))"
+
+    @d.l(~/a/.ilike(:x)).should == "('a' !~* x)"
+    @d.l(~/a/.ilike(:x, 'b')).should == "(('a' !~* x) AND ('a' !~* 'b'))"
+    @d.l(~/a/.ilike(:x, /b/)).should == "(('a' !~* x) AND ('a' !~* 'b'))"
+    @d.l(~/a/.ilike(:x, /b/i)).should == "(('a' !~* x) AND ('a' !~* 'b'))"
+
+    @d.l(~/a/i.ilike(:x)).should == "('a' !~* x)"
+    @d.l(~/a/i.ilike(:x, 'b')).should == "(('a' !~* x) AND ('a' !~* 'b'))"
+    @d.l(~/a/i.ilike(:x, /b/)).should == "(('a' !~* x) AND ('a' !~* 'b'))"
+    @d.l(~/a/i.ilike(:x, /b/i)).should == "(('a' !~* x) AND ('a' !~* 'b'))"
   end
 
   it "should support negating ranges via Hash#~ and Range" do
@@ -373,3 +444,88 @@ context "Blockless Ruby Filters" do
     end
   end
 end
+
+context Sequel::SQL::VirtualRow do
+  before do
+    db = Sequel::Database.new
+    db.quote_identifiers = true
+    @d = db[:items]
+    @d.meta_def(:supports_window_functions?){true}
+    def @d.l(*args, &block)
+      literal(filter_expr(*args, &block))
+    end
+  end
+
+  it "should treat methods without arguments as identifiers" do
+    @d.l{column}.should == '"column"'
+  end
+
+  it "should treat methods without arguments that have embedded double underscores as qualified identifiers" do
+    @d.l{table__column}.should == '"table"."column"'
+  end
+
+  it "should treat methods with arguments as functions with the arguments" do
+    @d.l{function(arg1, 10, 'arg3')}.should == 'function("arg1", 10, \'arg3\')'
+  end
+
+  it "should treat methods with a block and no arguments as a function call with no arguments" do
+    @d.l{version{}}.should == 'version()'
+  end
+
+  it "should treat methods with a block and a leading argument :* as a function call with the SQL wildcard" do
+    @d.l{count(:*){}}.should == 'count(*)'
+  end
+
+  it "should treat methods with a block and a leading argument :distinct as a function call with DISTINCT and the additional method arguments" do
+    @d.l{count(:distinct, column1){}}.should == 'count(DISTINCT "column1")'
+    @d.l{count(:distinct, column1, column2){}}.should == 'count(DISTINCT "column1", "column2")'
+  end
+
+  it "should raise an error if an unsupported argument is used with a block" do
+    proc{@d.l{count(:blah){}}}.should raise_error(Sequel::Error)
+  end
+
+  it "should treat methods with a block and a leading argument :over as a window function call" do
+    @d.l{rank(:over){}}.should == 'rank() OVER ()'
+  end
+
+  it "should support :partition options for window function calls" do
+    @d.l{rank(:over, :partition=>column1){}}.should == 'rank() OVER (PARTITION BY "column1")'
+    @d.l{rank(:over, :partition=>[column1, column2]){}}.should == 'rank() OVER (PARTITION BY "column1", "column2")'
+  end
+
+  it "should support :args options for window function calls" do
+    @d.l{avg(:over, :args=>column1){}}.should == 'avg("column1") OVER ()'
+    @d.l{avg(:over, :args=>[column1, column2]){}}.should == 'avg("column1", "column2") OVER ()'
+  end
+
+  it "should support :order option for window function calls" do
+    @d.l{rank(:over, :order=>column1){}}.should == 'rank() OVER (ORDER BY "column1")'
+    @d.l{rank(:over, :order=>[column1, column2]){}}.should == 'rank() OVER (ORDER BY "column1", "column2")'
+  end
+
+  it "should support :window option for window function calls" do
+    @d.l{rank(:over, :window=>:win){}}.should == 'rank() OVER ("win")'
+  end
+
+  it "should support :*=>true option for window function calls" do
+    @d.l{count(:over, :* =>true){}}.should == 'count(*) OVER ()'
+  end
+
+  it "should support :frame=>:all option for window function calls" do
+    @d.l{rank(:over, :frame=>:all){}}.should == 'rank() OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING)'
+  end
+
+  it "should support :frame=>:rows option for window function calls" do
+    @d.l{rank(:over, :frame=>:rows){}}.should == 'rank() OVER (ROWS UNBOUNDED PRECEDING)'
+  end
+
+  it "should support all these options together" do
+    @d.l{count(:over, :* =>true, :partition=>a, :order=>b, :window=>:win, :frame=>:rows){}}.should == 'count(*) OVER ("win" PARTITION BY "a" ORDER BY "b" ROWS UNBOUNDED PRECEDING)'
+  end
+
+  it "should raise an error if window functions are not supported" do
+    @d.meta_def(:supports_window_functions?){false}
+    proc{@d.l{count(:over, :* =>true, :partition=>a, :order=>b, :window=>:win, :frame=>:rows){}}}.should raise_error(Sequel::Error)
+  end
+end

data/spec/core/object_graph_spec.rb

@@ -30,7 +30,18 @@ describe Sequel::Dataset, " graphing" do
 
   it "#graph should accept a complex dataset and pass it directly to join" do
     ds = @ds1.graph(@ds2.filter(:x=>1), {:x=>:id})
-    ds.sql.should == 'SELECT points.id, points.x, points.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id FROM points LEFT OUTER JOIN (SELECT * FROM lines WHERE (x = 1)) AS lines ON (lines.x = points.id)'
+    ds.sql.should == 'SELECT points.id, points.x, points.y, t1.id AS t1_id, t1.x AS t1_x, t1.y AS t1_y, t1.graph_id FROM points LEFT OUTER JOIN (SELECT * FROM lines WHERE (x = 1)) AS t1 ON (t1.x = points.id)'
+  end
+
+  it "#graph should work on from_self datasets" do
+    ds = @ds1.from_self.graph(@ds2, :x=>:id)
+    ds.sql.should == 'SELECT t1.id, t1.x, t1.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id FROM (SELECT * FROM points) AS t1 LEFT OUTER JOIN lines ON (lines.x = t1.id)'
+    ds = @ds1.graph(@ds2.from_self, :x=>:id)
+    ds.sql.should == 'SELECT points.id, points.x, points.y, t1.id AS t1_id, t1.x AS t1_x, t1.y AS t1_y, t1.graph_id FROM points LEFT OUTER JOIN (SELECT * FROM (SELECT * FROM lines) AS t1) AS t1 ON (t1.x = points.id)'
+    ds = @ds1.from_self.from_self.graph(@ds2.from_self.from_self, :x=>:id)
+    ds.sql.should == 'SELECT t1.id, t1.x, t1.y, t2.id AS t2_id, t2.x AS t2_x, t2.y AS t2_y, t2.graph_id FROM (SELECT * FROM (SELECT * FROM points) AS t1) AS t1 LEFT OUTER JOIN (SELECT * FROM (SELECT * FROM (SELECT * FROM lines) AS t1) AS t1) AS t2 ON (t2.x = t1.id)'
+    ds = @ds1.from(@ds1, @ds3).graph(@ds2.from_self, :x=>:id)
+    ds.sql.should == 'SELECT t1.id, t1.x, t1.y, t3.id AS t3_id, t3.x AS t3_x, t3.y AS t3_y, t3.graph_id FROM (SELECT * FROM points) AS t1, (SELECT * FROM graphs) AS t2 LEFT OUTER JOIN (SELECT * FROM (SELECT * FROM lines) AS t1) AS t3 ON (t3.x = t1.id)'
   end
 
   it "#graph should accept a symbol table name as the dataset" do
@@ -187,6 +198,14 @@ describe Sequel::Dataset, " graphing" do
     results.first.should == {:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}, :graph=>{:id=>8, :x=>9, :y=>10, :graph_id=>11}}
   end
 
+  it "#ungraphed should remove the splitting of result sets into component tables" do
+    ds = @ds1.graph(@ds2, :x=>:id).ungraphed
+    def ds.fetch_rows(sql, &block)
+      yield({:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7})
+    end
+    ds.all.should == [{:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7}]
+  end
+
   it "#graph_each should give a nil value instead of a hash when all values for a table are nil" do
     ds = @ds1.graph(@ds2, :x=>:id)
     def ds.fetch_rows(sql, &block)

data/spec/core/schema_spec.rb

@@ -762,11 +762,11 @@ context "Schema Parser" do
       sqls << t
       [[:a, {:db_type=>t.to_s}]]
     end
-    @db.schema(:x).should == [[:a, {:db_type=>"x"}]]
+    @db.schema(:x).should == [[:a, {:db_type=>"x", :ruby_default=>nil}]]
     @sqls.should == ['x']
-    @db.schema(:x).should == [[:a, {:db_type=>"x"}]]
+    @db.schema(:x).should == [[:a, {:db_type=>"x", :ruby_default=>nil}]]
     @sqls.should == ['x']
-    @db.schema(:x, :reload=>true).should == [[:a, {:db_type=>"x"}]]
+    @db.schema(:x, :reload=>true).should == [[:a, {:db_type=>"x", :ruby_default=>nil}]]
     @sqls.should == ['x', 'x']
   end
 
@@ -775,11 +775,11 @@ context "Schema Parser" do
       [[t, {:db_type=>t}]]
     end
     s1 = @db.schema(:x)
-    s1.should == [['x', {:db_type=>'x'}]]
+    s1.should == [['x', {:db_type=>'x', :ruby_default=>nil}]]
     @db.schema(:x).object_id.should == s1.object_id
     @db.schema(:x.identifier).object_id.should == s1.object_id
     s2 = @db.schema(:x__y)
-    s2.should == [['y', {:db_type=>'y'}]]
+    s2.should == [['y', {:db_type=>'y', :ruby_default=>nil}]]
     @db.schema(:x__y).object_id.should == s2.object_id
     @db.schema(:y.qualify(:x)).object_id.should == s2.object_id
   end

data/spec/extensions/migration_spec.rb

@@ -47,39 +47,6 @@ context "Migration#apply" do
   end
 end
 
-class DummyMigrationDataset
-  attr_reader :from
-  
-  def initialize(x); @from = x; end
-  
-  @@version = nil
-  
-  def version; @@version; end
-  def version=(x); @@version = x; end
-  def first; @@version ? {:version => @@version} : nil; end
-  def update(h); @@version = h[:version]; end
-  def <<(h); @@version = h[:version]; end
-end
-
-class DummyMigrationDB
-  attr_reader :creates, :drops, :table_created
-  
-  def initialize
-    @creates = []
-    @drops = []
-  end
-  
-  def create(x); @creates << x; end
-  def drop(x); @drops << x; end
-  
-  def [](x); DummyMigrationDataset.new(x); end
-  
-  def create_table(x); raise if @table_created == x; @table_created = x; end
-  def table_exists?(x); @table_created == x; end
-  
-  def transaction; yield; end
-end
-
 MIGRATION_001 = %[
   class CreateSessions < Sequel::Migration
     def up
@@ -128,16 +95,76 @@ MIGRATION_005 = %[
   end
 ]
 
+ALT_MIGRATION_001 = %[
+  class CreateAltBasic < Sequel::Migration
+    def up
+      create(11111)
+    end
+    
+    def down
+      drop(11111)
+    end
+  end
+]
+
+ALT_MIGRATION_003 = %[
+  class CreateAltAdvanced < Sequel::Migration
+    def up
+      create(33333)
+    end
+    
+    def down
+      drop(33333)
+    end
+  end
+]
+
 context "Sequel::Migrator" do
   before do
-    @db = DummyMigrationDB.new
+    dbc = Class.new(MockDatabase) do
+      attr_reader :creates, :drops, :tables_created, :columns_created, :versions
+      def initialize(*args)
+        super
+        @creates = []
+        @drops = []
+        @tables_created = []
+        @columns_created = []
+        @versions = {}
+      end
+  
+      def create(x); @creates << x; end
+      def drop(x); @drops << x; end
+
+      def create_table(name, opts={}, &block)
+        super
+        @columns_created << / \(?(\w+) integer\)?\z/.match(sqls.last)[1].to_sym
+        @tables_created << name
+      end
+      
+      def dataset(opts={})
+        ds = super
+        ds.extend(Module.new do
+          def columns; db.columns_created end
+          def insert(h); db.versions.merge!(h); super(h) end
+          def update(h); db.versions.merge!(h); super(h) end
+          def fetch_rows(sql); db.execute(sql); yield(db.versions) unless db.versions.empty? end
+        end)
+        ds
+      end
+
+      def table_exists?(name)
+        @tables_created.include?(name)
+      end
+    end
+    @db = dbc.new
     
     File.open('001_create_sessions.rb', 'w') {|f| f << MIGRATION_001}
     File.open('002_create_nodes.rb', 'w') {|f| f << MIGRATION_002}
     File.open('003_create_users.rb', 'w') {|f| f << MIGRATION_003}
     File.open('005_5_create_attributes.rb', 'w') {|f| f << MIGRATION_005}
-    
-    @db[:schema_info].version = nil
+    Dir.mkdir("alt_app")
+    File.open('alt_app/001_create_alt_basic.rb', 'w') {|f| f << ALT_MIGRATION_001}
+    File.open('alt_app/003_create_alt_advanced.rb', 'w') {|f| f << ALT_MIGRATION_003}
   end
   
   after do
@@ -145,77 +172,97 @@ context "Sequel::Migrator" do
     Object.send(:remove_const, "CreateNodes") if Object.const_defined?("CreateNodes")
     Object.send(:remove_const, "CreateUsers") if Object.const_defined?("CreateUsers")
     Object.send(:remove_const, "CreateAttributes") if Object.const_defined?("CreateAttributes")
+    Object.send(:remove_const, "CreateAltBasic") if Object.const_defined?("CreateAltBasic")
+    Object.send(:remove_const, "CreateAltAdvanced") if Object.const_defined?("CreateAltAdvanced")
 
     File.delete('001_create_sessions.rb')
     File.delete('002_create_nodes.rb')
     File.delete('003_create_users.rb')
     File.delete('005_5_create_attributes.rb')
+    File.delete("alt_app/001_create_alt_basic.rb")
+    File.delete("alt_app/003_create_alt_advanced.rb")
+    Dir.rmdir("alt_app")
   end
   
-  specify "should return the list of files for a specified version range" do
-    Sequel::Migrator.migration_files('.', 1..1).should == \
-      ['./001_create_sessions.rb']
-
-    Sequel::Migrator.migration_files('.', 1..3).should == \
-      ['./001_create_sessions.rb', './002_create_nodes.rb', './003_create_users.rb']
-
-    Sequel::Migrator.migration_files('.', 3..6).should == \
-      ['./003_create_users.rb', './005_5_create_attributes.rb']
-      
+  specify "#migration_files should return the list of files for a specified version range" do
+    Sequel::Migrator.migration_files('.', 1..1).should == ['./001_create_sessions.rb']
+    Sequel::Migrator.migration_files('.', 1..3).should == ['./001_create_sessions.rb', './002_create_nodes.rb', './003_create_users.rb']
+    Sequel::Migrator.migration_files('.', 3..6).should == ['./003_create_users.rb', './005_5_create_attributes.rb']
     Sequel::Migrator.migration_files('.', 7..8).should == []
+    Sequel::Migrator.migration_files('alt_app', 1..1).should == ['alt_app/001_create_alt_basic.rb']
+    Sequel::Migrator.migration_files('alt_app', 1..3).should == ['alt_app/001_create_alt_basic.rb','alt_app/003_create_alt_advanced.rb']
   end
   
-  specify "should return the latest version available" do
+  specify "#latest_migration_version should return the latest version available" do
     Sequel::Migrator.latest_migration_version('.').should == 5
+    Sequel::Migrator.latest_migration_version('alt_app').should == 3
   end
   
-  specify "should load the migration classes for the specified range" do
-    Sequel::Migrator.migration_classes('.', 3, 0, :up).should == \
-      [CreateSessions, CreateNodes, CreateUsers]
+  specify "#migration_classes should load the migration classes for the specified range for the up direction" do
+    Sequel::Migrator.migration_classes('.', 3, 0, :up).should == [CreateSessions, CreateNodes, CreateUsers]
+    Sequel::Migrator.migration_classes('alt_app', 3, 0, :up).should == [CreateAltBasic, CreateAltAdvanced]
   end
   
-  specify "should load the migration classes for the specified range" do
-    Sequel::Migrator.migration_classes('.', 0, 5, :down).should == \
-      [CreateAttributes, CreateUsers, CreateNodes, CreateSessions]
+  specify "#migration_classes should load the migration classes for the specified range for the down direction" do
+    Sequel::Migrator.migration_classes('.', 0, 5, :down).should == [CreateAttributes, CreateUsers, CreateNodes, CreateSessions]
+    Sequel::Migrator.migration_classes('alt_app', 0, 3, :down).should == [CreateAltAdvanced, CreateAltBasic]
   end
   
-  specify "should start from current + 1 for the up direction" do
-    Sequel::Migrator.migration_classes('.', 3, 1, :up).should == \
-      [CreateNodes, CreateUsers]
+  specify "#migration_classes should start from current + 1 for the up direction" do
+    Sequel::Migrator.migration_classes('.', 3, 1, :up).should == [CreateNodes, CreateUsers]
+    Sequel::Migrator.migration_classes('alt_app', 3, 2, :up).should == [CreateAltAdvanced]
   end
   
-  specify "should end on current + 1 for the down direction" do
-    Sequel::Migrator.migration_classes('.', 2, 5, :down).should == \
-      [CreateAttributes, CreateUsers]
+  specify "#migration_classes should end on current + 1 for the down direction" do
+    Sequel::Migrator.migration_classes('.', 2, 5, :down).should == [CreateAttributes, CreateUsers]
+    Sequel::Migrator.migration_classes('alt_app', 2, 4, :down).should == [CreateAltAdvanced]
   end
   
-  specify "should automatically create the schema_info table" do
+  specify "#schema_info_dataset should automatically create the schema_info table" do
     @db.table_exists?(:schema_info).should be_false
     Sequel::Migrator.schema_info_dataset(@db)
     @db.table_exists?(:schema_info).should be_true
-    
-    # should not raise if table already exists
-    proc {Sequel::Migrator.schema_info_dataset(@db)}.should_not raise_error
+    @db.sqls.should == ["CREATE TABLE schema_info (version integer)"]
+  end
+
+  specify "should automatically create new APP_version column in schema_info" do
+    @db.table_exists?(:schema_info).should be_false
+    Sequel::Migrator.schema_info_dataset(@db, :column => :alt_version)
+    @db.table_exists?(:schema_info).should be_true
+    @db.sqls.should == ["CREATE TABLE schema_info (alt_version integer)"]
+  end
+  
+  specify "should automatically create new APP_version column in schema_info" do
+    @db.table_exists?(:alt_table).should be_false
+    Sequel::Migrator.schema_info_dataset(@db, :table => :alt_table)
+    @db.table_exists?(:alt_table).should be_true
+    Sequel::Migrator.schema_info_dataset(@db, :table => :alt_table, :column=>:alt_version)
+    @db.sqls.should == ["CREATE TABLE alt_table (version integer)",
+      "ALTER TABLE alt_table ADD COLUMN alt_version integer"]
   end
   
-  specify "should return a dataset for the schema_info table" do
-    d = Sequel::Migrator.schema_info_dataset(@db)
-    d.from.should == :schema_info
+  specify "should return a dataset for the correct table" do
+    Sequel::Migrator.schema_info_dataset(@db).first_source_alias.should == :schema_info
+    Sequel::Migrator.schema_info_dataset(@db, :table=>:blah).first_source_alias.should == :blah
   end
   
-  specify "should get the migration version stored in the database" do
-    # default is 0
+  specify "should assume a migration version of 0 if no migration information exists in the database" do
     Sequel::Migrator.get_current_migration_version(@db).should == 0
-    
-    Sequel::Migrator.schema_info_dataset(@db) << {:version => 4321}
-
+    @db.sqls.should == ["CREATE TABLE schema_info (version integer)", "SELECT * FROM schema_info LIMIT 1"]
+  end
+  specify "should use the migration version stored in the database" do
+    Sequel::Migrator.schema_info_dataset(@db).insert(:version => 4321)
     Sequel::Migrator.get_current_migration_version(@db).should == 4321
+    @db.sqls.should == ["CREATE TABLE schema_info (version integer)", "INSERT INTO schema_info (version) VALUES (4321)", "SELECT * FROM schema_info LIMIT 1"]
   end
   
   specify "should set the migration version stored in the database" do
-    Sequel::Migrator.get_current_migration_version(@db).should == 0
     Sequel::Migrator.set_current_migration_version(@db, 6666)
     Sequel::Migrator.get_current_migration_version(@db).should == 6666
+    @db.sqls.should == ["CREATE TABLE schema_info (version integer)",
+      "SELECT * FROM schema_info LIMIT 1",
+      "INSERT INTO schema_info (version) VALUES (6666)",
+      "SELECT * FROM schema_info LIMIT 1"]
   end
   
   specify "should apply migrations correctly in the up direction" do
@@ -228,6 +275,14 @@ context "Sequel::Migrator" do
     @db.creates.should == [3333, 5555]
 
     Sequel::Migrator.get_current_migration_version(@db).should == 5
+    @db.sqls.should == ["CREATE TABLE schema_info (version integer)",
+      "SELECT * FROM schema_info LIMIT 1",
+      "INSERT INTO schema_info (version) VALUES (3)",
+      "SELECT * FROM schema_info LIMIT 1",
+      "SELECT * FROM schema_info LIMIT 1",
+      "SELECT * FROM schema_info LIMIT 1",
+      "UPDATE schema_info SET version = 5",
+      "SELECT * FROM schema_info LIMIT 1"]
   end
   
   specify "should apply migrations correctly in the down direction" do
@@ -235,6 +290,10 @@ context "Sequel::Migrator" do
     @db.drops.should == [5555, 3333, 2222]
 
     Sequel::Migrator.get_current_migration_version(@db).should == 1
+    @db.sqls.should == ["CREATE TABLE schema_info (version integer)",
+      "SELECT * FROM schema_info LIMIT 1",
+      "INSERT INTO schema_info (version) VALUES (1)",
+      "SELECT * FROM schema_info LIMIT 1"]
   end
 
   specify "should apply migrations up to the latest version if no target is given" do
@@ -242,6 +301,11 @@ context "Sequel::Migrator" do
     @db.creates.should == [1111, 2222, 3333, 5555]
 
     Sequel::Migrator.get_current_migration_version(@db).should == 5
+    @db.sqls.should == ["CREATE TABLE schema_info (version integer)",
+      "SELECT * FROM schema_info LIMIT 1",
+      "SELECT * FROM schema_info LIMIT 1",
+      "INSERT INTO schema_info (version) VALUES (5)",
+      "SELECT * FROM schema_info LIMIT 1"]
   end
 
   specify "should apply migrations down to 0 version correctly" do
@@ -249,13 +313,15 @@ context "Sequel::Migrator" do
     @db.drops.should == [5555, 3333, 2222, 1111]
 
     Sequel::Migrator.get_current_migration_version(@db).should == 0
+    @db.sqls.should == ["CREATE TABLE schema_info (version integer)",
+      "SELECT * FROM schema_info LIMIT 1",
+      "INSERT INTO schema_info (version) VALUES (0)",
+      "SELECT * FROM schema_info LIMIT 1"]
   end
   
   specify "should return the target version" do
     Sequel::Migrator.apply(@db, '.', 3, 2).should == 3
-
     Sequel::Migrator.apply(@db, '.', 0).should == 0
-
     Sequel::Migrator.apply(@db, '.').should == 5
   end
 end