activerecord-cockroachdb-adapter 6.0.0 → 6.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4d570f0cc045c61b9fb3fd82bfa64462f34aa086295dff104b559f52e4b6b5ef
-  data.tar.gz: 9995b9883f98e7eba7f429f977eadc8001d3d4e91aa6b7e3eb4d8976f9e78ff1
+  metadata.gz: e12a061e79d389fd1c698456bf368bb8a2971d3c8e1580242aadb669bfa30809
+  data.tar.gz: e12b269976f47ff593b3ece0f7848e56b76dda1d6a797dc826c483d301dc3082
 SHA512:
-  metadata.gz: 6c2ec381be5f87497c1dd10521956475ebe8ed57b013e89296d29afc1b30764ef18952cafa7127b02df0dba6c8eb97315819e42d658235f41bccf5c86fd2b46c
-  data.tar.gz: 675854788950b2182be1e44864f2a2b03ef768ace4346660f2075437de4ee90dc28717e48d7346d23cece34b9aabb8c493cfa6d93fce494c02b396ad19f3a002
+  metadata.gz: 52a6c9404a44dac790e2e7c61548d703d53f27c9654d492e9e58ba2b0f20cd7d93f9c92d26391038eccb590695b71c90d15872d44e299fd7a4e6e3f1185a2986
+  data.tar.gz: fff215842d13491523a7001273df0abec8a95b31294c71b6873f1c604e77f3b43d98beac514bca747ef8bd55aec9160e2ff47cfb7181eac1e230a8a9d16ec6a7

data/CHANGELOG.md

@@ -1,31 +1,24 @@
 # Changelog
 
-## 6.0.0 - 2021-04-26
+## 6.1.0 - 2021-04-26
 
 - Add a telemetry query on start-up. This helps the Cockroach Labs team
   prioritize support for the adapter. It can be disabled by setting the
   `disable_cockroachdb_telemetry` configuration option to false.
 
-## 6.0.0-beta.5 - 2021-04-02
+## 6.1.0-beta.3 - 2021-04-02
 
 - Added a configuration option named `use_follower_reads_for_type_introspection`.
   If true, it improves the speed of type introspection by allowing potentially stale
   type metadata to be read. Defaults to false.
 
-## 6.0.0-beta.4 - 2021-03-06
+## 6.1.0-beta.2 - 2021-03-06
 
 - Improved connection performance by refactoring an introspection
   that loads types.
 - Changed version numbers to semver.
 
-## 6.0.0beta3
+## 6.1.0beta1
 
-- Added support for spatial features.
-
-## 6.0.0beta2
-
-- Updated transaction retry logic to work with Rails 6.
-
-## 6.0.0beta1
-
-- Initial support for Rails 6.
+- Initial support for Rails 6.1.
+- Support for spatial functionality.

data/CONTRIBUTING.md

@@ -78,6 +78,26 @@ 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
+
+Loading the full test schema every time a test runs can take a while, so for cases where loading the schema sequentially is unimportant, it is possible to use a backup to set up the database. This is significantly faster than the standard method and is provided to run individual tests faster, but should not be used to validate a build.
+
+First create the template database.
+
+```bash
+bundle exec rake db:create_test_template
+```
+
+This will create a template database for the current version (ex. `activerecord_test_template611` for version 6.1.1) and create a `BACKUP` in the `nodelocal://self/activerecord-crdb-adapter/#{activerecord_version}` directory.
+
+To load from the template, use the `COCKROACH_LOAD_FROM_TEMPLATE` flag.
+
+```bash
+COCKROACH_LOAD_FROM_TEMPLATE=1 TEST_FILES="test/cases/adapters/postgresql/ddl_test.rb" bundle exec rake test
+```
+
+And the `activerecord_unittest` database will use the `RESTORE` command to load the schema from the template database.
+
 # Improvements
 
 

data/README.md

@@ -1,16 +1,18 @@
 # ActiveRecord CockroachDB Adapter
 
-CockroachDB adapter for ActiveRecord 4 and 5. This is a lightweight extension of the PostgreSQL adapter that establishes compatibility with [CockroachDB](https://github.com/cockroachdb/cockroach).
+CockroachDB adapter for ActiveRecord 5 and 6. This is a lightweight extension of the PostgreSQL adapter that establishes compatibility with [CockroachDB](https://github.com/cockroachdb/cockroach).
 
 ## Installation
 
 Add this line to your project's Gemfile:
 
 ```ruby
-gem 'activerecord-cockroachdb-adapter', '~> 5.2.0'
+gem 'activerecord-cockroachdb-adapter', '~> 6.1.0'
 ```
 
-If you're using Rails 4.x, use the `0.1.x` versions of this gem.
+If you're using Rails 5.2, use the `5.2.x` versions of this gem.
+
+If you're using Rails 6.0, use the `6.0.x` versions of this gem.
 
 In `database.yml`, use the following adapter setting:
 

data/Rakefile

@@ -2,10 +2,30 @@ require "bundler/gem_tasks"
 require "rake/testtask"
 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'
+
+    # TODO: look into this more, but for some reason the blob alias
+    # is not defined while running this task.
+    ActiveRecord::ConnectionAdapters::CockroachDB::TableDefinition.class_eval do
+      alias :blob :binary
+    end
+
+    TemplateCreator.create_test_template
+  end
+end
+
 namespace :test do
   Rake::TestTask.new("cockroachdb") do |t|
     t.libs = ARTest::CockroachDB.test_load_paths

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       = "6.0.0"
+  spec.version       = "6.1.1"
   spec.licenses      = ["Apache-2.0"]
   spec.authors       = ["Cockroach Labs"]
   spec.email         = ["cockroach-db@googlegroups.com"]
@@ -13,8 +13,8 @@ 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", "~> 6.0.3"
-  spec.add_dependency "pg", ">= 0.20"
+  spec.add_dependency "activerecord", "~> 6.1"
+  spec.add_dependency "pg", "~> 1.2"
   spec.add_dependency "rgeo-activerecord", "~> 7.0.0"
 
   # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'

data/lib/active_record/connection_adapters/cockroachdb/oid/interval.rb

@@ -0,0 +1,126 @@
+# frozen-string-literal: true
+
+require "active_support/duration"
+
+module ActiveRecord
+  module ConnectionAdapters
+    module CockroachDB
+      module OID
+        module Interval # :nodoc:
+          DEFAULT_PRECISION = 6 # microseconds
+
+          def cast_value(value)
+            case value
+            when ::ActiveSupport::Duration
+              value
+            when ::String
+              begin
+                PostgresqlInterval::Parser.parse(value)
+              rescue PostgresqlInterval::ParseError
+                # Try ISO 8601
+                super
+              end
+            else
+              super
+            end
+          end
+
+          def serialize(value)
+            precision = self.precision || DEFAULT_PRECISION
+            case value
+            when ::ActiveSupport::Duration
+              serialize_duration(value, precision)
+            when ::Numeric
+              serialize_duration(value.seconds, precision)
+            else
+              super
+            end
+          end
+
+          def type_cast_for_schema(value)
+            serialize(value).inspect
+          end
+
+          private
+
+            # Convert an ActiveSupport::Duration to
+            # the postgres interval style
+            # ex. 1 year 2 mons 3 days 4 hours 5 minutes 6 seconds
+            def serialize_duration(value, precision)
+              yrs = value.parts.fetch(:years, 0)
+              mons = value.parts.fetch(:months, 0)
+              days = value.parts.fetch(:days, 0)
+              hrs = value.parts.fetch(:hours, 0)
+              mins = value.parts.fetch(:minutes, 0)
+              secs = value.parts.fetch(:seconds, 0).round(precision)
+
+              "#{yrs} years #{mons} mons #{days} days #{hrs} hours #{mins} minutes #{secs} seconds"
+            end
+        end
+
+        PostgreSQL::OID::Interval.prepend(Interval)
+      end
+
+      module PostgresqlInterval
+        class Parser
+          PARTS = ActiveSupport::Duration::PARTS
+          PARTS_IN_SECONDS = ActiveSupport::Duration::PARTS_IN_SECONDS
+
+          # modified regex from https://github.com/jeremyevans/sequel/blob/master/lib/sequel/extensions/pg_interval.rb#L86
+          REGEX = /\A([+-]?\d+ years?\s?)?([+-]?\d+ mons?\s?)?([+-]?\d+ days?\s?)?(?:([+-])?(\d{2,10}):(\d\d):(\d\d(\.\d+)?))?\z/
+
+          def self.parse(string)
+            matches = REGEX.match(string)
+            raise(ParseError) unless matches
+
+            # 1 => years, 2 => months, 3 => days, 4 => nil, 5 => hours,
+            # 6 => minutes, 7 => seconds with fraction digits, 8 => fractional portion of 7
+            duration = 0
+            parts = {}
+
+            if matches[1]
+              val = matches[1].to_i
+              duration += val * PARTS_IN_SECONDS[:years]
+              parts[:years] = val
+            end
+
+            if matches[2]
+              val = matches[2].to_i
+              duration += val * PARTS_IN_SECONDS[:months]
+              parts[:months] = val
+            end
+
+            if matches[3]
+              val = matches[3].to_i
+              duration += val * PARTS_IN_SECONDS[:days]
+              parts[:days] = val
+            end
+
+            if matches[5]
+              val = matches[5].to_i
+              duration += val * PARTS_IN_SECONDS[:hours]
+              parts[:hours] = val
+            end
+
+            if matches[6]
+              val = matches[6].to_i
+              duration += val * PARTS_IN_SECONDS[:minutes]
+              parts[:minutes] = val
+            end
+
+            if matches[7]
+              val = matches[7].to_f
+              duration += val * PARTS_IN_SECONDS[:seconds]
+              parts[:seconds] = val
+            end
+
+            ActiveSupport::Duration.new(duration, parts)
+          end
+        end
+
+        class ParseError < StandardError
+        end
+      end
+    end
+  end
+end

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

@@ -4,7 +4,7 @@ module ActiveRecord
       module SchemaStatements
         include ActiveRecord::ConnectionAdapters::PostgreSQL::SchemaStatements
 
-        def add_index(table_name, column_name, options = {})
+        def add_index(table_name, column_name, **options)
           super
         rescue ActiveRecord::StatementInvalid => error
           if debugging? && error.cause.class == PG::FeatureNotSupported

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

@@ -9,7 +9,7 @@ module ActiveRecord
         # transactions will be retried until they pass or the max retry limit is
         # exceeded.
         def within_new_transaction(isolation: nil, joinable: true, attempts: 0)
-          super
+          super(isolation: isolation, joinable: joinable)
         rescue ActiveRecord::StatementInvalid => error
           raise unless retryable? error
           raise if attempts >= @connection.max_transaction_retries

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

@@ -1,12 +1,10 @@
 module ActiveRecord
   module Type
     class << self
-      private
-
       # Return :postgresql instead of :cockroachdb for current_adapter_name so
       # we can continue using the ActiveRecord::Types defined in
       # PostgreSQLAdapter.
-      def current_adapter_name
+      def adapter_name_from(_model)
         :postgresql
       end
     end

data/lib/active_record/connection_adapters/cockroachdb_adapter.rb

@@ -1,6 +1,6 @@
 require "rgeo/active_record"
 
-require 'active_record/connection_adapters/postgresql_adapter'
+require "active_record/connection_adapters/postgresql_adapter"
 require "active_record/connection_adapters/cockroachdb/column_methods"
 require "active_record/connection_adapters/cockroachdb/schema_statements"
 require "active_record/connection_adapters/cockroachdb/referential_integrity"
@@ -15,6 +15,7 @@ require "active_record/connection_adapters/cockroachdb/spatial_column_info"
 require "active_record/connection_adapters/cockroachdb/setup"
 require "active_record/connection_adapters/cockroachdb/oid/type_map_initializer"
 require "active_record/connection_adapters/cockroachdb/oid/spatial"
+require "active_record/connection_adapters/cockroachdb/oid/interval"
 require "active_record/connection_adapters/cockroachdb/arel_tosql"
 
 # Run to ignore spatial tables that will break schemna dumper.
@@ -25,25 +26,29 @@ module ActiveRecord
   module ConnectionHandling
     def cockroachdb_connection(config)
       # This is copied from the PostgreSQL adapter.
-      conn_params = config.symbolize_keys
-
-      conn_params.delete_if { |_, v| v.nil? }
+      conn_params = config.symbolize_keys.compact
 
       # Map ActiveRecords param names to PGs.
       conn_params[:user] = conn_params.delete(:username) if conn_params[:username]
       conn_params[:dbname] = conn_params.delete(:database) if conn_params[:database]
 
       # Forward only valid config params to PG::Connection.connect.
-      valid_conn_param_keys = PG::Connection.conndefaults_hash.keys + [:sslmode, :application_name]
+      valid_conn_param_keys = PG::Connection.conndefaults_hash.keys + [:requiressl]
       conn_params.slice!(*valid_conn_param_keys)
 
-      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")
+      ConnectionAdapters::CockroachDBAdapter.new(
+        ConnectionAdapters::CockroachDBAdapter.new_client(conn_params),
+        logger,
+        conn_params,
+        config
+      )
+    # This rescue flow appears in new_client, but it is needed here as well
+    # since Cockroach will sometimes not raise until a query is made.
+    rescue ActiveRecord::StatementInvalid => error
+      if conn_params && conn_params[:dbname] && error.cause.message.include?(conn_params[:dbname])
         raise ActiveRecord::NoDatabaseError
       else
-        raise
+        raise ActiveRecord::ConnectionNotEstablished, error.message
       end
     end
   end
@@ -52,24 +57,29 @@ end
 module ActiveRecord
   module ConnectionAdapters
     module CockroachDBConnectionPool
-      def initialize(spec)
-        super(spec)
-        disable_telemetry = spec.config[:disable_cockroachdb_telemetry]
-        adapter = spec.config[:adapter]
+      def initialize(pool_config)
+        super(pool_config)
+        disable_telemetry = pool_config.db_config.configuration_hash[:disable_cockroachdb_telemetry]
+        adapter = pool_config.db_config.configuration_hash[:adapter]
         return if disable_telemetry || adapter != "cockroachdb"
 
-        with_connection do |conn|
-          if conn.active?
-            begin
-              query = "SELECT crdb_internal.increment_feature_counter('ActiveRecord %d.%d')"
-              conn.execute(query % [ActiveRecord::VERSION::MAJOR, ActiveRecord::VERSION::MINOR])
-            rescue ActiveRecord::StatementInvalid
-              # The increment_feature_counter built-in is not supported on this
-              # CockroachDB version. Ignore.
-            rescue StandardError => e
-              conn.logger.warn "Unexpected error when incrementing feature counter: #{e}"
+
+        begin
+          with_connection do |conn|
+            if conn.active?
+              begin
+                query = "SELECT crdb_internal.increment_feature_counter('ActiveRecord %d.%d')"
+                conn.execute(query % [ActiveRecord::VERSION::MAJOR, ActiveRecord::VERSION::MINOR])
+              rescue ActiveRecord::StatementInvalid
+                # The increment_feature_counter built-in is not supported on this
+                # CockroachDB version. Ignore.
+              rescue StandardError => e
+                conn.logger.warn "Unexpected error when incrementing feature counter: #{e}"
+              end
             end
           end
+        rescue ActiveRecord::NoDatabaseError
+          # Prevent failures on db creation and parallel testing.
         end
       end
     end
@@ -93,7 +103,7 @@ module ActiveRecord
           st_polygon:          {},
         }
 
-      # http://postgis.17.x6.nabble.com/Default-SRID-td5001115.html      
+      # http://postgis.17.x6.nabble.com/Default-SRID-td5001115.html
       DEFAULT_SRID = 0
 
       include CockroachDB::SchemaStatements
@@ -101,56 +111,6 @@ module ActiveRecord
       include CockroachDB::DatabaseStatements
       include CockroachDB::Quoting
 
-      # override
-      # This method makes a sql query to gather information about columns
-      # in a table. It returns an array of arrays (one for each col) and
-      # passes each to the SchemaStatements#new_column_from_field method
-      # as the field parameter. This data is then used to format the column
-      # objects for the model and sent to the OID for data casting.
-      #
-      # The issue with the default method is that the sql_type field is 
-      # retrieved with the `format_type` function, but this is implemented
-      # differently in CockroachDB than PostGIS, so geometry/geography
-      # types are missing information which makes parsing them impossible.
-      # Below is an example of what `format_type` returns for a geometry
-      # column.
-      #
-      # column_type: geometry(POINT, 4326)
-      # Expected: geometry(POINT, 4326)
-      # Actual: geometry
-      #
-      # The solution is to make the default query with super, then
-      # iterate through the columns and if it is a spatial type,
-      # access the proper column_type with the information_schema.columns 
-      # table.
-      #
-      # @see: https://github.com/rails/rails/blob/8695b028261bdd244e254993255c6641bdbc17a5/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb#L829
-      def column_definitions(table_name)
-        fields = super
-        # iterate through and identify all spatial fields based on format_type
-        # being geometry or geography, then query for the information_schema.column
-        # column_type because that contains the necessary information.
-        fields.map do |field|
-          dtype = field[1]
-          if dtype == 'geometry' || dtype == 'geography'
-            col_name = field[0]
-            data_type = \
-            query(<<~SQL, "SCHEMA")
-              SELECT c.data_type
-                FROM information_schema.columns c
-              WHERE c.table_name = #{quote(table_name)}
-                AND c.column_name = #{quote(col_name)}
-            SQL
-            field[1] = data_type[0][0]
-          end
-          field
-        end
-      end
-
-      def arel_visitor
-        Arel::Visitors::CockroachDB.new(self)
-      end
-
       def self.spatial_column_options(key)
         SPATIAL_COLUMN_OPTIONS[key]
       end
@@ -306,19 +266,28 @@ module ActiveRecord
             end
           end
 
-          # NOTE(joey): PostgreSQL intervals have a precision.
-          # CockroachDB intervals do not, so overide the type
-          # definition. Returning a ArgumentError may not be correct.
-          # This needs to be tested.
-          m.register_type "interval" do |_, _, sql_type|
+          # Belongs after other types are defined because of issues described
+          # in this https://github.com/rails/rails/pull/38571
+          # Once that PR is merged, we can call super at the top.
+          super(m)
+
+          # Override numeric type. This is almost identical to the default,
+          # except that the conditional based on the fmod is changed.
+          m.register_type "numeric" do |_, fmod, sql_type|
             precision = extract_precision(sql_type)
-            if precision
-              raise(ArgumentError, "CockroachDB does not support precision on intervals, but got precision: #{precision}")
+            scale = extract_scale(sql_type)
+
+            # If fmod is -1, that means that precision is defined but not
+            # scale, or neither is defined.
+            if fmod && fmod == -1 && !precision.nil?
+              # Below comment is from ActiveRecord
+              # FIXME: Remove this class, and the second argument to
+              # lookups on PG
+              Type::DecimalWithoutScale.new(precision: precision)
+            else
+              OID::Decimal.new(precision: precision, scale: scale)
             end
-            OID::SpecializedString.new(:interval, precision: precision)
           end
-
-          super(m)
         end
 
         # Configures the encoding, verbosity, schema search path, and time zone of the connection.
@@ -423,11 +392,85 @@ module ActiveRecord
         # 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 supports_string_to_array_coercion?
           return unless default =~ /\AARRAY\[\]\z/
           return "{}"
         end
 
+        # override
+        # This method makes a query to gather information about columns
+        # in a table. It returns an array of arrays (one for each col) and
+        # passes each to the SchemaStatements#new_column_from_field method
+        # as the field parameter. This data is then used to format the column
+        # objects for the model and sent to the OID for data casting.
+        #
+        # Sometimes there are differences between how data is formatted
+        # in Postgres and CockroachDB, so additional queries for certain types
+        # may be necessary to properly form the column definition.
+        #
+        # @see: https://github.com/rails/rails/blob/8695b028261bdd244e254993255c6641bdbc17a5/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb#L829
+        def column_definitions(table_name)
+          fields = super
+
+          # 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)
+          fields.map do |field|
+            dtype = field[1]
+            if re.match(dtype)
+              crdb_column_definition(field, table_name)
+            else
+              field
+            end
+          end
+        end
+
+        # Use the crdb_sql_type instead of the sql_type returned by
+        # column_definitions. This will include limit,
+        # precision, and scale information in the type.
+        # Ex. geometry -> geometry(point, 4326)
+        def crdb_column_definition(field, table_name)
+          col_name = field[0]
+          data_type = \
+          query(<<~SQL, "SCHEMA")
+            SELECT c.crdb_sql_type
+              FROM information_schema.columns c
+            WHERE c.table_name = #{quote(table_name)}
+              AND c.column_name = #{quote(col_name)}
+          SQL
+          field[1] = data_type[0][0].downcase
+          field
+        end
+
+        # override
+        # This method is used to determine if a
+        # FEATURE_NOT_SUPPORTED error from the PG gem should
+        # be an ActiveRecord::PreparedStatementCacheExpired
+        # error.
+        #
+        # ActiveRecord handles this by checking that the sql state matches the
+        # FEATURE_NOT_SUPPORTED code and that the source function
+        # is "RevalidateCachedQuery" since that is the only function
+        # in postgres that will create this error.
+        #
+        # That method will not work for CockroachDB because the error
+        # originates from the "runExecBuilder" function, so we need
+        # to modify the original to match the CockroachDB behavior.
+        def is_cached_plan_failure?(e)
+          pgerror = e.cause
+
+          pgerror.result.result_error_field(PG::PG_DIAG_SQLSTATE) == FEATURE_NOT_SUPPORTED &&
+            pgerror.result.result_error_field(PG::PG_DIAG_SOURCE_FUNCTION) == "runExecBuilder"
+        rescue
+          false
+        end
+
         # override
         # This method loads info about data types from the database to
         # populate the TypeMap.
@@ -505,6 +548,7 @@ module ActiveRecord
             @type_map_for_results = PG::TypeMapByOid.new
             @type_map_for_results.default_type_map = map
             @type_map_for_results.add_coder(PG::TextDecoder::Bytea.new(oid: 17, name: "bytea"))
+            @type_map_for_results.add_coder(MoneyDecoder.new(oid: 790, name: "money"))
 
             # extract timestamp decoder for use in update_typemap_for_default_timezone
             @timestamp_decoder = coders.find { |coder| coder.name == "timestamp" }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-cockroachdb-adapter
 version: !ruby/object:Gem::Version
-  version: 6.0.0
+  version: 6.1.1
 platform: ruby
 authors:
 - Cockroach Labs
-autorequire:
+autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-04-28 00:00:00.000000000 Z
+date: 2021-05-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 6.0.3
+        version: '6.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 6.0.3
+        version: '6.1'
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.20'
+        version: '1.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.20'
+        version: '1.2'
 - !ruby/object:Gem::Dependency
   name: rgeo-activerecord
   requirement: !ruby/object:Gem::Requirement
@@ -82,6 +82,7 @@ files:
 - lib/active_record/connection_adapters/cockroachdb/column_methods.rb
 - lib/active_record/connection_adapters/cockroachdb/database_statements.rb
 - lib/active_record/connection_adapters/cockroachdb/database_tasks.rb
+- lib/active_record/connection_adapters/cockroachdb/oid/interval.rb
 - lib/active_record/connection_adapters/cockroachdb/oid/spatial.rb
 - lib/active_record/connection_adapters/cockroachdb/oid/type_map_initializer.rb
 - lib/active_record/connection_adapters/cockroachdb/quoting.rb
@@ -99,7 +100,7 @@ licenses:
 - Apache-2.0
 metadata:
   allowed_push_host: https://rubygems.org
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -114,8 +115,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
-signing_key:
+rubygems_version: 3.0.3
+signing_key: 
 specification_version: 4
 summary: CockroachDB adapter for ActiveRecord.
 test_files: []