activerecord_views 0.0.17 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b2627c1dce47cf8e2c072dc3e47c36792dac3d2f1ff21271dc0c3268e502f386
-  data.tar.gz: e7faba517dfd15a41741c87e7657dd9e190e8b5a1047c155e18f8bfd300de3be
+  metadata.gz: 777d910ae40ada55060df98887059878cc8ddb8ec65f6d49a890d2de9164810f
+  data.tar.gz: d905c23880139d85f0fb9ec3c00318670a1638351fc8e42bab05656c8d097d2e
 SHA512:
-  metadata.gz: d93b3071f407c190a08c52f8bc998600049971bd1751ecf1f1a1b05682061b4e75d1d5ec2aa46d32feb54b24ba2153045644a0c22e1e6a595e4e6b212b44f857
-  data.tar.gz: f3df8e14207b91c5be93f40473ef63f4b3d56a52075d875c2e624edda16fe1594e9cb01bd9faa08ecf0408354cb7dd244c7d2dec1d0b14cb3635ce23aabe6c5f
+  metadata.gz: ed3ac3d78b82bf20501936c0c3f4a30815300da89d2516d9149d37723d977638f06f0c6414a62d1460239da7e94478110bb89ec13459d656d28cbe37ca94e254
+  data.tar.gz: 0f6f5bf130436bc8fcf1a9fd1ad383044bc4a0373dd1f18a56c5691ee20a1eb55d38476e8af294c9daeb740182b520aff7202c4c6b75cc638d46dd12cda26dff

data/.gitignore

@@ -1,5 +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,15 +1,25 @@
-appraise 'rails3_2' do
-  gem 'rails', '~> 3.2.0'
+appraise 'rails4_2' do
+  gem 'rails', '~> 4.2.0'
+  gem "pg", "< 0.21"
 end
 
-appraise 'rails4_0' do
-  gem 'rails', '~> 4.0.0'
+appraise 'rails5_0' do
+  gem 'rails', '~> 5.0.0'
+  gem "pg", "< 1.0"
 end
 
-appraise 'rails4_1' do
-  gem 'rails', '~> 4.1.0'
+appraise 'rails5_1' do
+  gem 'rails', '~> 5.1.0'
 end
 
-appraise 'rails4_2' do
-  gem 'rails', '~> 4.2.0'
+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', ['>= 3.2', '< 4.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 => "../"
+gemspec path: "../"

data/gemfiles/rails5_0.gemfile

@@ -0,0 +1,8 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rails", "~> 5.0.0"
+gem "pg", "< 1.0"
+
+gemspec path: "../"

data/gemfiles/{rails3_2.gemfile → rails5_1.gemfile}

@@ -2,6 +2,6 @@
 
 source "https://rubygems.org"
 
-gem "rails", "~> 3.2.0"
+gem "rails", "~> 5.1.0"
 
-gemspec :path => "../"
+gemspec path: "../"

data/gemfiles/{rails4_0.gemfile → rails5_2.gemfile}

@@ -2,6 +2,6 @@
 
 source "https://rubygems.org"
 
-gem "rails", "~> 4.0.0"
+gem "rails", "~> 5.2.0"
 
-gemspec :path => "../"
+gemspec path: "../"

data/gemfiles/{rails4_1.gemfile → rails6_0.gemfile}

@@ -2,6 +2,6 @@
 
 source "https://rubygems.org"
 
-gem "rails", "~> 4.1.0"
+gem "rails", "~> 6.0.0"
 
-gemspec :path => "../"
+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.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
@@ -152,36 +152,39 @@ module ActiveRecordViews
     end
   end
 
-  def self.drop_all_views(connection)
-    names = Set.new connection.select_values('SELECT name FROM active_record_views;')
+  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|
-      if view_exists?(connection, name)
-        get_view_dependants(connection, name).each do |dependant_name, _, _, _|
-          func.call(dependant_name)
+      func = lambda do |name|
+        if view_exists?(connection, name)
+          get_view_dependants(connection, name).each do |dependant_name, _, _, _|
+            func.call(dependant_name)
+          end
+          drop_view connection, name
         end
-        drop_view connection, name
       end
-    end
 
-    names.each { |name| func.call(name) }
+      names.each { |name| func.call(name) }
+    end
   end
 
   def self.execute_create_view(connection, name, sql, options)
     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
@@ -318,6 +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/active_record_views/checksum_cache.rb

@@ -6,15 +6,20 @@ module ActiveRecordViews
     end
 
     def init_state_table!
-      table_exists = @connection.table_exists?('active_record_views')
+      table_exists = if Rails::VERSION::MAJOR >= 5
+        @connection.data_source_exists?('active_record_views')
+      else
+        @connection.table_exists?('active_record_views')
+      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
 
@@ -29,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

@@ -4,16 +4,20 @@ module ActiveRecordViews
   module Extension
     extend ActiveSupport::Concern
 
-    def self.currently_migrating?
-      if defined?(Rake) && Rake.respond_to?(:application)
-        Rake.application.top_level_tasks.any? { |task_name| task_name =~ /^db:migrate($|:)/ }
+    mattr_accessor :create_enabled
+    self.create_enabled = true
+
+    mattr_accessor :create_queue
+    self.create_queue = []
+
+    def self.process_create_queue!
+      while create_args = create_queue.shift
+        ActiveRecordViews.create_view ActiveRecord::Base.connection, *create_args
       end
     end
 
     module ClassMethods
       def is_view(*args)
-        return if ActiveRecordViews::Extension.currently_migrating?
-
         cattr_accessor :view_options
         self.view_options = args.extract_options!
 
@@ -23,22 +27,27 @@ 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
 
-        ActiveRecordViews.create_view self.connection, self.table_name, self.name, sql, self.view_options
+        create_args = [self.table_name, self.name, sql, self.view_options]
+        if ActiveRecordViews::Extension.create_enabled
+          ActiveRecordViews.create_view self.connection, *create_args
+        else
+          ActiveRecordViews::Extension.create_queue << create_args
+        end
       end
 
       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
@@ -46,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
 
@@ -60,7 +70,11 @@ module ActiveRecordViews
           raise ArgumentError, 'not a materialized view'
         end
 
-        ActiveRecord::ConnectionAdapters::Column::TRUE_VALUES.include?(value)
+        if Rails::VERSION::MAJOR < 5
+          value = ActiveRecord::ConnectionAdapters::Column::TRUE_VALUES.include?(value)
+        end
+
+        value
       end
 
       def refreshed_at
@@ -70,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!