activerecord-cockroachdb-adapter 7.0.3 → 7.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 594ac59a7a678d5619ea771e3130a481481560adcc88032d7c17d61b6dabc279
-  data.tar.gz: 0cd6ea6bd6a1fe808142a91e35a24d4e15a59b48f56e4dba37d8a25584dd7a8a
+  metadata.gz: 6c3f85e82470685a2ece6851d557bcaf03f5a77ce309d76062c3960ca17d1606
+  data.tar.gz: b6ab7bfb9d29feebf217b70b11ccf2f73e6fb0853138cc27f4556f07b6c36dac
 SHA512:
-  metadata.gz: 56205a247976012b6a25691045a773ca9fefecc1b98bb47ee83fb85dffede72a8aed5bc605a332d00b31fb57f67ee1018b850d14638581454980a6b96d2e8865
-  data.tar.gz: 92515e498cc8cedfe284cfe4cf9b3cb87eae72630aa5828e5983dfabe488ad214386561a0fb8072963b0796559209ee033cb010495d263d44eb1abf048afaa37
+  metadata.gz: 96fbb4c5a42c1ab3f2fe590f3c74012b883c818608c5b9d0525f30739f1d4d8733c95cfffd31a8a05350d6210d995f84d915727a494264d1cb1c217d10d200b1
+  data.tar.gz: 12ae86ab8f26eb074eabb60cd3f831eed44729d98f70bdc88d1c0d9c3d5cff5680ae7cf0a9643756395e6cfc1257cb7fc62ee5abab4c37c6f0fe45817fc619a0

data/.editorconfig

@@ -0,0 +1,7 @@
+root = true
+
+[*.rb]
+indent_style = space
+indent_size = 2
+trim_trailing_whitespace = true
+insert_final_newline = true

data/.github/workflows/ci.yml

@@ -4,12 +4,9 @@
 name: Test
 
 on:
-  # Triggers the workflow on push or pull request events.
   push:
-    # This should disable running the workflow on tags, according to the
-    # on.<push|pull_request>.<branches|tags> GitHub Actions docs.
-    branches:
-      - "*"
+    branches: [master]
+  # Triggers the workflow on pull request events.
   pull_request:
     types: [opened, reopened, synchronize]
 
@@ -18,27 +15,42 @@ on:
 
 # This allows a subsequently queued workflow run to interrupt previous runs.
 concurrency:
-  group: '${{ github.workflow }} @ ${{ github.event.pull_request.head.label || github.head_ref || github.ref }}'
+  group: "${{ github.workflow }} @ ${{ github.ref }}"
   cancel-in-progress: true
 
 jobs:
+  # Since the name of the matrix job depends on the version, we define another job with a more stable name.
+  test_results:
+    if: ${{ always() }}
+    runs-on: ubuntu-latest
+    name: Test Results
+    needs: [test]
+    steps:
+      - run: |
+          result="${{ needs.test.result }}"
+          if [[ $result == "success" || $result == "skipped" ]]; then
+            exit 0
+          else
+            exit 1
+          fi
+
   test:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        crdb: [v23.1.5]
-        ruby: [ruby-head]
+        crdb: [v23.1.11]
+        ruby: [head]
     name: Test (crdb=${{ matrix.crdb }} ruby=${{ matrix.ruby }})
     steps:
       - name: Set Up Actions
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
       - name: Install GEOS
         run: sudo apt-get install libgeos-dev
       - name: Set Up Ruby
         uses: ruby/setup-ruby@v1
         with:
-           ruby-version: ${{ matrix.ruby }}
-           bundler-cache: true
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
       - name: Install and Start Cockroachdb
         run: |
           # Download CockroachDB
@@ -83,4 +95,4 @@ jobs:
             SET CLUSTER SETTING sql.defaults.experimental_temporary_tables.enabled = 'true';
           "
       - name: Test
-        run: bundle exec rake test
+        run: bundle exec rake test TESTOPTS='--profile=3'

data/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 ## Ongoing
 
+- Add support for [AOST](cockroachlabs.com/docs/stable/as-of-system-time) queries ([#284](https://github.com/cockroachdb/activerecord-cockroachdb-adapter/pull/284))
+- Dump schema name in foreign keys ([#289](https://github.com/cockroachdb/activerecord-cockroachdb-adapter/pull/289))
+
+## 7.1.0 - 2024-01-30
+
+- Add support for Rails 7.1 ([#300](https://github.com/cockroachdb/activerecord-cockroachdb-adapter/pull/300)).
+
 ## 7.0.3 - 2023-08-23
 
 - Fix Multiple Database connections ([#283](https://github.com/cockroachdb/activerecord-cockroachdb-adapter/pull/)).

data/Gemfile

@@ -10,6 +10,11 @@ module RailsTag
     def call
       req = gemspec_requirement
       "v" + all_activerecord_versions.find { req.satisfied_by?(_1) }.version
+    rescue => e
+      warn "Unable to determine Rails version. Using last used. Error: #{e.message}"
+      lockfile = File.expand_path("Gemfile.lock", __dir__)
+      File.foreach(lockfile, chomp: true).find { _1[/tag: (.*)$/] }
+      Regexp.last_match(1)
     end
 
     def gemspec_requirement
@@ -43,9 +48,13 @@ group :development, :test do
   # a specific rails codebase.
   gem "rails", github: "rails/rails", tag: RailsTag.call
 
+  # Needed for the test suite
+  gem "msgpack", ">= 1.7.0"
+
   gem "rake"
-  gem "byebug"
+  gem "debug"
   gem "minitest-excludes", "~> 2.0.1"
+  gem "minitest-github_action_reporter", github: "BuonOmo/minitest-github_action_reporter", require: "minitest/github_action_reporter_plugin"
 
   # Gems used by the ActiveRecord test suite
   gem "bcrypt", "~> 3.1.18"

data/activerecord-cockroachdb-adapter.gemspec

@@ -14,7 +14,7 @@ Gem::Specification.new do |spec|
   spec.description   = "Allows the use of CockroachDB as a backend for ActiveRecord and Rails apps."
   spec.homepage      = "https://github.com/cockroachdb/activerecord-cockroachdb-adapter"
 
-  spec.add_dependency "activerecord", "~> 7.0.3"
+  spec.add_dependency "activerecord", "~> 7.1.0"
   spec.add_dependency "pg", "~> 1.2"
   spec.add_dependency "rgeo-activerecord", "~> 7.0.0"
 

data/bin/console

@@ -12,39 +12,23 @@ require "active_record"
 #       structure_load(Post.connection_db_config, "awesome-file.sql")
 require "active_record/connection_adapters/cockroachdb/database_tasks"
 
-begin
-  retried = false
-  ActiveRecord::Base.establish_connection(
-    #Alternative version:  "cockroachdb://root@localhost:26257/ar_crdb_console"
-    adapter: "cockroachdb",
-    host: "localhost",
-    port: 26257,
-    user: "root",
-    database: "ar_crdb_console"
-  )
-  ActiveRecord::Base.connection
-rescue ActiveRecord::NoDatabaseError
-  raise if retried
-  system("cockroach sql --insecure --host=localhost:26257 --execute='create database ar_crdb_console'",
-    exception: true)
-  retried = true
-  retry
-end
-
-class Post < ActiveRecord::Base
-end
-
-unless Post.table_exists?
-  migration = Class.new(ActiveRecord::Migration::Current) do
-    def up
-      create_table("posts") do |t|
-        t.string :title
-        t.text :body
-      end
-    end
-  end
-  migration.migrate(:up)
-end
+schema_kind = ENV.fetch("SCHEMA_KIND", "default")
+
+system("cockroach sql --insecure --host=localhost:26257 --execute='drop database if exists ar_crdb_console'",
+  exception: true)
+system("cockroach sql --insecure --host=localhost:26257 --execute='create database ar_crdb_console'",
+  exception: true)
+
+ActiveRecord::Base.establish_connection(
+  #Alternative version:  "cockroachdb://root@localhost:26257/ar_crdb_console"
+  adapter: "cockroachdb",
+  host: "localhost",
+  port: 26257,
+  user: "root",
+  database: "ar_crdb_console"
+)
+
+load "#{__dir__}/console_schemas/#{schema_kind}.rb"
 
 require "irb"
 IRB.start(__FILE__)

data/bin/console_schemas/default.rb

@@ -0,0 +1,9 @@
+class Post < ActiveRecord::Base
+end
+
+ActiveRecord::Schema.define do
+  create_table("posts") do |t|
+    t.string :title
+    t.text :body
+  end
+end

data/bin/console_schemas/schemas.rb

@@ -0,0 +1,23 @@
+class Post < ActiveRecord::Base
+  self.table_name = "bar.posts"
+end
+
+class Comment < ActiveRecord::Base
+  self.table_name = "foo.comments"
+end
+
+ActiveRecord::Schema.define do
+  create_schema("foo")
+  create_schema("bar")
+  create_table("bar.posts") do |t|
+    t.string :title
+    t.text :body
+  end
+
+  create_table("foo.comments") do |t|
+    t.integer :post_id
+    t.text :body
+  end
+
+  add_foreign_key "foo.comments", "bar.posts", column: "post_id"
+end

data/bin/start-cockroachdb

@@ -9,6 +9,7 @@ pid_file="$root_dir/tmp/cockroach.pid"
 log_file="$root_dir/tmp/cockroachdb.log"
 
 mkdir -p "$root_dir/tmp"
+[[ -f "$pid_file" ]] && kill -9 $(cat "$pid_file")
 rm -f "$pid_file"
 
 if ! (( ${+commands[cockroach]} )); then
@@ -20,8 +21,6 @@ cockroach start-single-node \
 	--insecure --store=type=mem,size=0.25 --advertise-addr=localhost --pid-file "$pid_file" \
 	&> "$log_file" &
 
-cockroach_pid=$!
-
 until [[ -f "$pid_file" ]]; do
 	sleep 1
 done
@@ -41,8 +40,9 @@ ALTER DATABASE system CONFIGURE ZONE USING "gc.ttlseconds" = 600;
 
 CREATE DATABASE activerecord_unittest;
 CREATE DATABASE activerecord_unittest2;
-SQL
 
-tail -f "$log_file"
+SET CLUSTER SETTING sql.defaults.experimental_alter_column_type.enabled = 'true';
+SET CLUSTER SETTING sql.defaults.experimental_temporary_tables.enabled = 'true';
+SQL
 
-trap "kill $cockroach_pid" EXIT
+echo "CockroachDB started. PID: $(cat "$pid_file"). log: $log_file"

data/build/Dockerfile

@@ -1,7 +1,7 @@
 # This Dockerfile extends the Examples-ORM testing image in order to
 # install specific dependencies required for ActiveRecord tests.
 
-FROM cockroachdb/example-orms-builder:20200413-1918
+FROM us-east1-docker.pkg.dev/crl-ci-images/cockroach/example-orms-builder:20200413-1918
 
 # Native dependencies for libxml-ruby and sqlite3.
 RUN apt-get --allow-releaseinfo-change update -y && apt-get install -y \

data/lib/active_record/connection_adapters/cockroachdb/arel_tosql.rb

@@ -22,6 +22,14 @@ module Arel # :nodoc:
   module Visitors # :nodoc:
     class CockroachDB < PostgreSQL  # :nodoc:
       include RGeo::ActiveRecord::SpatialToSql
+
+      def visit_Arel_Nodes_JoinSource(o, collector)
+        super
+        if o.aost
+          collector << " AS OF SYSTEM TIME '#{o.aost.iso8601}'"
+        end
+        collector
+      end
     end
   end
 end

data/lib/active_record/connection_adapters/cockroachdb/column.rb

@@ -1,11 +1,11 @@
 module ActiveRecord
   module ConnectionAdapters
     module CockroachDB
-      class Column < PostgreSQLColumn
+      class Column < PostgreSQL::Column
         # most functions taken from activerecord-postgis-adapter spatial_column
         # https://github.com/rgeo/activerecord-postgis-adapter/blob/master/lib/active_record/connection_adapters/postgis/spatial_column.rb
         def initialize(name, default, sql_type_metadata = nil, null = true,
-                       default_function = nil, collation: nil, comment: nil,
+                       default_function = nil, collation: nil, comment: nil, identity: nil,
                        serial: nil, spatial: nil, generated: nil, hidden: nil)
           @sql_type_metadata = sql_type_metadata
           @geographic = !!(sql_type_metadata.sql_type =~ /geography\(/i)
@@ -30,7 +30,7 @@ module ActiveRecord
             build_from_sql_type(sql_type_metadata.sql_type)
           end
           super(name, default, sql_type_metadata, null, default_function,
-            collation: collation, comment: comment, serial: serial, generated: generated)
+            collation: collation, comment: comment, serial: serial, generated: generated, identity: identity)
           if spatial? && @srid
             @limit = { srid: @srid, type: to_type_name(geometric_type) }
             @limit[:has_z] = true if @has_z
@@ -53,10 +53,6 @@ module ActiveRecord
           spatial? ? @limit : super
         end
 
-        def virtual?
-          @generated.present?
-        end
-
         def hidden?
           @hidden
         end

data/lib/active_record/connection_adapters/cockroachdb/column_methods.rb

@@ -45,6 +45,14 @@ module ActiveRecord
         def st_polygon(name, options = {})
           column(name, :st_polygon, **options)
         end
+
+        private
+
+        def valid_column_definition_options
+          spatial = [:srid, :has_z, :has_m, :geographic, :spatial_type]
+          crdb = [:hidden]
+          super + spatial + crdb
+        end
       end
     end
 

data/lib/active_record/connection_adapters/cockroachdb/database_statements.rb

@@ -2,21 +2,6 @@ module ActiveRecord
   module ConnectionAdapters
     module CockroachDB
       module DatabaseStatements
-        # Since CockroachDB will run all transactions with serializable isolation,
-        # READ UNCOMMITTED, READ COMMITTED, and REPEATABLE READ are all aliases
-        # for SERIALIZABLE. This lets the adapter support all isolation levels,
-        # but READ UNCOMMITTED has been removed from this list because the
-        # ActiveRecord transaction isolation test fails for READ UNCOMMITTED.
-        # See https://www.cockroachlabs.com/docs/v19.2/transactions.html#isolation-levels
-        def transaction_isolation_levels
-          {
-            read_committed:   "READ COMMITTED",
-            repeatable_read:  "REPEATABLE READ",
-            serializable:     "SERIALIZABLE",
-            read_uncommitted: "READ UNCOMMITTED"
-          }
-        end
-
         # Overridden to avoid using transactions for schema creation.
         def insert_fixtures_set(fixture_set, tables_to_delete = [])
           fixture_inserts = build_fixture_statements(fixture_set)
@@ -29,74 +14,6 @@ module ActiveRecord
             end
           end
         end
-
-        private
-          def execute_batch(statements, name = nil)
-            statements.each do |statement|
-              execute(statement, name)
-            end
-          end
-
-          DEFAULT_INSERT_VALUE = Arel.sql("DEFAULT").freeze
-          private_constant :DEFAULT_INSERT_VALUE
-
-          def default_insert_value(column)
-            DEFAULT_INSERT_VALUE
-          end
-
-          def build_fixture_sql(fixtures, table_name)
-            columns = schema_cache.columns_hash(table_name)
-
-            values_list = fixtures.map do |fixture|
-              fixture = fixture.stringify_keys
-
-              unknown_columns = fixture.keys - columns.keys
-              if unknown_columns.any?
-                raise Fixture::FixtureError, %(table "#{table_name}" has no columns named #{unknown_columns.map(&:inspect).join(', ')}.)
-              end
-
-              columns.map do |name, column|
-                if fixture.key?(name)
-                  type = lookup_cast_type_from_column(column)
-                  with_yaml_fallback(type.serialize(fixture[name]))
-                else
-                  default_insert_value(column)
-                end
-              end
-            end
-
-            table = Arel::Table.new(table_name)
-            manager = Arel::InsertManager.new
-            manager.into(table)
-
-            if values_list.size == 1
-              values = values_list.shift
-              new_values = []
-              columns.each_key.with_index { |column, i|
-                unless values[i].equal?(DEFAULT_INSERT_VALUE)
-                  new_values << values[i]
-                  manager.columns << table[column]
-                end
-              }
-              values_list << new_values
-            else
-              columns.each_key { |column| manager.columns << table[column] }
-            end
-
-            manager.values = manager.create_values_list(values_list)
-            manager.to_sql
-          end
-
-          def build_fixture_statements(fixture_set)
-            fixture_set.map do |table_name, fixtures|
-              next if fixtures.empty?
-              build_fixture_sql(fixtures, table_name)
-            end.compact
-          end
-
-          def with_multi_statements
-            yield
-          end
       end
     end
   end

data/lib/active_record/connection_adapters/cockroachdb/database_tasks.rb

@@ -10,37 +10,44 @@ module ActiveRecord
               "https://github.com/cockroachdb/activerecord-cockroachdb-adapter/issues/new"
           end
 
-          case ActiveRecord.dump_schemas
-          when :all, String
-            raise  "Custom schemas are not supported in CockroachDB. " \
-              "See https://github.com/cockroachdb/cockroach/issues/26443."
-          when :schema_search_path
-            if configuration_hash[:schema_search_path]
-              raise  "Custom schemas are not supported in CockroachDB. " \
-                "See https://github.com/cockroachdb/cockroach/issues/26443."
+          # "See https://github.com/cockroachdb/cockroach/issues/26443."
+          search_path =
+            case ActiveRecord.dump_schemas
+            when :schema_search_path
+              configuration_hash[:schema_search_path]
+            when :all
+              nil
+            when String
+              ActiveRecord.dump_schemas
             end
-          end
 
           conn = ActiveRecord::Base.connection
-          File.open(filename, "w") do |file|
-            %w(SCHEMAS TYPES).each do |object_kind|
-              ActiveRecord::Base.connection.execute("SHOW CREATE ALL #{object_kind}").each_row { file.puts _1 }
-            end
+          begin
+            old_search_path = conn.schema_search_path
+            conn.schema_search_path = search_path
+            File.open(filename, "w") do |file|
+              %w(SCHEMAS TYPES).each do |object_kind|
+                ActiveRecord::Base.connection.execute("SHOW CREATE ALL #{object_kind}").each_row { file.puts _1 }
+              end
 
-            ignore_tables = ActiveRecord::SchemaDumper.ignore_tables.to_set
+              ignore_tables = ActiveRecord::SchemaDumper.ignore_tables.to_set
 
-            conn.execute("SHOW CREATE ALL TABLES").each_row do |(sql)|
-              if sql.start_with?("CREATE")
-                table_name = sql[/CREATE TABLE (?:.*?\.)?\"?(.*?)[\" ]/, 1]
-                next if ignore_tables.member?(table_name)
-              elsif sql.start_with?("ALTER")
-                table_name = sql[/ALTER TABLE (?:.*?\.)?\"?(.*?)[\" ]/, 1]
-                ref_table_name = sql[/REFERENCES (?:.*?\.)?\"?(.*?)[\" ]/, 1]
-                next if ignore_tables.member?(table_name) || ignore_tables.member?(ref_table_name)
-              end
+              conn.execute("SHOW CREATE ALL TABLES").each_row do |(sql)|
+                if sql.start_with?("CREATE")
+                  table_name = sql[/CREATE TABLE (?:.*?\.)?\"?(.*?)[\" ]/, 1]
+                  next if ignore_tables.member?(table_name)
+                elsif sql.start_with?("ALTER")
+                  table_name = sql[/ALTER TABLE (?:.*?\.)?\"?(.*?)[\" ]/, 1]
+                  ref_table_name = sql[/REFERENCES (?:.*?\.)?\"?(.*?)[\" ]/, 1]
+                  next if ignore_tables.member?(table_name) || ignore_tables.member?(ref_table_name)
+                end
 
-              file.puts sql
+                file.puts sql
+              end
+              file.puts "SET seach_path TO #{conn.schema_search_path};\n\n"
             end
+          ensure
+            conn.schema_search_path = old_search_path
           end
         end
 

data/lib/active_record/connection_adapters/cockroachdb/referential_integrity.rb

@@ -11,6 +11,14 @@ module ActiveRecord
   module ConnectionAdapters
     module CockroachDB
       module ReferentialIntegrity
+        # CockroachDB will raise a `PG::ForeignKeyViolation` when re-enabling
+        # referential integrity (e.g: adding a foreign key with invalid data
+        # raises).
+        # So foreign keys should always be valid for that matter.
+        def check_all_foreign_keys_valid!
+          true
+        end
+
         def disable_referential_integrity
           foreign_keys = tables.map { |table| foreign_keys(table) }.flatten
 
@@ -31,16 +39,12 @@ module ActiveRecord
 
           begin
             foreign_keys.each do |foreign_key|
-              begin
-                add_foreign_key(foreign_key.from_table, foreign_key.to_table, **foreign_key.options)
-              rescue ActiveRecord::StatementInvalid => error
-                if error.cause.class == PG::DuplicateObject
-                  # This error is safe to ignore because the yielded caller
-                  # already re-added the foreign key constraint.
-                else
-                  raise error
-                end
-              end
+              # Avoid having PG:DuplicateObject error if a test is ran in transaction.
+              # TODO: verify that there is no cache issue related to running this (e.g: fk
+              #   still in cache but not in db)
+              next if foreign_key_exists?(foreign_key.from_table, name: foreign_key.options[:name])
+
+              add_foreign_key(foreign_key.from_table, foreign_key.to_table, **foreign_key.options)
             end
           ensure
             ActiveRecord::Base.table_name_prefix = old_prefix

data/lib/active_record/connection_adapters/cockroachdb/schema_statements.rb

@@ -36,16 +36,25 @@ module ActiveRecord
         # Modified version of the postgresql foreign_keys method.
         # Replaces t2.oid::regclass::text with t2.relname since this is
         # more efficient in CockroachDB.
+        # Also, CockroachDB does not append the schema name in relname,
+        # so we append it manually.
         def foreign_keys(table_name)
           scope = quoted_scope(table_name)
           fk_info = exec_query(<<~SQL, "SCHEMA")
-            SELECT t2.relname AS to_table, a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete, c.convalidated AS valid
+            SELECT CASE
+              WHEN n2.nspname = current_schema()
+              THEN ''
+              ELSE n2.nspname || '.'
+            END || t2.relname AS to_table,
+            a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete, c.convalidated AS valid, c.condeferrable AS deferrable, c.condeferred AS deferred,
+            c.conkey, c.confkey, c.conrelid, c.confrelid
             FROM pg_constraint c
             JOIN pg_class t1 ON c.conrelid = t1.oid
             JOIN pg_class t2 ON c.confrelid = t2.oid
             JOIN pg_attribute a1 ON a1.attnum = c.conkey[1] AND a1.attrelid = t1.oid
             JOIN pg_attribute a2 ON a2.attnum = c.confkey[1] AND a2.attrelid = t2.oid
             JOIN pg_namespace t3 ON c.connamespace = t3.oid
+            JOIN pg_namespace n2 ON t2.relnamespace = n2.oid
             WHERE c.contype = 'f'
               AND t1.relname = #{scope[:name]}
               AND t3.nspname = #{scope[:schema]}
@@ -53,17 +62,31 @@ module ActiveRecord
           SQL
 
           fk_info.map do |row|
+            to_table = PostgreSQL::Utils.unquote_identifier(row["to_table"])
+            conkey = row["conkey"].scan(/\d+/).map(&:to_i)
+            confkey = row["confkey"].scan(/\d+/).map(&:to_i)
+
+            if conkey.size > 1
+              column = column_names_from_column_numbers(row["conrelid"], conkey)
+              primary_key = column_names_from_column_numbers(row["confrelid"], confkey)
+            else
+              column = PostgreSQL::Utils.unquote_identifier(row["column"])
+              primary_key = row["primary_key"]
+            end
+
             options = {
-              column: row["column"],
+              column: column,
               name: row["name"],
-              primary_key: row["primary_key"]
+              primary_key: primary_key
             }
-
             options[:on_delete] = extract_foreign_key_action(row["on_delete"])
             options[:on_update] = extract_foreign_key_action(row["on_update"])
+            options[:deferrable] = extract_constraint_deferrable(row["deferrable"], row["deferred"])
+
             options[:validate] = row["valid"]
+            to_table = PostgreSQL::Utils.unquote_identifier(row["to_table"])
 
-            ForeignKeyDefinition.new(table_name, row["to_table"], options)
+            ForeignKeyDefinition.new(table_name, to_table, options)
           end
         end
 
@@ -76,16 +99,20 @@ module ActiveRecord
 
         # override
         # https://github.com/rails/rails/blob/6-0-stable/activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb#L624
-        def new_column_from_field(table_name, field)
-          column_name, type, default, notnull, oid, fmod, collation, comment, generated, hidden = field
+        def new_column_from_field(table_name, field, _definition)
+          column_name, type, default, notnull, oid, fmod, collation, comment, identity, attgenerated, hidden = field
           type_metadata = fetch_type_metadata(column_name, type, oid.to_i, fmod.to_i)
           default_value = extract_value_from_default(default)
-          default_function = extract_default_function(default_value, default)
 
-          serial =
-            if (match = default_function&.match(/\Anextval\('"?(?<sequence_name>.+_(?<suffix>seq\d*))"?'::regclass\)\z/))
-              sequence_name_from_parts(table_name, column_name, match[:suffix]) == match[:sequence_name]
-            end
+          if attgenerated.present?
+            default_function = default
+          else
+            default_function = extract_default_function(default_value, default)
+          end
+
+          if match = default_function&.match(/\Anextval\('"?(?<sequence_name>.+_(?<suffix>seq\d*))"?'::regclass\)\z/)
+            serial = sequence_name_from_parts(table_name, column_name, match[:suffix]) == match[:sequence_name]
+          end
 
           # {:dimension=>2, :has_m=>false, :has_z=>false, :name=>"latlon", :srid=>0, :type=>"GEOMETRY"}
           spatial = spatial_column_info(table_name).get(column_name, type_metadata.sql_type)
@@ -99,8 +126,9 @@ module ActiveRecord
             collation: collation,
             comment: comment.presence,
             serial: serial,
+            identity: identity.presence,
             spatial: spatial,
-            generated: generated,
+            generated: attgenerated,
             hidden: hidden
           )
         end

data/lib/active_record/connection_adapters/cockroachdb/type.rb

@@ -1,15 +1,16 @@
 module ActiveRecord
   module Type
-    class << self
+    module CRDBExt
       # Return :postgresql instead of :cockroachdb for current_adapter_name so
       # we can continue using the ActiveRecord::Types defined in
       # PostgreSQLAdapter.
       def adapter_name_from(model)
-        name = model.connection_db_config.adapter.to_sym
+        name = super
         return :postgresql if name == :cockroachdb
 
         name
       end
     end
+    singleton_class.prepend CRDBExt
   end
 end

data/lib/active_record/connection_adapters/cockroachdb_adapter.rb

@@ -1,5 +1,6 @@
 require "rgeo/active_record"
 
+require_relative "../../arel/nodes/join_source_ext"
 require "active_record/connection_adapters/postgresql_adapter"
 require "active_record/connection_adapters/cockroachdb/attribute_methods"
 require "active_record/connection_adapters/cockroachdb/column_methods"
@@ -160,7 +161,7 @@ module ActiveRecord
       end
 
       def supports_bulk_alter?
-        false
+        true
       end
 
       def supports_json?
@@ -181,7 +182,15 @@ module ActiveRecord
       end
 
       def supports_partial_index?
-        @crdb_version >= 2020
+        true
+      end
+
+      def supports_index_include?
+        false
+      end
+
+      def supports_exclusion_constraints?
+        false
       end
 
       def supports_expression_index?
@@ -196,7 +205,7 @@ module ActiveRecord
       end
 
       def supports_comments?
-        @crdb_version >= 2010
+        true
       end
 
       def supports_comments_in_create?
@@ -208,11 +217,11 @@ module ActiveRecord
       end
 
       def supports_virtual_columns?
-        @crdb_version >= 2110
+        true
       end
 
       def supports_string_to_array_coercion?
-        @crdb_version >= 2020
+        true
       end
 
       def supports_partitioned_indexes?
@@ -238,62 +247,30 @@ module ActiveRecord
       alias index_name_length max_identifier_length
       alias table_alias_length max_identifier_length
 
-      def initialize(connection, logger, conn_params, config)
-        super(connection, logger, conn_params, config)
-
-        # crdb_version is the version of the binary running on the node. We
-        # really want to use `SHOW CLUSTER SETTING version` to get the cluster
-        # version, but that is only available to admins. Instead, we can use
-        # crdb_internal.is_at_least_version, but that's only available in 22.1.
-        crdb_version_string = query_value("SHOW crdb_version")
-        if crdb_version_string.include? "v22.1"
-          version_num = query_value(<<~SQL, "VERSION")
-            SELECT
-              CASE
-              WHEN crdb_internal.is_at_least_version('22.2') THEN 2220
-              WHEN crdb_internal.is_at_least_version('22.1') THEN 2210
-              ELSE 2120
-              END;
-          SQL
-        else
-          # This branch can be removed once the dialect stops supporting v21.2
-          # and earlier.
-          if crdb_version_string.include? "v1."
-            version_num = 1
-          elsif crdb_version_string.include? "v2."
-            version_num 2
-          elsif crdb_version_string.include? "v19.1."
-            version_num = 1910
-          elsif crdb_version_string.include? "v19.2."
-            version_num = 1920
-          elsif crdb_version_string.include? "v20.1."
-            version_num = 2010
-          elsif crdb_version_string.include? "v20.2."
-            version_num = 2020
-          elsif crdb_version_string.include? "v21.1."
-            version_num = 2110
-          else
-            version_num = 2120
-          end
-        end
-        @crdb_version = version_num.to_i
-
-        # NOTE: this is normally in configure_connection, but that is run
-        # before crdb_version is determined. Once all supported versions
-        # of CockroachDB support SET intervalstyle it can safely be moved
-        # back.
-        # Set interval output format to ISO 8601 for ease of parsing by ActiveSupport::Duration.parse
-        if @crdb_version >= 2120
-          begin
-            execute("SET intervalstyle_enabled = true", "SCHEMA")
-            execute("SET intervalstyle = iso_8601", "SCHEMA")
-          rescue
-            # Ignore any error. This can happen with a cluster that has
-            # not yet finalized the v21.2 upgrade. v21.2 does not have
-            # a way to tell if the upgrade was finalized (see comment above).
-          end
-        end
-      end
+      # NOTE: This commented bit of code allows to have access to crdb version,
+      # which can be useful for feature detection. However, we currently don't
+      # need, hence we avoid the extra queries.
+      #
+      #   def initialize(connection, logger, conn_params, config)
+      #     super(connection, logger, conn_params, config)
+
+      #     # crdb_version is the version of the binary running on the node. We
+      #     # really want to use `SHOW CLUSTER SETTING version` to get the cluster
+      #     # version, but that is only available to admins. Instead, we can use
+      #     # crdb_internal.is_at_least_version, but that's only available in 22.1.
+      #     crdb_version_string = query_value("SHOW crdb_version")
+      #     if crdb_version_string.include? "v22.1"
+      #       version_num = query_value(<<~SQL, "VERSION")
+      #         SELECT
+      #           CASE
+      #           WHEN crdb_internal.is_at_least_version('22.2') THEN 2220
+      #           WHEN crdb_internal.is_at_least_version('22.1') THEN 2210
+      #           ELSE 2120
+      #           END;
+      #       SQL
+      #     end
+      #     @crdb_version = version_num.to_i
+      #   end
 
       def self.database_exists?(config)
         !!ActiveRecord::Base.cockroachdb_connection(config)
@@ -306,12 +283,12 @@ module ActiveRecord
       # (DO $$) that CockroachDB does not support.
       #
       # Given a name and an array of values, creates an enum type.
-      def create_enum(name, values)
-        sql_values = values.map { |s| "'#{s}'" }.join(", ")
+      def create_enum(name, values, **options)
+        sql_values = values.map { |s| quote(s) }.join(", ")
         query = <<~SQL
-          CREATE TYPE IF NOT EXISTS \"#{name}\" AS ENUM (#{sql_values});
+          CREATE TYPE IF NOT EXISTS #{quote_table_name(name)} AS ENUM (#{sql_values});
         SQL
-        exec_query(query)
+        internal_exec_query(query).tap { reload_type_map }
       end
 
       class << self
@@ -369,56 +346,6 @@ module ActiveRecord
 
       private
 
-        # Configures the encoding, verbosity, schema search path, and time zone of the connection.
-        # This is called by #connect and should not be called manually.
-        #
-        # NOTE(joey): This was cradled from postgresql_adapter.rb. This
-        # was due to needing to override configuration statements.
-        def configure_connection
-          if @config[:encoding]
-            @connection.set_client_encoding(@config[:encoding])
-          end
-          self.client_min_messages = @config[:min_messages] || "warning"
-          self.schema_search_path = @config[:schema_search_path] || @config[:schema_order]
-
-          # Use standard-conforming strings so we don't have to do the E'...' dance.
-          set_standard_conforming_strings
-
-          variables = @config.fetch(:variables, {}).stringify_keys
-
-          # If using Active Record's time zone support configure the connection to return
-          # TIMESTAMP WITH ZONE types in UTC.
-          unless variables["timezone"]
-            if ActiveRecord.default_timezone == :utc
-              variables["timezone"] = "UTC"
-            elsif @local_tz
-              variables["timezone"] = @local_tz
-            end
-          end
-
-          # NOTE(joey): This is a workaround as CockroachDB 1.1.x
-          # supports SET TIME ZONE <...> and SET "time zone" = <...> but
-          # not SET timezone = <...>.
-          if variables.key?("timezone")
-            tz = variables.delete("timezone")
-            execute("SET TIME ZONE #{quote(tz)}", "SCHEMA")
-          end
-
-          # SET statements from :variables config hash
-          # https://www.postgresql.org/docs/current/static/sql-set.html
-          variables.map do |k, v|
-            if v == ":default" || v == :default
-              # Sets the value to the global or compile default
-
-              # NOTE(joey): I am not sure if simply commenting this out
-              # is technically correct.
-              # execute("SET #{k} = DEFAULT", "SCHEMA")
-            elsif !v.nil?
-              execute("SET SESSION #{k} = #{quote(v)}", "SCHEMA")
-            end
-          end
-        end
-
         # Override extract_value_from_default because the upstream definition
         # doesn't handle the variations in CockroachDB's behavior.
         def extract_value_from_default(default)
@@ -502,7 +429,8 @@ module ActiveRecord
               SELECT a.attname, format_type(a.atttypid, a.atttypmod),
                      pg_get_expr(d.adbin, d.adrelid), a.attnotnull, a.atttypid, a.atttypmod,
                      c.collname, NULL AS comment,
-                     #{supports_virtual_columns? ? 'attgenerated' : quote('')} as attgenerated,
+                     attidentity,
+                     attgenerated,
                      NULL as is_hidden
                 FROM pg_attribute a
                 LEFT JOIN pg_attrdef d ON a.attrelid = d.adrelid AND a.attnum = d.adnum
@@ -517,26 +445,31 @@ module ActiveRecord
 
           # Use regex comparison because if a type is an array it will
           # have [] appended to the end of it.
-          target_types = [
-            /geometry/,
-            /geography/,
-            /interval/,
-            /numeric/
-          ]
-
-          re = Regexp.union(target_types)
+          re = /\A(?:geometry|geography|interval|numeric)/
+
+          # 0: attname
+          # 1: type
+          # 2: default
+          # 3: attnotnull
+          # 4: atttypid
+          # 5: atttypmod
+          # 6: collname
+          # 7: comment
+          # 8: attidentity
+          # 9: attgenerated
+          # 10: is_hidden
           fields.map do |field|
             dtype = field[1]
             field[1] = crdb_fields[field[0]][2].downcase if re.match(dtype)
             field[7] = crdb_fields[field[0]][1]&.gsub!(/^\'|\'?$/, '')
-            field[9] = true if crdb_fields[field[0]][3]
+            field[10] = true if crdb_fields[field[0]][3]
             field
           end
           fields.delete_if do |field|
             # Don't include rowid column if it is hidden and the primary key
             # is not defined (meaning CRDB implicitly created it).
             if field[0] == CockroachDBAdapter::DEFAULT_PRIMARY_KEY
-              field[9] && !primary_key(table_name)
+              field[10] && !primary_key(table_name)
             else
               false # Keep this entry.
             end
@@ -549,11 +482,14 @@ module ActiveRecord
         # precision, and scale information in the type.
         # Ex. geometry -> geometry(point, 4326)
         def crdb_column_definitions(table_name)
+          table_name = PostgreSQL::Utils.extract_schema_qualified_name(table_name)
+          table = table_name.identifier
+          with_schema = " AND c.table_schema = #{quote(table_name.schema)}" if table_name.schema
           fields = \
           query(<<~SQL, "SCHEMA")
             SELECT c.column_name, c.column_comment, c.crdb_sql_type, c.is_hidden::BOOLEAN
-              FROM information_schema.columns c
-            WHERE c.table_name = #{quote(table_name)}
+            FROM information_schema.columns c
+            WHERE c.table_name = #{quote(table)}#{with_schema}
           SQL
 
           fields.reduce({}) do |a, e|
@@ -594,21 +530,10 @@ module ActiveRecord
         def load_additional_types(oids = nil)
           if @config[:use_follower_reads_for_type_introspection]
             initializer = OID::TypeMapInitializer.new(type_map)
-
-            query = <<~SQL
-              SELECT t.oid, t.typname, t.typelem, t.typdelim, t.typinput, r.rngsubtype, t.typtype, t.typbasetype
-              FROM pg_type as t
-              LEFT JOIN pg_range as r ON oid = rngtypid AS OF SYSTEM TIME '-10s'
-            SQL
-
-            if oids
-              query += "WHERE t.oid IN (%s)" % oids.join(", ")
-            else
-              query += initializer.query_conditions_for_initial_load
-            end
-
-            execute_and_clear(query, "SCHEMA", []) do |records|
-              initializer.run(records)
+            load_types_queries_with_aost(initializer, oids) do |query|
+              execute_and_clear(query, "SCHEMA", [], allow_retry: true, materialize_transactions: false) do |records|
+                initializer.run(records)
+              end
             end
           else
             super
@@ -619,6 +544,21 @@ module ActiveRecord
           super
         end
 
+        def load_types_queries_with_aost(initializer, oids)
+          query = <<~SQL
+            SELECT t.oid, t.typname, t.typelem, t.typdelim, t.typinput, r.rngsubtype, t.typtype, t.typbasetype
+            FROM pg_type as t
+            LEFT JOIN pg_range as r ON oid = rngtypid AS OF SYSTEM TIME '-10s'
+          SQL
+          if oids
+            yield query + "WHERE t.oid IN (%s)" % oids.join(", ")
+          else
+            yield query + initializer.query_conditions_for_known_type_names
+            yield query + initializer.query_conditions_for_known_type_types
+            yield query + initializer.query_conditions_for_array_types
+          end
+        end
+
         # override
         # This method maps data types to their proper decoder.
         #
@@ -649,15 +589,13 @@ module ActiveRecord
               WHERE t.typname IN (%s)
             SQL
 
-            coders = execute_and_clear(query, "SCHEMA", []) do |result|
-              result
-                .map { |row| construct_coder(row, coders_by_name[row["typname"]]) }
-                .compact
+            coders = execute_and_clear(query, "SCHEMA", [], allow_retry: true, materialize_transactions: false) do |result|
+              result.filter_map { |row| construct_coder(row, coders_by_name[row["typname"]]) }
             end
 
             map = PG::TypeMapByOid.new
             coders.each { |coder| map.add_coder(coder) }
-            @connection.type_map_for_results = map
+            @raw_connection.type_map_for_results = map
 
             @type_map_for_results = PG::TypeMapByOid.new
             @type_map_for_results.default_type_map = map

data/lib/active_record/relation/query_methods_ext.rb

@@ -3,6 +3,23 @@
 module ActiveRecord
   class Relation
     module QueryMethodsExt
+      def aost!(time) # :nodoc:
+        unless time.nil? || time.is_a?(Time)
+          raise ArgumentError, "Unsupported argument type: #{time} (#{time.class})"
+        end
+
+        @aost = time
+        self
+      end
+
+      # Set system time for the current query. Using
+      # `.aost(nil)` resets.
+      #
+      # See cockroachlabs.com/docs/stable/as-of-system-time
+      def aost(time)
+        spawn.aost!(time)
+      end
+
       def from!(...) # :nodoc:
         @force_index = nil
         @index_hint = nil
@@ -59,8 +76,20 @@ module ActiveRecord
         self
       end
 
+      # TODO: reset or no reset?
+
+      def show_create
+        connection.execute("show create table #{connection.quote_table_name self.table_name}").first["create_statement"]
+      end
+
       private
 
+      def build_arel(...)
+        arel = super
+        arel.aost(@aost) if @aost.present?
+        arel
+      end
+
       def from_clause_is_a_table_name?
         # if empty, we are just dealing with the current table.
         return true if from_clause.empty?
@@ -94,5 +123,5 @@ module ActiveRecord
   # as ancestor. That is how active_record is doing is as well.
   #
   # @see https://github.com/rails/rails/blob/914130a9f/activerecord/lib/active_record/querying.rb#L23
-  Querying.delegate(:force_index, :index_hint, to: :all)
+  Querying.delegate(:force_index, :index_hint, :aost, :show_create, to: :all)
 end

data/lib/arel/nodes/join_source_ext.rb

@@ -0,0 +1,28 @@
+module Arel
+  module Nodes
+    module JoinSourceExt
+      def initialize(...)
+        super
+        @aost = nil
+      end
+
+      def hash
+        [*super, aost].hash
+      end
+
+      def eql?(other)
+        super && aost == other.aost
+      end
+      alias_method :==, :eql?
+    end
+    JoinSource.attr_accessor :aost
+    JoinSource.prepend JoinSourceExt
+  end
+  module SelectManagerExt
+    def aost(time)
+      @ctx.source.aost = time
+      nil
+    end
+  end
+  SelectManager.prepend SelectManagerExt
+end

data/lib/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveRecord
-  COCKROACH_DB_ADAPTER_VERSION = "7.0.3"
+  COCKROACH_DB_ADAPTER_VERSION = "7.1.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-cockroachdb-adapter
 version: !ruby/object:Gem::Version
-  version: 7.0.3
+  version: 7.1.0
 platform: ruby
 authors:
 - Cockroach Labs
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-08-23 00:00:00.000000000 Z
+date: 2024-01-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 7.0.3
+        version: 7.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 7.0.3
+        version: 7.1.0
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
@@ -74,6 +74,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".editorconfig"
 - ".github/workflows/ci.yml"
 - ".github/workflows/docker.yml"
 - ".gitignore"
@@ -87,6 +88,8 @@ files:
 - Rakefile
 - activerecord-cockroachdb-adapter.gemspec
 - bin/console
+- bin/console_schemas/default.rb
+- bin/console_schemas/schemas.rb
 - bin/setup
 - bin/start-cockroachdb
 - build/Dockerfile
@@ -118,6 +121,7 @@ files:
 - lib/active_record/migration/cockroachdb/compatibility.rb
 - lib/active_record/relation/query_methods_ext.rb
 - lib/activerecord-cockroachdb-adapter.rb
+- lib/arel/nodes/join_source_ext.rb
 - lib/version.rb
 homepage: https://github.com/cockroachdb/activerecord-cockroachdb-adapter
 licenses:
@@ -139,7 +143,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.9
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: CockroachDB adapter for ActiveRecord.