sequel 5.1.0 → 5.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d380edb41288b7e5fd091c8ffd8215b9a8c0a8b2
-  data.tar.gz: e4c34f33035f7e2354f53e264683a60337c66d28
+  metadata.gz: ef9b7568e8d79bc20f28c50164f3f51da9882fa6
+  data.tar.gz: 24f2cda374fdc6e9b2e552d69cdad19542a9a06f
 SHA512:
-  metadata.gz: a18ccd0f5974af2610e2d274963b83fdba2aab99559c3e1cf2bceba99d890d6d4c0dda13c0c6b2f9fba913f41ba39983d65df52e39651e745fa86a1097c3c003
-  data.tar.gz: ac9efe8f2e33539d322b94b6e9e76cadf64091a2af6958bdbdd8e67bea691849382c5aae0032b29498ab4d3b9c4ddf599737be8170d6f435fd03028fbcfc1019
+  metadata.gz: 142a793eec4984fb6e83637758cb2211981199caa498b8bcee98cc87c0e4facf16b2c6829df0fc5cd8a783c99a728eefb84b53fb36d49d312815f712c6cdb667
+  data.tar.gz: '083f6448c19ec9d55567954c316b6a14934f1743e599ccf459b276485064f0af749a7492f42b728ee70df38bf61589775cdd77157b7fee3fcfdf5518d9719f3f'

data/CHANGELOG

@@ -1,3 +1,11 @@
+=== 5.2.0 (2017-10-27)
+
+* Fix type conversion for smallint unsigned and integer unsigned types on jdbc/mysql (jeremyevans) (#1443)
+
+* Add pg_extended_date_support extension, for handling infinite and BC dates/timestamps (jeremyevans)
+
+* Do not ignore existing @dataset instance variable when subclassing Sequel::Model (bjmllr) (#1435)
+
 === 5.1.0 (2017-10-01)
 
 * Make jdbc/h2 and jdbc/hsqldb adapters respect :foreign_key_constraint_name option when adding new foreign key column (jeremyevans)

data/doc/association_basics.rdoc

@@ -1165,7 +1165,7 @@ Called before adding an object to the association:
   
   class Artist
     # Don't allow adding an album to an artist if it has no tracks
-    one_to_many :albums, before_add: lambda{|ar, al| artist.cancel_action if al.num_tracks == 0}
+    one_to_many :albums, before_add: lambda{|ar, al| ar.cancel_action if al.num_tracks == 0}
   end
 
 ==== :after_add [+one_to_many+, +many_to_many+]
@@ -1189,7 +1189,7 @@ Called before removing an object from the association using <tt>remove_<i>associ
 
   class Artist
     # Don't allow removing a self-titled album
-    one_to_many :albums, before_remove: lambda{|ar, al| artist.cancel_action if al.name == ar.name}
+    one_to_many :albums, before_remove: lambda{|ar, al| ar.cancel_action if al.name == ar.name}
   end
 
 This is not called when using <tt>remove_all_<i>association</i></tt>.

data/doc/release_notes/5.2.0.txt

@@ -0,0 +1,33 @@
+= New Features
+
+* A pg_extended_date_support extension has been added.  This
+  extension adds support for infinite and BC dates/timestamps on
+  PostgreSQL.
+
+  The postgres adapter already had a convert_infinite_timestamps
+  setting, but it wasn't supported in the jdbc/postgresql adapter
+  and it didn't handle BC dates/timestamps.  Setting a non-default
+  convert_infinite_timestamps setting in the postgres adapter will
+  now automatically load the extension for backwards compatibility.
+
+  The pg_extended_date_support extension by default just fixes the
+  handling of BC dates/timestamps.  To get it to handle infinite
+  timestamps, you need to choose the appropriate setting for your
+  application:
+
+    DB.extension :pg_extended_date_support
+    DB.convert_infinite_timestamps = :string # or :float or :nil
+
+  This extension also enables the handling of timezone offsets
+  with seconds, which is not natively supported by ruby's Time
+  class in ruby <2.5.
+
+= Improvements
+
+* The jdbc/mysql adapter now handles smallint unsigned and
+  integer unsigned column types where the value for the column
+  is outside of the range of a Java short or integer.
+
+* Sequel::Model.inherited no longer modifies an existing @dataset
+  instance variable if one has already been set.  This fixes a
+  regression that was introduced in Sequel 5.0.0.

data/doc/security.rdoc

@@ -152,7 +152,7 @@ plain strings to literal strings.
 ==== SQL Fragment passed to Dataset#lock_style and Model#lock!
 
 The Sequel::Dataset#lock_style and Sequel::Model#lock! methods also treat
-an input string as SQL code. This method should not be called with user input.
+an input string as SQL code. These methods should not be called with user input.
 
   DB[:table].lock_style(params[:id]) # SQL injection!
   Album.first.lock!(params[:id]) # SQL injection!
@@ -184,8 +184,8 @@ injection:
   # SQL injection when using auto_literal_strings extension
 
 If you are using the auto_literal_strings extension, you need to be very careful,
-as the following methods will treat a plain string given as the first arguments
-as a literal strings:
+as the following methods will treat a plain string given as the first argument
+as a literal string:
 
 * Sequel::Dataset#where
 * Sequel::Dataset#having
@@ -204,7 +204,7 @@ Even stuff that looks like it may be safe isn't:
 
 The Model.find[rdoc-ref:Sequel::Model::ClassMethods#find] and
 Model.find_or_create[rdoc-ref:Sequel::Model::ClassMethods#find_or_create]
-class methods also will treat string arguments as literal strings if the
+class methods will also treat string arguments as literal strings if the
 auto_literal_strings extension is used:
 
   Album.find(params[:id])

data/lib/sequel/adapters/jdbc.rb

@@ -642,7 +642,7 @@ module Sequel
       end
 
       # Called before loading subadapter-specific code, necessary so that subadapter initialization code
-      # that runs queries works correctly.  This cannot be overriding in subadapters,
+      # that runs queries works correctly.  This cannot be overridden in subadapters.
       def setup_type_convertor_map_early
         @type_convertor_map = TypeConvertor::MAP.merge(Java::JavaSQL::Types::TIMESTAMP=>method(:timestamp_convert))
         @basic_type_convertor_map = TypeConvertor::BASIC_MAP.dup

data/lib/sequel/adapters/jdbc/mysql.rb

@@ -73,6 +73,16 @@ module Sequel
           mysql_connection_setting_sqls.each{|sql| statement(conn){|s| log_connection_yield(sql, conn){s.execute(sql)}}}
           super
         end
+
+        # Handle unsigned integer values
+        def setup_type_convertor_map
+          super
+          TypeConvertor::BASIC_MAP.dup
+          @type_convertor_map[Java::JavaSQL::Types::SMALLINT] = @type_convertor_map[Java::JavaSQL::Types::INTEGER]
+          @type_convertor_map[Java::JavaSQL::Types::INTEGER] = @type_convertor_map[Java::JavaSQL::Types::BIGINT]
+          @basic_type_convertor_map[Java::JavaSQL::Types::SMALLINT] = @basic_type_convertor_map[Java::JavaSQL::Types::INTEGER]
+          @basic_type_convertor_map[Java::JavaSQL::Types::INTEGER] = @basic_type_convertor_map[Java::JavaSQL::Types::BIGINT]
+        end
       end
     end
   end

data/lib/sequel/adapters/postgres.rb

@@ -149,18 +149,9 @@ module Sequel
     class Database < Sequel::Database
       include Sequel::Postgres::DatabaseMethods
 
-      INFINITE_TIMESTAMP_STRINGS = ['infinity'.freeze, '-infinity'.freeze].freeze
-      INFINITE_DATETIME_VALUES = ([PLUS_INFINITY, MINUS_INFINITY] + INFINITE_TIMESTAMP_STRINGS).freeze
-      
       set_adapter_scheme :postgresql
       set_adapter_scheme :postgres
 
-      # Whether infinite timestamps/dates should be converted on retrieval.  By default, no
-      # conversion is done, so an error is raised if you attempt to retrieve an infinite
-      # timestamp/date.  You can set this to :nil to convert to nil, :string to leave
-      # as a string, or :float to convert to an infinite float.
-      attr_reader :convert_infinite_timestamps
-
       # Convert given argument so that it can be used directly by pg.  Currently, pg doesn't
       # handle fractional seconds in Time/DateTime or blobs with "\0". Only public for use by
       # the adapter, shouldn't be used by external code.
@@ -232,36 +223,19 @@ module Sequel
         conn
       end
       
-      # Set whether to allow infinite timestamps/dates.  Make sure the
-      # conversion proc for date reflects that setting.
-      def convert_infinite_timestamps=(v)
-        @convert_infinite_timestamps = case v
-        when Symbol
-          v
-        when 'nil'
-          :nil
-        when 'string'
-          :string
-        when 'float'
-          :float
-        when String
-          typecast_value_boolean(v)
-        else
-          false
-        end
+      # Always false, support was moved to pg_extended_date_support extension.
+      # Needs to stay defined here so that sequel_pg works.
+      def convert_infinite_timestamps
+        false
+      end
 
-        pr = old_pr = @use_iso_date_format ? TYPE_TRANSLATOR.method(:date) : Sequel.method(:string_to_date)
-        if v
-          pr = lambda do |val|
-            case val
-            when *INFINITE_TIMESTAMP_STRINGS
-              infinite_timestamp_value(val)
-            else
-              old_pr.call(val)
-            end
-          end
+      # Enable pg_extended_date_support extension if symbol or string is given.
+      def convert_infinite_timestamps=(v)
+        case v
+        when Symbol, String, true
+          extension(:pg_extended_date_support)
+          self.convert_infinite_timestamps = v
         end
-        add_conversion_proc(1082, pr)
       end
 
       def disconnect_connection(conn)
@@ -312,6 +286,9 @@ module Sequel
         #           a version of PostgreSQL before 9.0, you will probably want to
         #           use a string if you are using any options at all, as the syntax
         #           Sequel uses for options is only compatible with PostgreSQL 9.0+.
+        #           This should be the full COPY statement passed to PostgreSQL, not
+        #           just the SELECT query.  If a string is given, the :format and
+        #           :options options are ignored.
         # Dataset :: Uses a query instead of a table name when copying.
         # other :: Uses a table name (usually a symbol) when copying.
         # 
@@ -462,21 +439,6 @@ module Sequel
         end
       end
 
-      # 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 convert_infinite_timestamps
-          case value
-          when *INFINITE_TIMESTAMP_STRINGS
-            infinite_timestamp_value(value)
-          else
-            super
-          end
-        else
-          super
-        end
-      end
-        
       private
 
       # Execute the given SQL string or prepared statement on the connection object.
@@ -583,54 +545,10 @@ module Sequel
         end
       end
 
-      # Return an appropriate value for the given infinite timestamp string.
-      def infinite_timestamp_value(value)
-        case convert_infinite_timestamps
-        when :nil
-          nil
-        when :string
-          value
-        else
-          value == 'infinity' ? PLUS_INFINITY : MINUS_INFINITY
-        end
-      end
-      
       # Don't log, since logging is done by the underlying connection.
       def log_connection_execute(conn, sql)
         conn.execute(sql)
       end
-
-      # If the value is an infinite value (either an infinite float or a string returned by
-      # by PostgreSQL for an infinite date), return it without converting it if
-      # convert_infinite_timestamps is set.
-      def typecast_value_date(value)
-        if convert_infinite_timestamps
-          case value
-          when *INFINITE_DATETIME_VALUES
-            value
-          else
-            super
-          end
-        else
-          super
-        end
-      end
-
-      # If the value is an infinite value (either an infinite float or a string returned by
-      # by PostgreSQL for an infinite timestamp), return it without converting it if
-      # convert_infinite_timestamps is set.
-      def typecast_value_datetime(value)
-        if convert_infinite_timestamps
-          case value
-          when *INFINITE_DATETIME_VALUES
-            value
-          else
-            super
-          end
-        else
-          super
-        end
-      end
     end
     
     class Dataset < Sequel::Dataset

data/lib/sequel/extensions/pg_extended_date_support.rb

@@ -0,0 +1,215 @@
+# frozen-string-literal: true
+#
+# The pg_extended_date_support extension allows support
+# for BC dates/timestamps by default, and infinite
+# dates/timestamps if configured.  Without this extension,
+# BC and infinite dates/timestamps will be handled incorrectly
+# or raise an error.  This behavior isn't the default because
+# it can hurt performance, and few users need support for BC
+# and infinite dates/timestamps.
+#
+# To load the extension into the database:
+#
+#   DB.extension :pg_extended_date_support
+#
+# To enable support for infinite dates/timestamps:
+#
+#   DB.convert_infinite_timestamps = 'string' # or 'nil' or 'float'
+#
+# Related module: Sequel::Postgres::ExtendedDateSupport
+
+#
+module Sequel
+  module Postgres
+    module ExtendedDateSupport
+      DATE_YEAR_1 = Date.new(1)
+      DATETIME_YEAR_1 = DateTime.new(1)
+      TIME_YEAR_1 = Time.at(-62135596800).utc
+      INFINITE_TIMESTAMP_STRINGS = ['infinity'.freeze, '-infinity'.freeze].freeze
+      INFINITE_DATETIME_VALUES = ([PLUS_INFINITY, MINUS_INFINITY] + INFINITE_TIMESTAMP_STRINGS).freeze
+
+      # Add dataset methods and update the conversion proces for dates and timestamps.
+      def self.extended(db)
+        db.extend_datasets(DatasetMethods)
+        procs = db.conversion_procs
+        procs[1082] = ::Sequel.method(:string_to_date)
+        procs[1184] = procs[1114] = db.method(:to_application_timestamp)
+      end
+
+      # Whether infinite timestamps/dates should be converted on retrieval.  By default, no
+      # conversion is done, so an error is raised if you attempt to retrieve an infinite
+      # timestamp/date.  You can set this to :nil to convert to nil, :string to leave
+      # as a string, or :float to convert to an infinite float.
+      attr_reader :convert_infinite_timestamps
+
+      # Set whether to allow infinite timestamps/dates.  Make sure the
+      # conversion proc for date reflects that setting.
+      def convert_infinite_timestamps=(v)
+        @convert_infinite_timestamps = case v
+        when Symbol
+          v
+        when 'nil'
+          :nil
+        when 'string'
+          :string
+        when 'float'
+          :float
+        when String, true
+          typecast_value_boolean(v)
+        else
+          false
+        end
+
+        pr = old_pr = Sequel.method(:string_to_date)
+        if @convert_infinite_timestamps
+          pr = lambda do |val|
+            case val
+            when *INFINITE_TIMESTAMP_STRINGS
+              infinite_timestamp_value(val)
+            else
+              old_pr.call(val)
+            end
+          end
+        end
+        add_conversion_proc(1082, pr)
+      end
+
+      # Handle BC dates in timestamps by moving the BC from after the time to
+      # after the date, to appease ruby's date parser.
+      # 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]
+            value = value.sub(' BC', '').sub(' ', ' BC ')
+          end
+          if m[1]
+            dt = DateTime.parse(value)
+            dt = dt.to_time unless Sequel.datetime_class == DateTime
+            Sequel.convert_output_timestamp(dt, Sequel.application_timezone)
+          else
+            super(value)
+          end
+        elsif convert_infinite_timestamps
+          case value
+          when *INFINITE_TIMESTAMP_STRINGS
+            infinite_timestamp_value(value)
+          else
+            super
+          end
+        else
+          super
+        end
+      end
+
+      private
+      
+      # Return an appropriate value for the given infinite timestamp string.
+      def infinite_timestamp_value(value)
+        case convert_infinite_timestamps
+        when :nil
+          nil
+        when :string
+          value
+        else
+          value == 'infinity' ? PLUS_INFINITY : MINUS_INFINITY
+        end
+      end
+      
+      # If the value is an infinite value (either an infinite float or a string returned by
+      # by PostgreSQL for an infinite date), return it without converting it if
+      # convert_infinite_timestamps is set.
+      def typecast_value_date(value)
+        if convert_infinite_timestamps
+          case value
+          when *INFINITE_DATETIME_VALUES
+            value
+          else
+            super
+          end
+        else
+          super
+        end
+      end
+
+      # If the value is an infinite value (either an infinite float or a string returned by
+      # by PostgreSQL for an infinite timestamp), return it without converting it if
+      # convert_infinite_timestamps is set.
+      def typecast_value_datetime(value)
+        if convert_infinite_timestamps
+          case value
+          when *INFINITE_DATETIME_VALUES
+            value
+          else
+            super
+          end
+        else
+          super
+        end
+      end
+        
+      module DatasetMethods
+        private
+
+        # Handle BC Date objects.
+        def literal_date(date)
+          if date < DATE_YEAR_1
+            date <<= ((date.year) * 24 - 12)
+            date.strftime("'%Y-%m-%d BC'")
+          else
+            super
+          end
+        end
+
+        # Handle BC DateTime objects.
+        def literal_datetime(date)
+          if date < DATETIME_YEAR_1
+            date <<= ((date.year) * 24 - 12)
+            date = db.from_application_timestamp(date)
+            minutes = (date.is_a?(DateTime) ? date.offset * 1440 : date.utc_offset/60).to_i
+            date.strftime("'%Y-%m-%d %H:%M:%S.%N#{format_timestamp_offset(*minutes.divmod(60))} BC'")
+          else
+            super
+          end
+        end
+
+        if RUBY_ENGINE == 'jruby'
+          # :nocov:
+
+          # Work around JRuby bug #4822 in Time#to_datetime for times before date of calendar reform
+          def literal_time(time)
+            if time < TIME_YEAR_1
+              literal_datetime(DateTime.parse(super))
+            else
+              super
+            end
+          end
+
+          ExtendedDateSupport::CONVERT_TYPES = [Java::JavaSQL::Types::DATE, Java::JavaSQL::Types::TIMESTAMP]
+
+          # Use non-JDBC parsing as JDBC parsing doesn't work for BC dates/timestamps.
+          def type_convertor(map, meta, type, i)
+            case type
+            when *CONVERT_TYPES
+              db.oid_convertor_proc(meta.getField(i).getOID)
+            else
+              super
+            end
+          end
+          # :nocov:
+        else
+          # Handle BC Time objects.
+          def literal_time(time)
+            if time < TIME_YEAR_1
+              literal_datetime(time.to_datetime)
+            else
+              super
+            end
+          end
+        end
+      end
+    end
+  end
+
+  Database.register_extension(:pg_extended_date_support, Postgres::ExtendedDateSupport)
+end

data/lib/sequel/model/base.rb

@@ -484,7 +484,7 @@ module Sequel
           subclass.instance_variable_set(iv, sup_class_value)
         end
 
-        unless ivs.include?("@dataset")
+        unless ivs.include?(:@dataset)
           if @dataset && self != Model
             subclass.set_dataset(@dataset.clone, :inherited=>true)
           elsif (n = subclass.name) && !n.to_s.empty?

data/lib/sequel/timezones.rb

@@ -164,7 +164,6 @@ module Sequel
           ary << offset
         end
         convert_input_timestamp(ary, input_timezone)
-        convert_input_timestamp(ary, input_timezone)
       when Time
         if datetime_class == DateTime
           v.to_datetime

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 = 1
+  MINOR = 2
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
   TINY  = 0

data/spec/adapters/mysql_spec.rb

@@ -142,6 +142,18 @@ describe "A MySQL dataset" do
     DB.drop_table?(:items)
   end
 
+  it "should handle large unsigned smallint/integer values" do
+    DB.alter_table(:items){set_column_type :value, 'smallint unsigned'}
+    @d.insert(:value=>(1 << 15) + 1)
+    @d.get(:value).must_equal((1 << 15) + 1)
+    DB.alter_table(:items){set_column_type :value, 'integer unsigned'}
+    @d.update(:value=>(1 << 31) + 1)
+    @d.get(:value).must_equal((1 << 31) + 1)
+    DB.alter_table(:items){set_column_type :value, 'bigint unsigned'}
+    @d.update(:value=>(1 << 63) + 1)
+    @d.get(:value).must_equal((1 << 63) + 1)
+  end
+
   it "should support ORDER clause in UPDATE statements" do
     @d.order(:name).update_sql(:value => 1).must_equal 'UPDATE `items` SET `value` = 1 ORDER BY `name`'
   end

data/spec/adapters/postgres_spec.rb

@@ -727,12 +727,13 @@ describe "A PostgreSQL dataset with a timestamp field" do
       DateTime :time
     end
     @d = @db[:test3]
+    @db.extension :pg_extended_date_support
   end
   before do
     @d.delete
   end
   after do
-    @db.convert_infinite_timestamps = false if @db.adapter_scheme == :postgres
+    @db.convert_infinite_timestamps = false
   end
   after(:all) do
     @db.drop_table?(:test3)
@@ -756,74 +757,126 @@ 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
 
-  if DB.adapter_scheme == :postgres
-    it "should handle infinite timestamps if convert_infinite_timestamps is set" do
-      @d.insert(:time=>Sequel.cast('infinity', DateTime))
-      @db.convert_infinite_timestamps = :nil
-      @db[:test3].get(:time).must_be_nil
-      @db.convert_infinite_timestamps = :string
-      @db[:test3].get(:time).must_equal 'infinity'
-      @db.convert_infinite_timestamps = :float
-      @db[:test3].get(:time).must_equal 1.0/0.0
-      @db.convert_infinite_timestamps = 'nil'
-      @db[:test3].get(:time).must_be_nil
-      @db.convert_infinite_timestamps = 'string'
-      @db[:test3].get(:time).must_equal 'infinity'
-      @db.convert_infinite_timestamps = 'float'
-      @db[:test3].get(:time).must_equal 1.0/0.0
-      @db.convert_infinite_timestamps = 't'
-      @db[:test3].get(:time).must_equal 1.0/0.0
-      @db.convert_infinite_timestamps = 'f'
-      proc{@db[:test3].get(:time)}.must_raise ArgumentError, Sequel::InvalidValue
-      @db.convert_infinite_timestamps = nil
-      proc{@db[:test3].get(:time)}.must_raise ArgumentError, Sequel::InvalidValue
-      @db.convert_infinite_timestamps = false
-      proc{@db[:test3].get(:time)}.must_raise ArgumentError, Sequel::InvalidValue
-
-      @d.update(:time=>Sequel.cast('-infinity', DateTime))
-      @db.convert_infinite_timestamps = :nil
-      @db[:test3].get(:time).must_be_nil
-      @db.convert_infinite_timestamps = :string
-      @db[:test3].get(:time).must_equal '-infinity'
-      @db.convert_infinite_timestamps = :float
-      @db[:test3].get(:time).must_equal(-1.0/0.0)
-    end
-
-    it "should handle conversions from infinite strings/floats in models" do
-      c = Class.new(Sequel::Model(:test3))
-      @db.convert_infinite_timestamps = :float
-      c.new(:time=>'infinity').time.must_equal 'infinity'
-      c.new(:time=>'-infinity').time.must_equal '-infinity'
-      c.new(:time=>1.0/0.0).time.must_equal 1.0/0.0
-      c.new(:time=>-1.0/0.0).time.must_equal(-1.0/0.0)
-    end
-
-    it "should handle infinite dates if convert_infinite_timestamps is set" do
-      @d.insert(:date=>Sequel.cast('infinity', Date))
-      @db.convert_infinite_timestamps = :nil
-      @db[:test3].get(:date).must_be_nil
-      @db.convert_infinite_timestamps = :string
-      @db[:test3].get(:date).must_equal 'infinity'
-      @db.convert_infinite_timestamps = :float
-      @db[:test3].get(:date).must_equal 1.0/0.0
-
-      @d.update(:date=>Sequel.cast('-infinity', :timestamp))
-      @db.convert_infinite_timestamps = :nil
-      @db[:test3].get(:date).must_be_nil
-      @db.convert_infinite_timestamps = :string
-      @db[:test3].get(:date).must_equal '-infinity'
-      @db.convert_infinite_timestamps = :float
-      @db[:test3].get(:date).must_equal(-1.0/0.0)
-    end
-
-    it "should handle conversions from infinite strings/floats in models" do
-      c = Class.new(Sequel::Model(:test3))
-      @db.convert_infinite_timestamps = :float
-      c.new(:date=>'infinity').date.must_equal 'infinity'
-      c.new(:date=>'-infinity').date.must_equal '-infinity'
-      c.new(:date=>1.0/0.0).date.must_equal 1.0/0.0
-      c.new(:date=>-1.0/0.0).date.must_equal(-1.0/0.0)
-    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
+  end
+
+  it "should handle infinite timestamps if convert_infinite_timestamps is set" do
+    @d.insert(:time=>Sequel.cast('infinity', DateTime))
+    @db.convert_infinite_timestamps = :nil
+    @db[:test3].get(:time).must_be_nil
+    @db.convert_infinite_timestamps = :string
+    @db[:test3].get(:time).must_equal 'infinity'
+    @db.convert_infinite_timestamps = :float
+    @db[:test3].get(:time).must_equal 1.0/0.0
+    @db.convert_infinite_timestamps = 'nil'
+    @db[:test3].get(:time).must_be_nil
+    @db.convert_infinite_timestamps = 'string'
+    @db[:test3].get(:time).must_equal 'infinity'
+    @db.convert_infinite_timestamps = 'float'
+    @db[:test3].get(:time).must_equal 1.0/0.0
+    @db.convert_infinite_timestamps = 't'
+    @db[:test3].get(:time).must_equal 1.0/0.0
+    @db.convert_infinite_timestamps = true
+    @db[:test3].get(:time).must_equal 1.0/0.0
+    @db.convert_infinite_timestamps = 'f'
+    proc{@db[:test3].get(:time)}.must_raise ArgumentError, Sequel::InvalidValue
+    @db.convert_infinite_timestamps = nil
+    proc{@db[:test3].get(:time)}.must_raise ArgumentError, Sequel::InvalidValue
+    @db.convert_infinite_timestamps = false
+    proc{@db[:test3].get(:time)}.must_raise ArgumentError, Sequel::InvalidValue
+
+    @d.update(:time=>Sequel.cast('-infinity', DateTime))
+    @db.convert_infinite_timestamps = :nil
+    @db[:test3].get(:time).must_be_nil
+    @db.convert_infinite_timestamps = :string
+    @db[:test3].get(:time).must_equal '-infinity'
+    @db.convert_infinite_timestamps = :float
+    @db[:test3].get(:time).must_equal(-1.0/0.0)
+  end
+
+  it "should handle infinite dates if convert_infinite_timestamps is set" do
+    @d.insert(:time=>Sequel.cast('infinity', DateTime))
+    @db.convert_infinite_timestamps = :nil
+    @db[:test3].get(Sequel.cast(:time, Date)).must_be_nil
+    @db.convert_infinite_timestamps = :string
+    @db[:test3].get(Sequel.cast(:time, Date)).must_equal 'infinity'
+    @db.convert_infinite_timestamps = :float
+    @db[:test3].get(Sequel.cast(:time, Date)).must_equal 1.0/0.0
+    @db.convert_infinite_timestamps = 'nil'
+    @db[:test3].get(Sequel.cast(:time, Date)).must_be_nil
+    @db.convert_infinite_timestamps = 'string'
+    @db[:test3].get(Sequel.cast(:time, Date)).must_equal 'infinity'
+    @db.convert_infinite_timestamps = 'float'
+    @db[:test3].get(Sequel.cast(:time, Date)).must_equal 1.0/0.0
+    @db.convert_infinite_timestamps = 't'
+    @db[:test3].get(Sequel.cast(:time, Date)).must_equal 1.0/0.0
+    @db.convert_infinite_timestamps = true
+    @db[:test3].get(Sequel.cast(:time, Date)).must_equal 1.0/0.0
+    @db.convert_infinite_timestamps = 'f'
+    proc{@db[:test3].get(Sequel.cast(:time, Date))}.must_raise ArgumentError, Sequel::InvalidValue
+    @db.convert_infinite_timestamps = nil
+    proc{@db[:test3].get(Sequel.cast(:time, Date))}.must_raise ArgumentError, Sequel::InvalidValue
+    @db.convert_infinite_timestamps = false
+    proc{@db[:test3].get(Sequel.cast(:time, Date))}.must_raise ArgumentError, Sequel::InvalidValue
+
+    @d.update(:time=>Sequel.cast('-infinity', DateTime))
+    @db.convert_infinite_timestamps = :nil
+    @db[:test3].get(Sequel.cast(:time, Date)).must_be_nil
+    @db.convert_infinite_timestamps = :string
+    @db[:test3].get(Sequel.cast(:time, Date)).must_equal '-infinity'
+    @db.convert_infinite_timestamps = :float
+    @db[:test3].get(Sequel.cast(:time, Date)).must_equal(-1.0/0.0)
+  end
+
+  it "should handle conversions from infinite strings/floats in models" do
+    c = Class.new(Sequel::Model(:test3))
+    @db.convert_infinite_timestamps = :float
+    c.new(:time=>'infinity').time.must_equal 'infinity'
+    c.new(:time=>'-infinity').time.must_equal '-infinity'
+    c.new(:time=>1.0/0.0).time.must_equal 1.0/0.0
+    c.new(:time=>-1.0/0.0).time.must_equal(-1.0/0.0)
+  end
+
+  it "should handle infinite dates if convert_infinite_timestamps is set" do
+    @d.insert(:date=>Sequel.cast('infinity', Date))
+    @db.convert_infinite_timestamps = :nil
+    @db[:test3].get(:date).must_be_nil
+    @db.convert_infinite_timestamps = :string
+    @db[:test3].get(:date).must_equal 'infinity'
+    @db.convert_infinite_timestamps = :float
+    @db[:test3].get(:date).must_equal 1.0/0.0
+
+    @d.update(:date=>Sequel.cast('-infinity', :timestamp))
+    @db.convert_infinite_timestamps = :nil
+    @db[:test3].get(:date).must_be_nil
+    @db.convert_infinite_timestamps = :string
+    @db[:test3].get(:date).must_equal '-infinity'
+    @db.convert_infinite_timestamps = :float
+    @db[:test3].get(:date).must_equal(-1.0/0.0)
+  end
+
+  it "should handle conversions from infinite strings/floats in models" do
+    c = Class.new(Sequel::Model(:test3))
+    @db.convert_infinite_timestamps = :float
+    c.new(:date=>'infinity').date.must_equal 'infinity'
+    c.new(:date=>'-infinity').date.must_equal '-infinity'
+    c.new(:date=>1.0/0.0).date.must_equal 1.0/0.0
+    c.new(:date=>-1.0/0.0).date.must_equal(-1.0/0.0)
   end
 
   it "explain and analyze should not raise errors" do

data/spec/extensions/pg_extended_date_support_spec.rb

@@ -0,0 +1,109 @@
+require_relative "spec_helper"
+
+describe "pg_extended_date_support extension" do
+  before do
+    @db = Sequel.mock(:host=>'postgres', :fetch=>{:v=>1}).extension(:pg_extended_date_support)
+    @db.extend_datasets{def quote_identifiers?; false end}
+  end
+  after do
+    Sequel.datetime_class = Time
+    Sequel.default_timezone = nil
+  end
+
+  it "should convert infinite timestamps and dates as configured" do
+    cp = @db.conversion_procs
+    d = lambda{|v| cp[1082].call(v)}
+    t = lambda{|v| cp[1114].call(v)}
+    pi = 'infinity'
+    ni = '-infinity'
+    today = Date.today
+    now = Time.now
+
+    d.(today.to_s).must_equal today
+    t.(now.strftime("%Y-%m-%d %H:%M:%S.%N")).must_equal now
+    proc{@db.typecast_value(:date, pi)}.must_raise Sequel::InvalidValue
+    proc{@db.typecast_value(:datetime, pi)}.must_raise Sequel::InvalidValue
+
+    [:nil, 'nil'].each do |v|
+      @db.convert_infinite_timestamps = v
+      d.(pi).must_be_nil
+      t.(pi).must_be_nil
+      d.(ni).must_be_nil
+      t.(ni).must_be_nil
+      @db.typecast_value(:date, pi).must_equal pi
+      @db.typecast_value(:datetime, pi).must_equal pi
+      @db.typecast_value(:date, ni).must_equal ni
+      @db.typecast_value(:datetime, ni).must_equal ni
+    end
+
+    d.(today.to_s).must_equal today
+    t.(now.strftime("%Y-%m-%d %H:%M:%S.%N")).must_equal now
+    @db.typecast_value(:date, today.to_s).must_equal today
+    @db.typecast_value(:datetime, now.strftime("%Y-%m-%d %H:%M:%S.%N")).must_equal now
+
+    [:string, 'string'].each do |v|
+      @db.convert_infinite_timestamps = v
+      d.(pi).must_equal pi
+      t.(pi).must_equal pi
+      d.(ni).must_equal ni
+      t.(ni).must_equal ni
+    end
+
+    [:float, 'float', 't', true].each do |v|
+      @db.convert_infinite_timestamps = v
+      d.(pi).must_equal 1.0/0.0
+      t.(pi).must_equal 1.0/0.0
+      d.(ni).must_equal -1.0/0.0
+      t.(ni).must_equal -1.0/0.0
+    end
+
+    ['f', false].each do |v|
+      @db.convert_infinite_timestamps = v
+      proc{d.(pi)}.must_raise ArgumentError, Sequel::InvalidValue
+      proc{t.(pi)}.must_raise ArgumentError, Sequel::InvalidValue
+      proc{d.(ni)}.must_raise ArgumentError, Sequel::InvalidValue
+      proc{t.(ni)}.must_raise ArgumentError, Sequel::InvalidValue
+    end
+  end
+
+  it "should handle parsing BC dates" do
+    @db.conversion_procs[1082].call("1092-10-20 BC").must_equal Date.new(-1091, 10, 20)
+  end
+
+  it "should handle parsing BC timestamps as Time values" do
+    @db.conversion_procs[1114].call("1200-02-15 14:13:20-00:00 BC").must_equal Time.at(-100000000000).utc
+    @db.conversion_procs[1114].call("1200-02-15 14:13:20-00:00:00 BC").must_equal Time.at(-100000000000).utc
+    Sequel.default_timezone = :utc
+    @db.conversion_procs[1114].call("1200-02-15 14:13:20 BC").must_equal Time.at(-100000000000).utc
+    Sequel.default_timezone = nil
+  end
+
+  it "should handle parsing BC timestamps as DateTime values" do
+    Sequel.datetime_class = DateTime
+    @db.conversion_procs[1114].call("1200-02-15 14:13:20-00:00 BC").must_equal DateTime.new(-1199, 2, 15, 14, 13, 20)
+    @db.conversion_procs[1114].call("1200-02-15 14:13:20-00:00:00 BC").must_equal DateTime.new(-1199, 2, 15, 14, 13, 20)
+    Sequel.default_timezone = :utc
+    @db.conversion_procs[1114].call("1200-02-15 14:13:20 BC").must_equal DateTime.new(-1199, 2, 15, 14, 13, 20)
+  end
+
+  it "should handle parsing AD timestamps with offset seconds" do
+    @db.conversion_procs[1114].call("1200-02-15 14:13:20-00:00:00").must_equal DateTime.new(1200, 2, 15, 14, 13, 20).to_time
+    Sequel.datetime_class = DateTime
+    @db.conversion_procs[1114].call("1200-02-15 14:13:20-00:00:00").must_equal DateTime.new(1200, 2, 15, 14, 13, 20)
+  end
+
+  it "should format BC dates" do
+    @db.literal(Date.new(-1091, 10, 20)).must_equal "'1092-10-20 BC'"
+    @db.literal(Date.new(1092, 10, 20)).must_equal "'1092-10-20'"
+  end
+
+  it "should format BC datetimes" do
+    @db.literal(DateTime.new(-1199, 2, 15, 14, 13, 20)).must_equal "'1200-02-15 14:13:20.000000000+0000 BC'"
+    @db.literal(DateTime.new(1200, 2, 15, 14, 13, 20)).must_equal "'1200-02-15 14:13:20.000000+0000'"
+  end
+
+  it "should format BC times" do
+    @db.literal(Time.at(-100000000000).utc).must_equal "'1200-02-15 14:13:20.000000000+0000 BC'"
+    @db.literal(Time.at(100000000000).utc).must_equal "'5138-11-16 09:46:40.000000+0000'"
+  end
+end

data/spec/model/base_spec.rb

@@ -381,6 +381,25 @@ describe "A model inheriting from a model" do
   end
 end
 
+describe "A model inheriting from a custom base that sets @dataset" do
+  before do
+    ::Feline = Class.new(Sequel::Model)
+    def Feline.inherited(subclass)
+      subclass.instance_variable_set(:@dataset, nil)
+      superclass.inherited(subclass)
+    end
+    class ::Leopard < Feline; end
+  end
+  after do
+    Object.send(:remove_const, :Leopard)
+    Object.send(:remove_const, :Feline)
+  end
+
+  it "should not infer the dataset of the subclass" do
+    proc{Leopard.dataset}.must_raise(Sequel::Error)
+  end
+end
+
 describe "Model.primary_key" do
   before do
     @c = Class.new(Sequel::Model)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 5.1.0
+  version: 5.2.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-10-01 00:00:00.000000000 Z
+date: 2017-10-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -252,6 +252,7 @@ extra_rdoc_files:
 - doc/release_notes/4.49.0.txt
 - doc/release_notes/5.0.0.txt
 - doc/release_notes/5.1.0.txt
+- doc/release_notes/5.2.0.txt
 files:
 - CHANGELOG
 - MIT-LICENSE
@@ -398,6 +399,7 @@ files:
 - doc/release_notes/4.9.0.txt
 - doc/release_notes/5.0.0.txt
 - doc/release_notes/5.1.0.txt
+- doc/release_notes/5.2.0.txt
 - doc/schema_modification.rdoc
 - doc/security.rdoc
 - doc/sharding.rdoc
@@ -521,6 +523,7 @@ files:
 - lib/sequel/extensions/pg_array.rb
 - lib/sequel/extensions/pg_array_ops.rb
 - lib/sequel/extensions/pg_enum.rb
+- lib/sequel/extensions/pg_extended_date_support.rb
 - lib/sequel/extensions/pg_hstore.rb
 - lib/sequel/extensions/pg_hstore_ops.rb
 - lib/sequel/extensions/pg_inet.rb
@@ -739,6 +742,7 @@ files:
 - spec/extensions/pg_array_ops_spec.rb
 - spec/extensions/pg_array_spec.rb
 - spec/extensions/pg_enum_spec.rb
+- spec/extensions/pg_extended_date_support_spec.rb
 - spec/extensions/pg_hstore_ops_spec.rb
 - spec/extensions/pg_hstore_spec.rb
 - spec/extensions/pg_inet_ops_spec.rb