sequel 3.36.1 → 3.37.0

data/lib/sequel/plugins/identity_map.rb

@@ -58,7 +58,7 @@ module Sequel
             left_key_alias = opts[:left_key_alias] ||= opts.default_associated_key_alias
             opts[:eager_loader] = lambda do |eo|
               return el.call(eo) unless model.identity_map
-              h = eo[:key_hash][left_pk]
+              h = eo[:id_map]
               eo[:rows].each{|object| object.associations[name] = []}
               r = uses_rcks ? rcks.zip(opts.right_primary_keys) : [[right, opts.right_primary_key]]
               l = uses_lcks ? [[lcks.map{|k| SQL::QualifiedIdentifier.new(join_table, k)}, h.keys]] : [[left, h.keys]]
@@ -107,7 +107,7 @@ module Sequel
             left_key_alias = opts[:left_key_alias]
             opts[:eager_loader] = lambda do |eo|
               return el.call(eo) unless model.identity_map
-              h = eo[:key_hash][left_pk]
+              h = eo[:id_map]
               eo[:rows].each{|object| object.associations[name] = []}
               ds = opts.associated_class 
               opts.reverse_edges.each{|t| ds = ds.join(t[:table], Array(t[:left]).zip(Array(t[:right])), :table_alias=>t[:alias])}

data/lib/sequel/plugins/list.rb

@@ -98,6 +98,7 @@ module Sequel
           unless send(position_field)
             send("#{position_field}=", list_dataset.max(position_field).to_i+1)
           end
+          super
         end
 
         # Find the last position in the list containing this instance.

data/lib/sequel/plugins/many_through_many.rb

@@ -53,7 +53,7 @@ module Sequel
           self[:uses_left_composite_keys] ? (0...self[:through].first[:left].length).map{|i| :"x_foreign_key_#{i}_x"} : :x_foreign_key_x
         end
 
-        %w'associated_key_table eager_loading_predicate_key edges final_edge final_reverse_edge reverse_edges'.each do |meth|
+        %w'associated_key_table predicate_key edges final_edge final_reverse_edge reverse_edges'.each do |meth|
           class_eval(<<-END, __FILE__, __LINE__+1)
             def #{meth}
               cached_fetch(:#{meth}){calculate_edges[:#{meth}]}
@@ -87,7 +87,7 @@ module Sequel
 
         # Transform the :through option into a list of edges and reverse edges to use to join tables when loading the association.
         def calculate_edges
-          es = [{:left_table=>self[:model].table_name, :left_key=>self[:left_primary_key]}]
+          es = [{:left_table=>self[:model].table_name, :left_key=>self[:left_primary_key_column]}]
           self[:through].each do |t|
             es.last.merge!(:right_key=>t[:left], :right_table=>t[:table], :join_type=>t[:join_type]||self[:graph_join_type], :conditions=>(t[:conditions]||[]).to_a, :block=>t[:block])
             es.last[:only_conditions] = t[:only_conditions] if t.include?(:only_conditions)
@@ -109,7 +109,7 @@ module Sequel
                :final_reverse_edge=>final_reverse_edge,
                :edges=>edges,
                :reverse_edges=>reverse_edges,
-               :eager_loading_predicate_key=>qualify(final_reverse_alias, edges.first[:right]),
+               :predicate_key=>qualify(final_reverse_alias, edges.first[:right]),
                :associated_key_table=>final_reverse_edge[:alias],
           }
           h.each{|k, v| cached_set(k, v)}
@@ -123,24 +123,17 @@ module Sequel
         # * through - The tables and keys to join between the current table and the associated table.
         #   Must be an array, with elements that are either 3 element arrays, or hashes with keys :table, :left, and :right.
         #   The required entries in the array/hash are:
-        #   * :table (first array element) - The name of the table to join.
-        #   * :left (middle array element) - The key joining the table to the previous table. Can use an
-        #     array of symbols for a composite key association.
-        #   * :right (last array element) - The key joining the table to the next table. Can use an
-        #     array of symbols for a composite key association.
+        #   :table (first array element) :: The name of the table to join.
+        #   :left (middle array element) :: The key joining the table to the previous table. Can use an
+        #                                   array of symbols for a composite key association.
+        #   :right (last array element) :: The key joining the table to the next table. Can use an
+        #                                  array of symbols for a composite key association.
         #   If a hash is provided, the following keys are respected when using eager_graph:
-        #   * :block - A proc to use as the block argument to join.
-        #   * :conditions - Extra conditions to add to the JOIN ON clause.  Must be a hash or array of two pairs.
-        #   * :join_type - The join type to use for the join, defaults to :left_outer.
-        #   * :only_conditions - Conditions to use for the join instead of the ones specified by the keys.
-        # * opts - The options for the associaion.  Takes the same options as associate, and supports these additional options:
-        #   * :left_primary_key - column in current table that the first :left option in
-        #     through points to, as a symbol. Defaults to primary key of current table. Can use an
-        #     array of symbols for a composite key association.
-        #   * :right_primary_key - column in associated table that the final :right option in 
-        #     through points to, as a symbol. Defaults to primary key of the associated table.  Can use an
-        #     array of symbols for a composite key association.
-        #   * :uniq - Adds a after_load callback that makes the array of objects unique.
+        #   :block :: A proc to use as the block argument to join.
+        #   :conditions :: Extra conditions to add to the JOIN ON clause.  Must be a hash or array of two pairs.
+        #   :join_type :: The join type to use for the join, defaults to :left_outer.
+        #   :only_conditions :: Conditions to use for the join instead of the ones specified by the keys.
+        # * opts - The options for the associaion.  Takes the same options as many_to_many.
         def many_through_many(name, through, opts={}, &block)
           associate(:many_through_many, name, opts.merge(through.is_a?(Hash) ? through : {:through=>through}), &block)
         end
@@ -171,23 +164,26 @@ module Sequel
           uses_lcks = opts[:uses_left_composite_keys] = left_key.is_a?(Array)
           left_keys = Array(left_key)
           left_pk = (opts[:left_primary_key] ||= self.primary_key)
+          opts[:eager_loader_key] = left_pk unless opts.has_key?(:eager_loader_key)
           left_pks = opts[:left_primary_keys] = Array(left_pk)
+          lpkc = opts[:left_primary_key_column] ||= left_pk
+          lpkcs = opts[:left_primary_key_columns] ||= Array(lpkc)
           opts[:dataset] ||= lambda do
             ds = opts.associated_class
-            opts.reverse_edges.each{|t| ds = ds.join(t[:table], Array(t[:left]).zip(Array(t[:right])), :table_alias=>t[:alias])}
+            opts.reverse_edges.each{|t| ds = ds.join(t[:table], Array(t[:left]).zip(Array(t[:right])), :table_alias=>t[:alias], :qualify=>:deep)}
             ft = opts.final_reverse_edge
-            ds.join(ft[:table],  Array(ft[:left]).zip(Array(ft[:right])) + left_keys.zip(left_pks.map{|k| send(k)}), :table_alias=>ft[:alias])
+            ds.join(ft[:table],  Array(ft[:left]).zip(Array(ft[:right])) + opts.predicate_keys.zip(left_pks.map{|k| send(k)}), :table_alias=>ft[:alias], :qualify=>:deep)
           end
 
           left_key_alias = opts[:left_key_alias] ||= opts.default_associated_key_alias
           opts[:eager_loader] ||= lambda do |eo|
-            h = eo[:key_hash][left_pk]
+            h = eo[:id_map]
             rows = eo[:rows]
             rows.each{|object| object.associations[name] = []}
             ds = opts.associated_class 
-            opts.reverse_edges.each{|t| ds = ds.join(t[:table], Array(t[:left]).zip(Array(t[:right])), :table_alias=>t[:alias])}
+            opts.reverse_edges.each{|t| ds = ds.join(t[:table], Array(t[:left]).zip(Array(t[:right])), :table_alias=>t[:alias], :qualify=>:deep)}
             ft = opts.final_reverse_edge
-            ds = ds.join(ft[:table], Array(ft[:left]).zip(Array(ft[:right])) + [[opts.eager_loading_predicate_key, h.keys]], :table_alias=>ft[:alias])
+            ds = ds.join(ft[:table], Array(ft[:left]).zip(Array(ft[:right])) + [[opts.predicate_key, h.keys]], :table_alias=>ft[:alias], :qualify=>:deep)
             ds = model.eager_loading_dataset(opts, ds, nil, eo[:associations], eo)
             case opts.eager_limit_strategy
             when :window_function
@@ -198,7 +194,7 @@ module Sequel
               ds = apply_correlated_subquery_eager_limit_strategy(ds, opts) do |xds|
                 dsa = ds.send(:dataset_alias, 2)
                 opts.reverse_edges.each{|t| xds = xds.join(t[:table], Array(t[:left]).zip(Array(t[:right])), :table_alias=>t[:alias])}
-                xds.join(ft[:table], Array(ft[:left]).zip(Array(ft[:right])) + left_keys.map{|k| [k, SQL::QualifiedIdentifier.new(ft[:table], k)]}, :table_alias=>dsa)
+                xds.join(ft[:table], Array(ft[:left]).zip(Array(ft[:right])) + left_keys.map{|k| [k, SQL::QualifiedIdentifier.new(ft[:table], k)]}, :table_alias=>dsa, :qualify=>:deep)
               end
             end
             ds.all do |assoc_record|
@@ -227,11 +223,11 @@ module Sequel
             ds = eo[:self]
             iq = eo[:implicit_qualifier]
             opts.edges.each do |t|
-              ds = ds.graph(t[:table], t.fetch(:only_conditions, (Array(t[:right]).zip(Array(t[:left])) + t[:conditions])), :select=>false, :table_alias=>ds.unused_table_alias(t[:table]), :join_type=>t[:join_type], :implicit_qualifier=>iq, &t[:block])
+              ds = ds.graph(t[:table], t.fetch(:only_conditions, (Array(t[:right]).zip(Array(t[:left])) + t[:conditions])), :select=>false, :table_alias=>ds.unused_table_alias(t[:table]), :join_type=>t[:join_type], :qualify=>:deep, :implicit_qualifier=>iq, &t[:block])
               iq = nil
             end
             fe = opts.final_edge
-            ds.graph(opts.associated_class, use_only_conditions ? only_conditions : (Array(opts.right_primary_key).zip(Array(fe[:left])) + conditions), :select=>select, :table_alias=>eo[:table_alias], :join_type=>join_type, &graph_block)
+            ds.graph(opts.associated_class, use_only_conditions ? only_conditions : (Array(opts.right_primary_key).zip(Array(fe[:left])) + conditions), :select=>select, :table_alias=>eo[:table_alias], :qualify=>:deep, :join_type=>join_type, &graph_block)
           end
 
           def_association_dataset_methods(opts)
@@ -243,22 +239,27 @@ module Sequel
 
         # Use a subquery to filter rows to those related to the given associated object
         def many_through_many_association_filter_expression(op, ref, obj)
-          lpks = ref[:left_primary_keys]
+          lpks = ref[:left_primary_key_columns]
           lpks = lpks.first if lpks.length == 1
           lpks = ref.qualify(model.table_name, lpks)
           edges = ref.edges
           first, rest = edges.first, edges[1..-1]
           last = edges.last
           ds = model.db[first[:table]].select(*Array(ref.qualify(first[:table], first[:right])))
-          rest.each{|e| ds = ds.join(e[:table], e.fetch(:only_conditions, (Array(e[:right]).zip(Array(e[:left])) + e[:conditions])), :table_alias=>ds.unused_table_alias(e[:table]), &e[:block])}
+          rest.each{|e| ds = ds.join(e[:table], e.fetch(:only_conditions, (Array(e[:right]).zip(Array(e[:left])) + e[:conditions])), :table_alias=>ds.unused_table_alias(e[:table]), :qualify=>:deep, &e[:block])}
           last_alias = if rest.empty?
             first[:table]
           else
             last_join = ds.opts[:join].last
             last_join.table_alias || last_join.table
           end
-          meths = ref.right_primary_keys
-          meths = ref.qualify(obj.model.table_name, meths) if obj.is_a?(Sequel::Dataset)
+
+          meths = if obj.is_a?(Sequel::Dataset)
+            ref.qualify(obj.model.table_name, ref.right_primary_keys)
+          else
+            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))

data/lib/sequel/plugins/nested_attributes.rb

@@ -83,8 +83,11 @@ module Sequel
         
         # Allow nested attributes to be set for the given associations.  Options:
         # * :destroy - Allow destruction of nested records.
-        # * :fields - If provided, should be an Array.  Restricts the fields allowed to be
-        #   modified through the association_attributes= method to the specific fields given.
+        # * :fields - If provided, should be an Array or proc. If it is an array,
+        #   restricts the fields allowed to be modified through the
+        #   association_attributes= method to the specific fields given. If it is
+        #   a proc, it will be called with the associated object and should return an
+        #   array of the allowable fields.
         # * :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
@@ -168,7 +171,11 @@ module Sequel
 
             # 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))}
+            if reflection[:type] == :many_to_one 
+              before_save_hook{send(reflection.setter_method, obj.save(:validate=>false))}
+            else
+              after_save_hook{send(reflection.setter_method, obj)}
+            end
           end
           obj
         end
@@ -207,6 +214,7 @@ module Sequel
         # specific :fields if configured.
         def nested_attributes_set_attributes(reflection, obj, attributes)
           if fields = reflection[:nested_attributes][:fields]
+            fields = fields.call(obj) if fields.respond_to?(:call)
             obj.set_only(attributes, fields)
           else
             obj.set(attributes)

data/lib/sequel/plugins/rcte_tree.rb

@@ -160,7 +160,7 @@ module Sequel
         end
         a[:after_load] ||= aal
         a[:eager_loader] ||= proc do |eo|
-          id_map = eo[:key_hash][key]
+          id_map = eo[:id_map]
           parent_map = {}
           children_map = {}
           eo[:rows].each do |obj|
@@ -259,7 +259,7 @@ module Sequel
         end
         d[:after_load] = dal
         d[:eager_loader] ||= proc do |eo|
-          id_map = eo[:key_hash][prkey]
+          id_map = eo[:id_map]
           associations = eo[:associations]
           parent_map = {}
           children_map = {}

data/lib/sequel/plugins/schema.rb

@@ -66,7 +66,7 @@ module Sequel
         # test code or simple examples.
         def set_schema(name = nil, &block)
           set_dataset(db[name]) if name
-          @schema = Sequel::Schema::Generator.new(db, &block)
+          @schema = db.create_table_generator(&block)
           set_primary_key(@schema.primary_key_name) if @schema.primary_key_name
         end
         

data/lib/sequel/sql.rb

@@ -67,7 +67,7 @@ module Sequel
       # such methods are the values of the object's attributes.
       def self.attr_reader(*args)
         super
-        comparison_attrs.concat args
+        comparison_attrs.concat(args)
       end
 
       # All attributes used for equality and hash methods.
@@ -166,12 +166,12 @@ module Sequel
       # Custom expressions that may have different syntax on different databases
       CUSTOM_EXPRESSIONS = [:extract]
 
-      # An array of args for this object
-      attr_reader :args
-
       # The operator symbol for this object
       attr_reader :op
       
+      # An array of args for this object
+      attr_reader :args
+
       # Set the operator symbol and arguments for this object to the ones given.
       # Convert all args that are hashes or arrays of two element arrays to +BooleanExpressions+,
       # other than the second arg for an IN/NOT IN operator.
@@ -1075,12 +1075,12 @@ module Sequel
 
     # Represents an SQL function call.
     class Function < GenericExpression
-      # The array of arguments to pass to the function (may be blank)
-      attr_reader :args
-
       # The SQL function to call
       attr_reader :f
       
+      # The array of arguments to pass to the function (may be blank)
+      attr_reader :args
+
       # Set the functions and args to the given arguments
       def initialize(f, *args)
         @f, @args = f, args
@@ -1173,16 +1173,16 @@ module Sequel
     # required for the prepared statement support and for database-specific
     # literalization.
     class PlaceholderLiteralString < GenericExpression
+      # The literal string containing placeholders.  This can also be an array
+      # of strings, where each arg in args goes between the string elements. 
+      attr_reader :str
+
       # The arguments that will be subsituted into the placeholders.
       # Either an array of unnamed placeholders (which will be substituted in
       # order for ? characters), or a hash of named placeholders (which will be
       # substituted for :key phrases).
       attr_reader :args
 
-      # The literal string containing placeholders.  This can also be an array
-      # of strings, where each arg in args goes between the string elements. 
-      attr_reader :str
-
       # Whether to surround the expression with parantheses
       attr_reader :parens
 
@@ -1257,12 +1257,12 @@ module Sequel
     class QualifiedIdentifier < GenericExpression
       include QualifyingMethods
 
-      # The column/table referenced
-      attr_reader :column
-
       # The table/schema qualifying the reference
       attr_reader :table
 
+      # The column/table referenced
+      attr_reader :column
+
       # Set the table and column to the given arguments
       def initialize(table, column)
         @table, @column = table, column

data/lib/sequel/version.rb

@@ -3,10 +3,10 @@ module Sequel
   MAJOR = 3
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 36
+  MINOR = 37
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
-  TINY  = 1
+  TINY  = 0
   
   # The version of Sequel you are using, as a string (e.g. "2.11.0")
   VERSION = [MAJOR, MINOR, TINY].join('.')

data/spec/adapters/mysql_spec.rb

@@ -1224,3 +1224,28 @@ if MYSQL_DB.adapter_scheme == :mysql
     end
   end
 end
+
+if MYSQL_DB.adapter_scheme == :mysql2
+  describe "Mysql2 streaming" do
+    before(:all) do
+      MYSQL_DB.create_table!(:a){Integer :a}
+      MYSQL_DB.transaction do
+        1000.times do |i|
+          MYSQL_DB[:a].insert(i)
+        end
+      end
+      @ds = MYSQL_DB[:a].stream.order(:a)
+    end
+    after(:all) do
+      MYSQL_DB.drop_table?(:a)
+    end
+
+    specify "should correctly stream results" do
+      @ds.map(:a).should == (0...1000).to_a
+    end
+
+    specify "should correctly handle early returning when streaming results" do
+      3.times{@ds.each{|r| break r[:a]}.should == 0}
+    end
+  end if false
+end

data/spec/adapters/postgres_spec.rb

@@ -158,6 +158,43 @@ describe "A PostgreSQL dataset" do
     @d.lock('EXCLUSIVE'){@d.insert(:name=>'a')}
   end
 
+  specify "should support exclusion constraints when creating or altering tables" do
+    begin
+      @db = POSTGRES_DB
+      @db.create_table!(:atest){Integer :t; exclude [[:t.desc(:nulls=>:last), '=']], :using=>:btree, :where=>proc{t > 0}}
+      @db[:atest].insert(1)
+      @db[:atest].insert(2)
+      proc{@db[:atest].insert(2)}.should raise_error(Sequel::DatabaseError)
+
+      @db.create_table!(:atest){Integer :t}
+      @db.alter_table(:atest){add_exclusion_constraint [[:t, '=']], :using=>:btree, :name=>'atest_ex'}
+      @db[:atest].insert(1)
+      @db[:atest].insert(2)
+      proc{@db[:atest].insert(2)}.should raise_error(Sequel::DatabaseError)
+      @db.alter_table(:atest){drop_constraint 'atest_ex'}
+    ensure
+      @db.drop_table?(:atest)
+    end
+  end if POSTGRES_DB.server_version >= 90000
+
+  specify "should support adding foreign key constarints that are not yet valid, and validating them later" do
+    begin
+      @db = POSTGRES_DB
+      @db.create_table!(:atest){primary_key :id; Integer :fk}
+      @db[:atest].insert(1, 5)
+      @db.alter_table(:atest){add_foreign_key [:fk], :atest, :not_valid=>true, :name=>:atest_fk}
+      @db[:atest].insert(2, 1)
+      proc{@db[:atest].insert(3, 4)}.should raise_error(Sequel::DatabaseError)
+
+      proc{@db.alter_table(:atest){validate_constraint :atest_fk}}.should raise_error(Sequel::DatabaseError)
+      @db[:atest].where(:id=>1).update(:fk=>2)
+      @db.alter_table(:atest){validate_constraint :atest_fk}
+      proc{@db.alter_table(:atest){validate_constraint :atest_fk}}.should_not raise_error
+    ensure
+      @db.drop_table?(:atest)
+    end
+  end if POSTGRES_DB.server_version >= 90200
+
   specify "should support :using when altering a column's type" do
     begin
       @db = POSTGRES_DB
@@ -1349,11 +1386,12 @@ end
 
 describe 'PostgreSQL array handling' do
   before(:all) do
-    Sequel.extension :pg_array
     @db = POSTGRES_DB
-    @db.extend Sequel::Postgres::PGArray::DatabaseMethods
+    @db.extension :pg_array
     @ds = @db[:items]
     @native = POSTGRES_DB.adapter_scheme == :postgres
+    @jdbc = POSTGRES_DB.adapter_scheme == :jdbc
+    @tp = lambda{@db.schema(:items).map{|a| a.last[:type]}}
   end
   after do
     @db.drop_table?(:items)
@@ -1367,21 +1405,29 @@ describe 'PostgreSQL array handling' do
       column :r, 'real[]'
       column :dp, 'double precision[]'
     end
+    @tp.call.should == [:integer_array, :integer_array, :bigint_array, :float_array, :float_array]
     @ds.insert([1].pg_array(:int2), [nil, 2].pg_array(:int4), [3, nil].pg_array(:int8), [4, nil, 4.5].pg_array(:real), [5, nil, 5.5].pg_array("double precision"))
     @ds.count.should == 1
-    if @native
-      rs = @ds.all
+    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.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
       @ds.insert(rs.first)
       @ds.all.should == rs
+    end
 
-      @ds.delete
-      @ds.insert([[1], [2]].pg_array(:int2), [[nil, 2], [3, 4]].pg_array(:int4), [[3, nil], [nil, nil]].pg_array(:int8), [[4, nil], [nil, 4.5]].pg_array(:real), [[5, nil], [nil, 5.5]].pg_array("double precision"))
-      rs = @ds.all
+    @ds.delete
+    @ds.insert([[1], [2]].pg_array(:int2), [[nil, 2], [3, 4]].pg_array(:int4), [[3, nil], [nil, nil]].pg_array(:int8), [[4, nil], [nil, 4.5]].pg_array(:real), [[5, nil], [nil, 5.5]].pg_array("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.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
@@ -1394,21 +1440,28 @@ describe 'PostgreSQL array handling' do
     @db.create_table!(:items) do
       column :n, 'numeric[]'
     end
+    @tp.call.should == [:decimal_array]
     @ds.insert([BigDecimal.new('1.000000000000000000001'), nil, BigDecimal.new('1')].pg_array(:numeric))
     @ds.count.should == 1
-    if @native
-      rs = @ds.all
+    rs = @ds.all
+    if @jdbc || @native
       rs.should == [{:n=>[BigDecimal.new('1.000000000000000000001'), nil, BigDecimal.new('1')]}]
+    end
+    if @native
       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
       @ds.insert(rs.first)
       @ds.all.should == rs
+    end
 
-      @ds.delete
-      @ds.insert([[BigDecimal.new('1.0000000000000000000000000000001'), nil], [nil, BigDecimal.new('1')]].pg_array(:numeric))
-      rs = @ds.all
+    @ds.delete
+    @ds.insert([[BigDecimal.new('1.0000000000000000000000000000001'), nil], [nil, BigDecimal.new('1')]].pg_array(:numeric))
+    rs = @ds.all
+    if @jdbc || @native
       rs.should == [{:n=>[[BigDecimal.new('1.0000000000000000000000000000001'), nil], [nil, BigDecimal.new('1')]]}]
+    end
+    if @native
       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
@@ -1423,21 +1476,75 @@ describe 'PostgreSQL array handling' do
       column :vc, 'varchar[]'
       column :t, 'text[]'
     end
+    @tp.call.should == [:string_array, :string_array, :string_array]
     @ds.insert(['a', nil, 'NULL', 'b"\'c'].pg_array('char(4)'), ['a', nil, 'NULL', 'b"\'c'].pg_array(:varchar), ['a', nil, 'NULL', 'b"\'c'].pg_array(:text))
     @ds.count.should == 1
-    if @native
-      rs = @ds.all
+    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.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
       @ds.insert(rs.first)
       @ds.all.should == rs
+    end
 
+    @ds.delete
+    @ds.insert([[['a'], [nil]], [['NULL'], ['b"\'c']]].pg_array('char(4)'), [[['a'], ['']], [['NULL'], ['b"\'c']]].pg_array(:varchar), [[['a'], [nil]], [['NULL'], ['b"\'c']]].pg_array(: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.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
-      @ds.insert([[['a'], [nil]], [['NULL'], ['b"\'c']]].pg_array('char(4)'), [[['a'], ['']], [['NULL'], ['b"\'c']]].pg_array(:varchar), [[['a'], [nil]], [['NULL'], ['b"\'c']]].pg_array(:text))
+      @ds.insert(rs.first)
+      @ds.all.should == rs
+    end
+  end
+
+  specify 'insert and retrieve arrays of other types' do
+    @db.create_table!(:items) do
+      column :b, 'bool[]'
+      column :d, 'date[]'
+      column :t, 'time[]'
+      column :ts, 'timestamp[]'
+      column :tstz, 'timestamptz[]'
+    end
+    @tp.call.should == [:boolean_array, :date_array, :time_array, :datetime_array, :datetime_timezone_array]
+
+    d = Date.today
+    t = Sequel::SQLTime.create(10, 20, 30)
+    ts = Time.local(2011, 1, 2, 3, 4, 5)
+
+    @ds.insert([true, false].pg_array(:bool), [d, nil].pg_array(:date), [t, nil].pg_array(:time), [ts, nil].pg_array(:timestamp), [ts, nil].pg_array(: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.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
+      @ds.insert(rs.first)
+      @ds.all.should == rs
+    end
+
+    @db.create_table!(:items) do
+      column :ba, 'bytea[]'
+      column :tz, 'timetz[]'
+      column :o, 'oid[]'
+    end
+    @tp.call.should == [:blob_array, :time_timezone_array, :integer_array]
+    @ds.insert( [Sequel.blob("a\0"), nil].pg_array(:bytea), [t, nil].pg_array(:timetz), [1, 2, 3].pg_array(:oid))
+    @ds.count.should == 1
+    if @native
       rs = @ds.all
-      rs.should == [{:c=>[[['a   '], [nil]], [['NULL'], ['b"\'c']]], :vc=>[[['a'], ['']], [['NULL'], ['b"\'c']]], :t=>[[['a'], [nil]], [['NULL'], ['b"\'c']]]}]
+      rs.should == [{:ba=>[Sequel.blob("a\0"), nil], :tz=>[t, nil], :o=>[1, 2, 3]}]
       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
@@ -1463,6 +1570,42 @@ describe 'PostgreSQL array handling' do
     @ds.get(:i).should == a
     @ds.filter(:i=>:$i).call(:first, :i=>a).should == {:i=>a}
     @ds.filter(:i=>:$i).call(:first, :i=>['', nil, nil, 'a']).should == nil
+
+    @db.create_table!(:items) do
+      column :i, 'date[]'
+    end
+    a = [Date.today]
+    @ds.call(:insert, {:i=>:$i}, :i=>a.pg_array('date'))
+    @ds.get(:i).should == a
+    @ds.filter(:i=>:$i).call(:first, :i=>a).should == {:i=>a}
+    @ds.filter(:i=>:$i).call(:first, :i=>[Date.today-1].pg_array('date')).should == nil
+
+    @db.create_table!(:items) do
+      column :i, 'timestamp[]'
+    end
+    a = [Time.local(2011, 1, 2, 3, 4, 5)]
+    @ds.call(:insert, {:i=>:$i}, :i=>a.pg_array('timestamp'))
+    @ds.get(:i).should == a
+    @ds.filter(:i=>:$i).call(:first, :i=>a).should == {:i=>a}
+    @ds.filter(:i=>:$i).call(:first, :i=>[a.first-1].pg_array('timestamp')).should == nil
+
+    @db.create_table!(:items) do
+      column :i, 'boolean[]'
+    end
+    a = [true, false]
+    @ds.call(:insert, {:i=>:$i}, :i=>a.pg_array('boolean'))
+    @ds.get(:i).should == a
+    @ds.filter(:i=>:$i).call(:first, :i=>a).should == {:i=>a}
+    @ds.filter(:i=>:$i).call(:first, :i=>[false, true].pg_array('boolean')).should == nil
+
+    @db.create_table!(:items) do
+      column :i, 'bytea[]'
+    end
+    a = [Sequel.blob("a\0'\"")]
+    @ds.call(:insert, {:i=>:$i}, :i=>a.pg_array('bytea'))
+    @ds.get(:i).should == a
+    @ds.filter(:i=>:$i).call(:first, :i=>a).should == {:i=>a}
+    @ds.filter(:i=>:$i).call(:first, :i=>[Sequel.blob("b\0")].pg_array('bytea')).should == nil
   end if POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG
 
   specify 'with models' do
@@ -1541,9 +1684,8 @@ end
 
 describe 'PostgreSQL hstore handling' do
   before(:all) do
-    Sequel.extension :pg_hstore
     @db = POSTGRES_DB
-    @db.extend Sequel::Postgres::HStore::DatabaseMethods
+    @db.extension :pg_hstore
     @ds = @db[:items]
     @h = {'a'=>'b', 'c'=>nil, 'd'=>'NULL', 'e'=>'\\\\" \\\' ,=>'}
     @native = POSTGRES_DB.adapter_scheme == :postgres
@@ -1586,20 +1728,104 @@ describe 'PostgreSQL hstore handling' do
     @ds.filter(:i=>:$i).call(:first, :i=>{}).should == nil
   end if POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG
 
-  specify 'with models' do
+  specify 'with models and associations' do
     @db.create_table!(:items) do
       primary_key :id
       column :h, :hstore
     end
-    c = Class.new(Sequel::Model(@db[:items]))
+    c = Class.new(Sequel::Model(@db[:items])) do
+      def self.name
+        'Item'
+      end
+      unrestrict_primary_key
+      def item_id
+        h['item_id'].to_i if h
+      end
+      def left_item_id
+        h['left_item_id'].to_i if h
+      end
+    end
+    Sequel.extension :pg_hstore_ops
+    c.plugin :many_through_many
     c.plugin :typecast_on_load, :h unless @native
-    c.create(:h=>@h.hstore).h.should == @h
+
+    h = {'item_id'=>"2", 'left_item_id'=>"1"}
+    o2 = c.create(:id=>2)
+    o = c.create(:id=>1, :h=>h)
+    o.h.should == h
+
+    c.many_to_one :item, :class=>c, :key_column=>Sequel.cast(:h.hstore['item_id'], Integer)
+    c.one_to_many :items, :class=>c, :key=>Sequel.cast(:h.hstore['item_id'], Integer), :key_method=>:item_id
+    c.many_to_many :related_items, :class=>c, :join_table=>:items___i, :left_key=>Sequel.cast(:h.hstore['left_item_id'], Integer), :right_key=>Sequel.cast(:h.hstore['item_id'], Integer)
+
+    c.many_to_one :other_item, :class=>c, :key=>:id, :primary_key_method=>:item_id, :primary_key=>Sequel.cast(:h.hstore['item_id'], Integer)
+    c.one_to_many :other_items, :class=>c, :primary_key=>:item_id, :key=>:id, :primary_key_column=>Sequel.cast(:h.hstore['item_id'], Integer)
+    c.many_to_many :other_related_items, :class=>c, :join_table=>:items___i, :left_key=>:id, :right_key=>:id,
+      :left_primary_key_column=>Sequel.cast(:h.hstore['left_item_id'], Integer),
+      :left_primary_key=>:left_item_id,
+      :right_primary_key=>Sequel.cast(:h.hstore['left_item_id'], Integer),
+      :right_primary_key_method=>:left_item_id
+
+    c.many_through_many :mtm_items, [
+        [:items, Sequel.cast(:h.hstore['item_id'], Integer), Sequel.cast(:h.hstore['left_item_id'], Integer)],
+        [:items, Sequel.cast(:h.hstore['left_item_id'], Integer), Sequel.cast(:h.hstore['left_item_id'], Integer)]
+      ],
+      :class=>c,
+      :left_primary_key_column=>Sequel.cast(:h.hstore['item_id'], Integer),
+      :left_primary_key=>:item_id,
+      :right_primary_key=>Sequel.cast(:h.hstore['left_item_id'], Integer),
+      :right_primary_key_method=>:left_item_id
+
+    # Lazily Loading
+    o.item.should == o2
+    o2.items.should == [o]
+    o.related_items.should == [o2]
+    o2.other_item.should == o
+    o.other_items.should == [o2]
+    o.other_related_items.should == [o]
+    o.mtm_items.should == [o]
+
+    # Eager Loading via eager
+    os = c.eager(:item, :related_items, :other_items, :other_related_items, :mtm_items).where(:id=>1).all.first
+    os.item.should == o2
+    os.related_items.should == [o2]
+    os.other_items.should == [o2]
+    os.other_related_items.should == [o]
+    os.mtm_items.should == [o]
+    os = c.eager(:items, :other_item).where(:id=>2).all.first
+    os.items.should == [o]
+    os.other_item.should == o
+
+    # Eager Loading via eager_graph
+    c.eager_graph(:item).where(:items__id=>1).all.first.item.should == o2
+    c.eager_graph(:items).where(:items__id=>2).all.first.items.should == [o]
+    c.eager_graph(:related_items).where(:items__id=>1).all.first.related_items.should == [o2]
+    c.eager_graph(:other_item).where(:items__id=>2).all.first.other_item.should == o
+    c.eager_graph(:other_items).where(:items__id=>1).all.first.other_items.should == [o2]
+    c.eager_graph(:other_related_items).where(:items__id=>1).all.first.other_related_items.should == [o]
+    c.eager_graph(:mtm_items).where(:items__id=>1).all.first.mtm_items.should == [o]
+
+    # Filter By Associations - Model Instances
+    c.filter(:item=>o2).all.should == [o]
+    c.filter(:items=>o).all.should == [o2]
+    c.filter(:related_items=>o2).all.should == [o]
+    c.filter(:other_item=>o).all.should == [o2]
+    c.filter(:other_items=>o2).all.should == [o]
+    c.filter(:other_related_items=>o).all.should == [o]
+    c.filter(:mtm_items=>o).all.should == [o]
+   
+    # Filter By Associations - Model Datasets
+    c.filter(:item=>c.filter(:id=>o2.id)).all.should == [o]
+    c.filter(:items=>c.filter(:id=>o.id)).all.should == [o2]
+    c.filter(:related_items=>c.filter(:id=>o2.id)).all.should == [o]
+    c.filter(:other_item=>c.filter(:id=>o.id)).all.should == [o2]
+    c.filter(:other_items=>c.filter(:id=>o2.id)).all.should == [o]
+    c.filter(:other_related_items=>c.filter(:id=>o.id)).all.should == [o]
+    c.filter(:mtm_items=>c.filter(:id=>o.id)).all.should == [o]
   end
 
   specify 'operations/functions with pg_hstore_ops' do
-    Sequel.extension :pg_hstore_ops
-    Sequel.extension :pg_array
-    Sequel.extension :pg_array_ops
+    Sequel.extension :pg_hstore_ops, :pg_array, :pg_array_ops
     @db.create_table!(:items){hstore :h1; hstore :h2; hstore :h3; String :t}
     @ds.insert({'a'=>'b', 'c'=>nil}.hstore, {'a'=>'b'}.hstore, {'d'=>'e'}.hstore)
     h1 = :h1.hstore
@@ -1684,9 +1910,8 @@ 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
+    @db.extension :pg_array, :pg_json
     @ds = @db[:items]
     @a = [1, 2, {'a'=>'b'}, 3.0]
     @h = {'a'=>'b', '1'=>[3, 4, 5]}
@@ -1728,6 +1953,24 @@ describe 'PostgreSQL json type' do
     end
   end
 
+  specify 'insert and retrieve json[] values' do
+    @db.create_table!(:items){column :j, 'json[]'}
+    j = [{'a'=>1}.pg_json, ['b', 2].pg_json].pg_array
+    @ds.insert(j)
+    @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 == j
+      v.to_a.should == j
+      @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})
@@ -1740,6 +1983,13 @@ describe 'PostgreSQL json type' do
     @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
+
+    @db.create_table!(:items){column :i, 'json[]'}
+    j = [{'a'=>1}.pg_json, ['b', 2].pg_json].pg_array(:text)
+    @ds.call(:insert, {:i=>j}, {:i=>:$i})
+    @ds.get(:i).should == j
+    @ds.filter(:i.cast('text[]')=>:$i).call(:first, :i=>j).should == {:i=>j}
+    @ds.filter(:i.cast('text[]')=>:$i).call(:first, :i=>[].pg_array).should == nil
   end if POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG
 
   specify 'with models' do
@@ -1758,9 +2008,8 @@ 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
+    @db.extension :pg_array, :pg_inet
     @ds = @db[:items]
     @v4 = '127.0.0.1'
     @v4nm = '127.0.0.0/8'
@@ -1811,6 +2060,24 @@ describe 'PostgreSQL inet/cidr types' do
     end
   end
 
+  specify 'insert and retrieve inet/cidr/macaddr array values' do
+    @db.create_table!(:items){column :i, 'inet[]'; column :c, 'cidr[]'; column :m, 'macaddr[]'}
+    @ds.insert([@ipv4].pg_array('inet'), [@ipv4nm].pg_array('cidr'), ['12:34:56:78:90:ab'].pg_array('macaddr'))
+    @ds.count.should == 1
+    if @native
+      rs = @ds.all
+      rs.first.values.all?{|c| c.is_a?(Sequel::Postgres::PGArray)}.should be_true
+      rs.first[:i].first.should == @ipv4
+      rs.first[:c].first.should == @ipv4nm
+      rs.first[:m].first.should == '12:34:56:78:90:ab'
+      rs.first[:i].first.should be_a_kind_of(IPAddr)
+      rs.first[:c].first.should be_a_kind_of(IPAddr)
+      @ds.delete
+      @ds.insert(rs.first)
+      @ds.all.should == rs
+    end
+  end
+
   specify 'use ipaddr in bound variables' do
     @db.create_table!(:items){inet :i; cidr :c}
 
@@ -1829,6 +2096,12 @@ describe 'PostgreSQL inet/cidr types' do
       @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
+
+    @db.create_table!(:items){column :i, 'inet[]'; column :c, 'cidr[]'; column :m, 'macaddr[]'}
+    @ds.call(:insert, {:i=>[@ipv4], :c=>[@ipv4nm], :m=>['12:34:56:78:90:ab']}, {:i=>:$i, :c=>:$c, :m=>:$m})
+    @ds.filter(:i=>:$i, :c=>:$c, :m=>:$m).call(:first, :i=>[@ipv4], :c=>[@ipv4nm], :m=>['12:34:56:78:90:ab']).should == {:i=>[@ipv4], :c=>[@ipv4nm], :m=>['12:34:56:78:90:ab']}
+    @ds.filter(:i=>:$i, :c=>:$c, :m=>:$m).call(:first, :i=>[], :c=>[], :m=>[]).should == nil
+    @ds.filter(:i=>:$i, :c=>:$c, :m=>:$m).call(:delete, :i=>[@ipv4], :c=>[@ipv4nm], :m=>['12:34:56:78:90:ab']).should == 1
   end if POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG
 
   specify 'with models' do
@@ -1844,4 +2117,275 @@ describe 'PostgreSQL inet/cidr types' do
       c.create(:i=>@ipv6, :c=>@ipv6nm).values.values_at(:i, :c).should == [@ipv6, @ipv6nm]
     end
   end
+end
+
+describe 'PostgreSQL range types' do
+  before(:all) do
+    @db = POSTGRES_DB
+    @db.extension :pg_array, :pg_range
+    @ds = @db[:items]
+    @map = {:i4=>'int4range', :i8=>'int8range', :n=>'numrange', :d=>'daterange', :t=>'tsrange', :tz=>'tstzrange'}
+    @r = {:i4=>1...2, :i8=>2...3, :n=>BigDecimal.new('1.0')..BigDecimal.new('2.0'), :d=>Date.today...(Date.today+1), :t=>Time.local(2011, 1)..Time.local(2011, 2), :tz=>Time.local(2011, 1)..Time.local(2011, 2)}
+    @ra = {}
+    @pgr = {}
+    @pgra = {}
+    @r.each{|k, v| @ra[k] = [v].pg_array(@map[k])}
+    @r.each{|k, v| @pgr[k] = v.pg_range}
+    @r.each{|k, v| @pgra[k] = [v.pg_range].pg_array(@map[k])}
+    @native = POSTGRES_DB.adapter_scheme == :postgres
+  end
+  after do
+    @db.drop_table?(:items)
+  end
+
+  specify 'insert and retrieve range type values' do
+    @db.create_table!(:items){int4range :i4; int8range :i8; numrange :n; daterange :d; tsrange :t; tstzrange :tz}
+    [@r, @pgr].each do |input|
+      h = {}
+      input.each{|k, v| h[k] = Sequel.cast(v, @map[k])}
+      @ds.insert(h)
+      @ds.count.should == 1
+      if @native
+        rs = @ds.all
+        rs.first.each do |k, v|
+          v.should_not be_a_kind_of(Range)
+          v.to_range.should be_a_kind_of(Range)
+          v.should == @r[k]
+          v.to_range.should == @r[k]
+        end
+        @ds.delete
+        @ds.insert(rs.first)
+        @ds.all.should == rs
+      end
+      @ds.delete
+    end
+  end
+
+  specify 'insert and retrieve arrays of range type values' do
+    @db.create_table!(:items){column :i4, 'int4range[]'; column :i8, 'int8range[]'; column :n, 'numrange[]'; column :d, 'daterange[]'; column :t, 'tsrange[]'; column :tz, 'tstzrange[]'}
+    [@ra, @pgra].each do |input|
+      @ds.insert(input)
+      @ds.count.should == 1
+      if @native
+        rs = @ds.all
+        rs.first.each do |k, v|
+          v.should_not be_a_kind_of(Array)
+          v.to_a.should be_a_kind_of(Array)
+          v.first.should_not be_a_kind_of(Range)
+          v.first.to_range.should be_a_kind_of(Range)
+          v.should == @ra[k].to_a
+          v.first.should == @r[k]
+        end
+        @ds.delete
+        @ds.insert(rs.first)
+        @ds.all.should == rs
+      end
+      @ds.delete
+    end
+  end
+
+  specify 'use range types in bound variables' do
+    @db.create_table!(:items){int4range :i4; int8range :i8; numrange :n; daterange :d; tsrange :t; tstzrange :tz}
+    h = {}
+    @r.keys.each{|k| h[k] = :"$#{k}"}
+    r2 = {}
+    @r.each{|k, v| r2[k] = Range.new(v.begin, v.end+2)}
+    @ds.call(:insert, @r, h)
+    @ds.first.should == @r
+    @ds.filter(h).call(:first, @r).should == @r
+    @ds.filter(h).call(:first, @pgr).should == @r
+    @ds.filter(h).call(:first, r2).should == nil
+    @ds.filter(h).call(:delete, @r).should == 1
+
+    @db.create_table!(:items){column :i4, 'int4range[]'; column :i8, 'int8range[]'; column :n, 'numrange[]'; column :d, 'daterange[]'; column :t, 'tsrange[]'; column :tz, 'tstzrange[]'}
+    @r.each{|k, v| r2[k] = [Range.new(v.begin, v.end+2)]}
+    @ds.call(:insert, @ra, h)
+    @ds.filter(h).call(:first, @ra).each{|k, v| v.should == @ra[k].to_a}
+    @ds.filter(h).call(:first, @pgra).each{|k, v| v.should == @ra[k].to_a}
+    @ds.filter(h).call(:first, r2).should == nil
+    @ds.filter(h).call(:delete, @ra).should == 1
+  end if POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG
+
+  specify 'with models' do
+    @db.create_table!(:items){primary_key :id; int4range :i4; int8range :i8; numrange :n; daterange :d; tsrange :t; tstzrange :tz}
+    c = Class.new(Sequel::Model(@db[:items]))
+    c.plugin :typecast_on_load, :i4, :i8, :n, :d, :t, :tz unless @native
+    v = c.create(@r).values
+    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 :typecast_on_load, :i4, :i8, :n, :d, :t, :tz unless @native
+      v = c.create(@ra).values
+      v.delete(:id)
+      v.each{|k,v| v.should == @ra[k].to_a}
+    end
+  end
+
+  specify 'operations/functions with pg_range_ops' do
+    Sequel.extension :pg_range_ops
+
+    @db.get((1..5).pg_range(:int4range).op.contains(2..4)).should be_true
+    @db.get((1..5).pg_range(:int4range).op.contains(3..6)).should be_false
+    @db.get((1..5).pg_range(:int4range).op.contains(0..6)).should be_false
+
+    @db.get((1..5).pg_range(:int4range).op.contained_by(0..6)).should be_true
+    @db.get((1..5).pg_range(:int4range).op.contained_by(3..6)).should be_false
+    @db.get((1..5).pg_range(:int4range).op.contained_by(2..4)).should be_false
+
+    @db.get((1..5).pg_range(:int4range).op.overlaps(5..6)).should be_true
+    @db.get((1...5).pg_range(:int4range).op.overlaps(5..6)).should be_false
+    
+    @db.get((1..5).pg_range(:int4range).op.left_of(6..10)).should be_true
+    @db.get((1..5).pg_range(:int4range).op.left_of(5..10)).should be_false
+    @db.get((1..5).pg_range(:int4range).op.left_of(-1..0)).should be_false
+    @db.get((1..5).pg_range(:int4range).op.left_of(-1..3)).should be_false
+
+    @db.get((1..5).pg_range(:int4range).op.right_of(6..10)).should be_false
+    @db.get((1..5).pg_range(:int4range).op.right_of(5..10)).should be_false
+    @db.get((1..5).pg_range(:int4range).op.right_of(-1..0)).should be_true
+    @db.get((1..5).pg_range(:int4range).op.right_of(-1..3)).should be_false
+
+    @db.get((1..5).pg_range(:int4range).op.starts_before(6..10)).should be_true
+    @db.get((1..5).pg_range(:int4range).op.starts_before(5..10)).should be_true
+    @db.get((1..5).pg_range(:int4range).op.starts_before(-1..0)).should be_false
+    @db.get((1..5).pg_range(:int4range).op.starts_before(-1..3)).should be_false
+
+    @db.get((1..5).pg_range(:int4range).op.ends_after(6..10)).should be_false
+    @db.get((1..5).pg_range(:int4range).op.ends_after(5..10)).should be_false
+    @db.get((1..5).pg_range(:int4range).op.ends_after(-1..0)).should be_true
+    @db.get((1..5).pg_range(:int4range).op.ends_after(-1..3)).should be_true
+
+    @db.get((1..5).pg_range(:int4range).op.adjacent_to(6..10)).should be_true
+    @db.get((1...5).pg_range(:int4range).op.adjacent_to(6..10)).should be_false
+
+    @db.get(((1..5).pg_range(:int4range).op + (6..10)).adjacent_to(6..10)).should be_false
+    @db.get(((1..5).pg_range(:int4range).op + (6..10)).adjacent_to(11..20)).should be_true
+
+    @db.get(((1..5).pg_range(:int4range).op * (2..6)).adjacent_to(6..10)).should be_true
+    @db.get(((1..4).pg_range(:int4range).op * (2..6)).adjacent_to(6..10)).should be_false
+
+    @db.get(((1..5).pg_range(:int4range).op - (2..6)).adjacent_to(2..10)).should be_true
+    @db.get(((0..4).pg_range(:int4range).op - (3..6)).adjacent_to(4..10)).should be_false
+
+    @db.get((0..4).pg_range(:int4range).op.lower).should == 0
+    @db.get((0..4).pg_range(:int4range).op.upper).should == 5
+
+    @db.get((0..4).pg_range(:int4range).op.isempty).should be_false
+    @db.get(Sequel::Postgres::PGRange.empty(:int4range).op.isempty).should be_true
+
+    @db.get((1..5).pg_range(:numrange).op.lower_inc).should be_true
+    @db.get(Sequel::Postgres::PGRange.new(1, 5, :exclude_begin=>true, :db_type=>:numrange).op.lower_inc).should be_false
+
+    @db.get((1..5).pg_range(:numrange).op.upper_inc).should be_true
+    @db.get((1...5).pg_range(:numrange).op.upper_inc).should be_false
+
+    @db.get(Sequel::Postgres::PGRange.new(1, 5, :db_type=>:int4range).op.lower_inf).should be_false
+    @db.get(Sequel::Postgres::PGRange.new(nil, 5, :db_type=>:int4range).op.lower_inf).should be_true
+
+    @db.get(Sequel::Postgres::PGRange.new(1, 5, :db_type=>:int4range).op.upper_inf).should be_false
+    @db.get(Sequel::Postgres::PGRange.new(1, nil, :db_type=>:int4range).op.upper_inf).should be_true
+  end
 end if POSTGRES_DB.server_version >= 90200
+
+describe 'PostgreSQL interval types' do
+  before(:all) do
+    @db = POSTGRES_DB
+    @db.extension :pg_array, :pg_interval
+    @ds = @db[:items]
+    @native = POSTGRES_DB.adapter_scheme == :postgres
+  end
+  after(:all) do
+    Sequel::Postgres::PG_TYPES.delete(1186)
+  end
+  after do
+    @db.drop_table?(:items)
+  end
+
+  specify 'insert and retrieve interval values' do
+    @db.create_table!(:items){interval :i}
+    [
+      ['0', '00:00:00',  0, [[:seconds, 0]]],
+      ['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]]],
+      ['1 minute', '00:01:00', 60, [[:seconds, 60]]],
+      ['1 hour', '01:00:00', 3600, [[:seconds, 3600]]],
+      ['1 day', '1 day', 86400, [[:days, 1]]],
+      ['1 week', '7 days', 86400*7, [[:days, 7]]],
+      ['1 month', '1 mon', 86400*30, [[:months, 1]]],
+      ['1 year', '1 year', 31557600, [[:years, 1]]],
+      ['1 decade', '10 years', 31557600*10, [[:years, 10]]],
+      ['1 century', '100 years', 31557600*100, [[:years, 100]]],
+      ['1 millennium', '1000 years', 31557600*1000, [[:years, 1000]]],
+      ['1 year 2 months 3 weeks 4 days 5 hours 6 minutes 7 seconds', '1 year 2 mons 25 days 05:06:07', 31557600 + 2*86400*30 + 3*86400*7 + 4*86400 + 5*3600 + 6*60 + 7, [[:years, 1], [:months, 2], [:days, 25], [:seconds, 18367]]],
+      ['-1 year +2 months -3 weeks +4 days -5 hours +6 minutes -7 seconds', '-10 mons -17 days -04:54:07', -10*86400*30 - 3*86400*7 + 4*86400 - 5*3600 + 6*60 - 7, [[:months, -10], [:days, -17], [:seconds, -17647]]],
+      ['+2 years -1 months +3 weeks -4 days +5 hours -6 minutes +7 seconds', '1 year 11 mons 17 days 04:54:07', 31557600 + 11*86400*30 + 3*86400*7 - 4*86400 + 5*3600 - 6*60 + 7, [[:years, 1], [:months, 11], [:days, 17], [:seconds, 17647]]],
+    ].each do |instr, outstr, value, parts|
+      @ds.insert(instr)
+      @ds.count.should == 1
+      if @native
+        @ds.get(Sequel.cast(:i, String)).should == outstr
+        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}
+        @ds.delete
+        @ds.insert(rs.first)
+        @ds.all.should == rs
+      end
+      @ds.delete
+    end
+  end
+
+  specify 'insert and retrieve interval array values' do
+    @db.create_table!(:items){column :i, 'interval[]'}
+    @ds.insert(['1 year 2 months 3 weeks 4 days 5 hours 6 minutes 7 seconds'].pg_array('interval'))
+    @ds.count.should == 1
+    if @native
+      rs = @ds.all
+      rs.first[:i].is_a?(Sequel::Postgres::PGArray).should be_true
+      rs.first[:i].first.is_a?(ActiveSupport::Duration).should be_true
+      rs.first[:i].first.should == ActiveSupport::Duration.new(31557600 + 2*86400*30 + 3*86400*7 + 4*86400 + 5*3600 + 6*60 + 7, [[:years, 1], [:months, 2], [:days, 25], [:seconds, 18367]])
+      rs.first[:i].first.parts.sort_by{|k,v| k.to_s}.should == [[:years, 1], [:months, 2], [:days, 25], [:seconds, 18367]].sort_by{|k,v| k.to_s}
+      @ds.delete
+      @ds.insert(rs.first)
+      @ds.all.should == rs
+    end
+  end
+
+  specify 'use intervals in bound variables' do
+    @db.create_table!(:items){interval :i}
+    @ds.insert('1 year 2 months 3 weeks 4 days 5 hours 6 minutes 7 seconds')
+    d = @ds.get(:i)
+    @ds.delete
+
+    @ds.call(:insert, {:i=>d}, {:i=>:$i})
+    @ds.get(:i).should == d
+    @ds.filter(:i=>:$i).call(:first, :i=>d).should == {:i=>d}
+    @ds.filter(:i=>:$i).call(:first, :i=>'0').should == nil
+    @ds.filter(:i=>:$i).call(:delete, :i=>d).should == 1
+
+    @db.create_table!(:items){column :i, 'interval[]'}
+    @ds.call(:insert, {:i=>[d]}, {:i=>:$i})
+    @ds.filter(:i=>:$i).call(:first, :i=>[d]).should == {:i=>[d]}
+    @ds.filter(:i=>:$i).call(:first, :i=>[]).should == nil
+    @ds.filter(:i=>:$i).call(:delete, :i=>[d]).should == 1
+  end if POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG
+
+  specify 'with models' do
+    @db.create_table!(:items) do
+      primary_key :id
+      interval :i
+    end
+    c = Class.new(Sequel::Model(@db[:items]))
+    c.plugin :typecast_on_load, :i, :c unless @native
+    v = c.create(:i=>'1 year 2 mons 25 days 05:06:07').i
+    v.is_a?(ActiveSupport::Duration).should be_true
+    v.should == ActiveSupport::Duration.new(31557600 + 2*86400*30 + 3*86400*7 + 4*86400 + 5*3600 + 6*60 + 7, [[:years, 1], [:months, 2], [:days, 25], [:seconds, 18367]])
+    v.parts.sort_by{|k,v| k.to_s}.should == [[:years, 1], [:months, 2], [:days, 25], [:seconds, 18367]].sort_by{|k,v| k.to_s}
+  end
+end if ((require 'active_support/duration'; require 'active_support/inflector'; require 'active_support/core_ext/string/inflections'; true) rescue false)
+