sequel 4.23.0 → 4.24.0

data/lib/sequel/plugins/update_refresh.rb

@@ -19,6 +19,20 @@ module Sequel
     #
     #   # Make the Album class refresh after update
     #   Album.plugin :update_refresh
+    #
+    # As a performance optimisation, if you know only specific
+    # columns will have changed, you can specify them to the
+    # +columns+ option. This can be a performance gain if it
+    # would avoid pointlessly comparing many other columns.
+    # Note that this option currently only has an effect if the
+    # dataset # supports RETURNING.
+    #
+    #   # Only include the artist column in RETURNING
+    #   Album.plugin :update_refresh, :columns => :artist
+    #
+    #   # Only include the artist and title columns in RETURNING
+    #   Album.plugin :update_refresh, :columns => [ :artist, :title ]
+    #
     module UpdateRefresh
       module InstanceMethods
         def after_update
@@ -33,7 +47,7 @@ module Sequel
         def _update_without_checking(columns)
           ds = _update_dataset
           if ds.supports_returning?(:update)
-            ds = ds.opts[:returning] ? ds : ds.returning
+            ds = ds.opts[:returning] ? ds : ds.returning(*self.class.update_refresh_columns)
             rows = ds.update(columns)
             n = rows.length
             if n == 1
@@ -45,6 +59,17 @@ module Sequel
           end
         end
       end
+
+      module ClassMethods
+        attr_reader :update_refresh_columns
+      end
+
+      def self.configure(model, opts=OPTS)
+        model.instance_eval do
+          @update_refresh_columns = Array(opts[:columns]) || []
+        end
+      end
+
     end
   end
 end

data/lib/sequel/plugins/validation_helpers.rb

@@ -30,6 +30,9 @@ module Sequel
     #                   Sequel will attempt to insert a NULL value into the database, instead of using the
     #                   database's default.
     # :allow_nil :: Whether to skip the validation if the value is nil.
+    # :from :: Set to :values to pull column values from the values hash instead of calling the related method.
+    #          Allows for setting up methods on the underlying column values, in the cases where the model
+    #          transforms the underlying value before returning it, such as when using serialization.
     # :message :: The message to use.  Can be a string which is used directly, or a
     #             proc which is called.  If the validation method takes a argument before the array of attributes,
     #             that argument is passed as an argument to the proc.
@@ -227,6 +230,7 @@ module Sequel
             opts = Hash[opts].merge!(atts.pop)
           end
           message = validation_error_message(opts[:message])
+          from_values = opts[:from] == :values
           where = opts[:where]
           atts.each do |a|
             arr = Array(a)
@@ -236,7 +240,7 @@ module Sequel
             ds = if where
               where.call(ds, self, arr)
             else
-              vals = arr.map{|x| get_column_value(x)}
+              vals = arr.map{|x| from_values ? values[x] : get_column_value(x)}
               next if vals.any?(&:nil?)
               ds.where(arr.zip(vals))
             end
@@ -265,9 +269,10 @@ module Sequel
         # an error message for that attributes.
         def validatable_attributes(atts, opts)
           am, an, ab, m = opts.values_at(:allow_missing, :allow_nil, :allow_blank, :message)
+          from_values = opts[:from] == :values
           Array(atts).each do |a|
             next if am && !values.has_key?(a)
-            v = get_column_value(a)
+            v = from_values ? values[a] : get_column_value(a)
             next if an && v.nil?
             next if ab && v.respond_to?(:blank?) && v.blank?
             if message = yield(a, v, m)

data/lib/sequel/version.rb

@@ -3,7 +3,7 @@ module Sequel
   MAJOR = 4
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 23
+  MINOR = 24
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
   TINY  = 0

data/spec/adapters/oracle_spec.rb

@@ -150,7 +150,7 @@ describe "An Oracle database" do
       {:date_created=>nil, :name => 'abc', :value => 123} 
     ]
 
-    @d.filter(:name => 'abc').limit(1).to_a.must_equal [
+    @d.filter(:name => 'abc').order(:value).limit(1).to_a.must_equal [
       {:date_created=>nil, :name => 'abc', :value => 123}                                        
     ]
         

data/spec/adapters/postgres_spec.rb

@@ -1913,6 +1913,19 @@ if DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG && DB.server_versio
       i = 0
       @db.listen('foo2', :timeout=>0.001, :loop=>proc{i+=1; throw :stop if i > 3}){|ev, pid, payload| called = true}.must_equal nil
       i.must_equal 4
+
+      called = false
+      i = 0
+      @db.listen('foo2', :timeout=>proc{i+=1; 0.001}){|ev, pid, payload| called = true}.must_equal nil
+      called.must_equal false
+      i.must_equal 1
+
+	  i = 0
+      t = 0
+      @db.listen('foo2', :timeout=>proc{t+=1; 0.001}, :loop=>proc{i+=1; throw :stop if i > 3}){|ev, pid, payload| called = true}.must_equal nil
+      called.must_equal false
+      t.must_equal 4
+
     end unless RUBY_PLATFORM =~ /mingw/ # Ruby freezes on this spec on this platform/version
   end
 end
@@ -2940,6 +2953,54 @@ describe 'PostgreSQL inet/cidr types' do
       c.create(:i=>@ipv6, :c=>@ipv6nm).values.values_at(:i, :c).must_equal [@ipv6, @ipv6nm]
     end
   end
+
+  it 'operations/functions with pg_inet_ops' do
+    Sequel.extension :pg_inet_ops
+
+    @db.get(Sequel.pg_inet_op('1.2.3.4') << '1.2.3.0/24').must_equal true
+    @db.get(Sequel.pg_inet_op('1.2.3.4') << '1.2.3.4/32').must_equal false
+    @db.get(Sequel.pg_inet_op('1.2.3.4') << '1.2.2.0/24').must_equal false
+    @db.get(Sequel.pg_inet_op('1.2.3.4').contained_by('1.2.3.0/24')).must_equal true
+    @db.get(Sequel.pg_inet_op('1.2.3.4').contained_by('1.2.3.4/32')).must_equal false
+    @db.get(Sequel.pg_inet_op('1.2.3.4').contained_by('1.2.2.0/24')).must_equal false
+
+    @db.get(Sequel.pg_inet_op('1.2.3.4').contained_by_or_equals('1.2.3.0/24')).must_equal true
+    @db.get(Sequel.pg_inet_op('1.2.3.4').contained_by_or_equals('1.2.3.4/32')).must_equal true
+    @db.get(Sequel.pg_inet_op('1.2.3.4').contained_by_or_equals('1.2.2.0/24')).must_equal false
+
+    @db.get(Sequel.pg_inet_op('1.2.3.0/24') >> '1.2.3.4').must_equal true
+    @db.get(Sequel.pg_inet_op('1.2.3.0/24') >> '1.2.2.4').must_equal false
+    @db.get(Sequel.pg_inet_op('1.2.3.0/24').contains('1.2.3.4')).must_equal true
+    @db.get(Sequel.pg_inet_op('1.2.3.0/24').contains('1.2.2.4')).must_equal false
+
+    @db.get(Sequel.pg_inet_op('1.2.3.0/24').contains_or_equals('1.2.3.4')).must_equal true
+    @db.get(Sequel.pg_inet_op('1.2.3.0/24').contains_or_equals('1.2.2.4')).must_equal false
+    @db.get(Sequel.pg_inet_op('1.2.3.0/24').contains_or_equals('1.2.3.0/24')).must_equal true
+
+    @db.get(Sequel.pg_inet_op('1.2.3.0/32') + 1).must_equal IPAddr.new('1.2.3.1/32')
+    @db.get(Sequel.pg_inet_op('1.2.3.1/32') - 1).must_equal IPAddr.new('1.2.3.0/32')
+    @db.get(Sequel.pg_inet_op('1.2.3.1/32') - '1.2.3.0/32').must_equal 1
+    @db.get(Sequel.pg_inet_op('1.2.3.0/32') & '1.2.0.4/32').must_equal IPAddr.new('1.2.0.0/32')
+    @db.get(Sequel.pg_inet_op('1.2.0.0/32') | '0.0.3.4/32').must_equal IPAddr.new('1.2.3.4/32')
+    @db.get(~Sequel.pg_inet_op('0.0.0.0/32')).must_equal IPAddr.new('255.255.255.255/32')
+
+    @db.get(Sequel.pg_inet_op('1.2.3.4/24').abbrev).must_equal '1.2.3.4/24'
+    @db.get(Sequel.pg_inet_op('1.2.3.4/24').broadcast).must_equal IPAddr.new('1.2.3.255/24')
+    @db.get(Sequel.pg_inet_op('1.2.3.4/24').family).must_equal 4
+    @db.get(Sequel.pg_inet_op('1.2.3.4/24').host).must_equal '1.2.3.4'
+    @db.get(Sequel.pg_inet_op('1.2.3.4/24').hostmask).must_equal IPAddr.new('0.0.0.255/32')
+    @db.get(Sequel.pg_inet_op('1.2.3.4/24').masklen).must_equal 24
+    @db.get(Sequel.pg_inet_op('1.2.3.4/24').netmask).must_equal IPAddr.new('255.255.255.0/32')
+    @db.get(Sequel.pg_inet_op('1.2.3.4/24').network).must_equal IPAddr.new('1.2.3.0/24')
+    @db.get(Sequel.pg_inet_op('1.2.3.4/24').set_masklen(16)).must_equal IPAddr.new('1.2.3.4/16')
+    @db.get(Sequel.pg_inet_op('1.2.3.4/32').text).must_equal '1.2.3.4/32'
+
+    if @db.server_version >= 90400
+      @db.get(Sequel.pg_inet_op('1.2.3.0/24').contains_or_contained_by('1.2.0.0/16')).must_equal true
+      @db.get(Sequel.pg_inet_op('1.2.0.0/16').contains_or_contained_by('1.2.3.0/24')).must_equal true
+      @db.get(Sequel.pg_inet_op('1.3.0.0/16').contains_or_contained_by('1.2.3.0/24')).must_equal false
+    end
+  end
 end
 
 describe 'PostgreSQL range types' do

data/spec/core_extensions_spec.rb

@@ -630,7 +630,7 @@ end
 describe "Postgres extensions integration" do
   before do
     @db = Sequel.mock
-    Sequel.extension(:pg_array, :pg_array_ops, :pg_hstore, :pg_hstore_ops, :pg_json, :pg_json_ops, :pg_range, :pg_range_ops, :pg_row, :pg_row_ops)
+    Sequel.extension(:pg_array, :pg_array_ops, :pg_hstore, :pg_hstore_ops, :pg_json, :pg_json_ops, :pg_range, :pg_range_ops, :pg_row, :pg_row_ops, :pg_inet_ops)
   end
 
   it "Symbol#pg_array should return an ArrayOp" do
@@ -645,6 +645,10 @@ describe "Postgres extensions integration" do
     @db.literal(:a.hstore['a']).must_equal "(a -> 'a')"
   end
 
+  it "Symbol#pg_inet should return an InetOp" do
+    @db.literal(:a.pg_inet.contains(:b)).must_equal "(a >> b)"
+  end
+
   it "Symbol#pg_json should return an JSONOp" do
     @db.literal(:a.pg_json[%w'a b']).must_equal "(a #> ARRAY['a','b'])"
     @db.literal(:a.pg_json.extract('a')).must_equal "json_extract_path(a, 'a')"

data/spec/extensions/association_pks_spec.rb

@@ -2,8 +2,10 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "Sequel::Plugins::AssociationPks" do
   before do
-    @db = Sequel.mock(:fetch=>proc do |sql|
+    @db = Sequel.mock(:autoid=>1, :fetch=>proc do |sql|
       case sql
+      when /SELECT \* FROM (?:artists|albums) WHERE \(id = (\d+)\) LIMIT 1/
+        {:id=>$1.to_i}
       when "SELECT id FROM albums WHERE (albums.artist_id = 1)"
         [{:id=>1}, {:id=>2}, {:id=>3}]
       when /SELECT tag_id FROM albums_tags WHERE \(album_id = (\d)\)/
@@ -278,4 +280,74 @@ describe "Sequel::Plugins::AssociationPks" do
     Hash[match[1].split(', ').zip(match[2].split(', '))].must_equal("first"=>"12", "last"=>"12", "album_id"=>"2")
     sqls.length.must_equal 6
   end
+
+  it "should handle delaying setting of association pks until after saving for new objects, if :delay plugin option is used" do
+    @Artist.one_to_many :albums, :clone=>:albums, :delay_pks=>true
+    @Album.many_to_many :tags, :clone=>:tags, :delay_pks=>true
+
+    ar = @Artist.new
+    ar.album_pks.must_equal []
+    ar.album_pks = [1,2,3]
+    ar.album_pks.must_equal [1,2,3]
+    @db.sqls.must_equal []
+
+    ar.save
+    @db.sqls.must_equal [
+      "INSERT INTO artists DEFAULT VALUES",
+      "UPDATE albums SET artist_id = 1 WHERE (id IN (1, 2, 3))",
+      "UPDATE albums SET artist_id = NULL WHERE ((albums.artist_id = 1) AND (id NOT IN (1, 2, 3)))",
+      "SELECT * FROM artists WHERE (id = 1) LIMIT 1",
+    ]
+
+    al = @Album.new
+    al.tag_pks.must_equal []
+    al.tag_pks = [1,2]
+    al.tag_pks.must_equal [1, 2]
+    @db.sqls.must_equal []
+
+    al.save
+    @db.sqls.must_equal [
+      "INSERT INTO albums DEFAULT VALUES",
+      "DELETE FROM albums_tags WHERE ((album_id = 2) AND (tag_id NOT IN (1, 2)))",
+      "SELECT tag_id FROM albums_tags WHERE (album_id = 2)",
+      "BEGIN",
+      "INSERT INTO albums_tags (album_id, tag_id) VALUES (2, 1)",
+      "COMMIT",
+      "SELECT * FROM albums WHERE (id = 2) LIMIT 1"
+    ]
+  end
+
+  it "should handle delaying setting of association pks until after saving for existing objects, if :delay=>:all plugin option is used" do
+    @Artist.one_to_many :albums, :clone=>:albums, :delay_pks=>:always
+    @Album.many_to_many :tags, :clone=>:tags, :delay_pks=>:always
+
+    ar = @Artist.load(:id=>1)
+    ar.album_pks.must_equal [1,2,3]
+    @db.sqls
+    ar.album_pks = [2,4]
+    ar.album_pks.must_equal [2,4]
+    @db.sqls.must_equal []
+
+    ar.save_changes
+    @db.sqls.must_equal [
+      "UPDATE albums SET artist_id = 1 WHERE (id IN (2, 4))",
+      "UPDATE albums SET artist_id = NULL WHERE ((albums.artist_id = 1) AND (id NOT IN (2, 4)))"
+    ]
+
+    al = @Album.load(:id=>1)
+    al.tag_pks.must_equal [1,2]
+    @db.sqls
+    al.tag_pks = [2,3]
+    al.tag_pks.must_equal [2,3]
+    @db.sqls.must_equal []
+
+    al.save_changes
+    @db.sqls.must_equal [
+      "DELETE FROM albums_tags WHERE ((album_id = 1) AND (tag_id NOT IN (2, 3)))",
+      "SELECT tag_id FROM albums_tags WHERE (album_id = 1)",
+      "BEGIN",
+      "INSERT INTO albums_tags (album_id, tag_id) VALUES (1, 3)",
+      "COMMIT",
+    ]
+  end
 end

data/spec/extensions/auto_validations_spec.rb

@@ -48,6 +48,25 @@ describe "Sequel::Plugins::AutoValidations" do
     @m.errors.must_equal(:name=>["is longer than 50 characters"])
   end
 
+  it "should handle simple unique indexes correctly" do
+    def (@c.db).indexes(t, *)
+      raise if t.is_a?(Sequel::Dataset)
+      return [] if t != :test
+      {:a=>{:columns=>[:name], :unique=>true}}
+    end
+    @c.plugin :auto_validations
+    @m.set(:name=>'foo', :d=>Date.today)
+    @m.valid?.must_equal false
+    @m.errors.must_equal(:name=>["is already taken"])
+  end
+
+  it "should validate using the underlying column values" do
+    @c.send(:define_method, :name){super() * 2}
+    @c.db.fetch = {:v=>0}
+    @m.set(:d=>Date.today, :num=>1, :name=>'b'*26)
+    @m.valid?.must_equal true
+  end
+
   it "should handle databases that don't support index parsing" do
     def (@m.db).supports_index_parsing?() false end
     @m.model.send(:setup_auto_validations)
@@ -155,4 +174,19 @@ describe "Sequel::Plugins::AutoValidations" do
     @c.set_dataset(@c.db[:foo])
     @c.new.valid?.must_equal true
   end
+
+  it "should support setting validator options" do
+    sc = Class.new(@c)
+    sc.plugin :auto_validations, :max_length_opts=> {:message=> 'ml_message'}, :schema_types_opts=> {:message=> 'st_message'}, :explicit_not_null_opts=> {:message=> 'enn_message'}, :unique_opts=> {:message=> 'u_message'}
+
+    @m = sc.new
+    @m.set(:name=>'a'*51, :d => '/', :nnd => nil, :num=>1)
+    @m.valid?.must_equal false
+    @m.errors.must_equal(:name=>["ml_message"], :d=>["st_message"], :nnd=>["enn_message"])
+
+    @m = sc.new
+    @m.set(:name=>1, :num=>1, :d=>Date.today)
+    @m.valid?.must_equal false
+    @m.errors.must_equal([:name, :num]=>["u_message"])
+  end
 end

data/spec/extensions/class_table_inheritance_spec.rb

@@ -35,6 +35,8 @@ describe "class_table_inheritance plugin" do
     end 
     class ::Executive < Manager
     end 
+    class ::Ceo < Executive
+    end 
     class ::Staff < Employee
       many_to_one :manager
     end 
@@ -42,57 +44,59 @@ describe "class_table_inheritance plugin" do
     @db.sqls
   end
   after do
+    Object.send(:remove_const, :Ceo)
     Object.send(:remove_const, :Executive)
     Object.send(:remove_const, :Manager)
     Object.send(:remove_const, :Staff)
     Object.send(:remove_const, :Employee)
   end
 
-  it "should have simple_table = nil for all classes" do
-    Employee.simple_table.must_equal nil
+  it "should have simple_table = nil for all subclasses" do
     Manager.simple_table.must_equal nil
     Executive.simple_table.must_equal nil
+    Ceo.simple_table.must_equal nil
     Staff.simple_table.must_equal nil
   end
   
     it "should have working row_proc if using set_dataset in subclass to remove columns" do
       Manager.set_dataset(Manager.dataset.select(*(Manager.columns - [:blah])))
-      Manager.dataset._fetch = {:id=>1, :kind=>'Executive'}
-      Manager[1].must_equal Executive.load(:id=>1, :kind=>'Executive')
+      Manager.dataset._fetch = {:id=>1, :kind=>'Ceo'}
+      Manager[1].must_equal Ceo.load(:id=>1, :kind=>'Ceo')
     end
 
   it "should use a joined dataset in subclasses" do
-    Employee.dataset.sql.must_equal 'SELECT employees.id, employees.name, employees.kind FROM employees'
+    Employee.dataset.sql.must_equal 'SELECT * FROM employees'
     Manager.dataset.sql.must_equal 'SELECT employees.id, employees.name, employees.kind, managers.num_staff FROM employees INNER JOIN managers ON (managers.id = employees.id)'
     Executive.dataset.sql.must_equal 'SELECT employees.id, employees.name, employees.kind, managers.num_staff, executives.num_managers FROM employees INNER JOIN managers ON (managers.id = employees.id) INNER JOIN executives ON (executives.id = managers.id)'
+    Ceo.dataset.sql.must_equal 'SELECT employees.id, employees.name, employees.kind, managers.num_staff, executives.num_managers FROM employees INNER JOIN managers ON (managers.id = employees.id) INNER JOIN executives ON (executives.id = managers.id) WHERE (employees.kind IN (\'Ceo\'))'
     Staff.dataset.sql.must_equal 'SELECT employees.id, employees.name, employees.kind, staff.manager_id FROM employees INNER JOIN staff ON (staff.id = employees.id)'
   end
   
   it "should return rows with the correct class based on the polymorphic_key value" do
-    @ds._fetch = [{:kind=>'Employee'}, {:kind=>'Manager'}, {:kind=>'Executive'}, {:kind=>'Staff'}]
-    Employee.all.collect{|x| x.class}.must_equal [Employee, Manager, Executive, Staff]
+    @ds._fetch = [{:kind=>'Employee'}, {:kind=>'Manager'}, {:kind=>'Executive'}, {:kind=>'Ceo'}, {:kind=>'Staff'}]
+    Employee.all.collect{|x| x.class}.must_equal [Employee, Manager, Executive, Ceo, Staff]
   end 
   
   it "should return rows with the correct class based on the polymorphic_key value for subclasses" do
-    Manager.dataset._fetch = [{:kind=>'Manager'}, {:kind=>'Executive'}]
-    Manager.all.collect{|x| x.class}.must_equal [Manager, Executive]
+    Manager.dataset._fetch = [{:kind=>'Manager'}, {:kind=>'Executive'}, {:kind=>'Ceo'}]
+    Manager.all.collect{|x| x.class}.must_equal [Manager, Executive, Ceo]
   end
   
   it "should have refresh return all columns in subclass after loading from superclass" do
-    Employee.dataset._fetch = [{:id=>1, :name=>'A', :kind=>'Executive'}]
-    Executive.instance_dataset._fetch = [{:id=>1, :name=>'A', :kind=>'Executive', :num_staff=>3, :num_managers=>2}]
+    Employee.dataset._fetch = [{:id=>1, :name=>'A', :kind=>'Ceo'}]
+    Ceo.instance_dataset._fetch = [{:id=>1, :name=>'A', :kind=>'Ceo', :num_staff=>3, :num_managers=>2}]
     a = Employee.first
-    a.class.must_equal Executive
-    a.values.must_equal(:id=>1, :name=>'A', :kind=>'Executive')
-    a.refresh.values.must_equal(:id=>1, :name=>'A', :kind=>'Executive', :num_staff=>3, :num_managers=>2)
-    @db.sqls.must_equal ["SELECT employees.id, employees.name, employees.kind FROM employees LIMIT 1",
-      "SELECT employees.id, employees.name, employees.kind, managers.num_staff, executives.num_managers FROM employees INNER JOIN managers ON (managers.id = employees.id) INNER JOIN executives ON (executives.id = managers.id) WHERE (executives.id = 1) LIMIT 1"]
+    a.class.must_equal Ceo
+    a.values.must_equal(:id=>1, :name=>'A', :kind=>'Ceo')
+    a.refresh.values.must_equal(:id=>1, :name=>'A', :kind=>'Ceo', :num_staff=>3, :num_managers=>2)
+    @db.sqls.must_equal ["SELECT * FROM employees LIMIT 1",
+      "SELECT employees.id, employees.name, employees.kind, managers.num_staff, executives.num_managers FROM employees INNER JOIN managers ON (managers.id = employees.id) INNER JOIN executives ON (executives.id = managers.id) WHERE ((employees.kind IN ('Ceo')) AND (executives.id = 1)) LIMIT 1"]
   end
   
   it "should return rows with the current class if cti_key is nil" do
     Employee.plugin(:class_table_inheritance)
-    Employee.dataset._fetch = [{:kind=>'Employee'}, {:kind=>'Manager'}, {:kind=>'Executive'}, {:kind=>'Staff'}]
-    Employee.all.collect{|x| x.class}.must_equal [Employee, Employee, Employee, Employee]
+    Employee.dataset._fetch = [{:kind=>'Employee'}, {:kind=>'Manager'}, {:kind=>'Executive'}, {:kind=>'Ceo'}, {:kind=>'Staff'}]
+    Employee.all.collect{|x| x.class}.must_equal [Employee, Employee, Employee, Employee, Employee]
   end
   
   it "should return rows with the current class if cti_key is nil in subclasses" do
@@ -106,15 +110,17 @@ describe "class_table_inheritance plugin" do
   end
   
   it "should handle a model map with integer values" do
-    Employee.plugin(:class_table_inheritance, :key=>:kind, :model_map=>{0=>:Employee, 1=>:Manager, 2=>:Executive})
+    Employee.plugin(:class_table_inheritance, :key=>:kind, :model_map=>{0=>:Employee, 1=>:Manager, 2=>:Executive, 3=>:Ceo})
+    Object.send(:remove_const, :Ceo)
     Object.send(:remove_const, :Executive)
     Object.send(:remove_const, :Manager)
     class ::Manager < Employee; end 
     class ::Executive < Manager; end 
-    Employee.dataset._fetch = [{:kind=>nil},{:kind=>0},{:kind=>1}, {:kind=>2}]
-    Employee.all.collect{|x| x.class}.must_equal [Employee, Employee, Manager, Executive]
-    Manager.dataset._fetch = [{:kind=>nil},{:kind=>0},{:kind=>1}, {:kind=>2}]
-    Manager.all.collect{|x| x.class}.must_equal [Manager, Employee, Manager, Executive]
+    class ::Ceo < Executive; end 
+    Employee.dataset._fetch = [{:kind=>nil},{:kind=>0},{:kind=>1}, {:kind=>2}, {:kind=>3}]
+    Employee.all.collect{|x| x.class}.must_equal [Employee, Employee, Manager, Executive, Ceo]
+    Manager.dataset._fetch = [{:kind=>nil},{:kind=>0},{:kind=>1}, {:kind=>2}, {:kind=>3}]
+    Manager.all.collect{|x| x.class}.must_equal [Manager, Employee, Manager, Executive, Ceo]
   end
   
   it "should fallback to the main class if the given class does not exist" do
@@ -123,8 +129,8 @@ describe "class_table_inheritance plugin" do
   end
   
   it "should fallback to the main class if the given class does not exist in subclasses" do
-    Manager.dataset._fetch = [{:kind=>'Manager'}, {:kind=>'Executive'}, {:kind=>'Blah'}]
-    Manager.all.collect{|x| x.class}.must_equal [Manager, Executive, Manager]
+    Manager.dataset._fetch = [{:kind=>'Manager'}, {:kind=>'Executive'}, {:kind=>'Ceo'}, {:kind=>'Blah'}]
+    Manager.all.collect{|x| x.class}.must_equal [Manager, Executive, Ceo, Manager]
   end
 
   it "should sets the model class name for the key when creating new parent class records" do
@@ -133,8 +139,8 @@ describe "class_table_inheritance plugin" do
   end
   
   it "should sets the model class name for the key when creating new subclass records" do
-    Executive.create
-    @db.sqls.must_equal ["INSERT INTO employees (kind) VALUES ('Executive')",
+    Ceo.create
+    @db.sqls.must_equal ["INSERT INTO employees (kind) VALUES ('Ceo')",
       "INSERT INTO managers (id) VALUES (1)",
       "INSERT INTO executives (id) VALUES (1)"]
   end
@@ -163,45 +169,42 @@ describe "class_table_inheritance plugin" do
     @db.sqls.must_equal ["INSERT INTO employees (kind) VALUES ('Employee')"]
   end
 
-  it "should raise an error if attempting to create an anonymous subclass" do
-    proc{Class.new(Manager)}.must_raise(Sequel::Error)
-  end
-
   it "should allow specifying a map of names to tables to override implicit mapping" do
     Manager.dataset.sql.must_equal 'SELECT employees.id, employees.name, employees.kind, managers.num_staff FROM employees INNER JOIN managers ON (managers.id = employees.id)'
     Staff.dataset.sql.must_equal 'SELECT employees.id, employees.name, employees.kind, staff.manager_id FROM employees INNER JOIN staff ON (staff.id = employees.id)'
   end
 
   it "should lazily load attributes for columns in subclass tables" do
-    Manager.instance_dataset._fetch = Manager.dataset._fetch = {:id=>1, :name=>'J', :kind=>'Executive', :num_staff=>2}
+    Manager.instance_dataset._fetch = Manager.dataset._fetch = {:id=>1, :name=>'J', :kind=>'Ceo', :num_staff=>2}
     m = Manager[1]
     @db.sqls.must_equal ['SELECT employees.id, employees.name, employees.kind, managers.num_staff FROM employees INNER JOIN managers ON (managers.id = employees.id) WHERE (managers.id = 1) LIMIT 1']
-    Executive.instance_dataset._fetch = Executive.dataset._fetch = {:num_managers=>3}
+    @db.fetch = {:num_managers=>3}
+    m.must_be_kind_of Ceo
     m.num_managers.must_equal 3
     @db.sqls.must_equal ['SELECT executives.num_managers FROM employees INNER JOIN managers ON (managers.id = employees.id) INNER JOIN executives ON (executives.id = managers.id) WHERE (executives.id = 1) LIMIT 1']
-    m.values.must_equal(:id=>1, :name=>'J', :kind=>'Executive', :num_staff=>2, :num_managers=>3)
+    m.values.must_equal(:id=>1, :name=>'J', :kind=>'Ceo', :num_staff=>2, :num_managers=>3)
   end
 
   it "should lazily load columns in middle classes correctly when loaded from parent class" do
-    Employee.dataset._fetch = {:id=>1, :kind=>'Executive'}
+    Employee.dataset._fetch = {:id=>1, :kind=>'Ceo'}
     Manager.dataset._fetch = {:num_staff=>2}
     e = Employee[1]
-    e.must_be_kind_of(Executive)
-    @db.sqls.must_equal ["SELECT employees.id, employees.name, employees.kind FROM employees WHERE (id = 1) LIMIT 1"]
+    e.must_be_kind_of(Ceo)
+    @db.sqls.must_equal ["SELECT * FROM employees WHERE (id = 1) LIMIT 1"]
     e.num_staff.must_equal 2
     @db.sqls.must_equal ["SELECT managers.num_staff FROM employees INNER JOIN managers ON (managers.id = employees.id) WHERE (managers.id = 1) LIMIT 1"]
   end
 
   it "should eagerly load lazily columns in subclasses when loaded from parent class" do
-    Employee.dataset._fetch = {:id=>1, :kind=>'Executive'}
+    Employee.dataset._fetch = {:id=>1, :kind=>'Ceo'}
     Manager.dataset._fetch = {:id=>1, :num_staff=>2}
-    Executive.dataset._fetch = {:id=>1, :num_managers=>3}
+    @db.fetch = {:id=>1, :num_managers=>3}
     e = Employee.all.first
-    e.must_be_kind_of(Executive)
-    @db.sqls.must_equal ["SELECT employees.id, employees.name, employees.kind FROM employees"]
-    e.num_staff#.must_equal 2
+    e.must_be_kind_of(Ceo)
+    @db.sqls.must_equal ["SELECT * FROM employees"]
+    e.num_staff.must_equal 2
     @db.sqls.must_equal ["SELECT managers.id, managers.num_staff FROM employees INNER JOIN managers ON (managers.id = employees.id) WHERE (managers.id IN (1))"]
-    e.num_managers#.must_equal 3
+    e.num_managers.must_equal 3
     @db.sqls.must_equal ['SELECT executives.id, executives.num_managers FROM employees INNER JOIN managers ON (managers.id = employees.id) INNER JOIN executives ON (executives.id = managers.id) WHERE (executives.id IN (1))']
   end
   
@@ -213,62 +216,63 @@ describe "class_table_inheritance plugin" do
   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.must_equal :id}
+    [Employee, Manager, Executive, Ceo, Staff].each{|c| c.primary_key.must_equal :id}
   end
 
   it "should have table_name return the table name of the most specific table" do
     Employee.table_name.must_equal :employees
     Manager.table_name.must_equal :managers
     Executive.table_name.must_equal :executives
+    Ceo.table_name.must_equal :executives
     Staff.table_name.must_equal :staff
   end
 
   it "should delete the correct rows from all tables when deleting" do
-    Executive.load(:id=>1).delete
+    Ceo.load(:id=>1).delete
     @db.sqls.must_equal ["DELETE FROM executives WHERE (id = 1)", "DELETE FROM managers WHERE (id = 1)", "DELETE FROM employees WHERE (id = 1)"]
   end
 
   it "should not allow deletion of frozen object" do
-    o = Executive.load(:id=>1)
+    o = Ceo.load(:id=>1)
     o.freeze
     proc{o.delete}.must_raise(Sequel::Error)
     @db.sqls.must_equal []
   end
 
   it "should insert the correct rows into all tables when inserting" do
-    Executive.create(:num_managers=>3, :num_staff=>2, :name=>'E')
+    Ceo.create(:num_managers=>3, :num_staff=>2, :name=>'E')
     sqls = @db.sqls
     sqls.length.must_equal 3
-    sqls[0].must_match(/INSERT INTO employees \((name|kind), (name|kind)\) VALUES \('(E|Executive)', '(E|Executive)'\)/)
+    sqls[0].must_match(/INSERT INTO employees \((name|kind), (name|kind)\) VALUES \('(E|Ceo)', '(E|Ceo)'\)/)
     sqls[1].must_match(/INSERT INTO managers \((num_staff|id), (num_staff|id)\) VALUES \([12], [12]\)/)
     sqls[2].must_match(/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 = Ceo.new(:num_managers=>3, :num_staff=>2, :name=>'E')
     e.id = 2
     e.save
     sqls = @db.sqls
     sqls.length.must_equal 3
-    sqls[0].must_match(/INSERT INTO employees \((name|kind|id), (name|kind|id), (name|kind|id)\) VALUES \(('E'|'Executive'|2), ('E'|'Executive'|2), ('E'|'Executive'|2)\)/)
+    sqls[0].must_match(/INSERT INTO employees \((name|kind|id), (name|kind|id), (name|kind|id)\) VALUES \(('E'|'Ceo'|2), ('E'|'Ceo'|2), ('E'|'Ceo'|2)\)/)
     sqls[1].must_match(/INSERT INTO managers \((num_staff|id), (num_staff|id)\) VALUES \(2, 2\)/)
     sqls[2].must_match(/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')
+    Ceo.load(:id=>2).update(:num_managers=>3, :num_staff=>2, :name=>'E')
     @db.sqls.must_equal ["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
-    Manager.dataset._fetch = {:id=>3, :name=>'E', :kind=>'Executive', :num_managers=>3}
-    Staff.load(:manager_id=>3).manager.must_equal Executive.load(:id=>3, :name=>'E', :kind=>'Executive', :num_managers=>3)
+    Manager.dataset._fetch = {:id=>3, :name=>'E', :kind=>'Ceo', :num_managers=>3}
+    Staff.load(:manager_id=>3).manager.must_equal Ceo.load(:id=>3, :name=>'E', :kind=>'Ceo', :num_managers=>3)
     @db.sqls.must_equal ['SELECT employees.id, employees.name, employees.kind, managers.num_staff FROM employees INNER JOIN managers ON (managers.id = employees.id) WHERE (managers.id = 3) LIMIT 1']
   end
   
   it "should handle one_to_many relationships correctly" do
     Staff.dataset._fetch = {:id=>1, :name=>'S', :kind=>'Staff', :manager_id=>3}
-    Executive.load(:id=>3).staff_members.must_equal [Staff.load(:id=>1, :name=>'S', :kind=>'Staff', :manager_id=>3)]
+    Ceo.load(:id=>3).staff_members.must_equal [Staff.load(:id=>1, :name=>'S', :kind=>'Staff', :manager_id=>3)]
     @db.sqls.must_equal ['SELECT employees.id, employees.name, employees.kind, staff.manager_id FROM employees INNER JOIN staff ON (staff.id = employees.id) WHERE (staff.manager_id = 3)']
   end
 end