activerecord_views 0.0.20 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b7bd9cd5324106a6834c7121d6dc674bb622a61866edcecd968a0ed87b2000c2
-  data.tar.gz: 850fcbff468562ace2ae45a4cf8a9f255ef0e9dcc26be6efba8191247731b4b3
+  metadata.gz: 67e33c3b91d943b9fec0cf41b263302025ae787d41fe9404724cfd93c0105c73
+  data.tar.gz: 29b11133c94e86c16563083c1176616da9988fe9493fd69e8f2201436edded43
 SHA512:
-  metadata.gz: a87e872a8469f95873acf78c06ab136156514c70d0fecf63da7f0a6038ebd39cd75e0a79b52786abcff8f5b23fc443dd8393d0a6f96d57d23864c846fce1df28
-  data.tar.gz: 6bf70cae5bffa0791d9d5ad82ea931cb06b02e893d19fd801c33b5401f841e2b5cb01ed88574762a6448f2ec3e0d9e0e0310139ec25a1105b7cb6858b7cb2eeb
+  metadata.gz: 194ac35e51118b4d57956d083d5bff2fc859c6b1bcc09ccfde564fa3425dade51caa53835676f676b3c26999b138ee81710a5d5d0c605f90fbdaebf718b0e89f
+  data.tar.gz: a611fff391e863d46580cd6dea1c02e95d14660a3e900212e624a162f9a99a7879ddfe6c5be709a902f44930c9c3c02ebf58cde1b67cd46d23bf141816b392d2

data/.gitignore

@@ -1,6 +1,8 @@
 .bundle
+tmp/**
 Gemfile.lock
 gemfiles/*.gemfile.lock
 pkg
 spec/internal/db/schema.rb
+spec/internal/app/models_temp/**
 spec/internal/log/*.log

data/.tool-versions

@@ -0,0 +1 @@
+ruby 2.6.7

data/Appraisals

@@ -1,9 +1,11 @@
 appraise 'rails4_2' do
   gem 'rails', '~> 4.2.0'
+  gem "pg", "< 0.21"
 end
 
 appraise 'rails5_0' do
   gem 'rails', '~> 5.0.0'
+  gem "pg", "< 1.0"
 end
 
 appraise 'rails5_1' do
@@ -13,3 +15,11 @@ end
 appraise 'rails5_2' do
   gem 'rails', '~> 5.2.0'
 end
+
+appraise 'rails6_0' do
+  gem 'rails', '~> 6.0.0'
+end
+
+appraise 'rails6_1' do
+  gem 'rails', '~> 6.1.0'
+end

data/README.markdown

@@ -23,7 +23,7 @@ gem 'activerecord_views'
 app/models/account.rb:
 
 ```ruby
-class Account < ActiveRecord::Base
+class Account < ApplicationRecord
   has_many :transactions
 
   has_one :account_balance
@@ -34,7 +34,7 @@ end
 app/models/transaction.rb:
 
 ```ruby
-class Transaction < ActiveRecord::Base
+class Transaction < ApplicationRecord
   belongs_to :account
 end
 ```
@@ -42,7 +42,7 @@ end
 app/models/account_balance.rb:
 
 ```ruby
-class AccountBalance < ActiveRecord::Base
+class AccountBalance < ApplicationRecord
   is_view
 
   belongs_to :account
@@ -70,7 +70,7 @@ end
 
 ## Dependencies
 
-You can use an view model from another view model or within SQL blocks in your application code.
+You can use a view model from another view model or within SQL blocks in your application code.
 In order to ensure the model file is loaded (and thus the view is created), you should reference
 the model class when you use the view rather than using the database table name directly:
 
@@ -88,11 +88,11 @@ a safety check which will require you to specify the dependency explicitly if yo
 to another view model:
 
 ```ruby
-class AccountBalance < ActiveRecord::Base
+class AccountBalance < ApplicationRecord
   is_view
 end
 
-class AccountSummary < ActiveRecord::Base
+class AccountSummary < ApplicationRecord
   is_view dependencies: [AccountBalance]
 end
 ```
@@ -106,7 +106,7 @@ Materialized views let you cache the output of views. This is useful for views w
 To configure an ActiveRecordViews model as being materialized, pass the `materialized: true` option to `is_view`:
 
 ```ruby
-class AccountBalance < ActiveRecord::Base
+class AccountBalance < ApplicationRecord
   is_view materialized: true
 end
 ```
@@ -121,24 +121,34 @@ AccountBalance.refresh_view!
 AccountBalance.view_populated? # => true
 ```
 
-ActiveRecordViews records when a view was last refreshed. This is often useful for giving users an idea of how stale data. To retrieve this timestamp, call `.refreshed_at` on the model:
+ActiveRecordViews records when a view was last refreshed. This is often useful for giving users an idea of how old the cached data is. To retrieve this timestamp, call `.refreshed_at` on the model:
 
 ActiveRecordViews also has a convenience method called `ensure_populated!` which checks all materialized views in a chain of dependencies have been initially populated. This can be used as a safeguard to lazily populate views on demand. You will probably also setup a schedule to periodically refresh the view data when it gets stale.
 
 PostgreSQL 9.4 supports refreshing materialized views concurrently. This allows other processes to continue reading old cached data while the view is being updated. To use this feature you must have define a unique index on the materialized view:
 
-```sql
-class AccountBalance < ActiveRecord::Base
+```ruby
+class AccountBalance < ApplicationRecord
   is_view materialized: true, unique_columns: %w[account_id]
 end
 ```
 
 Note: If your view has a single column as the unique key, you can also tell ActiveRecord about it by adding `self.primary_key = :account_id` in your model file. This is required for features such as `.find` and `.find_each` to work.
 
-Once you have defined the unique columns for the view, you can then use `concurrent: true` to force a concurrent refresh or `concurrent: :auto` to concurrently refresh when possible:
+Once you have defined the unique columns for the view, ActiveRecordViews will automatically start refreshing concurrently when you call `refresh_view!`. If you wish to force a non-concurrent refresh, which is typically faster but blocks reads while the view is refreshing, you can then use the `concurrent: false` option:
 
 ```ruby
-AccountBalance.refresh_view! concurrent: :auto
+AccountBalance.refresh_view! concurrent: false
+```
+
+### Resetting all materialised views
+
+If you are using [Database Cleaner](https://github.com/DatabaseCleaner/database_cleaner) in your test suite,
+you probably also want to reset the contents of materialised views for each test run to ensure state
+does not leak between tests. You can do this with the following in your test suite hooks:
+
+```ruby
+ActiveRecordViews.reset_materialized_views
 ```
 
 ## Pre-populating views in Rails development mode
@@ -153,9 +163,11 @@ Rails.application.eager_load!
 
 ## Handling renames/deletions
 
-ActiveRecordViews tracks database views by their name. When an ActiveRecordViews model is renamed or deleted, there is no longer a link between the model and the associated database table. This means an orphan view will be left in the database.
+ActiveRecordViews tracks database views by their name. When an ActiveRecordViews model is renamed or deleted, there is no longer a link between the model and the associated database table. This means an orphan view would be left in the database.
 
-In order to keep things tidy and to avoid accidentally referencing a stale view, you should remove the view and associated ActiveRecordViews metadata when renaming or deleting a model using ActiveRecordViews. This is best done with a database migration (use `rails generate migration`) containing the following:
+ActiveRecordViews will automatically drop deleted views while checking for changes in both production mode when migrations are run and in development mode when code reloads (e.g. refreshing the browser).
+
+You should avoid dropping views using `DROP VIEW` as this will cause the internal state of ActiveRecordViews to become out of sync. If you want to drop an existing view manually you can instead run the following:
 
 ```ruby
 ActiveRecordViews.drop_view connection, 'account_balances'
@@ -167,6 +179,8 @@ Alternatively, all view models can be dropped with the following:
 ActiveRecordViews.drop_all_views connection
 ```
 
+Dropping all views is most useful when doing significant structual changes. Both methods can be used in migrations where there are incompatible dependency changes that would otherwise error. ActiveRecordViews will automatically recreate views again when it next checks for pending changes (e.g. production migrations or dev reloading).
+
 ## Usage outside of Rails
 
 When included in a Ruby on Rails project, ActiveRecordViews will automatically detect `.sql` files alongside models in `app/models`.

data/activerecord_views.gemspec

@@ -17,10 +17,12 @@ Gem::Specification.new do |gem|
   gem.test_files = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ['lib']
 
-  gem.add_dependency 'activerecord', ['>= 4.2', '< 5.3']
+  gem.add_dependency 'activerecord', ['>= 4.2', '< 6.2']
 
   gem.add_development_dependency 'appraisal'
   gem.add_development_dependency 'rspec-rails', '>= 2.14'
+  gem.add_development_dependency 'super_diff'
   gem.add_development_dependency 'combustion', '>= 0.5.1'
   gem.add_development_dependency 'pg'
+  gem.add_development_dependency 'warning'
 end

data/gemfiles/rails4_2.gemfile

@@ -3,5 +3,6 @@
 source "https://rubygems.org"
 
 gem "rails", "~> 4.2.0"
+gem "pg", "< 0.21"
 
 gemspec path: "../"

data/gemfiles/rails5_0.gemfile

@@ -3,5 +3,6 @@
 source "https://rubygems.org"
 
 gem "rails", "~> 5.0.0"
+gem "pg", "< 1.0"
 
 gemspec path: "../"

data/gemfiles/rails6_0.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rails", "~> 6.0.0"
+
+gemspec path: "../"

data/gemfiles/rails6_1.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rails", "~> 6.1.0"
+
+gemspec path: "../"

data/lib/active_record_views/checksum_cache.rb

@@ -13,12 +13,13 @@ module ActiveRecordViews
       end
 
       if table_exists && !@connection.column_exists?('active_record_views', 'class_name')
-        @connection.transaction :requires_new => true do
-          @connection.select_values('SELECT name FROM active_record_views;').each do |view_name|
-            @connection.execute "DROP VIEW IF EXISTS #{view_name} CASCADE;"
-          end
-          @connection.execute 'DROP TABLE active_record_views;'
+        @connection.begin_transaction
+        in_transaction = true
+
+        @connection.select_values('SELECT name FROM active_record_views;').each do |view_name|
+          @connection.execute "DROP VIEW IF EXISTS #{view_name} CASCADE;"
         end
+        @connection.execute 'DROP TABLE active_record_views;'
         table_exists = false
       end
 
@@ -33,6 +34,9 @@ module ActiveRecordViews
       unless table_exists
         @connection.execute "CREATE TABLE active_record_views(name text PRIMARY KEY, class_name text NOT NULL UNIQUE, checksum text NOT NULL, options json NOT NULL DEFAULT '{}', refreshed_at timestamp);"
       end
+
+    ensure
+      @connection.commit_transaction if in_transaction
     end
 
     def get(name)

data/lib/active_record_views/extension.rb

@@ -16,12 +16,6 @@ module ActiveRecordViews
       end
     end
 
-    def self.currently_migrating?
-      if defined?(Rake) && Rake.respond_to?(:application)
-        Rake.application.top_level_tasks.any? { |task_name| task_name =~ /^db:migrate($|:)/ }
-      end
-    end
-
     module ClassMethods
       def is_view(*args)
         cattr_accessor :view_options
@@ -33,11 +27,11 @@ module ActiveRecordViews
         sql ||= begin
           sql_path = ActiveRecordViews.find_sql_file(self.name.underscore)
           ActiveRecordViews.register_for_reload self, sql_path
-          ActiveRecordViews.read_sql_file(sql_path)
+          ActiveRecordViews.read_sql_file(self, sql_path)
         end
 
         create_args = [self.table_name, self.name, sql, self.view_options]
-        if ActiveRecordViews::Extension.create_enabled && !ActiveRecordViews::Extension.currently_migrating?
+        if ActiveRecordViews::Extension.create_enabled
           ActiveRecordViews.create_view self.connection, *create_args
         else
           ActiveRecordViews::Extension.create_queue << create_args
@@ -47,13 +41,13 @@ module ActiveRecordViews
       def refresh_view!(options = {})
         options.assert_valid_keys :concurrent
 
-        concurrent = case options[:concurrent]
-        when nil, false
+        concurrent = case options.fetch(:concurrent, :auto)
+        when false
           false
         when true
           true
         when :auto
-          view_populated? && ActiveRecordViews.supports_concurrent_refresh?(connection)
+          view_options.fetch(:unique_columns, nil) && view_populated? && ActiveRecordViews.supports_concurrent_refresh?(connection)
         else
           raise ArgumentError, 'invalid concurrent option'
         end
@@ -61,6 +55,7 @@ module ActiveRecordViews
         connection.transaction do
           connection.execute "REFRESH MATERIALIZED VIEW#{' CONCURRENTLY' if concurrent} #{connection.quote_table_name self.table_name};"
           connection.execute "UPDATE active_record_views SET refreshed_at = current_timestamp AT TIME ZONE 'UTC' WHERE name = #{connection.quote self.table_name};"
+          connection.clear_query_cache
         end
       end
 
@@ -89,9 +84,11 @@ module ActiveRecordViews
           WHERE name = #{connection.quote self.table_name};
         SQL
 
-        if value
-          ActiveSupport::TimeZone['UTC'].parse(value)
+        if value.is_a? String
+          value = ActiveSupport::TimeZone['UTC'].parse(value)
         end
+
+        value
       end
 
       def ensure_populated!

data/lib/active_record_views/railtie.rb

@@ -2,16 +2,25 @@ module ActiveRecordViews
   class Railtie < ::Rails::Railtie
     initializer 'active_record_views' do |app|
       ActiveSupport.on_load :active_record do
-        ActiveRecordViews.sql_load_path << Rails.root + 'app/models'
+        ActiveRecordViews.sql_load_path += Rails.application.config.paths['app/models'].to_a
         ActiveRecordViews.init!
         ActiveRecordViews::Extension.create_enabled = !Rails.env.production?
       end
 
-      ActiveSupport.on_load :action_controller do
-        unless app.config.cache_classes
-          ActionDispatch::Callbacks.before do
+      unless app.config.cache_classes
+        if app.respond_to?(:reloader)
+          app.reloader.before_class_unload do
             ActiveRecordViews.reload_stale_views!
           end
+          app.executor.to_run do
+            ActiveRecordViews.reload_stale_views!
+          end
+        else
+          ActiveSupport.on_load :action_controller do
+            ActionDispatch::Callbacks.before do
+              ActiveRecordViews.reload_stale_views!
+            end
+          end
         end
       end
     end

data/lib/active_record_views/registered_view.rb

@@ -1,6 +1,6 @@
 module ActiveRecordViews
   class RegisteredView
-    attr_reader :sql_path
+    attr_reader :model_class_name, :sql_path
 
     def initialize(model_class, sql_path)
       @model_class_name = model_class.name
@@ -16,9 +16,14 @@ module ActiveRecordViews
       sql_timestamp != @cached_sql_timestamp
     end
 
+    def dead?
+      !File.exist?(sql_path)
+    end
+
     def reload!
       if File.exist? sql_path
-        ActiveRecordViews.create_view model_class.connection, model_class.table_name, model_class.name, ActiveRecordViews.read_sql_file(sql_path), model_class.view_options
+        ActiveRecordViews.create_view model_class.connection, model_class.table_name, model_class.name, ActiveRecordViews.read_sql_file(model_class, sql_path), model_class.view_options
+        model_class.reset_column_information
       else
         ActiveRecordViews.drop_view model_class.connection, model_class.table_name
       end

data/lib/active_record_views/version.rb

@@ -1,3 +1,3 @@
 module ActiveRecordViews
-  VERSION = '0.0.20'
+  VERSION = '0.1.3'
 end

data/lib/active_record_views.rb

@@ -28,9 +28,9 @@ module ActiveRecordViews
     raise "could not find #{name}.sql"
   end
 
-  def self.read_sql_file(sql_path)
+  def self.read_sql_file(model_class, sql_path)
     if sql_path.end_with?('.erb')
-      ERB.new(File.read(sql_path)).result
+      ERB.new(File.read(sql_path)).result(model_class.instance_eval { binding })
     else
       File.read(sql_path)
     end
@@ -54,7 +54,7 @@ module ActiveRecordViews
           states[temp_connection] = states[connection] = temp_connection
           yield temp_connection
         ensure
-          connection.pool.checkin temp_connection
+          connection.pool.checkin temp_connection if temp_connection
           states[temp_connection] = states[connection] = nil
         end
       else
@@ -154,6 +154,7 @@ module ActiveRecordViews
 
   def self.drop_all_views(base_connection)
     without_transaction base_connection do |connection|
+      ActiveRecordViews::ChecksumCache.new(connection)
       names = Set.new connection.select_values('SELECT name FROM active_record_views;')
 
       func = lambda do |name|
@@ -173,17 +174,17 @@ module ActiveRecordViews
     options.assert_valid_keys :dependencies, :materialized, :unique_columns
     sql = sql.sub(/;\s*\z/, '')
 
-    if options[:materialized]
+    if options.fetch(:materialized, false)
       connection.execute "CREATE MATERIALIZED VIEW #{connection.quote_table_name name} AS #{sql} WITH NO DATA;"
     else
       connection.execute "CREATE VIEW #{connection.quote_table_name name} AS #{sql};"
     end
 
-    if options[:unique_columns]
+    if unique_columns = options.fetch(:unique_columns, nil)
       connection.execute <<-SQL.squish
         CREATE UNIQUE INDEX #{connection.quote_table_name "#{name}_pkey"}
         ON #{connection.quote_table_name name}(
-          #{options[:unique_columns].map { |column_name| connection.quote_table_name(column_name) }.join(', ')}
+          #{unique_columns.map { |column_name| connection.quote_table_name(column_name) }.join(', ')}
         );
       SQL
     end
@@ -320,14 +321,42 @@ module ActiveRecordViews
       if registered_view.stale?
         registered_view.reload!
       end
+      if registered_view.dead?
+        self.registered_views.delete registered_view
+      end
     end
   end
 
   def self.drop_unregistered_views!
     connection = ActiveRecord::Base.connection
+    ActiveRecordViews::ChecksumCache.new(connection)
 
     connection.select_rows('SELECT name, class_name FROM active_record_views')
       .reject { |name, class_name| Object.const_defined? class_name }
       .each { |name, class_name| ActiveRecordViews.drop_view connection, name }
   end
+
+  def self.reset_materialized_views
+    connection = ActiveRecord::Base.connection
+    ActiveRecordViews::ChecksumCache.new(connection)
+
+    connection.transaction do
+      materialized_views = connection.select_values(<<~SQL)
+        SELECT name
+        FROM active_record_views
+        WHERE (options ->> 'materialized')::boolean
+        AND refreshed_at IS NOT NULL
+      SQL
+
+      materialized_views.each do |view|
+        connection.execute(<<~SQL)
+          REFRESH MATERIALIZED VIEW #{view} WITH NO DATA;
+        SQL
+      end
+
+      connection.execute(<<~SQL)
+        UPDATE active_record_views SET refreshed_at = NULL;
+      SQL
+    end
+  end
 end

data/lib/tasks/active_record_views.rake

@@ -6,33 +6,87 @@ Rake::Task['db:migrate'].enhance do
   end
 end
 
-Rake::Task['db:structure:dump'].enhance do
+schema_rake_task = Gem::Version.new(Rails.version) >= Gem::Version.new("6.1") ? 'db:schema:dump' : 'db:structure:dump'
+
+Rake::Task[schema_rake_task].enhance do
   table_exists = if Rails::VERSION::MAJOR >= 5
     ActiveRecord::Base.connection.data_source_exists?('active_record_views')
   else
     ActiveRecord::Base.connection.table_exists?('active_record_views')
   end
 
-  if table_exists
-    filename = ENV['DB_STRUCTURE'] || File.join(Rails.root, "db", "structure.sql")
+  if schema_rake_task == 'db:structure:dump'
+    ActiveRecord::Base.schema_format = :sql
+  end
+
+  if table_exists && ActiveRecord::Base.schema_format == :sql
+    tasks = ActiveRecord::Tasks::DatabaseTasks
 
-    if defined? ActiveRecord::Tasks::DatabaseTasks
-      tasks = ActiveRecord::Tasks::DatabaseTasks
-      config = tasks.current_config
-      tasks.send(:class_for_adapter, config.fetch('adapter')).new(config)
-      pg_tasks = tasks.send(:class_for_adapter, config.fetch('adapter')).new(config)
-      pg_tasks.send(:set_psql_env)
+    filename = case
+    when tasks.respond_to?(:dump_filename)
+      tasks.dump_filename('primary')
     else
-      config = current_config
-      set_psql_env(config)
+      tasks.schema_file
     end
 
-    require 'shellwords'
-    system("pg_dump --data-only --table=active_record_views #{Shellwords.escape config['database']} >> #{Shellwords.escape filename}")
-    raise 'active_record_views metadata dump failed' unless $?.success?
+    config = if ActiveRecord::Base.configurations.respond_to?(:configs_for)
+      if Rails.version.start_with?('6.0.')
+        ActiveRecord::Base.configurations.configs_for(env_name: Rails.env, spec_name: 'primary').config
+      else
+        ActiveRecord::Base.configurations.configs_for(env_name: Rails.env, name: 'primary')
+      end
+    else
+      tasks.current_config
+    end
+    adapter = if config.respond_to?(:adapter)
+      config.adapter
+    else
+      config.fetch('adapter')
+    end
+    database = if config.respond_to?(:database)
+      config.database
+    else
+      config.fetch('database')
+    end
+
+    pg_tasks = tasks.send(:class_for_adapter, adapter).new(config)
+    pg_tasks.send(:set_psql_env)
+
+    begin
+      active_record_views_dump = Tempfile.open("active_record_views_dump.sql")
+      require 'shellwords'
+      system("pg_dump --data-only --no-owner --table=active_record_views #{Shellwords.escape database} >> #{Shellwords.escape active_record_views_dump.path}")
+      raise 'active_record_views metadata dump failed' unless $?.success?
+
+      if Gem::Version.new(Rails.version) >= Gem::Version.new("5.1")
+        pg_tasks.send(:remove_sql_header_comments, active_record_views_dump.path)
+      end
+
+      # Substitute out any timestamps that were dumped from the active_record_views table
+      #
+      # Before:
+      #
+      #     COPY public.active_record_views (name, class_name, checksum, options, refreshed_at) FROM stdin;
+      #     test_view       TestView        42364a017b73ef516a0eca9827e6fa00623257ee        {"dependencies":[]}     2021-10-26 02:49:12.247494
+      #     \.
+      #
+      # After:
+      #
+      #     COPY public.active_record_views (name, class_name, checksum, options, refreshed_at) FROM stdin;
+      #     test_view       TestView        42364a017b73ef516a0eca9827e6fa00623257ee        {"dependencies":[]}     \N
+      #     \.
+      active_record_views_dump_content = active_record_views_dump.read
+      if active_record_views_dump_content !~ /^COPY public.active_record_views \(.+, refreshed_at\) FROM stdin;$/
+        raise 'refreshed_at is not final column'
+      end
+      active_record_views_dump_content.gsub!(/\t\d\d\d\d-\d\d-\d\d.*$/, "\t\\N")
 
-    File.open filename, 'a' do |io|
-      io.puts 'UPDATE public.active_record_views SET refreshed_at = NULL WHERE refreshed_at IS NOT NULL;'
+      File.open filename, 'a' do |io|
+        io.puts active_record_views_dump_content
+      end
+    ensure
+      active_record_views_dump.close
+      active_record_views_dump.unlink
     end
   end
 end

data/spec/active_record_views_checksum_cache_spec.rb

@@ -49,18 +49,22 @@ describe ActiveRecordViews::ChecksumCache do
       end
 
       it 'drops existing managed views recreates the table' do
-        expect(ActiveRecord::Base.connection).to receive(:execute).with(/\ABEGIN\z/).once.and_call_original
-        expect(ActiveRecord::Base.connection).to receive(:execute).with(/\ADROP VIEW IF EXISTS test_view CASCADE;\z/).once.and_call_original
-        expect(ActiveRecord::Base.connection).to receive(:execute).with(/\ADROP TABLE active_record_views;\z/).once.and_call_original
-        expect(ActiveRecord::Base.connection).to receive(:execute).with(/\ACREATE TABLE active_record_views/).once.and_call_original
-        expect(ActiveRecord::Base.connection).to receive(:execute).with(/\ACOMMIT\z/).once.and_call_original
-
         expect(connection.column_exists?('active_record_views', 'class_name')).to eq false
         expect(ActiveRecordViews.view_exists?(connection, 'test_view')).to eq true
         expect(ActiveRecordViews.view_exists?(connection, 'other_view')).to eq true
 
+        sql_statements.clear
+
         ActiveRecordViews::ChecksumCache.new(connection)
 
+        expect(sql_statements.grep_v(/^\s*SELECT/)).to match [
+          'BEGIN',
+          'DROP VIEW IF EXISTS test_view CASCADE;',
+          'DROP TABLE active_record_views;',
+          /^CREATE TABLE active_record_views/,
+          'COMMIT',
+        ]
+
         expect(connection.column_exists?('active_record_views', 'class_name')).to eq true
         expect(ActiveRecordViews.view_exists?(connection, 'test_view')).to eq false
         expect(ActiveRecordViews.view_exists?(connection, 'other_view')).to eq true