sequel 4.8.0 → 4.9.0

data/lib/sequel/model.rb

@@ -80,7 +80,7 @@ module Sequel
 
     # Class methods added to model that call the method of the same name on the dataset
     DATASET_METHODS = (Dataset::ACTION_METHODS + Dataset::QUERY_METHODS +
-      [:each_server]) - [:and, :or, :[], :columns, :columns!, :delete, :update, :add_graph_aliases]
+      [:each_server]) - [:and, :or, :[], :columns, :columns!, :delete, :update, :add_graph_aliases, :first, :first!]
     
     # Boolean settings that can be modified at the global, class, or instance level.
     BOOLEAN_SETTINGS = [:typecast_empty_string_to_nil, :typecast_on_assignment, :strict_param_setting, \
@@ -119,7 +119,7 @@ module Sequel
       :@typecast_empty_string_to_nil=>nil, :@typecast_on_assignment=>nil,
       :@raise_on_typecast_failure=>nil, :@plugins=>:dup, :@setter_methods=>nil,
       :@use_after_commit_rollback=>nil, :@fast_pk_lookup_sql=>nil,
-      :@fast_instance_delete_sql=>nil,
+      :@fast_instance_delete_sql=>nil, :@finders=>:dup, :@finder_loaders=>:dup,
       :@db=>nil, :@default_set_fields_options=>:dup}
 
     # Regular expression that determines if a method name is normal in the sense that
@@ -138,6 +138,8 @@ module Sequel
     @dataset_method_modules = []
     @default_eager_limit_strategy = true
     @default_set_fields_options = {}
+    @finders = {}
+    @finder_loaders = {}
     @overridable_methods_module = nil
     @fast_pk_lookup_sql = nil
     @fast_instance_delete_sql = nil

data/lib/sequel/model/associations.rb

@@ -2324,7 +2324,7 @@ END
           orig_ds = ds
           local_opts = ds.opts[:eager_graph][:local]
           limit_strategy = r.eager_graph_limit_strategy(local_opts[:limit_strategy])
-          ds = loader.call(:self=>ds, :table_alias=>assoc_table_alias, :implicit_qualifier=>ta, :callback=>callback, :join_type=>local_opts[:join_type], :limit_strategy=>limit_strategy, :from_self_alias=>ds.opts[:eager_graph][:master])
+          ds = loader.call(:self=>ds, :table_alias=>assoc_table_alias, :implicit_qualifier=>(ta == ds.opts[:eager_graph][:master]) ? first_source : qualifier_from_alias_symbol(ta, first_source), :callback=>callback, :join_type=>local_opts[:join_type], :limit_strategy=>limit_strategy, :from_self_alias=>ds.opts[:eager_graph][:master])
           if r[:order_eager_graph] && (order = r.fetch(:graph_order, r[:order]))
             ds = ds.order_more(*qualified_expression(order, assoc_table_alias))
           end

data/lib/sequel/model/base.rb

@@ -107,7 +107,7 @@ module Sequel
       #   # => #<Artist {:name=>'Bob', ...}>
       def [](*args)
         args = args.first if args.size <= 1
-        args.is_a?(Hash) ? dataset[args] : (primary_key_lookup(args) unless args.nil?)
+        args.is_a?(Hash) ? first_where(args) : (primary_key_lookup(args) unless args.nil?)
       end
 
       # Initializes a model instance as an existing record. This constructor is
@@ -308,7 +308,12 @@ module Sequel
       #   Artist.find{name > 'M'}
       #   # SELECT * FROM artists WHERE (name > 'M') LIMIT 1
       def find(*args, &block)
-        filter(*args, &block).first
+        if args.length == 1 && !block
+          # Use optimized finder
+          first_where(args.first)
+        else
+          filter(*args, &block).first
+        end
       end
       
       # Like +find+ but invokes create with given conditions when record does not
@@ -327,6 +332,114 @@ module Sequel
         find(cond) || create(cond, &block)
       end
     
+
+      FINDER_TYPES = [:first, :all, :each, :get].freeze
+
+      # Create an optimized finder method using a dataset placeholder literalizer.
+      # This pre-computes the SQL to use for the query, except for given arguments.
+      #
+      # There are two ways to use this.  The recommended way is to pass a symbol
+      # that represents a model class method that returns a dataset:
+      #
+      #   def Artist.by_name(name)
+      #     where(:name=>name)
+      #   end
+      #
+      #   Artist.finder :by_name
+      #
+      # This creates an optimized first_by_name method, which you can call normally:
+      #
+      #   Artist.first_by_name("Joe")
+      #
+      # The alternative way to use this to pass your own block:
+      #
+      #   Artist.finder(:name=>:first_by_name){|pl, ds| ds.where(:name=>pl.arg).limit(1)}
+      #
+      # Note that if you pass your own block, you are responsible for manually setting
+      # limits if necessary (as shown above).
+      #
+      # Options:
+      # :arity :: When using a symbol method name, this specifies the arity of the method.
+      #           This should be used if if the method accepts an arbitrary number of arguments,
+      #           or the method has default argument values.  Note that if the method is defined
+      #           as a dataset method, the class method Sequel creates accepts an arbitrary number
+      #           of arguments, so you should use this option in that case.  If you want to handle
+      #           multiple possible arities, you need to call the finder method multiple times with
+      #           unique :arity and :name methods each time.
+      # :name :: The name of the method to create.  This must be given if you pass a block.
+      #          If you use a symbol, this defaults to the symbol prefixed by the type.
+      # :mod :: The module in which to create the finder method.  Defaults to the singleton
+      #         class of the model.
+      # :type :: The type of query to run.  Can be :first, :each, :all, or :get, defaults to
+      #          :first.
+      #
+      # Caveats:
+      #
+      # This doesn't handle all possible cases.  For example, if you have a method such as:
+      #
+      #   def Artist.by_name(name)
+      #     name ? where(:name=>name) : exclude(:name=>nil)
+      #   end
+      #
+      # Then calling a finder without an argument will not work as you expect.
+      #
+      #   Artist.finder :by_name
+      #   Artist.by_name(nil).first
+      #   # WHERE (name IS NOT NULL)
+      #   Artist.first_by_name(nil)
+      #   # WHERE (name IS NULL)
+      #
+      # See Dataset::PlaceholderLiteralizer for additional caveats.
+      def finder(meth=OPTS, opts=OPTS, &block)
+        if block
+          raise Error, "cannot pass both a method name argument and a block of Model.finder" unless meth.is_a?(Hash)
+          raise Error, "cannot pass two option hashes to Model.finder" unless opts.equal?(OPTS)
+          opts = meth
+          raise Error, "must provide method name via :name option when passing block to Model.finder" unless meth_name = opts[:name]
+        end
+
+        type = opts.fetch(:type, :first)
+        raise Error, ":type option to Model.finder must be :first, :all, :each, or :get" unless FINDER_TYPES.include?(type)
+        limit1 = type == :first || type == :get
+        meth_name ||= opts[:name] || :"#{type}_#{meth}"
+
+        loader_proc = proc do |model|
+          unless block
+            argn = opts[:arity]
+            block =  lambda do |pl, model2|
+              method = model2.method(meth)
+              argn ||= (method.arity < 0 ? method.arity.abs - 1 : method.arity)
+              args = (0...argn).map{pl.arg}
+              ds = method.call(*args)
+              ds = ds.limit(1) if limit1
+              ds
+            end
+          end
+
+          Sequel::Dataset::PlaceholderLiteralizer.loader(model, &block) 
+        end
+        Sequel.synchronize{@finder_loaders[meth_name] = loader_proc}
+        mod = opts[:mod] || (class << self; self; end)
+        def_finder_method(mod, meth_name, type)
+      end
+
+      # An alias for calling first on the model's dataset, but with
+      # optimized handling of the single argument case.
+      def first(*args, &block)
+        if args.length == 1 && !block && !args.first.is_a?(Integer)
+          # Use optimized finder
+          first_where(args.first)
+        else
+          dataset.first(*args, &block)
+        end
+      end
+
+      # An alias for calling first! on the model's dataset, but with
+      # optimized handling of the single argument case.
+      def first!(*args, &block)
+        first(*args, &block) || raise(Sequel::NoMatchingRow)
+      end
+
       # Clear the setter_methods cache when a module is included, as it
       # may contain setter methods.
       def include(mod)
@@ -699,6 +812,24 @@ module Sequel
         end
       end
 
+      # Define a finder method in the given module with the given method name that
+      # load rows using the finder with the given name.
+      def def_finder_method(mod, meth, type)
+        mod.send(:define_method, meth){|*args, &block| finder_for(meth).send(type, *args, &block)}
+      end
+
+      # Find the finder to use for the give method.  If a finder has not been loaded
+      # for the method, load the finder and set correctly in the finders hash, then
+      # return the finder.
+      def finder_for(meth)
+        unless finder = Sequel.synchronize{@finders[meth]}
+          finder_loader = @finder_loaders.fetch(meth)
+          finder = finder_loader.call(self)
+          Sequel.synchronize{@finders[meth] = finder}
+        end
+        finder
+      end
+
       # Get the schema from the database, fall back on checking the columns
       # via the database if that will return inaccurate results or if
       # it raises an error.
@@ -831,7 +962,7 @@ module Sequel
           ds.fetch_rows(sql){|r| return ds.row_proc.call(r)}
           nil
         else
-          dataset[primary_key_hash(pk)]
+          first_where(primary_key_hash(pk))
         end
       end
 
@@ -849,6 +980,7 @@ module Sequel
       # Reset the instance dataset to a modified copy of the current dataset,
       # should be used whenever the model's dataset is modified.
       def reset_instance_dataset
+        @finders.clear if @finders
         @instance_dataset = @dataset.limit(1).naked if @dataset
       end
   
@@ -2055,5 +2187,6 @@ module Sequel
 
     extend ClassMethods
     plugin self
+    finder(:where, :arity=>1, :mod=>ClassMethods)
   end
 end

data/lib/sequel/model/errors.rb

@@ -29,6 +29,12 @@ module Sequel
       #   errors.full_messages
       #   # => ['name is not valid',
       #   #     'hometown is not at least 2 letters']
+      #
+      # If the message is a Sequel::LiteralString, it will be used literally, without the column name:
+      #
+      #   errors.add(:name, Sequel.lit("Album name is not valid"))
+      #   errors.full_messages
+      #   # => ['Album name is not valid']
       def full_messages
         inject([]) do |m, kv| 
           att, errors = *kv

data/lib/sequel/plugins/defaults_setter.rb

@@ -46,7 +46,7 @@ module Sequel
           when Sequel::CURRENT_DATE
             lambda{Date.today}
           when Sequel::CURRENT_TIMESTAMP
-            lambda{Sequel.datetime_class.now}
+            lambda{dataset.current_datetime}
           else
             v
           end

data/lib/sequel/plugins/eager_each.rb

@@ -22,6 +22,15 @@ module Sequel
     #   Album.plugin :eager_each
     module EagerEach 
       module DatasetMethods
+        # Don't call #all when attempting to load the columns.
+        def columns
+          if use_eager_all?
+            clone(:all_called=>true).columns
+          else
+            super
+          end
+        end
+
         # Call #all instead of #each if eager loading,
         # uless #each is being called by #all.
         def each(&block)

data/lib/sequel/plugins/nested_attributes.rb

@@ -286,7 +286,7 @@ module Sequel
         def validate_associated_object(reflection, obj)
           return if reflection[:validate] == false
           association = reflection[:name]
-          if (reflection[:type] == :one_to_many || reflection[:type] == :one_to_one) && (key = reflection[:key]).is_a?(Symbol) && !obj.values[key]
+          if (reflection[:type] == :one_to_many || reflection[:type] == :one_to_one) && (key = reflection[:key]).is_a?(Symbol) && !(pk_val = obj.values[key])
             # There could be a presence validation on the foreign key in the associated model,
             # which will fail if we validate before saving the current object.  If there is
             # no value for the foreign key, set it to the current primary key value, or a dummy
@@ -295,7 +295,7 @@ module Sequel
             key = nil if pk
           end
           obj.errors.full_messages.each{|m| errors.add(association, m)} unless obj.valid?
-          if key
+          if key && !pk_val
             # If we used a dummy value of 0, remove it so it doesn't accidently remain.
             obj.values.delete(key)
           end

data/lib/sequel/plugins/timestamps.rb

@@ -79,7 +79,7 @@ module Sequel
         def set_create_timestamp(time=nil)
           field = model.create_timestamp_field
           meth = :"#{field}="
-          self.send(meth, time||=Sequel.datetime_class.now) if respond_to?(field) && respond_to?(meth) && (model.create_timestamp_overwrite? || send(field).nil?)
+          self.send(meth, time||=model.dataset.current_datetime) if respond_to?(field) && respond_to?(meth) && (model.create_timestamp_overwrite? || send(field).nil?)
           set_update_timestamp(time) if model.set_update_timestamp_on_create?
         end
         
@@ -87,7 +87,7 @@ module Sequel
         # object has a setter method for the update timestamp field.
         def set_update_timestamp(time=nil)
           meth = :"#{model.update_timestamp_field}="
-          self.send(meth, time||Sequel.datetime_class.now) if respond_to?(meth)
+          self.send(meth, time||model.dataset.current_datetime) if respond_to?(meth)
         end
       end
     end

data/lib/sequel/plugins/touch.rb

@@ -130,9 +130,9 @@ module Sequel
         end
 
         # The value to use when modifying the touch column for the model instance.
-        # Uses Time.now to work well with typecasting.
+        # Uses Time/DateTime.now to work well with typecasting.
         def touch_instance_value
-          Time.now
+          model.dataset.current_datetime
         end
       end
     end

data/lib/sequel/sql.rb

@@ -216,7 +216,7 @@ module Sequel
         case op
         when *N_ARITY_OPERATORS
           raise(Error, "The #{op} operator requires at least 1 argument") unless args.length >= 1
-          old_args = args
+          old_args = args.map{|a| a.is_a?(self.class) && a.op == :NOOP ? a.args.first : a}
           args = []
           old_args.each{|a| a.is_a?(self.class) && a.op == op ? args.concat(a.args) : args.push(a)}
         when *TWO_ARITY_OPERATORS
@@ -798,20 +798,23 @@ module Sequel
     # arguments with the appropriate operator, and the & and | operators return
     # boolean expressions combining all of the arguments with either AND or OR.
     module OperatorBuilders
-      %w'+ - * /'.each do |op|
-        class_eval(<<-END, __FILE__, __LINE__ + 1)
-          def #{op}(*args)
-            SQL::NumericExpression.new(:#{op}, *args)
-          end
-        END
-      end
-
-      {'&'=>'AND', '|'=>'OR'}.each do |m, op|
-        class_eval(<<-END, __FILE__, __LINE__ + 1)
-          def #{m}(*args)
-            SQL::BooleanExpression.new(:#{op}, *args)
-          end
-        END
+      {'::Sequel::SQL::NumericExpression'=>{'+'=>'+', '-'=>'-', '*'=>'*', '/'=>'/'},
+       '::Sequel::SQL::BooleanExpression'=>{'&'=>'AND', '|'=>'OR'}}.each do |klass, ops|
+        ops.each do |m, op|
+          class_eval(<<-END, __FILE__, __LINE__ + 1)
+            def #{m}(*args)
+              if (args.length == 1)
+                if (v = args.first).class.is_a?(#{klass})
+                  v
+                else
+                  #{klass}.new(:NOOP, v)
+                end
+              else
+                #{klass}.new(:#{op}, *args)
+              end
+            end
+          END
+        end
       end
       
       # Invert the given expression.  Returns a <tt>Sequel::SQL::BooleanExpression</tt>
@@ -1012,6 +1015,8 @@ module Sequel
           StringExpression.like(l, r)
         when DelayedEvaluation
           Sequel.delay{from_value_pair(l, r.callable.call)}
+        when Dataset::PlaceholderLiteralizer::Argument
+          r.transform{|v| from_value_pair(l, v)}
         else
           new(:'=', l, r)
         end

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 = 8
+  MINOR = 9
   # 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

@@ -170,8 +170,31 @@ describe "A PostgreSQL database" do
     @db.server_version.should > 70000
   end
 
+  specify "should support disable_insert_returning" do
+    ds = @db[:public__testfk].disable_insert_returning
+    ds.delete
+    ds.insert.should == nil
+    id = ds.max(:id)
+    ds.select_order_map([:id, :i]).should == [[id, nil]]
+    ds.insert(:i=>id).should == nil
+    ds.select_order_map([:id, :i]).should == [[id, nil], [id+1, id]]
+    ds.insert_select(:i=>ds.max(:id)).should == nil
+    ds.select_order_map([:id, :i]).should == [[id, nil], [id+1, id]]
+    c = Class.new(Sequel::Model(ds))
+    c.class_eval do
+      def before_create
+        self.id = model.max(:id)+1
+        super
+      end
+    end
+    c.create(:i=>id+1).should == c.load(:id=>id+2, :i=>id+1)
+    ds.select_order_map([:id, :i]).should == [[id, nil], [id+1, id], [id+2, id+1]]
+    ds.delete
+  end
+
   specify "should support functions with and without quoting" do
     ds = @db[:public__testfk]
+    ds.delete
     ds.insert
     ds.get{sum(1)}.should == 1
     ds.get{Sequel.function('pg_catalog.sum', 1)}.should == 1
@@ -1497,6 +1520,23 @@ if DB.adapter_scheme == :postgres
       end
     end
 
+    specify "should respect the :hold=>true option for creating the cursor WITH HOLD and not using a transaction" do
+      @ds.use_cursor.each{@db.in_transaction?.should == true}
+      check_sqls{@db.sqls.any?{|s| s =~ /WITH HOLD/}.should == false}
+      @ds.use_cursor(:hold=>true).each{@db.in_transaction?.should == false}
+      check_sqls{@db.sqls.any?{|s| s =~ /WITH HOLD/}.should == true}
+    end
+
+    specify "should support updating individual rows based on a cursor" do
+      @db.transaction(:rollback=>:always) do
+        @ds.use_cursor(:rows_per_fetch=>1).each do |row|
+          @ds.where_current_of.update(:x=>Sequel.*(row[:x], 10))
+        end
+        @ds.select_order_map(:x).should == (0..1000).map{|x| x * 10}
+      end
+      @ds.select_order_map(:x).should == (0..1000).to_a
+    end
+
     specify "should respect the :cursor_name option" do
       one_rows = []
       two_rows = []
@@ -1852,7 +1892,7 @@ 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]
+    @tp.call.should == [:smallint_array, :integer_array, :bigint_array, :real_array, :float_array]
     @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
@@ -1915,12 +1955,12 @@ describe 'PostgreSQL array handling' do
       column :vc, 'varchar[]'
       column :t, 'text[]'
     end
-    @tp.call.should == [:string_array, :string_array, :string_array]
-    @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))
+    @tp.call.should == [:character_array, :varchar_array, :string_array]
+    @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 @native
-      rs.should == [{:c=>['a   ', nil, 'NULL', 'b"\'c'], :vc=>['a', nil, 'NULL', 'b"\'c'], :t=>['a', nil, 'NULL', 'b"\'c']}]
+      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
@@ -1929,10 +1969,10 @@ describe 'PostgreSQL array handling' do
     end
 
     @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))
+    @ds.insert(Sequel.pg_array([[['a'], [nil]], [['NULL'], ['b"\'c']]], 'char(4)'), Sequel.pg_array([[['a[],\\[\\]\\,\\""NULL",'], ['']], [['NULL'], ['b"\'c']]], :varchar), Sequel.pg_array([[['a'], [nil]], [['NULL'], ['b"\'c']]], :text))
     rs = @ds.all
     if @native
-      rs.should == [{:c=>[[['a   '], [nil]], [['NULL'], ['b"\'c']]], :vc=>[[['a'], ['']], [['NULL'], ['b"\'c']]], :t=>[[['a'], [nil]], [['NULL'], ['b"\'c']]]}]
+      rs.should == [{:c=>[[['a   '], [nil]], [['NULL'], ['b"\'c']]], :vc=>[[['a[],\\[\\]\\,\\""NULL",'], ['']], [['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
@@ -1972,7 +2012,7 @@ describe 'PostgreSQL array handling' do
       column :tz, 'timetz[]'
       column :o, 'oid[]'
     end
-    @tp.call.should == [:blob_array, :time_timezone_array, :integer_array]
+    @tp.call.should == [:blob_array, :time_timezone_array, :oid_array]
     @ds.insert(Sequel.pg_array([Sequel.blob("a\0"), nil], :bytea), Sequel.pg_array([t, nil], :timetz), Sequel.pg_array([1, 2, 3], :oid))
     @ds.count.should == 1
     if @native
@@ -2109,11 +2149,33 @@ describe 'PostgreSQL array handling' do
     end
     c = Class.new(Sequel::Model(@db[:items]))
     c.plugin :pg_typecast_on_load, :i, :f, :d, :t unless @native
+    h = {:i=>[1,2, nil], :f=>[[1, 2.5], [3, 4.5]], :d=>[1, BigDecimal.new('1.000000000000000000001')], :t=>[%w'a b c', ['NULL', nil, '1']]}
+    o = c.create(h)
+    o.i.should == [1, 2, nil]
+    o.f.should == [[1, 2.5], [3, 4.5]]
+    o.d.should == [BigDecimal.new('1'), BigDecimal.new('1.000000000000000000001')]
+    o.t.should == [%w'a b c', ['NULL', nil, '1']]
+    c.where(:i=>o.i, :f=>o.f, :d=>o.d, :t=>o.t).all.should == [o]
+    o2 = c.new(h)
+    c.where(:i=>o2.i, :f=>o2.f, :d=>o2.d, :t=>o2.t).all.should == [o]
+
+    @db.create_table!(:items) do
+      primary_key :id
+      column :i, 'int2[]'
+      column :f, 'real[]'
+      column :d, 'numeric(30,28)[]'
+      column :t, 'varchar[]'
+    end
+    c = Class.new(Sequel::Model(@db[:items]))
+    c.plugin :pg_typecast_on_load, :i, :f, :d, :t unless @native
     o = c.create(:i=>[1,2, nil], :f=>[[1, 2.5], [3, 4.5]], :d=>[1, BigDecimal.new('1.000000000000000000001')], :t=>[%w'a b c', ['NULL', nil, '1']])
     o.i.should == [1, 2, nil]
     o.f.should == [[1, 2.5], [3, 4.5]]
     o.d.should == [BigDecimal.new('1'), BigDecimal.new('1.000000000000000000001')]
     o.t.should == [%w'a b c', ['NULL', nil, '1']]
+    c.where(:i=>o.i, :f=>o.f, :d=>o.d, :t=>o.t).all.should == [o]
+    o2 = c.new(h)
+    c.where(:i=>o2.i, :f=>o2.f, :d=>o2.d, :t=>o2.t).all.should == [o]
   end
 
   specify 'operations/functions with pg_array_ops' do
@@ -2973,8 +3035,8 @@ end if (begin require 'active_support/duration'; require 'active_support/inflect
 describe 'PostgreSQL row-valued/composite types' do
   before(:all) do
     @db = DB
-    Sequel.extension :pg_array_ops, :pg_row_ops
     @db.extension :pg_array, :pg_row
+    Sequel.extension :pg_array_ops, :pg_row_ops
     @ds = @db[:person]
 
     @db.create_table!(:address) do