activerecord-cockroachdb-adapter 8.0.2 → 8.1.0

data/test/cases/migration/references_foreign_key_test.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+module ActiveRecord
+  module CockroachDB
+    class Migration
+      class ReferencesForeignKeyTest < ActiveRecord::TestCase
+        # These tests are identical to the ones found in Rails, save for the fact
+        # that transactions are turned off for test runs. It is necessary to disable
+        # transactional tests in order to assert on schema changes due to how
+        # CockroachDB handles transactions.
+        self.use_transactional_tests = false
+
+        setup do
+          @connection = ActiveRecord::Base.lease_connection
+          @connection.create_table(:testing_parents, force: true)
+        end
+
+        teardown do
+          @connection.drop_table "testings", if_exists: true
+          @connection.drop_table "testing_parents", if_exists: true
+        end
+
+        test "foreign keys can be created while changing the table" do
+          @connection.create_table :testings
+          @connection.change_table :testings do |t|
+            t.references :testing_parent, foreign_key: true
+          end
+
+          fk = @connection.foreign_keys("testings").first
+          assert_equal "testings", fk.from_table
+          assert_equal "testing_parents", fk.to_table
+        end
+
+        test "foreign keys accept options when changing the table" do
+          @connection.change_table :testing_parents do |t|
+            t.references :other, index: { unique: true }
+          end
+          @connection.create_table :testings
+          @connection.change_table :testings do |t|
+            t.references :testing_parent, foreign_key: { primary_key: :other_id }
+          end
+
+          fk = @connection.foreign_keys("testings").find { |k| k.to_table == "testing_parents" }
+          assert_equal "other_id", fk.primary_key
+        end
+
+        test "foreign key column can be removed" do
+          @connection.create_table :testings do |t|
+            t.references :testing_parent, index: true, foreign_key: true
+          end
+
+          assert_difference "@connection.foreign_keys('testings').size", -1 do
+            @connection.remove_reference :testings, :testing_parent, foreign_key: true
+          end
+        end
+
+        test "removing column removes foreign key" do
+          @connection.create_table :testings do |t|
+            t.references :testing_parent, index: true, foreign_key: true
+          end
+
+          assert_difference "@connection.foreign_keys('testings').size", -1 do
+            @connection.remove_column :testings, :testing_parent_id
+          end
+        end
+
+        test "foreign key methods respect pluralize_table_names" do
+          begin
+            original_pluralize_table_names = ActiveRecord::Base.pluralize_table_names
+            ActiveRecord::Base.pluralize_table_names = false
+            @connection.create_table :testing
+            @connection.change_table :testing_parents do |t|
+              t.references :testing, foreign_key: true
+            end
+
+            fk = @connection.foreign_keys("testing_parents").first
+            assert_equal "testing_parents", fk.from_table
+            assert_equal "testing", fk.to_table
+
+            assert_difference "@connection.foreign_keys('testing_parents').size", -1 do
+              @connection.remove_reference :testing_parents, :testing, foreign_key: true
+            end
+          ensure
+            ActiveRecord::Base.pluralize_table_names = original_pluralize_table_names
+            @connection.drop_table "testing", if_exists: true
+          end
+        end
+
+        test "multiple foreign keys can be removed to the selected one" do
+          @connection.create_table :testings do |t|
+            t.references :parent1, foreign_key: { to_table: :testing_parents }
+            t.references :parent2, foreign_key: { to_table: :testing_parents }
+          end
+
+          assert_difference "@connection.foreign_keys('testings').size", -1 do
+            @connection.remove_reference :testings, :parent1, foreign_key: { to_table: :testing_parents }
+          end
+
+          fks = @connection.foreign_keys("testings").sort_by(&:column)
+
+          fk_definitions = fks.map { |fk| [fk.from_table, fk.to_table, fk.column] }
+          assert_equal([["testings", "testing_parents", "parent2_id"]], fk_definitions)
+        end
+
+        test "multiple foreign keys can be added to the same table" do
+          @connection.create_table :testings do |t|
+            t.references :parent1, foreign_key: { to_table: :testing_parents }
+            t.references :parent2, foreign_key: { to_table: :testing_parents }
+            t.references :self_join, foreign_key: { to_table: :testings }
+          end
+
+          fks = @connection.foreign_keys("testings").sort_by(&:column)
+
+          fk_definitions = fks.map { |fk| [fk.from_table, fk.to_table, fk.column] }
+          assert_equal([["testings", "testing_parents", "parent1_id"],
+                        ["testings", "testing_parents", "parent2_id"],
+                        ["testings", "testings", "self_join_id"]], fk_definitions)
+        end
+      end
+    end
+  end
+end

data/test/cases/migration_test.rb

@@ -0,0 +1,120 @@
+require "cases/helper_cockroachdb"
+require "models/person"
+require "support/copy_cat"
+
+class Reminder < ActiveRecord::Base; end unless Object.const_defined?(:Reminder)
+class Thing < ActiveRecord::Base; end unless Object.const_defined?(:Thing)
+module CockroachDB
+  class MigrationTest < ActiveRecord::TestCase
+    self.use_transactional_tests = false
+
+    fixtures :people
+
+    CopyCat.copy_methods(self, ::MigrationTest, :setup)
+
+    teardown do
+      ActiveRecord::Base.table_name_prefix = ""
+      ActiveRecord::Base.table_name_suffix = ""
+
+      @schema_migration.create_table
+      @schema_migration.delete_all_versions
+
+      %w(things awesome_things prefix_things_suffix p_awesome_things_s).each do |table|
+        Thing.lease_connection.drop_table(table, if_exists: true)
+      end
+      Thing.reset_column_information
+
+      %w(reminders people_reminders prefix_reminders_suffix).each do |table|
+        Reminder.lease_connection.drop_table(table, if_exists: true)
+      end
+      Reminder.reset_table_name
+      Reminder.reset_column_information
+
+      %w(last_name key bio age height wealth birthday favorite_day
+       moment_of_truth male administrator funny).each do |column|
+        Person.lease_connection.remove_column("people", column, if_exists: true)
+      end
+      Person.lease_connection.remove_column("people", "first_name", if_exists: true)
+      Person.lease_connection.remove_column("people", "middle_name", if_exists: true)
+      Person.lease_connection.add_column("people", "first_name", :string)
+      Person.reset_column_information
+
+      ActiveRecord::Migration.verbose = @verbose_was
+    end
+
+    def test_remove_column_with_if_not_exists_not_set
+      migration_a = Class.new(ActiveRecord::Migration::Current) {
+        def version; 100 end
+        def migrate(x)
+          add_column "people", "last_name", :string
+        end
+      }.new
+
+      migration_b = Class.new(ActiveRecord::Migration::Current) {
+        def version; 101 end
+        def migrate(x)
+          remove_column "people", "last_name"
+        end
+      }.new
+
+      migration_c = Class.new(ActiveRecord::Migration::Current) {
+        def version; 102 end
+        def migrate(x)
+          remove_column "people", "last_name"
+        end
+      }.new
+
+      ActiveRecord::Migrator.new(:up, [migration_a], @schema_migration, @internal_metadata, 100).migrate
+      assert_column Person, :last_name, "migration_a should have added the last_name column on people"
+
+      ActiveRecord::Migrator.new(:up, [migration_b], @schema_migration, @internal_metadata, 101).migrate
+      assert_no_column Person, :last_name, "migration_b should have dropped the last_name column on people"
+      migrator = ActiveRecord::Migrator.new(:up, [migration_c], @schema_migration, @internal_metadata, 102)
+
+      error = assert_raises do
+        migrator.migrate
+      end
+
+      assert_match(/column \"last_name\" does not exist/, error.message)
+    ensure
+      Person.reset_column_information
+    end
+  end
+
+  class BulkAlterTableMigrationsTest < ActiveRecord::TestCase
+    def setup
+      @connection = Person.lease_connection
+      @connection.create_table(:delete_me, force: true) { |t| }
+      Person.reset_column_information
+      Person.reset_sequence_name
+    end
+
+    teardown do
+      Person.lease_connection.drop_table(:delete_me, if_exists: true)
+    end
+
+    # Change expected query count from PostgreSQLAdapter to CockroachDBAdapter.
+    CopyCat.copy_methods(self, ::BulkAlterTableMigrationsTest,
+      :test_adding_indexes,
+      :test_removing_index,
+      :test_adding_multiple_columns,
+      :test_changing_index
+    ) do
+      def on_str(node)
+        return unless node in [:str, "PostgreSQLAdapter"]
+
+        replace(node.loc.expression, '"CockroachDBAdapter"')
+      end
+    end
+
+    private
+
+    CopyCat.copy_methods(self, ::BulkAlterTableMigrationsTest,
+      :with_bulk_change_table,
+      :column,
+      :columns,
+      :index,
+      :indexes
+    )
+  end
+end

data/test/cases/persistence_test.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/topic"
+
+module CockroachDB
+  class PersistenceTest < ActiveRecord::TestCase
+    fixtures :topics
+
+    self.use_transactional_tests = false
+
+    # This test is identical to the one found in Rails, except we need to run
+    # it with transactions turned off in order to properly assert on the newly
+    # added column.
+    def test_reset_column_information_resets_children
+      child_class = Class.new(Topic)
+      child_class.new # force schema to load
+
+      ActiveRecord::Base.lease_connection.add_column(:topics, :foo, :string)
+      Topic.reset_column_information
+
+      # this should redefine attribute methods
+      child_class.new
+
+      assert child_class.instance_methods.include?(:foo)
+      assert child_class.instance_methods.include?(:foo_changed?)
+      assert_equal "bar", child_class.new(foo: :bar).foo
+    ensure
+      ActiveRecord::Base.lease_connection.remove_column(:topics, :foo)
+      Topic.reset_column_information
+    end
+  end
+end

data/test/cases/primary_keys_test.rb

@@ -0,0 +1,134 @@
+require "cases/helper_cockroachdb"
+
+# Load dependencies from ActiveRecord test suite
+require "support/schema_dumping_helper"
+require "models/topic"
+require "models/mixed_case_monkey"
+
+module CockroachDB
+  class PrimaryKeysTest < ActiveRecord::TestCase
+    fixtures :mixed_case_monkeys, :topics
+
+    # This replaces the same test that's been excluded from PrimaryKeysTest. We
+    # run it here without an assertion on column.default_function because it
+    # will always be unique_rowid() in CockroachDB.
+    # See test/excludes/PrimaryKeysTest.rb
+    def test_serial_with_quoted_sequence_name
+      column = MixedCaseMonkey.columns_hash[MixedCaseMonkey.primary_key]
+      assert_predicate column, :serial?
+    end
+
+    # This replaces the same test that's been excluded from PrimaryKeysTest. We
+    # run it here without an assertion on column.default_function because it
+    # will always be unique_rowid() in CockroachDB.
+    # See test/excludes/PrimaryKeysTest.rb
+    def test_serial_with_unquoted_sequence_name
+      column = Topic.columns_hash[Topic.primary_key]
+      assert_predicate column, :serial?
+    end
+  end
+
+  class PrimaryKeyIntegerTest < ActiveRecord::TestCase
+    include SchemaDumpingHelper
+
+    self.use_transactional_tests = false
+
+    class Widget < ActiveRecord::Base
+    end
+
+    setup do
+      @connection = ActiveRecord::Base.lease_connection
+      @pk_type = :serial
+    end
+
+    teardown do
+      @connection.drop_table :widgets, if_exists: true
+    end
+
+    # This replaces the same test that's been excluded from
+    # PrimaryKeyIntegerTest. In PostgreSQL, serial columns are backed by integer
+    # columns. They're also backed by integer columns in CockroachDB, but
+    # integer columns are the same size as PostgreSQL's bigints. Therefore, we
+    # change the final assertion to verify the serial column is a bigint.
+    # See test/excludes/PrimaryKeyIntegerTest.rb
+    test "primary key column type with serial/integer" do
+      @connection.create_table(:widgets, id: @pk_type, force: true)
+      column = @connection.columns(:widgets).find { |c| c.name == "id" }
+      assert_equal :integer, column.type
+      assert_predicate column, :bigint?
+    end
+
+    # This replaces the same test that's been excluded from
+    # PrimaryKeyIntegerTest. Although the widgets table is created with a serial
+    # primary key, that info will not be included in the schema dump.
+    # CockroachDB serial and bigserial columns are really bigserial columns, and
+    # ActiveRecord defaults to bigserial primary keys. Therefore, nothing about
+    # the id primary key will be in the widgets schema dump.
+    # See test/excludes/PrimaryKeyIntegerTest.rb
+    test "schema dump primary key with serial/integer" do
+      @connection.create_table(:widgets, id: @pk_type, force: true)
+      schema = dump_table_schema "widgets"
+      assert_match %r{create_table "widgets", }, schema
+    end
+  end
+
+  class PrimaryKeyIntegerNilDefaultTest < ActiveRecord::TestCase
+    include SchemaDumpingHelper
+
+    self.use_transactional_tests = false
+
+    def setup
+      @connection = ActiveRecord::Base.lease_connection
+    end
+
+    def teardown
+      @connection.drop_table :int_defaults, if_exists: true
+    end
+
+    # This replaces the same test that's been excluded from
+    # PrimaryKeyIntegerNilDefaultTest. int_defaults is created with an integer
+    # primary key, and integer columns are bigints in CockroachDB. Therefore,
+    # the schema dump will include the primary key as :bigint.
+    # See test/excludes/PrimaryKeyIntegerNilDefaultTest.rb
+    def test_schema_dump_primary_key_integer_with_default_nil
+      skip if current_adapter?(:SQLite3Adapter)
+      @connection.create_table(:int_defaults, id: :integer, default: nil, force: true)
+      schema = dump_table_schema "int_defaults"
+      assert_match %r{create_table "int_defaults", id: :bigint, default: nil}, schema
+    end
+  end
+
+  class PrimaryKeyHiddenColumnTest < ActiveRecord::TestCase
+    class Rocket < ActiveRecord::Base
+    end
+
+    def setup
+      connection = ActiveRecord::Base.lease_connection
+      connection.execute <<-SQL
+        CREATE TABLE rockets(
+          id SERIAL PRIMARY KEY USING HASH WITH (bucket_count=4)
+        )
+      SQL
+    end
+
+    def teardown
+      ActiveRecord::Base.connection.drop_table :rockets
+    end
+
+    def test_to_key_with_hidden_primary_key_part
+      rocket = Rocket.new
+      assert_nil rocket.to_key
+      rocket.save
+      assert_equal rocket.to_key, [rocket.id]
+    end
+
+    def test_read_attribute_with_hidden_primary_key_part
+      rocket = Rocket.create!
+      id = assert_not_deprecated(ActiveRecord.deprecator) do
+        rocket.read_attribute(:id)
+      end
+
+      assert_equal rocket.id, id
+    end
+  end
+end

data/test/cases/relation/aost_test.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "cases/helper_cockroachdb"
+require "models/post"
+require "models/comment"
+
+module CockroachDB
+  class AostTest < ActiveRecord::TestCase
+    def test_simple_aost
+      time = 2.days.ago
+      re_time = Regexp.quote(time.iso8601)
+      assert_match(/from "posts" as of system time '#{re_time}'/i, Post.aost(time).to_sql)
+      assert_match(/from "posts" as of system time '#{re_time}'/i, Post.where(name: "foo").aost(time).to_sql)
+    end
+
+    def test_reset_aost
+      time = 1.second.from_now
+      assert_match(/from "posts"\z/i, Post.aost(time).aost(nil).to_sql)
+    end
+
+    def test_aost_with_join
+      time = Time.now
+      assert_match(
+        /FROM "posts" INNER JOIN "comments" ON "comments"."post_id" = "posts"."id" AS OF SYSTEM TIME '#{Regexp.quote time.iso8601}'/,
+        Post.joins(:comments).aost(time).to_sql
+      )
+    end
+
+    def test_aost_with_subquery
+      time = 4.seconds.ago
+      assert_match(/from \(.*?\) subquery as of system time '#{Regexp.quote time.iso8601}'/i, Post.from(Post.where(name: "foo")).aost(time).to_sql)
+    end
+
+    def test_only_time_input
+      time = 1.second.ago
+      expected = "SELECT \"posts\".* FROM \"posts\" AS OF SYSTEM TIME '#{time.iso8601}'"
+      assert_equal expected, Post.aost(time).to_sql
+      assert_raises(ArgumentError) { Post.aost("no time") }
+      assert_raises(ArgumentError) { Post.aost(true) }
+    end
+  end
+
+  class AostNoTransactionTest < ActiveRecord::TestCase
+    # AOST per query is not compatible with transactions.
+    self.use_transactional_tests = false
+
+    def test_aost_with_multiple_queries
+      time = 1.second.ago
+      queries = capture_sql {
+        Post.aost(time).limit(2).find_each(batch_size: 1).to_a
+      }
+      queries.each do
+        assert_match %r(FROM "posts" AS OF SYSTEM TIME '#{Regexp.quote time.iso8601}'), _1
+      end
+    end
+  end
+end

data/test/cases/relation/or_test.rb

@@ -0,0 +1,26 @@
+# This test has been copied to fix a bug in the test setup. It can be removed
+# once the bugfix has been released in Rails - see rails/rails#38978.
+# See test/excludes/OrTest.rb
+
+require "cases/helper_cockroachdb"
+
+# Load dependencies from ActiveRecord test suite
+require "cases/helper"
+require "models/post"
+require "models/author"
+require "models/categorization"
+
+module ActiveRecord
+  module CockroachDB
+    class OrTest < ActiveRecord::TestCase
+      fixtures :posts
+      fixtures :authors, :author_addresses
+
+      def test_or_when_grouping
+        groups = Post.where("id < 10").group("body")
+        expected = groups.having("COUNT(*) > 1 OR body like 'Such%'").count
+        assert_equal expected, groups.having("COUNT(*) > 1").or(groups.having("body like 'Such%'")).count
+      end
+    end
+  end
+end

data/test/cases/relation/table_hints_test.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require "cases/helper_cockroachdb"
+require "models/post"
+
+module CockroachDB
+  class TableHintsTest < ActiveRecord::TestCase
+    fixtures :posts
+
+    def test_add_hint
+      force_index = ->(q) { q.force_index("index_posts_on_author_id") }
+      index_hint = ->(q) { q.index_hint("NO_FULL_SCAN") }
+
+      assert_queries_match(/"posts"@\{FORCE_INDEX=index_posts_on_author_id\}/) do
+        Post.then(&force_index).take
+      end
+
+      assert_queries_match(/"posts"@\{NO_FULL_SCAN\}/) do
+        Post.then(&index_hint).take
+      end
+
+      [force_index, index_hint].permutation do |procs|
+        assert_queries_match(/"posts"@\{NO_FULL_SCAN,FORCE_INDEX=index_posts_on_author_id\}/) do
+          Post.then(&procs.reduce(:<<)).take
+        end
+      end
+    end
+
+    def test_choose_index_order
+      idx = "index_posts_on_author_id"
+      assert_queries_match(/"posts"@\{FORCE_INDEX=#{idx},ASC\}/) do
+        Post.force_index(idx, direction: "ASC").take
+      end
+      assert_queries_match(/"posts"@\{FORCE_INDEX=#{idx},DESC\}/) do
+        Post.force_index(idx, direction: "DESC").take
+      end
+      assert_queries_match(/"posts"@\{NO_FULL_SCAN,FORCE_INDEX=#{idx},DESC\}/) do
+        Post.force_index(idx, direction: "DESC").index_hint("NO_FULL_SCAN").take
+      end
+    end
+
+    def test_use_other_table
+      force_index = ->(q) { q.force_index("index_subscribers_on_nick") }
+      index_hint = ->(q) { q.index_hint("NO_FULL_SCAN") }
+      post_from = Post.select(:id).from("subscribers")
+
+      assert_queries_match(/subscribers@\{FORCE_INDEX=index_subscribers_on_nick\}/) do
+        post_from.then(&force_index).take
+      end
+
+      assert_queries_match(/subscribers@\{NO_FULL_SCAN\}/) do
+        post_from.then(&index_hint).take
+      end
+
+      [force_index, index_hint].permutation do |procs|
+        assert_queries_match(/subscribers@\{NO_FULL_SCAN,FORCE_INDEX=index_subscribers_on_nick\}/) do
+          post_from.then(&procs.reduce(:<<)).take
+        end
+      end
+    end
+
+    def test_from_with_space
+      ["foo\t", "foo  "].each do
+        assert_match(/FROM foo@\{H\}/, Post.from(_1).index_hint("H").to_sql)
+        assert_match(
+          /FROM foo@\{H,FORCE_INDEX=i\}/,
+          Post.from(_1).index_hint("H").force_index("i").to_sql
+        )
+      end
+    end
+
+    def test_reset_with_from
+      force_index = ->(q) { q.force_index("type") }
+      index_hint = ->(q) { q.index_hint("NO_FULL_SCAN") }
+
+      [force_index, index_hint].permutation do
+        assert_match(
+          /FROM age\z/,
+          Post.then(&_1).then(&_2).from("age").to_sql
+        )
+      end
+      [force_index, index_hint].each do
+        assert_match(/FROM age\z/, Post.then(&_1).from("age").to_sql)
+      end
+
+    end
+
+    def test_ignore_from_multiple_tables
+      tables = "ta, tb"
+      from = ->(q) { q.from(tables) }
+      force_index = ->(q) { q.force_index("type") }
+      index_hint = ->(q) { q.index_hint("NO_FULL_SCAN") }
+
+      (
+        [from, force_index, index_hint].permutation +
+        [from, force_index].permutation +
+        [from, index_hint].permutation
+      ).each do |procs|
+        assert_match(
+          /FROM #{tables}\z/,
+          Post.then(&procs.reduce(:<<)).to_sql
+        )
+      end
+    end
+
+    def test_ignore_from_subquery
+      subquery = Post.where("created_at < ?", 1.year.ago)
+      from = ->(q) { q.from(subquery) }
+      force_index = ->(q) { q.force_index("safeword") }
+      index_hint = ->(q) { q.index_hint("NO_FULL_SCAN") }
+
+      (
+        [from, force_index, index_hint].permutation +
+        [from, force_index].permutation +
+        [from, index_hint].permutation
+      ).each do |procs|
+        refute_match(
+          /safeword|NO_FULL_SCAN|@/,
+          Post.then(&procs.reduce(:<<)).to_sql
+        )
+      end
+    end
+  end
+end

data/test/cases/relation_test.rb

@@ -0,0 +1,26 @@
+require "cases/helper_cockroachdb"
+
+require "cases/helper"
+require "models/post"
+require "models/comment"
+require "models/author"
+require "models/rating"
+require "models/categorization"
+
+module ActiveRecord
+  module CockroachDB
+    class RelationTest < ActiveRecord::TestCase
+      fixtures :posts
+
+      def test_relation_with_annotation_includes_comment_in_to_sql
+        post_with_annotation = Post.where(id: 1).annotate("foo")
+        assert_match %r{= '1' /\* foo \*/}, post_with_annotation.to_sql
+      end
+
+      def test_relation_with_annotation_filters_sql_comment_delimiters
+        post_with_annotation = Post.where(id: 1).annotate("**//foo//**")
+        assert_includes post_with_annotation.to_sql, "= '1' /* ** //foo// ** */"
+      end
+    end
+  end
+end

data/test/cases/relations_test.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/post"
+require "models/comment"
+
+module CockroachDB
+  class RelationTest < ActiveRecord::TestCase
+    fixtures :posts, :comments
+
+    def test_finding_with_subquery_with_eager_loading_in_from
+      relation = Comment.includes(:post).where("posts.type": "Post").order(:id)
+      assert_equal relation.to_a, Comment.select("*").from(relation).order(:id).to_a
+      assert_equal relation.to_a, Comment.select("subquery.*").from(relation).order(:id).to_a
+      assert_equal relation.to_a, Comment.select("a.*").from(relation, :a).order(:id).to_a
+    end
+
+    def test_finding_with_arel_sql_order
+      query = Tag.order(Arel.sql("field(id, ?)", [1, 3, 2])).to_sql
+      assert_match(/field\(id, '1', '3', '2'\)/, query)
+
+      query = Tag.order(Arel.sql("field(id, ?)", [])).to_sql
+      assert_match(/field\(id, NULL\)/, query)
+
+      query = Tag.order(Arel.sql("field(id, ?)", nil)).to_sql
+      assert_match(/field\(id, NULL\)/, query)
+    end
+  end
+end