activerecord-cockroachdb-adapter 8.0.3 → 8.1.0

data/test/excludes/SequenceNameDetectionTestCases/LongerSequenceNameDetectionTest.rb

@@ -0,0 +1 @@
+exclude :test_schema_dump_with_long_table_name, "Serial columns are dumped as a bigserials against CockroachDB. This happens because serial columns are backed by integers, and integers are really bigints in CockroachDB. See https://www.cockroachlabs.com/docs/v19.2/serial.html#generated-values-for-mode-sql_sequence."

data/test/excludes/StrictLoadingFixturesTest.rb

@@ -0,0 +1 @@
+exclude :test_strict_loading_violations_are_ignored_on_fixtures, "This test is re-implemented with transactional tests disabled."

data/test/excludes/TestFixturesTest.rb

@@ -0,0 +1 @@
+exclude :test_doesnt_rely_on_active_support_test_case_specific_methods, "This test is replaced with a version in our test suite."

data/test/excludes/TransactionInstrumentationTest.rb

@@ -0,0 +1 @@
+exclude :test_transaction_instrumentation_with_restart_parent_transaction_on_rollback, "CRDB doesn't support ROLLBACK AND CHAIN"

data/test/excludes/TransactionIsolationTest.rb

@@ -0,0 +1 @@
+exclude :test_read_uncommitted, "CockroachDB implements all isolation levels as SERIALIZABLE so this test does not work as expected."

data/test/excludes/TypeTest.rb

@@ -0,0 +1 @@
+exclude :test_lookup_defaults_to_the_current_adapter, "Skipping until we can triage further. See https://github.com/cockroachdb/activerecord-cockroachdb-adapter/issues/48"

data/test/excludes/UniquenessValidationTest.rb

@@ -0,0 +1,2 @@
+exclude :test_validate_uniqueness_uuid, "This test is only meant to be run with a PostgreSQL adapter"
+exclude :test_validate_case_insensitive_uniqueness, "This tests relies on an implemented pg_cast table, see cockroach/cockroach#47498 for more details"

data/test/excludes/UnloggedTablesTest.rb

@@ -0,0 +1,3 @@
+instance_methods.grep(/\Atest_\w+\z/).each do |method_name|
+  exclude method_name, "UNLOGGED has no effect in CockroachDB."
+end

data/test/excludes/UnsafeRawSqlTest.rb

@@ -0,0 +1,2 @@
+exclude "test_order:_allows_NULLS_FIRST_and_NULLS_LAST_too", "This functionality is not yet implemented, see https://github.com/cockroachdb/cockroach/issues/6224 for more details"
+exclude "test_order:_allows_valid_arguments_with_COLLATE", "Replaced for correct collation name"

data/test/excludes/UpdateableViewTest.rb

@@ -0,0 +1,5 @@
+updateable_msg = "Updateable views are not currently supported, see https://github.com/cockroachdb/cockroach/issues/20948"
+exclude :test_update_record_to_fail_view_conditions, updateable_msg
+exclude :test_insert_record, updateable_msg
+exclude :test_insert_record_populates_primary_key, updateable_msg
+exclude :test_update_record, updateable_msg

data/test/excludes/WithAnnotationsTest.rb

@@ -0,0 +1,6 @@
+exclude :test_has_and_belongs_to_many_with_annotation_includes_a_query_comment, "This test is overrided to fix the fixtures sequence. See test/cases/associations_test.rb"
+exclude :test_belongs_to_with_annotation_includes_a_query_comment, "This test is overrided to fix the fixtures sequence. See test/cases/associations_test.rb"
+exclude :test_has_one_with_annotation_includes_a_query_comment, "This test is overrided to fix the fixtures sequence. See test/cases/associations_test.rb"
+exclude :test_has_many_with_annotation_includes_a_query_comment, "This test is overrided to fix the fixtures sequence. See test/cases/associations_test.rb"
+exclude :test_has_many_through_with_annotation_includes_a_query_comment, "This test is overrided to fix the fixtures sequence. See test/cases/associations_test.rb"
+exclude :test_has_many_through_with_annotation_includes_a_query_comment_when_eager_loading, "This test is overrided to fix the fixtures sequence. See test/cases/associations_test.rb"

data/test/models/building.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class Building < ActiveRecord::Base
+end

data/test/models/spatial_model.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# This does not have an associated tabled in the cockroach_specific_schema
+class SpatialModel < ActiveRecord::Base
+end

data/test/schema/cockroachdb_specific_schema.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+# This is a copy of postgresql_specific_schema.rb from ActiveRecord's test
+# suite. Statements that don't work against CockroachDB have been commented out
+# with an explanation of why they don't work.
+
+ActiveRecord::Schema.define do
+  ActiveRecord::TestCase.enable_extension!("uuid-ossp", connection)
+  ActiveRecord::TestCase.enable_extension!("pgcrypto",  connection) if connection.supports_pgcrypto_uuid?
+
+  uuid_default = connection.supports_pgcrypto_uuid? ? {} : { default: "uuid_generate_v4()" }
+
+  create_table :chat_messages, id: :uuid, force: true, **uuid_default do |t|
+    t.text :content
+  end
+
+  create_table :chat_messages_custom_pk, id: false, force: true do |t|
+    t.uuid :message_id, primary_key: true, default: "uuid_generate_v4()"
+    t.text :content
+  end
+
+  create_table :uuid_parents, id: :uuid, force: true, **uuid_default do |t|
+    t.string :name
+  end
+
+  create_table :uuid_children, id: :uuid, force: true, **uuid_default do |t|
+    t.string :name
+    t.uuid :uuid_parent_id
+  end
+
+  create_table :defaults, force: true do |t|
+    t.virtual :virtual_stored_number, type: :integer, as: "random_number * 10", stored: true if supports_virtual_columns?
+    t.integer :random_number, default: -> { "random() * 100" }
+    t.string :ruby_on_rails, default: -> { "concat('Ruby ', 'on ', 'Rails')" }
+    t.date :modified_date, default: -> { "CURRENT_DATE" }
+    t.date :modified_date_function, default: -> { "now()" }
+    t.date :fixed_date, default: "2004-01-01"
+    t.datetime :modified_time, default: -> { "CURRENT_TIMESTAMP" }
+    t.datetime :modified_time_without_precision, precision: nil, default: -> { "CURRENT_TIMESTAMP" }
+    t.datetime :modified_time_with_precision_0, precision: 0, default: -> { "CURRENT_TIMESTAMP" }
+    t.datetime :modified_time_function, default: -> { "now()" }
+    t.datetime :fixed_time, default: "2004-01-01 00:00:00.000000-00"
+    t.timestamptz :fixed_time_with_time_zone, default: "2004-01-01 01:00:00+1"
+    t.column :char1, "char(1)", default: "Y"
+    t.string :char2, limit: 50, default: "a varchar field"
+    t.text :char3, default: "a text field"
+    t.bigint :bigint_default, default: -> { "0::bigint" }
+    t.binary :binary_default_function, default: -> { "convert_to('A', 'UTF8')" }
+    t.text :multiline_default, default: "--- []
+
+"
+  end
+
+  if supports_identity_columns?
+    drop_table "postgresql_identity_table", if_exists: true
+    execute <<~SQL
+      create table postgresql_identity_table (
+        id INT PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY
+      )
+    SQL
+
+    drop_table "cpk_postgresql_identity_table", if_exists: true
+    execute <<~SQL
+      create table cpk_postgresql_identity_table (
+        another_id INT NOT NULL,
+        id INT NOT NULL GENERATED BY DEFAULT AS IDENTITY,
+        CONSTRAINT cpk_postgresql_identity_table_pkey PRIMARY KEY (another_id, id)
+      )
+    SQL
+  end
+
+  create_table :postgresql_times, force: true do |t|
+    t.interval :time_interval
+    t.interval :scaled_time_interval, precision: 6
+  end
+
+  create_table :postgresql_oids, force: true do |t|
+    t.oid :obj_id
+  end
+
+  drop_table "postgresql_timestamp_with_zones", if_exists: true
+  drop_table "postgresql_partitioned_table", if_exists: true
+  drop_table "postgresql_partitioned_table_parent", if_exists: true
+
+  execute "DROP SEQUENCE IF EXISTS companies_nonstd_seq CASCADE"
+  execute "CREATE SEQUENCE companies_nonstd_seq START 101 OWNED BY companies.id"
+  execute "ALTER TABLE companies ALTER COLUMN id SET DEFAULT nextval('companies_nonstd_seq')"
+  execute "DROP SEQUENCE IF EXISTS companies_id_seq"
+
+  execute "DROP FUNCTION IF EXISTS partitioned_insert_trigger()"
+
+  # CockroachDB uses unique_rowid() for primary keys by default instead of
+  # sequences. Therefore, there aren't any sequences to update here.
+  # See https://www.cockroachlabs.com/docs/v19.2/serial.html#modes-of-operation.
+  # %w(accounts_id_seq developers_id_seq projects_id_seq topics_id_seq customers_id_seq orders_id_seq).each do |seq_name|
+  #   execute "SELECT setval('#{seq_name}', 100)"
+  # end
+
+  execute <<_SQL
+  CREATE TABLE postgresql_timestamp_with_zones (
+    id SERIAL PRIMARY KEY,
+    time TIMESTAMP WITH TIME ZONE
+  );
+_SQL
+
+# Table inheritance is not supported in CockroachDB.
+# See https://go.crdb.dev/issue-v/22456/v24.1
+#   begin
+#     execute <<_SQL
+#     CREATE TABLE postgresql_partitioned_table_parent (
+#       id SERIAL PRIMARY KEY,
+#       number integer
+#     );
+#     CREATE TABLE postgresql_partitioned_table ( )
+#       INHERITS (postgresql_partitioned_table_parent);
+
+#     CREATE OR REPLACE FUNCTION partitioned_insert_trigger()
+#     RETURNS TRIGGER AS $$
+#     BEGIN
+#       INSERT INTO postgresql_partitioned_table VALUES (NEW.*);
+#       RETURN NULL;
+#     END;
+#     $$
+#     LANGUAGE plpgsql;
+
+#     CREATE TRIGGER insert_partitioning_trigger
+#       BEFORE INSERT ON postgresql_partitioned_table_parent
+#       FOR EACH ROW EXECUTE PROCEDURE partitioned_insert_trigger();
+# _SQL
+#   rescue ActiveRecord::StatementInvalid => e
+#     if e.message.include?('language "plpgsql" does not exist')
+#       execute "CREATE LANGUAGE 'plpgsql';"
+#       retry
+#     else
+#       raise e
+#     end
+#   end
+
+  # This table is to verify if the :limit option is being ignored for text and binary columns
+  create_table :limitless_fields, force: true do |t|
+    t.binary :binary, limit: 100_000
+    t.text :text, limit: 100_000
+  end
+
+  create_table :bigint_array, force: true do |t|
+    t.integer :big_int_data_points, limit: 8, array: true
+    t.decimal :decimal_array_default, array: true, default: [1.23, 3.45]
+  end
+
+  create_table :uuid_comments, force: true, id: false do |t|
+    t.uuid :uuid, primary_key: true, **uuid_default
+    t.string :content
+  end
+
+  create_table :uuid_entries, force: true, id: false do |t|
+    t.uuid :uuid, primary_key: true, **uuid_default
+    t.string :entryable_type, null: false
+    t.uuid :entryable_uuid, null: false
+  end
+
+  create_table :uuid_items, force: true, id: false do |t|
+    t.uuid :uuid, primary_key: true, **uuid_default
+    t.string :title
+  end
+
+  create_table :uuid_messages, force: true, id: false do |t|
+    t.uuid :uuid, primary_key: true, **uuid_default
+    t.string :subject
+  end
+
+  # CockroachDB does not support exclusion constraints.
+  #
+  # create_table :test_exclusion_constraints, force: true do |t|
+  #   ...
+  # end
+
+  create_table :test_unique_constraints, force: true do |t|
+    t.integer :position_1
+    t.integer :position_2
+    t.integer :position_3
+    t.integer :position_4
+
+    # CockroachDB does not support deferrable, hence these four lines have been simplified.
+    t.unique_constraint :position_1, name: "test_unique_constraints_position_1"
+    t.unique_constraint :position_2, name: "test_unique_constraints_position_2"
+    t.unique_constraint :position_3, name: "test_unique_constraints_position_3"
+    t.unique_constraint :position_4, name: "test_unique_constraints_position_4"
+  end
+
+  if supports_partitioned_indexes?
+    create_table(:measurements, id: false, force: true, options: "PARTITION BY LIST (city_id)") do |t|
+      t.string :city_id, null: false
+      t.date :logdate, null: false
+      t.integer :peaktemp
+      t.integer :unitsales
+      t.index [:logdate, :city_id], unique: true
+    end
+    create_table(:measurements_toronto, id: false, force: true,
+                                        options: "PARTITION OF measurements FOR VALUES IN (1)")
+    create_table(:measurements_concepcion, id: false, force: true,
+                                           options: "PARTITION OF measurements FOR VALUES IN (2)")
+  end
+
+  add_index(:companies, [:firm_id, :type], name: "company_include_index", include: [:name, :account_id])
+
+  # In the original PostgreSQL schema, there would be a table here, populated using triggers.
+  # This is not supported by Cockroachdb so we removed that bit.
+
+  create_table :buildings, force: true do |t|
+    t.st_point :coordinates, srid: 3857
+    t.st_point :latlon, srid: 4326, geographic: true
+    t.st_polygon :boundary, srid: 3857
+    t.multi_polygon :m_poly, srid: 3857
+    t.multi_point :points, srid: 3857
+    t.line_string :path, srid: 3857
+    t.column(:shape, :geometry)
+  end
+end

data/test/support/copy_cat.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "parser"
+require "prism"
+
+module CopyCat
+  module NoWarnRewrite
+    def warn(message, category: nil, **kwargs)
+      if /method redefined; discarding old|previous definition of/.match?(message) &&
+         caller_locations.any? { _1.path["test/support/copy_cat.rb"] && _1.label["copy_methods"] }
+        # ignore
+      else
+        super
+      end
+    end
+  end
+  ::Warning.singleton_class.prepend NoWarnRewrite
+
+  extend self
+
+  # Copy methods from The original rails class to our adapter.
+  # While copying, we can rewrite the source code of the method using
+  # ast. Use `debug: true` to lead you through that process.
+  #
+  # Once debug is set, you can check the closest node you want to edit
+  # and then create a method `on_<node_type>` to handle it.
+  def copy_methods(new_klass, old_klass, *methods, debug: false, &block)
+    if debug and not block_given?
+      puts "You need to provide a block to debug."
+    end
+    methods.each do |met|
+      file, _ = old_klass.instance_method(met).source_location
+      ast = find_method(Prism::Translation::Parser.parse_file(file), met)
+      code =
+        if block_given?
+          source = ast.location.expression.source
+          buffer = Parser::Source::Buffer.new(met, source: source)
+          # We need to recompute the ast to have correct locations.
+          ast = Prism::Translation::Parser.parse(source)
+
+          if debug
+            puts "=" * 80
+            puts "Rewriter doc: https://www.rubydoc.info/gems/parser/3.3.0.5/Parser/TreeRewriter"
+            puts "Pattern matching doc: https://docs.ruby-lang.org/en/master/syntax/pattern_matching_rdoc.html"
+            puts
+            puts "Method: #{met}"
+            puts
+            puts "Source:"
+            puts buffer.source
+            puts
+            puts "AST:"
+            pp ast
+            puts
+          end
+          rewriter_class = Class.new(Parser::TreeRewriter, &block)
+          rewriter_class.new.rewrite(buffer, ast)
+        else
+          ast.location.expression.source
+        end
+      if debug and block_given?
+        puts "Rewritten source:"
+        puts code
+        puts "=" * 80
+      end
+      location = caller_locations(3, 1).first
+      new_klass.class_eval(code, location.absolute_path || location.path, location.lineno)
+    end
+  end
+
+  def find_method(ast, method_name)
+    method_name = method_name.to_sym
+    to_search = [ast]
+    while !to_search.empty?
+      node = to_search.shift
+      next unless node.is_a?(Parser::AST::Node)
+      if node in [:def, ^method_name, *]
+        return node
+      end
+      to_search += node.children
+    end
+    return nil
+  end
+end

data/test/support/exclude_from_transactional_tests.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# Allow exclusion of tests by name using #exclude_from_transactional_tests(test_name)
+module ExcludeFromTransactionalTests
+  module ClassMethods
+    def exclude_from_transactional_tests(name)
+      @non_transactional_list ||= []
+      @non_transactional_list << name.to_s
+    end
+
+    def non_transactional_list
+      @non_transactional_list ||= []
+    end
+  end
+
+  def self.prepended(base)
+    base.extend ClassMethods
+  end
+
+  def before_setup
+    @old_use_transactional_tests = self.use_transactional_tests
+    if @old_use_transactional_tests # stay false if false
+      self.use_transactional_tests = !self.class.non_transactional_list.include?(@NAME.to_s)
+    end
+    super
+  end
+
+  def after_teardown
+    super
+  ensure
+    self.use_transactional_tests = @old_use_transactional_tests
+  end
+end

data/test/support/paths_cockroachdb.rb

@@ -0,0 +1,46 @@
+module ARTest
+  module CockroachDB
+
+    extend self
+
+    def root_cockroachdb
+      File.expand_path File.join(File.dirname(__FILE__), '..', '..')
+    end
+
+    def test_root_cockroachdb
+      File.join root_cockroachdb, 'test'
+    end
+
+    def root_activerecord
+      File.join Gem.loaded_specs['rails'].full_gem_path, 'activerecord'
+    end
+
+    def root_activerecord_lib
+      File.join root_activerecord, 'lib'
+    end
+
+    def root_activerecord_test
+      File.join root_activerecord, 'test'
+    end
+
+    def test_load_paths
+      ['lib', 'test', root_activerecord_lib, root_activerecord_test]
+    end
+
+    def add_to_load_paths!
+      test_load_paths.each { |p| $LOAD_PATH.unshift(p) unless $LOAD_PATH.include?(p) }
+    end
+
+    def arconfig_file
+      File.join test_root_cockroachdb, 'config.yml'
+    end
+
+    def arconfig_file_env!
+      ENV['ARCONFIG'] = arconfig_file
+    end
+
+  end
+end
+
+ARTest::CockroachDB.add_to_load_paths!
+ARTest::CockroachDB.arconfig_file_env!

data/test/support/rake_helpers.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RakeHelpers
+  COCKROACHDB_TEST_HELPER = 'test/cases/helper_cockroachdb.rb'
+
+  module_function
+
+  # Look for TEST_FILES_AR or TEST_FILES env variables
+  # to set specific tests, otherwise load every tests
+  # from active_record and this adapter.
+  def test_files
+    ar_test_files = ENV.fetch('TEST_FILES_AR', '')
+    cr_test_files = ENV.fetch('TEST_FILES', '')
+
+    return all_test_files if ar_test_files.empty? && cr_test_files.empty?
+
+    ar_test_files = ar_test_files.
+      split(',').
+      map { |file| File.join ARTest::CockroachDB.root_activerecord, file.strip }.
+      tap { _1.prepend(COCKROACHDB_TEST_HELPER) unless _1.empty? }
+
+    cr_test_files = cr_test_files.split(',').map(&:strip)
+
+    ar_test_files + cr_test_files
+  end
+
+  def all_test_files
+    activerecord_test_files =
+      ::Rake::FileList["#{ARTest::CockroachDB.root_activerecord}/test/cases/**/*_test.rb"].
+      reject { _1.include?("/adapters/") || _1.include?("/encryption/performance") } +
+      ::Rake::FileList["#{ARTest::CockroachDB.root_activerecord}/test/cases/adapters/postgresql/**/*_test.rb"]
+
+      cockroachdb_test_files = ::Rake::FileList['test/cases/**/*_test.rb']
+
+      ::Rake::FileList[COCKROACHDB_TEST_HELPER] + activerecord_test_files + cockroachdb_test_files
+  end
+end

data/test/support/sql_logger.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module SQLLogger
+  module_function
+
+  def stdout_log
+    ActiveRecord::Base.logger = Logger.new(STDOUT)
+    ActiveRecord::Base.logger.level = Logger::DEBUG
+    ActiveRecord::LogSubscriber::IGNORE_PAYLOAD_NAMES.clear
+    ActiveRecord::Base.logger.formatter = proc { |severity, time, progname, msg|
+      th = Thread.current[:name]
+      th = "THREAD=#{th}" if th
+      Logger::Formatter.new.call(severity, time, progname || th, msg)
+    }
+  end
+
+  def summary_log
+    ActiveRecord::TotalTimeSubscriber.attach_to :active_record
+    Minitest.after_run {
+      detail = ActiveRecord::TotalTimeSubscriber.hash.map { |k,v| [k, [v.sum, v.sum / v.size, v.size]]}.sort_by { |_, (_total, avg, _)| -avg }.to_h
+      time = detail.values.sum { |(total, _, _)| total } / 1_000
+      count = detail.values.sum { |(_, _, count)| count }
+      File.write(
+        "tmp/query_time.json",
+        JSON.pretty_generate(detail)
+      )
+      puts "Total time spent in SQL: #{time}s (#{count} queries)"
+      puts "Detail per query kind available in tmp/query_time.json (total time in ms, avg time in ms, query count). Sorted by avg time."
+    }
+  end
+
+  # Remove content between single quotes and double quotes from keys
+  # to have a clear idea of which queries are being executed.
+  def clean_sql(sql)
+    sql.gsub(/".*?"/m, "\"...\"").gsub("''", "").gsub(/'.*?'/m, "'...'")
+  end
+end
+
+class ActiveRecord::TotalTimeSubscriber < ActiveRecord::LogSubscriber
+  def self.hash
+    @@hash
+  end
+
+  def sql(event)
+    # NOTE: If you want to debug a specific query, you can use a 'binding.irb' here with
+    # a specific condition on 'event.payload[:sql]' content.
+    #
+    #     binding.irb if event.payload[:sql].include?("attr.attname, nsp.nspname")
+    #
+    @@hash ||= {}
+    key = SQLLogger.clean_sql(event.payload[:sql])
+    @@hash[key] ||= []
+    @@hash[key].push event.duration
+  end
+end

data/test/support/template_creator.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require "activerecord-cockroachdb-adapter"
+require_relative 'paths_cockroachdb'
+require 'support/config' # ARTest.config
+require 'support/connection' # ARTest.connect
+
+module TemplateCreator
+  class DefaultDB < ActiveRecord::Base
+    establish_connection(
+      adapter: 'cockroachdb',
+      database: 'defaultdb',
+      port: 26257,
+      user: 'root',
+      host: 'localhost'
+    )
+  end
+
+  # Database created once the backup is finished to make sure we have a
+  # clean backup to work with. See #template_exists?
+  EXISTS = "exists"
+  BACKUP_DIR = "userfile://defaultdb.public/activerecord-crdb-adapter"
+
+  module_function
+
+  def template_version
+    ar_version = ActiveRecord.version.version.gsub('.','_')
+    main_schema_digest = Digest::MD5.file(SCHEMA_ROOT + "/schema.rb").hexdigest
+    crdb_schema_digest = Digest::MD5.file("#{__dir__}/../schema/cockroachdb_specific_schema.rb").hexdigest
+    "#{ar_version}_#{main_schema_digest}_#{crdb_schema_digest}"
+  end
+
+  def version_backup_path
+    BACKUP_DIR + "/#{template_version}"
+  end
+
+  def template_db_name(db_name)
+    "#{db_name}__template__#{template_version}"
+  end
+
+  def template_exists?
+    template_db_exists?(EXISTS)
+  end
+
+  def databases
+    @databases ||=ARTest.config.dig("connections", "cockroachdb").map { |_, value| value["database"] }.uniq
+  end
+
+  def with_template_db_names
+    old_crdb = ARTest.config["connections"]["cockroachdb"]
+    new_crdb = old_crdb.transform_values { _1.merge("database" => template_db_name(_1["database"])) }
+    ARTest.config["connections"]["cockroachdb"] = new_crdb
+    yield
+  ensure
+    ARTest.config["connections"]["cockroachdb"] = old_crdb
+  end
+
+  def template_db_exists?(db_name)
+    DefaultDB.lease_connection.select_value("SELECT 1 FROM pg_database WHERE datname='#{template_db_name(db_name)}'") == 1
+  end
+
+  def drop_template_db(db_name)
+    DefaultDB.lease_connection.execute("DROP DATABASE #{template_db_name(db_name)} CASCADE")
+  end
+
+  def create_template_db(db_name)
+    DefaultDB.lease_connection.execute("CREATE DATABASE #{template_db_name(db_name)}")
+  end
+
+  def create_test_template(&block)
+    databases.each do |db_name|
+      drop_template_db(db_name) if template_db_exists?(db_name)
+      create_template_db(db_name)
+    end
+
+    with_template_db_names do
+      shh { ARTest.connect }
+      block.call
+    end
+
+    DefaultDB.lease_connection.execute(<<~SQL)
+    BACKUP DATABASE #{databases.map { |db| template_db_name(db) }.join(', ')}
+    INTO '#{version_backup_path}'
+    SQL
+    create_template_db(EXISTS)
+  end
+
+  def load_from_template(&block)
+    create_test_template(&block) unless template_exists?
+    databases.each do |db_name|
+      begin
+        DefaultDB.lease_connection.execute("DROP DATABASE #{db_name}")
+      rescue ActiveRecord::StatementInvalid => e
+        unless e.cause.class == PG::InvalidCatalogName
+          raise e
+        end
+      end
+      DefaultDB.lease_connection.execute("CREATE DATABASE #{db_name}")
+      DefaultDB.lease_connection.execute(<<~SQL)
+      RESTORE #{template_db_name(db_name)}.*
+      FROM LATEST IN '#{version_backup_path}'
+      WITH into_db = '#{db_name}'
+      SQL
+    end
+  end
+
+  private def shh
+    original_stdout = $stdout
+    $stdout = StringIO.new
+    yield
+  ensure
+    $stdout = original_stdout
+  end
+end