sequel 3.4.0 → 3.5.0

data/spec/adapters/postgres_spec.rb

@@ -137,7 +137,7 @@ context "A PostgreSQL dataset with a timestamp field" do
     @d.delete
   end
 
-  specify "should store milliseconds in time fields" do
+  cspecify "should store milliseconds in time fields", :do do
     t = Time.now
     @d << {:value=>1, :time=>t}
     @d.literal(@d[:value =>'1'][:time]).should == @d.literal(t)
@@ -375,9 +375,8 @@ context "Postgres::Dataset#insert" do
 
   specify "should use INSERT RETURNING if server_version >= 80200" do
     @ds.meta_def(:server_version){80201}
-    @ds.should_receive(:clone).once.with(:server=>:default, :sql=>'INSERT INTO test5 (value) VALUES (10) RETURNING xid').and_return(@ds)
-    @ds.should_receive(:single_value).once
     @ds.insert(:value=>10)
+    @db.sqls.last.should == 'INSERT INTO test5 (value) VALUES (10) RETURNING xid'
   end
 
   specify "should have insert_returning_sql use the RETURNING keyword" do
@@ -390,6 +389,10 @@ context "Postgres::Dataset#insert" do
     @ds.insert_select(:value=>10).should == nil
   end
 
+  specify "should have insert_select return nil if disable_insert_returning is used" do
+    @ds.disable_insert_returning.insert_select(:value=>10).should == nil
+  end
+
   specify "should have insert_select insert the record and return the inserted record if server_version < 80200" do
     @ds.meta_def(:server_version){80201}
     h = @ds.insert_select(:value=>10)

data/spec/adapters/spec_helper.rb

@@ -8,3 +8,24 @@ begin
   require File.join(File.dirname(File.dirname(__FILE__)), 'spec_config.rb')
 rescue LoadError
 end
+
+class Spec::Example::ExampleGroup
+  def self.cspecify(message, *checked, &block)
+    pending = false
+    checked.each do |c|
+      case c
+      when INTEGRATION_DB.class.adapter_scheme
+        pending = c
+      when Proc
+        pending = c if c.first.call(INTEGRATION_DB)
+      when Array
+        pending = c if c.first == INTEGRATION_DB.class.adapter_scheme && c.last == INTEGRATION_DB.call(INTEGRATION_DB)
+      end
+    end
+    if pending
+      specify(message){pending("Not yet working on #{Array(pending).join(', ')}", &block)}
+    else
+      specify(message, &block)
+    end
+  end
+end

data/spec/adapters/sqlite_spec.rb

@@ -68,7 +68,7 @@ context "An SQLite database" do
     proc {@db.temp_store = :invalid}.should raise_error(Sequel::Error)
   end
   
-  specify "should support timestamps and datetimes and respect datetime_class" do
+  cspecify "should support timestamps and datetimes and respect datetime_class", :do, :jdbc, :amalgalite do
     @db.create_table!(:time){timestamp :t; datetime :d}
     t1 = Time.at(1)
     @db[:time] << {:t => t1, :d => t1.to_i}

data/spec/core/connection_pool_spec.rb

@@ -85,7 +85,7 @@ context "A connection pool handling connections" do
   end
 
   specify "#make_new should not make more than max_size connections" do
-    50.times{Thread.new{@cpool.hold{sleep 0.01}}}
+    50.times{Thread.new{@cpool.hold{sleep 0.001}}}
     @cpool.created_count.should == @max_size
   end
 

data/spec/core/database_spec.rb

@@ -1251,6 +1251,7 @@ context "Database#typecast_value" do
   before do
     @db = Sequel::Database.new
   end
+
   specify "should raise an InvalidValue when given an invalid value" do
     proc{@db.typecast_value(:integer, "13a")}.should raise_error(Sequel::InvalidValue)
     proc{@db.typecast_value(:float, "4.e2")}.should raise_error(Sequel::InvalidValue)
@@ -1260,6 +1261,24 @@ context "Database#typecast_value" do
     proc{@db.typecast_value(:time, Date.new)}.should raise_error(Sequel::InvalidValue)
     proc{@db.typecast_value(:datetime, 4)}.should raise_error(Sequel::InvalidValue)
   end
+
+  specify "should have an underlying exception class available at wrapped_exception" do
+    begin
+      @db.typecast_value(:date, 'a')
+      true.should == false
+    rescue Sequel::InvalidValue => e
+      e.wrapped_exception.should be_a_kind_of(ArgumentError)
+    end
+  end
+
+  specify "should include underlying exception class in #inspect" do
+    begin
+      @db.typecast_value(:date, 'a')
+      true.should == false
+    rescue Sequel::InvalidValue => e
+      e.inspect.should =~ /\A#<Sequel::InvalidValue: ArgumentError: .*>\z/
+    end
+  end
 end
 
 context "Database#blank_object?" do
@@ -1383,5 +1402,12 @@ context "Database#column_schema_to_ruby_default" do
     p["10:20:30", :time].should == Time.parse('10:20:30')
     p["CURRENT_DATE", :date].should == nil
     p["CURRENT_TIMESTAMP", :datetime].should == nil
+    p["a", :enum].should == "a"
+    
+    db.meta_def(:database_type){:mssql}
+    p["(N'a')", :string].should == "a"
+    p["((-12))", :integer].should == -12
+    p["((12.1))", :float].should == 12.1
+    p["((-12.1))", :decimal].should == BigDecimal.new('-12.1')
   end
-end
+end

data/spec/core/dataset_spec.rb

@@ -211,7 +211,7 @@ context "A simple dataset" do
   specify "should format an insert statement with sub-query" do
     @sub = Sequel::Dataset.new(nil).from(:something).filter(:x => 2)
     @dataset.insert_sql(@sub).should == \
-      "INSERT INTO test (SELECT * FROM something WHERE (x = 2))"
+      "INSERT INTO test SELECT * FROM something WHERE (x = 2)"
   end
   
   specify "should format an insert statement with array" do
@@ -2586,6 +2586,56 @@ context "Dataset#insert_sql" do
   specify "should raise an Error if the dataset has no sources" do
     proc{Sequel::Database.new.dataset.insert_sql}.should raise_error(Sequel::Error)
   end
+  
+  specify "should accept datasets" do
+    @ds.insert_sql(@ds).should == "INSERT INTO items SELECT * FROM items"
+  end
+  
+  specify "should accept datasets with columns" do
+    @ds.insert_sql([:a, :b], @ds).should == "INSERT INTO items (a, b) SELECT * FROM items"
+  end
+  
+  specify "should raise if given bad values" do
+    proc{@ds.clone(:values=>'a').send(:_insert_sql)}.should raise_error(Sequel::Error)
+  end
+  
+  specify "should accept separate values" do
+    @ds.insert_sql(1).should == "INSERT INTO items VALUES (1)"
+    @ds.insert_sql(1, 2).should == "INSERT INTO items VALUES (1, 2)"
+    @ds.insert_sql(1, 2, 3).should == "INSERT INTO items VALUES (1, 2, 3)"
+  end
+  
+  specify "should accept a single array of values" do
+    @ds.insert_sql([1, 2, 3]).should == "INSERT INTO items VALUES (1, 2, 3)"
+  end
+  
+  specify "should accept an array of columns and an array of values" do
+    @ds.insert_sql([:a, :b, :c], [1, 2, 3]).should == "INSERT INTO items (a, b, c) VALUES (1, 2, 3)"
+  end
+  
+  specify "should raise an array if the columns and values differ in size" do
+    proc{@ds.insert_sql([:a, :b], [1, 2, 3])}.should raise_error(Sequel::Error)
+  end
+  
+  specify "should accept a single LiteralString" do
+    @ds.insert_sql('VALUES (1, 2, 3)'.lit).should == "INSERT INTO items VALUES (1, 2, 3)"
+  end
+  
+  specify "should accept an array of columns and an LiteralString" do
+    @ds.insert_sql([:a, :b, :c], 'VALUES (1, 2, 3)'.lit).should == "INSERT INTO items (a, b, c) VALUES (1, 2, 3)"
+  end
+  
+  specify "should accept an object that responds to values and returns a hash by using that hash as the columns and values" do
+    o = Object.new
+    def o.values; {:c=>'d'}; end
+    @ds.insert_sql(o).should == "INSERT INTO items (c) VALUES ('d')"
+  end
+  
+  specify "should accept an object that responds to values and returns something other than a hash by using the object itself as a single value" do
+    o = Date.civil(2000, 1, 1)
+    def o.values; self; end
+    @ds.insert_sql(o).should == "INSERT INTO items VALUES ('2000-01-01')"
+  end
 end
 
 class DummyMummyDataset < Sequel::Dataset
@@ -3219,7 +3269,19 @@ describe "Sequel timezone support" do
   specify "should raise an error when attempting to typecast to a timestamp from an unsupported type" do
     proc{Sequel.database_to_application_timestamp(Object.new)}.should raise_error(Sequel::InvalidValue)
   end
+
+  specify "should raise an InvalidValue error when the DateTime class is used and when a bad application timezone is used when attempting to convert timestamps" do
+    Sequel.application_timezone = :blah
+    Sequel.datetime_class = DateTime
+    proc{Sequel.database_to_application_timestamp('2009-06-01 10:20:30')}.should raise_error(Sequel::InvalidValue)
+  end
   
+  specify "should raise an InvalidValue error when the DateTime class is used and when a bad database timezone is used when attempting to convert timestamps" do
+    Sequel.database_timezone = :blah
+    Sequel.datetime_class = DateTime
+    proc{Sequel.database_to_application_timestamp('2009-06-01 10:20:30')}.should raise_error(Sequel::InvalidValue)
+  end
+
   specify "should have Sequel.default_timezone= should set all other timezones" do
     Sequel.database_timezone.should == nil
     Sequel.application_timezone.should == nil

data/spec/core/object_graph_spec.rb

@@ -41,7 +41,7 @@ describe Sequel::Dataset, " graphing" do
     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)'
+    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 (SELECT * FROM points) AS t1, (SELECT * FROM graphs) AS t2) AS t1 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

data/spec/core/schema_spec.rb

@@ -825,5 +825,6 @@ context "Schema Parser" do
     @db.schema(:smallmoney).first.last[:type].should == :decimal
     @db.schema(:binary).first.last[:type].should == :blob
     @db.schema(:varbinary).first.last[:type].should == :blob
+    @db.schema(:enum).first.last[:type].should == :enum
   end
 end

data/spec/extensions/active_model_spec.rb

@@ -0,0 +1,47 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+if (begin
+  require 'active_model'
+  true
+  rescue LoadError
+  end)
+describe "ActiveModel plugin" do
+  before do
+    @c = Class.new(Sequel::Model) do
+      def delete; end
+    end
+    @c.plugin :active_model
+    @m = @c.new
+    @o = @c.load({})
+  end
+
+  specify "should be compliant to the ActiveModel spec" do
+    s = ''
+    IO.popen('-') do |f|
+      if f
+        s = f.read
+      else
+        ActiveModel::Lint.test(@m)
+      end
+    end
+    s.should =~ /0 failures, 0 errors/
+  end
+  
+  specify "to_model should return self" do
+    @m.to_model.object_id.should == @m.object_id
+  end
+  
+  specify "new_record? should be aliased to new" do
+    @m.new_record?.should == true
+    @o.new_record?.should == false
+  end
+  
+  specify "new_record? should be aliased to new" do
+    @m.destroyed?.should == false
+    @o.destroyed?.should == false
+    @m.destroy
+    @o.destroy
+    @m.destroyed?.should == true
+    @o.destroyed?.should == true
+  end
+end 
+end

data/spec/extensions/association_dependencies_spec.rb

@@ -0,0 +1,108 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe "AssociationDependencies plugin" do
+  before do
+    mods = @mods = []
+    @c = Class.new(Sequel::Model)
+    @c.plugin :association_dependencies
+    @Artist = Class.new(@c).set_dataset(:artists)
+    ds1 = @Artist.dataset
+    def ds1.fetch_rows(s)
+      (MODEL_DB.sqls ||= []) << s
+      yield({:id=>2, :name=>'Ar'})
+    end
+    @Album = Class.new(@c).set_dataset(:albums)
+    ds1 = @Album.dataset
+    def ds1.fetch_rows(s)
+      (MODEL_DB.sqls ||= []) << s
+      yield({:id=>1, :name=>'Al', :artist_id=>2})
+    end
+    @Artist.columns :id, :name
+    @Album.columns :id, :name, :artist_id
+    @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id
+    @Artist.many_to_many :other_artists, :class=>@artist, :join_table=>:aoa, :left_key=>:l, :right_key=>:r
+    @Album.many_to_one :artist, :class=>@Artist
+    MODEL_DB.reset
+  end
+
+  specify "should allow destroying associated many_to_one associated object" do
+    @Album.add_association_dependencies :artist=>:destroy
+    @Album.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
+    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE (id = 1)', 'SELECT * FROM artists WHERE (artists.id = 2)', 'DELETE FROM artists WHERE (id = 2)']
+  end
+
+  specify "should allow deleting associated many_to_one associated object" do
+    @Album.add_association_dependencies :artist=>:delete
+    @Album.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
+    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE (id = 1)', 'DELETE FROM artists WHERE (artists.id = 2)']
+  end
+
+  specify "should allow destroying associated one_to_many objects" do
+    @Artist.add_association_dependencies :albums=>:destroy
+    @Artist.load(:id=>2, :name=>'Ar').destroy
+    MODEL_DB.sqls.should == ['SELECT * FROM albums WHERE (albums.artist_id = 2)', 'DELETE FROM albums WHERE (id = 1)', 'DELETE FROM artists WHERE (id = 2)']
+  end
+
+  specify "should allow deleting associated one_to_many objects" do
+    @Artist.add_association_dependencies :albums=>:delete
+    @Artist.load(:id=>2, :name=>'Ar').destroy
+    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE (albums.artist_id = 2)', 'DELETE FROM artists WHERE (id = 2)']
+  end
+
+  specify "should allow nullifying associated one_to_many objects" do
+    @Artist.add_association_dependencies :albums=>:nullify
+    @Artist.load(:id=>2, :name=>'Ar').destroy
+    MODEL_DB.sqls.should == ['UPDATE albums SET artist_id = NULL WHERE (artist_id = 2)', 'DELETE FROM artists WHERE (id = 2)']
+  end
+
+  specify "should allow nullifying associated many_to_many associations" do
+    @Artist.add_association_dependencies :other_artists=>:nullify
+    @Artist.load(:id=>2, :name=>'Ar').destroy
+    MODEL_DB.sqls.should == ['DELETE FROM aoa WHERE (l = 2)', 'DELETE FROM artists WHERE (id = 2)']
+  end
+
+  specify "should raise an error if attempting to nullify a many_to_one association" do
+    proc{@Album.add_association_dependencies :artist=>:nullify}.should raise_error(Sequel::Error)
+  end
+
+  specify "should raise an error if using an unrecognized dependence action" do
+    proc{@Album.add_association_dependencies :artist=>:blah}.should raise_error(Sequel::Error)
+  end
+
+  specify "should raise an error if a nonexistent association is used" do
+    proc{@Album.add_association_dependencies :blah=>:delete}.should raise_error(Sequel::Error)
+  end
+
+  specify "should raise an error if a invalid association type is used" do
+    @Artist.plugin :many_through_many
+    @Artist.many_through_many :other_albums, [[:id, :id, :id]]
+    proc{@Artist.add_association_dependencies :other_albums=>:nullify}.should raise_error(Sequel::Error)
+  end
+
+  specify "should raise an error if using a many_to_many association type without nullify" do
+    proc{@Artist.add_association_dependencies :other_artists=>:delete}.should raise_error(Sequel::Error)
+  end
+
+  specify "should allow specifying association dependencies in the plugin call" do
+    @Album.plugin :association_dependencies, :artist=>:destroy
+    @Album.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
+    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE (id = 1)', 'SELECT * FROM artists WHERE (artists.id = 2)', 'DELETE FROM artists WHERE (id = 2)']
+  end
+
+  specify "should work with subclasses" do
+    c = Class.new(@Album)
+    c.add_association_dependencies :artist=>:destroy
+    c.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
+    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE (id = 1)', 'SELECT * FROM artists WHERE (artists.id = 2)', 'DELETE FROM artists WHERE (id = 2)']
+    MODEL_DB.reset
+
+    @Album.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
+    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE (id = 1)']
+    MODEL_DB.reset
+
+    @Album.add_association_dependencies :artist=>:destroy
+    c2 = Class.new(@Album)
+    c2.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
+    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE (id = 1)', 'SELECT * FROM artists WHERE (artists.id = 2)', 'DELETE FROM artists WHERE (id = 2)']
+  end
+end

data/spec/extensions/class_table_inheritance_spec.rb

@@ -0,0 +1,252 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe "class_table_inheritance plugin" do
+  before do
+    @db = db = MODEL_DB.clone
+    def db.schema(table, opts={})
+      {:employees=>[[:id, {:primary_key=>true, :type=>:integer}], [:name, {:type=>:string}], [:kind, {:type=>:string}]],
+       :managers=>[[:id, {:type=>:integer}], [:num_staff, {:type=>:integer}]],
+       :executives=>[[:id, {:type=>:integer}], [:num_managers, {:type=>:integer}]],
+       :staff=>[[:id, {:type=>:integer}], [:manager_id, {:type=>:integer}]],
+       }[table]
+     end
+    def db.dataset(*args)
+      ds = super(*args)
+      def ds.columns
+        {[:employees]=>[:id, :name, :kind],
+         [:managers]=>[:id, :num_staff],
+         [:executives]=>[:id, :num_managers],
+         [:staff]=>[:id, :manager_id],
+         [:employees, :managers]=>[:id, :name, :kind, :num_staff],
+         [:employees, :managers, :executives]=>[:id, :name, :kind, :num_staff, :num_managers],
+         [:employees, :staff]=>[:id, :name, :kind, :manager_id],
+        }[opts[:from] + (opts[:join] || []).map{|x| x.table}]
+      end
+      def ds.insert(*args)
+        db << insert_sql(*args)
+        1
+      end
+      ds
+    end
+    class ::Employee < Sequel::Model(db)
+      def _refresh(x); @values[:id] = 1 end
+      def self.columns
+        dataset.columns
+      end
+      plugin :class_table_inheritance, :key=>:kind, :table_map=>{:Staff=>:staff}
+    end 
+    class ::Manager < Employee
+      one_to_many :staff_members, :class=>:Staff
+    end 
+    class ::Executive < Manager
+    end 
+    class ::Staff < Employee
+      many_to_one :manager
+    end 
+    @ds = Employee.dataset
+    @db.reset
+  end
+  after do
+    Object.send(:remove_const, :Executive)
+    Object.send(:remove_const, :Manager)
+    Object.send(:remove_const, :Staff)
+    Object.send(:remove_const, :Employee)
+  end
+
+  specify "should have simple_table = nil" do
+    Employee.simple_table.should == nil
+    Manager.simple_table.should == nil
+    Executive.simple_table.should == nil
+    Staff.simple_table.should == nil
+  end
+  
+  specify "should use a joined dataset in subclasses" do
+    Employee.dataset.sql.should == 'SELECT * FROM employees'
+    Manager.dataset.sql.should == 'SELECT * FROM employees INNER JOIN managers USING (id)'
+    Executive.dataset.sql.should == 'SELECT * FROM employees INNER JOIN managers USING (id) INNER JOIN executives USING (id)'
+    Staff.dataset.sql.should == 'SELECT * FROM employees INNER JOIN staff USING (id)'
+  end
+  
+  it "should return rows with the correct class based on the polymorphic_key value" do
+    def @ds.fetch_rows(sql)
+      yield({:kind=>'Employee'})
+      yield({:kind=>'Manager'})
+      yield({:kind=>'Executive'})
+      yield({:kind=>'Staff'})
+    end 
+    Employee.all.collect{|x| x.class}.should == [Employee, Manager, Executive, Staff]
+  end 
+  
+  it "should return rows with the correct class based on the polymorphic_key value for subclasses" do
+    ds = Manager.dataset
+    def ds.fetch_rows(sql)
+      yield({:kind=>'Manager'})
+      yield({:kind=>'Executive'})
+    end 
+    Manager.all.collect{|x| x.class}.should == [Manager, Executive]
+  end
+  
+  it "should return rows with the current class if cti_key is nil" do
+    Employee.plugin(:class_table_inheritance)
+    def @ds.fetch_rows(sql)
+      yield({:kind=>'Employee'})
+      yield({:kind=>'Manager'})
+      yield({:kind=>'Executive'})
+      yield({:kind=>'Staff'})
+    end 
+    Employee.all.collect{|x| x.class}.should == [Employee, Employee, Employee, Employee]
+  end
+  
+  it "should return rows with the current class if cti_key is nil in subclasses" do
+    Employee.plugin(:class_table_inheritance)
+    Object.send(:remove_const, :Executive)
+    Object.send(:remove_const, :Manager)
+    class ::Manager < Employee
+    end 
+    class ::Executive < Manager
+    end 
+    ds = Manager.dataset
+    def ds.fetch_rows(sql)
+      yield({:kind=>'Manager'})
+      yield({:kind=>'Executive'})
+    end 
+    Manager.all.collect{|x| x.class}.should == [Manager, Manager]
+  end
+  
+  it "should fallback to the main class if the given class does not exist" do
+    def @ds.fetch_rows(sql)
+      yield({:kind=>'Employee'})
+      yield({:kind=>'Manager'})
+      yield({:kind=>'Blah'})
+      yield({:kind=>'Staff'})
+    end 
+    Employee.all.collect{|x| x.class}.should == [Employee, Manager, Employee, Staff]
+  end
+  
+  it "should fallback to the main class if the given class does not exist in subclasses" do
+    ds = Manager.dataset
+    def ds.fetch_rows(sql)
+      yield({:kind=>'Manager'})
+      yield({:kind=>'Executive'})
+      yield({:kind=>'Blah'})
+    end 
+    Manager.all.collect{|x| x.class}.should == [Manager, Executive, Manager]
+  end
+
+  it "should add a before_create hook that sets the model class name for the key" do
+    Employee.create
+    @db.sqls.should == ["INSERT INTO employees (kind) VALUES ('Employee')"]
+  end
+  
+  it "should add a before_create hook that sets the model class name for the key in subclasses" do
+    Executive.create
+    @db.sqls.should == ["INSERT INTO employees (kind) VALUES ('Executive')",
+      "INSERT INTO managers (id) VALUES (1)",
+      "INSERT INTO executives (id) VALUES (1)"]
+  end
+
+  it "should ignore existing cti_key value" do
+    Employee.create(:kind=>'Manager')
+    @db.sqls.should == ["INSERT INTO employees (kind) VALUES ('Employee')"]
+  end
+    
+  it "should ignore existing cti_key value in subclasses" do
+    Manager.create(:kind=>'Executive')
+    @db.sqls.should == ["INSERT INTO employees (kind) VALUES ('Manager')",
+      "INSERT INTO managers (id) VALUES (1)"]
+  end
+
+  it "should raise an error if attempting to create an anonymous subclass" do
+    proc{Class.new(Manager)}.should raise_error(Sequel::Error)
+  end
+
+  it "should allow specifying a map of names to tables to override implicit mapping" do
+    Manager.dataset.sql.should == 'SELECT * FROM employees INNER JOIN managers USING (id)'
+    Staff.dataset.sql.should == 'SELECT * FROM employees INNER JOIN staff USING (id)'
+  end
+
+  it "should lazily load attributes for columns in subclass tables" do
+    ds = Manager.dataset
+    def ds.fetch_rows(sql)
+      @db << sql
+      yield({:id=>1, :name=>'J', :kind=>'Executive', :num_staff=>2})
+    end
+    m = Manager[1]
+    @db.sqls.should == ['SELECT * FROM employees INNER JOIN managers USING (id) WHERE (id = 1) LIMIT 1']
+    @db.reset
+    ds = Executive.dataset
+    def ds.fetch_rows(sql)
+      @db << sql
+      yield({:num_managers=>3})
+    end
+    m.num_managers.should == 3
+    @db.sqls.should == ['SELECT num_managers FROM employees INNER JOIN managers USING (id) INNER JOIN executives USING (id) WHERE (id = 1) LIMIT 1']
+    m.values.should == {:id=>1, :name=>'J', :kind=>'Executive', :num_staff=>2, :num_managers=>3}
+  end
+
+  it "should include schema for columns for tables for ancestor classes" do
+    Employee.db_schema.should == {:id=>{:primary_key=>true, :type=>:integer}, :name=>{:type=>:string}, :kind=>{:type=>:string}}
+    Manager.db_schema.should == {:id=>{:primary_key=>true, :type=>:integer}, :name=>{:type=>:string}, :kind=>{:type=>:string}, :num_staff=>{:type=>:integer}}
+    Executive.db_schema.should == {:id=>{:primary_key=>true, :type=>:integer}, :name=>{:type=>:string}, :kind=>{:type=>:string}, :num_staff=>{:type=>:integer}, :num_managers=>{:type=>:integer}}
+    Staff.db_schema.should == {:id=>{:primary_key=>true, :type=>:integer}, :name=>{:type=>:string}, :kind=>{:type=>:string}, :manager_id=>{:type=>:integer}}
+  end
+
+  it "should use the correct primary key (which should have the same name in all subclasses)" do
+    [Employee, Manager, Executive, Staff].each{|c| c.primary_key.should == :id}
+  end
+
+  it "should have table_name return the table name of the most specific table" do
+    Employee.table_name.should == :employees
+    Manager.table_name.should == :managers
+    Executive.table_name.should == :executives
+    Staff.table_name.should == :staff
+  end
+
+  it "should delete the correct rows from all tables when deleting" do
+    Executive.load(:id=>1).delete
+    @db.sqls.should == ["DELETE FROM executives WHERE (id = 1)", "DELETE FROM managers WHERE (id = 1)", "DELETE FROM employees WHERE (id = 1)"]
+  end
+
+  it "should insert the correct rows into all tables when inserting" do
+    Executive.create(:num_managers=>3, :num_staff=>2, :name=>'E')
+    @db.sqls.length.should == 3
+    @db.sqls[0].should =~ /INSERT INTO employees \((name|kind), (name|kind)\) VALUES \('(E|Executive)', '(E|Executive)'\)/
+    @db.sqls[1].should =~ /INSERT INTO managers \((num_staff|id), (num_staff|id)\) VALUES \([12], [12]\)/
+    @db.sqls[2].should =~ /INSERT INTO executives \((num_managers|id), (num_managers|id)\) VALUES \([13], [13]\)/
+    end
+    
+  it "should insert the correct rows into all tables with a given primary key" do
+    e = Executive.new(:num_managers=>3, :num_staff=>2, :name=>'E')
+    e.id = 2
+    e.save
+    @db.sqls.length.should == 3
+    @db.sqls[0].should =~ /INSERT INTO employees \((name|kind|id), (name|kind|id), (name|kind|id)\) VALUES \(('E'|'Executive'|2), ('E'|'Executive'|2), ('E'|'Executive'|2)\)/
+    @db.sqls[1].should =~ /INSERT INTO managers \((num_staff|id), (num_staff|id)\) VALUES \(2, 2\)/
+    @db.sqls[2].should =~ /INSERT INTO executives \((num_managers|id), (num_managers|id)\) VALUES \([23], [23]\)/
+  end
+
+  it "should update the correct rows in all tables when updating" do
+    Executive.load(:id=>2).update(:num_managers=>3, :num_staff=>2, :name=>'E')
+    @db.sqls.should == ["UPDATE employees SET name = 'E' WHERE (id = 2)", "UPDATE managers SET num_staff = 2 WHERE (id = 2)", "UPDATE executives SET num_managers = 3 WHERE (id = 2)"]
+  end
+
+  it "should handle many_to_one relationships correctly" do
+    ds = Manager.dataset
+    def ds.fetch_rows(sql)
+      @db << sql
+      yield({:id=>3, :name=>'E', :kind=>'Executive', :num_managers=>3})
+    end
+    Staff.load(:manager_id=>3).manager.should == Executive.load(:id=>3, :name=>'E', :kind=>'Executive', :num_managers=>3)
+    @db.sqls.should == ['SELECT * FROM employees INNER JOIN managers USING (id) WHERE (managers.id = 3) LIMIT 1']
+  end
+  
+  it "should handle one_to_many relationships correctly" do
+    ds = Staff.dataset
+    def ds.fetch_rows(sql)
+      @db << sql
+      yield({:id=>1, :name=>'S', :kind=>'Staff', :manager_id=>3})
+    end
+    Executive.load(:id=>3).staff_members.should == [Staff.load(:id=>1, :name=>'S', :kind=>'Staff', :manager_id=>3)]
+    @db.sqls.should == ['SELECT * FROM employees INNER JOIN staff USING (id) WHERE (staff.manager_id = 3)']
+  end
+end