activerecord-cockroachdb-adapter 0.2.3 → 5.2.2

data/Rakefile

@@ -1,10 +1,22 @@
 require "bundler/gem_tasks"
 require "rake/testtask"
+require_relative 'test/support/paths_cockroachdb'
+require_relative 'test/support/rake_helpers'
 
-Rake::TestTask.new(:test) do |t|
-  t.libs << "test"
-  t.libs << "lib"
-  t.test_files = FileList['test/**/*_test.rb']
+task test: ["test:cockroachdb"]
+task default: [:test]
+
+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
 end
 
-task :default => :test
+task 'test:cockroachdb' => 'test:cockroachdb:env'

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.2.3"
+  spec.version       = "5.2.2"
   spec.licenses      = ["Apache-2.0"]
   spec.authors       = ["Cockroach Labs"]
   spec.email         = ["cockroach-db@googlegroups.com"]
@@ -14,7 +14,8 @@ Gem::Specification.new do |spec|
   spec.homepage      = "https://github.com/cockroachdb/activerecord-cockroachdb-adapter"
 
   spec.add_dependency "activerecord", "~> 5.2"
-  spec.add_dependency "pg", ">= 0.20", "< 0.22"
+  spec.add_dependency "pg", ">= 0.20"
+  spec.add_dependency "rgeo-activerecord", "~> 7.0.0"
 
   # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
   # to allow pushing to a single host or delete this section to allow pushing to any host.
@@ -31,8 +32,4 @@ Gem::Specification.new do |spec|
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
-
-  spec.add_development_dependency "bundler", "~> 1.14"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "minitest", "~> 5.0"
 end

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/postgres-test:20170308-1644
+FROM cockroachdb/example-orms-builder:20200413-1918
 
 # Native dependencies for libxml-ruby and sqlite3.
 RUN apt-get update -y && apt-get install -y \

data/build/teamcity-test.sh

@@ -1,16 +1,15 @@
 #!/usr/bin/env bash
 
-set -euo pipefail
+set -euox pipefail
 
-# Download CockroachDB. NB: currently this uses an alpha, due to feature
-# requirements.
-VERSION=v2.0-alpha.20171218
+# Download CockroachDB
+VERSION=v20.2.3
 wget -qO- https://binaries.cockroachdb.com/cockroach-$VERSION.linux-amd64.tgz | tar  xvz
 readonly COCKROACH=./cockroach-$VERSION.linux-amd64/cockroach
 
 # Make sure cockroach can be found on the path. This is required for the
 # ActiveRecord Rakefile that rebuilds the test database.
-export PATH=$(pwd)/cockroach-$VERSION.linux-amd64/:$PATH
+export PATH=./cockroach-$VERSION.linux-amd64/:$PATH
 readonly urlfile=cockroach-url
 
 run_cockroach() {
@@ -22,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 --spatial-libs=./cockroach-$VERSION.linux-amd64/lib --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.
@@ -32,45 +31,26 @@ run_cockroach() {
     echo "server not yet available; sleeping for $backoff seconds"
     sleep $backoff
   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';"
 }
 
-# Target the Rails dependency file.
-export BUNDLE_GEMFILE=$(pwd)/rails/Gemfile
-
 # Install ruby dependencies.
+gem install bundler:2.1.4
 bundle install
 
-cp build/config.teamcity.yml rails/activerecord/test/config.yml
-
-# 'Install' our adapter. This involves symlinking it inside of
-# ActiveRecord. Normally the adapter will transitively install
-# ActiveRecord, but we need to execute tests from inside the Rails
-# context so we cannot rely on that. We also need previous links to make
-# tests idempotent.
-rm -f rails/activerecord/lib/active_record/connection_adapters/cockroachdb_adapter.rb
-ln -s $(pwd)/lib/active_record/connection_adapters/cockroachdb_adapter.rb rails/activerecord/lib/active_record/connection_adapters/cockroachdb_adapter.rb
-rm -rf rails/activerecord/lib/active_record/connection_adapters/cockroachdb
-ln -s $(pwd)/lib/active_record/connection_adapters/cockroachdb rails/activerecord/lib/active_record/connection_adapters/cockroachdb
+run_cockroach
 
-# Get the test files with "# FILE(OK)". These should pass.
-TESTS=$(cd rails/activerecord && find test/cases -type f \( -name "*_test.rb" \) -exec grep -l "# FILE(OK)" {} +)
-
-for TESTFILE in ${TESTS}; do
-  # Start CockroachDB
-  run_cockroach
-  # Run the tests.
-  echo "Rebuilding database"
-  (cd rails/activerecord && bundle exec rake db:cockroachdb:rebuild)
-  echo "Running test: $TESTFILE"
-  # Run the test. Continue testing even if this file fails.
-  if ! (cd rails/activerecord && bundle exec rake test:cockroachdb TESTFILES=$TESTFILE); then
-    echo "Test FAILED: $TESTFILE"
+if ! (RUBYOPT="-W0" TESTOPTS="-v" bundle exec rake test); then
+    echo "Tests failed"
     HAS_FAILED=1
-  else
-    echo "Test PASSED: $TESTFILE"
+else
+    echo "Tests passed"
     HAS_FAILED=0
-  fi
-done
+fi
 
 # Attempt a clean shutdown for good measure. We'll force-kill in the
 # exit trap if this script fails.

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/arel_tosql.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module RGeo
+  module ActiveRecord
+    ##
+    # Extend rgeo-activerecord visitors to use PostGIS specific functionality
+    module SpatialToPostGISSql
+      def visit_in_spatial_context(node, collector)
+        # Use ST_GeomFromEWKT for EWKT geometries
+        if node.is_a?(String) && node =~ /SRID=[\d+]{0,};/
+          collector << "#{st_func('ST_GeomFromEWKT')}(#{quote(node)})"
+        else
+          super(node, collector)
+        end
+      end
+    end
+  end
+end
+RGeo::ActiveRecord::SpatialToSql.prepend RGeo::ActiveRecord::SpatialToPostGISSql
+
+module Arel # :nodoc:
+  module Visitors # :nodoc:
+    class CockroachDB < PostgreSQL  # :nodoc:
+      include RGeo::ActiveRecord::SpatialToSql
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module ActiveRecord
+  module CockroachDB
+    module AttributeMethodsMonkeyPatch
+
+      private
+
+      # Filter out rowid so it doesn't get inserted by ActiveRecord. rowid is a
+      # column added by CockroachDB for tables that don't define primary keys.
+      # CockroachDB will automatically insert rowid values. See
+      # https://www.cockroachlabs.com/docs/v19.2/create-table.html#create-a-table.
+      def attributes_for_create(attribute_names)
+        super.reject { |name| name == ConnectionAdapters::CockroachDBAdapter::DEFAULT_PRIMARY_KEY }
+      end
+
+      # Filter out rowid so it doesn't get updated by ActiveRecord. rowid is a
+      # column added by CockroachDB for tables that don't define primary keys.
+      # CockroachDB will automatically insert rowid values. See
+      # https://www.cockroachlabs.com/docs/v19.2/create-table.html#create-a-table.
+      def attributes_for_update(attribute_names)
+        super.reject { |name| name == ConnectionAdapters::CockroachDBAdapter::DEFAULT_PRIMARY_KEY }
+      end
+    end
+  end
+
+  class Base
+    prepend CockroachDB::AttributeMethodsMonkeyPatch
+  end
+end

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

@@ -0,0 +1,94 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module CockroachDB
+      module PostgreSQLColumnMonkeyPatch
+        # 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, table_name = nil,
+                       default_function = nil, collation = nil, comment = nil, cast_type = nil, opts = nil)
+          @sql_type_metadata = sql_type_metadata
+          @geographic = !!(sql_type_metadata.sql_type =~ /geography\(/i)
+
+          @cast_type = cast_type
+          @geographic = !!(sql_type_metadata.sql_type =~ /geography\(/i)
+          if opts
+            # This case comes from an entry in the geometry_columns table
+            set_geometric_type_from_name(opts[:type])
+            @srid = opts[:srid].to_i
+            @has_z = !!opts[:has_z]
+            @has_m = !!opts[:has_m]
+          elsif @geographic
+            # Geographic type information is embedded in the SQL type
+            @srid = 4326
+            @has_z = @has_m = false
+            build_from_sql_type(sql_type_metadata.sql_type)
+          elsif sql_type =~ /geography|geometry|point|linestring|polygon/i
+            build_from_sql_type(sql_type_metadata.sql_type)
+          elsif sql_type_metadata.sql_type =~ /geography|geometry|point|linestring|polygon/i
+            # A geometry column with no geometry_columns entry.
+            # @geometric_type = geo_type_from_sql_type(sql_type)
+            build_from_sql_type(sql_type_metadata.sql_type)
+          end
+          super(name, default, sql_type_metadata, null, table_name, default_function, collation, comment: comment)
+          if spatial?
+            if @srid
+              @limit = { srid: @srid, type: to_type_name(geometric_type) }
+              @limit[:has_z] = true if @has_z
+              @limit[:has_m] = true if @has_m
+              @limit[:geographic] = true if @geographic
+            end
+          end
+        end
+
+        attr_reader :geographic,
+                    :geometric_type,
+                    :has_m,
+                    :has_z,
+                    :srid
+
+        alias geographic? geographic
+        alias has_z? has_z
+        alias has_m? has_m
+
+        def limit
+          spatial? ? @limit : super
+        end
+
+        def spatial?
+          %i[geometry geography].include?(@sql_type_metadata.type)
+        end
+
+        def serial?
+          default_function == 'unique_rowid()'
+        end
+
+        private
+
+        def set_geometric_type_from_name(name)
+          @geometric_type = RGeo::ActiveRecord.geometric_type_from_name(name) || RGeo::Feature::Geometry
+        end
+
+        def build_from_sql_type(sql_type)
+          geo_type, @srid, @has_z, @has_m = OID::Spatial.parse_sql_type(sql_type)
+          set_geometric_type_from_name(geo_type)
+        end
+
+        def to_type_name(geometric_type)
+          name = geometric_type.type_name.underscore
+          case name
+          when 'point'
+            'st_point'
+          when 'polygon'
+            'st_polygon'
+          else
+            name
+          end
+        end
+      end
+    end
+
+    class PostgreSQLColumn
+      prepend CockroachDB::PostgreSQLColumnMonkeyPatch
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module CockroachDB
+      module ColumnMethods
+        def spatial(name, options = {})
+          raise "You must set a type. For example: 't.spatial type: :st_point'" unless options[:type]
+
+          column(name, options[:type], **options)
+        end
+
+        def geography(name, options = {})
+          column(name, :geography, **options)
+        end
+
+        def geometry(name, options = {})
+          column(name, :geometry, **options)
+        end
+
+        def geometry_collection(name, options = {})
+          column(name, :geometry_collection, **options)
+        end
+
+        def line_string(name, options = {})
+          column(name, :line_string, **options)
+        end
+
+        def multi_line_string(name, options = {})
+          column(name, :multi_line_string, **options)
+        end
+
+        def multi_point(name, options = {})
+          column(name, :multi_point, **options)
+        end
+
+        def multi_polygon(name, options = {})
+          column(name, :multi_polygon, **options)
+        end
+
+        def st_point(name, options = {})
+          column(name, :st_point, **options)
+        end
+
+        def st_polygon(name, options = {})
+          column(name, :st_polygon, **options)
+        end
+      end
+    end
+
+    PostgreSQL::Table.include CockroachDB::ColumnMethods
+  end
+end

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

@@ -0,0 +1,102 @@
+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"
+          }
+        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
+end