sequel 3.11.0 → 3.12.0

data/spec/extensions/schema_dumper_spec.rb

@@ -69,7 +69,7 @@ describe "Sequel::Database dump methods" do
     @d.meta_def(:tables){|o| [:t1, :t2]}
     @d.meta_def(:schema) do |t, *o|
       case t
-      when :t1
+      when :t1, 't__t1', :t__t1.identifier
         [[:c1, {:db_type=>'integer', :primary_key=>true, :allow_null=>false}],
          [:c2, {:db_type=>'varchar(20)', :allow_null=>true}]]
       when :t2
@@ -92,6 +92,14 @@ describe "Sequel::Database dump methods" do
     @d.dump_table_schema(:t1).should == "create_table(:t1) do\n  primary_key :c1\n  String :c2, :size=>20\nend"
   end
 
+  it "should support dumping table schemas when given a string" do
+    @d.dump_table_schema('t__t1').should == "create_table(\"t__t1\") do\n  primary_key :c1\n  String :c2, :size=>20\nend"
+  end
+
+  it "should support dumping table schemas when given an identifier" do
+    @d.dump_table_schema(:t__t1.identifier).should == "create_table(\"t__t1\") do\n  primary_key :c1\n  String :c2, :size=>20\nend"
+  end
+
   it "should dump non-Integer primary key columns with explicit :type" do
     @d.dump_table_schema(:t6).should == "create_table(:t6) do\n  primary_key :c1, :type=>Bignum\nend"
   end
@@ -114,8 +122,8 @@ describe "Sequel::Database dump methods" do
 
   it "should support dumping the whole database as a migration" do
     @d.dump_schema_migration.should == <<-END_MIG
-Class.new(Sequel::Migration) do
-  def up
+Sequel.migration do
+  up do
     create_table(:t1) do
       primary_key :c1
       String :c2, :size=>20
@@ -129,7 +137,7 @@ Class.new(Sequel::Migration) do
     end
   end
   
-  def down
+  down do
     drop_table(:t1, :t2)
   end
 end
@@ -139,8 +147,8 @@ END_MIG
   it "should sort table names when dumping a migration" do
     @d.meta_def(:tables){|o| [:t2, :t1]}
     @d.dump_schema_migration.should == <<-END_MIG
-Class.new(Sequel::Migration) do
-  def up
+Sequel.migration do
+  up do
     create_table(:t1) do
       primary_key :c1
       String :c2, :size=>20
@@ -154,7 +162,7 @@ Class.new(Sequel::Migration) do
     end
   end
   
-  def down
+  down do
     drop_table(:t1, :t2)
   end
 end
@@ -164,8 +172,8 @@ END_MIG
   it "should honor the :same_db option to not convert types" do
     @d.dump_table_schema(:t1, :same_db=>true).should == "create_table(:t1) do\n  primary_key :c1\n  column :c2, \"varchar(20)\"\nend"
     @d.dump_schema_migration(:same_db=>true).should == <<-END_MIG
-Class.new(Sequel::Migration) do
-  def up
+Sequel.migration do
+  up do
     create_table(:t1) do
       primary_key :c1
       column :c2, "varchar(20)"
@@ -179,7 +187,7 @@ Class.new(Sequel::Migration) do
     end
   end
   
-  def down
+  down do
     drop_table(:t1, :t2)
   end
 end
@@ -193,8 +201,8 @@ END_MIG
     end
     @d.dump_table_schema(:t1, :indexes=>false).should == "create_table(:t1) do\n  primary_key :c1\n  String :c2, :size=>20\nend"
     @d.dump_schema_migration(:indexes=>false).should == <<-END_MIG
-Class.new(Sequel::Migration) do
-  def up
+Sequel.migration do
+  up do
     create_table(:t1) do
       primary_key :c1
       String :c2, :size=>20
@@ -208,7 +216,7 @@ Class.new(Sequel::Migration) do
     end
   end
   
-  def down
+  down do
     drop_table(:t1, :t2)
   end
 end
@@ -222,13 +230,13 @@ END_MIG
        :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>true}}
     end
     @d.dump_indexes_migration.should == <<-END_MIG
-Class.new(Sequel::Migration) do
-  def up
+Sequel.migration do
+  up do
     add_index :t1, [:c1], :ignore_errors=>true, :name=>:i1
     add_index :t1, [:c2, :c1], :ignore_errors=>true, :unique=>true
   end
   
-  def down
+  down do
     drop_index :t1, [:c1], :ignore_errors=>true, :name=>:i1
     drop_index :t1, [:c2, :c1], :ignore_errors=>true, :unique=>true
   end
@@ -282,7 +290,8 @@ END_MIG
       blob varbinary varbinary(10) binary binary(20) year" +
       ["double precision", "timestamp with time zone", "timestamp without time zone",
        "time with time zone", "time without time zone", "character varying(20)"] +
-      %w"nvarchar ntext smalldatetime smallmoney binary varbinary nchar"
+      %w"nvarchar ntext smalldatetime smallmoney binary varbinary nchar" +
+      ["timestamp(6) without time zone", "timestamp(6) with time zone"]
     @d.meta_def(:schema) do |t, *o|
       i = 0
       types.map{|x| [:"c#{i+=1}", {:db_type=>x, :allow_null=>true}]}
@@ -350,6 +359,8 @@ create_table(:x) do
   File :c59
   File :c60
   String :c61, :fixed=>true
+  DateTime :c62, :size=>6
+  DateTime :c63, :size=>6
 end
 END_MIG
     @d.dump_table_schema(:x).should == table.chomp

data/spec/extensions/sharding_spec.rb

@@ -0,0 +1,272 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe "sharding plugin" do
+  before do
+    @db = Sequel::Model.db.clone
+    @Artist = Class.new(Sequel::Model(@db[:artists]))
+    @Artist.class_eval do
+      columns :id, :name
+
+      def self.y
+        {:id=>2, :name=>'YJM'}
+      end
+    end
+    @Album = Class.new(Sequel::Model(@db[:albums]))
+    @Album.class_eval do
+      columns :id, :artist_id, :name
+
+      def self.ds_ext(m=nil)
+        @ds_ext = m if m
+        @ds_ext
+      end
+
+      def self.y
+        {:id=>1, :name=>'RF', :artist_id=>2}
+      end
+      
+      private
+
+      def _join_table_dataset(opts)
+        ds = super
+        m = model
+        ds.meta_def(:model){m}
+        ds.extend model.ds_ext
+        ds
+      end
+    end
+    @Tag = Class.new(Sequel::Model(@db[:tags]))
+    @Tag.class_eval do
+      columns :id, :name
+
+      def self.y
+        {:id=>3, :name=>'M'}
+      end
+    end
+    models = [@Artist, @Album, @Tag]
+    @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id
+    @Album.many_to_one :artist, :class=>@Artist
+    @Album.many_to_many :tags, :class=>@Tag, :left_key=>:album_id, :right_key=>:tag_id, :join_table=>:albums_tags
+    m = Module.new do
+      def actions
+        @actions ||= []
+      end
+    end
+    models.each do |model|
+      model.extend m
+      model.plugin :sharding
+      model.dataset.extend(ds_ext = Module.new do
+        def insert(h={})
+          model.actions << [:insert, h.dup, opts[:server]]
+          1
+        end
+        def delete
+          model.actions << [:delete,(literal(opts[:where]) if opts[:where]), opts[:server]]
+          1
+        end
+        def update(h={})
+          model.actions << [:update, h.dup, (literal(opts[:where]) if opts[:where]), opts[:server]]
+          1
+        end
+        def fetch_rows(sql)
+          model.actions << [:fetch, (literal(opts[:where] || opts[:join]) if opts[:where] || opts[:join]), opts[:server]]
+          yield(model.y)
+        end
+      end)
+      @Album.ds_ext(ds_ext)
+    end
+    def @db.actions; @actions ||= []; end
+    def @db.transaction(opts)
+      actions << [:transaction, opts[:server]]
+      super
+    end
+  end 
+
+  specify "should allow you to instantiate a new object for a specified shard" do
+    @Album.new_using_server(:s1, :name=>'RF').save
+    @Album.actions.should == [[:insert, {:name=>"RF"}, :s1], [:fetch, "(id = 1)", :s1]]
+    
+    @Album.actions.clear
+    @Album.new_using_server(:s2){|o| o.name = 'MO'}.save
+    @Album.actions.should == [[:insert, {:name=>"MO"}, :s2], [:fetch, "(id = 1)", :s2]]
+  end 
+
+  specify "should allow you to create and save a new object for a specified shard" do
+    @Album.create_using_server(:s1, :name=>'RF')
+    @Album.actions.should == [[:insert, {:name=>"RF"}, :s1], [:fetch, "(id = 1)", :s1]]
+    
+    @Album.actions.clear
+    @Album.create_using_server(:s2){|o| o.name = 'MO'}
+    @Album.actions.should == [[:insert, {:name=>"MO"}, :s2], [:fetch, "(id = 1)", :s2]]
+  end 
+
+  specify "should have objects retrieved from a specific shard update that shard" do
+    @Album.server(:s1).first.update(:name=>'MO')
+    @Album.actions.should == [[:fetch, nil, :s1], [:update, {:name=>"MO"}, "(id = 1)", :s1]]
+  end 
+
+  specify "should have objects retrieved from a specific shard delete from that shard" do
+    @Album.server(:s1).first.delete
+    @Album.actions.should == [[:fetch, nil, :s1], [:delete, "(id = 1)", :s1]]
+  end 
+
+  specify "should have objects retrieved from a specific shard reload from that shard" do
+    @Album.server(:s1).first.reload
+    @Album.actions.should == [[:fetch, nil, :s1], [:fetch, "(id = 1)", :s1]]
+  end 
+
+  specify "should use current dataset's shard when eager loading if eagerly loaded dataset doesn't have its own shard" do
+    albums = @Album.server(:s1).eager(:artist).all
+    @Album.actions.should == [[:fetch, nil, :s1]]
+    @Artist.actions.should == [[:fetch, "(artists.id IN (2))", :s1]]
+    @Artist.actions.clear
+    albums.length == 1
+    albums.first.artist.save
+    @Artist.actions.should == [[:update, {:name=>"YJM"}, "(id = 2)", :s1]]
+  end 
+
+  specify "should not use current dataset's shard when eager loading if eagerly loaded dataset has its own shard" do
+    @Artist.dataset.opts[:server] = :s2
+    albums = @Album.server(:s1).eager(:artist).all
+    @Album.actions.should == [[:fetch, nil, :s1]]
+    @Artist.actions.should == [[:fetch, "(artists.id IN (2))", :s2]]
+    @Artist.actions.clear
+    albums.length == 1
+    albums.first.artist.save
+    @Artist.actions.should == [[:update, {:name=>"YJM"}, "(id = 2)", :s2]]
+  end 
+
+  specify "should use current dataset's shard when eager graphing if eagerly graphed dataset doesn't have its own shard" do
+    ds = @Album.server(:s1).eager_graph(:artist)
+    def ds.fetch_rows(sql)
+      super(sql)
+      yield({:id=>1, :artist_id=>2, :name=>'RF', :artist_id_0=>2, :artist_name=>'YJM'})
+    end
+    albums = ds.all
+    @Album.actions.should == [[:fetch, "( LEFT OUTER JOIN artists AS artist ON (artist.id = albums.artist_id))", :s1]]
+    albums.length == 1
+    albums.first.artist.save
+    @Artist.actions.should == [[:update, {:name=>"YJM"}, "(id = 2)", :s1]]
+  end 
+
+  specify "should not use current dataset's shard when eager graphing if eagerly graphed dataset has its own shard" do
+    @Artist.dataset.opts[:server] = :s2
+    ds = @Album.server(:s1).eager_graph(:artist)
+    def ds.fetch_rows(sql)
+      super(sql)
+      yield({:id=>1, :artist_id=>2, :name=>'RF', :artist_id_0=>2, :artist_name=>'YJM'})
+    end
+    albums = ds.all
+    @Album.actions.should == [[:fetch, "( LEFT OUTER JOIN artists AS artist ON (artist.id = albums.artist_id))", :s1]]
+    albums.length == 1
+    albums.first.artist.save
+    @Artist.actions.should == [[:update, {:name=>"YJM"}, "(id = 2)", :s2]]
+  end 
+
+  specify "should use eagerly graphed dataset shard for eagerly graphed objects even if current dataset does not have a shard" do
+    @Artist.dataset.opts[:server] = :s2
+    ds = @Album.eager_graph(:artist)
+    def ds.fetch_rows(sql)
+      super(sql)
+      yield({:id=>1, :artist_id=>2, :name=>'RF', :artist_id_0=>2, :artist_name=>'YJM'})
+    end
+    albums = ds.all
+    @Album.actions.should == [[:fetch, "( LEFT OUTER JOIN artists AS artist ON (artist.id = albums.artist_id))", nil]]
+    albums.length == 1
+    albums.first.artist.save
+    @Artist.actions.should == [[:update, {:name=>"YJM"}, "(id = 2)", :s2]]
+  end 
+
+  specify "should have objects retrieved from a specific shard use associated objects from that shard, with modifications to the associated objects using that shard" do
+    album = @Album.server(:s1).first
+    @Album.actions.should == [[:fetch, nil, :s1]]
+    album.artist.update(:name=>'AS')
+    @Artist.actions.should == [[:fetch, "(artists.id = 2)", :s1], [:update, {:name=>"AS"}, "(id = 2)", :s1]]
+    album.tags.map{|a| a.update(:name=>'SR')}
+    @Tag.actions.should == [[:fetch, "( INNER JOIN albums_tags ON ((albums_tags.tag_id = tags.id) AND (albums_tags.album_id = 1)))", :s1], [:update, {:name=>"SR"}, "(id = 3)", :s1]]
+    
+    @Album.actions.clear
+    @Artist.actions.clear
+    @Artist.server(:s2).first.albums.map{|a| a.update(:name=>'MO')}
+    @Artist.actions.should == [[:fetch, nil, :s2]]
+    @Album.actions.should == [[:fetch, "(albums.artist_id = 2)", :s2], [:update, {:name=>"MO"}, "(id = 1)", :s2]]
+  end 
+
+  specify "should have objects retrieved from a specific shard add associated objects to that shard" do
+    album = @Album.server(:s1).first
+    artist = @Artist.server(:s2).first
+    @Album.actions.clear
+    @Artist.actions.clear
+
+    artist.add_album(:name=>'MO')
+    @Album.actions.should == [[:insert, {:name=>"MO", :artist_id=>2}, :s2], [:fetch, "(id = 1)", :s2]]
+    @Album.actions.clear
+    
+    album.add_tag(:name=>'SR')
+    @Tag.actions.should == [[:insert, {:name=>"SR"}, :s1], [:fetch, "(id = 1)", :s1]]
+    @Album.actions.should == [[:insert, {:album_id=>1, :tag_id=>3}, :s1]]
+  end 
+
+  specify "should have objects retrieved from a specific shard remove associated objects from that shard" do
+    album = @Album.server(:s1).first
+    artist = @Artist.server(:s2).first
+    @Album.actions.clear
+    @Artist.actions.clear
+
+    artist.remove_album(1)
+    @Album.actions.should == [[:fetch, "((albums.artist_id = 2) AND (albums.id = 1))", :s2], [:update, {:name=>"RF", :artist_id=>nil}, "(id = 1)", :s2]]
+    @Album.actions.clear
+    
+    album.remove_tag(3)
+    @Tag.actions.should == [[:fetch, "(tags.id = 3)", :s1]]
+    @Album.actions.should == [[:delete, "((album_id = 1) AND (tag_id = 3))", :s1]]
+  end 
+
+  specify "should have objects retrieved from a specific shard remove all associated objects from that shard" do
+    album = @Album.server(:s1).first
+    artist = @Artist.server(:s2).first
+    @Album.actions.clear
+    @Artist.actions.clear
+
+    artist.remove_all_albums
+    @Album.actions.should == [[:update, {:artist_id=>nil}, "(artist_id = 2)", :s2]]
+    @Album.actions.clear
+    
+    album.remove_all_tags
+    @Album.actions.should == [[:delete, "(album_id = 1)", :s1]]
+  end 
+
+  specify "should not override a server already set on an associated object" do
+    album = @Album.server(:s1).first
+    artist = @Artist.server(:s2).first
+    @Album.actions.clear
+    @Artist.actions.clear
+
+    artist.add_album(@Album.load(:id=>4, :name=>'MO').set_server(:s3))
+    @Album.actions.should == [[:update, {:name=>"MO", :artist_id=>2}, "(id = 4)", :s3]]
+    @Album.actions.clear
+
+    artist.remove_album(@Album.load(:id=>5, :name=>'T', :artist_id=>2).set_server(:s4))
+    # Should select from current object's shard to check existing association, but update associated object's shard
+    @Album.actions.should == [[:fetch, "((albums.artist_id = 2) AND (id = 5))", :s2], [:update, {:name=>"T", :artist_id=>nil}, "(id = 5)", :s4]]
+    @Album.actions.clear
+  end 
+
+  specify "should be able to set a shard to use for any object using set_server" do
+    @Album.server(:s1).first.set_server(:s2).reload
+    @Album.actions.should == [[:fetch, nil, :s1], [:fetch, "(id = 1)", :s2]]
+  end 
+
+  specify "should use transactions on the correct shard" do
+    @Album.use_transactions = true
+    @Album.server(:s2).first.save
+    @Album.actions.should == [[:fetch, nil, :s2], [:update, {:name=>"RF", :artist_id=>2}, "(id = 1)", :s2]]
+    @db.actions.should == [[:transaction, :s2]]
+  end 
+
+  specify "should use not override shard given when saving" do
+    @Album.use_transactions = true
+    @Album.server(:s2).first.save(:server=>:s1)
+    @Album.actions.should == [[:fetch, nil, :s2], [:update, {:name=>"RF", :artist_id=>2}, "(id = 1)", :s2]]
+    @db.actions.should == [[:transaction, :s1]]
+  end 
+end

data/spec/extensions/single_table_inheritance_spec.rb

@@ -41,8 +41,8 @@ describe Sequel::Model, "#sti_key" do
     end 
     StiTest.all.collect{|x| x.class}.should == [StiTest, StiTestSub1, StiTestSub2]
     StiTest.dataset.sql.should == "SELECT * FROM sti_tests"
-    StiTestSub1.dataset.sql.should == "SELECT * FROM sti_tests WHERE (sti_tests.blah = 'StiTestSub1')"
-    StiTestSub2.dataset.sql.should == "SELECT * FROM sti_tests WHERE (sti_tests.blah = 'StiTestSub2')"
+    StiTestSub1.dataset.sql.should == "SELECT * FROM sti_tests WHERE (sti_tests.blah IN ('StiTestSub1'))"
+    StiTestSub2.dataset.sql.should == "SELECT * FROM sti_tests WHERE (sti_tests.blah IN ('StiTestSub2'))"
   end 
   
   it "should return rows with the correct class based on the polymorphic_key value" do
@@ -90,7 +90,95 @@ describe Sequel::Model, "#sti_key" do
 
   it "should add a filter to model datasets inside subclasses hook to only retreive objects with the matching key" do
     StiTest.dataset.sql.should == "SELECT * FROM sti_tests"
-    StiTestSub1.dataset.sql.should == "SELECT * FROM sti_tests WHERE (sti_tests.kind = 'StiTestSub1')"
-    StiTestSub2.dataset.sql.should == "SELECT * FROM sti_tests WHERE (sti_tests.kind = 'StiTestSub2')"
+    StiTestSub1.dataset.sql.should == "SELECT * FROM sti_tests WHERE (sti_tests.kind IN ('StiTestSub1'))"
+    StiTestSub2.dataset.sql.should == "SELECT * FROM sti_tests WHERE (sti_tests.kind IN ('StiTestSub2'))"
+  end
+
+  it "should add a correct filter for multiple levels of subclasses" do
+    class ::StiTestSub1A < StiTestSub1; end
+    StiTestSub1.dataset.sql.should == "SELECT * FROM sti_tests WHERE (sti_tests.kind IN ('StiTestSub1', 'StiTestSub1A'))"
+    StiTestSub1A.dataset.sql.should == "SELECT * FROM sti_tests WHERE (sti_tests.kind IN ('StiTestSub1A'))"
+    class ::StiTestSub2A < StiTestSub2; end
+    StiTestSub2.dataset.sql.should == "SELECT * FROM sti_tests WHERE (sti_tests.kind IN ('StiTestSub2', 'StiTestSub2A'))"
+    StiTestSub2A.dataset.sql.should == "SELECT * FROM sti_tests WHERE (sti_tests.kind IN ('StiTestSub2A'))"
+    class ::StiTestSub1B < StiTestSub1A; end
+    StiTestSub1.dataset.sql.should == "SELECT * FROM sti_tests WHERE (sti_tests.kind IN ('StiTestSub1', 'StiTestSub1A', 'StiTestSub1B'))"
+    StiTestSub1A.dataset.sql.should == "SELECT * FROM sti_tests WHERE (sti_tests.kind IN ('StiTestSub1A', 'StiTestSub1B'))"
+    StiTestSub1B.dataset.sql.should == "SELECT * FROM sti_tests WHERE (sti_tests.kind IN ('StiTestSub1B'))"
+  end
+
+  context "with custom options" do
+    before do
+      class ::StiTest2 < Sequel::Model
+        columns :id, :kind
+        def _refresh(x); end
+      end
+    end
+    after do
+      Object.send(:remove_const, :StiTest2)
+      Object.send(:remove_const, :StiTest3)
+      Object.send(:remove_const, :StiTest4)
+    end
+
+    it "should work with custom procs with strings" do
+      StiTest2.plugin :single_table_inheritance, :kind, :model_map=>proc{|v| v == 1 ? 'StiTest3' : 'StiTest4'}, :key_map=>proc{|klass| klass.name == 'StiTest3' ? 1 : 2}
+      class ::StiTest3 < ::StiTest2; end
+      class ::StiTest4 < ::StiTest2; end
+      StiTest2.dataset.row_proc.call(:kind=>0).should be_a_instance_of(StiTest4)
+      StiTest2.dataset.row_proc.call(:kind=>1).should be_a_instance_of(StiTest3)
+      StiTest2.dataset.row_proc.call(:kind=>2).should be_a_instance_of(StiTest4)
+
+      StiTest2.create.kind.should == 2
+      StiTest3.create.kind.should == 1
+      StiTest4.create.kind.should == 2
+    end
+
+    it "should work with custom procs with symbols" do
+      StiTest2.plugin :single_table_inheritance, :kind, :model_map=>proc{|v| v == 1 ? :StiTest3 : :StiTest4}, :key_map=>proc{|klass| klass.name == 'StiTest3' ? 1 : 2}
+      class ::StiTest3 < ::StiTest2; end
+      class ::StiTest4 < ::StiTest2; end
+      StiTest2.dataset.row_proc.call(:kind=>0).should be_a_instance_of(StiTest4)
+      StiTest2.dataset.row_proc.call(:kind=>1).should be_a_instance_of(StiTest3)
+      StiTest2.dataset.row_proc.call(:kind=>2).should be_a_instance_of(StiTest4)
+
+      StiTest2.create.kind.should == 2
+      StiTest3.create.kind.should == 1
+      StiTest4.create.kind.should == 2
+    end
+
+    it "should work with custom hashes" do
+      StiTest2.plugin :single_table_inheritance, :kind, :model_map=>{0=>StiTest2, 1=>:StiTest3, 2=>'StiTest4'}, :key_map=>{StiTest2=>4, 'StiTest3'=>5, 'StiTest4'=>6}
+      class ::StiTest3 < ::StiTest2; end
+      class ::StiTest4 < ::StiTest2; end
+      StiTest2.dataset.row_proc.call(:kind=>0).should be_a_instance_of(StiTest2)
+      StiTest2.dataset.row_proc.call(:kind=>1).should be_a_instance_of(StiTest3)
+      StiTest2.dataset.row_proc.call(:kind=>2).should be_a_instance_of(StiTest4)
+
+      StiTest2.create.kind.should == 4
+      StiTest3.create.kind.should == 5
+      StiTest4.create.kind.should == 6
+    end
+
+    it "should infer key_map from model_map if provided as a hash" do
+      StiTest2.plugin :single_table_inheritance, :kind, :model_map=>{0=>StiTest2, 1=>'StiTest3', 2=>:StiTest4}
+      class ::StiTest3 < ::StiTest2; end
+      class ::StiTest4 < ::StiTest2; end
+      StiTest2.dataset.row_proc.call(:kind=>0).should be_a_instance_of(StiTest2)
+      StiTest2.dataset.row_proc.call(:kind=>1).should be_a_instance_of(StiTest3)
+      StiTest2.dataset.row_proc.call(:kind=>2).should be_a_instance_of(StiTest4)
+
+      StiTest2.create.kind.should == 0
+      StiTest3.create.kind.should == 1
+      StiTest4.create.kind.should == 2
+    end
+
+    it "should raise exceptions if a bad model value is used" do
+      StiTest2.plugin :single_table_inheritance, :kind, :model_map=>{0=>1,1=>1.5, 2=>Date.today}
+      class ::StiTest3 < ::StiTest2; end
+      class ::StiTest4 < ::StiTest2; end
+      proc{StiTest2.dataset.row_proc.call(:kind=>0)}.should raise_error(Sequel::Error)
+      proc{StiTest2.dataset.row_proc.call(:kind=>1)}.should raise_error(Sequel::Error)
+      proc{StiTest2.dataset.row_proc.call(:kind=>2)}.should raise_error(Sequel::Error)
+    end
   end
 end