sequel 4.3.0 → 4.4.0

data/lib/sequel/plugins/json_serializer.rb

@@ -293,7 +293,7 @@ module Sequel
 
       module DatasetMethods
         # Return a JSON string representing an array of all objects in
-        # this dataset.  Takes the same options as the the instance
+        # this dataset.  Takes the same options as the instance
         # method, and passes them to every instance.  Additionally,
         # respects the following options:
         #

data/lib/sequel/plugins/many_through_many.rb

@@ -138,6 +138,13 @@ module Sequel
           h.each{|k, v| cached_set(k, v)}
           h
         end
+
+        def filter_by_associations_add_conditions_dataset_filter(ds)
+          reverse_edges.each{|t| ds = ds.join(t[:table], Array(t[:left]).zip(Array(t[:right])), :table_alias=>t[:alias], :qualify=>:deep)}
+          ft = final_reverse_edge
+          ds.join(ft[:table],  Array(ft[:left]).zip(Array(ft[:right])), :table_alias=>ft[:alias], :qualify=>:deep).
+            select(*qualify(ft[:alias], Array(self[:left_key])))
+        end
       end
 
       module ClassMethods
@@ -275,13 +282,14 @@ module Sequel
             ref.right_primary_key_methods
           end
 
-          exp = association_filter_key_expression(ref.qualify(last_alias, Array(ref.final_edge[:left])), meths, obj)
-          if exp == SQL::Constants::FALSE
-            association_filter_handle_inversion(op, exp, Array(lpks))
-          else
-            ds = ds.where(exp).exclude(SQL::BooleanExpression.from_value_pairs(ds.opts[:select].zip([]), :OR))
-            association_filter_handle_inversion(op, SQL::BooleanExpression.from_value_pairs(lpks=>ds), Array(lpks))
+          expr = association_filter_key_expression(ref.qualify(last_alias, Array(ref.final_edge[:left])), meths, obj)
+          unless expr == SQL::Constants::FALSE
+            ds = ds.where(expr).exclude(SQL::BooleanExpression.from_value_pairs(ds.opts[:select].zip([]), :OR))
+            expr = SQL::BooleanExpression.from_value_pairs(lpks=>ds)
+            expr = add_association_filter_conditions(ref, obj, expr)
           end
+
+          association_filter_handle_inversion(op, expr, Array(lpks))
         end
       end
     end

data/lib/sequel/plugins/pg_array_associations.rb

@@ -67,6 +67,9 @@ module Sequel
     # This plugin should work on all supported PostgreSQL versions, except
     # the remove_all modification method for many_to_pg_array associations, which
     # requires the array_remove method added in PostgreSQL 9.3.
+    #
+    # This plugin requires that the underlying database have the pg_array
+    # extension loaded.
     module PgArrayAssociations
       # The AssociationReflection subclass for many_to_pg_array associations.
       class ManyToPgArrayAssociationReflection < Sequel::Model::Associations::AssociationReflection
@@ -109,6 +112,15 @@ module Sequel
     
         private
     
+        def filter_by_associations_add_conditions_dataset_filter(ds)
+          key = qualify(associated_class.table_name, self[:key])
+          ds.select{unnest(key)}.exclude(key=>nil)
+        end
+        
+        def filter_by_associations_conditions_key
+          qualify(self[:model].table_name, primary_key)
+        end
+
         # Only consider an association as a reciprocal if it has matching keys
         # and primary keys.
         def reciprocal_association?(assoc_reflect)
@@ -162,8 +174,22 @@ module Sequel
           cached_fetch(:primary_key_method){primary_key}
         end
 
+        def filter_by_associations_conditions_expression(obj)
+          ds = filter_by_associations_conditions_dataset.where(filter_by_associations_conditions_subquery_conditions(obj))
+          Sequel.function(:coalesce, Sequel.pg_array(filter_by_associations_conditions_key).overlaps(ds), Sequel::SQL::Constants::FALSE)
+        end
+
         private
     
+        def filter_by_associations_add_conditions_dataset_filter(ds)
+          pk = qualify(associated_class.table_name, primary_key)
+          ds.select{array_agg(pk)}.exclude(pk=>nil)
+        end
+        
+        def filter_by_associations_conditions_key
+          qualify(self[:model].table_name, self[:key])
+        end
+
         # Only consider an association as a reciprocal if it has matching keys
         # and primary keys.
         def reciprocal_association?(assoc_reflect)
@@ -426,6 +452,7 @@ module Sequel
             Sequel.expr(pk=>obj.select{Sequel.pg_array_op(ref.qualify(obj.model.table_name, ref[:key_column])).unnest})
           end
           expr = Sequel::SQL::Constants::FALSE unless expr
+          expr = add_association_filter_conditions(ref, obj, expr)
           association_filter_handle_inversion(op, expr, [pk])
         end
 
@@ -445,6 +472,7 @@ module Sequel
             Sequel.function(:coalesce, Sequel.pg_array_op(key).overlaps(obj.select{array_agg(ref.qualify(obj.model.table_name, ref.primary_key))}), Sequel::SQL::Constants::FALSE)
           end
           expr = Sequel::SQL::Constants::FALSE unless expr
+          expr = add_association_filter_conditions(ref, obj, expr)
           association_filter_handle_inversion(op, expr, [key])
         end
       end

data/lib/sequel/plugins/rcte_tree.rb

@@ -304,7 +304,7 @@ module Sequel
             level = associations
             no_cache_level = level - 1
             associations = {}
-            base_case = base_case.select_more(SQL::AliasedExpression.new(0, la))
+            base_case = base_case.select_more(SQL::AliasedExpression.new(Sequel.cast(0, Integer), la))
             recursive_case = recursive_case.select_more(SQL::AliasedExpression.new(SQL::QualifiedIdentifier.new(t, la) + 1, la)).filter(SQL::QualifiedIdentifier.new(t, la) < level - 1)
           end
           table_alias = model.dataset.schema_and_table(model.table_name)[1].to_sym

data/lib/sequel/plugins/serialization.rb

@@ -56,6 +56,17 @@ module Sequel
     #   user = User.create
     #   user.permissions = { :global => 'read-only' }
     #   user.save
+    #
+    # Note that if you mutate serialized column values without reassigning them,
+    # those changes won't be picked up by <tt>Model#save_changes</tt> or
+    # <tt>Model#update</tt>.  Example:
+    #
+    #   user = User[1]
+    #   user.permissions[:global] = 'foo'
+    #   user.save_changes # Will not pick up changes to permissions
+    #
+    # You can use the +serialization_modification_detection+ plugin to pick
+    # up such changes.
     module Serialization
       # The default serializers supported by the serialization module.
       # Use register_format to add serializers to this hash.

data/lib/sequel/plugins/single_table_inheritance.rb

@@ -126,7 +126,7 @@ module Sequel
         attr_reader :sti_key_array
 
         # A hash/proc with class keys and column value values, mapping
-        # the the class to a particular value given to the sti_key column.
+        # the class to a particular value given to the sti_key column.
         # Used to set the column value when creating objects, and for the
         # filter when retrieving objects in subclasses.
         attr_reader :sti_key_map

data/lib/sequel/plugins/table_select.rb

@@ -0,0 +1,41 @@
+module Sequel
+  module Plugins
+    # The table_select plugin changes the default selection for a
+    # model dataset from <tt>*</tt> to <tt>table.*</tt>.
+    # This makes it so that if you join the model's dataset to
+    # other tables, columns in the other tables do not appear
+    # in the result sets (and possibly overwrite columns in the
+    # current model with the same name).
+    #
+    # Usage:
+    #
+    #   # Make all model subclasses select table.*
+    #   Sequel::Model.plugin :table_select
+    #
+    #   # Make the Album class select albums.*
+    #   Album.plugin :table_select
+    module TableSelect
+      # Modify the current model's dataset selection, if the model
+      # has a dataset.
+      def self.configure(model)
+        model.instance_eval do
+          self.dataset = dataset if @dataset
+        end
+      end
+
+      module ClassMethods
+        private
+
+        # If the underlying dataset selects from a single table and
+        # has no explicit selection, select table.* from that table.
+        def convert_input_dataset(ds)
+          ds = super
+          if !ds.opts[:select] && (from = ds.opts[:from]) && from.length == 1 && !ds.opts[:join]
+            ds = ds.select_all(ds.first_source)
+          end
+          ds
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/tree.rb

@@ -93,7 +93,7 @@ module Sequel
         #   subchild1.ancestors # => [child1, root]
         def descendants
           nodes = children.dup
-          nodes.each{|child| nodes.concat(child.descendants)}
+          children.each{|child| nodes.concat(child.descendants)}
           nodes 
         end
 

data/lib/sequel/sql.rb

@@ -1477,7 +1477,7 @@ module Sequel
       end
 
       # Create a new +Subscript+ appending the given subscript(s)
-      # the the current array of subscripts.
+      # to the current array of subscripts.
       #
       #   :a.sql_subscript(2) # a[2]
       #   :a.sql_subscript(2) | 1 # a[2, 1]
@@ -1582,7 +1582,7 @@ module Sequel
     #   # Literal Strings
     #   ds.filter{{a=>`some SQL`}} # SELECT * FROM t WHERE (a = some SQL)
     #
-    # For a more detailed explanation, see the {Virtual Rows guide}[link:files/doc/virtual_rows_rdoc.html].
+    # For a more detailed explanation, see the {Virtual Rows guide}[rdoc-ref:doc/virtual_rows.rdoc].
     class VirtualRow < BasicObject
       WILDCARD = LiteralString.new('*').freeze
       QUESTION_MARK = LiteralString.new('?').freeze

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 = 3
+  MINOR = 4
   # 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

@@ -21,13 +21,34 @@ describe "An Oracle database" do
       Integer :id
       String :cat_name, :size => 50
     end
+
+    DB.create_table!(:notes) do
+      Integer :id
+      String :title, :size => 50
+      String :content, :text => true
+    end
     @d = DB[:items]
   end
   after do
     @d.delete
   end
   after(:all) do
-    DB.drop_table?(:items, :books, :categories)
+    DB.drop_table?(:items, :books, :categories, :notes)
+  end
+
+  specify "should allow limit and offset with clob columns" do
+    notes = []
+    notes << {:id => 1, :title => 'abc', :content => 'zyx'}
+    notes << {:id => 2, :title => 'def', :content => 'wvu'}
+    notes << {:id => 3, :title => 'ghi', :content => 'tsr'}
+    notes << {:id => 4, :title => 'jkl', :content => 'qpo'}
+    notes << {:id => 5, :title => 'mno', :content => 'nml'}
+    DB[:notes].multi_insert(notes)
+
+    DB[:notes].sort_by{|x| x[:id]}.should == notes
+    rows = DB[:notes].limit(3, 0).all
+    rows.length.should == 3
+    rows.all?{|v| notes.should include(v)}
   end
 
   specify "should provide disconnect functionality" do

data/spec/adapters/postgres_spec.rb

@@ -1763,8 +1763,7 @@ describe 'PostgreSQL array handling' do
     @db = DB
     @db.extension :pg_array
     @ds = @db[:items]
-    @native = DB.adapter_scheme == :postgres
-    @jdbc = DB.adapter_scheme == :jdbc
+    @native = DB.adapter_scheme == :postgres || DB.adapter_scheme == :jdbc
     @tp = lambda{@db.schema(:items).map{|a| a.last[:type]}}
   end
   after do
@@ -1783,10 +1782,8 @@ describe 'PostgreSQL array handling' do
     @ds.insert(Sequel.pg_array([1], :int2), Sequel.pg_array([nil, 2], :int4), Sequel.pg_array([3, nil], :int8), Sequel.pg_array([4, nil, 4.5], :real), Sequel.pg_array([5, nil, 5.5], "double precision"))
     @ds.count.should == 1
     rs = @ds.all
-    if @jdbc || @native
-      rs.should == [{:i2=>[1], :i4=>[nil, 2], :i8=>[3, nil], :r=>[4.0, nil, 4.5], :dp=>[5.0, nil, 5.5]}]
-    end
     if @native
+      rs.should == [{:i2=>[1], :i4=>[nil, 2], :i8=>[3, nil], :r=>[4.0, nil, 4.5], :dp=>[5.0, nil, 5.5]}]
       rs.first.values.each{|v| v.should_not be_a_kind_of(Array)}
       rs.first.values.each{|v| v.to_a.should be_a_kind_of(Array)}
       @ds.delete
@@ -1798,10 +1795,8 @@ describe 'PostgreSQL array handling' do
     @ds.insert(Sequel.pg_array([[1], [2]], :int2), Sequel.pg_array([[nil, 2], [3, 4]], :int4), Sequel.pg_array([[3, nil], [nil, nil]], :int8), Sequel.pg_array([[4, nil], [nil, 4.5]], :real), Sequel.pg_array([[5, nil], [nil, 5.5]], "double precision"))
 
     rs = @ds.all
-    if @jdbc || @native
-      rs.should == [{:i2=>[[1], [2]], :i4=>[[nil, 2], [3, 4]], :i8=>[[3, nil], [nil, nil]], :r=>[[4, nil], [nil, 4.5]], :dp=>[[5, nil], [nil, 5.5]]}]
-    end
     if @native
+      rs.should == [{:i2=>[[1], [2]], :i4=>[[nil, 2], [3, 4]], :i8=>[[3, nil], [nil, nil]], :r=>[[4, nil], [nil, 4.5]], :dp=>[[5, nil], [nil, 5.5]]}]
       rs.first.values.each{|v| v.should_not be_a_kind_of(Array)}
       rs.first.values.each{|v| v.to_a.should be_a_kind_of(Array)}
       @ds.delete
@@ -1818,10 +1813,8 @@ describe 'PostgreSQL array handling' do
     @ds.insert(Sequel.pg_array([BigDecimal.new('1.000000000000000000001'), nil, BigDecimal.new('1')], :numeric))
     @ds.count.should == 1
     rs = @ds.all
-    if @jdbc || @native
-      rs.should == [{:n=>[BigDecimal.new('1.000000000000000000001'), nil, BigDecimal.new('1')]}]
-    end
     if @native
+      rs.should == [{:n=>[BigDecimal.new('1.000000000000000000001'), nil, BigDecimal.new('1')]}]
       rs.first.values.each{|v| v.should_not be_a_kind_of(Array)}
       rs.first.values.each{|v| v.to_a.should be_a_kind_of(Array)}
       @ds.delete
@@ -1832,10 +1825,8 @@ describe 'PostgreSQL array handling' do
     @ds.delete
     @ds.insert(Sequel.pg_array([[BigDecimal.new('1.0000000000000000000000000000001'), nil], [nil, BigDecimal.new('1')]], :numeric))
     rs = @ds.all
-    if @jdbc || @native
-      rs.should == [{:n=>[[BigDecimal.new('1.0000000000000000000000000000001'), nil], [nil, BigDecimal.new('1')]]}]
-    end
     if @native
+      rs.should == [{:n=>[[BigDecimal.new('1.0000000000000000000000000000001'), nil], [nil, BigDecimal.new('1')]]}]
       rs.first.values.each{|v| v.should_not be_a_kind_of(Array)}
       rs.first.values.each{|v| v.to_a.should be_a_kind_of(Array)}
       @ds.delete
@@ -1854,10 +1845,8 @@ describe 'PostgreSQL array handling' do
     @ds.insert(Sequel.pg_array(['a', nil, 'NULL', 'b"\'c'], 'char(4)'), Sequel.pg_array(['a', nil, 'NULL', 'b"\'c'], :varchar), Sequel.pg_array(['a', nil, 'NULL', 'b"\'c'], :text))
     @ds.count.should == 1
     rs = @ds.all
-    if @jdbc || @native
-      rs.should == [{:c=>['a   ', nil, 'NULL', 'b"\'c'], :vc=>['a', nil, 'NULL', 'b"\'c'], :t=>['a', nil, 'NULL', 'b"\'c']}]
-    end
     if @native
+      rs.should == [{:c=>['a   ', nil, 'NULL', 'b"\'c'], :vc=>['a', nil, 'NULL', 'b"\'c'], :t=>['a', nil, 'NULL', 'b"\'c']}]
       rs.first.values.each{|v| v.should_not be_a_kind_of(Array)}
       rs.first.values.each{|v| v.to_a.should be_a_kind_of(Array)}
       @ds.delete
@@ -1868,10 +1857,8 @@ describe 'PostgreSQL array handling' do
     @ds.delete
     @ds.insert(Sequel.pg_array([[['a'], [nil]], [['NULL'], ['b"\'c']]], 'char(4)'), Sequel.pg_array([[['a'], ['']], [['NULL'], ['b"\'c']]], :varchar), Sequel.pg_array([[['a'], [nil]], [['NULL'], ['b"\'c']]], :text))
     rs = @ds.all
-    if @jdbc || @native
-      rs.should == [{:c=>[[['a   '], [nil]], [['NULL'], ['b"\'c']]], :vc=>[[['a'], ['']], [['NULL'], ['b"\'c']]], :t=>[[['a'], [nil]], [['NULL'], ['b"\'c']]]}]
-    end
     if @native
+      rs.should == [{:c=>[[['a   '], [nil]], [['NULL'], ['b"\'c']]], :vc=>[[['a'], ['']], [['NULL'], ['b"\'c']]], :t=>[[['a'], [nil]], [['NULL'], ['b"\'c']]]}]
       rs.first.values.each{|v| v.should_not be_a_kind_of(Array)}
       rs.first.values.each{|v| v.to_a.should be_a_kind_of(Array)}
       @ds.delete
@@ -1897,10 +1884,8 @@ describe 'PostgreSQL array handling' do
     @ds.insert(Sequel.pg_array([true, false], :bool), Sequel.pg_array([d, nil], :date), Sequel.pg_array([t, nil], :time), Sequel.pg_array([ts, nil], :timestamp), Sequel.pg_array([ts, nil], :timestamptz))
     @ds.count.should == 1
     rs = @ds.all
-    if @jdbc || @native
-      rs.should == [{:b=>[true, false], :d=>[d, nil], :t=>[t, nil], :ts=>[ts, nil], :tstz=>[ts, nil]}]
-    end
     if @native
+      rs.should == [{:b=>[true, false], :d=>[d, nil], :t=>[t, nil], :ts=>[ts, nil], :tstz=>[ts, nil]}]
       rs.first.values.each{|v| v.should_not be_a_kind_of(Array)}
       rs.first.values.each{|v| v.to_a.should be_a_kind_of(Array)}
       @ds.delete
@@ -1978,7 +1963,7 @@ describe 'PostgreSQL array handling' do
       @ds.insert(rs.first)
       @ds.all.should == rs
     end
-  end unless DB.adapter_scheme == :jdbc
+  end
 
   specify 'use arrays in bound variables' do
     @db.create_table!(:items) do
@@ -2137,7 +2122,7 @@ describe 'PostgreSQL hstore handling' do
     @db.extension :pg_array, :pg_hstore
     @ds = @db[:items]
     @h = {'a'=>'b', 'c'=>nil, 'd'=>'NULL', 'e'=>'\\\\" \\\' ,=>'}
-    @native = DB.adapter_scheme == :postgres
+    @native = DB.adapter_scheme == :postgres || DB.adapter_scheme == :jdbc
   end
   after do
     @db.drop_table?(:items)
@@ -2152,6 +2137,7 @@ describe 'PostgreSQL hstore handling' do
     if @native
       rs = @ds.all
       v = rs.first[:h]
+      v.should == @h
       v.should_not be_a_kind_of(Hash)
       v.to_hash.should be_a_kind_of(Hash)
       v.to_hash.should == @h
@@ -2387,7 +2373,7 @@ describe 'PostgreSQL json type' do
     @ds = @db[:items]
     @a = [1, 2, {'a'=>'b'}, 3.0]
     @h = {'a'=>'b', '1'=>[3, 4, 5]}
-    @native = DB.adapter_scheme == :postgres
+    @native = DB.adapter_scheme == :postgres || DB.adapter_scheme == :jdbc
   end
   after do
     @db.drop_table?(:items)
@@ -2519,7 +2505,7 @@ describe 'PostgreSQL json type' do
     j = Sequel.pg_json([{'a'=>1, 'b'=>'c'}, {'a'=>2, 'b'=>'d'}]).op
     @db.from(j.populate_set(Sequel.cast(nil, :items))).select_order_map(:a).should == [1, 2]
     @db.from(j.populate_set(Sequel.cast(nil, :items))).select_order_map(:b).should == %w'c d'
-  end if DB.server_version >= 90300 && DB.adapter_scheme == :postgres
+  end if DB.server_version >= 90300 && (DB.adapter_scheme == :postgres || DB.adapter_scheme == :jdbc)
 end if DB.server_version >= 90200
 
 describe 'PostgreSQL inet/cidr types' do
@@ -2539,7 +2525,7 @@ describe 'PostgreSQL inet/cidr types' do
       @ipv6 = IPAddr.new(@v6)
       @ipv6nm = IPAddr.new(@v6nm)
     end
-    @native = DB.adapter_scheme == :postgres
+    @native = DB.adapter_scheme == :postgres || DB.adapter_scheme == :jdbc
   end
   after do
     @db.drop_table?(:items)
@@ -2650,7 +2636,7 @@ describe 'PostgreSQL range types' do
     @r.each{|k, v| @ra[k] = Sequel.pg_array([v], @map[k])}
     @r.each{|k, v| @pgr[k] = Sequel.pg_range(v)}
     @r.each{|k, v| @pgra[k] = Sequel.pg_array([Sequel.pg_range(v)], @map[k])}
-    @native = DB.adapter_scheme == :postgres
+    @native = DB.adapter_scheme == :postgres || DB.adapter_scheme == :jdbc
   end
   after do
     @db.drop_table?(:items)
@@ -2732,14 +2718,12 @@ describe 'PostgreSQL range types' do
     v.delete(:id)
     v.should == @r
 
-    unless @db.adapter_scheme == :jdbc
-      @db.create_table!(:items){primary_key :id; column :i4, 'int4range[]'; column :i8, 'int8range[]'; column :n, 'numrange[]'; column :d, 'daterange[]'; column :t, 'tsrange[]'; column :tz, 'tstzrange[]'}
-      c = Class.new(Sequel::Model(@db[:items]))
-      c.plugin :pg_typecast_on_load, :i4, :i8, :n, :d, :t, :tz unless @native
-      v = c.create(@ra).values
-      v.delete(:id)
-      v.each{|k,v1| v1.should == @ra[k].to_a}
-    end
+    @db.create_table!(:items){primary_key :id; column :i4, 'int4range[]'; column :i8, 'int8range[]'; column :n, 'numrange[]'; column :d, 'daterange[]'; column :t, 'tsrange[]'; column :tz, 'tstzrange[]'}
+    c = Class.new(Sequel::Model(@db[:items]))
+    c.plugin :pg_typecast_on_load, :i4, :i8, :n, :d, :t, :tz unless @native
+    v = c.create(@ra).values
+    v.delete(:id)
+    v.each{|k,v1| v1.should == @ra[k].to_a}
   end
 
   specify 'operations/functions with pg_range_ops' do
@@ -2817,7 +2801,7 @@ describe 'PostgreSQL interval types' do
     @db = DB
     @db.extension :pg_array, :pg_interval
     @ds = @db[:items]
-    @native = DB.adapter_scheme == :postgres
+    @native = DB.adapter_scheme == :postgres || DB.adapter_scheme == :jdbc
   end
   after(:all) do
     Sequel::Postgres::PG_TYPES.delete(1186)
@@ -2829,7 +2813,8 @@ describe 'PostgreSQL interval types' do
   specify 'insert and retrieve interval values' do
     @db.create_table!(:items){interval :i}
     [
-      ['0', '00:00:00',  0, [[:seconds, 0]]],
+      ['0', '00:00:00',  0, []],
+      ['1', '00:00:01',  1, [[:seconds, 1]]],
       ['1 microsecond', '00:00:00.000001',  0.000001, [[:seconds, 0.000001]]],
       ['1 millisecond', '00:00:00.001',  0.001, [[:seconds, 0.001]]],
       ['1 second', '00:00:01', 1, [[:seconds, 1]]],
@@ -2853,7 +2838,7 @@ describe 'PostgreSQL interval types' do
         rs = @ds.all
         rs.first[:i].is_a?(ActiveSupport::Duration).should be_true
         rs.first[:i].should == ActiveSupport::Duration.new(value, parts)
-        rs.first[:i].parts.sort_by{|k,v| k.to_s}.should == parts.sort_by{|k,v| k.to_s}
+        rs.first[:i].parts.sort_by{|k,v| k.to_s}.reject{|k,v| v == 0}.should == parts.sort_by{|k,v| k.to_s}
         @ds.delete
         @ds.insert(rs.first)
         @ds.all.should == rs
@@ -2935,7 +2920,7 @@ describe 'PostgreSQL row-valued/composite types' do
     @db.register_row_type(Sequel.qualify(:public, :person))
     @db.register_row_type(:public__company)
 
-    @native = DB.adapter_scheme == :postgres
+    @native = DB.adapter_scheme == :postgres || DB.adapter_scheme == :jdbc
   end
   after(:all) do
     @db.drop_table?(:company, :person, :address)
@@ -2980,7 +2965,7 @@ describe 'PostgreSQL row-valued/composite types' do
       @db.drop_table(:domain_check)
       @db << "DROP DOMAIN positive_integer"
     end
-  end if DB.adapter_scheme == :postgres
+  end if DB.adapter_scheme == :postgres || DB.adapter_scheme == :jdbc
 
   specify 'insert and retrieve arrays of row types' do
     @ds = @db[:company]
@@ -3170,12 +3155,10 @@ describe 'PostgreSQL row-valued/composite types' do
 
       Company.plugin :pg_typecast_on_load, :employees unless @native
       e = Person.new(:id=>1, :address=>a)
-      unless @db.adapter_scheme == :jdbc
-        o = Company.create(:id=>1, :employees=>[{:id=>1, :address=>{:street=>'123 Sesame St', :city=>'Somewhere', :zip=>'12345'}}])
-        o.employees.should == [e]
-        o = Company.create(:id=>1, :employees=>[e])
-        o.employees.should == [e]
-      end
+      o = Company.create(:id=>1, :employees=>[{:id=>1, :address=>{:street=>'123 Sesame St', :city=>'Somewhere', :zip=>'12345'}}])
+      o.employees.should == [e]
+      o = Company.create(:id=>1, :employees=>[e])
+      o.employees.should == [e]
     end
   end
 end