sequel 3.4.0 → 3.5.0

data/spec/extensions/subclasses_spec.rb

@@ -0,0 +1,52 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe Sequel::Model, "Subclasses plugin" do
+  before do
+    @c = Class.new(Sequel::Model)
+    @c.plugin :subclasses
+  end
+
+  specify "#subclasses should record direct subclasses of the given model" do
+    @c.subclasses.should == []
+
+    sc1 = Class.new(@c)
+    @c.subclasses.should == [sc1]
+    sc1.subclasses.should == []
+
+    sc2 = Class.new(@c)
+    @c.subclasses.should == [sc1, sc2]
+    sc1.subclasses.should == []
+    sc2.subclasses.should == []
+
+    ssc1 = Class.new(sc1)
+    @c.subclasses.should == [sc1, sc2]
+    sc1.subclasses.should == [ssc1]
+    sc2.subclasses.should == []
+  end
+
+  specify "#descendents should record all descendent subclasses of the given model" do
+    @c.descendents.should == []
+
+    sc1 = Class.new(@c)
+    @c.descendents.should == [sc1]
+    sc1.descendents.should == []
+
+    sc2 = Class.new(@c)
+    @c.descendents.should == [sc1, sc2]
+    sc1.descendents.should == []
+    sc2.descendents.should == []
+
+    ssc1 = Class.new(sc1)
+    @c.descendents.should == [sc1, ssc1, sc2]
+    sc1.descendents.should == [ssc1]
+    sc2.descendents.should == []
+    ssc1.descendents.should == []
+
+    sssc1 = Class.new(ssc1)
+    @c.descendents.should == [sc1, ssc1, sssc1, sc2]
+    sc1.descendents.should == [ssc1, sssc1]
+    sc2.descendents.should == []
+    ssc1.descendents.should == [sssc1]
+    sssc1.descendents.should == []
+  end
+end

data/spec/extensions/thread_local_timezones_spec.rb

@@ -0,0 +1,45 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe "Sequel thread_local_timezones extension" do
+  after do
+    Sequel.default_timezone = nil
+    Sequel.thread_application_timezone = nil
+    Sequel.thread_database_timezone = nil
+    Sequel.thread_typecast_timezone = nil
+  end
+  
+  it "should allow specifying thread local timezones via thread_*_timezone=" do
+    proc{Sequel.thread_application_timezone = :local}.should_not raise_error
+    proc{Sequel.thread_database_timezone = :utc}.should_not raise_error
+    proc{Sequel.thread_typecast_timezone = nil}.should_not raise_error
+  end
+    
+  it "should use thread local timezone if available" do
+    Sequel.thread_application_timezone = :local
+    Sequel.application_timezone.should == :local
+    Sequel.thread_database_timezone = :utc
+    Sequel.database_timezone.should == :utc
+    Sequel.thread_typecast_timezone = nil
+    Sequel.typecast_timezone.should == nil
+  end
+  
+  it "should fallback to default timezone if no thread_local timezone" do
+    Sequel.default_timezone = :utc
+    Sequel.application_timezone.should == :utc
+    Sequel.database_timezone.should == :utc
+    Sequel.typecast_timezone.should == :utc
+  end
+  
+  it "should use a nil thread_local_timezone if set instead of falling back to the default timezone if thread_local_timezone is set to :nil" do
+    Sequel.typecast_timezone = :utc
+    Sequel.thread_typecast_timezone = nil
+    Sequel.typecast_timezone.should == :utc
+    Sequel.thread_typecast_timezone = :nil
+    Sequel.typecast_timezone.should == nil
+  end
+    
+  it "should be thread safe" do
+    [Thread.new{Sequel.thread_application_timezone = :utc; sleep 0.03; Sequel.application_timezone.should == :utc},
+     Thread.new{sleep 0.01; Sequel.thread_application_timezone = :local; sleep 0.01; Sequel.application_timezone.should == :local}].each{|x| x.join}
+  end
+end

data/spec/extensions/touch_spec.rb

@@ -0,0 +1,155 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe "Touch plugin" do
+  before do
+    @c = Class.new(Sequel::Model) do
+      def _refresh(*); end 
+    end
+    p = proc{def touch_instance_value; touch_association_value; end}
+    @Artist = Class.new(@c, &p).set_dataset(:artists)
+    @Album = Class.new(@c, &p).set_dataset(:albums)
+
+    @Artist.columns :id, :updated_at, :modified_on
+    @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id
+
+    @Album.columns :id, :updated_at, :modified_on, :artist_id, :original_album_id
+    @Album.one_to_many :followup_albums, :class=>@Album, :key=>:original_album_id
+    @Album.many_to_one :artist, :class=>@Artist
+
+    @a = @Artist.load(:id=>1)
+    MODEL_DB.reset
+  end
+
+  specify "should default to using Time.now when setting the column values for model instances" do
+    c = Class.new(Sequel::Model).set_dataset(:a)
+    c.plugin :touch
+    c.columns :id, :updated_at
+    c.load(:id=>1).touch
+    MODEL_DB.sqls.first.should =~ /UPDATE a SET updated_at = '[-0-9 :.]+' WHERE \(id = 1\)/
+  end
+
+  specify "should allow #touch instance method for updating the updated_at column" do
+    @Artist.plugin :touch
+    @a.touch
+    MODEL_DB.sqls.should == ["UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)"]
+  end
+
+  specify "should have #touch take an argument for the column to touch" do
+    @Artist.plugin :touch
+    @a.touch(:modified_on)
+    MODEL_DB.sqls.should == ["UPDATE artists SET modified_on = CURRENT_TIMESTAMP WHERE (id = 1)"]
+  end
+
+  specify "should be able to specify the default column to touch in the plugin call using the :column option" do
+    @Artist.plugin :touch, :column=>:modified_on
+    @a.touch
+    MODEL_DB.sqls.should == ["UPDATE artists SET modified_on = CURRENT_TIMESTAMP WHERE (id = 1)"]
+  end
+
+  specify "should be able to specify the default column to touch using the touch_column model accessor" do
+    @Artist.plugin :touch
+    @Artist.touch_column = :modified_on
+    @a.touch
+    MODEL_DB.sqls.should == ["UPDATE artists SET modified_on = CURRENT_TIMESTAMP WHERE (id = 1)"]
+  end
+
+  specify "should be able to specify the associations to touch in the plugin call using the :associations option" do
+    @Artist.plugin :touch, :associations=>:albums
+    @a.touch
+    MODEL_DB.sqls.should == ["UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)",
+      "UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (albums.artist_id = 1)"]
+  end
+
+  specify "should be able to give an array to the :associations option specifying multiple associations" do
+    @Album.plugin :touch, :associations=>[:artist, :followup_albums]
+    @Album.load(:id=>4, :artist_id=>1).touch
+    MODEL_DB.sqls.shift.should == "UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (id = 4)"
+    MODEL_DB.sqls.sort.should == ["UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (albums.original_album_id = 4)",
+      "UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (artists.id = 1)"]
+  end
+
+  specify "should be able to give a hash to the :associations option specifying the column to use for each association" do
+    @Artist.plugin :touch, :associations=>{:albums=>:modified_on}
+    @a.touch
+    MODEL_DB.sqls.should == ["UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)",
+      "UPDATE albums SET modified_on = CURRENT_TIMESTAMP WHERE (albums.artist_id = 1)"]
+  end
+
+  specify "should default to using the touch_column as the default touch column for associations" do
+    @Artist.plugin :touch, :column=>:modified_on, :associations=>:albums
+    @a.touch
+    MODEL_DB.sqls.should == ["UPDATE artists SET modified_on = CURRENT_TIMESTAMP WHERE (id = 1)",
+      "UPDATE albums SET modified_on = CURRENT_TIMESTAMP WHERE (albums.artist_id = 1)"]
+  end
+
+  specify "should allow the mixed use of symbols and hashes inside an array for the :associations option" do
+    @Album.plugin :touch, :associations=>[:artist, {:followup_albums=>:modified_on}]
+    @Album.load(:id=>4, :artist_id=>1).touch
+    MODEL_DB.sqls.shift.should == "UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (id = 4)"
+    MODEL_DB.sqls.sort.should == ["UPDATE albums SET modified_on = CURRENT_TIMESTAMP WHERE (albums.original_album_id = 4)",
+      "UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (artists.id = 1)"]
+  end
+
+  specify "should be able to specify the associations to touch via a touch_associations_method" do
+    @Album.plugin :touch
+    @Album.touch_associations(:artist, {:followup_albums=>:modified_on})
+    @Album.load(:id=>4, :artist_id=>1).touch
+    MODEL_DB.sqls.shift.should == "UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (id = 4)"
+    MODEL_DB.sqls.sort.should == ["UPDATE albums SET modified_on = CURRENT_TIMESTAMP WHERE (albums.original_album_id = 4)",
+      "UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (artists.id = 1)"]
+  end
+
+  specify "should touch associated objects when destroying an object" do
+    @Album.plugin :touch
+    @Album.touch_associations(:artist, {:followup_albums=>:modified_on})
+    @Album.load(:id=>4, :artist_id=>1).destroy
+    MODEL_DB.sqls.shift.should == "DELETE FROM albums WHERE (id = 4)"
+    MODEL_DB.sqls.sort.should == ["UPDATE albums SET modified_on = CURRENT_TIMESTAMP WHERE (albums.original_album_id = 4)",
+      "UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (artists.id = 1)"]
+  end
+
+  specify "should not update a column that doesn't exist" do
+    @Album.plugin :touch, :column=>:x
+    a = @Album.load(:id=>1)
+    a.touch
+    MODEL_DB.sqls.should == []
+    a.artist_id = 1
+    a.touch
+    MODEL_DB.sqls.should == ['UPDATE albums SET artist_id = 1 WHERE (id = 1)']
+  end
+
+  specify "should raise an error if given a column argument in touch that doesn't exist" do
+    @Artist.plugin :touch
+    proc{@a.touch(:x)}.should raise_error(Sequel::Error)
+  end
+
+  specify "should raise an Error when a nonexistent association is given" do
+    @Artist.plugin :touch
+    proc{@Artist.plugin :touch, :associations=>:blah}.should raise_error(Sequel::Error)
+  end
+
+  specify "should work correctly in subclasses" do
+    @Artist.plugin :touch
+    c1 = Class.new(@Artist)
+    c1.load(:id=>4).touch
+    MODEL_DB.sqls.should == ["UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (id = 4)"]
+    MODEL_DB.reset
+
+    c1.touch_column = :modified_on
+    c1.touch_associations :albums
+    c1.load(:id=>1).touch
+    MODEL_DB.sqls.should == ["UPDATE artists SET modified_on = CURRENT_TIMESTAMP WHERE (id = 1)",
+      "UPDATE albums SET modified_on = CURRENT_TIMESTAMP WHERE (albums.artist_id = 1)"]
+    MODEL_DB.reset
+
+    @a.touch
+    MODEL_DB.sqls.should == ["UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)"]
+    MODEL_DB.reset
+
+    @Artist.plugin :touch, :column=>:modified_on, :associations=>:albums
+    c2 = Class.new(@Artist)
+    c2.load(:id=>4).touch
+    MODEL_DB.sqls.should == ["UPDATE artists SET modified_on = CURRENT_TIMESTAMP WHERE (id = 4)",
+      "UPDATE albums SET modified_on = CURRENT_TIMESTAMP WHERE (albums.artist_id = 4)"]
+  end
+end

data/spec/extensions/typecast_on_load_spec.rb

@@ -0,0 +1,60 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe Sequel::Model, "TypecastOnLoad plugin" do
+  before do
+    @db = Sequel::Database.new({})
+    def @db.schema(*args)
+      [[:id, {}], [:y, {:type=>:boolean, :db_type=>'tinyint(1)'}], [:b, {:type=>:integer, :db_type=>'integer'}]]
+    end
+    @c = Class.new(Sequel::Model(@db[:items])) do
+      attr_accessor :bset
+      def b=(x)
+        self.bset = true
+        super
+      end
+    end
+    @c.instance_eval do
+      @columns = [:id, :b, :y]
+      def columns; @columns; end
+    end
+  end 
+
+  specify "should call setter method with value when loading the object, for all given columns" do
+    @c.plugin :typecast_on_load, :b
+    o = @c.load(:id=>1, :b=>"1", :y=>"0")
+    o.values.should == {:id=>1, :b=>1, :y=>"0"}
+    o.bset.should == true
+  end
+
+  specify "should allowing setting columns separately via add_typecast_on_load_columns" do
+    @c.plugin :typecast_on_load
+    @c.load(:id=>1, :b=>"1", :y=>"0").values.should == {:id=>1, :b=>"1", :y=>"0"}
+    @c.add_typecast_on_load_columns :b
+    @c.load(:id=>1, :b=>"1", :y=>"0").values.should == {:id=>1, :b=>1, :y=>"0"}
+    @c.add_typecast_on_load_columns :y
+    @c.load(:id=>1, :b=>"1", :y=>"0").values.should == {:id=>1, :b=>1, :y=>false}
+  end
+
+  specify "should work with subclasses" do
+    @c.plugin :typecast_on_load
+    @c.load(:id=>1, :b=>"1", :y=>"0").values.should == {:id=>1, :b=>"1", :y=>"0"}
+
+    c1 = Class.new(@c)
+    @c.add_typecast_on_load_columns :b
+    @c.load(:id=>1, :b=>"1", :y=>"0").values.should == {:id=>1, :b=>1, :y=>"0"}
+    c1.load(:id=>1, :b=>"1", :y=>"0").values.should == {:id=>1, :b=>"1", :y=>"0"}
+
+    c2 = Class.new(@c)
+    @c.add_typecast_on_load_columns :y
+    @c.load(:id=>1, :b=>"1", :y=>"0").values.should == {:id=>1, :b=>1, :y=>false}
+    c2.load(:id=>1, :b=>"1", :y=>"0").values.should == {:id=>1, :b=>1, :y=>"0"}
+    
+    c1.add_typecast_on_load_columns :y
+    c1.load(:id=>1, :b=>"1", :y=>"0").values.should == {:id=>1, :b=>"1", :y=>false}
+  end
+
+  specify "should not mark the object as modified" do
+    @c.plugin :typecast_on_load, :b
+    @c.load(:id=>1, :b=>"1", :y=>"0").modified?.should == false
+  end
+end

data/spec/integration/database_test.rb

@@ -12,6 +12,14 @@ describe Sequel::Database do
     proc{INTEGRATION_DB << "SELECT"}.should raise_error(Sequel::DatabaseError)
   end
 
+  specify "should store underlying wrapped exception in Sequel::DatabaseError" do
+    begin
+      INTEGRATION_DB << "SELECT"
+    rescue Sequel::DatabaseError=>e
+      e.wrapped_exception.should be_a_kind_of(Exception)
+    end
+  end
+
   specify "should not have the connection pool swallow non-StandardError based exceptions" do
     proc{INTEGRATION_DB.pool.hold{raise Interrupt, "test"}}.should raise_error(Interrupt)
   end

data/spec/integration/dataset_test.rb

@@ -23,7 +23,7 @@ describe "Simple Dataset operations" do
       {:id => 3, :number=>30} ]   
   end 
 
-  specify "should insert with a primary key specified" do
+  cspecify "should insert with a primary key specified", :mssql do
     @ds.insert(:id=>100, :number=>20)
     sqls_should_be(/INSERT INTO items \((number, id|id, number)\) VALUES \((100, 20|20, 100)\)/)
     @ds.count.should == 2
@@ -74,7 +74,7 @@ describe "Simple Dataset operations" do
     @ds.order(:id).limit(2, 1).all.should == [{:id=>2, :number=>20}]
   end
   
-  specify "should fetch correctly with a limit and offset without an order" do
+  cspecify "should fetch correctly with a limit and offset without an order", :mssql do
     @ds.limit(2, 1).all.should == []
   end
 
@@ -244,7 +244,7 @@ describe "Simple Dataset operations in transactions" do
     INTEGRATION_DB.drop_table(:items_insert_in_transaction)
   end
 
-  specify "should insert correctly with a primary key specified inside a transaction" do
+  cspecify "should insert correctly with a primary key specified inside a transaction", :mssql do
     INTEGRATION_DB.transaction do
       @ds.insert(:id=>100, :number=>20)
       sqls_should_be('BEGIN', /INSERT INTO items_insert_in_transaction \((number, id|id, number)\) VALUES \((100, 20|20, 100)\)/)
@@ -284,7 +284,7 @@ describe "Dataset UNION, EXCEPT, and INTERSECT" do
     end
   end
   
-  specify "should give the correct results for UNION, EXCEPT, and INTERSECT when used with ordering and limits" do
+  cspecify "should give the correct results for UNION, EXCEPT, and INTERSECT when used with ordering and limits", :mssql do
     @ds1.insert(:number=>8)
     @ds2.insert(:number=>9)
     @ds1.insert(:number=>38)
@@ -400,14 +400,14 @@ if INTEGRATION_DB.dataset.supports_window_functions?
         [{:rank=>1, :id=>1}, {:rank=>2, :id=>2}, {:rank=>3, :id=>3}, {:rank=>4, :id=>4}, {:rank=>5, :id=>5}, {:rank=>6, :id=>6}]
     end
       
-    specify "should give correct results for aggregate window functions with orders" do
+    cspecify "should give correct results for aggregate window functions with orders", :mssql do
       @ds.select(:id){sum(:over, :args=>amount, :partition=>group_id, :order=>id){}.as(:sum)}.all.should ==
         [{:sum=>1, :id=>1}, {:sum=>11, :id=>2}, {:sum=>111, :id=>3}, {:sum=>1000, :id=>4}, {:sum=>11000, :id=>5}, {:sum=>111000, :id=>6}]
       @ds.select(:id){sum(:over, :args=>amount, :order=>id){}.as(:sum)}.all.should ==
         [{:sum=>1, :id=>1}, {:sum=>11, :id=>2}, {:sum=>111, :id=>3}, {:sum=>1111, :id=>4}, {:sum=>11111, :id=>5}, {:sum=>111111, :id=>6}]
     end
     
-    specify "should give correct results for aggregate window functions with frames" do
+    cspecify "should give correct results for aggregate window functions with frames", :mssql do
       @ds.select(:id){sum(:over, :args=>amount, :partition=>group_id, :order=>id, :frame=>:all){}.as(:sum)}.all.should ==
         [{:sum=>111, :id=>1}, {:sum=>111, :id=>2}, {:sum=>111, :id=>3}, {:sum=>111000, :id=>4}, {:sum=>111000, :id=>5}, {:sum=>111000, :id=>6}]
       @ds.select(:id){sum(:over, :args=>amount, :partition=>group_id, :frame=>:all){}.as(:sum)}.all.should ==
@@ -449,19 +449,19 @@ describe Sequel::SQL::Constants do
     @db.drop_table(:constants)
   end
   
-  it "should have working CURRENT_DATE" do
+  cspecify "should have working CURRENT_DATE", [:odbc, :mssql], [:jdbc, :sqlite] do
     @db.create_table!(:constants){Date :d}
     @ds.insert(:d=>Sequel::CURRENT_DATE)
     Date.today.should == @c2[@ds.get(:d)]
   end
 
-  it "should have working CURRENT_TIME" do
+  cspecify "should have working CURRENT_TIME", [:do, :mysql], [:jdbc, :sqlite] do
     @db.create_table!(:constants){Time :t, :only_time=>true}
     @ds.insert(:t=>Sequel::CURRENT_TIME)
     (Time.now - @c[@ds.get(:t)]).should be_close(0, 1)
   end
 
-  it "should have working CURRENT_TIMESTAMP" do
+  cspecify "should have working CURRENT_TIMESTAMP", [:jdbc, :sqlite] do
     @db.create_table!(:constants){DateTime :ts}
     @ds.insert(:ts=>Sequel::CURRENT_TIMESTAMP)
     (Time.now - @c[@ds.get(:ts)]).should be_close(0, 1)

data/spec/integration/plugin_test.rb

@@ -0,0 +1,139 @@
+require File.join(File.dirname(__FILE__), 'spec_helper.rb')
+
+# H2 and MSSQL don't support USING joins
+unless [:h2, :mssql].include?(INTEGRATION_DB.database_type)
+describe "Class Table Inheritance Plugin" do
+  before do
+    @db = INTEGRATION_DB
+    @db.instance_variable_set(:@schemas, {})
+    @db.create_table!(:employees) do
+      primary_key :id
+      String :name
+      String :kind
+    end
+    @db.create_table!(:managers) do
+      foreign_key :id, :employees, :primary_key=>true
+      Integer :num_staff
+    end
+    @db.create_table!(:executives) do
+      foreign_key :id, :managers, :primary_key=>true
+      Integer :num_managers
+    end
+    @db.create_table!(:staff) do
+      foreign_key :id, :employees, :primary_key=>true
+      foreign_key :manager_id, :managers
+    end
+    class ::Employee < Sequel::Model(@db)
+      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 
+    
+    @i1 =@db[:employees].insert(:name=>'E', :kind=>'Employee')
+    @i2 = @db[:employees].insert(:name=>'S', :kind=>'Staff')
+    @i3 = @db[:employees].insert(:name=>'M', :kind=>'Manager')
+    @i4 = @db[:employees].insert(:name=>'Ex', :kind=>'Executive')
+    @db[:managers].insert(:id=>@i3, :num_staff=>7)
+    @db[:managers].insert(:id=>@i4, :num_staff=>5)
+    @db[:executives].insert(:id=>@i4, :num_managers=>6)
+    @db[:staff].insert(:id=>@i2, :manager_id=>@i4)
+    
+    clear_sqls
+  end
+  after do
+    @db.drop_table :executives, :managers, :staff, :employees
+    [:Executive, :Manager, :Staff, :Employee].each{|s| Object.send(:remove_const, s)}
+  end
+
+  specify "should return rows as subclass instances" do
+    Employee.order(:id).all.should == [
+      Employee.load(:id=>@i1, :name=>'E', :kind=>'Employee'),
+      Staff.load(:id=>@i2, :name=>'S', :kind=>'Staff'),
+      Manager.load(:id=>@i3, :name=>'M', :kind=>'Manager'),
+      Executive.load(:id=>@i4, :name=>'Ex', :kind=>'Executive')
+    ]
+  end
+  
+  specify "should lazily load columns in subclass tables" do
+    a = Employee.order(:id).all
+    a[1][:manager_id].should == nil
+    a[1].manager_id.should == @i4
+  end
+  
+  specify "should include schema for columns for tables for ancestor classes" do
+    Employee.db_schema.keys.sort_by{|x| x.to_s}.should == [:id, :kind, :name]
+    Staff.db_schema.keys.sort_by{|x| x.to_s}.should == [:id, :kind, :manager_id, :name]
+    Manager.db_schema.keys.sort_by{|x| x.to_s}.should == [:id, :kind, :name, :num_staff]
+    Executive.db_schema.keys.sort_by{|x| x.to_s}.should == [:id, :kind, :name, :num_managers, :num_staff]
+  end
+  
+  specify "should include columns for tables for ancestor classes" do
+    Employee.columns.should == [:id, :name, :kind]
+    Staff.columns.should == [:id, :name, :kind, :manager_id]
+    Manager.columns.should == [:id, :name, :kind, :num_staff]
+    Executive.columns.should == [:id, :name, :kind, :num_staff, :num_managers]
+  end
+  
+  specify "should delete rows from all tables" do
+    e = Executive.first
+    i = e.id
+    e.staff_members_dataset.destroy
+    e.destroy
+    @db[:executives][:id=>i].should == nil
+    @db[:managers][:id=>i].should == nil
+    @db[:employees][:id=>i].should == nil
+  end
+  
+  # See http://www.sqlite.org/src/tktview/3338b3fa19ac4abee6c475126a2e6d9d61f26ab1
+  cspecify "should insert rows into all tables", :sqlite do
+    e = Executive.create(:name=>'Ex2', :num_managers=>8, :num_staff=>9)
+    i = e.id
+    @db[:employees][:id=>i].should == {:id=>i, :name=>'Ex2', :kind=>'Executive'}
+    @db[:managers][:id=>i].should == {:id=>i, :num_staff=>9}
+    @db[:executives][:id=>i].should == {:id=>i, :num_managers=>8}
+  end
+  
+  specify "should update rows in all tables" do
+    Executive.first.update(:name=>'Ex2', :num_managers=>8, :num_staff=>9)
+    @db[:employees][:id=>@i4].should == {:id=>@i4, :name=>'Ex2', :kind=>'Executive'}
+    @db[:managers][:id=>@i4].should == {:id=>@i4, :num_staff=>9}
+    @db[:executives][:id=>@i4].should == {:id=>@i4, :num_managers=>8}
+  end
+  
+  cspecify "should handle many_to_one relationships", :sqlite do
+    m = Staff.first.manager
+    m.should == Manager[@i4]
+    m.should be_a_kind_of(Executive)
+  end
+  
+  cspecify "should handle eagerly loading many_to_one relationships", :sqlite do
+    Staff.limit(1).eager(:manager).all.map{|x| x.manager}.should == [Manager[@i4]]
+  end
+  
+  cspecify "should handle eagerly graphing many_to_one relationships", :sqlite do
+    ss = Staff.eager_graph(:manager).all
+    ss.should == [Staff[@i2]]
+    ss.map{|x| x.manager}.should == [Manager[@i4]]
+  end
+  
+  specify "should handle one_to_many relationships" do
+    Executive.first.staff_members.should == [Staff[@i2]]
+  end
+  
+  specify "should handle eagerly loading one_to_many relationships" do
+    Executive.limit(1).eager(:staff_members).first.staff_members.should == [Staff[@i2]]
+  end
+  
+  cspecify "should handle eagerly graphing one_to_many relationships", :sqlite do
+    es = Executive.limit(1).eager_graph(:staff_members).all
+    es.should == [Executive[@i4]]
+    es.map{|x| x.staff_members}.should == [[Staff[@i2]]]
+  end
+end
+end