sequel 5.9.0 → 5.10.0

data/lib/sequel/extensions/pg_extended_date_support.rb

@@ -83,12 +83,12 @@ module Sequel
       # If convert_infinite_timestamps is true and the value is infinite, return an appropriate
       # value based on the convert_infinite_timestamps setting.
       def to_application_timestamp(value)
-        if value.is_a?(String) && (m = value.match(/(?:(?:[-+]\d\d:\d\d)(:\d\d)?)?( BC)?\z/)) && (m[1] || m[2])
-          if m[2]
+        if value.is_a?(String) && (m = value.match(/((?:[-+]\d\d:\d\d)(:\d\d)?)?( BC)?\z/)) && (m[2] || m[3])
+          if m[3]
             value = value.sub(' BC', '').sub(' ', ' BC ')
             conv = defined?(JRUBY_VERSION) && JRUBY_VERSION == '9.2.0.0'
           end
-          if m[1] || conv
+          if m[2] || conv
             dt = DateTime.parse(value)
             if conv
               # :nocov:
@@ -99,7 +99,14 @@ module Sequel
               end
               # :nocov:
             end
-            dt = dt.to_time unless Sequel.datetime_class == DateTime
+            unless Sequel.datetime_class == DateTime
+              dt = dt.to_time
+              if conv && (timezone == nil || timezone == :local) && !m[1]
+                # :nocov:
+                dt = Sequel.send(:convert_input_timestamp, dt.strftime("%F %T.%6N"), :local)
+                # :nocov:
+              end
+            end
             Sequel.convert_output_timestamp(dt, Sequel.application_timezone)
           else
             super(value)

data/lib/sequel/extensions/pg_range.rb

@@ -452,13 +452,15 @@ module Sequel
         end
       end
 
+      ENDLESS_RANGE_NOT_SUPPORTED = RUBY_VERSION < '2.6'
+
       # Return a ruby Range object for this instance, if one can be created.
       def to_range
         return @range if @range
         raise(Error, "cannot create ruby range for an empty PostgreSQL range") if empty?
         raise(Error, "cannot create ruby range when PostgreSQL range excludes beginning element") if exclude_begin?
         raise(Error, "cannot create ruby range when PostgreSQL range has unbounded beginning") unless self.begin
-        raise(Error, "cannot create ruby range when PostgreSQL range has unbounded ending") unless self.end
+        raise(Error, "cannot create ruby range when PostgreSQL range has unbounded ending") if ENDLESS_RANGE_NOT_SUPPORTED && !self.end
         @range = Range.new(self.begin, self.end, exclude_end?)
       end
 
@@ -466,7 +468,7 @@ module Sequel
       # it must have a beginning and an ending (no unbounded ranges), and it cannot exclude
       # the beginning element.
       def valid_ruby_range?
-        !(empty? || exclude_begin? || !self.begin || !self.end)
+        !(empty? || exclude_begin? || !self.begin || (ENDLESS_RANGE_NOT_SUPPORTED && !self.end))
       end
 
       # Whether the beginning of the range is unbounded.

data/lib/sequel/model/associations.rb

@@ -2401,6 +2401,14 @@ module Sequel
         # cached associations.
         def change_column_value(column, value)
           if assocs = model.autoreloading_associations[column]
+            if new?
+              # Do deeper checking for new objects, so that associations are
+              # not deleted when values do not change.  This code is run at
+              # a higher level for existing objects.
+              vals = @values
+              return super unless !vals.include?(column) || value != (c = vals[column]) || value.class != c.class
+            end
+
             assocs.each{|a| associations.delete(a)}
           end
           super
@@ -2681,8 +2689,8 @@ module Sequel
         # creates a subquery to the join table.
         def complex_expression_sql_append(sql, op, args)
           r = args[1]
-          if (((op == :'=' || op == :'!=') and r.is_a?(Sequel::Model)) ||
-              (multiple = ((op == :IN || op == :'NOT IN') and ((is_ds = r.is_a?(Sequel::Dataset)) or r.all?{|x| x.is_a?(Sequel::Model)}))))
+          if (((op == :'=' || op == :'!=') && r.is_a?(Sequel::Model)) ||
+              (multiple = ((op == :IN || op == :'NOT IN') && ((is_ds = r.is_a?(Sequel::Dataset)) || (r.respond_to?(:all?) && r.all?{|x| x.is_a?(Sequel::Model)})))))
             l = args[0]
             if ar = model.association_reflections[l]
               if multiple

data/lib/sequel/plugins/list.rb

@@ -45,19 +45,26 @@ module Sequel
     # race conditions, and is not safe when concurrent modifications are made
     # to the same list.
     #
-    # Additionally, note that unlike ruby arrays, the list plugin assumes that the
-    # first entry in the list has position 1, not position 0.
+    # Note that by default, unlike ruby arrays, the list plugin assumes the first
+    # entry in the list has position 1, not position 0.
+    #
+    # You can change this by providing an integer <tt>:top</tt> option:
+    #
+    #   Item.plugin :list, top: 0
     #
     # Copyright (c) 2007-2010 Sharon Rosner, Wayne E. Seguin, Aman Gupta, Adrian Madrid, Jeremy Evans
     module List
-      # Set the +position_field+ and +scope_proc+ attributes for the model,
-      # using the <tt>:field</tt> and <tt>:scope</tt> options, respectively.
+      # Set the +position_field+, +scope_proc+ and +top_of_list+ attributes for the model,
+      # using the <tt>:field</tt>, <tt>:scope</tt>, and <tt>:top</tt> options, respectively.
       # The <tt>:scope</tt> option can be a symbol, array of symbols, or a proc that
       # accepts a model instance and returns a dataset representing the list.
       # Also, modify the model dataset's order to order by the position and scope fields.
       def self.configure(model, opts = OPTS)
         model.position_field = opts[:field] || :position
         model.dataset = model.dataset.order_prepend(model.position_field)
+        model.instance_exec do
+          @top_of_list = opts[:top] || 1
+        end
         
         model.scope_proc = case scope = opts[:scope]
         when Symbol
@@ -80,7 +87,10 @@ module Sequel
         # proc should accept an instance and return a dataset representing the list.
         attr_accessor :scope_proc
 
-        Plugins.inherited_instance_variables(self, :@position_field=>nil, :@scope_proc=>nil)
+        # An Integer to use as the position of the top of the list. Defaults to 1.
+        attr_reader :top_of_list
+
+        Plugins.inherited_instance_variables(self, :@position_field=>nil, :@scope_proc=>nil, :@top_of_list=>nil)
       end
 
       module InstanceMethods
@@ -122,7 +132,7 @@ module Sequel
             checked_transaction do
               ds = list_dataset
               op, ds = if target < current
-                target = 1 if target < 1
+                target = model.top_of_list if target < model.top_of_list
                 [:+, ds.where(position_field=>target...current)]
               else
                 lp ||= last_position
@@ -142,9 +152,9 @@ module Sequel
           move_to(lp, lp)
         end
 
-        # Move this instance to the top (first position, position 1) of the list.
+        # Move this instance to the top (first position, usually position 1) of the list.
         def move_to_top
-          move_to(1)
+          move_to(model.top_of_list)
         end
 
         # Move this instance the given number of places up in the list, or 1 place

data/lib/sequel/plugins/pg_array_associations.rb

@@ -160,7 +160,7 @@ module Sequel
 
         def filter_by_associations_add_conditions_dataset_filter(ds)
           key = qualify(associated_class.table_name, self[:key])
-          ds.select{unnest(key)}.exclude(key=>nil)
+          ds.cross_join(Sequel.function(:unnest, key).as(:_smtopgaa_, [:_smtopgaa_key_])).exclude(key=>nil).select(:_smtopgaa_key_)
         end
         
         def filter_by_associations_conditions_key
@@ -527,7 +527,7 @@ module Sequel
               Sequel[pk=>assoc_pks]
             end
           when Sequel::Dataset
-            Sequel[pk=>obj.select{Sequel.pg_array_op(ref.qualify(obj.model.table_name, ref[:key_column])).unnest}]
+            obj.select(ref.qualify(obj.model.table_name, ref[:key_column]).as(:key)).from_self.where{{pk=>any(:key)}}.select(1).exists
           end
           expr = Sequel::SQL::Constants::FALSE unless expr
           expr = add_association_filter_conditions(ref, obj, expr)

data/lib/sequel/plugins/tree.rb

@@ -32,12 +32,8 @@ module Sequel
       def self.apply(model, opts=OPTS)
         opts = opts.dup
         opts[:class] = model
+        opts[:key] ||= :parent_id
 
-        model.instance_exec do
-          @parent_column = (opts[:key] ||= :parent_id)
-          @tree_order = opts[:order]
-        end
-        
         par = opts.merge(opts.fetch(:parent, OPTS))
         parent = par.fetch(:name, :parent)
         
@@ -47,10 +43,16 @@ module Sequel
         par[:reciprocal] = children
         chi[:reciprocal] = parent
 
-        model.many_to_one parent, par
-        model.one_to_many children, chi
+        model.instance_exec do
+          @parent_column = opts[:key]
+          @tree_order = opts[:order]
+          @parent_association_name = parent
+          @children_association_name = children
 
-        model.plugin SingleRoot if opts[:single_root]
+          many_to_one parent, par
+          one_to_many children, chi
+          plugin SingleRoot if opts[:single_root]
+        end
       end
       
       module ClassMethods
@@ -61,7 +63,13 @@ module Sequel
         # parent of the leaf.
         attr_accessor :parent_column
 
-        Plugins.inherited_instance_variables(self, :@parent_column=>nil, :@tree_order=>nil)
+        # The association name for the parent association
+        attr_reader :parent_association_name
+
+        # The association name for the children association
+        attr_reader :children_association_name
+
+        Plugins.inherited_instance_variables(self, :@parent_column=>nil, :@tree_order=>nil, :@parent_association_name=>nil, :@children_association_name=>nil)
 
         # Should freeze tree order if it is an array when freezing the model class.
         def freeze
@@ -93,7 +101,10 @@ module Sequel
         #   subchild1.ancestors # => [child1, root]
         def ancestors
           node, nodes = self, []
-          nodes << node = node.parent while node.parent
+          meth = model.parent_association_name
+          while par = node.send(meth)
+            nodes << node = par
+          end
           nodes
         end
 
@@ -101,8 +112,8 @@ module Sequel
         #
         #   node.descendants # => [child1, child2, subchild1_1, subchild1_2, subchild2_1, subchild2_2]
         def descendants
-          nodes = children.dup
-          children.each{|child| nodes.concat(child.descendants)}
+          nodes = send(model.children_association_name).dup
+          send(model.children_association_name).each{|child| nodes.concat(child.descendants)}
           nodes 
         end
 
@@ -121,7 +132,11 @@ module Sequel
         #
         #   subchild1.self_and_siblings # => [subchild1, subchild2]
         def self_and_siblings
-          parent ? parent.children : model.roots
+          if parent = send(model.parent_association_name)
+            parent.send(model.children_association_name)
+          else
+            model.roots
+          end
         end
 
         # Returns all siblings of the current node.

data/lib/sequel/sql.rb

@@ -26,12 +26,27 @@ module Sequel
       # Set the date used for SQLTime instances.
       attr_writer :date
 
-      # use the date explicitly set, or the current date if there is not a
+      # Use the date explicitly set, or the current date if there is not a
       # date set.
       def date
         @date || now
       end
 
+      # Set the correct date and timezone when parsing times.
+      def parse(*)
+        t = super
+
+        utc = Sequel.application_timezone == :utc
+        d = @date
+        if d || utc
+          meth = utc ? :utc : :local
+          d ||= t
+          t = public_send(meth, d.year, d.month, d.day, t.hour, t.min, t.sec, t.usec)
+        end
+
+        t
+      end
+
       # Create a new SQLTime instance given an hour, minute, second, and usec.
       def create(hour, minute, second, usec = 0)
         t = date
@@ -1059,7 +1074,11 @@ module Sequel
       def self.from_value_pair(l, r)
         case r
         when Range
-          new(:AND, new(:>=, l, r.begin), new(r.exclude_end? ? :< : :<=, l, r.end))
+          expr = new(:>=, l, r.begin)
+          unless r.end.nil?
+            expr = new(:AND, expr, new(r.exclude_end? ? :< : :<=, l, r.end))
+          end
+          expr
         when ::Array, ::Sequel::Dataset
           new(:IN, l, r)
         when NegativeBooleanConstant
@@ -1846,7 +1865,7 @@ module Sequel
         freeze
       end
 
-      include(Module.new do
+      m = Module.new do
         # Return an +Identifier+, +QualifiedIdentifier+, or +Function+, depending
         # on arguments and whether a block is provided.  Does not currently call the block.
         # See the class level documentation.
@@ -1862,7 +1881,8 @@ module Sequel
             Function.new(m, *args)
           end
         end
-      end)
+      end
+      include m
 
       Sequel::VIRTUAL_ROW = new
     end

data/lib/sequel/version.rb

@@ -5,7 +5,7 @@ module Sequel
   MAJOR = 5
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 9
+  MINOR = 10
   # 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

@@ -271,6 +271,11 @@ describe "PostgreSQL views" do
     @db.refresh_view(:items_view, :concurrently=>true)
   end if DB.server_version >= 90400
 
+  it "should support specifying tablespaces for materialized views" do
+    @opts = {:materialized=>true}
+    @db.create_view(:items_view, @db[:items].where{number >= 10}, :materialized=>true, :tablespace=>:pg_default)
+  end if DB.server_version >= 90300
+
   it "should support :if_exists=>true for not raising an error if the view does not exist" do
     @db.drop_view(:items_view, :if_exists=>true)
   end
@@ -720,6 +725,21 @@ describe "A PostgreSQL dataset" do
     @db.add_index :test, [:name, :value], :if_not_exists=>true, :name=>'tnv3'
   end if DB.server_version >= 90500
 
+  it "should support including columns in indexes" do
+    @db.create_table(:atest){Integer :a; Integer :b; Integer :c}
+    @db.add_index :atest, :a, :include=>[:b, :c]
+    @db.add_index :atest, :b, :include=>:a
+  end if DB.server_version >= 110000
+
+  it "should support specifying tablespaces for tables" do
+    @db.create_table(:atest, :tablespace=>:pg_default){Integer :a}
+  end
+
+  it "should support specifying tablespaces for indexes" do
+    @db.create_table(:atest){Integer :a}
+    @db.add_index :atest, :a, :tablespace=>:pg_default
+  end
+
   it "#lock should lock table if inside a transaction" do
     @db.transaction{@d.lock('EXCLUSIVE'); @d.insert(:name=>'a')}
   end
@@ -849,6 +869,9 @@ describe "A PostgreSQL dataset with a timestamp field" do
   end
   after do
     @db.convert_infinite_timestamps = false
+    Sequel.datetime_class = Time
+    Sequel::SQLTime.date = nil
+    Sequel.application_timezone = nil
   end
   after(:all) do
     @db.drop_table?(:test3)
@@ -872,22 +895,62 @@ describe "A PostgreSQL dataset with a timestamp field" do
     (t2.is_a?(Time) ? t2.usec : t2.strftime('%N').to_i/1000).must_equal t.strftime('%N').to_i/1000
   end
 
+  it "should respect SQLTime.date setting for time columns" do
+    Sequel::SQLTime.date = Time.local(2000, 1, 2)
+    d = Sequel::SQLTime.create(10, 11, 12)
+    @db.get(Sequel.cast(d, :time)).must_equal d
+    @db.get(Sequel.cast(d, :timetz)).must_equal d
+  end
+
+  it "should respect Sequel.application_timezone for time columns" do
+    d = Sequel::SQLTime.create(10, 11, 12)
+    Sequel.application_timezone = :local
+    @db.get(Sequel.cast(d, :time)).utc_offset.must_equal Time.now.utc_offset
+    @db.get(Sequel.cast(d, :timetz)).utc_offset.must_equal Time.now.utc_offset
+    Sequel.application_timezone = :utc
+    @db.get(Sequel.cast(d, :time)).utc_offset.must_equal 0
+    @db.get(Sequel.cast(d, :timetz)).utc_offset.must_equal 0
+  end
+
+  it "should handle parsing dates and timestamps in with 1, 2, and 3 digit years" do
+    [1, 10, 100, -2, -20, -200].each do |year|
+      d = Date.new(year, 2, 3)
+      @db.get(Sequel.cast(d, Date)).must_equal d
+      d = Time.local(year, 2, 3, 10, 11, 12)
+      @db.get(Sequel.cast(d, Time)).must_equal d
+      begin
+        Sequel.datetime_class = DateTime
+        d = DateTime.new(year, 2, 3, 10, 11, 12)
+        @db.get(Sequel.cast(d, Time)).must_equal d
+      ensure
+        Sequel.datetime_class = Time
+      end
+    end
+  end
+
+  it "should handle parsing dates and timestamps in the distant future" do
+    d = Date.new(5874896, 2, 3)
+    @db.get(Sequel.cast(d, Date)).must_equal d
+    d = Time.local(294275, 2, 3, 10, 11, 12)
+    @db.get(Sequel.cast(d, Time)).must_equal d
+    Sequel.datetime_class = DateTime
+    d = DateTime.new(294275, 2, 3, 10, 11, 12)
+    @db.get(Sequel.cast(d, Time)).must_equal d
+  end
+
   it "should handle BC times and dates" do
     d = Date.new(-1234, 2, 3)
     @db.get(Sequel.cast(d, Date)).must_equal d
-    begin
-      Sequel.default_timezone = :utc
-      t = Time.at(-100000000000).utc + 0.5
-      @db.get(Sequel.cast(t, Time)).must_equal t
-      @db.get(Sequel.cast(t, :timestamptz)).must_equal t
-      Sequel.datetime_class = DateTime
-      dt = DateTime.new(-1234, 2, 3, 10, 20, Rational(30, 20))
-      @db.get(Sequel.cast(dt, DateTime)).must_equal dt
-      @db.get(Sequel.cast(dt, :timestamptz)).must_equal dt
-    ensure
-      Sequel.datetime_class = Time
-      Sequel.default_timezone = nil
-    end
+    Sequel.default_timezone = :utc
+    t = Time.at(-100000000000).utc + 0.5
+    @db.get(Sequel.cast(t, Time)).must_equal t
+    @db.get(Sequel.cast(t, :timestamptz)).must_equal t
+    Sequel.datetime_class = DateTime
+    dt = DateTime.new(-1234, 2, 3, 10, 20, Rational(30, 20))
+    @db.get(Sequel.cast(dt, DateTime)).must_equal dt
+    @db.get(Sequel.cast(dt, :timestamptz)).must_equal dt
+    Sequel.datetime_class = Time
+    Sequel.default_timezone = nil
   end
 
   it "should handle infinite timestamps if convert_infinite_timestamps is set" do
@@ -2343,13 +2406,13 @@ describe 'PostgreSQL array handling' do
   end
 
   it 'insert and retrieve custom array types' do
-    int2vector = Class.new do
+    point= Class.new do
       attr_reader :array
       def initialize(array)
         @array = array
       end
       def sql_literal_append(ds, sql)
-        sql << "'#{array.join(' ')}'"
+        sql << "'(#{array.join(',')})'"
       end
       def ==(other)
         if other.is_a?(self.class)
@@ -2359,16 +2422,16 @@ describe 'PostgreSQL array handling' do
         end
       end
     end
-    @db.register_array_type(:int2vector){|s| int2vector.new(s.split.map{|i| i.to_i})}
+    @db.register_array_type(:point){|s| point.new(s[1...-1].split(',').map{|i| i.to_i})}
     @db.create_table!(:items) do
-      column :b, 'int2vector[]'
+      column :b, 'point[]'
     end
-    @tp.call.must_equal [:int2vector_array]
-    int2v = int2vector.new([1, 2])
-    @ds.insert(Sequel.pg_array([int2v], :int2vector))
+    @tp.call.must_equal [:point_array]
+    pv = point.new([1, 2])
+    @ds.insert(Sequel.pg_array([pv], :point))
     @ds.count.must_equal 1
     rs = @ds.all
-    rs.must_equal [{:b=>[int2v]}]
+    rs.must_equal [{:b=>[pv]}]
     rs.first.values.each{|v| v.class.must_equal(Sequel::Postgres::PGArray)}
     rs.first.values.each{|v| v.to_a.must_be_kind_of(Array)}
     @ds.delete
@@ -2398,7 +2461,7 @@ describe 'PostgreSQL array handling' do
     @ds.delete
     @ds.insert(rs.first)
     @ds.all.must_equal rs
-  end if DB.adapter_scheme == :postgres || DB.adapter_scheme == :jdbc
+  end
 
   it 'use arrays in bound variables' do
     @db.create_table!(:items) do
@@ -3039,7 +3102,7 @@ describe 'PostgreSQL json type' do
       j = Sequel.pg_json([{'a'=>1, 'b'=>'c'}, {'a'=>2, 'b'=>'d'}]).op
       @db.from(j.populate_set(Sequel.cast(nil, :items))).select_order_map(:a).must_equal [1, 2]
       @db.from(j.populate_set(Sequel.cast(nil, :items))).select_order_map(:b).must_equal %w'c d'
-    end if DB.server_version >= 90300 && (DB.adapter_scheme == :postgres || DB.adapter_scheme == :jdbc)
+    end if DB.server_version >= 90300
   end
 end if DB.server_version >= 90200
 
@@ -3189,6 +3252,11 @@ describe 'PostgreSQL inet/cidr types' do
 
     @db.get(Sequel.pg_inet_op('1.2.3.4/24').abbrev).must_equal '1.2.3.4/24'
     @db.get(Sequel.pg_inet_op('1.2.3.4/24').broadcast).must_equal IPAddr.new('1.2.3.255/24')
+    @db.get(Sequel.pg_inet_op('1234:3456:5678:789a:9abc:bced:edf0:f012/96').broadcast).must_equal IPAddr.new('1234:3456:5678:789a:9abc:bced::/96')
+    @db.get(Sequel.pg_inet_op('1234:3456:5678:789a:9abc:bced:edf0:f012/128').broadcast).must_equal IPAddr.new('1234:3456:5678:789a:9abc:bced:edf0:f012/128')
+    @db.get(Sequel.pg_inet_op('1234:3456:5678:789a:9abc:bced:edf0:f012/64').broadcast).must_equal IPAddr.new('1234:3456:5678:789a::/64')
+    @db.get(Sequel.pg_inet_op('1234:3456:5678:789a:9abc:bced:edf0:f012/32').broadcast).must_equal IPAddr.new('1234:3456::/32')
+    @db.get(Sequel.pg_inet_op('1234:3456:5678:789a:9abc:bced:edf0:f012/0').broadcast).must_equal IPAddr.new('::/0')
     @db.get(Sequel.pg_inet_op('1.2.3.4/24').family).must_equal 4
     @db.get(Sequel.pg_inet_op('1.2.3.4/24').host).must_equal '1.2.3.4'
     @db.get(Sequel.pg_inet_op('1.2.3.4/24').hostmask).must_equal IPAddr.new('0.0.0.255/32')
@@ -3218,7 +3286,7 @@ describe 'PostgreSQL custom range types' do
     r = Sequel::SQLTime.create(10, 11, 12)..Sequel::SQLTime.create(11, 12, 13)
     @db.get(Sequel.pg_range(r, :timerange)).to_range.must_equal r
   end
-end if DB.server_version >= 90200 && DB.adapter_scheme == :postgres || DB.adapter_scheme == :jdbc
+end if DB.server_version >= 90200
 
 describe 'PostgreSQL range types' do
   before(:all) do
@@ -3570,7 +3638,7 @@ describe 'PostgreSQL row-valued/composite types' do
       @db.drop_table(:domain_check)
       @db << "DROP DOMAIN positive_integer"
     end
-  end if DB.adapter_scheme == :postgres || DB.adapter_scheme == :jdbc
+  end
 
   it 'insert and retrieve arrays of row types' do
     @ds = @db[:company]
@@ -3822,7 +3890,7 @@ describe 'PostgreSQL enum types' do
 
   it "should add array parsers for enum values" do
     @db.get(Sequel.pg_array(%w'a b', :test_enum)).must_equal %w'a b'
-  end if DB.adapter_scheme == :postgres || DB.adapter_scheme == :jdbc
+  end
 
   it "should set up model typecasting correctly" do
     c = Class.new(Sequel::Model(:test_enumt))