activerecord-cockroachdb-adapter 8.0.3 → 8.1.1

data/test/cases/adapter_test.rb

@@ -0,0 +1,98 @@
+require "cases/helper_cockroachdb"
+require "models/binary"
+require "models/developer"
+require "models/post"
+require "models/author"
+
+module CockroachDB
+  class AdapterTest < ActiveRecord::TestCase
+    self.use_transactional_tests = false
+
+    def setup
+      @connection = ActiveRecord::Base.lease_connection
+    end
+
+    # This replaces the same test that's been excluded from
+    # ActiveRecord::AdapterTest. We can run it here with
+    # use_transactional_tests set to false.
+    # See test/excludes/ActiveRecord/AdapterTest.rb.
+    def test_indexes
+      idx_name = "accounts_idx"
+
+      indexes = @connection.indexes("accounts")
+      assert_empty indexes
+
+      @connection.add_index :accounts, :firm_id, name: idx_name
+      indexes = @connection.indexes("accounts")
+      assert_equal "accounts", indexes.first.table
+      assert_equal idx_name, indexes.first.name
+      assert !indexes.first.unique
+      assert_equal ["firm_id"], indexes.first.columns
+    ensure
+      @connection.remove_index(:accounts, name: idx_name, if_exists: true)
+    end
+
+    # This replaces the same test that's been excluded from
+    # ActiveRecord::AdapterTest. We can run it here with
+    # use_transactional_tests set to false.
+    # See test/excludes/ActiveRecord/AdapterTest.rb.
+    def test_remove_index_when_name_and_wrong_column_name_specified
+      index_name = "accounts_idx"
+
+      @connection.add_index :accounts, :firm_id, name: index_name
+      assert_raises ArgumentError do
+        @connection.remove_index :accounts, name: index_name, column: :wrong_column_name
+      end
+    ensure
+      @connection.remove_index(:accounts, name: index_name)
+    end
+
+    # This replaces the same test that's been excluded from
+    # ActiveRecord::AdapterTest. We can run it here with
+    # use_transactional_tests set to false.
+    # See test/excludes/ActiveRecord/AdapterTest.rb.
+    def test_remove_index_when_name_and_wrong_column_name_specified_positional_argument
+      index_name = "accounts_idx"
+
+      @connection.add_index :accounts, :firm_id, name: index_name
+      assert_raises ArgumentError do
+        @connection.remove_index :accounts, :wrong_column_name, name: index_name
+      end
+    ensure
+      @connection.remove_index(:accounts, name: index_name)
+    end
+
+  end
+
+  class AdapterTestWithoutTransaction < ActiveRecord::TestCase
+    self.use_transactional_tests = false
+
+    class Widget < ActiveRecord::Base
+      self.primary_key = "widgetid"
+    end
+
+    def setup
+      @connection = ActiveRecord::Base.lease_connection
+    end
+
+    teardown do
+      @connection.drop_table :widgets, if_exists: true
+      @connection.exec_query("DROP SEQUENCE IF EXISTS widgets_seq")
+    end
+
+    # This test replaces the excluded test_reset_empty_table_with_custom_pk. We
+    # can run the same assertions, but we have to manually create the table so
+    # it has a primary key sequence.
+    # See test/excludes/ActiveRecord/AdapterTestWithoutTransaction.rb.
+    def test_reset_empty_table_with_custom_pk_sequence
+      @connection.exec_query("CREATE SEQUENCE widgets_seq")
+      @connection.exec_query("
+        CREATE TABLE widgets (
+          widgetid INT PRIMARY KEY DEFAULT nextval('widgets_seq'),
+          name string
+        )
+      ")
+      assert_equal 1, Widget.create(name: "weather").id
+    end
+  end
+end

data/test/cases/adapters/cockroachdb/cached_plan_failure_test.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "cases/helper_cockroachdb"
+
+class CockroachDBCachedPlanFailureTest < ActiveRecord::PostgreSQLTestCase
+  FakeResult = Struct.new(:fields) do
+    def result_error_field(code)
+      fields[code]
+    end
+  end
+  FakeError = Struct.new(:result)
+
+  # Reference the adapter's constant so the tests can't drift from the
+  # heuristic they are meant to verify.
+  CACHED_PLAN_MESSAGE =
+    ActiveRecord::ConnectionAdapters::CockroachDBAdapter::CACHED_PLAN_HEURISTIC
+
+  def setup
+    @connection = ActiveRecord::Base.lease_connection
+  end
+
+  # CockroachDB has raised this error from "runExecBuilder" (Execute
+  # phase) and, since cockroachdb/cockroach#164406, from "execBind"
+  # (Bind phase). Detection must not depend on the source function.
+  def test_detects_cached_plan_failure_from_any_source_function
+    %w[runExecBuilder execBind].each do |source_function|
+      pgerror = FakeError.new(FakeResult.new({
+        PG::PG_DIAG_SQLSTATE => "0A000",
+        PG::PG_DIAG_MESSAGE_PRIMARY => CACHED_PLAN_MESSAGE,
+        PG::PG_DIAG_SOURCE_FUNCTION => source_function
+      }))
+      assert @connection.send(:is_cached_plan_failure?, pgerror),
+        "expected cached plan failure to be detected when raised from #{source_function}"
+    end
+  end
+
+  def test_detects_cached_plan_failure_with_wrapped_message
+    pgerror = FakeError.new(FakeResult.new({
+      PG::PG_DIAG_SQLSTATE => "0A000",
+      PG::PG_DIAG_MESSAGE_PRIMARY => "portal \"p1\": #{CACHED_PLAN_MESSAGE}"
+    }))
+    assert @connection.send(:is_cached_plan_failure?, pgerror)
+  end
+
+  def test_ignores_other_feature_not_supported_errors
+    pgerror = FakeError.new(FakeResult.new({
+      PG::PG_DIAG_SQLSTATE => "0A000",
+      PG::PG_DIAG_MESSAGE_PRIMARY => "unimplemented: something else"
+    }))
+    assert_not @connection.send(:is_cached_plan_failure?, pgerror)
+  end
+
+  def test_ignores_cached_plan_message_with_other_sqlstate
+    pgerror = FakeError.new(FakeResult.new({
+      PG::PG_DIAG_SQLSTATE => "XX000",
+      PG::PG_DIAG_MESSAGE_PRIMARY => CACHED_PLAN_MESSAGE
+    }))
+    assert_not @connection.send(:is_cached_plan_failure?, pgerror)
+  end
+
+  def test_returns_false_when_error_fields_unavailable
+    assert_not @connection.send(:is_cached_plan_failure?, Object.new)
+  end
+
+  # End-to-end check that a real cached-plan failure is caught and recovered
+  # from against a live server, rather than only exercising the classifier
+  # with fabricated errors. Adding a column changes the result type of a
+  # cached `SELECT *`, which makes CockroachDB raise FEATURE_NOT_SUPPORTED
+  # ("cached plan must not change result type") the next time the prepared
+  # statement runs. The adapter must evict the stale statement and retry.
+  #
+  # Recovery only happens outside a transaction (inside one, the adapter can
+  # only raise PreparedStatementCacheExpired), so this test must not run in
+  # the suite's wrapping transaction.
+  exclude_from_transactional_tests :test_recovers_from_real_cached_plan_failure
+
+  def test_recovers_from_real_cached_plan_failure
+    @connection.execute("DROP TABLE IF EXISTS cached_plan_things")
+    @connection.execute("CREATE TABLE cached_plan_things (id INT PRIMARY KEY, a INT)")
+    @connection.execute("INSERT INTO cached_plan_things (id, a) VALUES (1, 10)")
+
+    sql = "SELECT * FROM cached_plan_things WHERE id = $1"
+    bind = ActiveRecord::Relation::QueryAttribute.new(
+      "id", 1, ActiveRecord::Type::Integer.new
+    )
+
+    # Prime the server-side prepared statement cache. `prepare: true` forces
+    # the prepared-statement code path that contains the recovery logic.
+    first = @connection.exec_query(sql, "SQL", [bind], prepare: true)
+    assert_equal ["id", "a"], first.columns
+
+    # Invalidate the cached plan by changing the result type.
+    @connection.execute("ALTER TABLE cached_plan_things ADD COLUMN b INT")
+
+    # Re-running the same prepared statement would raise without recovery;
+    # the adapter should transparently flush the stale statement and retry.
+    second = assert_nothing_raised do
+      @connection.exec_query(sql, "SQL", [bind], prepare: true)
+    end
+    assert_equal ["id", "a", "b"], second.columns
+    assert_equal 1, second.rows.length
+  ensure
+    @connection.execute("DROP TABLE IF EXISTS cached_plan_things")
+    @connection.clear_cache!
+  end
+end

data/test/cases/adapters/cockroachdb/referential_integrity_test.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "cases/helper_cockroachdb"
+require "support/connection_helper" # for #reset_connection
+require "support/copy_cat"
+
+class CockroachDBReferentialIntegrityTest < ActiveRecord::PostgreSQLTestCase
+  include ConnectionHelper
+
+  module ProgrammerMistake
+    def execute_batch(sql, name = nil)
+      raise ArgumentError, "something is not right." if name.match?(/referential integrity/)
+      super
+    end
+  end
+
+  def setup
+    @connection = ActiveRecord::Base.lease_connection
+  end
+
+  def teardown
+    reset_connection
+  end
+
+  exclude_from_transactional_tests :test_only_catch_active_record_errors_others_bubble_up
+  CopyCat.copy_methods(self, ::PostgreSQLReferentialIntegrityTest, :test_only_catch_active_record_errors_others_bubble_up)
+
+  def test_should_reraise_invalid_foreign_key_exception_and_show_warning
+    warning = capture(:stderr) do
+      e = assert_raises(ActiveRecord::InvalidForeignKey) do
+        @connection.disable_referential_integrity do
+          @connection.execute("INSERT INTO authors (name, author_address_id) VALUES ('Mona Chollet', 42)")
+        end
+      end
+      assert_match (/Key \(author_address_id\)=\(42\) is not present in table/), e.message
+    end
+    assert_match (/WARNING: Rails was not able to disable referential integrity/), warning
+    assert_match (/autocommit_before_ddl/), warning
+  end
+
+  def test_no_warning_nor_error_with_autocommit_before_ddl
+    @connection.execute("SET SESSION autocommit_before_ddl = 'on'")
+    warning = capture(:stderr) do
+      @connection.disable_referential_integrity do
+        @connection.execute("INSERT INTO authors (name, author_address_id) VALUES ('Mona Chollet', 42)")
+        @connection.truncate(:authors)
+      end
+    end
+    assert_predicate warning, :blank?, "expected no warnings but got:\n#{warning}"
+  end
+
+  # `#disable_referential_integrity` drops and re-adds every foreign key using
+  # batched DDL. CockroachDB cannot auto-unlock a `schema_locked` table for a
+  # multi-statement batch, so the adapter must unlock the affected tables (both
+  # the referencing and referenced ones) around the batch and restore their
+  # locked state. This must run outside a transaction: the batched DDL only
+  # takes the unlocking path when no transaction is open, and toggling
+  # `schema_locked` is only allowed in single-statement implicit transactions.
+  exclude_from_transactional_tests :test_disable_referential_integrity_unlocks_schema_locked_tables
+  def test_disable_referential_integrity_unlocks_schema_locked_tables
+    skip "schema_locked requires CockroachDB v25.3+" if @connection.database_version < 25_03_00
+
+    # `authors.author_address_id` references `author_addresses`, so this covers
+    # both the referencing and referenced sides of a foreign key.
+    begin
+      @connection.execute("ALTER TABLE authors SET (schema_locked = true)")
+      @connection.execute("ALTER TABLE author_addresses SET (schema_locked = true)")
+      assert schema_locked?(:authors), "precondition: authors should be schema_locked"
+      assert schema_locked?(:author_addresses), "precondition: author_addresses should be schema_locked"
+
+      assert_nothing_raised do
+        @connection.disable_referential_integrity { }
+      end
+
+      assert schema_locked?(:authors), "authors should be re-locked afterwards"
+      assert schema_locked?(:author_addresses), "author_addresses should be re-locked afterwards"
+    ensure
+      @connection.execute("ALTER TABLE authors SET (schema_locked = false)")
+      @connection.execute("ALTER TABLE author_addresses SET (schema_locked = false)")
+    end
+  end
+
+  private
+
+  def schema_locked?(table)
+    reloptions = @connection.query_value(<<~SQL)
+      SELECT array_to_string(reloptions, ',') FROM pg_class WHERE relname = #{@connection.quote(table.to_s)}
+    SQL
+    reloptions.to_s.include?("schema_locked=true")
+  end
+end

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

@@ -0,0 +1,71 @@
+require "cases/helper_cockroachdb"
+
+module CockroachDB
+  class PostgresqlActiveSchemaTest < ActiveRecord::PostgreSQLTestCase
+    def setup
+      ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.class_eval do
+        def execute(sql, name = nil) sql end
+      end
+    end
+
+    teardown do
+      ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.class_eval do
+        remove_method :execute
+      end
+    end
+
+    # This replaces the same test that's been excluded from
+    # PostgresqlActiveSchemaTest. It is almost exactly the same, but it excludes
+    # assertions against partial indexes because they're not supported in
+    # CockroachDB.
+    # See test/excludes/PostgresqlActiveSchemaTest.rb
+    def test_add_index
+      # add_index calls index_name_exists? which can't work since execute is stubbed
+      ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.send(:define_method, :index_name_exists?) { |*| false }
+
+      expected = %(CREATE UNIQUE INDEX "index_people_on_lower_last_name" ON "people" (lower(last_name)))
+      assert_equal expected, add_index(:people, "lower(last_name)", unique: true)
+
+      expected = %(CREATE UNIQUE INDEX "index_people_on_last_name_varchar_pattern_ops" ON "people" (last_name varchar_pattern_ops))
+      assert_equal expected, add_index(:people, "last_name varchar_pattern_ops", unique: true)
+
+      expected = %(CREATE INDEX CONCURRENTLY "index_people_on_last_name" ON "people" ("last_name"))
+      assert_equal expected, add_index(:people, :last_name, algorithm: :concurrently)
+
+      expected = %(CREATE INDEX "index_people_on_last_name_and_first_name" ON "people" ("last_name" DESC, "first_name" ASC))
+      assert_equal expected, add_index(:people, [:last_name, :first_name], order: { last_name: :desc, first_name: :asc })
+      assert_equal expected, add_index(:people, ["last_name", :first_name], order: { last_name: :desc, "first_name" => :asc })
+
+      %w(gin gist hash btree).each do |type|
+        expected = %(CREATE INDEX "index_people_on_last_name" ON "people" USING #{type} ("last_name"))
+        assert_equal expected, add_index(:people, :last_name, using: type)
+
+        expected = %(CREATE INDEX CONCURRENTLY "index_people_on_last_name" ON "people" USING #{type} ("last_name"))
+        assert_equal expected, add_index(:people, :last_name, using: type, algorithm: :concurrently)
+
+        expected = %(CREATE UNIQUE INDEX "index_people_on_lower_last_name" ON "people" USING #{type} (lower(last_name)))
+        assert_equal expected, add_index(:people, "lower(last_name)", using: type, unique: true)
+      end
+
+      expected = %(CREATE INDEX "index_people_on_last_name" ON "people" USING gist ("last_name" bpchar_pattern_ops))
+      assert_equal expected, add_index(:people, :last_name, using: :gist, opclass: { last_name: :bpchar_pattern_ops })
+
+      expected = %(CREATE INDEX "index_people_on_last_name_and_first_name" ON "people" ("last_name" DESC NULLS LAST, "first_name" ASC))
+      assert_equal expected, add_index(:people, [:last_name, :first_name], order: { last_name: "DESC NULLS LAST", first_name: :asc })
+
+      expected = %(CREATE INDEX "index_people_on_last_name" ON "people" ("last_name" NULLS FIRST))
+      assert_equal expected, add_index(:people, :last_name, order: "NULLS FIRST")
+
+      assert_raise ArgumentError do
+        add_index(:people, :last_name, algorithm: :copy)
+      end
+
+      ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.send :remove_method, :index_name_exists?
+    end
+
+    private
+      def method_missing(...)
+        ActiveRecord::Base.lease_connection.send(...)
+      end
+  end
+end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "cases/helper_cockroachdb"
+
+module ActiveRecord
+  module CockroachDB
+    class Migration
+      class PGChangeSchemaTest < ActiveRecord::PostgreSQLTestCase
+        self.use_transactional_tests = false
+        attr_reader :connection
+
+        def setup
+          super
+          @connection = ActiveRecord::Base.lease_connection
+          connection.create_table(:strings) do |t|
+            t.string :somedate
+          end
+        end
+
+        def teardown
+          connection.drop_table :strings
+        end
+
+        def test_change_string_to_date
+          connection.change_column :strings, :somedate, :timestamp, using: 'CAST("somedate" AS timestamp)'
+          assert_equal :datetime, connection.columns(:strings).find { |c| c.name == "somedate" }.type
+        end
+
+        def test_change_type_with_symbol
+          connection.change_column :strings, :somedate, :timestamp, cast_as: :timestamp
+          assert_equal :datetime, connection.columns(:strings).find { |c| c.name == "somedate" }.type
+        end
+
+        def test_change_type_with_symbol_with_timestamptz
+          connection.change_column :strings, :somedate, :timestamptz, cast_as: :timestamptz
+          assert_equal :timestamptz, connection.columns(:strings).find { |c| c.name == "somedate" }.type
+        end
+
+        def test_change_type_with_symbol_using_datetime
+          connection.change_column :strings, :somedate, :datetime, cast_as: :datetime
+          assert_equal :datetime, connection.columns(:strings).find { |c| c.name == "somedate" }.type
+        end
+
+        def test_change_type_with_symbol_using_timestamp_with_timestamptz_as_default
+          with_cockroachdb_datetime_type(:timestamptz) do
+            connection.change_column :strings, :somedate, :timestamp, cast_as: :timestamp
+            assert_equal :timestamp, connection.columns(:strings).find { |c| c.name == "somedate" }.type
+          end
+        end
+
+        def test_change_type_with_symbol_with_timestamptz_as_default
+          with_cockroachdb_datetime_type(:timestamptz) do
+            connection.change_column :strings, :somedate, :timestamptz, cast_as: :timestamptz
+            assert_equal :datetime, connection.columns(:strings).find { |c| c.name == "somedate" }.type
+          end
+        end
+
+        def test_change_type_with_symbol_using_datetime_with_timestamptz_as_default
+          with_cockroachdb_datetime_type(:timestamptz) do
+            connection.change_column :strings, :somedate, :datetime, cast_as: :datetime
+            assert_equal :datetime, connection.columns(:strings).find { |c| c.name == "somedate" }.type
+          end
+        end
+
+        def test_change_type_with_array
+          connection.change_column :strings, :somedate, :timestamp, array: true, cast_as: :timestamp
+          column = connection.columns(:strings).find { |c| c.name == "somedate" }
+          assert_equal :datetime, column.type
+          assert_predicate column, :array?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "cases/helper_cockroachdb"
+
+
+module ActiveRecord
+  module CockroachDB
+    class PostgresqlConnectionTest < ActiveRecord::PostgreSQLTestCase
+      include ConnectionHelper
+
+      def test_set_session_variable_true
+        run_without_connection do |orig_connection|
+          ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { null_ordered_last: true }))
+          set_true = ActiveRecord::Base.lease_connection.exec_query "SHOW NULL_ORDERED_LAST"
+          assert_equal [["on"]], set_true.rows
+        end
+      end
+
+      def test_set_session_variable_false
+        run_without_connection do |orig_connection|
+          ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { null_ordered_last: false }))
+          set_false = ActiveRecord::Base.lease_connection.exec_query "SHOW NULL_ORDERED_LAST"
+          assert_equal [["off"]], set_false.rows
+        end
+      end
+
+      def test_set_session_variable_nil
+        run_without_connection do |orig_connection|
+          # This should be a no-op that does not raise an error
+          assert_nothing_raised do
+            ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { null_ordered_last: nil }))
+          end
+        end
+      end
+
+      def test_set_session_variable_default
+        run_without_connection do |orig_connection|
+          # This should execute a query that does not raise an error
+          assert_nothing_raised do
+            ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { null_ordered_last: :default }))
+          end
+        end
+      end
+    end
+  end
+end