activerecord-cockroachdb-adapter 7.0.2 → 7.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a24349ecd71877aabdf47013dd73406e4bb16c0495fee7295e11656a6eea20b4
-  data.tar.gz: 1bf5fe5b0d56f12249090edfd84bd56a81ac18f05670259a7473d780648045e5
+  metadata.gz: 594ac59a7a678d5619ea771e3130a481481560adcc88032d7c17d61b6dabc279
+  data.tar.gz: 0cd6ea6bd6a1fe808142a91e35a24d4e15a59b48f56e4dba37d8a25584dd7a8a
 SHA512:
-  metadata.gz: 24bd03ffa04bdd43827923fbe411b8d05e74fad8f9bedd54511de71593d06a2b40e5289a15bc84d09ec9002b949a5b0e91a168cba3b451d003e54f36ecfa758a
-  data.tar.gz: 90dd57aee1a18163fc18b9027f45dbed3045183de4bc2d098cc895e90d3723c4512f00dce1255263dd08b11b449adc5f84f6de4da4a07ac9802e82ed22d571b0
+  metadata.gz: 56205a247976012b6a25691045a773ca9fefecc1b98bb47ee83fb85dffede72a8aed5bc605a332d00b31fb57f67ee1018b850d14638581454980a6b96d2e8865
+  data.tar.gz: 92515e498cc8cedfe284cfe4cf9b3cb87eae72630aa5828e5983dfabe488ad214386561a0fb8072963b0796559209ee033cb010495d263d44eb1abf048afaa37

data/.github/workflows/ci.yml

@@ -0,0 +1,86 @@
+# Inspired from:
+# - https://github.com/cockroachdb/sqlalchemy-cockroachdb/blob/master/.github/workflows/ci.yml
+# - https://github.com/rgeo/activerecord-postgis-adapter/blob/master/.github/workflows/tests.yml
+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:
+      - "*"
+  pull_request:
+    types: [opened, reopened, synchronize]
+
+  # Allows you to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+# 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 }}'
+  cancel-in-progress: true
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        crdb: [v23.1.5]
+        ruby: [ruby-head]
+    name: Test (crdb=${{ matrix.crdb }} ruby=${{ matrix.ruby }})
+    steps:
+      - name: Set Up Actions
+        uses: actions/checkout@v3
+      - 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
+      - name: Install and Start Cockroachdb
+        run: |
+          # Download CockroachDB
+          wget -qO- https://binaries.cockroachdb.com/cockroach-${{ matrix.crdb }}.linux-amd64.tgz | tar xvz
+
+          export PATH=./cockroach-${{ matrix.crdb }}.linux-amd64/:$PATH
+          readonly urlfile=cockroach-url
+
+          # Start a CockroachDB server and wait for it to become ready.
+          rm -f "$urlfile"
+          rm -rf cockroach-data
+          # Start CockroachDB.
+          cockroach start-single-node --max-sql-memory=25% --cache=25% --insecure --host=localhost --spatial-libs=./cockroach-${{ matrix.crdb }}.linux-amd64/lib --listening-url-file="$urlfile" >/dev/null 2>&1 &
+          # Ensure CockroachDB is stopped on script exit.
+          # Wait until CockroachDB has started.
+          for i in {0..3}; do
+            [[ -f "$urlfile" ]] && break
+            backoff=$((2 ** i))
+            echo "server not yet available; sleeping for $backoff seconds"
+            sleep $backoff
+          done
+          cockroach sql --insecure -e "
+            CREATE DATABASE activerecord_unittest;
+            CREATE DATABASE activerecord_unittest2;
+            SET CLUSTER SETTING sql.stats.automatic_collection.enabled = false;
+            SET CLUSTER SETTING sql.stats.histogram_collection.enabled = false;
+            SET CLUSTER SETTING jobs.retention_time = '180s';
+            SET CLUSTER SETTING sql.defaults.experimental_alter_column_type.enabled = 'true';
+
+            ALTER RANGE default CONFIGURE ZONE USING num_replicas = 1, gc.ttlseconds = 30;
+            ALTER TABLE system.public.jobs CONFIGURE ZONE USING num_replicas = 1, gc.ttlseconds = 30;
+            ALTER RANGE meta CONFIGURE ZONE USING num_replicas = 1, gc.ttlseconds = 30;
+            ALTER RANGE system CONFIGURE ZONE USING num_replicas = 1, gc.ttlseconds = 30;
+            ALTER RANGE liveness CONFIGURE ZONE USING num_replicas = 1, gc.ttlseconds = 30;
+
+            SET CLUSTER SETTING kv.range_merge.queue_interval = '50ms';
+            SET CLUSTER SETTING kv.raft_log.disable_synchronization_unsafe = 'true';
+            SET CLUSTER SETTING jobs.registry.interval.cancel = '180s';
+            SET CLUSTER SETTING jobs.registry.interval.gc = '30s';
+            SET CLUSTER SETTING kv.range_split.by_load_merge_delay = '5s';
+
+            SET CLUSTER SETTING sql.defaults.experimental_temporary_tables.enabled = 'true';
+          "
+      - name: Test
+        run: bundle exec rake test

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## Ongoing
+
+## 7.0.3 - 2023-08-23
+
+- Fix Multiple Database connections ([#283](https://github.com/cockroachdb/activerecord-cockroachdb-adapter/pull/)).
+- Add support for sql load in rake tasks ([#275](https://github.com/cockroachdb/activerecord-cockroachdb-adapter/pull/)).
+- Add support for sql dump in rake tasks ([#273](https://github.com/cockroachdb/activerecord-cockroachdb-adapter/pull/)).
+- Add support for table optimize hints ([#266](https://github.com/cockroachdb/activerecord-cockroachdb-adapter/pull/)).
+
 ## 7.0.2 - 2023-05-23
 
 - Fix default numbers test to expect the correct result after

data/CONTRIBUTING.md

@@ -15,12 +15,15 @@ override and monkey-patch functionality.
 
 ## Setup and running tests
 
-In CockroachDB, create two databases to be used by the ActiveRecord test suite:
+### CockroachDB
+
+First, You should setup a cockroachdb local instance. You can use the
+`bin/start-cockroachdb` to help you with that task. Otherwise, once setup,
+create two databases to be used by the ActiveRecord test suite:
 activerecord_unittest and activerecord_unittest2.
 
 ```sql
 CREATE DATABASE activerecord_unittest;
-
 CREATE DATABASE activerecord_unittest2;
 ```
 
@@ -87,12 +90,6 @@ To run a specific test case, use minitest's `-n` option to run tests that match
 TEST_FILES="test/cases/adapter_test.rb" TESTOPTS=`-n=/test_indexes/` bundle exec rake test
 ```
 
-By default, tests will be run from the bundled version of Rails. To run against a local copy, set environemnt variable `RAILS_SOURCE`. Running against a local copy of Rails can be helpful when try to debug issues.
-
-```bash
-RAILS_SOURCE="path/to/local_copy" bundle exec rake test
-```
-
 `test/config.yml` assumes CockroachDB will be running at localhost:26257 with a root user. Make changes to `test/config.yml` as needed.
 
 ### Run Tests from a Backup
@@ -117,23 +114,6 @@ And the `activerecord_unittest` database will use the `RESTORE` command to load
 
 # Improvements
 
-
-## Support past Rails versions
-
-Currently, only a beta version of Rails is tested. This means that the
-adapter has been modified in to accommodate unreleased changes. In order
-to run the tests for Rails 5.1 or 4.2, the test changes will need to be
-cherry-picked back. Conflicts are mostly only expected for tests that
-have not yet been added.
-
-Sadly, this does mean that we will have to have multiple versions of the
-driver for the multiple versions of Rails.
-
-A proposal for the CockroachDB adapter versioning would be to follow
-ActiveRecord minor versions. For example, if you use Rails 4.2.5, you
-would specify the CockroachDB version `~> 4.2.0`.
-
-
 ## Running CI automatically
 
 Currently the fork is set up to run using TeamCity only on the current
@@ -247,7 +227,7 @@ need to be cleaned up.
 
 # Notes for the non-Rubyer
 
-rvm is an environment manager that lets you manage and swap between
+rbenv is an environment manager that lets you manage and swap between
 multiple versions of Ruby and their dependencies.
 
 bundle is dependency manager that uses a projects `Gemfile` (and often

data/Gemfile

@@ -1,58 +1,49 @@
-require 'openssl'
-source 'https://rubygems.org'
-gemspec
+# frozen_string_literal: true
 
-if ENV['RAILS_SOURCE']
-  gemspec path: ENV['RAILS_SOURCE']
-else
-  def get_version_from_gemspec
-    gemspec = eval(File.read('activerecord-cockroachdb-adapter.gemspec'))
+source "https://rubygems.org"
 
-    gem_version = gemspec.dependencies.
-      find { |dep| dep.name == 'activerecord' }.
-      requirement.
-      requirements.
-      first.
-      last
+gemspec
 
-    major, minor, tiny, pre = gem_version.segments
 
-    if pre
-      gem_version.to_s
-    else
-      find_latest_matching_version(major, minor)
+module RailsTag
+  class << self
+    def call
+      req = gemspec_requirement
+      "v" + all_activerecord_versions.find { req.satisfied_by?(_1) }.version
     end
-  end
 
-  def find_latest_matching_version(gemspec_major, gemspec_minor)
-    all_activerecord_versions.
-      reject { |version| version["prerelease"] }.
-      map { |version| version["number"].split(".").map(&:to_i) }.
-      find { |major, minor|
-        major == gemspec_major && (minor == gemspec_minor || gemspec_minor.nil?)
-      }.join(".")
-  end
+    def gemspec_requirement
+      File
+        .foreach(File.expand_path("activerecord-cockroachdb-adapter.gemspec", __dir__), chomp: true)
+        .find { _1[/add_dependency\s.activerecord.,\s.(.*)./] }
+
+      Gem::Requirement.new(Regexp.last_match(1))
+    end
 
-  def all_activerecord_versions
-    require 'net/http'
-    require 'yaml'
+    def all_activerecord_versions
+      require 'net/http'
+      require 'yaml'
 
-    uri = URI.parse "https://rubygems.org/api/v1/versions/activerecord.yaml"
-    http = Net::HTTP.new(uri.host, uri.port)
-    http.use_ssl = true
-    http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      uri = URI.parse "https://rubygems.org/api/v1/versions/activerecord.yaml"
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
 
-    YAML.load(
-      http.request(Net::HTTP::Get.new(uri.request_uri)).body
-    )
+      YAML.load(
+        http.request(Net::HTTP::Get.new(uri.request_uri)).body
+      ).map { Gem::Version.new(_1["number"]) }
+    end
   end
-
-  # Get Rails from source because the gem doesn't include tests
-  version = ENV['RAILS_VERSION'] || get_version_from_gemspec
-  gem 'rails', git: "https://github.com/rails/rails.git", tag: "v#{version}"
 end
 
-group :development do
+
+group :development, :test do
+  # We need to load the gem from git to have access to activerecord's test files.
+  # You can use `path: "some/local/rails"` if you want to test the gem against
+  # a specific rails codebase.
+  gem "rails", github: "rails/rails", tag: RailsTag.call
+
+  gem "rake"
   gem "byebug"
   gem "minitest-excludes", "~> 2.0.1"
 

data/README.md

@@ -321,7 +321,7 @@ p modified_fac.parse_wkt(wkt)
 #=>  #<RGeo::Geographic::SphericalPolygonImpl>
 ```
 
-Be careful when performing calculations on potentially invalid geometries, as the results might be nonsensical. For example, the area returned of an hourglass made of 2 equivalent triangles with a self-intersection in the middle is 0. 
+Be careful when performing calculations on potentially invalid geometries, as the results might be nonsensical. For example, the area returned of an hourglass made of 2 equivalent triangles with a self-intersection in the middle is 0.
 
 Note that when using the `spherical_factory`, there is a chance that valid geometries will be interpreted as invalid due to floating point issues with small geometries.
 

data/Rakefile

@@ -4,14 +4,12 @@ require_relative 'test/support/paths_cockroachdb'
 require_relative 'test/support/rake_helpers'
 require_relative 'test/support/template_creator'
 
-task test: ["test:cockroachdb"]
 task default: [:test]
 
 namespace :db do
   task "create_test_template" do
     ENV['DEBUG_COCKROACHDB_ADAPTER'] = "1"
     ENV['COCKROACH_SKIP_LOAD_SCHEMA'] = "1"
-    ENV["ARCONN"] = "cockroachdb"
 
     TemplateCreator.connect
     require_relative 'test/cases/helper'
@@ -26,17 +24,9 @@ namespace :db do
   end
 end
 
-namespace :test do
-  Rake::TestTask.new("cockroachdb") do |t|
-    t.libs = ARTest::CockroachDB.test_load_paths
-    t.test_files = test_files
-    t.warning = !!ENV["WARNING"]
-    t.verbose = false
-  end
-
-  task "cockroachdb:env" do
-    ENV["ARCONN"] = "cockroachdb"
-  end
+Rake::TestTask.new do |t|
+  t.libs = ARTest::CockroachDB.test_load_paths
+  t.test_files = RakeHelpers.test_files
+  t.warning = !!ENV["WARNING"]
+  t.verbose = false
 end
-
-task 'test:cockroachdb' => 'test:cockroachdb:env'

data/activerecord-cockroachdb-adapter.gemspec

@@ -1,9 +1,6 @@
-# coding: utf-8
+# frozen_string_literal: true
 
-lib = File.expand_path('lib', __dir__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-
-require './lib/version.rb'
+require_relative 'lib/version'
 version = ActiveRecord::COCKROACH_DB_ADAPTER_VERSION
 
 Gem::Specification.new do |spec|

data/bin/console

@@ -1,14 +1,50 @@
 #!/usr/bin/env ruby
 
-require "bundler/setup"
-require "activerecord/cockroachdb"
+$:.unshift(File.expand_path("../lib", __dir__))
 
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
+# require "bundler/setup"
+# Bundler.require :development
 
-# (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
-# Pry.start
+require "active_record"
+# This allows playing with the rake task as well. Ex:
+#
+#     ActiveRecord::Tasks::DatabaseTasks.
+#       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
 
 require "irb"
 IRB.start(__FILE__)

data/bin/start-cockroachdb

@@ -0,0 +1,48 @@
+#!/usr/bin/env zsh
+
+set -eu
+
+die() { echo "$0: $*" 1>&2 ; false; }
+
+root_dir="$(dirname $(dirname "$0:A"))"
+pid_file="$root_dir/tmp/cockroach.pid"
+log_file="$root_dir/tmp/cockroachdb.log"
+
+mkdir -p "$root_dir/tmp"
+rm -f "$pid_file"
+
+if ! (( ${+commands[cockroach]} )); then
+	die 'the `cockroach` toolchain is not installed.
+See https://www.cockroachlabs.com/docs/stable/install-cockroachdb.html'
+fi
+
+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
+
+
+cat <<-SQL | cockroach sql --insecure --host=localhost:26257 > /dev/null
+-- https://www.cockroachlabs.com/docs/stable/local-testing.html
+SET CLUSTER SETTING kv.raft_log.disable_synchronization_unsafe = true;
+SET CLUSTER SETTING kv.range_merge.queue_interval = '50ms';
+SET CLUSTER SETTING jobs.registry.interval.gc = '30s';
+SET CLUSTER SETTING jobs.registry.interval.cancel = '180s';
+SET CLUSTER SETTING jobs.retention_time = '15s';
+SET CLUSTER SETTING sql.stats.automatic_collection.enabled = false;
+SET CLUSTER SETTING kv.range_split.by_load_merge_delay = '5s';
+ALTER RANGE default CONFIGURE ZONE USING "gc.ttlseconds" = 600;
+ALTER DATABASE system CONFIGURE ZONE USING "gc.ttlseconds" = 600;
+
+CREATE DATABASE activerecord_unittest;
+CREATE DATABASE activerecord_unittest2;
+SQL
+
+tail -f "$log_file"
+
+trap "kill $cockroach_pid" EXIT

data/build/teamcity-test.sh

@@ -70,12 +70,7 @@ run_cockroach
 
 if ! (RUBYOPT="-W0" TESTOPTS="-v" bundle exec rake test); then
     echo "Tests failed"
-    HAS_FAILED=1
-else
-    echo "Tests passed"
-    HAS_FAILED=0
+    exit 1
 fi
 
-if [ $HAS_FAILED -eq 1 ]; then
-  exit 1
-fi
+echo "Tests passed"

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

@@ -1,7 +1,7 @@
 module ActiveRecord
   module ConnectionAdapters
     module CockroachDB
-      module PostgreSQLColumnMonkeyPatch
+      class Column < PostgreSQLColumn
         # 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,
@@ -93,9 +93,5 @@ module ActiveRecord
         end
       end
     end
-
-    class PostgreSQLColumn
-      prepend CockroachDB::PostgreSQLColumnMonkeyPatch
-    end
   end
 end

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

@@ -5,12 +5,89 @@ module ActiveRecord
     module CockroachDB
       class DatabaseTasks < ActiveRecord::Tasks::PostgreSQLDatabaseTasks
         def structure_dump(filename, extra_flags=nil)
-          raise "db:structure:dump is unimplemented. See https://github.com/cockroachdb/activerecord-cockroachdb-adapter/issues/2"
+          if extra_flags
+            raise "No flag supported yet, please raise an issue if needed. " \
+              "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."
+            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
+
+            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
+
+              file.puts sql
+            end
+          end
         end
 
         def structure_load(filename, extra_flags=nil)
-          raise "db:structure:load is unimplemented. See https://github.com/cockroachdb/activerecord-cockroachdb-adapter/issues/2"
+          if extra_flags
+            raise "No flag supported yet, please raise an issue if needed. " \
+              "https://github.com/cockroachdb/activerecord-cockroachdb-adapter/issues/new"
+          end
+
+          run_cmd("cockroach", ["sql", "--set", "errexit=false", "--file", filename], "loading")
+        end
+
+        private
+
+        # Adapted from https://github.com/rails/rails/blob/a5fc471b3/activerecord/lib/active_record/tasks/postgresql_database_tasks.rb#L106.
+        # Using https://www.cockroachlabs.com/docs/stable/connection-parameters.html#additional-connection-parameters.
+        def cockroach_env
+          usr_pwd = ""
+          if configuration_hash[:username]
+            usr_pwd += configuration_hash[:username].to_s
+            if configuration_hash[:password]
+              usr_pwd += ":"
+              usr_pwd += configuration_hash[:password].to_s
+            end
+            usr_pwd += "@"
+          end
+
+          port = ""
+          port = ":#{configuration_hash[:port]}" if configuration_hash[:port]
+
+          params = %i(sslmode sslrootcert sslcert sslkey).filter_map do |key|
+            "#{key}=#{configuration_hash[key]}" if configuration_hash[key]
+          end.join("&")
+          params = "?#{params}" unless params.empty?
+
+          url = "postgres://#{usr_pwd}#{db_config.host}#{port}/#{db_config.database}#{params}"
+
+          {
+            # NOTE: sslmode in the url will take precedence over this setting, hence
+            #   we don't need to conditionally set it.
+            "COCKROACH_INSECURE" => "true",
+            "COCKROACH_URL" => url
+          }
         end
+        # The `#run_cmd` method use `psql_env` to set environments variables.
+        # We override it with cockroach env variables.
+        alias_method :psql_env, :cockroach_env
       end
     end
   end

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

@@ -19,6 +19,12 @@ module ActiveRecord
         # converting to WKB, so this does it automatically.
         def quote(value)
           if value.is_a?(Numeric)
+            # NOTE: The fact that integers are quoted is important and helps
+            # mitigate a potential vulnerability.
+            #
+            # See
+            # - https://nvd.nist.gov/vuln/detail/CVE-2022-44566
+            # - https://github.com/cockroachdb/activerecord-cockroachdb-adapter/pull/280#discussion_r1288692977
             "'#{quote_string(value.to_s)}'"
           elsif RGeo::Feature::Geometry.check_type(value)
             "'#{RGeo::WKRep::WKBGenerator.new(hex_format: true, type_format: :ewkb, emit_ewkb_srid: true).generate(value)}'"

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

@@ -90,7 +90,7 @@ module ActiveRecord
           # {: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)
 
-          PostgreSQL::Column.new(
+          CockroachDB::Column.new(
             column_name,
             default_value,
             type_metadata,
@@ -112,7 +112,7 @@ module ActiveRecord
         # since type alone is not enough to format the column.
         # Ex. type_to_sql(:geography, limit: "Point,4326")
         # => "geography(Point,4326)"
-        # 
+        #
         def type_to_sql(type, limit: nil, precision: nil, scale: nil, array: nil, **) # :nodoc:
           sql = \
             case type.to_s

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

@@ -4,8 +4,11 @@ module ActiveRecord
       # 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)
-        :postgresql
+      def adapter_name_from(model)
+        name = model.connection_db_config.adapter.to_sym
+        return :postgresql if name == :cockroachdb
+
+        name
       end
     end
   end

data/lib/active_record/connection_adapters/cockroachdb_adapter.rb

@@ -23,6 +23,8 @@ require "active_record/connection_adapters/cockroachdb/arel_tosql"
 require_relative "../migration/cockroachdb/compatibility"
 require_relative "../../version"
 
+require_relative "../relation/query_methods_ext"
+
 # Run to ignore spatial tables that will break schemna dumper.
 # Defined in ./setup.rb
 ActiveRecord::ConnectionAdapters::CockroachDB.initial_setup

data/lib/active_record/relation/query_methods_ext.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class Relation
+    module QueryMethodsExt
+      def from!(...) # :nodoc:
+        @force_index = nil
+        @index_hint = nil
+        super
+      end
+
+      # Set table index hint for the query to the
+      # given `index_name`, and `direction` (either
+      # `ASC` or `DESC`).
+      #
+      # Any call to `ActiveRecord::QueryMethods#from`
+      # will reset the index hint. Index hints are
+      # not set if the `from` clause is not a table
+      # name.
+      #
+      # @see https://www.cockroachlabs.com/docs/v22.2/table-expressions#force-index-selection
+      def force_index(index_name, direction: nil)
+        spawn.force_index!(index_name, direction: direction)
+      end
+
+      def force_index!(index_name, direction: nil)
+        return self unless from_clause_is_a_table_name?
+
+        index_name = sanitize_sql(index_name.to_s)
+        direction = direction.to_s.upcase
+        direction = %w[ASC DESC].include?(direction) ? ",#{direction}" : ""
+
+        @force_index = "FORCE_INDEX=#{index_name}#{direction}"
+        self.from_clause = build_from_clause_with_hints
+        self
+      end
+
+      # Set table index hint for the query with the
+      # given `hint`. This allows more control over
+      # the hint than `ActiveRecord::Relation#force_index`.
+      # For instance, you could set it to `NO_FULL_SCAN`.
+      #
+      # Any call to `ActiveRecord::QueryMethods#from`
+      # will reset the index hint. Index hints are
+      # not set if the `from` clause is not a table
+      # name.
+      #
+      # @see https://www.cockroachlabs.com/docs/v22.2/table-expressions#force-index-selection
+      def index_hint(hint)
+        spawn.index_hint!(hint)
+      end
+
+      def index_hint!(hint)
+        return self unless from_clause_is_a_table_name?
+
+        hint = sanitize_sql(hint.to_s)
+        @index_hint = hint.to_s
+        self.from_clause = build_from_clause_with_hints
+        self
+      end
+
+      private
+
+      def from_clause_is_a_table_name?
+        # if empty, we are just dealing with the current table.
+        return true if from_clause.empty?
+        # `from_clause` can be a subquery.
+        return false unless from_clause.value.is_a?(String)
+        # `from_clause` can be a list of tables or a function.
+        # A simple way to check is to see if the string
+        # contains special characters. But we have to
+        # not check against an existing table hint.
+        return !from_clause.value.gsub(/\@{.*?\}/, "").match?(/[,\(]/)
+      end
+
+      def build_from_clause_with_hints
+        table_hints = [@index_hint, @force_index].compact.join(",")
+
+        table_name =
+          if from_clause.empty?
+            quoted_table_name
+          else
+            # Remove previous table hints if any. And spaces.
+            from_clause.value.partition("@").first.strip
+          end
+        Relation::FromClause.new("#{table_name}@{#{table_hints}}", nil)
+      end
+    end
+
+    QueryMethods.prepend(QueryMethodsExt)
+  end
+  # `ActiveRecord::Base` ancestors do not include `QueryMethods`.
+  # But the `#all` method returns a relation, which has `QueryMethods`
+  # 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)
+end

data/lib/activerecord-cockroachdb-adapter.rb

@@ -1,4 +1,4 @@
-if defined?(Rails)
+if defined?(Rails::Railtie)
   module ActiveRecord
     module ConnectionAdapters
       class CockroachDBRailtie < ::Rails::Railtie

data/lib/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-cockroachdb-adapter
 version: !ruby/object:Gem::Version
-  version: 7.0.2
+  version: 7.0.3
 platform: ruby
 authors:
 - Cockroach Labs
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-05-30 00:00:00.000000000 Z
+date: 2023-08-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -74,6 +74,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ci.yml"
 - ".github/workflows/docker.yml"
 - ".gitignore"
 - ".gitmodules"
@@ -87,6 +88,7 @@ files:
 - activerecord-cockroachdb-adapter.gemspec
 - bin/console
 - bin/setup
+- bin/start-cockroachdb
 - build/Dockerfile
 - build/config.teamcity.yml
 - build/local-test.sh
@@ -114,6 +116,7 @@ files:
 - lib/active_record/connection_adapters/cockroachdb/type.rb
 - lib/active_record/connection_adapters/cockroachdb_adapter.rb
 - lib/active_record/migration/cockroachdb/compatibility.rb
+- lib/active_record/relation/query_methods_ext.rb
 - lib/activerecord-cockroachdb-adapter.rb
 - lib/version.rb
 homepage: https://github.com/cockroachdb/activerecord-cockroachdb-adapter