ibm_db 5.2.0-x86-mingw32 → 5.3.2-x86-mingw32

data/test/cases/bind_parameter_test.rb

@@ -1,13 +1,15 @@
-require 'cases/helper'
-require 'models/topic'
-require 'models/author'
-require 'models/post'
+# frozen_string_literal: true
 
-if ActiveRecord::Base.connection.supports_statement_cache? &&
-   ActiveRecord::Base.connection.prepared_statements
+require "cases/helper"
+require "models/topic"
+require "models/reply"
+require "models/author"
+require "models/post"
+
+if ActiveRecord::Base.connection.prepared_statements
   module ActiveRecord
     class BindParameterTest < ActiveRecord::TestCase
-      fixtures :topics, :authors, :posts
+      fixtures :topics, :authors, :author_addresses, :posts
 
       class LogListener
         attr_accessor :calls
@@ -23,7 +25,6 @@ if ActiveRecord::Base.connection.supports_statement_cache? &&
 
       def setup
         super
-		puts "BindParameterTest - setup"
         @connection = ActiveRecord::Base.connection
         @subscriber = LogListener.new
         @pk = Topic.columns_hash[Topic.primary_key]
@@ -31,55 +32,227 @@ if ActiveRecord::Base.connection.supports_statement_cache? &&
       end
 
       def teardown
-	    puts "BindParameterTest - teardown"
         ActiveSupport::Notifications.unsubscribe(@subscription)
       end
 
+      def test_statement_cache
+        @connection.clear_cache!
+
+        topics = Topic.where(id: 1)
+        assert_equal [1], topics.map(&:id)
+        assert_includes statement_cache, to_sql_key(topics.arel)
+
+        @connection.clear_cache!
+
+        assert_not_includes statement_cache, to_sql_key(topics.arel)
+      end
+
+      def test_statement_cache_with_query_cache
+        @connection.enable_query_cache!
+        @connection.clear_cache!
+
+        topics = Topic.where(id: 1)
+        assert_equal [1], topics.map(&:id)
+        assert_includes statement_cache, to_sql_key(topics.arel)
+      ensure
+        @connection.disable_query_cache!
+      end
+
+      def test_statement_cache_with_find
+        @connection.clear_cache!
+
+        assert_equal 1, Topic.find(1).id
+        assert_raises(RecordNotFound) { SillyReply.find(2) }
+
+        topic_sql = cached_statement(Topic, Topic.primary_key)
+        assert_includes statement_cache, to_sql_key(topic_sql)
+
+        reply_sql = cached_statement(SillyReply, SillyReply.primary_key)
+        assert_includes statement_cache, to_sql_key(reply_sql)
+
+        replies = SillyReply.where(id: 2).limit(1)
+        assert_includes statement_cache, to_sql_key(replies.arel)
+      end
+
+      def test_statement_cache_with_find_by
+        @connection.clear_cache!
+
+        assert_equal 1, Topic.find_by!(id: 1).id
+        assert_raises(RecordNotFound) { SillyReply.find_by!(id: 2) }
+
+        topic_sql = cached_statement(Topic, ["id"])
+        assert_includes statement_cache, to_sql_key(topic_sql)
+
+        reply_sql = cached_statement(SillyReply, ["id"])
+        assert_includes statement_cache, to_sql_key(reply_sql)
+
+        replies = SillyReply.where(id: 2).limit(1)
+        assert_includes statement_cache, to_sql_key(replies.arel)
+      end
+
+      def test_statement_cache_with_in_clause
+        @connection.clear_cache!
+
+        topics = Topic.where(id: [1, 3]).order(:id)
+        assert_equal [1, 3], topics.map(&:id)
+        assert_not_includes statement_cache, to_sql_key(topics.arel)
+      end
+
+      def test_statement_cache_with_sql_string_literal
+        @connection.clear_cache!
+
+        topics = Topic.where("topics.id = ?", 1)
+        assert_equal [1], topics.map(&:id)
+        assert_not_includes statement_cache, to_sql_key(topics.arel)
+      end
+
+      def test_too_many_binds
+        bind_params_length = @connection.send(:bind_params_length)
+
+        topics = Topic.where(id: (1 .. bind_params_length).to_a << 2**63)
+        assert_equal Topic.count, topics.count
+
+        topics = Topic.where.not(id: (1 .. bind_params_length).to_a << 2**63)
+        assert_equal 0, topics.count
+      end
+
+      def test_too_many_binds_with_query_cache
+        @connection.enable_query_cache!
+
+        bind_params_length = @connection.send(:bind_params_length)
+        topics = Topic.where(id: (1 .. bind_params_length + 1).to_a)
+        assert_equal Topic.count, topics.count
+
+        topics = Topic.where.not(id: (1 .. bind_params_length + 1).to_a)
+        assert_equal 0, topics.count
+      ensure
+        @connection.disable_query_cache!
+      end
+
       def test_bind_from_join_in_subquery
-	    puts "BindParameterTest - test_bind_from_join_in_subquery"
-        subquery = Author.joins(:thinking_posts).where(name: 'David')
-        scope = Author.from(subquery, 'authors').where(id: 1)
+        subquery = Author.joins(:thinking_posts).where(name: "David")
+        scope = Author.from(subquery, "authors").where(id: 1)
         assert_equal 1, scope.count
       end
 
       def test_binds_are_logged
-	    puts "BindParameterTest - test_binds_are_logged"
-        sub   = Arel::Nodes::BindParam.new
+        sub   = Arel::Nodes::BindParam.new(1)
         binds = [Relation::QueryAttribute.new("id", 1, Type::Value.new)]
         sql   = "select * from topics where id = #{sub.to_sql}"
 
-        @connection.exec_query(sql, 'SQL', binds)
+        @connection.exec_query(sql, "SQL", binds)
 
         message = @subscriber.calls.find { |args| args[4][:sql] == sql }
         assert_equal binds, message[4][:binds]
       end
 
       def test_find_one_uses_binds
-	    puts "BindParameterTest - test_find_one_uses_binds"
         Topic.find(1)
         message = @subscriber.calls.find { |args| args[4][:binds].any? { |attr| attr.value == 1 } }
-        assert message, 'expected a message with binds'
+        assert message, "expected a message with binds"
       end
 
       def test_logs_binds_after_type_cast
-	    puts "BindParameterTest - test_logs_binds_after_type_cast"
         binds = [Relation::QueryAttribute.new("id", "10", Type::Integer.new)]
         assert_logs_binds(binds)
       end
 
       def test_logs_legacy_binds_after_type_cast
-	    puts "BindParameterTest - test_logs_legacy_binds_after_type_cast"
         binds = [[@pk, "10"]]
-        assert_logs_binds(binds)
+        assert_deprecated do
+          assert_logs_binds(binds)
+        end
+      end
+
+      def test_bind_params_to_sql_with_prepared_statements
+        assert_bind_params_to_sql
+      end
+
+      def test_bind_params_to_sql_with_unprepared_statements
+        @connection.unprepared_statement do
+          assert_bind_params_to_sql
+        end
+      end
+
+      def test_nested_unprepared_statements
+        assert_predicate @connection, :prepared_statements?
+
+        @connection.unprepared_statement do
+          assert_not_predicate @connection, :prepared_statements?
+
+          @connection.unprepared_statement do
+            assert_not_predicate @connection, :prepared_statements?
+          end
+
+          assert_not_predicate @connection, :prepared_statements?
+        end
+
+        assert_predicate @connection, :prepared_statements?
       end
 
       private
+        def assert_bind_params_to_sql
+          table = Author.quoted_table_name
+          pk = "#{table}.#{Author.quoted_primary_key}"
+
+          # prepared_statements: true
+          #
+          #   SELECT `authors`.* FROM `authors` WHERE (`authors`.`id` IN (?, ?, ?) OR `authors`.`id` IS NULL)
+          #
+          # prepared_statements: false
+          #
+          #   SELECT `authors`.* FROM `authors` WHERE (`authors`.`id` IN (1, 2, 3) OR `authors`.`id` IS NULL)
+          #
+          sql = "SELECT #{table}.* FROM #{table} WHERE (#{pk} IN (#{bind_params(1..3)}) OR #{pk} IS NULL)"
+
+          authors = Author.where(id: [1, 2, 3, nil])
+          assert_equal sql, @connection.to_sql(authors.arel)
+          assert_sql(sql) { assert_equal 3, authors.length }
+
+          # prepared_statements: true
+          #
+          #   SELECT `authors`.* FROM `authors` WHERE `authors`.`id` IN (?, ?, ?)
+          #
+          # prepared_statements: false
+          #
+          #   SELECT `authors`.* FROM `authors` WHERE `authors`.`id` IN (1, 2, 3)
+          #
+          sql = "SELECT #{table}.* FROM #{table} WHERE #{pk} IN (#{bind_params(1..3)})"
+
+          authors = Author.where(id: [1, 2, 3, 9223372036854775808])
+          assert_equal sql, @connection.to_sql(authors.arel)
+          assert_sql(sql) { assert_equal 3, authors.length }
+        end
+
+        def bind_params(ids)
+          collector = @connection.send(:collector)
+          bind_params = ids.map { |i| Arel::Nodes::BindParam.new(i) }
+          sql, _ = @connection.visitor.compile(bind_params, collector)
+          sql
+        end
+
+        def to_sql_key(arel)
+          sql = @connection.to_sql(arel)
+          @connection.respond_to?(:sql_key, true) ? @connection.send(:sql_key, sql) : sql
+        end
+
+        def cached_statement(klass, key)
+          cache = klass.send(:cached_find_by_statement, key) do
+            raise "#{klass} has no cached statement by #{key.inspect}"
+          end
+          cache.send(:query_builder).instance_variable_get(:@sql)
+        end
+
+        def statement_cache
+          @connection.instance_variable_get(:@statements).send(:cache)
+        end
+
         def assert_logs_binds(binds)
           payload = {
             name: "SQL",
             sql: "select * from topics where id = ?",
             binds: binds,
-            type_casted_binds: @connection.type_casted_binds(binds)
+            type_casted_binds: @connection.send(:type_casted_binds, binds)
           }
 
           event = ActiveSupport::Notifications::Event.new(

data/test/cases/boolean_test.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/boolean"
+
+class BooleanTest < ActiveRecord::TestCase
+  def test_boolean
+    b_nil   = Boolean.create!(value: nil)
+    b_false = Boolean.create!(value: false)
+    b_true  = Boolean.create!(value: true)
+
+    assert_nil Boolean.find(b_nil.id).value
+    assert_not_predicate Boolean.find(b_false.id), :value?
+    assert_predicate Boolean.find(b_true.id), :value?
+  end
+
+  def test_boolean_without_questionmark
+    b_true = Boolean.create!(value: true)
+
+    subclass   = Class.new(Boolean).find(b_true.id)
+    superclass = Boolean.find(b_true.id)
+
+    assert_equal superclass.read_attribute(:has_fun), subclass.read_attribute(:has_fun)
+  end
+
+  def test_boolean_cast_from_string
+    b_blank = Boolean.create!(value: "")
+    b_false = Boolean.create!(value: "0")
+    b_true  = Boolean.create!(value: "1")
+
+    assert_nil Boolean.find(b_blank.id).value
+    assert_not_predicate Boolean.find(b_false.id), :value?
+    assert_predicate Boolean.find(b_true.id), :value?
+  end
+
+  def test_find_by_boolean_string
+    b_false = Boolean.create!(value: "false")
+    b_true  = Boolean.create!(value: "true")
+
+    assert_equal b_false, Boolean.find_by(value: "false")
+    assert_equal b_true, Boolean.find_by(value: "true")
+  end
+
+  def test_find_by_falsy_boolean_symbol
+    ActiveModel::Type::Boolean::FALSE_VALUES.each do |value|
+      b_false = Boolean.create!(value: value)
+
+      assert_not_predicate b_false, :value?
+      assert_equal b_false, Boolean.find_by(id: b_false.id, value: value.to_s.to_sym)
+    end
+  end
+end

data/test/cases/cache_key_test.rb

@@ -1,26 +1,131 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 module ActiveRecord
   class CacheKeyTest < ActiveRecord::TestCase
     self.use_transactional_tests = false
 
-    class CacheMe < ActiveRecord::Base; end
+    class CacheMe < ActiveRecord::Base
+      self.cache_versioning = false
+    end
+
+    class CacheMeWithVersion < ActiveRecord::Base
+      self.cache_versioning = true
+    end
 
     setup do
       @connection = ActiveRecord::Base.connection
-      @connection.create_table(:cache_mes) { |t| t.timestamps }
+      @connection.create_table(:cache_mes, force: true) { |t| t.timestamps }
+      @connection.create_table(:cache_me_with_versions, force: true) { |t| t.timestamps }
     end
 
     teardown do
-      @connection.drop_table :cache_mes
-	  #, if_exists: true
+      @connection.drop_table :cache_mes, if_exists: true
+      @connection.drop_table :cache_me_with_versions, if_exists: true
     end
 
-    test "test_cache_key_format_is_not_too_precise" do
+    test "cache_key format is not too precise" do
       record = CacheMe.create
       key = record.cache_key
 
       assert_equal key, record.reload.cache_key
     end
+
+    test "cache_key has no version when versioning is on" do
+      record = CacheMeWithVersion.create
+      assert_equal "active_record/cache_key_test/cache_me_with_versions/#{record.id}", record.cache_key
+    end
+
+    test "cache_version is only there when versioning is on" do
+      assert_predicate CacheMeWithVersion.create.cache_version, :present?
+      assert_not_predicate CacheMe.create.cache_version, :present?
+    end
+
+    test "cache_key_with_version always has both key and version" do
+      r1 = CacheMeWithVersion.create
+      assert_equal "active_record/cache_key_test/cache_me_with_versions/#{r1.id}-#{r1.updated_at.utc.to_s(:usec)}", r1.cache_key_with_version
+
+      r2 = CacheMe.create
+      assert_equal "active_record/cache_key_test/cache_mes/#{r2.id}-#{r2.updated_at.utc.to_s(:usec)}", r2.cache_key_with_version
+    end
+
+    test "cache_version is the same when it comes from the DB or from the user" do
+      skip("Mysql2 and PostgreSQL don't return a string value for updated_at") if current_adapter?(:Mysql2Adapter, :PostgreSQLAdapter)
+
+      record = CacheMeWithVersion.create
+      record_from_db = CacheMeWithVersion.find(record.id)
+      assert_not_called(record_from_db, :updated_at) do
+        record_from_db.cache_version
+      end
+
+      assert_equal record.cache_version, record_from_db.cache_version
+    end
+
+    test "cache_version does not truncate zeros when timestamp ends in zeros" do
+      skip("Mysql2 and PostgreSQL don't return a string value for updated_at") if current_adapter?(:Mysql2Adapter, :PostgreSQLAdapter)
+
+      travel_to Time.now.beginning_of_day do
+        record = CacheMeWithVersion.create
+        record_from_db = CacheMeWithVersion.find(record.id)
+        assert_not_called(record_from_db, :updated_at) do
+          record_from_db.cache_version
+        end
+
+        assert_equal record.cache_version, record_from_db.cache_version
+      end
+    end
+
+    test "cache_version calls updated_at when the value is generated at create time" do
+      record = CacheMeWithVersion.create
+      assert_called(record, :updated_at) do
+        record.cache_version
+      end
+    end
+
+    test "cache_version does NOT call updated_at when value is from the database" do
+      skip("Mysql2 and PostgreSQL don't return a string value for updated_at") if current_adapter?(:Mysql2Adapter, :PostgreSQLAdapter)
+
+      record = CacheMeWithVersion.create
+      record_from_db = CacheMeWithVersion.find(record.id)
+      assert_not_called(record_from_db, :updated_at) do
+        record_from_db.cache_version
+      end
+    end
+
+    test "cache_version does call updated_at when it is assigned via a Time object" do
+      record = CacheMeWithVersion.create
+      record_from_db = CacheMeWithVersion.find(record.id)
+      assert_called(record_from_db, :updated_at) do
+        record_from_db.updated_at = Time.now
+        record_from_db.cache_version
+      end
+    end
+
+    test "cache_version does call updated_at when it is assigned via a string" do
+      record = CacheMeWithVersion.create
+      record_from_db = CacheMeWithVersion.find(record.id)
+      assert_called(record_from_db, :updated_at) do
+        record_from_db.updated_at = Time.now.to_s
+        record_from_db.cache_version
+      end
+    end
+
+    test "cache_version does call updated_at when it is assigned via a hash" do
+      record = CacheMeWithVersion.create
+      record_from_db = CacheMeWithVersion.find(record.id)
+      assert_called(record_from_db, :updated_at) do
+        record_from_db.updated_at = { 1 => 2016, 2 => 11, 3 => 12, 4 => 1, 5 => 2, 6 => 3, 7 => 22 }
+        record_from_db.cache_version
+      end
+    end
+
+    test "updated_at on class but not on instance raises an error" do
+      record = CacheMeWithVersion.create
+      record_from_db = CacheMeWithVersion.where(id: record.id).select(:id).first
+      assert_raises(ActiveModel::MissingAttributeError) do
+        record_from_db.cache_version
+      end
+    end
   end
 end