activerecord-cockroachdb-adapter 0.3.0.beta1 → 6.0.0beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 48ca5207eae1d4bf1c26da960ad80e78f54099b1eb62466e89ff5186c9d41632
-  data.tar.gz: d3d8a5c38a3adda552b283663d4aaf88e05587b3ac9e0da28418fa05d72cfcdd
+  metadata.gz: f2d3e8ca47a966406dd46a2516ee8e28d4634109974b012604efa5eeef41661c
+  data.tar.gz: 78f2720ce377db8b5d61c830c2f8819f4a928bceee3121668348293944b459ac
 SHA512:
-  metadata.gz: 955dca7f67f68b93fd2ebd19cd6027de446598c823abbc108ce5630fbf6d566c14c09e283f37e3d04fb306ff72a68e55f6856daea91a61f9488636f9da957920
-  data.tar.gz: 9cb056da8d37cd199427f2ae25d354bcb3fb606fde92e1c01fb2cef7eedd2122a9eccbf0b3693d7d0c7197f8ff8d7d4b1321d16d9212db4331673ddf5669b934
+  metadata.gz: 7928d308947df985eac1ecf4ac2338d8ed5e079c2436562a822b149699b0bc42e38411e90a73a5623c376613ca610060d68f9040d823b9fa65d2869baa98a6fd
+  data.tar.gz: 5421bb06b3185d331a0a43e700e2475f6ce28ee38d433ba28e3e82c4a0e361a94518dd46fd41b54d1a83f1a217d19e098eef0a251ad7e79803263c08bfd7e3dc

data/.gitignore

@@ -7,3 +7,4 @@
 /pkg/
 /spec/reports/
 /tmp/
+*.gem

data/CONTRIBUTING.md

@@ -46,19 +46,31 @@ Using [bundler](http://bundler.io/), install the dependancies of Rails.
 bundle install
 ```
 
-Then, to run the full ActiveRecord test suite with an active CockroachDB instance:
+Then, to run the full test suite with an active CockroachDB instance:
 
 ```bash
 bundle exec rake test
 ```
 
-To run specific tests, set environemnt variable `TEST_FILES_AR`. For example, to run ActiveRecord tests `test/cases/associations_test.rb` and `test/cases/ar_schema_test.rb.rb`
+To run specific ActiveRecord tests, set environemnt variable `TEST_FILES_AR`. For example, to run ActiveRecord tests `test/cases/associations_test.rb` and `test/cases/ar_schema_test.rb.rb`
 
 ```bash
 TEST_FILES_AR="test/cases/associations_test.rb,test/cases/ar_schema_test.rb" 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`.
+To run specific CockroachDB Adapter tests, set environemnt variable `TEST_FILES`. For example, to run CockroachDB Adpater tests `test/cases/adapter_test.rb` and `test/cases/associations/left_outer_join_association_test.rb`
+
+```bash
+TEST_FILES="test/cases/adapter_test.rb,test/cases/associations/left_outer_join_association_test.rb" bundle exec rake test
+```
+
+To run a specific test case, use minitest's `-n` option to run tests that match a given pattern. All minitest options are set via the `TESTOPTS` environemnt variable. For example, to run `test_indexes` from CockroachDB's `test/cases/adapter_test.rb` file
+
+```bash
+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

data/README.md

@@ -7,7 +7,7 @@ CockroachDB adapter for ActiveRecord 4 and 5. This is a lightweight extension of
 Add this line to your project's Gemfile:
 
 ```ruby
-gem 'activerecord-cockroachdb-adapter', '~> 0.2'
+gem 'activerecord-cockroachdb-adapter', '~> 5.2.0'
 ```
 
 If you're using Rails 4.x, use the `0.1.x` versions of this gem.

data/activerecord-cockroachdb-adapter.gemspec

@@ -4,7 +4,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name          = "activerecord-cockroachdb-adapter"
-  spec.version       = "0.3.0.beta1"
+  spec.version       = "6.0.0beta2"
   spec.licenses      = ["Apache-2.0"]
   spec.authors       = ["Cockroach Labs"]
   spec.email         = ["cockroach-db@googlegroups.com"]
@@ -13,7 +13,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", "~> 5.2"
+  spec.add_dependency "activerecord", "~> 6.0.3"
   spec.add_dependency "pg", ">= 0.20"
 
   # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'

data/build/teamcity-test.sh

@@ -1,9 +1,9 @@
 #!/usr/bin/env bash
 
-set -euo pipefail
+set -euox pipefail
 
 # Download CockroachDB
-VERSION=v20.1.0-rc.1
+VERSION=v20.2.3
 wget -qO- https://binaries.cockroachdb.com/cockroach-$VERSION.linux-amd64.tgz | tar  xvz
 readonly COCKROACH=./cockroach-$VERSION.linux-amd64/cockroach
 
@@ -21,7 +21,7 @@ run_cockroach() {
   cockroach quit --insecure || true
   rm -rf cockroach-data
   # Start CockroachDB.
-  cockroach start --insecure --host=localhost --listening-url-file="$urlfile" >/dev/null 2>&1 &
+  cockroach start-single-node --max-sql-memory=25% --cache=25% --insecure --host=localhost --listening-url-file="$urlfile" >/dev/null 2>&1 &
   # Ensure CockroachDB is stopped on script exit.
   trap "echo 'Exit routine: Killing CockroachDB.' && kill -9 $! &> /dev/null" EXIT
   # Wait until CockroachDB has started.
@@ -33,6 +33,9 @@ run_cockroach() {
   done
   cockroach sql --insecure -e 'CREATE DATABASE activerecord_unittest;'
   cockroach sql --insecure -e 'CREATE DATABASE activerecord_unittest2;'
+  cockroach sql --insecure -e 'SET CLUSTER SETTING sql.stats.automatic_collection.enabled = false;'
+  cockroach sql --insecure -e 'SET CLUSTER SETTING sql.stats.histogram_collection.enabled = false;'
+  cockroach sql --insecure -e "SET CLUSTER SETTING jobs.retention_time = '180s';"
 }
 
 # Install ruby dependencies.
@@ -41,7 +44,7 @@ bundle install
 
 run_cockroach
 
-if ! (bundle exec rake test); then
+if ! (RUBYOPT="-W0" TESTOPTS="-v" bundle exec rake test); then
     echo "Tests failed"
     HAS_FAILED=1
 else

data/docker.sh

@@ -2,7 +2,7 @@
 #
 # This file is largely cargo-culted from cockroachdb/cockroach/build/builder.sh.
 
-set -euo pipefail
+set -euox pipefail
 
 DOCKER_IMAGE_TAG=activerecord_test_container
 

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

@@ -15,6 +15,87 @@ module ActiveRecord
             serializable:     "SERIALIZABLE"
           }
         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)
+          table_deletes = tables_to_delete.map { |table| "DELETE FROM #{quote_table_name(table)}" }
+          statements = table_deletes + fixture_inserts
+
+          with_multi_statements do
+            disable_referential_integrity do
+              execute_batch(statements, "Fixtures Load")
+            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/schema_statements.rb

@@ -38,6 +38,54 @@ module ActiveRecord
         def default_sequence_name(table_name, pk = "id")
           nil
         end
+
+        # CockroachDB will use INT8 if the SQL type is INTEGER, so we make it use
+        # INT4 explicitly when needed.
+        def type_to_sql(type, limit: nil, precision: nil, scale: nil, array: nil, **) # :nodoc:
+          sql = \
+            case type.to_s
+            when "integer"
+              case limit
+              when nil; "int"
+              when 1, 2; "int2"
+              when 3, 4; "int4"
+              when 5..8; "int8"
+              else super
+              end
+            else
+              super
+            end
+          # The call to super might have appeneded [] already.
+          if array && type != :primary_key && !sql.end_with?("[]")
+            sql = "#{sql}[]"
+          end
+          sql
+        end
+
+        # This overrides the method from PostegreSQL adapter
+        # Resets the sequence of a table's primary key to the maximum value.
+        def reset_pk_sequence!(table, pk = nil, sequence = nil)
+          unless pk && sequence
+            default_pk, default_sequence = pk_and_sequence_for(table)
+
+            pk ||= default_pk
+            sequence ||= default_sequence
+          end
+
+          if @logger && pk && !sequence
+            @logger.warn "#{table} has primary key #{pk} with no default sequence."
+          end
+
+          if pk && sequence
+            quoted_sequence = quote_table_name(sequence)
+            max_pk = query_value("SELECT MAX(#{quote_column_name pk}) FROM #{quote_table_name(table)}", "SCHEMA")
+            if max_pk.nil?
+              minvalue = query_value("SELECT seqmin FROM pg_sequence WHERE seqrelid = #{quote(quoted_sequence)}::regclass", "SCHEMA")
+            end
+
+            query_value("SELECT setval(#{quote(quoted_sequence)}, #{max_pk ? max_pk : minvalue}, #{max_pk ? true : false})", "SCHEMA")
+          end
+        end
       end
     end
   end

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

@@ -8,16 +8,22 @@ module ActiveRecord
         # transactions that fail due to serialization errors. Failed
         # transactions will be retried until they pass or the max retry limit is
         # exceeded.
-        def within_new_transaction(options = {})
-          attempts = options.fetch(:attempts, 0)
+        def within_new_transaction(isolation: nil, joinable: true, attempts: 0)
           super
-        rescue ActiveRecord::SerializationFailure => error
+        rescue ActiveRecord::StatementInvalid => error
+          raise unless retryable? error
           raise if attempts >= @connection.max_transaction_retries
 
           attempts += 1
           sleep_seconds = (2 ** attempts + rand) / 10
           sleep(sleep_seconds)
-          within_new_transaction(options.merge(attempts: attempts)) { yield }
+          within_new_transaction(isolation: isolation, joinable: joinable, attempts: attempts) { yield }
+        end
+
+        def retryable?(error)
+          return true if error.is_a? ActiveRecord::SerializationFailure
+          return retryable? error.cause if error.cause
+          false
         end
       end
     end

data/lib/active_record/connection_adapters/cockroachdb_adapter.rb

@@ -24,10 +24,14 @@ module ActiveRecord
       valid_conn_param_keys = PG::Connection.conndefaults_hash.keys + [:sslmode, :application_name]
       conn_params.slice!(*valid_conn_param_keys)
 
-      # The postgres drivers don't allow the creation of an unconnected
-      # PG::Connection object, so just pass a nil connection object for the
-      # time being.
-      ConnectionAdapters::CockroachDBAdapter.new(nil, logger, conn_params, config)
+      conn = PG.connect(conn_params)
+      ConnectionAdapters::CockroachDBAdapter.new(conn, logger, conn_params, config)
+    rescue ::PG::Error, ActiveRecord::ActiveRecordError  => error
+      if error.message.include?("does not exist")
+        raise ActiveRecord::NoDatabaseError
+      else
+        raise
+      end
     end
   end
 end
@@ -56,6 +60,10 @@ module ActiveRecord
         100000
       end
 
+      def supports_bulk_alter?
+        false
+      end
+
       def supports_json?
         # FIXME(joey): Add a version check.
         true
@@ -69,18 +77,12 @@ module ActiveRecord
         false
       end
 
-      def supports_ranges?
-        # See cockroachdb/cockroach#17022
-        false
-      end
-
       def supports_materialized_views?
         false
       end
 
       def supports_partial_index?
-        # See cockroachdb/cockroach#9683
-        false
+        @crdb_version >= 202
       end
 
       def supports_expression_index?
@@ -103,8 +105,7 @@ module ActiveRecord
       end
 
       def supports_advisory_locks?
-        # FIXME(joey): We may want to make this false.
-        true
+        false
       end
 
       def supports_virtual_columns?
@@ -112,6 +113,10 @@ module ActiveRecord
         false
       end
 
+      def supports_string_to_array_coercion?
+        @crdb_version >= 202
+      end
+
       # This is hardcoded to 63 (as previously was in ActiveRecord 5.0) to aid in
       # migration from PostgreSQL to CockroachDB. In practice, this limitation
       # is arbitrary since CockroachDB supports index name lengths and table alias
@@ -127,6 +132,31 @@ 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_string = query_value("SHOW crdb_version")
+        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 = 191
+        elsif crdb_version_string.include? "v19.2."
+          version_num = 192
+        elsif crdb_version_string.include? "v20.1."
+          version_num = 201
+        else
+          version_num = 202
+        end
+        @crdb_version = version_num
+      end
+
+      def self.database_exists?(config)
+        !!ActiveRecord::Base.cockroachdb_connection(config)
+      rescue ActiveRecord::NoDatabaseError
+        false
+      end
+
       private
 
         def initialize_type_map(m = type_map)
@@ -199,7 +229,8 @@ module ActiveRecord
         def extract_value_from_default(default)
           super ||
             extract_escaped_string_from_default(default) ||
-            extract_time_from_default(default)
+            extract_time_from_default(default) ||
+            extract_empty_array_from_default(default)
         end
 
         # Both PostgreSQL and CockroachDB use C-style string escapes under the
@@ -241,6 +272,15 @@ module ActiveRecord
           nil
         end
 
+        # CockroachDB stores default values for arrays in the `ARRAY[...]` format.
+        # In general, it is hard to parse that, but it is easy to handle the common
+        # case of an empty array.
+        def extract_empty_array_from_default(default)
+          return unless supports_string_to_array_coercion? 
+          return unless default =~ /\AARRAY\[\]\z/
+          return "{}"
+        end
+
       # end private
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-cockroachdb-adapter
 version: !ruby/object:Gem::Version
-  version: 0.3.0.beta1
+  version: 6.0.0beta2
 platform: ruby
 authors:
 - Cockroach Labs
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-04-17 00:00:00.000000000 Z
+date: 2020-12-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.2'
+        version: 6.0.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.2'
+        version: 6.0.3
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
@@ -77,7 +77,7 @@ licenses:
 - Apache-2.0
 metadata:
   allowed_push_host: https://rubygems.org
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -92,8 +92,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubygems_version: 3.1.2
-signing_key: 
+rubygems_version: 3.1.4
+signing_key:
 specification_version: 4
 summary: CockroachDB adapter for ActiveRecord.
 test_files: []