activerecord-cockroachdb-adapter 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c39398a79fef87dc0b0cde4cf0558ca1820005a5
-  data.tar.gz: e18cf876bd4be4886a9429b55c5a82704c80d957
+  metadata.gz: 96a284c08e5798cc8b45332be543b14f60bdb8c0
+  data.tar.gz: ffa757e8b581788ba8d1880842d37eca7058695e
 SHA512:
-  metadata.gz: 60bcfd758fad44e6f3922896301f2c750d53b310879d525b8f70274838a1639a722614a2b9ad5e6f2db2e9e429b0c2b1f80adfd9d3c69473e00b4c6b8dad481c
-  data.tar.gz: 3ef108048920f4708465cebda053a2681420bf77da6b0a7ab036ff6a3f1c42060620d6c53bb21a4df9384e6b4f0ee2f0b0a14fadfef57e884c25bc1fb86d21b9
+  metadata.gz: 456d42bc6a8a973488a6c66a9631d8e78f7e4a35abb379b3958239b6fb474bce9a3503678be6a098d788bb09425c02d30732fb1ee546b3d4c2b8cb21b3a7fe57
+  data.tar.gz: 40ada5999c613d6d2f953ce7fc99b9fbb3793685d258fe9cef790e2421df96d218ee3684081a499571ed38cc129be6e65de6a87328d57297fdd62323430c61c6

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "rails"]
+	path = rails
+	url = https://github.com/lego/ruby-on-rails.git

data/CONTRIBUTING.md

@@ -0,0 +1,248 @@
+# Getting started
+
+
+## ActiveRecord adapters and you
+
+There are two repositories for the ActiveRecord adapter. The one you're in
+currently, [activerecord-cockroachdb-adapter], is the CockroachDB specific
+ActiveRecord code. Users install this alongside ActiveRecord then use
+CockroachDBAdapter to initialize ActiveRecord for their projects.
+
+This adapter extends the PostgreSQL ActiveRecord adapter in order to
+override and monkey-patch functionality.
+
+The other repository is a fork of [Rails]. The tests have been modified
+for the purposes of testing our CockroachDB adapter.
+
+[activerecord-cockroachdb-adapter]: https://github.com/cockroachdb/activerecord-cockroachdb-adapter/
+[Rails]: https://github.com/lego/ruby-on-rails
+
+
+## Setup and running tests
+
+It is best to have a Ruby environment manager installed, such as
+[rvm](https://rvm.io/), as Rails has varying Ruby version requirements.
+If you are using rvm, you then install and use the required Ruby
+version.  The current tests use Rails 5.2.0 beta and Ruby >= 2.2.2.
+
+(Alternatively, one can use `./docker.sh build/teamcity-test.sh` to run
+tests similarily to TeamCity. The database is destroyed between each
+test file.)
+
+
+```bash
+rvm install 2.2.5
+# This only makes Ruby 2.2.5 active for the length of the terminal session.
+rvm use 2.2.5
+```
+
+Using [bundler](http://bundler.io/), install the dependancies of Rails.
+Additionally, make sure the Rails git submodule is loaded.
+
+```bash
+# Ensure the rails fork is fetched.
+git submodule update
+# Install rails dependancies.
+(cd rails && bundle install)
+```
+
+Then, to run the test with an active CockroachDB instance:
+
+```bash
+cp build/config.teamcity.yml rails/activerecord/test/config.yml
+(cd rails/activerecord && BUNDLE_GEMFILE=../Gemfile bundle exec rake db:cockroachdb:rebuild)
+(cd rails/activerecord && BUNDLE_GEMFILE=../Gemfile bundle exec rake test:cockroachdb)
+```
+
+### Test commands in detail
+
+```bash
+cp build/config.teamcity.yml rails/activerecord/test/config.yml
+```
+
+This copies the TeamCity ActiveRecord configuration for the application.
+This configuration specifies:
+
+- CockroachDB port and host the test suite uses.
+- Database names used for the different test connections. (ActiveRecord
+  uses two separate connections for some tests.)
+
+```
+(cd rails/activerecord && BUNDLE_GEMFILE=../Gemfile bundle exec rake db:cockroachdb:rebuild)
+```
+
+This prepares CockroachDB for running tests. It only drops and
+re-creates all of the databases needed.
+
+- This command needs to be run from activerecord folder in order to use
+  the ActiveRecord `Rakefile`. The `Rakefile` defines scripts (called
+  tasks) such as executing tests.
+- `BUNDLE_GEMFILE=../Gemfile` tells `bundle` to use the dependancies for
+  Rails that were previously installed.
+- `bundle exec rake` uses `bundle` to execute the Ruby package `rake`.
+- `rake db:cockroachdb:rebuild` runs the specified Rake task. All tasks
+  can be found in `rails/activerecord/Rakefile`.
+
+
+```
+(cd rails/activerecord && BUNDLE_GEMFILE=../Gemfile bundle exec rake test:cockroachdb)
+```
+
+This executes the CockroachDB tests.
+
+- Like the previous command, this one uses the Activerecord Rakefile and
+  the Rails Gemfile. The task code can be found in the Rakefile.
+- Running specific test files can be done by appending
+  `TESTFILES=test/cases/attribute_methods.rb` to the command. Globs are
+  used. Multiple individual files cannot be specified.
+
+
+# Improvements
+
+
+## Support past Rails versions
+
+Currently, only a beta version of Rails is tested. This means that the
+adapter has been modified in to accomodate 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
+master branch, with an alpha build of CockroachDB. it would be even
+better to be able to test multiple versions of the adapter, and do so
+against different versions of CockroachDB.
+
+
+## Adding feature support
+
+As CockroachDB improves, so do the features that can be supported in
+ActiveRecord. Many of them are gated by conditions the
+CockroachDBAdapter has overrided. As these features are completed, these
+gates should be toggled. Something that would help this process would be
+linking those issues back to this adapter so that part of the feature
+completing includes updating the adapter.
+
+
+## Execute only tests that run with a connection
+
+I have not investigated if this is already possible, but I would assume
+no.
+
+A possible way to approach this would be to add a shim to cause any
+tests that use it to fail, and grep the tests that pass and then skip
+them.
+
+# Cleanup
+
+One of the earlier commits to the Rails repo did a big grep of
+`PostgreSQLAdapter` -> `CockroachDBAdapter`. In order to better support
+changes upstream, this modification should be changed to instead only
+add `CockroachDBAdapter` alongside any `PostgreSQLAdapter`. The later
+test cleanup commit will conflict on any further changes (like adding
+back PostgreSQL, or removing CockroachDB for PostgreSQL).
+
+## Publishing to Rubygems
+
+TODO: Expand on this. Jordan is likely the only person with publishing
+credentials. I'm not sure if there is anything else other than:
+
+```
+gem build ...
+gem publish <output file>
+```
+
+
+# Notes
+
+When executing the test suite, each test file will reload fixtures. This
+drops and creates about 200 tables (2 databases, 100 tables each).
+Currently there are performance problems that rise from having lots of
+table descriptors around, [cockroachdb/cockroach#20753]. At best, we can
+run test files individually, clear out the CockroachDB data, and restart
+the node to alleviate this.
+
+Currently, annotations have been added to test files to indicate if it
+is failing, and some brief details on why. Any annotated failures have
+been skipped right now for further investigation. The pattern is the
+following:
+
+`# FILE(OK)` indicates that the file is currently passing, with no skips
+required.
+
+`# FILE(BAD)` indicates that there are failures that have been skipped.
+These skips will look like `skip(reason) if current_adapter?(:CockroachDBAdapter)`.
+
+`# FILE(BROKEN)` indicates that there are failures that have not been
+skipped. This is often done if the entirety of a test file is
+unsupported.
+
+`# FILE(NOT DONE)` indicates files that have not yet been executed,
+cleaned up, or skipped until passing.
+
+The purpose of these was to make the tests grep-able while going through
+all the failures.
+
+
+[cockroachdb/cockroach#20753]: https://github.com/cockroachdb/cockroach/issues/20753#issuecomment-352810425
+
+
+## Tracked test failures
+
+Some of the skipped failures are:
+
+- `default:` key is not working for columns in table schema
+  definitions. This causes tests to fail due to unexpected data.
+
+- `array:` key is not working for columns in table schema definitions.
+
+- `"Salary is not appearing in list"` is being raised in a number of
+  places. Likely during fixture setup.
+
+- `sum` function seems to result in a different type in ActiveRecord.
+  Instead of returning a Ruby `int`, it returns a Ruby `string`. It
+  appears that MySQL2 also does this. A suspected cause might be how
+  `Decimal` is handled if `sum` consumes integers and return a
+  decimal.
+
+- Potentially fork the PostgreSQL::SchemaDumper to handle anything
+  specific to CockroachDB, like primary keys or bigints.
+
+- You can call `@connection.create_table(..., id: :bigint)`, but this
+  will not changes things for CockroachDB (I think...), so it would be
+  not allowed. Even better, our adapter could interpret this and
+  generate the appropriate explicit pkey column. Not sure what string
+  pkeys look like...
+
+- `string` types are introspected to `text` types.
+
+- A user can do an update, delete, and insert on views.
+
+- Postgres specific bit strings are not properly supported.
+
+Grepping for `FIXME(joey)`, `TODO(joey)`, and `NOTE(joey)` will yeild
+most of the touchpoints including test failures and temporary monkey
+patches. Some monkey patches were made directly to Rails, which will
+need to be cleaned up.
+
+
+# Notes for the non-Rubyer
+
+rvm is an environment manager that lets you manage and swap between
+multiple verisons of Ruby and their dependancies.
+
+bundle is dependancy manager that uses a projects `Gemfile` (and often
+`<project>.gemspec`) to manage and load dependancies and their required
+versions. When using projects commands are prefixed with
+`bundle exec ...`. Bundle will ensure that all depenedncies are fetched
+and used.

data/Gemfile

@@ -1,4 +1,11 @@
 source 'https://rubygems.org'
 
+# gem 'activerecord', git: 'https://github.com/lego/ruby-on-rails.git'
+
+git_source(:github) { |repo| "https://github.com/#{repo}.git" }
+
 # Specify your gem's dependencies in activerecord-cockroachdb-adapter.gemspec
 gemspec
+
+# We need a newish Rake since Active Job sets its test tasks' descriptions.
+gem "rake", ">= 11.1"

data/README.md

@@ -1,6 +1,6 @@
 # ActiveRecord CockroachDB Adapter
 
-CockroachDB adapter for ActiveRecord 5. This is a lightweight extension of the PostgreSQL adapter that establishes compatibility with [CockroachDB](https://github.com/cockroachdb/cockroach).
+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).
 
 ## Installation
 
@@ -10,10 +10,20 @@ Add this line to your project's Gemfile:
 gem 'activerecord-cockroachdb-adapter', '~> 0.2.2'
 ```
 
+If you're using Rails 4.x, use the `0.1.x` versions of this gem.
+
 In `database.yml`, use the following adapter setting:
 
 ```
 development:
   adapter: cockroachdb
   port: 26257
+  host: <hostname>
+  user: <username>
 ```
+
+
+## Modifying the adapter?
+
+See [CONTRIBUTING.md](/CONTRIBUTING.md) for more details on setting up
+the environment and making modifications.

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.2"
+  spec.version       = "0.2.3"
   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.1", ">= 5.1.1"
+  spec.add_dependency "activerecord", "~> 5.2"
   spec.add_dependency "pg", ">= 0.20", "< 0.22"
 
   # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'

data/build/Dockerfile

@@ -0,0 +1,17 @@
+# This Dockerfile extends the Examples-ORM testing image in order to
+# install specific dependencies required for ActiveRecord tests.
+
+FROM cockroachdb/postgres-test:20170308-1644
+
+# Native dependencies for libxml-ruby and sqlite3.
+RUN apt-get update -y && apt-get install -y \
+  libxslt-dev \
+  libxml2-dev \
+  libsqlite3-dev \
+  && rm -rf /var/lib/apt/lists/*
+
+# Ruby testing dependencies.
+RUN gem install bundle rake
+
+# Add global Gem binaries to the path.
+ENV PATH /usr/local/lib/ruby/gems/2.4.0::$PATH

data/build/config.teamcity.yml

@@ -0,0 +1,28 @@
+default_connection: cockroachdb
+
+with_manual_interventions: false
+
+connections:
+  cockroachdb:
+    arunit:
+      database: activerecord_unittest
+      host: localhost
+      port: 26257
+      user: root
+      requiressl: disable
+      min_messages: warning
+    arunit_without_prepared_statements:
+      database: activerecord_unittest
+      host: localhost
+      port: 26257
+      user: root
+      requiressl: disable
+      min_messages: warning
+      prepared_statements: false
+    arunit2:
+      database: activerecord_unittest2
+      host: localhost
+      port: 26257
+      user: root
+      requiressl: disable
+      min_messages: warning

data/build/local-test.sh

@@ -0,0 +1,38 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+readonly urlfile=cockroach-url
+
+# Start a CockroachDB server, wait for it to become ready, and arrange for it to
+# be force-killed when the script exits.
+rm -f "$urlfile"
+# Clean out a past CockroachDB instance. This happens if a build was
+# canceled on an agent.
+rm -rf $HOME/tmp/rails &
+# Start CockroachDB.
+cockroach quit --insecure || true
+cockroach start --insecure --host=localhost --listening-url-file="$urlfile" --store=path=$HOME/tmp/rails &
+trap "echo 'Exit routine: Killing CockroachDB.' && kill -9 $! &> /dev/null" EXIT
+for i in {0..3}
+do
+  [[ -f "$urlfile" ]] && break
+  backoff=$((2 ** i))
+  echo "server not yet available; sleeping for $backoff seconds"
+  sleep $backoff
+done
+
+# Target the Rails dependency file.
+export BUNDLE_GEMFILE=$(pwd)/rails/Gemfile
+
+# Run the tests.
+cp build/config.teamcity.yml rails/activerecord/test/config.yml
+echo "Rebuilding database"
+(cd rails/activerecord && bundle exec rake db:cockroachdb:rebuild)
+echo "Starting tests"
+(cd rails/activerecord && bundle exec rake test:cockroachdb TESTFILES=$1)
+
+# Attempt a clean shutdown for good measure. We'll force-kill in the atexit
+# handler if this fails.
+cockroach quit --insecure
+trap - EXIT

data/build/teamcity-test.sh

@@ -0,0 +1,82 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+# Download CockroachDB. NB: currently this uses an alpha, due to feature
+# requirements.
+VERSION=v2.0-alpha.20171218
+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
+readonly urlfile=cockroach-url
+
+run_cockroach() {
+  # Start a CockroachDB server, wait for it to become ready, and arrange
+  # for it to be force-killed when the script exits.
+  rm -f "$urlfile"
+  # Clean out a past CockroachDB instance. This will clean out leftovers
+  # from the build agent, and also between CockroachDB runs.
+  cockroach quit --insecure || true
+  rm -rf cockroach-data
+  # Start CockroachDB.
+  cockroach start --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.
+  for i in {0..3}; do
+    [[ -f "$urlfile" ]] && break
+    backoff=$((2 ** i))
+    echo "server not yet available; sleeping for $backoff seconds"
+    sleep $backoff
+  done
+}
+
+# Target the Rails dependency file.
+export BUNDLE_GEMFILE=$(pwd)/rails/Gemfile
+
+# Install ruby dependencies.
+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
+
+# 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"
+    HAS_FAILED=1
+  else
+    echo "Test PASSED: $TESTFILE"
+    HAS_FAILED=0
+  fi
+done
+
+# Attempt a clean shutdown for good measure. We'll force-kill in the
+# exit trap if this script fails.
+cockroach quit --insecure
+trap - EXIT
+
+if [ $HAS_FAILED -eq 1 ]; then
+  exit 1
+fi

data/docker.sh

@@ -0,0 +1,38 @@
+#!/bin/bash
+#
+# This file is largely cargo-culted from cockroachdb/cockroach/build/builder.sh.
+
+set -euo pipefail
+
+DOCKER_IMAGE_TAG=activerecord_test_container
+
+# Build the docker image to use.
+docker build -t ${DOCKER_IMAGE_TAG} build/
+
+# Absolute path to this repository.
+repo_root=$(cd "$(dirname "${0}")" && pwd)
+
+# Make a fake passwd file for the invoking user.
+#
+# This setup is so that files created from inside the container in a mounted
+# volume end up being owned by the invoking user and not by root.
+# We'll mount a fresh directory owned by the invoking user as /root inside the
+# container because the container needs a $HOME (without one the default is /)
+# and because various utilities (e.g. bash writing to .bash_history) need to be
+# able to write to there.
+username=$(id -un)
+uid_gid=$(id -u):$(id -g)
+container_root=${repo_root}/docker_root
+mkdir -p "${container_root}"/{etc,home,home/"${username}"/activerecord-cockroachdb-adapter,home/.gems}
+echo "${username}:x:${uid_gid}::/home/${username}:/bin/bash" > "${container_root}/etc/passwd"
+
+docker run \
+  --volume="${container_root}/etc/passwd:/etc/passwd" \
+  --volume="${container_root}/home/${username}:/home/${username}" \
+  --volume="${repo_root}:/home/${username}/activerecord-cockroachdb-adapter" \
+  --workdir="/home/${username}/activerecord-cockroachdb-adapter" \
+  --env=PIP_USER=1 \
+  --env=GEM_HOME="/home/${username}/.gems" \
+  --user="${uid_gid}" \
+  "${DOCKER_IMAGE_TAG}" \
+  "$@"

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+# NOTE(joey): This is cradled from connection_adapters/postgresql/referential_integrity.rb
+# It is commonly used for setting up fixtures during tests.
+module ActiveRecord
+  module ConnectionAdapters
+    module CockroachDB
+      module ReferentialIntegrity # :nodoc:
+        def disable_referential_integrity # :nodoc:
+          original_exception = nil
+          fkeys = nil
+
+          begin
+            transaction do
+              tables.each do |table_name|
+                fkeys = foreign_keys(table_name)
+                fkeys.each do |fkey|
+                  remove_foreign_key table_name, name: fkey.options[:name]
+                end
+              end
+            end
+          rescue ActiveRecord::ActiveRecordError => e
+            original_exception = e
+          end
+
+          begin
+            yield
+          rescue ActiveRecord::InvalidForeignKey => e
+            warn <<-WARNING
+WARNING: Rails was not able to disable referential integrity.
+
+Please go to https://github.com/cockroachdb/activerecord-cockroachdb-adapter
+and report this issue.
+
+    cause: #{original_exception.try(:message)}
+
+              WARNING
+            raise e
+          end
+
+          begin
+            transaction do
+              if !fkeys.nil?
+                 fkeys.each do |fkey|
+                  add_foreign_key fkey.from_table, fkey.to_table, fkey.options
+                end
+              end
+            end
+          rescue ActiveRecord::ActiveRecordError
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+require 'active_record/connection_adapters/postgresql/schema_statements'
+
+module ActiveRecord
+  module ConnectionAdapters
+    module CockroachDB
+      module SchemaStatements
+        include ActiveRecord::ConnectionAdapters::PostgreSQL::SchemaStatements
+        # NOTE(joey): This was ripped from PostgresSQL::SchemaStatements, with a
+        # slight modification to change setval(string, int, bool) to just
+        # setval(string, int) for CockroachDB compatbility.
+        # See https://github.com/cockroachdb/cockroach/issues/19723
+        #
+        # Resets the sequence of a table's primary key to the maximum value.
+        def reset_pk_sequence!(table, pk = nil, sequence = nil) #:nodoc:
+          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?
+              if postgresql_version >= 100000
+                minvalue = query_value("SELECT seqmin FROM pg_sequence WHERE seqrelid = #{quote(quoted_sequence)}::regclass", "SCHEMA")
+              else
+                minvalue = query_value("SELECT min_value FROM #{quoted_sequence}", "SCHEMA")
+              end
+            end
+            if max_pk
+              # NOTE(joey): This is done to replace the call:
+              #
+              #    SELECT setval(..., max_pk, false)
+              #
+              # with
+              #
+              #    SELECT setval(..., max_pk-1)
+              #
+              # These two statements are semantically equivilant, but
+              # setval(string, int, bool) is not supported by CockroachDB.
+              #
+              # FIXME(joey): This is incorrect if the sequence is not 1
+              # incremented. We would need to pull out the custom increment value.
+              max_pk - 1
+            end
+            query_value("SELECT setval(#{quote(quoted_sequence)}, #{max_pk ? max_pk : minvalue})", "SCHEMA")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'active_record/connection_adapters/abstract/transaction'
+
+module ActiveRecord
+  module ConnectionAdapters
+
+    # NOTE(joey): This is a very sad monkey patch. Unfortunately, it is
+    # required in order to prevent doing more than 2 nested transactions
+    # while still allowing a single nested transaction. This is because
+    # CockroachDB only supports a single savepoint at the beginning of a
+    # transaction. Allowing this works for the common case of testing.
+    module CockroachDB
+      module TransactionManagerMonkeyPatch
+        def begin_transaction(options={})
+          @connection.lock.synchronize do
+            # If the transaction nesting is already 2 deep, raise an error.
+            if @connection.adapter_name == "CockroachDB" && @stack.is_a?(ActiveRecord::ConnectionAdapters::SavepointTransaction)
+              raise(ArgumentError, "cannot nest more than 1 transaction at a time. this is a CockroachDB limitation")
+            end
+          end
+          super(options)
+        end
+      end
+    end
+
+    class TransactionManager
+      prepend CockroachDB::TransactionManagerMonkeyPatch
+    end
+  end
+end

data/lib/active_record/connection_adapters/cockroachdb_adapter.rb

@@ -1,4 +1,8 @@
 require 'active_record/connection_adapters/postgresql_adapter'
+require "active_record/connection_adapters/postgresql/schema_statements"
+require "active_record/connection_adapters/cockroachdb/schema_statements"
+require "active_record/connection_adapters/cockroachdb/referential_integrity"
+require "active_record/connection_adapters/cockroachdb/transaction_manager"
 
 module ActiveRecord
   module ConnectionHandling
@@ -13,7 +17,7 @@ module ActiveRecord
       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 + [:requiressl]
+      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
@@ -24,125 +28,275 @@ module ActiveRecord
   end
 end
 
-class ActiveRecord::ConnectionAdapters::CockroachDBAdapter < ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
-  ADAPTER_NAME = "CockroachDB".freeze
+module ActiveRecord
+  module ConnectionAdapters
+    class CockroachDBAdapter < PostgreSQLAdapter
+      ADAPTER_NAME = "CockroachDB".freeze
 
-  # Note that in the migration from ActiveRecord 5.0 to 5.1, the
-  # `extract_schema_qualified_name` method was aliased in the PostgreSQLAdapter.
-  # To ensure backward compatibility with both <5.1 and 5.1, we rename it here
-  # to use the same original `Utils` module.
-  Utils = ActiveRecord::ConnectionAdapters::PostgreSQL::Utils
+      include CockroachDB::SchemaStatements
+      include CockroachDB::ReferentialIntegrity
 
-  def supports_json?
-      false
-  end
 
-  def supports_ddl_transactions?
-      false
-  end
+      # Note that in the migration from ActiveRecord 5.0 to 5.1, the
+      # `extract_schema_qualified_name` method was aliased in the PostgreSQLAdapter.
+      # To ensure backward compatibility with both <5.1 and 5.1, we rename it here
+      # to use the same original `Utils` module.
+      Utils = PostgreSQL::Utils
 
-  def supports_extensions?
-      false
-  end
+      def supports_json?
+        # FIXME(joey): Add a version check.
+        true
+      end
 
-  def supports_ranges?
-      false
-  end
+      def supports_ddl_transactions?
+        false
+      end
 
-  def supports_materialized_views?
-      false
-  end
+      def supports_extensions?
+        false
+      end
 
-  def supports_pg_crypto_uuid?
-      false
-  end
+      def supports_ranges?
+        # See cockroachdb/cockroach#17022
+        false
+      end
 
-  def indexes(table_name, name = nil) # :nodoc:
-    # The PostgreSQL adapter uses a correlated subquery in the following query,
-    # which CockroachDB does not yet support. That portion of the query fetches
-    # any non-standard opclasses that each index uses. CockroachDB also doesn't
-    # support opclasses at this time, so the query is modified to just remove
-    # the section about opclasses entirely.
-    if name
-      ActiveSupport::Deprecation.warn(<<-MSG.squish)
-        Passing name to #indexes is deprecated without replacement.
-      MSG
-    end
+      def supports_materialized_views?
+        false
+      end
+
+      def supports_pg_crypto_uuid?
+        false
+      end
+
+      def supports_partial_index?
+        # See cockroachdb/cockroach#9683
+        false
+      end
+
+      def supports_expression_index?
+        # See cockroachdb/cockroach#9682
+        false
+      end
+
+      def supports_datetime_with_precision?
+        false
+      end
+
+      def supports_comments?
+        # See cockroachdb/cockroach#19472.
+        false
+      end
+
+      def supports_comments_in_create?
+        # See cockroachdb/cockroach#19472.
+        false
+      end
+
+      def supports_advisory_locks?
+        # FIXME(joey): We may want to make this false.
+        true
+      end
+
+      def supports_virtual_columns?
+        # See cockroachdb/cockroach#20882.
+        false
+      end
 
-    table = Utils.extract_schema_qualified_name(table_name.to_s)
-
-    result = query(<<-SQL, "SCHEMA")
-      SELECT distinct i.relname, d.indisunique, d.indkey, pg_get_indexdef(d.indexrelid), t.oid,
-                      pg_catalog.obj_description(i.oid, 'pg_class') AS comment
-      FROM pg_class t
-      INNER JOIN pg_index d ON t.oid = d.indrelid
-      INNER JOIN pg_class i ON d.indexrelid = i.oid
-      LEFT JOIN pg_namespace n ON n.oid = i.relnamespace
-      WHERE i.relkind = 'i'
-        AND d.indisprimary = 'f'
-        AND t.relname = '#{table.identifier}'
-        AND n.nspname = #{table.schema ? "'#{table.schema}'" : 'ANY (current_schemas(false))'}
-      ORDER BY i.relname
-    SQL
-
-    result.map do |row|
-      index_name = row[0]
-      unique = row[1]
-      indkey = row[2].split(" ").map(&:to_i)
-      inddef = row[3]
-      oid = row[4]
-      comment = row[5]
-
-      expressions, where = inddef.scan(/\((.+?)\)(?: WHERE (.+))?\z/).flatten
-
-      if indkey.include?(0)
-        columns = expressions
-      else
-        columns = Hash[query(<<-SQL.strip_heredoc, "SCHEMA")].values_at(*indkey).compact
-          SELECT a.attnum, a.attname
-          FROM pg_attribute a
-          WHERE a.attrelid = #{oid}
-          AND a.attnum IN (#{indkey.join(",")})
+      def supports_savepoints?
+        # See cockroachdb/cockroach#10735.
+        false
+      end
+
+      def transaction_isolation_levels
+        {
+          # Explicitly prevent READ UNCOMMITTED from being used. This
+          # was due to the READ UNCOMMITTED test failing.
+          # read_uncommitted: "READ UNCOMMITTED",
+          read_committed:   "READ COMMITTED",
+          repeatable_read:  "REPEATABLE READ",
+          serializable:     "SERIALIZABLE"
+        }
+      end
+
+
+      # Sadly, we can only do savepoints at the beginning of
+      # transactions. This means that we cannot use them for most cases
+      # of transaction, so we just pretend they're usable.
+      def create_savepoint(name = "COCKROACH_RESTART"); end
+
+      def exec_rollback_to_savepoint(name = "COCKROACH_RESTART"); end
+
+      def release_savepoint(name = "COCKROACH_RESTART"); end
+
+      def indexes(table_name, name = nil) # :nodoc:
+        # The PostgreSQL adapter uses a correlated subquery in the following query,
+        # which CockroachDB does not yet support. That portion of the query fetches
+        # any non-standard opclasses that each index uses. CockroachDB also doesn't
+        # support opclasses at this time, so the query is modified to just remove
+        # the section about opclasses entirely.
+        if name
+          ActiveSupport::Deprecation.warn(<<-MSG.squish)
+            Passing name to #indexes is deprecated without replacement.
+          MSG
+        end
+
+        table = Utils.extract_schema_qualified_name(table_name.to_s)
+
+        result = query(<<-SQL, "SCHEMA")
+          SELECT distinct i.relname, d.indisunique, d.indkey, pg_get_indexdef(d.indexrelid), t.oid,
+                          pg_catalog.obj_description(i.oid, 'pg_class') AS comment
+          FROM pg_class t
+          INNER JOIN pg_index d ON t.oid = d.indrelid
+          INNER JOIN pg_class i ON d.indexrelid = i.oid
+          LEFT JOIN pg_namespace n ON n.oid = i.relnamespace
+          WHERE i.relkind = 'i'
+            AND d.indisprimary = 'f'
+            AND t.relname = '#{table.identifier}'
+            AND n.nspname = #{table.schema ? "'#{table.schema}'" : 'ANY (current_schemas(false))'}
+          ORDER BY i.relname
         SQL
 
-        # add info on sort order for columns (only desc order is explicitly specified, asc is the default)
-        orders = Hash[
-          expressions.scan(/(\w+) DESC/).flatten.map { |order_column| [order_column, :desc] }
-        ]
+        result.map do |row|
+          index_name = row[0]
+          unique = row[1]
+          indkey = row[2].split(" ").map(&:to_i)
+          inddef = row[3]
+          oid = row[4]
+          comment = row[5]
+
+          expressions, where = inddef.scan(/\((.+?)\)(?: WHERE (.+))?\z/).flatten
+
+          if indkey.include?(0)
+            columns = expressions
+          else
+            columns = Hash[query(<<-SQL.strip_heredoc, "SCHEMA")].values_at(*indkey).compact
+              SELECT a.attnum, a.attname
+              FROM pg_attribute a
+              WHERE a.attrelid = #{oid}
+              AND a.attnum IN (#{indkey.join(",")})
+            SQL
+
+            # add info on sort order for columns (only desc order is explicitly specified, asc is the default)
+            orders = Hash[
+              expressions.scan(/(\w+) DESC/).flatten.map { |order_column| [order_column, :desc] }
+            ]
+          end
+
+          # FIXME(joey): This may be specific to ActiveRecord 5.2.
+          IndexDefinition.new(
+            table_name,
+            index_name,
+            unique,
+            columns,
+            orders: orders,
+            where: where,
+            comment: comment.presence
+          )
+        end.compact
       end
 
-      ActiveRecord::ConnectionAdapters::IndexDefinition.new(table_name, index_name, unique, columns, [], orders, where, nil, nil, comment.presence)
-    end.compact
-  end
 
+      def primary_keys(table_name)
+          name = Utils.extract_schema_qualified_name(table_name.to_s)
+          select_values(<<-SQL.strip_heredoc, "SCHEMA")
+          SELECT column_name
+              FROM information_schema.key_column_usage kcu
+              JOIN information_schema.table_constraints tc
+              ON kcu.table_name = tc.table_name
+              AND kcu.table_schema = tc.table_schema
+              AND kcu.constraint_name = tc.constraint_name
+              WHERE constraint_type = 'PRIMARY KEY'
+              AND kcu.table_name = #{quote(name.identifier)}
+              AND kcu.table_schema = #{name.schema ? quote(name.schema) : "ANY (current_schemas(false))"}
+              ORDER BY kcu.ordinal_position
+          SQL
+      end
 
-  def primary_keys(table_name)
-      name = Utils.extract_schema_qualified_name(table_name.to_s)
-      select_values(<<-SQL.strip_heredoc, "SCHEMA")
-      SELECT column_name
-          FROM information_schema.key_column_usage kcu
-          JOIN information_schema.table_constraints tc
-          ON kcu.table_name = tc.table_name
-          AND kcu.table_schema = tc.table_schema
-          AND kcu.constraint_name = tc.constraint_name
-          WHERE constraint_type = 'PRIMARY KEY'
-          AND kcu.table_name = #{quote(name.identifier)}
-          AND kcu.table_schema = #{name.schema ? quote(name.schema) : "ANY (current_schemas(false))"}
-          ORDER BY kcu.ordinal_position
-      SQL
-  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
+      # lengths far greater than this value. For the time being though, we match
+      # the original behavior for PostgreSQL to simplify migrations.
+      #
+      # Note that in the migration to ActiveRecord 5.1, this was changed in
+      # PostgreSQLAdapter to use `SHOW max_identifier_length` (which does not
+      # exist in CockroachDB). Therefore, we have to redefine this here.
+      def max_identifier_length
+        63
+      end
+      alias index_name_length max_identifier_length
+      alias table_alias_length max_identifier_length
+
+      private
+
+        def initialize_type_map(m = type_map)
+          super(m)
+          # 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|
+            precision = extract_precision(sql_type)
+            if precision
+              raise(ArgumentError, "CockroachDB does not support precision on intervals, but got precision: #{precision}")
+            end
+            OID::SpecializedString.new(:interval, precision: precision)
+          end
+        end
+
+        # 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
 
-  # 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
-  # lengths far greater than this value. For the time being though, we match
-  # the original behavior for PostgreSQL to simplify migrations.
-  #
-  # Note that in the migration to ActiveRecord 5.1, this was changed in
-  # PostgreSQLAdapter to use `SHOW max_identifier_length` (which does not
-  # exist in CockroachDB). Therefore, we have to redefine this here.
-  def table_alias_length
-    63
+          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::Base.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
+
+
+      # end private
+    end
   end
-  alias index_name_length table_alias_length
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-cockroachdb-adapter
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors:
 - Cockroach Labs
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-06-13 00:00:00.000000000 Z
+date: 2018-04-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,20 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.1'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 5.1.1
+        version: '5.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.1'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 5.1.1
+        version: '5.2'
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
@@ -101,7 +95,8 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
-- ".travis.yml"
+- ".gitmodules"
+- CONTRIBUTING.md
 - Gemfile
 - LICENSE
 - README.md
@@ -109,7 +104,15 @@ files:
 - activerecord-cockroachdb-adapter.gemspec
 - bin/console
 - bin/setup
+- build/Dockerfile
+- build/config.teamcity.yml
+- build/local-test.sh
+- build/teamcity-test.sh
+- docker.sh
 - lib/active_record/connection_adapters/cockroachdb/database_tasks.rb
+- lib/active_record/connection_adapters/cockroachdb/referential_integrity.rb
+- lib/active_record/connection_adapters/cockroachdb/schema_statements.rb
+- lib/active_record/connection_adapters/cockroachdb/transaction_manager.rb
 - lib/active_record/connection_adapters/cockroachdb_adapter.rb
 - lib/activerecord-cockroachdb-adapter.rb
 homepage: https://github.com/cockroachdb/activerecord-cockroachdb-adapter
@@ -133,7 +136,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: CockroachDB adapter for ActiveRecord.

data/.travis.yml

@@ -1,5 +0,0 @@
-sudo: false
-language: ruby
-rvm:
-  - 2.4.0
-before_install: gem install bundler -v 1.14.3