ibm_db 5.2.0-x86-mingw32 → 5.4.0-x86-mingw32

data/test/cases/adapters/postgresql/infinity_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 class PostgresqlInfinityTest < ActiveRecord::PostgreSQLTestCase
@@ -11,11 +13,12 @@ class PostgresqlInfinityTest < ActiveRecord::PostgreSQLTestCase
     @connection.create_table(:postgresql_infinities) do |t|
       t.float :float
       t.datetime :datetime
+      t.date :date
     end
   end
 
   teardown do
-    @connection.drop_table 'postgresql_infinities', if_exists: true
+    @connection.drop_table "postgresql_infinities", if_exists: true
   end
 
   test "type casting infinity on a float column" do
@@ -25,12 +28,12 @@ class PostgresqlInfinityTest < ActiveRecord::PostgreSQLTestCase
   end
 
   test "type casting string on a float column" do
-    record = PostgresqlInfinity.new(float: 'Infinity')
+    record = PostgresqlInfinity.new(float: "Infinity")
     assert_equal Float::INFINITY, record.float
-    record = PostgresqlInfinity.new(float: '-Infinity')
+    record = PostgresqlInfinity.new(float: "-Infinity")
     assert_equal(-Float::INFINITY, record.float)
-    record = PostgresqlInfinity.new(float: 'NaN')
-    assert_send [record.float, :nan?]
+    record = PostgresqlInfinity.new(float: "NaN")
+    assert record.float.nan?, "Expected #{record.float} to be NaN"
   end
 
   test "update_all with infinity on a float column" do
@@ -41,11 +44,25 @@ class PostgresqlInfinityTest < ActiveRecord::PostgreSQLTestCase
   end
 
   test "type casting infinity on a datetime column" do
+    record = PostgresqlInfinity.create!(datetime: "infinity")
+    record.reload
+    assert_equal Float::INFINITY, record.datetime
+
     record = PostgresqlInfinity.create!(datetime: Float::INFINITY)
     record.reload
     assert_equal Float::INFINITY, record.datetime
   end
 
+  test "type casting infinity on a date column" do
+    record = PostgresqlInfinity.create!(date: "infinity")
+    record.reload
+    assert_equal Float::INFINITY, record.date
+
+    record = PostgresqlInfinity.create!(date: Float::INFINITY)
+    record.reload
+    assert_equal Float::INFINITY, record.date
+  end
+
   test "update_all with infinity on a datetime column" do
     record = PostgresqlInfinity.create!
     PostgresqlInfinity.update_all(datetime: Float::INFINITY)
@@ -54,16 +71,38 @@ class PostgresqlInfinityTest < ActiveRecord::PostgreSQLTestCase
   end
 
   test "assigning 'infinity' on a datetime column with TZ aware attributes" do
-    begin
-      in_time_zone "Pacific Time (US & Canada)" do
-        record = PostgresqlInfinity.create!(datetime: "infinity")
-        assert_equal Float::INFINITY, record.datetime
-        assert_equal record.datetime, record.reload.datetime
-      end
-    ensure
-      # setting time_zone_aware_attributes causes the types to change.
-      # There is no way to do this automatically since it can be set on a superclass
-      PostgresqlInfinity.reset_column_information
+    in_time_zone "Pacific Time (US & Canada)" do
+      record = PostgresqlInfinity.create!(datetime: "infinity")
+      assert_equal Float::INFINITY, record.datetime
+      assert_equal record.datetime, record.reload.datetime
     end
+  ensure
+    # setting time_zone_aware_attributes causes the types to change.
+    # There is no way to do this automatically since it can be set on a superclass
+    PostgresqlInfinity.reset_column_information
+  end
+
+  test "where clause with infinite range on a datetime column" do
+    record = PostgresqlInfinity.create!(datetime: Time.current)
+
+    string = PostgresqlInfinity.where(datetime: "-infinity".."infinity")
+    assert_equal record, string.take
+
+    infinity = PostgresqlInfinity.where(datetime: -::Float::INFINITY..::Float::INFINITY)
+    assert_equal record, infinity.take
+
+    assert_equal infinity.to_sql, string.to_sql
+  end
+
+  test "where clause with infinite range on a date column" do
+    record = PostgresqlInfinity.create!(date: Date.current)
+
+    string = PostgresqlInfinity.where(date: "-infinity".."infinity")
+    assert_equal record, string.take
+
+    infinity = PostgresqlInfinity.where(date: -::Float::INFINITY..::Float::INFINITY)
+    assert_equal record, infinity.take
+
+    assert_equal infinity.to_sql, string.to_sql
   end
 end

data/test/cases/adapters/postgresql/integer_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "active_support/core_ext/numeric/bytes"
 

data/test/cases/adapters/postgresql/interval_test.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/schema_dumping_helper"
+
+class PostgresqlIntervalTest < ActiveRecord::PostgreSQLTestCase
+  include SchemaDumpingHelper
+
+  class IntervalDataType < ActiveRecord::Base
+    attribute :maximum_term, :interval
+    attribute :minimum_term, :interval, precision: 3
+    attribute :default_term, :interval
+    attribute :all_terms,    :interval, array: true
+    attribute :legacy_term,  :string
+  end
+
+  class DeprecatedIntervalDataType < ActiveRecord::Base; end
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+    @connection.transaction do
+      @connection.create_table("interval_data_types") do |t|
+        t.interval "maximum_term"
+        t.interval "minimum_term", precision: 3
+        t.interval "default_term", default: "P3Y"
+        t.interval "all_terms", array: true
+        t.interval "legacy_term"
+      end
+      @connection.create_table("deprecated_interval_data_types") do |t|
+        t.interval "duration"
+      end
+    end
+    @column_max = IntervalDataType.columns_hash["maximum_term"]
+    @column_min = IntervalDataType.columns_hash["minimum_term"]
+    assert(@column_max.is_a?(ActiveRecord::ConnectionAdapters::PostgreSQLColumn))
+    assert(@column_min.is_a?(ActiveRecord::ConnectionAdapters::PostgreSQLColumn))
+    assert_nil @column_max.precision
+    assert_equal 3,   @column_min.precision
+  end
+
+  teardown do
+    @connection.execute "DROP TABLE IF EXISTS interval_data_types"
+    @connection.execute "DROP TABLE IF EXISTS deprecated_interval_data_types"
+  end
+
+  def test_column
+    assert_equal :interval,     @column_max.type
+    assert_equal :interval,     @column_min.type
+    assert_equal "interval",    @column_max.sql_type
+    assert_equal "interval(3)", @column_min.sql_type
+  end
+
+  def test_interval_type
+    IntervalDataType.create!(
+      maximum_term: 6.year + 5.month + 4.days + 3.hours + 2.minutes + 1.seconds,
+      minimum_term: 1.year + 2.month + 3.days + 4.hours + 5.minutes + (6.234567).seconds,
+      all_terms:    [1.month, 1.year, 1.hour],
+      legacy_term:  "33 years",
+    )
+    i = IntervalDataType.last!
+    assert_equal "P6Y5M4DT3H2M1S",     i.maximum_term.iso8601
+    assert_equal "P1Y2M3DT4H5M6.235S", i.minimum_term.iso8601
+    assert_equal "P3Y",                i.default_term.iso8601
+    assert_equal %w[ P1M P1Y PT1H ],   i.all_terms.map(&:iso8601)
+    assert_equal "P33Y",               i.legacy_term
+  end
+
+  def test_interval_type_cast_from_invalid_string
+    i = IntervalDataType.create!(maximum_term: "1 year 2 minutes")
+    i.reload
+    assert_nil i.maximum_term
+  end
+
+  def test_interval_type_cast_from_numeric
+    i = IntervalDataType.create!(minimum_term: 36000)
+    i.reload
+    assert_equal "PT10H",  i.minimum_term.iso8601
+  end
+
+  def test_interval_type_cast_string_and_numeric_from_user
+    i = IntervalDataType.new(maximum_term: "P1YT2M", minimum_term: "PT10H", legacy_term: "P1DT1H")
+    assert i.maximum_term.is_a?(ActiveSupport::Duration)
+    assert i.legacy_term.is_a?(String)
+    assert_equal "P1YT2M", i.maximum_term.iso8601
+    assert_equal "PT10H",  i.minimum_term.iso8601
+    assert_equal "P1DT1H", i.legacy_term
+  end
+
+  def test_deprecated_legacy_type
+    assert_deprecated do
+      DeprecatedIntervalDataType.new
+    end
+  end
+
+  def test_schema_dump_with_default_value
+    output = dump_table_schema "interval_data_types"
+    assert_match %r{t\.interval "default_term", default: "P3Y"}, output
+  end
+end

data/test/cases/adapters/postgresql/json_test.rb

@@ -1,223 +1,38 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require 'support/schema_dumping_helper'
+require "cases/json_shared_test_cases"
 
 module PostgresqlJSONSharedTestCases
-  include SchemaDumpingHelper
-
-  class JsonDataType < ActiveRecord::Base
-    self.table_name = 'json_data_type'
-
-    store_accessor :settings, :resolution
-  end
+  include JSONSharedTestCases
 
   def setup
-    @connection = ActiveRecord::Base.connection
-    begin
-      @connection.create_table('json_data_type') do |t|
-        t.public_send column_type, 'payload', default: {} # t.json 'payload', default: {}
-        t.public_send column_type, 'settings'             # t.json 'settings'
-        t.public_send column_type, 'objects', array: true # t.json 'objects', array: true
-      end
-    rescue ActiveRecord::StatementInvalid
-      skip "do not test on PostgreSQL without #{column_type} type."
+    super
+    @connection.create_table("json_data_type") do |t|
+      t.public_send column_type, "payload", default: {} # t.json 'payload', default: {}
+      t.public_send column_type, "settings"             # t.json 'settings'
+      t.public_send column_type, "objects", array: true # t.json 'objects', array: true
     end
-  end
-
-  def teardown
-    @connection.drop_table :json_data_type, if_exists: true
-    JsonDataType.reset_column_information
-  end
-
-  def test_column
-    column = JsonDataType.columns_hash["payload"]
-    assert_equal column_type, column.type
-    assert_equal column_type.to_s, column.sql_type
-    assert_not column.array?
-
-    type = JsonDataType.type_for_attribute("payload")
-    assert_not type.binary?
+  rescue ActiveRecord::StatementInvalid
+    skip "do not test on PostgreSQL without #{column_type} type."
   end
 
   def test_default
-    @connection.add_column 'json_data_type', 'permissions', column_type, default: {"users": "read", "posts": ["read", "write"]}
-    JsonDataType.reset_column_information
-
-    assert_equal({"users"=>"read", "posts"=>["read", "write"]}, JsonDataType.column_defaults['permissions'])
-    assert_equal({"users"=>"read", "posts"=>["read", "write"]}, JsonDataType.new.permissions)
-  ensure
-    JsonDataType.reset_column_information
-  end
-
-  def test_change_table_supports_json
-    @connection.transaction do
-      @connection.change_table('json_data_type') do |t|
-        t.public_send column_type, 'users', default: '{}' # t.json 'users', default: '{}'
-      end
-      JsonDataType.reset_column_information
-      column = JsonDataType.columns_hash['users']
-      assert_equal column_type, column.type
-
-      raise ActiveRecord::Rollback # reset the schema change
-    end
-  ensure
-    JsonDataType.reset_column_information
-  end
-
-  def test_schema_dumping
-    output = dump_table_schema("json_data_type")
-    assert_match(/t\.#{column_type.to_s}\s+"payload",\s+default: {}/, output)
-  end
+    @connection.add_column "json_data_type", "permissions", column_type, default: { "users": "read", "posts": ["read", "write"] }
+    klass.reset_column_information
 
-  def test_cast_value_on_write
-    x = JsonDataType.new payload: {"string" => "foo", :symbol => :bar}
-    assert_equal({"string" => "foo", :symbol => :bar}, x.payload_before_type_cast)
-    assert_equal({"string" => "foo", "symbol" => "bar"}, x.payload)
-    x.save
-    assert_equal({"string" => "foo", "symbol" => "bar"}, x.reload.payload)
+    assert_equal({ "users" => "read", "posts" => ["read", "write"] }, klass.column_defaults["permissions"])
+    assert_equal({ "users" => "read", "posts" => ["read", "write"] }, klass.new.permissions)
   end
 
   def test_deserialize_with_array
-    x = JsonDataType.new(objects: ["foo" => "bar"])
+    x = klass.new(objects: ["foo" => "bar"])
     assert_equal ["foo" => "bar"], x.objects
     x.save!
     assert_equal ["foo" => "bar"], x.objects
     x.reload
     assert_equal ["foo" => "bar"], x.objects
   end
-
-  def test_type_cast_json
-    type = JsonDataType.type_for_attribute("payload")
-
-    data = "{\"a_key\":\"a_value\"}"
-    hash = type.deserialize(data)
-    assert_equal({'a_key' => 'a_value'}, hash)
-    assert_equal({'a_key' => 'a_value'}, type.deserialize(data))
-
-    assert_equal({}, type.deserialize("{}"))
-    assert_equal({'key'=>nil}, type.deserialize('{"key": null}'))
-    assert_equal({'c'=>'}','"a"'=>'b "a b'}, type.deserialize(%q({"c":"}", "\"a\"":"b \"a b"})))
-  end
-
-  def test_rewrite
-    @connection.execute "insert into json_data_type (payload) VALUES ('{\"k\":\"v\"}')"
-    x = JsonDataType.first
-    x.payload = { '"a\'' => 'b' }
-    assert x.save!
-  end
-
-  def test_select
-    @connection.execute "insert into json_data_type (payload) VALUES ('{\"k\":\"v\"}')"
-    x = JsonDataType.first
-    assert_equal({'k' => 'v'}, x.payload)
-  end
-
-  def test_select_multikey
-    @connection.execute %q|insert into json_data_type (payload) VALUES ('{"k1":"v1", "k2":"v2", "k3":[1,2,3]}')|
-    x = JsonDataType.first
-    assert_equal({'k1' => 'v1', 'k2' => 'v2', 'k3' => [1,2,3]}, x.payload)
-  end
-
-  def test_null_json
-    @connection.execute %q|insert into json_data_type (payload) VALUES(null)|
-    x = JsonDataType.first
-    assert_equal(nil, x.payload)
-  end
-
-  def test_select_nil_json_after_create
-    json = JsonDataType.create(payload: nil)
-    x = JsonDataType.where(payload:nil).first
-    assert_equal(json, x)
-  end
-
-  def test_select_nil_json_after_update
-    json = JsonDataType.create(payload: "foo")
-    x = JsonDataType.where(payload:nil).first
-    assert_equal(nil, x)
-
-    json.update_attributes payload: nil
-    x = JsonDataType.where(payload:nil).first
-    assert_equal(json.reload, x)
-  end
-
-  def test_select_array_json_value
-    @connection.execute %q|insert into json_data_type (payload) VALUES ('["v0",{"k1":"v1"}]')|
-    x = JsonDataType.first
-    assert_equal(['v0', {'k1' => 'v1'}], x.payload)
-  end
-
-  def test_rewrite_array_json_value
-    @connection.execute %q|insert into json_data_type (payload) VALUES ('["v0",{"k1":"v1"}]')|
-    x = JsonDataType.first
-    x.payload = ['v1', {'k2' => 'v2'}, 'v3']
-    assert x.save!
-  end
-
-  def test_with_store_accessors
-    x = JsonDataType.new(resolution: "320×480")
-    assert_equal "320×480", x.resolution
-
-    x.save!
-    x = JsonDataType.first
-    assert_equal "320×480", x.resolution
-
-    x.resolution = "640×1136"
-    x.save!
-
-    x = JsonDataType.first
-    assert_equal "640×1136", x.resolution
-  end
-
-  def test_duplication_with_store_accessors
-    x = JsonDataType.new(resolution: "320×480")
-    assert_equal "320×480", x.resolution
-
-    y = x.dup
-    assert_equal "320×480", y.resolution
-  end
-
-  def test_yaml_round_trip_with_store_accessors
-    x = JsonDataType.new(resolution: "320×480")
-    assert_equal "320×480", x.resolution
-
-    y = YAML.load(YAML.dump(x))
-    assert_equal "320×480", y.resolution
-  end
-
-  def test_changes_in_place
-    json = JsonDataType.new
-    assert_not json.changed?
-
-    json.payload = { 'one' => 'two' }
-    assert json.changed?
-    assert json.payload_changed?
-
-    json.save!
-    assert_not json.changed?
-
-    json.payload['three'] = 'four'
-    assert json.payload_changed?
-
-    json.save!
-    json.reload
-
-    assert_equal({ 'one' => 'two', 'three' => 'four' }, json.payload)
-    assert_not json.changed?
-  end
-
-  def test_assigning_string_literal
-    json = JsonDataType.create(payload: "foo")
-    assert_equal "foo", json.payload
-  end
-
-  def test_assigning_number
-    json = JsonDataType.create(payload: 1.234)
-    assert_equal 1.234, json.payload
-  end
-
-  def test_assigning_boolean
-    json = JsonDataType.create(payload: true)
-    assert_equal true, json.payload
-  end
 end
 
 class PostgresqlJSONTest < ActiveRecord::PostgreSQLTestCase

data/test/cases/adapters/postgresql/ltree_test.rb

@@ -1,49 +1,47 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require 'support/schema_dumping_helper'
+require "support/schema_dumping_helper"
 
 class PostgresqlLtreeTest < ActiveRecord::PostgreSQLTestCase
   include SchemaDumpingHelper
   class Ltree < ActiveRecord::Base
-    self.table_name = 'ltrees'
+    self.table_name = "ltrees"
   end
 
   def setup
     @connection = ActiveRecord::Base.connection
 
-    enable_extension!('ltree', @connection)
+    enable_extension!("ltree", @connection)
 
-    @connection.transaction do
-      @connection.create_table('ltrees') do |t|
-        t.ltree 'path'
-      end
+    @connection.create_table("ltrees") do |t|
+      t.ltree "path"
     end
-  rescue ActiveRecord::StatementInvalid
-    skip "do not test on PG without ltree"
   end
 
   teardown do
-    @connection.drop_table 'ltrees', if_exists: true
+    @connection.drop_table "ltrees", if_exists: true
   end
 
   def test_column
-    column = Ltree.columns_hash['path']
+    column = Ltree.columns_hash["path"]
     assert_equal :ltree, column.type
     assert_equal "ltree", column.sql_type
-    assert_not column.array?
+    assert_not_predicate column, :array?
 
-    type = Ltree.type_for_attribute('path')
-    assert_not type.binary?
+    type = Ltree.type_for_attribute("path")
+    assert_not_predicate type, :binary?
   end
 
   def test_write
-    ltree = Ltree.new(path: '1.2.3.4')
+    ltree = Ltree.new(path: "1.2.3.4")
     assert ltree.save!
   end
 
   def test_select
     @connection.execute "insert into ltrees (path) VALUES ('1.2.3')"
     ltree = Ltree.first
-    assert_equal '1.2.3', ltree.path
+    assert_equal "1.2.3", ltree.path
   end
 
   def test_schema_dump_with_shorthand

data/test/cases/adapters/postgresql/money_test.rb

@@ -1,22 +1,26 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require 'support/schema_dumping_helper'
+require "support/schema_dumping_helper"
 
 class PostgresqlMoneyTest < ActiveRecord::PostgreSQLTestCase
   include SchemaDumpingHelper
 
-  class PostgresqlMoney < ActiveRecord::Base; end
+  class PostgresqlMoney < ActiveRecord::Base
+    validates :depth, numericality: true
+  end
 
   setup do
     @connection = ActiveRecord::Base.connection
     @connection.execute("set lc_monetary = 'C'")
-    @connection.create_table('postgresql_moneys', force: true) do |t|
+    @connection.create_table("postgresql_moneys", force: true) do |t|
       t.money "wealth"
       t.money "depth", default: "150.55"
     end
   end
 
   teardown do
-    @connection.drop_table 'postgresql_moneys', if_exists: true
+    @connection.drop_table "postgresql_moneys", if_exists: true
   end
 
   def test_column
@@ -24,15 +28,16 @@ class PostgresqlMoneyTest < ActiveRecord::PostgreSQLTestCase
     assert_equal :money, column.type
     assert_equal "money", column.sql_type
     assert_equal 2, column.scale
-    assert_not column.array?
+    assert_not_predicate column, :array?
 
     type = PostgresqlMoney.type_for_attribute("wealth")
-    assert_not type.binary?
+    assert_not_predicate type, :binary?
   end
 
   def test_default
-    assert_equal BigDecimal.new("150.55"), PostgresqlMoney.column_defaults['depth']
-    assert_equal BigDecimal.new("150.55"), PostgresqlMoney.new.depth
+    assert_equal BigDecimal("150.55"), PostgresqlMoney.column_defaults["depth"]
+    assert_equal BigDecimal("150.55"), PostgresqlMoney.new.depth
+    assert_equal "150.55", PostgresqlMoney.new.depth_before_type_cast
   end
 
   def test_money_values
@@ -43,14 +48,40 @@ class PostgresqlMoneyTest < ActiveRecord::PostgreSQLTestCase
     second_money = PostgresqlMoney.find(2)
     assert_equal 567.89, first_money.wealth
     assert_equal(-567.89, second_money.wealth)
+    assert_equal 567.89, @connection.query_value("SELECT wealth FROM postgresql_moneys WHERE id = 1")
+    assert_equal(-567.89, @connection.query_value("SELECT wealth FROM postgresql_moneys WHERE id = 2"))
   end
 
   def test_money_type_cast
-    type = PostgresqlMoney.type_for_attribute('wealth')
-    assert_equal(12345678.12, type.cast("$12,345,678.12"))
-    assert_equal(12345678.12, type.cast("$12.345.678,12"))
-    assert_equal(-1.15, type.cast("-$1.15"))
-    assert_equal(-2.25, type.cast("($2.25)"))
+    type = PostgresqlMoney.type_for_attribute("wealth")
+    assert_equal(12345678.12, type.cast(+"$12,345,678.12"))
+    assert_equal(12345678.12, type.cast(+"$12.345.678,12"))
+    assert_equal(12345678.12, type.cast(+"12,345,678.12"))
+    assert_equal(12345678.12, type.cast(+"12.345.678,12"))
+    assert_equal(-1.15, type.cast(+"-$1.15"))
+    assert_equal(-2.25, type.cast(+"($2.25)"))
+    assert_equal(-1.15, type.cast(+"-1.15"))
+    assert_equal(-2.25, type.cast(+"(2.25)"))
+  end
+
+  def test_money_regex_backtracking
+    type = PostgresqlMoney.type_for_attribute("wealth")
+    Timeout.timeout(0.1) do
+      assert_equal(0.0, type.cast("$" + "," * 100000 + ".11!"))
+      assert_equal(0.0, type.cast("$" + "." * 100000 + ",11!"))
+    end
+  end
+
+  def test_sum_with_type_cast
+    @connection.execute("INSERT INTO postgresql_moneys (id, wealth) VALUES (1, '123.45'::money)")
+
+    assert_equal BigDecimal("123.45"), PostgresqlMoney.sum("id * wealth")
+  end
+
+  def test_pluck_with_type_cast
+    @connection.execute("INSERT INTO postgresql_moneys (id, wealth) VALUES (1, '123.45'::money)")
+
+    assert_equal [BigDecimal("123.45")], PostgresqlMoney.pluck(Arel.sql("id * wealth"))
   end
 
   def test_schema_dumping
@@ -60,10 +91,10 @@ class PostgresqlMoneyTest < ActiveRecord::PostgreSQLTestCase
   end
 
   def test_create_and_update_money
-    money = PostgresqlMoney.create(wealth: "987.65")
+    money = PostgresqlMoney.create(wealth: +"987.65")
     assert_equal 987.65, money.wealth
 
-    new_value = BigDecimal.new('123.45')
+    new_value = BigDecimal("123.45")
     money.wealth = new_value
     money.save!
     money.reload
@@ -80,7 +111,7 @@ class PostgresqlMoneyTest < ActiveRecord::PostgreSQLTestCase
 
   def test_update_all_with_money_big_decimal
     money = PostgresqlMoney.create!
-    PostgresqlMoney.update_all(wealth: '123.45'.to_d)
+    PostgresqlMoney.update_all(wealth: "123.45".to_d)
     money.reload
 
     assert_equal 123.45, money.wealth