sequel 3.35.0 → 3.36.0

data/lib/sequel/plugins/nested_attributes.rb

@@ -87,20 +87,30 @@ module Sequel
         #   modified through the association_attributes= method to the specific fields given.
         # * :limit - For *_to_many associations, a limit on the number of records
         #   that will be processed, to prevent denial of service attacks.
+        # * :reject_if - A proc that is given each attribute hash before it is
+        #   passed to its associated object. If the proc returns a truthy
+        #   value, the attribute hash is ignored.
         # * :remove - Allow disassociation of nested records (can remove the associated
         #   object from the parent object, but not destroy the associated object).
-        # * :strict - Set to false to not raise an error message if a primary key
-        #   is provided in a record, but it doesn't match an existing associated
-        #   object.
+        # * :strict - Kept for backward compatibility. Setting it to false is
+        #   equivalent to setting :unmatched_pk to :ignore.
+        # * :transform - A proc to transform attribute hashes before they are
+        #   passed to associated object. Takes two arguments, the parent object and
+        #   the attribute hash. Uses the return value as the new attribute hash.
+        # * :unmatched_pk - Specify the action to be taken if a primary key is
+        #   provided in a record, but it doesn't match an existing associated
+        #   object. Set to :create to create a new object with that primary
+        #   key, :ignore to ignore the record, or :raise to raise an error.
+        #   The default is :raise.
         #
-        # If a block is provided, it is passed each nested attribute hash.  If
-        # the hash should be ignored, the block should return anything except false or nil.
+        # If a block is provided, it is used to set the :reject_if option.
         def nested_attributes(*associations, &block)
           include(self.nested_attributes_module ||= Module.new) unless nested_attributes_module
           opts = associations.last.is_a?(Hash) ? associations.pop : {}
           reflections = associations.map{|a| association_reflection(a) || raise(Error, "no association named #{a} for #{self}")}
           reflections.each do |r|
             r[:nested_attributes] = opts
+            r[:nested_attributes][:unmatched_pk] ||= opts.delete(:strict) == false ? :ignore : :raise
             r[:nested_attributes][:reject_if] ||= block
             def_nested_attribute_method(r)
           end
@@ -133,7 +143,9 @@ module Sequel
         def nested_attributes_check_key_modifications(reflection, obj)
           keys = reflection.associated_object_keys.map{|x| obj.send(x)}
           yield
-          raise(Error, "Modifying association dependent key(s) when updating associated objects is not allowed") unless keys == reflection.associated_object_keys.map{|x| obj.send(x)}
+          unless keys == reflection.associated_object_keys.map{|x| obj.send(x)}
+            raise(Error, "Modifying association dependent key(s) when updating associated objects is not allowed")
+          end
         end
         
         # Create a new associated object with the given attributes, validate
@@ -148,6 +160,12 @@ module Sequel
             after_save_hook{send(reflection.add_method, obj)}
           else
             associations[reflection[:name]] = obj
+
+            # Because we are modifying the associations cache manually before the
+            # setter is called, we still want to run the setter code even though
+            # the cached value will be the same as the given value.
+            @set_associated_object_if_same = true
+
             # Don't need to validate the object twice if :validate association option is not false
             # and don't want to validate it at all if it is false.
             send(reflection[:type] == :many_to_one ? :before_save_hook : :after_save_hook){send(reflection.setter_method, obj.save(:validate=>false))}
@@ -155,16 +173,6 @@ module Sequel
           obj
         end
         
-        # Find an associated object with the matching pk.  If a matching option
-        # is not found and the :strict option is not false, raise an Error.
-        def nested_attributes_find(reflection, pk)
-          pk = pk.to_s
-          unless obj = Array(send(reflection[:name])).find{|x| x.pk.to_s == pk}
-            raise(Error, "no matching associated object with given primary key (association: #{reflection[:name]}, pk: #{pk})") unless reflection[:nested_attributes][:strict] == false
-          end
-          obj
-        end
-        
         # Take an array or hash of attribute hashes and set each one individually.
         # If a hash is provided it, sort it by key and then use the values.
         # If there is a limit on the nested attributes for this association,
@@ -177,24 +185,22 @@ module Sequel
           attributes_list.each{|a| nested_attributes_setter(reflection, a)}
         end
         
-        # Remove the matching associated object from the current object.
-        # If the :destroy option is given, destroy the object after disassociating it
+        # Remove the given associated object from the current object. If the
+        # :destroy option is given, destroy the object after disassociating it
         # (unless destroying the object would automatically disassociate it).
-        # Returns the object removed, if it exists.
-        def nested_attributes_remove(reflection, pk, opts={})
-          if obj = nested_attributes_find(reflection, pk)
-            if !opts[:destroy] || reflection.remove_before_destroy?
-              before_save_hook do
-                if reflection.returns_array?
-                  send(reflection.remove_method, obj)
-                else
-                  send(reflection.setter_method, nil)
-                end
+        # Returns the object removed.
+        def nested_attributes_remove(reflection, obj, opts={})
+          if !opts[:destroy] || reflection.remove_before_destroy?
+            before_save_hook do
+              if reflection.returns_array?
+                send(reflection.remove_method, obj)
+              else
+                send(reflection.setter_method, nil)
               end
             end
-            after_save_hook{obj.destroy} if opts[:destroy]
-            obj
           end
+          after_save_hook{obj.destroy} if opts[:destroy]
+          obj
         end
         
         # Set the fields in the obj based on the association, only allowing
@@ -207,43 +213,57 @@ module Sequel
           end
         end
 
-        # Modify the associated object based on the contents of the attribtues hash:
+        # Modify the associated object based on the contents of the attributes hash:
+        # * If a :transform block was given to nested_attributes, use it to modify the attribute hash.
         # * If a block was given to nested_attributes, call it with the attributes and return immediately if the block returns true.
+        # * If a primary key exists in the attributes hash and it matches an associated object:
+        # ** If _delete is a key in the hash and the :destroy option is used, destroy the matching associated object.
+        # ** If _remove is a key in the hash and the :remove option is used, disassociated the matching associated object.
+        # ** Otherwise, update the matching associated object with the contents of the hash.
+        # * If a primary key exists in the attributes hash but it does not match an associated object,
+        #   either raise an error, create a new object or ignore the hash, depending on the :unmatched_pk option.
         # * If no primary key exists in the attributes hash, create a new object.
-        # * If _delete is a key in the hash and the :destroy option is used, destroy the matching associated object.
-        # * If _remove is a key in the hash and the :remove option is used, disassociated the matching associated object.
-        # * Otherwise, update the matching associated object with the contents of the hash.
         def nested_attributes_setter(reflection, attributes)
+          if a = reflection[:nested_attributes][:transform]
+            attributes = a.call(self, attributes)
+          end
           return if (b = reflection[:nested_attributes][:reject_if]) && b.call(attributes)
           modified!
           klass = reflection.associated_class
-          if pk = attributes.delete(klass.primary_key) || attributes.delete(klass.primary_key.to_s)
-            attributes = attributes.dup
+          sym_keys = Array(klass.primary_key)
+          str_keys = sym_keys.map{|k| k.to_s}
+          if (pk = attributes.values_at(*sym_keys)).all? || (pk = attributes.values_at(*str_keys)).all?
+            pk = pk.map{|k| k.to_s}
+            obj = Array(send(reflection[:name])).find{|x| Array(x.pk).map{|k| k.to_s} == pk}
+          end
+          if obj
+            attributes = attributes.dup.delete_if{|k,v| str_keys.include? k.to_s}
             if reflection[:nested_attributes][:destroy] && klass.db.send(:typecast_value_boolean, attributes.delete(:_delete) || attributes.delete('_delete'))
-              nested_attributes_remove(reflection, pk, :destroy=>true)
+              nested_attributes_remove(reflection, obj, :destroy=>true)
             elsif reflection[:nested_attributes][:remove] && klass.db.send(:typecast_value_boolean, attributes.delete(:_remove) || attributes.delete('_remove'))
-              nested_attributes_remove(reflection, pk)
+              nested_attributes_remove(reflection, obj)
             else
-              nested_attributes_update(reflection, pk, attributes)
+              nested_attributes_update(reflection, obj, attributes)
+            end
+          elsif pk.all? && reflection[:nested_attributes][:unmatched_pk] != :create
+            if reflection[:nested_attributes][:unmatched_pk] == :raise
+              raise(Error, "no matching associated object with given primary key (association: #{reflection[:name]}, pk: #{pk})")
             end
           else
             nested_attributes_create(reflection, attributes)
           end
         end
         
-        # Update the matching associated object with the attributes,
-        # validating it when the parent object is validated and saving it
-        # when the parent is saved.
-        # Returns the object updated, if it exists.
-        def nested_attributes_update(reflection, pk, attributes)
-          if obj = nested_attributes_find(reflection, pk)
-            nested_attributes_update_attributes(reflection, obj, attributes)
-            after_validation_hook{validate_associated_object(reflection, obj)}
-            # Don't need to validate the object twice if :validate association option is not false
-            # and don't want to validate it at all if it is false.
-            after_save_hook{obj.save_changes(:validate=>false)}
-            obj
-          end
+        # Update the given object with the attributes, validating it when the
+        # parent object is validated and saving it when the parent is saved.
+        # Returns the object updated.
+        def nested_attributes_update(reflection, obj, attributes)
+          nested_attributes_update_attributes(reflection, obj, attributes)
+          after_validation_hook{validate_associated_object(reflection, obj)}
+          # Don't need to validate the object twice if :validate association option is not false
+          # and don't want to validate it at all if it is false.
+          after_save_hook{obj.save_changes(:validate=>false)}
+          obj
         end
 
         # Update the attributes for the given object related to the current object through the association.

data/lib/sequel/plugins/optimistic_locking.rb

@@ -65,6 +65,14 @@ module Sequel
           lc = model.lock_column
           instance_filter(lc=>send(lc))
         end
+
+        # Clear the instance filters when refreshing, so that attempting to
+        # refresh after a failed save removes the previous lock column filter
+        # (the new one will be added before updating).
+        def _refresh(ds)
+          clear_instance_filters
+          super
+        end
         
         # Only update the row if it has the same lock version, and increment the
         # lock version.

data/lib/sequel/plugins/tactical_eager_loading.rb

@@ -28,19 +28,18 @@ module Sequel
     module TacticalEagerLoading
       module InstanceMethods
         # The dataset that retrieved this object, set if the object was
-        # reteived via Dataset#all with an active identity map.
+        # reteived via Dataset#all.
         attr_accessor :retrieved_by
 
         # All model objects retrieved with this object, set if the object was
-        # reteived via Dataset#all with an active identity map.
+        # reteived via Dataset#all.
         attr_accessor :retrieved_with
 
         private
 
-        # If there is an active identity map and the association is not in the
-        # associations cache and the object was reteived via Dataset#all,
-        # eagerly load the association for all model objects retrieved with the
-        # current object.
+        # If there the association is not in the associations cache and the object
+        # was reteived via Dataset#all, eagerly load the association for all model
+        # objects retrieved with the current object.
         def load_associated_objects(opts, reload=false)
           name = opts[:name]
           if !associations.include?(name) && retrieved_by
@@ -51,6 +50,7 @@ module Sequel
               # is only defined in a subclass.  This particular instance can use the
               # association, but it can't be eagerly loaded as the parent class doesn't
               # have access to the association, and that's the class doing the eager loading.
+              nil
             end
           end
           super
@@ -60,7 +60,7 @@ module Sequel
       module DatasetMethods
         private
 
-        # If there is an active identity map, set the reteived_with attribute for the object
+        # Set the reteived_with and retrieved_by attributes for the object
         # with the current dataset and array of all objects.
         def post_load(objects)
           super

data/lib/sequel/version.rb

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

data/spec/adapters/postgres_spec.rb

@@ -60,12 +60,22 @@ describe "A PostgreSQL database" do
       [:value, {:type=>:blob, :allow_null=>true, :default=>nil, :ruby_default=>nil, :db_type=>"bytea", :primary_key=>false}]
     ]
   end
+
+  specify "should parse foreign keys for tables in a schema" do
+    begin
+      @db.create_table!(:public__testfk){primary_key :id; foreign_key :i, :public__testfk}
+      @db.foreign_key_list(:public__testfk).should == [{:on_delete=>:no_action, :on_update=>:no_action, :columns=>[:i], :key=>[:id], :deferrable=>false, :table=>Sequel.qualify(:public, :testfk), :name=>:testfk_i_fkey}]
+    ensure
+      @db.drop_table(:public__testfk)
+    end
+  end
 end
 
 describe "A PostgreSQL dataset" do
   before do
     @d = POSTGRES_DB[:test]
     @d.delete # remove all records
+    POSTGRES_DB.sqls.clear
   end
 
   specify "should quote columns and tables using double quotes if quoting identifiers" do
@@ -148,6 +158,102 @@ describe "A PostgreSQL dataset" do
     @d.lock('EXCLUSIVE'){@d.insert(:name=>'a')}
   end
 
+  specify "should support :using when altering a column's type" do
+    begin
+      @db = POSTGRES_DB
+      @db.create_table!(:atest){Integer :t}
+      @db[:atest].insert(1262304000)
+      @db.alter_table(:atest){set_column_type :t, Time, :using=>'epoch'.cast(Time) + '1 second'.cast(:interval) * :t}
+      @db[:atest].get(:t.extract(:year)).should == 2010
+    ensure
+      @db.drop_table?(:atest)
+    end
+  end
+
+  specify "should support :using with a string when altering a column's type" do
+    begin
+      @db = POSTGRES_DB
+      @db.create_table!(:atest){Integer :t}
+      @db[:atest].insert(1262304000)
+      @db.alter_table(:atest){set_column_type :t, Time, :using=>"'epoch'::timestamp + '1 second'::interval * t"}
+      @db[:atest].get(:t.extract(:year)).should == 2010
+    ensure
+      @db.drop_table?(:atest)
+    end
+  end
+
+  specify "should have #transaction support various types of synchronous options" do
+    @db = POSTGRES_DB
+    @db.transaction(:synchronous=>:on){}
+    @db.transaction(:synchronous=>true){}
+    @db.transaction(:synchronous=>:off){}
+    @db.transaction(:synchronous=>false){}
+    @db.sqls.grep(/synchronous/).should == ["SET LOCAL synchronous_commit = on", "SET LOCAL synchronous_commit = on", "SET LOCAL synchronous_commit = off", "SET LOCAL synchronous_commit = off"]
+
+    @db.sqls.clear
+    @db.transaction(:synchronous=>nil){}
+    @db.sqls.should == ['BEGIN', 'COMMIT']
+
+    if @db.server_version >= 90100
+      @db.sqls.clear
+      @db.transaction(:synchronous=>:local){}
+      @db.sqls.grep(/synchronous/).should == ["SET LOCAL synchronous_commit = local"]
+
+      if @db.server_version >= 90200
+        @db.sqls.clear
+        @db.transaction(:synchronous=>:remote_write){}
+        @db.sqls.grep(/synchronous/).should == ["SET LOCAL synchronous_commit = remote_write"]
+      end
+    end
+  end
+
+  specify "should have #transaction support read only transactions" do
+    @db = POSTGRES_DB
+    @db.transaction(:read_only=>true){}
+    @db.transaction(:read_only=>false){}
+    @db.transaction(:isolation=>:serializable, :read_only=>true){}
+    @db.transaction(:isolation=>:serializable, :read_only=>false){}
+    @db.sqls.grep(/READ/).should == ["SET TRANSACTION READ ONLY", "SET TRANSACTION READ WRITE", "SET TRANSACTION ISOLATION LEVEL SERIALIZABLE READ ONLY", "SET TRANSACTION ISOLATION LEVEL SERIALIZABLE READ WRITE"]
+  end
+
+  specify "should have #transaction support deferrable transactions" do
+    @db = POSTGRES_DB
+    @db.transaction(:deferrable=>true){}
+    @db.transaction(:deferrable=>false){}
+    @db.transaction(:deferrable=>true, :read_only=>true){}
+    @db.transaction(:deferrable=>false, :read_only=>false){}
+    @db.transaction(:isolation=>:serializable, :deferrable=>true, :read_only=>true){}
+    @db.transaction(:isolation=>:serializable, :deferrable=>false, :read_only=>false){}
+    @db.sqls.grep(/DEF/).should == ["SET TRANSACTION DEFERRABLE", "SET TRANSACTION NOT DEFERRABLE", "SET TRANSACTION READ ONLY DEFERRABLE", "SET TRANSACTION READ WRITE NOT DEFERRABLE",  "SET TRANSACTION ISOLATION LEVEL SERIALIZABLE READ ONLY DEFERRABLE", "SET TRANSACTION ISOLATION LEVEL SERIALIZABLE READ WRITE NOT DEFERRABLE"]
+  end if POSTGRES_DB.server_version >= 90100
+
+  specify "should support creating indexes concurrently" do
+    POSTGRES_DB.sqls.clear
+    POSTGRES_DB.add_index :test, [:name, :value], :concurrently=>true
+    POSTGRES_DB.sqls.should == ['CREATE INDEX CONCURRENTLY "test_name_value_index" ON "test" ("name", "value")'] if check_sqls
+  end
+
+  specify "should support dropping indexes only if they already exist" do
+    POSTGRES_DB.add_index :test, [:name, :value], :name=>'tnv1'
+    POSTGRES_DB.sqls.clear
+    POSTGRES_DB.drop_index :test, [:name, :value], :if_exists=>true, :name=>'tnv1'
+    POSTGRES_DB.sqls.should == ['DROP INDEX IF EXISTS "tnv1"']
+  end
+
+  specify "should support CASCADE when dropping indexes" do
+    POSTGRES_DB.add_index :test, [:name, :value], :name=>'tnv2'
+    POSTGRES_DB.sqls.clear
+    POSTGRES_DB.drop_index :test, [:name, :value], :cascade=>true, :name=>'tnv2'
+    POSTGRES_DB.sqls.should == ['DROP INDEX "tnv2" CASCADE']
+  end
+
+  specify "should support dropping indexes concurrently" do
+    POSTGRES_DB.add_index :test, [:name, :value], :name=>'tnv2'
+    POSTGRES_DB.sqls.clear
+    POSTGRES_DB.drop_index :test, [:name, :value], :concurrently=>true, :name=>'tnv2'
+    POSTGRES_DB.sqls.should == ['DROP INDEX CONCURRENTLY "tnv2"']
+  end if POSTGRES_DB.server_version >= 90200
+
   specify "#lock should lock table if inside a transaction" do
     POSTGRES_DB.transaction{@d.lock('EXCLUSIVE'); @d.insert(:name=>'a')}
   end
@@ -1188,7 +1294,7 @@ if POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG && POSTGRE
       i = 0
       @db.listen('foo2', :timeout=>0.001, :loop=>proc{i+=1; throw :stop if i > 3}){|ev, pid, payload| called = true}.should == nil
       i.should == 4
-    end unless RUBY_VERSION =~ /1.8.7|1.9.2/ && RUBY_PLATFORM =~ /mingw/ # Ruby freezes on this spec on this platform/version
+    end unless RUBY_PLATFORM =~ /mingw/ # Ruby freezes on this spec on this platform/version
   end
 end
 
@@ -1575,3 +1681,167 @@ describe 'PostgreSQL hstore handling' do
     @ds.get(h2.avals.pg_array.length).should == 1
   end
 end if POSTGRES_DB.type_supported?(:hstore)
+
+describe 'PostgreSQL json type' do
+  before(:all) do
+    Sequel.extension :pg_json
+    @db = POSTGRES_DB
+    @db.extend Sequel::Postgres::JSONDatabaseMethods
+    @ds = @db[:items]
+    @a = [1, 2, {'a'=>'b'}, 3.0]
+    @h = {'a'=>'b', '1'=>[3, 4, 5]}
+    @native = POSTGRES_DB.adapter_scheme == :postgres
+  end
+  after do
+    @db.drop_table?(:items)
+  end
+
+  specify 'insert and retrieve json values' do
+    @db.create_table!(:items){json :j}
+    @ds.insert(@h.pg_json)
+    @ds.count.should == 1
+    if @native
+      rs = @ds.all
+      v = rs.first[:j]
+      v.should_not be_a_kind_of(Hash)
+      v.to_hash.should be_a_kind_of(Hash)
+      v.should == @h
+      v.to_hash.should == @h
+      @ds.delete
+      @ds.insert(rs.first)
+      @ds.all.should == rs
+    end
+
+    @ds.delete
+    @ds.insert(@a.pg_json)
+    @ds.count.should == 1
+    if @native
+      rs = @ds.all
+      v = rs.first[:j]
+      v.should_not be_a_kind_of(Array)
+      v.to_a.should be_a_kind_of(Array)
+      v.should == @a
+      v.to_a.should == @a
+      @ds.delete
+      @ds.insert(rs.first)
+      @ds.all.should == rs
+    end
+  end
+
+  specify 'use json in bound variables' do
+    @db.create_table!(:items){json :i}
+    @ds.call(:insert, {:i=>@h.pg_json}, {:i=>:$i})
+    @ds.get(:i).should == @h
+    @ds.filter(:i.cast(String)=>:$i).call(:first, :i=>@h.pg_json).should == {:i=>@h}
+    @ds.filter(:i.cast(String)=>:$i).call(:first, :i=>{}.pg_json).should == nil
+    @ds.filter(:i.cast(String)=>:$i).call(:delete, :i=>@h.pg_json).should == 1
+
+    @ds.call(:insert, {:i=>@a.pg_json}, {:i=>:$i})
+    @ds.get(:i).should == @a
+    @ds.filter(:i.cast(String)=>:$i).call(:first, :i=>@a.pg_json).should == {:i=>@a}
+    @ds.filter(:i.cast(String)=>:$i).call(:first, :i=>[].pg_json).should == nil
+  end if POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG
+
+  specify 'with models' do
+    @db.create_table!(:items) do
+      primary_key :id
+      json :h
+    end
+    c = Class.new(Sequel::Model(@db[:items]))
+    c.plugin :typecast_on_load, :h unless @native
+    c.create(:h=>@h.pg_json).h.should == @h
+    c.create(:h=>@a.pg_json).h.should == @a
+  end
+end if POSTGRES_DB.server_version >= 90200
+
+describe 'PostgreSQL inet/cidr types' do
+  ipv6_broken = (IPAddr.new('::1'); false) rescue true
+
+  before(:all) do
+    Sequel.extension :pg_inet
+    @db = POSTGRES_DB
+    @db.extend Sequel::Postgres::InetDatabaseMethods
+    @ds = @db[:items]
+    @v4 = '127.0.0.1'
+    @v4nm = '127.0.0.0/8'
+    @v6 = '2001:4f8:3:ba:2e0:81ff:fe22:d1f1'
+    @v6nm = '2001:4f8:3:ba::/64'
+    @ipv4 = IPAddr.new(@v4)
+    @ipv4nm = IPAddr.new(@v4nm)
+    unless ipv6_broken
+      @ipv6 = IPAddr.new(@v6)
+      @ipv6nm = IPAddr.new(@v6nm)
+    end
+    @native = POSTGRES_DB.adapter_scheme == :postgres
+  end
+  after do
+    @db.drop_table?(:items)
+  end
+
+  specify 'insert and retrieve inet/cidr values' do
+    @db.create_table!(:items){inet :i; cidr :c}
+    @ds.insert(@ipv4, @ipv4nm)
+    @ds.count.should == 1
+    if @native
+      rs = @ds.all
+      rs.first[:i].should == @ipv4
+      rs.first[:c].should == @ipv4nm
+      rs.first[:i].should be_a_kind_of(IPAddr)
+      rs.first[:c].should be_a_kind_of(IPAddr)
+      @ds.delete
+      @ds.insert(rs.first)
+      @ds.all.should == rs
+    end
+
+    unless ipv6_broken
+      @ds.delete
+      @ds.insert(@ipv6, @ipv6nm)
+      @ds.count.should == 1
+      if @native
+        rs = @ds.all
+        v = rs.first[:j]
+        rs.first[:i].should == @ipv6
+        rs.first[:c].should == @ipv6nm
+        rs.first[:i].should be_a_kind_of(IPAddr)
+        rs.first[:c].should be_a_kind_of(IPAddr)
+        @ds.delete
+        @ds.insert(rs.first)
+        @ds.all.should == rs
+      end
+    end
+  end
+
+  specify 'use ipaddr in bound variables' do
+    @db.create_table!(:items){inet :i; cidr :c}
+
+    @ds.call(:insert, {:i=>@ipv4, :c=>@ipv4nm}, {:i=>:$i, :c=>:$c})
+    @ds.get(:i).should == @ipv4
+    @ds.get(:c).should == @ipv4nm
+    @ds.filter(:i=>:$i, :c=>:$c).call(:first, :i=>@ipv4, :c=>@ipv4nm).should == {:i=>@ipv4, :c=>@ipv4nm}
+    @ds.filter(:i=>:$i, :c=>:$c).call(:first, :i=>@ipv6, :c=>@ipv6nm).should == nil
+    @ds.filter(:i=>:$i, :c=>:$c).call(:delete, :i=>@ipv4, :c=>@ipv4nm).should == 1
+
+    unless ipv6_broken
+      @ds.call(:insert, {:i=>@ipv6, :c=>@ipv6nm}, {:i=>:$i, :c=>:$c})
+      @ds.get(:i).should == @ipv6
+      @ds.get(:c).should == @ipv6nm
+      @ds.filter(:i=>:$i, :c=>:$c).call(:first, :i=>@ipv6, :c=>@ipv6nm).should == {:i=>@ipv6, :c=>@ipv6nm}
+      @ds.filter(:i=>:$i, :c=>:$c).call(:first, :i=>@ipv4, :c=>@ipv4nm).should == nil
+      @ds.filter(:i=>:$i, :c=>:$c).call(:delete, :i=>@ipv6, :c=>@ipv6nm).should == 1
+    end
+  end if POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG
+
+  specify 'with models' do
+    @db.create_table!(:items) do
+      primary_key :id
+      inet :i
+      cidr :c
+    end
+    c = Class.new(Sequel::Model(@db[:items]))
+    c.plugin :typecast_on_load, :i, :c unless @native
+    c.create(:i=>@v4, :c=>@v4nm).values.values_at(:i, :c).should == [@ipv4, @ipv4nm]
+    unless ipv6_broken
+      c.create(:i=>@ipv6, :c=>@ipv6nm).values.values_at(:i, :c).should == [@ipv6, @ipv6nm]
+    end
+  end
+end if POSTGRES_DB.server_version >= 90200