activerecord-pg-extensions 0.4.4 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 45b4e3d0cf437ce75246b882697214a96cf89e44b2b28420b5dd215f243f5351
-  data.tar.gz: c49b15be7227aafe9de557cf78ef4d4938a842b72d28838f2c1bef59d49f1a7f
+  metadata.gz: 2f00b73b6ca45b6816eb823afa1cb16213baf9a9671d02c5633c4cf07fa92026
+  data.tar.gz: 84f12098d7d3d638671cdbcf32e9e1f4e56ece8b64cc799f167b2eff336cc7dd
 SHA512:
-  metadata.gz: 1123584bcfb35e545245c3274e3e1d485ff9080cf46fdcf1788eddbcc7477dcbdc4a3e66c7d3742d3f6f9b701599454b81e994bd8c228eeb77560698c0b2369e
-  data.tar.gz: 5fda99a4141dee1332a889f7123581ceb6ca5e321e064bff89e5015c63d50d73c1e0cb1c0f775ca1d67d29f4d04ff9a7bc7d98c02ea482efabfd8f28e4cb7c7a
+  metadata.gz: 414294a360874650bedada98a2ccb4fb73fe8f2eb85d2c020387280dd84739af6807c703c016f4c7027c030ffb2f57cc4a1e493104a08ec79b599993b36f56c1
+  data.tar.gz: 8333b90a0265330c6f9f99d8826839003086816726f041e685916254de9cecd89db4ee2b9815975080b40cdd9be784ddd24d1f96322a8bba12c6971c2f91f3a6

data/lib/active_record/pg_extensions/pessimistic_migrations.rb

@@ -27,10 +27,8 @@ module ActiveRecord
         end
         begin
           validate_constraint(table, temp_constraint_name)
-        rescue ActiveRecord::StatementInvalid => e
-          raise ActiveRecord::NotNullViolation.new(sql: e.sql, binds: e.binds) if e.cause.is_a?(PG::CheckViolation)
-
-          raise
+        rescue PG::CheckViolation => e
+          raise ActiveRecord::NotNullViolation.new(sql: e.sql, binds: e.binds)
         end
 
         transaction do
@@ -66,7 +64,7 @@ module ActiveRecord
       # will automatically remove a NOT VALID index before trying to add
       def add_index(table_name, column_name, **options)
         # catch a concurrent index add that fails because it already exists, and is invalid
-        if options[:algorithm] == :concurrently || options[:if_not_exists]
+        if options[:algorithm] == :concurrently && options[:if_not_exists]
           column_names = index_column_names(column_name)
           index_name = options[:name].to_s if options.key?(:name)
           index_name ||= index_name(table_name, column_names)
@@ -84,16 +82,26 @@ module ActiveRecord
               AND i.relnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = #{index[:schema]} )
             LIMIT 1
           SQL
-          if valid == false && options[:algorithm] == :concurrently
-            remove_index(table_name, name: index_name,
-                                     algorithm: :concurrently)
-          end
-          return if options[:if_not_exists] && valid == true
+          return if valid == true
+
+          remove_index(table_name, name: index_name, algorithm: :concurrently) if valid == false
         end
-        # Rails.version: can stop doing this in Rails 6.2, when it's natively supported
-        options.delete(:if_not_exists)
         super
       end
+
+      def add_check_constraint(table_name, expression, if_not_exists: false, **options)
+        return if if_not_exists && check_constraint_for(table_name, expression, **options)
+
+        super
+      end
+
+      if ActiveRecord.version < Gem::Version.new("7.1")
+        def remove_check_constraint(table_name, expression = nil, if_exists: false, **options)
+          return if if_exists && !check_constraint_for(table_name, expression, **options)
+
+          super
+        end
+      end
     end
   end
 end

data/lib/active_record/pg_extensions/postgresql_adapter.rb

@@ -9,8 +9,8 @@ module ActiveRecord
       # set constraint check timing for the current transaction
       # see https://www.postgresql.org/docs/current/sql-set-constraints.html
       def set_constraints(deferred, *constraints)
-        raise ArgumentError, "deferred must be :deferred or :immediate" unless %w[deferred
-                                                                                  immediate].include?(deferred.to_s)
+        raise ArgumentError, "deferred must be :deferred or :immediate" unless %i[deferred
+                                                                                  immediate].include?(deferred)
 
         constraints = constraints.map { |c| quote_table_name(c) }.join(", ")
         constraints = "ALL" if constraints.empty?
@@ -160,7 +160,7 @@ module ActiveRecord
             raise ArgumentError, "columns may only be specified if a analyze is specified" unless analyze
 
             table.map do |table_name, columns|
-              "#{quote_table_name(table_name)} (#{Array.wrap(columns).map { |c| quote_column_name(c) }.join(', ')})"
+              "#{quote_table_name(table_name)} (#{Array.wrap(columns).map { |c| quote_column_name(c) }.join(", ")})"
             end.join(", ")
           else
             quote_table_name(table)
@@ -182,35 +182,35 @@ module ActiveRecord
       def current_wal_lsn
         return nil unless wal?
 
-        select_value("SELECT #{pre_pg10_wal_function_name('pg_current_wal_lsn')}()")
+        select_value("SELECT #{pre_pg10_wal_function_name("pg_current_wal_lsn")}()")
       end
 
       # see https://www.postgresql.org/docs/current/functions-admin.html#id-1.5.8.33.5.5.2.2.2.1.1.1
       def current_wal_flush_lsn
         return nil unless wal?
 
-        select_value("SELECT #{pre_pg10_wal_function_name('pg_current_wal_flush_lsn')}()")
+        select_value("SELECT #{pre_pg10_wal_function_name("pg_current_wal_flush_lsn")}()")
       end
 
       # see https://www.postgresql.org/docs/current/functions-admin.html#id-1.5.8.33.5.5.2.2.3.1.1.1
       def current_wal_insert_lsn
         return nil unless wal?
 
-        select_value("SELECT #{pre_pg10_wal_function_name('pg_current_wal_insert_lsn')}()")
+        select_value("SELECT #{pre_pg10_wal_function_name("pg_current_wal_insert_lsn")}()")
       end
 
       # https://www.postgresql.org/docs/current/functions-admin.html#id-1.5.8.33.6.3.2.2.2.1.1.1
       def last_wal_receive_lsn
         return nil unless wal?
 
-        select_value("SELECT #{pre_pg10_wal_function_name('pg_last_wal_receive_lsn')}()")
+        select_value("SELECT #{pre_pg10_wal_function_name("pg_last_wal_receive_lsn")}()")
       end
 
       # see https://www.postgresql.org/docs/current/functions-admin.html#id-1.5.8.33.6.3.2.2.3.1.1.1
       def last_wal_replay_lsn
         return nil unless wal?
 
-        select_value("SELECT #{pre_pg10_wal_function_name('pg_last_wal_replay_lsn')}()")
+        select_value("SELECT #{pre_pg10_wal_function_name("pg_last_wal_replay_lsn")}()")
       end
 
       # see https://www.postgresql.org/docs/current/functions-admin.html#id-1.5.8.33.5.5.2.2.4.1.1.1
@@ -229,7 +229,7 @@ module ActiveRecord
           end
         end
 
-        select_value("SELECT #{pre_pg10_wal_function_name('pg_wal_lsn_diff')}(#{lsns[0]}, #{lsns[1]})")
+        select_value("SELECT #{pre_pg10_wal_function_name("pg_wal_lsn_diff")}(#{lsns[0]}, #{lsns[1]})")
       end
 
       def in_recovery?
@@ -238,7 +238,7 @@ module ActiveRecord
 
       def set(configuration_parameter, value, local: false)
         value = value.nil? ? "DEFAULT" : quote(value)
-        execute("SET#{' LOCAL' if local} #{configuration_parameter} TO #{value}")
+        execute("SET#{" LOCAL" if local} #{configuration_parameter} TO #{value}")
       end
 
       def reset(configuration_parameter)
@@ -274,65 +274,8 @@ module ActiveRecord
         end
       end
 
-      unless ::Rails.version >= "6.1"
-        def add_check_constraint(table_name, expression, name:, validate: true)
-          sql = +"ALTER TABLE #{quote_table_name(table_name)} ADD CONSTRAINT #{quote_column_name(name)} CHECK (#{expression})" # rubocop:disable Layout/LineLength
-          sql << " NOT VALID" unless validate
-          execute(sql)
-        end
-
-        def remove_check_constraint(table_name, name:)
-          execute("ALTER TABLE #{quote_table_name(table_name)} DROP CONSTRAINT #{quote_column_name(name)}")
-        end
-      end
-
       private
 
-      if ::Rails.version < "6.1"
-        # significant change: add PG::TextDecoder::Numeric
-        def add_pg_decoders
-          @default_timezone = nil
-          @timestamp_decoder = nil
-
-          coders_by_name = {
-            "int2" => PG::TextDecoder::Integer,
-            "int4" => PG::TextDecoder::Integer,
-            "int8" => PG::TextDecoder::Integer,
-            "oid" => PG::TextDecoder::Integer,
-            "float4" => PG::TextDecoder::Float,
-            "float8" => PG::TextDecoder::Float,
-            "bool" => PG::TextDecoder::Boolean,
-            "numeric" => PG::TextDecoder::Numeric
-          }
-
-          if defined?(PG::TextDecoder::TimestampUtc)
-            # Use native PG encoders available since pg-1.1
-            coders_by_name["timestamp"] = PG::TextDecoder::TimestampUtc
-            coders_by_name["timestamptz"] = PG::TextDecoder::TimestampWithTimeZone
-          end
-
-          known_coder_types = coders_by_name.keys.map { |n| quote(n) }
-          query = format(<<~SQL, *known_coder_types.join(", "))
-            SELECT t.oid, t.typname
-            FROM pg_type as t
-            WHERE t.typname IN (%s)
-          SQL
-          coders = execute_and_clear(query, "SCHEMA", []) do |result|
-            result
-              .map { |row| construct_coder(row, coders_by_name[row["typname"]]) }
-              .compact
-          end
-
-          map = PG::TypeMapByOid.new
-          coders.each { |coder| map.add_coder(coder) }
-          @connection.type_map_for_results = map
-
-          # extract timestamp decoder for use in update_typemap_for_default_timezone
-          @timestamp_decoder = coders.find { |coder| coder.name == "timestamp" }
-          update_typemap_for_default_timezone
-        end
-      end
-
       def initialize_type_map(map = type_map)
         map.register_type "pg_lsn", ActiveRecord::ConnectionAdapters::PostgreSQL::OID::SpecializedString.new(:pg_lsn)
 

data/lib/active_record/pg_extensions/version.rb

@@ -2,6 +2,6 @@
 
 module ActiveRecord
   module PGExtensions
-    VERSION = "0.4.4"
+    VERSION = "0.5.1"
   end
 end

metadata

@@ -1,55 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-pg-extensions
 version: !ruby/object:Gem::Version
-  version: 0.4.4
+  version: 0.5.1
 platform: ruby
 authors:
 - Cody Cutrer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-03-18 00:00:00.000000000 Z
+date: 2023-09-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '6.0'
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '7.1'
+        version: 7.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '6.0'
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '7.1'
+        version: 7.0.0
 - !ruby/object:Gem::Dependency
   name: railties
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '6.0'
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '7.1'
+        version: 7.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '6.0'
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '7.1'
+        version: 7.0.0
 - !ruby/object:Gem::Dependency
   name: appraisal
   requirement: !ruby/object:Gem::Requirement
@@ -121,19 +109,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '3.0'
 - !ruby/object:Gem::Dependency
-  name: rubocop
+  name: rubocop-inst
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '1'
 - !ruby/object:Gem::Dependency
   name: rubocop-rake
   requirement: !ruby/object:Gem::Requirement
@@ -172,7 +160,6 @@ files:
 - CHANGELOG.md
 - LICENSE.txt
 - README.md
-- config/database.yml
 - lib/active_record/pg_extensions.rb
 - lib/active_record/pg_extensions/all.rb
 - lib/active_record/pg_extensions/errors.rb
@@ -183,9 +170,6 @@ files:
 - lib/active_record/pg_extensions/transaction.rb
 - lib/active_record/pg_extensions/version.rb
 - lib/activerecord-pg-extensions.rb
-- spec/pessimistic_migrations_spec.rb
-- spec/postgresql_adapter_spec.rb
-- spec/spec_helper.rb
 homepage: https://github.com/instructure/activerecord-pg-extensions
 licenses:
 - MIT
@@ -200,19 +184,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.4.19
 signing_key:
 specification_version: 4
 summary: Several extensions to ActiveRecord's PostgreSQLAdapter.
-test_files:
-- spec/spec_helper.rb
-- spec/postgresql_adapter_spec.rb
-- spec/pessimistic_migrations_spec.rb
-- config/database.yml
+test_files: []

data/config/database.yml

@@ -1,3 +0,0 @@
-test:
-  adapter: postgresql
-  database: arpgextensions

data/spec/pessimistic_migrations_spec.rb

@@ -1,136 +0,0 @@
-# frozen_string_literal: true
-
-describe ActiveRecord::PGExtensions::PessimisticMigrations do
-  around do |example|
-    connection.dont_execute(&example)
-  end
-
-  describe "#change_column_null" do
-    # Rails 6.1 doesn't quote the constraint name when adding a check constraint??
-    def quote_constraint_name(name)
-      Rails.version >= "6.1" ? name : connection.quote_column_name(name)
-    end
-
-    it "does nothing extra when changing a column to nullable" do
-      connection.change_column_null(:table, :column, true)
-      expect(connection.executed_statements).to eq ['ALTER TABLE "table" ALTER COLUMN "column" DROP NOT NULL']
-    end
-
-    it "does nothing if we're in a transaction" do
-      connection.transaction do
-        connection.change_column_null(:table, :column, true)
-      end
-      expect(connection.executed_statements).to eq ["BEGIN",
-                                                    'ALTER TABLE "table" ALTER COLUMN "column" DROP NOT NULL',
-                                                    "COMMIT"]
-    end
-
-    it "skips entirely if the column is already NOT NULL" do
-      expect(connection).to receive(:columns).with(:table).and_return([double(name: "column", null: false)])
-      connection.change_column_null(:table, :column, false)
-      expect(connection.executed_statements).to eq([])
-    end
-
-    it "adds and removes a check constraint" do
-      expect(connection).to receive(:columns).and_return([])
-      allow(connection).to receive(:check_constraint_for!).and_return(double(name: "chk_rails_table_column_not_null"))
-      connection.change_column_null(:table, :column, false)
-
-      expect(connection.executed_statements).to eq [
-        "SELECT convalidated FROM pg_constraint INNER JOIN pg_namespace ON pg_namespace.oid=connamespace WHERE conname='chk_rails_table_column_not_null' AND nspname=ANY (current_schemas(false))\n", # rubocop:disable Layout/LineLength
-        %{ALTER TABLE "table" ADD CONSTRAINT #{quote_constraint_name('chk_rails_table_column_not_null')} CHECK ("column" IS NOT NULL) NOT VALID}, # rubocop:disable Layout/LineLength
-        'ALTER TABLE "table" VALIDATE CONSTRAINT "chk_rails_table_column_not_null"',
-        "BEGIN",
-        'ALTER TABLE "table" ALTER COLUMN "column" SET NOT NULL',
-        'ALTER TABLE "table" DROP CONSTRAINT "chk_rails_table_column_not_null"',
-        "COMMIT"
-      ]
-    end
-
-    it "verifies an existing check constraint" do
-      expect(connection).to receive(:columns).and_return([])
-      allow(connection).to receive(:check_constraint_for!).and_return(double(name: "chk_rails_table_column_not_null"))
-      expect(connection).to receive(:select_value).and_return(false)
-      connection.change_column_null(:table, :column, false)
-
-      expect(connection.executed_statements).to eq [
-        # stubbed out <check constraint valid>
-        'ALTER TABLE "table" VALIDATE CONSTRAINT "chk_rails_table_column_not_null"',
-        "BEGIN",
-        'ALTER TABLE "table" ALTER COLUMN "column" SET NOT NULL',
-        'ALTER TABLE "table" DROP CONSTRAINT "chk_rails_table_column_not_null"',
-        "COMMIT"
-      ]
-    end
-  end
-
-  describe "#add_foreign_key" do
-    it "does nothing extra if a transaction is already active" do
-      connection.transaction do
-        connection.add_foreign_key :emails, :users, delay_validation: true
-      end
-      expect(connection.executed_statements).to match(
-        ["BEGIN",
-         match(/\AALTER TABLE "emails" ADD CONSTRAINT "fk_rails_[0-9a-f]+".+REFERENCES "users" \("id"\)\s*\z/m),
-         "COMMIT"]
-      )
-    end
-
-    it "delays validation" do
-      connection.add_foreign_key :emails, :users, delay_validation: true
-      expect(connection.executed_statements).to match(
-        [/convalidated/,
-         match(/\AALTER TABLE "emails" ADD CONSTRAINT "[a-z0-9_]+".+REFERENCES "users" \("id"\)\s+NOT VALID\z/m),
-         match(/^ALTER TABLE "emails" VALIDATE CONSTRAINT "fk_rails_[0-9a-f]+"/)]
-      )
-    end
-
-    it "only validates if the constraint already exists, and is not valid" do
-      expect(connection).to receive(:select_value).with(/convalidated/, "SCHEMA").and_return(false)
-      connection.add_foreign_key :emails, :users, delay_validation: true
-      expect(connection.executed_statements).to match(
-        [match(/^ALTER TABLE "emails" VALIDATE CONSTRAINT "fk_rails_[0-9a-f]+"/)]
-      )
-    end
-
-    it "does nothing if constraint already exists" do
-      expect(connection).to receive(:select_value).with(/convalidated/, "SCHEMA").and_return(true)
-      connection.add_foreign_key :emails, :users, if_not_exists: true
-      expect(connection.executed_statements).to eq []
-    end
-
-    it "still tries if delay_validation is true but if_not_exists is false and it already exists" do
-      expect(connection).to receive(:select_value).with(/convalidated/, "SCHEMA").and_return(true)
-      connection.add_foreign_key :emails, :users, delay_validation: true
-      expect(connection.executed_statements).to match(
-        [match(/\AALTER TABLE "emails" ADD CONSTRAINT "[a-z0-9_]+".+REFERENCES "users" \("id"\)\s+NOT VALID\z/m),
-         match(/^ALTER TABLE "emails" VALIDATE CONSTRAINT "fk_rails_[0-9a-f]+"/)]
-      )
-    end
-
-    it "does nothing if_not_exists is true and it is NOT VALID" do
-      expect(connection).to receive(:select_value).with(/convalidated/, "SCHEMA").and_return(false)
-      connection.add_foreign_key :emails, :users, if_not_exists: true
-      expect(connection.executed_statements).to eq []
-    end
-  end
-
-  describe "#add_index" do
-    it "removes a NOT VALID index before re-adding" do
-      expect(connection).to receive(:select_value).with(/indisvalid/, "SCHEMA").and_return(false)
-      expect(connection).to receive(:remove_index).with(:users, name: "index_users_on_name", algorithm: :concurrently)
-
-      connection.add_index :users, :name, algorithm: :concurrently
-      expect(connection.executed_statements).to match(
-        [match(/\ACREATE +INDEX CONCURRENTLY "index_users_on_name" ON "users" +\("name"\)\z/)]
-      )
-    end
-
-    it "does nothing if the index already exists" do
-      expect(connection).to receive(:select_value).with(/indisvalid/, "SCHEMA").and_return(true)
-
-      connection.add_index :users, :name, if_not_exists: true
-      expect(connection.executed_statements).to eq []
-    end
-  end
-end

data/spec/postgresql_adapter_spec.rb

@@ -1,457 +0,0 @@
-# frozen_string_literal: true
-
-describe ActiveRecord::ConnectionAdapters::PostgreSQLAdapter do
-  before do
-    allow(connection).to receive(:reload_type_map)
-  end
-
-  describe "#set_constraints" do
-    around do |example|
-      connection.dont_execute(&example)
-    end
-
-    it "requires :deferred or :immediate" do
-      expect { connection.set_constraints("garbage") }.to raise_error(ArgumentError)
-    end
-
-    it "defaults to all" do
-      connection.set_constraints(:deferred)
-      expect(connection.executed_statements).to eq ["SET CONSTRAINTS ALL DEFERRED"]
-    end
-
-    it "quotes constraints" do
-      connection.set_constraints(:deferred, :my_fk)
-      expect(connection.executed_statements).to eq ['SET CONSTRAINTS "my_fk" DEFERRED']
-    end
-
-    it "quotes multiple constraints" do
-      connection.set_constraints(:deferred, :my_fk1, :my_fk2)
-      expect(connection.executed_statements).to eq ['SET CONSTRAINTS "my_fk1", "my_fk2" DEFERRED']
-    end
-  end
-
-  describe "#defer_constraints" do
-    around do |example|
-      connection.dont_execute(&example)
-    end
-
-    it "defers and resets" do
-      block_called = false
-      connection.defer_constraints do
-        block_called = true
-      end
-      expect(block_called).to eq true
-      expect(connection.executed_statements).to eq ["SET CONSTRAINTS ALL DEFERRED", "SET CONSTRAINTS ALL IMMEDIATE"]
-    end
-  end
-
-  describe "#set_replica_identity" do
-    around do |example|
-      connection.dont_execute(&example)
-    end
-
-    it "resets identity" do
-      connection.set_replica_identity(:my_table)
-      expect(connection.executed_statements).to eq ['ALTER TABLE "my_table" REPLICA IDENTITY DEFAULT']
-    end
-
-    it "sets full identity" do
-      connection.set_replica_identity(:my_table, :full)
-      expect(connection.executed_statements).to eq ['ALTER TABLE "my_table" REPLICA IDENTITY FULL']
-    end
-
-    it "sets an index" do
-      connection.set_replica_identity(:my_table, :my_index)
-      expect(connection.executed_statements).to eq ['ALTER TABLE "my_table" REPLICA IDENTITY USING INDEX "my_index"']
-    end
-  end
-
-  context "extensions" do
-    it "creates and drops an extension" do
-      connection.create_extension(:pg_trgm, schema: "public")
-      expect(connection.executed_statements).to eq ["CREATE EXTENSION pg_trgm SCHEMA public"]
-      expect(ext = connection.extension(:pg_trgm)).not_to be_nil
-      expect(ext.schema).to eq "public"
-      expect(ext.version).not_to be_nil
-      expect(ext.name).to eq "pg_trgm"
-    ensure
-      connection.executed_statements.clear
-      connection.drop_extension(:pg_trgm, if_exists: true)
-      expect(connection.executed_statements).to eq ["DROP EXTENSION IF EXISTS pg_trgm"]
-      expect(connection.extension(:pg_trgm)).to be_nil
-    end
-
-    it "doesn't try to recreate" do
-      connection.create_extension(:pg_trgm, schema: "public")
-      connection.create_extension(:pg_trgm, schema: "public", if_not_exists: true)
-      expect(connection.executed_statements).to eq ["CREATE EXTENSION pg_trgm SCHEMA public",
-                                                    "CREATE EXTENSION IF NOT EXISTS pg_trgm SCHEMA public"]
-    ensure
-      connection.drop_extension(:pg_trgm, if_exists: true)
-    end
-
-    context "non-executing" do
-      around do |example|
-        connection.dont_execute(&example)
-      end
-
-      it "supports all options on create" do
-        connection.create_extension(:my_extension, if_not_exists: true, schema: "public", version: "2.0", cascade: true)
-        expect(connection.executed_statements).to eq(
-          ["CREATE EXTENSION IF NOT EXISTS my_extension SCHEMA public VERSION '2.0' CASCADE"]
-        )
-      end
-
-      it "supports all options on drop" do
-        connection.drop_extension(:my_extension, if_exists: true, cascade: true)
-        expect(connection.executed_statements).to eq ["DROP EXTENSION IF EXISTS my_extension CASCADE"]
-      end
-
-      it "can update an extensions" do
-        connection.alter_extension(:my_extension, version: true)
-        expect(connection.executed_statements).to eq ["ALTER EXTENSION my_extension UPDATE"]
-      end
-
-      it "can update to a specific version" do
-        connection.alter_extension(:my_extension, version: "2.0")
-        expect(connection.executed_statements).to eq ["ALTER EXTENSION my_extension UPDATE TO '2.0'"]
-      end
-
-      it "can change schemas" do
-        connection.alter_extension(:my_extension, schema: "my_app")
-        expect(connection.executed_statements).to eq ["ALTER EXTENSION my_extension SET SCHEMA my_app"]
-      end
-
-      it "cannot change schema and update" do
-        expect { connection.alter_extension(:my_extension, schema: "my_app", version: "2.0") }
-          .to raise_error(ArgumentError)
-      end
-
-      it "can drop multiple extensions" do
-        connection.drop_extension(:my_extension1, :my_extension2)
-        expect(connection.executed_statements).to eq ["DROP EXTENSION my_extension1, my_extension2"]
-      end
-
-      it "does not allow dropping no extensions" do
-        expect { connection.drop_extension }.to raise_error(ArgumentError)
-      end
-
-      describe "#extension_available?" do
-        it "works with no version constraint" do
-          connection.extension_available?(:postgis)
-          expect(connection.executed_statements).to eq ["SELECT 1 FROM pg_available_extensions WHERE name='postgis'"]
-        end
-
-        it "works with a version constraint" do
-          connection.extension_available?(:postgis, "2.0")
-          expect(connection.executed_statements).to eq(
-            ["SELECT 1 FROM pg_available_extension_versions WHERE name='postgis' AND version='2.0'"]
-          )
-        end
-      end
-    end
-  end
-
-  describe "#add_schema_to_search_path" do
-    around do |example|
-      original_search_path = connection.schema_search_path
-      connection.schema_search_path = "public"
-      example.call
-    ensure
-      connection.schema_search_path = original_search_path
-    end
-
-    it "adds a schema to search path" do
-      connection.add_schema_to_search_path("postgis") do
-        expect(connection.schema_search_path).to eq "public,postgis"
-      end
-      expect(connection.schema_search_path).to eq "public"
-    end
-
-    it "doesn't duplicate an existing schema" do
-      connection.add_schema_to_search_path("public") do
-        expect(connection.schema_search_path).to eq "public"
-      end
-      expect(connection.schema_search_path).to eq "public"
-    end
-
-    it "is cleaned up properly when the transaction rolls back manually" do
-      expect do
-        connection.add_schema_to_search_path("postgis") do
-          raise ActiveRecord::Rollback
-        end
-      end.to raise_error(ActiveRecord::Rollback)
-      expect(connection.schema_search_path).to eq "public"
-    end
-
-    it "is cleaned up properly when the transaction rolls back" do
-      expect do
-        connection.add_schema_to_search_path("postgis") do
-          connection.execute("gibberish")
-        end
-      end.to raise_error(ActiveRecord::StatementInvalid)
-      expect(connection.schema_search_path).to eq "public"
-    end
-  end
-
-  describe "#vacuum" do
-    it "does a straight vacuum of everything" do
-      connection.vacuum
-      expect(connection.executed_statements).to eq ["VACUUM"]
-    end
-
-    it "supports several options" do
-      connection.vacuum(analyze: true, verbose: true)
-      expect(connection.executed_statements).to eq ["VACUUM VERBOSE ANALYZE"]
-    end
-
-    it "validates parallel option is an integer" do
-      expect { connection.vacuum(parallel: :garbage) }.to raise_error(ArgumentError)
-    end
-
-    it "validates parallel option is postive" do
-      expect { connection.vacuum(parallel: -1) }.to raise_error(ArgumentError)
-    end
-
-    context "non-executing" do
-      around do |example|
-        connection.dont_execute(&example)
-      end
-
-      it "vacuums a table" do
-        connection.vacuum(:my_table)
-        expect(connection.executed_statements).to eq ['VACUUM "my_table"']
-      end
-
-      it "vacuums multiple tables" do
-        connection.vacuum(:table1, :table2)
-        expect(connection.executed_statements).to eq ['VACUUM "table1", "table2"']
-      end
-
-      it "requires analyze with specific columns" do
-        expect { connection.vacuum({ my_table: :column1 }) }.to raise_error(ArgumentError)
-      end
-
-      it "analyzes a specific column" do
-        connection.vacuum({ my_table: :column }, analyze: true)
-        expect(connection.executed_statements).to eq ['VACUUM ANALYZE "my_table" ("column")']
-      end
-
-      it "analyzes multiples columns" do
-        connection.vacuum({ my_table: %i[column1 column2] }, analyze: true)
-        expect(connection.executed_statements).to eq ['VACUUM ANALYZE "my_table" ("column1", "column2")']
-      end
-
-      it "analyzes a mixture of tables and columns" do
-        connection.vacuum(:table1, { my_table: %i[column1 column2] }, analyze: true)
-        expect(connection.executed_statements).to eq ['VACUUM ANALYZE "table1", "my_table" ("column1", "column2")']
-      end
-    end
-
-    describe "#wal_lsn_diff" do
-      skip unless connection.wal?
-
-      it "executes" do
-        expect(connection.wal_lsn_diff(:current, :current)).to eq 0
-      end
-    end
-
-    describe "#in_recovery?" do
-      it "works" do
-        expect(connection.in_recovery?).to eq false
-      end
-    end
-
-    describe "#select_value" do
-      it "casts numeric types" do
-        expect(connection.select_value("SELECT factorial(2)")).to eq 2
-      end
-    end
-  end
-
-  describe "#with_statement_timeout" do
-    around do |example|
-      # these specs were written before we supported deferring setting timeouts
-      # until the transaction materializes
-      connection.disable_lazy_transactions!
-      example.call
-      connection.enable_lazy_transactions!
-    end
-
-    it "stops long-running queries" do
-      expect do
-        connection.with_statement_timeout(0.01) do
-          connection.execute("SELECT pg_sleep(3)")
-        end
-      end.to raise_error(ActiveRecord::QueryCanceled)
-    end
-
-    it "re-raises other errors" do
-      expect do
-        connection.with_statement_timeout(1) do
-          connection.execute("bad sql")
-        end
-      end.to(raise_error { |e| expect(e.cause).to be_a(PG::SyntaxError) })
-    end
-
-    context "without executing" do
-      around do |example|
-        connection.dont_execute(&example)
-      end
-
-      it "converts integer to ms" do
-        connection.with_statement_timeout(30) { nil }
-        expect(connection.executed_statements).to eq(
-          [
-            "BEGIN",
-            "SET LOCAL statement_timeout TO '30000ms'",
-            "COMMIT"
-          ]
-        )
-      end
-
-      it "converts float to ms" do
-        connection.with_statement_timeout(5.5) { nil }
-        expect(connection.executed_statements).to eq(
-          [
-            "BEGIN",
-            "SET LOCAL statement_timeout TO '5500ms'",
-            "COMMIT"
-          ]
-        )
-      end
-
-      it "converts ActiveSupport::Duration to ms" do
-        connection.with_statement_timeout(5.seconds) { nil }
-        expect(connection.executed_statements).to eq(
-          [
-            "BEGIN",
-            "SET LOCAL statement_timeout TO '5000ms'",
-            "COMMIT"
-          ]
-        )
-      end
-
-      it "allows true" do
-        connection.with_statement_timeout(true) { nil }
-        expect(connection.executed_statements).to eq(
-          [
-            "BEGIN",
-            "SET LOCAL statement_timeout TO '30000ms'",
-            "COMMIT"
-          ]
-        )
-      end
-    end
-  end
-
-  describe "#statement_timeout=" do
-    around do |example|
-      connection.dont_execute(&example)
-    end
-
-    it "raises if a transaction isn't active" do
-      expect { connection.statement_timeout = 30 }.to raise_error(ArgumentError)
-    end
-
-    it "does nothing if the transaction never materializes" do
-      connection.transaction do
-        connection.statement_timeout = 30
-        expect(connection.statement_timeout).to eq 30
-      end
-      expect(connection.statement_timeout).to be_nil
-
-      expect(connection.executed_statements).to be_empty
-    end
-
-    it "sets the timeout if the transaction is materialized" do
-      connection.transaction do
-        connection.select_value("SELECT 1")
-        connection.statement_timeout = 30
-        expect(connection.statement_timeout).to eq 30
-      end
-      expect(connection.statement_timeout).to be_nil
-
-      expect(connection.executed_statements).to eq(
-        ["BEGIN",
-         "SELECT 1",
-         "SET LOCAL statement_timeout TO '30000ms'",
-         "COMMIT"]
-      )
-    end
-
-    it "sets the timeout if the transaction materializes" do
-      connection.transaction do
-        connection.statement_timeout = 30
-        connection.select_value("SELECT 1")
-        expect(connection.statement_timeout).to eq 30
-      end
-      expect(connection.statement_timeout).to be_nil
-
-      expect(connection.executed_statements).to eq(
-        ["BEGIN",
-         "SET LOCAL statement_timeout TO '30000ms'",
-         "SELECT 1",
-         "COMMIT"]
-      )
-    end
-
-    it "works with nested transactions" do
-      connection.transaction do
-        connection.statement_timeout = 30
-        connection.transaction(requires_new: true) do
-          connection.statement_timeout = 15
-          connection.select_value("SELECT 1")
-          expect(connection.statement_timeout).to eq 15
-        end
-        expect(connection.statement_timeout).to eq 30
-      end
-      expect(connection.statement_timeout).to be_nil
-
-      expect(connection.executed_statements).to eq(
-        ["BEGIN",
-         "SET LOCAL statement_timeout TO '30000ms'",
-         "SAVEPOINT active_record_1",
-         "SET LOCAL statement_timeout TO '15000ms'",
-         "SELECT 1",
-         "RELEASE SAVEPOINT active_record_1",
-         "COMMIT"]
-      )
-    end
-  end
-
-  unless Rails.version >= "6.1"
-    describe "#add_check_constraint" do
-      around do |example|
-        connection.dont_execute(&example)
-      end
-
-      it "works" do
-        connection.add_check_constraint(:table, "column IS NOT NULL", name: :my_constraint)
-        expect(connection.executed_statements).to eq(
-          ['ALTER TABLE "table" ADD CONSTRAINT "my_constraint" CHECK (column IS NOT NULL)']
-        )
-      end
-
-      it "defers validation" do
-        connection.add_check_constraint(:table, "column IS NOT NULL", name: :my_constraint, validate: false)
-        expect(connection.executed_statements).to eq(
-          ['ALTER TABLE "table" ADD CONSTRAINT "my_constraint" CHECK (column IS NOT NULL) NOT VALID']
-        )
-      end
-    end
-
-    describe "#remove_check_constraint" do
-      around do |example|
-        connection.dont_execute(&example)
-      end
-
-      it "works" do
-        connection.remove_check_constraint(:table, name: :my_constraint)
-        expect(connection.executed_statements).to eq(
-          ['ALTER TABLE "table" DROP CONSTRAINT "my_constraint"']
-        )
-      end
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-require "activerecord-pg-extensions"
-require "byebug"
-require "active_record/railtie"
-require "active_record/pg_extensions/all"
-
-ActiveRecord::Base # rubocop:disable Lint/Void
-Rails.env = "test"
-
-class Application < Rails::Application
-  config.eager_load = false
-end
-Application.initialize!
-
-ActiveRecord::Tasks::DatabaseTasks.create_all
-
-module StatementCaptureConnection
-  def dont_execute
-    @dont_execute = true
-    yield
-  ensure
-    @dont_execute = false
-  end
-
-  def executed_statements
-    @executed_statements ||= []
-  end
-
-  %w[execute exec_no_cache exec_cache].each do |method|
-    class_eval <<-RUBY, __FILE__, __LINE__ + 1
-      def #{method}(statement, *#{Rails.version >= '7.0' ? ', **kwargs' : ''})
-        materialize_transactions # this still needs to get called, even if we skip actually executing
-        executed_statements << statement
-        return empty_pg_result if @dont_execute
-
-        super
-      end
-    RUBY
-  end
-
-  # we can't actually generate a dummy one of these, so we just query the db with something
-  # that won't return anything
-  def empty_pg_result
-    @connection.async_exec("SELECT 0 WHERE FALSE")
-  end
-end
-ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.prepend(StatementCaptureConnection)
-
-RSpec.configure do |config|
-  config.expect_with :rspec do |c|
-    c.syntax = :expect
-  end
-
-  def connection
-    ActiveRecord::Base.connection
-  end
-
-  config.before do
-    connection.executed_statements.clear
-  end
-end