sequel 3.46.0 → 3.47.0

data/lib/sequel/plugins/subclasses.rb

@@ -45,17 +45,15 @@ module Sequel
           Sequel.synchronize{_descendents}
         end
 
+        Plugins.inherited_instance_variables(self, :@subclasses=>lambda{|v| []}, :@on_subclass=>nil)
+
         # Add the subclass to this model's current subclasses,
         # and initialize a new subclasses instance variable
         # in the subclass.
         def inherited(subclass)
           super
           Sequel.synchronize{subclasses << subclass}
-          subclass.instance_variable_set(:@subclasses, [])
-          if on_subclass
-            subclass.instance_variable_set(:@on_subclass, on_subclass)
-            on_subclass.call(subclass)
-          end
+          on_subclass.call(subclass) if on_subclass
         end
 
         private

data/lib/sequel/plugins/tactical_eager_loading.rb

@@ -42,9 +42,9 @@ module Sequel
         # objects retrieved with the current object.
         def load_associated_objects(opts, reload=false)
           name = opts[:name]
-          if !associations.include?(name) && retrieved_by
+          if !associations.include?(name) && retrieved_by && !frozen?
             begin
-              retrieved_by.send(:eager_load, retrieved_with, name=>{})
+              retrieved_by.send(:eager_load, retrieved_with.reject{|o| o.frozen?}, name=>{})
             rescue Sequel::UndefinedAssociation
               # This can happen if class table inheritance is used and the association
               # is only defined in a subclass.  This particular instance can use the

data/lib/sequel/plugins/timestamps.rb

@@ -47,13 +47,8 @@ module Sequel
           @create_timestamp_overwrite
         end
         
-        # Copy the class instance variables used from the superclass to the subclass
-        def inherited(subclass)
-          super
-          [:@create_timestamp_field, :@update_timestamp_field, :@create_timestamp_overwrite, :@set_update_timestamp_on_create].each do |iv|
-            subclass.instance_variable_set(iv, instance_variable_get(iv))
-          end
-        end
+        Plugins.inherited_instance_variables(self, :@create_timestamp_field=>nil, :@update_timestamp_field=>nil,
+          :@create_timestamp_overwrite=>nil, :@set_update_timestamp_on_create=>nil)
         
         # Whether to set the update timestamp to the create timestamp when creating
         def set_update_timestamp_on_create?

data/lib/sequel/plugins/touch.rb

@@ -30,6 +30,10 @@ module Sequel
       # The default column to update when touching
       TOUCH_COLUMN_DEFAULT = :updated_at
 
+      def self.apply(model, opts={})
+        model.instance_variable_set(:@touched_associations, {})
+      end
+
       # Set the touch_column and touched_associations variables for the model.
       # Options:
       # * :associations - The associations to touch when a model instance is
@@ -41,7 +45,6 @@ module Sequel
       # * :column - The column to modify when touching a model instance.
       def self.configure(model, opts={})
         model.touch_column = opts[:column] || TOUCH_COLUMN_DEFAULT if opts[:column] || !model.touch_column
-        model.instance_variable_set(:@touched_associations, {})
         model.touch_associations(opts[:associations]) if opts[:associations]
       end
 
@@ -56,13 +59,7 @@ module Sequel
         # are column name symbols.
         attr_reader :touched_associations
 
-        # Set the touch_column for the subclass to be the same as the current class.
-        # Also, create a copy of the touched_associations in the subclass.
-        def inherited(subclass)
-          super
-          subclass.touch_column = touch_column
-          subclass.instance_variable_set(:@touched_associations, touched_associations.dup)
-        end
+        Plugins.inherited_instance_variables(self, :@touched_associations=>:dup, :@touch_column=>nil)
 
         # Add additional associations to be touched.  See the :association option
         # of the Sequel::Plugin::Touch.configure method for the format of the associations

data/lib/sequel/plugins/tree.rb

@@ -55,12 +55,7 @@ module Sequel
         # parent of the leaf.
         attr_accessor :parent_column
 
-        # Copy the +parent_column+ and +order_column+ to the subclass.
-        def inherited(subclass)
-          super
-          subclass.parent_column = parent_column
-          subclass.tree_order = tree_order 
-        end
+        Plugins.inherited_instance_variables(self, :@parent_column=>nil, :@tree_order=>nil)
 
         # Returns list of all root nodes (those with no parent nodes).
         #

data/lib/sequel/plugins/typecast_on_load.rb

@@ -36,11 +36,7 @@ module Sequel
           @typecast_on_load_columns.concat(columns)
         end
 
-        # Give the subclass a copy of the typecast on load columns.
-        def inherited(subclass)
-          super
-          subclass.instance_variable_set(:@typecast_on_load_columns, typecast_on_load_columns.dup)
-        end
+        Plugins.inherited_instance_variables(self, :@typecast_on_load_columns=>:dup)
       end
 
       module InstanceMethods

data/lib/sequel/plugins/update_primary_key.rb

@@ -20,27 +20,39 @@ module Sequel
     #   # Make the Album class support primary key updates
     #   Album.plugin :update_primary_key
     module UpdatePrimaryKey
-      module ClassMethods
-        # Cache the pk_hash when loading records
-        def call(h)
-          r = super(h)
-          r.pk_hash
-          r
-        end
-      end
-
       module InstanceMethods
-        # Clear the pk_hash and object dataset cache, and recache
-        # the pk_hash
+        # Clear the cached primary key.
         def after_update
           super
           @pk_hash = nil
-          pk_hash
         end
 
-        # Cache the pk_hash instead of generating it every time
+        # Use the cached primary key if one is present.
         def pk_hash
-          @pk_hash ||= super
+          @pk_hash || super
+        end
+
+        private
+
+        # If the primary key column changes, clear related associations and cache
+        # the previous primary key values.
+        def change_column_value(column, value)
+          pk = primary_key
+          if (pk.is_a?(Array) ? pk.include?(column) : pk == column)
+            @pk_hash ||= pk_hash unless new?
+            clear_associations_using_primary_key
+          end
+          super
+        end
+
+        # Clear associations that are likely to be tied to the primary key.
+        # Note that this currently can clear additional options that don't reference
+        # the primary key (such as one_to_many columns referencing a column other than the
+        # primary key).
+        def clear_associations_using_primary_key
+          associations.keys.each do |k|
+            associations.delete(k) if model.association_reflection(k)[:type] != :many_to_one
+          end
         end
       end
     end

data/lib/sequel/plugins/validation_class_methods.rb

@@ -21,7 +21,6 @@ module Sequel
       # Setup the validations hash for the given model.
       def self.apply(model)
         model.class_eval do
-          @validation_mutex = Mutex.new
           @validations = {}
           @validation_reflections = {}
         end
@@ -63,21 +62,15 @@ module Sequel
           !validations.empty?
         end
 
-        # Setup the validations and validation_reflections hash in the subclass.
-        def inherited(subclass)
-          vr = @validation_reflections
-          subclass.class_eval do
-            @validation_mutex = Mutex.new
-            @validations = {}
-            h = {}
-            vr.each{|k,v| h[k] = v.dup}
-            @validation_reflections = h
-          end
-          super
-        end
-    
+        Plugins.inherited_instance_variables(self, :@validations=>:hash_dup, :@validation_reflections=>:hash_dup)
+
         # Instructs the model to skip validations defined in superclasses
         def skip_superclass_validations
+          superclass.validations.each do |att, procs|
+            if ps = @validations[att]
+              @validations[att] -= procs
+            end
+          end
           @skip_superclass_validations = true
         end
         
@@ -107,7 +100,6 @@ module Sequel
     
         # Validates the given instance.
         def validate(o)
-          superclass.validate(o) if superclass.respond_to?(:validate) && !skip_superclass_validations?
           validations.each do |att, procs|
             v = case att
             when Array
@@ -200,7 +192,7 @@ module Sequel
           end
           tag = opts[:tag]
           atts.each do |a| 
-            a_vals = @validation_mutex.synchronize{validations[a] ||= []}
+            a_vals = Sequel.synchronize{validations[a] ||= []}
             if tag && (old = a_vals.find{|x| x[0] == tag})
               old[1] = blk
             else
@@ -362,6 +354,28 @@ module Sequel
           end
         end
     
+        # Validates whether an attribute has the correct ruby type for the associated
+        # database type.  This is generally useful in conjunction with
+        # raise_on_typecast_failure = false, to handle typecasting errors at validation
+        # time instead of at setter time. 
+        #
+        # Possible Options:
+        # * :message - The message to use (default: 'is not a valid (integer|datetime|etc.)')
+        def validates_schema_type(*atts)
+          opts = {
+            :tag => :schema_type,
+          }.merge!(extract_options!(atts))
+          reflect_validation(:schema_type, opts, atts)
+          atts << opts
+          validates_each(*atts) do |o, a, v|
+            next if v.nil? || (klass = o.send(:schema_type_class, a)).nil?
+            if klass.is_a?(Array) ? !klass.any?{|kls| v.is_a?(kls)} : !v.is_a?(klass)
+              message = opts[:message] || "is not a valid #{Array(klass).join(" or ").downcase}"
+              o.errors.add(a, message)
+            end
+          end
+        end
+    
         # Validates only if the fields in the model (specified by atts) are
         # unique in the database.  Pass an array of fields instead of multiple
         # fields to specify that the combination of fields must be unique,
@@ -446,6 +460,7 @@ module Sequel
         # Validates the object.
         def validate
           model.validate(self)
+          super
         end
       end
     end

data/lib/sequel/plugins/validation_helpers.rb

@@ -6,35 +6,36 @@ module Sequel
     #   Sequel::Model.plugin :validation_helpers
     #   class Album < Sequel::Model
     #     def validate
+    #       super
     #       validates_min_length 1, :num_tracks
     #     end
     #   end
     #
-    # The validates_unique validation has a unique API, but the other validations have
-    # the API explained here:
+    # The validates_unique and validates_schema_types methods have a unique API, but the other
+    # validations have the API explained here:
     #
     # Arguments:
-    # * atts - Single attribute symbol or an array of attribute symbols specifying the
-    #   attribute(s) to validate.
+    # atts :: Single attribute symbol or an array of attribute symbols specifying the
+    #         attribute(s) to validate.
     # Options:
-    # * :allow_blank - Whether to skip the validation if the value is blank.  You should
-    #   make sure all objects respond to blank if you use this option, which you can do by:
+    # :allow_blank :: Whether to skip the validation if the value is blank.  You should
+    #                 make sure all objects respond to blank if you use this option, which you can do by:
     #     Sequel.extension :blank
-    # * :allow_missing - Whether to skip the validation if the attribute isn't a key in the
-    #   values hash.  This is different from allow_nil, because Sequel only sends the attributes
-    #   in the values when doing an insert or update.  If the attribute is not present, Sequel
-    #   doesn't specify it, so the database will use the table's default value.  This is different
-    #   from having an attribute in values with a value of nil, which Sequel will send as NULL.
-    #   If your database table has a non NULL default, this may be a good option to use.  You
-    #   don't want to use allow_nil, because if the attribute is in values but has a value nil,
-    #   Sequel will attempt to insert a NULL value into the database, instead of using the
-    #   database's default.
-    # * :allow_nil - Whether to skip the validation if the value is nil.
-    # * :message - The message to use.  Can be a string which is used directly, or a
-    #   proc which is called.  If the validation method takes a argument before the array of attributes,
-    #   that argument is passed as an argument to the proc.  The exception is the
-    #   validates_not_string method, which doesn't take an argument, but passes
-    #   the schema type symbol as the argument to the proc.
+    # :allow_missing :: Whether to skip the validation if the attribute isn't a key in the
+    #                   values hash.  This is different from allow_nil, because Sequel only sends the attributes
+    #                   in the values when doing an insert or update.  If the attribute is not present, Sequel
+    #                   doesn't specify it, so the database will use the table's default value.  This is different
+    #                   from having an attribute in values with a value of nil, which Sequel will send as NULL.
+    #                   If your database table has a non NULL default, this may be a good option to use.  You
+    #                   don't want to use allow_nil, because if the attribute is in values but has a value nil,
+    #                   Sequel will attempt to insert a NULL value into the database, instead of using the
+    #                   database's default.
+    # :allow_nil :: Whether to skip the validation if the value is nil.
+    # :message :: The message to use.  Can be a string which is used directly, or a
+    #             proc which is called.  If the validation method takes a argument before the array of attributes,
+    #             that argument is passed as an argument to the proc.  The exception is the
+    #             validates_not_string method, which doesn't take an argument, but passes
+    #             the schema type symbol as the argument to the proc.
     #
     # The default validation options for all models can be modified by
     # changing the values of the Sequel::Plugins::ValidationHelpers::DEFAULT_OPTIONS hash.  You
@@ -83,13 +84,14 @@ module Sequel
         :length_range=>{:message=>lambda{|range| "is too short or too long"}},
         :max_length=>{:message=>lambda{|max| "is longer than #{max} characters"}, :nil_message=>lambda{"is not present"}},
         :min_length=>{:message=>lambda{|min| "is shorter than #{min} characters"}},
+        :not_null=>{:message=>lambda{"is not present"}},
         :not_string=>{:message=>lambda{|type| type ? "is not a valid #{type}" : "is a string"}},
         :numeric=>{:message=>lambda{"is not a number"}},
-        :type=>{:message=>lambda{|klass| "is not a #{klass}"}},
+        :type=>{:message=>lambda{|klass| klass.is_a?(Array) ? "is not a valid #{klass.join(" or ").downcase}" : "is not a valid #{klass.to_s.downcase}"}},
         :presence=>{:message=>lambda{"is not present"}},
         :unique=>{:message=>lambda{'is already taken'}}
       }
-      
+
       module InstanceMethods 
         # Check that the attribute values are the given exact length.
         def validates_exact_length(exact, atts, opts={})
@@ -136,6 +138,11 @@ module Sequel
           validatable_attributes_for_type(:min_length, atts, opts){|a,v,m| validation_error_message(m, min) unless v && v.length >= min}
         end
 
+        # Check attribute value(s) are not NULL/nil.
+        def validates_not_null(atts, opts={})
+          validatable_attributes_for_type(:not_null, atts, opts){|a,v,m| validation_error_message(m) if v.nil?}
+        end
+        
         # Check that the attribute value(s) is not a string.  This is generally useful
         # in conjunction with raise_on_typecast_failure = false, where you are
         # passing in string values for non-string attributes (such as numbers and dates).
@@ -158,12 +165,28 @@ module Sequel
           end
         end
 
-        # Check if value is an instance of a class
+        # Validates for all of the model columns (or just the given columns)
+        # that the column value is an instance of the expected class based on
+        # the column's schema type.
+        def validates_schema_types(atts=keys)
+          Array(atts).each do |k|
+            next unless type = schema_type_class(k)
+            validates_type(type, k)
+          end
+        end
+
+        # Check if value is an instance of a class.  If +klass+ is an array,
+        # the value must be an instance of one of the classes in the array.
         def validates_type(klass, atts, opts={})
           klass = klass.to_s.constantize if klass.is_a?(String) || klass.is_a?(Symbol)
-          validatable_attributes_for_type(:type, atts, opts){|a,v,m| validation_error_message(m, klass) if !v.nil? && !v.is_a?(klass)}
+          validatable_attributes_for_type(:type, atts, opts) do |a,v,m|
+            next if v.nil?
+            if klass.is_a?(Array) ? !klass.any?{|kls| v.is_a?(kls)} : !v.is_a?(klass)
+              validation_error_message(m, klass)
+            end
+          end
         end
-    
+
         # Check attribute value(s) is not considered blank by the database, but allow false values.
         def validates_presence(atts, opts={})
           validatable_attributes_for_type(:presence, atts, opts){|a,v,m| validation_error_message(m) if model.db.send(:blank_object?, v) && v != false}
@@ -220,6 +243,7 @@ module Sequel
           where = opts[:where]
           atts.each do |a|
             arr = Array(a)
+            next if arr.any?{|x| errors.on(x)}
             next if opts[:only_if_modified] && !new? && !arr.any?{|x| changed_columns.include?(x)}
             ds = if where
               where.call(model.dataset, self, arr)

data/lib/sequel/plugins/xml_serializer.rb

@@ -151,11 +151,6 @@ module Sequel
           new.from_xml_node(parent, opts)
         end
 
-        # Call the dataset +to_xml+ method.
-        def to_xml(opts={})
-          dataset.to_xml(opts)
-        end
-
         # Return an appropriate Nokogiri::XML::Builder instance
         # used to create the XML.  This should probably not be used
         # directly by user code.
@@ -201,6 +196,8 @@ module Sequel
           end
           proc{|s| "#{pr[s]}_"}
         end
+
+        Plugins.def_dataset_methods(self, :to_xml)
       end
 
       module InstanceMethods
@@ -282,7 +279,7 @@ module Sequel
           parent.children.each do |node|
             next if node.is_a?(Nokogiri::XML::Text)
             k = name_proc[node.name]
-            if assocs_hash && (assoc = assocs_hash[k])
+            if assocs_hash && assocs_hash[k]
               assocs_present << [k.to_sym, node]
             else
               hash[k] = node.key?('nil') ? nil : node.children.first.to_s

data/lib/sequel/sql.rb

@@ -1606,7 +1606,7 @@ module Sequel
           if args.empty?
             Function.new(m)
           else
-            case arg = args.shift
+            case args.shift
             when :*
               Function.new(m, WILDCARD)
             when :distinct

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 = 46
+  MINOR = 47
   # 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

@@ -116,6 +116,25 @@ describe "A PostgreSQL database" do
   end
 end
 
+describe "A PostgreSQL database with domain types" do
+  before(:all) do
+    @db = POSTGRES_DB
+    @db << "DROP DOMAIN IF EXISTS positive_number CASCADE"
+    @db << "CREATE DOMAIN positive_number AS numeric(10,2) CHECK (VALUE > 0)"
+    @db.create_table!(:testfk){positive_number :id, :primary_key=>true}
+  end
+  after(:all) do
+    @db.drop_table?(:testfk)
+    @db << "DROP DOMAIN positive_number"
+  end
+
+  specify "should correctly parse the schema" do
+    sch = @db.schema(:testfk, :reload=>true)
+    sch.first.last.delete(:domain_oid).should be_a_kind_of(Integer)
+    sch.should == [[:id, {:type=>:decimal, :ruby_default=>nil, :db_type=>"numeric(10,2)", :default=>nil, :oid=>1700, :primary_key=>true, :allow_null=>false, :db_domain_type=>'positive_number'}]]
+  end
+end
+
 describe "A PostgreSQL dataset" do
   before(:all) do
     @db = POSTGRES_DB
@@ -482,6 +501,23 @@ describe "A PostgreSQL dataset with a timestamp field" do
       @db[:test3].get(:time).should == 'infinity'
       @db.convert_infinite_timestamps = :float
       @db[:test3].get(:time).should == 1.0/0.0
+      @db.convert_infinite_timestamps = 'nil'
+      @db[:test3].get(:time).should == nil
+      @db.convert_infinite_timestamps = 'string'
+      @db[:test3].get(:time).should == 'infinity'
+      @db.convert_infinite_timestamps = 'float'
+      @db[:test3].get(:time).should == 1.0/0.0
+      @db.convert_infinite_timestamps = 't'
+      @db[:test3].get(:time).should == 1.0/0.0
+      if ((Time.parse('infinity'); nil) rescue true)
+        # Skip for loose time parsing (e.g. old rbx)
+        @db.convert_infinite_timestamps = 'f'
+        proc{@db[:test3].get(:time)}.should raise_error
+        @db.convert_infinite_timestamps = nil
+        proc{@db[:test3].get(:time)}.should raise_error
+        @db.convert_infinite_timestamps = false
+        proc{@db[:test3].get(:time)}.should raise_error
+      end
 
       @d.update(:time=>Sequel.cast('-infinity', DateTime))
       @db.convert_infinite_timestamps = :nil
@@ -1217,7 +1253,7 @@ describe "Postgres::Database functions, languages, schemas, and triggers" do
     args = ['tf', 'SELECT 1', {:returns=>:integer}]
     @d.send(:create_function_sql, *args).should =~ /\A\s*CREATE FUNCTION tf\(\)\s+RETURNS integer\s+LANGUAGE SQL\s+AS 'SELECT 1'\s*\z/
     @d.create_function(*args)
-    rows = @d['SELECT tf()'].all.should == [{:tf=>1}]
+    @d['SELECT tf()'].all.should == [{:tf=>1}]
     @d.send(:drop_function_sql, 'tf').should == 'DROP FUNCTION tf()'
     @d.drop_function('tf')
     proc{@d['SELECT tf()'].all}.should raise_error(Sequel::DatabaseError)
@@ -1229,7 +1265,7 @@ describe "Postgres::Database functions, languages, schemas, and triggers" do
     @d.create_function(*args)
     # Make sure replace works
     @d.create_function(*args)
-    rows = @d['SELECT tf(1, 2)'].all.should == [{:tf=>3}]
+    @d['SELECT tf(1, 2)'].all.should == [{:tf=>3}]
     args = ['tf', {:if_exists=>true, :cascade=>true, :args=>[[:integer, :a], :integer]}]
     @d.send(:drop_function_sql,*args).should == 'DROP FUNCTION IF EXISTS tf(a integer, integer) CASCADE'
     @d.drop_function(*args)
@@ -1323,6 +1359,7 @@ if POSTGRES_DB.adapter_scheme == :postgres
     before do
       @db = POSTGRES_DB
       Sequel::Postgres::PG_NAMED_TYPES[:interval] = lambda{|v| v.reverse}
+      @db.extension :pg_array
       @db.reset_conversion_procs
     end
     after do
@@ -1336,6 +1373,12 @@ if POSTGRES_DB.adapter_scheme == :postgres
       @db[:foo].insert(Sequel.cast('21 days', :interval))
       @db[:foo].get(:bar).should == 'syad 12'
     end
+
+    specify "should handle array types of named types" do
+      @db.create_table!(:foo){column :bar, 'interval[]'}
+      @db[:foo].insert(Sequel.pg_array(['21 days'], :interval))
+      @db[:foo].get(:bar).should == ['syad 12']
+    end
   end
 end
 
@@ -1792,6 +1835,42 @@ describe 'PostgreSQL array handling' do
     end
   end
 
+  specify 'insert and retrieve custom array types' do
+    int2vector = Class.new do
+      attr_reader :array
+      def initialize(array)
+        @array = array
+      end
+      def sql_literal_append(ds, sql)
+        sql << "'#{array.join(' ')}'"
+      end
+      def ==(other)
+        if other.is_a?(self.class)
+          array == other.array
+        else
+          super
+        end
+      end
+    end
+    @db.register_array_type(:int2vector){|s| int2vector.new(s.split.map{|i| i.to_i})}
+    @db.create_table!(:items) do
+      column :b, 'int2vector[]'
+    end
+    @tp.call.should == [:int2vector_array]
+    int2v = int2vector.new([1, 2])
+    @ds.insert(Sequel.pg_array([int2v], :int2vector))
+    @ds.count.should == 1
+    rs = @ds.all
+    if @native
+      rs.should == [{:b=>[int2v]}]
+      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
+  end unless POSTGRES_DB.adapter_scheme == :jdbc
+
   specify 'use arrays in bound variables' do
     @db.create_table!(:items) do
       column :i, 'int4[]'
@@ -1929,7 +2008,7 @@ end
 describe 'PostgreSQL hstore handling' do
   before(:all) do
     @db = POSTGRES_DB
-    @db.extension :pg_hstore
+    @db.extension :pg_array, :pg_hstore
     @ds = @db[:items]
     @h = {'a'=>'b', 'c'=>nil, 'd'=>'NULL', 'e'=>'\\\\" \\\' ,=>'}
     @native = POSTGRES_DB.adapter_scheme == :postgres
@@ -1956,6 +2035,24 @@ describe 'PostgreSQL hstore handling' do
     end
   end
 
+  specify 'insert and retrieve hstore[] values' do
+    @db.create_table!(:items) do
+      column :h, 'hstore[]'
+    end
+    @ds.insert(Sequel.pg_array([Sequel.hstore(@h)], :hstore))
+    @ds.count.should == 1
+    if @native
+      rs = @ds.all
+      v = rs.first[:h].first
+      v.should_not be_a_kind_of(Hash)
+      v.to_hash.should be_a_kind_of(Hash)
+      v.to_hash.should == @h
+      @ds.delete
+      @ds.insert(rs.first)
+      @ds.all.should == rs
+    end
+  end
+
   specify 'use hstore in bound variables' do
     @db.create_table!(:items) do
       column :i, :hstore
@@ -2136,6 +2233,7 @@ describe 'PostgreSQL hstore handling' do
     @ds.from(:items___i).select(Sequel.hstore('t'=>'s').op.record_set(:i).as(:r)).from_self(:alias=>:s).select(Sequel.lit('(r).*')).from_self.select_map(:t).should == ['s']
 
     @ds.from(Sequel.hstore('t'=>'s', 'a'=>'b').op.skeys.as(:s)).select_order_map(:s).should == %w'a t'
+    @ds.from((Sequel.hstore('t'=>'s', 'a'=>'b').op - 'a').skeys.as(:s)).select_order_map(:s).should == %w't'
 
     @ds.get(h1.slice(Sequel.pg_array(%w'a c')).keys.pg_array.length).should == 2
     @ds.get(h1.slice(Sequel.pg_array(%w'd c')).keys.pg_array.length).should == 1
@@ -2300,7 +2398,7 @@ describe 'PostgreSQL inet/cidr types' do
       @ds.count.should == 1
       if @native
         rs = @ds.all
-        v = rs.first[:j]
+        rs.first[:j]
         rs.first[:i].should == @ipv6
         rs.first[:c].should == @ipv6nm
         rs.first[:i].should be_a_kind_of(IPAddr)
@@ -2472,7 +2570,7 @@ describe 'PostgreSQL range types' do
       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,v| v.should == @ra[k].to_a}
+      v.each{|k,v1| v1.should == @ra[k].to_a}
     end
   end
 
@@ -2500,15 +2598,19 @@ describe 'PostgreSQL range types' do
     @db.get(Sequel.pg_range(1..5, :int4range).op.right_of(-1..0)).should be_true
     @db.get(Sequel.pg_range(1..5, :int4range).op.right_of(-1..3)).should be_false
 
-    @db.get(Sequel.pg_range(1..5, :int4range).op.starts_before(6..10)).should be_true
-    @db.get(Sequel.pg_range(1..5, :int4range).op.starts_before(5..10)).should be_true
-    @db.get(Sequel.pg_range(1..5, :int4range).op.starts_before(-1..0)).should be_false
-    @db.get(Sequel.pg_range(1..5, :int4range).op.starts_before(-1..3)).should be_false
+    @db.get(Sequel.pg_range(1..5, :int4range).op.ends_before(6..10)).should be_true
+    @db.get(Sequel.pg_range(1..5, :int4range).op.ends_before(5..10)).should be_true
+    @db.get(Sequel.pg_range(1..5, :int4range).op.ends_before(-1..0)).should be_false
+    @db.get(Sequel.pg_range(1..5, :int4range).op.ends_before(-1..3)).should be_false
+    @db.get(Sequel.pg_range(1..5, :int4range).op.ends_before(-1..7)).should be_true
 
-    @db.get(Sequel.pg_range(1..5, :int4range).op.ends_after(6..10)).should be_false
-    @db.get(Sequel.pg_range(1..5, :int4range).op.ends_after(5..10)).should be_false
-    @db.get(Sequel.pg_range(1..5, :int4range).op.ends_after(-1..0)).should be_true
-    @db.get(Sequel.pg_range(1..5, :int4range).op.ends_after(-1..3)).should be_true
+    @db.get(Sequel.pg_range(1..5, :int4range).op.starts_after(6..10)).should be_false
+    @db.get(Sequel.pg_range(1..5, :int4range).op.starts_after(5..10)).should be_false
+    @db.get(Sequel.pg_range(1..5, :int4range).op.starts_after(3..10)).should be_false
+    @db.get(Sequel.pg_range(1..5, :int4range).op.starts_after(-1..10)).should be_true
+    @db.get(Sequel.pg_range(1..5, :int4range).op.starts_after(-1..0)).should be_true
+    @db.get(Sequel.pg_range(1..5, :int4range).op.starts_after(-1..3)).should be_true
+    @db.get(Sequel.pg_range(1..5, :int4range).op.starts_after(-5..-1)).should be_true
 
     @db.get(Sequel.pg_range(1..5, :int4range).op.adjacent_to(6..10)).should be_true
     @db.get(Sequel.pg_range(1...5, :int4range).op.adjacent_to(6..10)).should be_false
@@ -2637,7 +2739,7 @@ describe 'PostgreSQL interval types' do
     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}
+    v.parts.sort_by{|k,_| k.to_s}.should == [[:years, 1], [:months, 2], [:days, 25], [:seconds, 18367]].sort_by{|k,_| k.to_s}
   end
 end if (begin require 'active_support/duration'; require 'active_support/inflector'; require 'active_support/core_ext/string/inflections'; true; rescue LoadError; false end)
 
@@ -2697,6 +2799,21 @@ describe 'PostgreSQL row-valued/composite types' do
     end
   end
 
+  specify 'insert and retrieve row types containing domains' do
+    begin
+      @db << "DROP DOMAIN IF EXISTS positive_integer CASCADE"
+      @db << "CREATE DOMAIN positive_integer AS integer CHECK (VALUE > 0)"
+      @db.create_table!(:domain_check) do
+        positive_integer :id
+      end
+      @db.register_row_type(:domain_check)
+      @db.get(@db.row_type(:domain_check, [1])).should == {:id=>1}
+    ensure
+      @db.drop_table(:domain_check)
+      @db << "DROP DOMAIN positive_integer"
+    end
+  end if POSTGRES_DB.adapter_scheme == :postgres
+
   specify 'insert and retrieve arrays of row types' do
     @ds = @db[:company]
     @ds.insert(:id=>1, :employees=>Sequel.pg_array([@db.row_type(:person, [1, Sequel.pg_row(['123 Sesame St', 'Somewhere', '12345'])])]))
@@ -2734,7 +2851,6 @@ describe 'PostgreSQL row-valued/composite types' do
     @ds.filter(:employees=>Sequel.cast(:$employees, 'person[]')).call(:first, :employees=>Sequel.pg_array([@db.row_type(:person, [1, Sequel.pg_row(['123 Sesame St', 'Somewhere', '12345'])])]))[:id].should == 1
     @ds.filter(:employees=>Sequel.cast(:$employees, 'person[]')).call(:first, :employees=>Sequel.pg_array([@db.row_type(:person, [1, Sequel.pg_row(['123 Sesame St', 'Somewhere', '12356'])])])).should == nil
 
-
     @ds.delete
     @ds.call(:insert, {:employees=>Sequel.pg_array([@db.row_type(:person, [1, Sequel.pg_row([nil, nil, nil])])])}, {:employees=>:$employees, :id=>1})
     @ds.get(:employees).should == [{:address=>{:city=>nil, :zip=>nil, :street=>nil}, :id=>1}]