activerecord_views 0.0.6 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 888479aa2afb60445b3c837ae67a597d2b799569
-  data.tar.gz: f86bb06ff3b0d2edfe8f0e524e34b8ed1d8076bb
+  metadata.gz: b5c0f7297c9900d6d2ce6e803a35eca6a8015c84
+  data.tar.gz: 5a5874b77eec4404e21b2a2ac07bc9a78e2ff0cd
 SHA512:
-  metadata.gz: 429f8e647553fa58bb61bd0318446aca7b6b00496e01fd9f3686614129b3ac57d7621d6b073182db5c366bd24eb9da70a31e1d6aa081741e6291fc41d388ff12
-  data.tar.gz: 0a96d8276ef10685005852d9c8d4c86bab7e0a01ca6eac93dded99b6b13c04459809f2cf9b9b0a901bf3d9dcc6688cc422203f266727b60918878e5ab451ad25
+  metadata.gz: f58e18bb2e9ae78e98b127074038856bf4a94273d482022d5ab38fc5f7bac2be9e1deb0f989ba32c9040019008c1dcf49247ef7a4c5de56ae5b2b2283d9df584
+  data.tar.gz: 8d38a7027e201afa5f6884792b4da2e2957400d2b0908525d838c29cf03d019c0f02646f97fed8e0b88b94cd3420b617881ee1c5b187c1cdbea399198b45ca8e

data/README.markdown

@@ -18,7 +18,7 @@ Add this line to your application's `Gemfile`:
 gem 'activerecord_views'
 ```
 
-## Usage
+## Example
 
 app/models/account.rb:
 
@@ -68,6 +68,46 @@ Account.includes(:account_balance).find_each do |account|
 end
 ```
 
+## Materialized views
+
+ActiveRecordViews has support [PostgreSQL's materialized views](http://www.postgresql.org/docs/9.4/static/rules-materializedviews.html).
+By default, views execute their query to calculate the output every time they are accessed.
+Materialized views let you cache the output of views. This is useful for views which have expensive calculations. Your application can then trigger a refresh of the cached data as required.
+
+To configure an ActiveRecordViews model as being materialized, pass the `materialized: true` option to `is_view`:
+
+```ruby
+class AccountBalance < ActiveRecord::Base
+  is_view materialized: true
+end
+```
+
+Materialized views are not initially populated upon creation as this could greatly slow down application startup.
+An exception will be raised if you attempt to read from a view before it is populated.
+You can test if a materialized view has been populated with the `view_populated?` class method and trigger a refresh with the `refresh_view!` class method:
+
+```ruby
+AccountBalance.view_populated? # => false
+AccountBalance.refresh_view!
+AccountBalance.view_populated? # => true
+```
+
+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
+  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` when refreshing:
+
+```ruby
+AccountBalance.refresh_view! concurrent: true
+```
+
 ## Pre-populating views in Rails development mode
 
 Rails loads classes lazily in development mode by default.
@@ -88,7 +128,7 @@ In order to keep things tidy and to avoid accidentally referencing a stale view,
 ActiveRecordViews.drop_view connection, 'account_balances'
 ```
 
-### Usage outside of Rails
+## Usage outside of Rails
 
 When included in a Ruby on Rails project, ActiveRecordViews will automatically detect `.sql` files alongside models in `app/models`.
 Outside of Rails, you will have to tell ActiveRecordViews where to find associated `.sql` files for models:

data/lib/active_record_views/checksum_cache.rb

@@ -18,20 +18,58 @@ module ActiveRecordViews
         table_exists = false
       end
 
+      if table_exists && !@connection.column_exists?('active_record_views', 'options')
+        @connection.execute "ALTER TABLE active_record_views ADD COLUMN options json NOT NULL DEFAULT '{}';"
+      end
+
       unless table_exists
-        @connection.execute 'CREATE TABLE active_record_views(name text PRIMARY KEY, class_name text NOT NULL UNIQUE, checksum text NOT NULL);'
+        @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 '{}');"
       end
     end
 
     def get(name)
-      @connection.select_one("SELECT class_name, checksum FROM active_record_views WHERE name = #{@connection.quote name}").try(:symbolize_keys)
+      if data = @connection.select_one("SELECT class_name, checksum, options FROM active_record_views WHERE name = #{@connection.quote name}")
+        data.symbolize_keys!
+        data[:options] = JSON.load(data[:options]).symbolize_keys
+        data
+      end
     end
 
     def set(name, data)
       if data
-        data.assert_valid_keys :class_name, :checksum
-        if @connection.update("UPDATE active_record_views SET class_name = #{@connection.quote data[:class_name]}, checksum = #{@connection.quote data[:checksum]} WHERE name = #{@connection.quote name}") == 0
-          @connection.insert "INSERT INTO active_record_views (name, class_name, checksum) VALUES (#{@connection.quote name}, #{@connection.quote data[:class_name]}, #{@connection.quote data[:checksum]})"
+        data.assert_valid_keys :class_name, :checksum, :options
+
+        options = data[:options] || {}
+        unless options.keys.all? { |key| key.is_a?(Symbol) }
+          raise ArgumentError, 'option keys must be symbols'
+        end
+        options_json = JSON.dump(options)
+
+        rows_updated = @connection.update(<<-SQL)
+          UPDATE active_record_views
+          SET
+            class_name = #{@connection.quote data[:class_name]},
+            checksum = #{@connection.quote data[:checksum]},
+            options = #{@connection.quote options_json}
+          WHERE
+            name = #{@connection.quote name}
+          ;
+        SQL
+
+        if rows_updated == 0
+          @connection.insert <<-SQL
+            INSERT INTO active_record_views (
+              name,
+              class_name,
+              checksum,
+              options
+            ) VALUES (
+              #{@connection.quote name},
+              #{@connection.quote data[:class_name]},
+              #{@connection.quote data[:checksum]},
+              #{@connection.quote options_json}
+            )
+          SQL
         end
       else
         @connection.delete "DELETE FROM active_record_views WHERE name = #{@connection.quote name}"

data/lib/active_record_views/extension.rb

@@ -11,7 +11,15 @@ module ActiveRecordViews
     end
 
     module ClassMethods
-      def is_view(sql = nil)
+      def is_view(*args)
+        return if ActiveRecordViews::Extension.currently_migrating?
+
+        cattr_accessor :view_options
+        self.view_options = args.extract_options!
+
+        raise ArgumentError, "wrong number of arguments (#{args.size} for 0..1)" unless (0..1).cover?(args.size)
+        sql = args.shift
+
         sql ||= begin
           sql_path = ActiveRecordViews.find_sql_file(self.name.underscore)
           ActiveRecordViews.register_for_reload self, sql_path
@@ -23,9 +31,26 @@ module ActiveRecordViews
           end
         end
 
-        unless ActiveRecordViews::Extension.currently_migrating?
-          ActiveRecordViews.create_view self.connection, self.table_name, self.name, sql
+        ActiveRecordViews.create_view self.connection, self.table_name, self.name, sql, self.view_options
+      end
+
+      def refresh_view!(options = {})
+        options.assert_valid_keys :concurrent
+        connection.execute "REFRESH MATERIALIZED VIEW#{' CONCURRENTLY' if options[:concurrent]} #{connection.quote_table_name self.table_name};"
+      end
+
+      def view_populated?
+        value = connection.select_value(<<-SQL)
+          SELECT ispopulated
+          FROM pg_matviews
+          WHERE schemaname = 'public' AND matviewname = #{connection.quote self.table_name};
+        SQL
+
+        if value.nil?
+          raise ArgumentError, 'not a materialized view'
         end
+
+        ActiveRecord::ConnectionAdapters::Column::TRUE_VALUES.include?(value)
       end
     end
   end

data/lib/active_record_views/registered_view.rb

@@ -1,6 +1,6 @@
 module ActiveRecordViews
   class RegisteredView
-    attr_reader :model_class, :sql_path
+    attr_reader :sql_path
 
     def initialize(model_class, sql_path)
       @model_class_name = model_class.name
@@ -17,8 +17,8 @@ module ActiveRecordViews
     end
 
     def reload!
-      if File.exists? sql_path
-        ActiveRecordViews.create_view model_class.connection, model_class.table_name, model_class.name, File.read(sql_path)
+      if File.exist? sql_path
+        ActiveRecordViews.create_view model_class.connection, model_class.table_name, model_class.name, File.read(sql_path), model_class.view_options
       else
         ActiveRecordViews.drop_view model_class.connection, model_class.table_name
       end
@@ -28,7 +28,7 @@ module ActiveRecordViews
     private
 
     def sql_timestamp
-      File.exists?(sql_path) ? File.mtime(sql_path) : nil
+      File.exist?(sql_path) ? File.mtime(sql_path) : nil
     end
 
     def update_timestamp!

data/lib/active_record_views/version.rb

@@ -1,3 +1,3 @@
 module ActiveRecordViews
-  VERSION = '0.0.6'
+  VERSION = '0.0.7'
 end

data/lib/active_record_views.rb

@@ -20,9 +20,9 @@ module ActiveRecordViews
   def self.find_sql_file(name)
     self.sql_load_path.each do |dir|
       path = "#{dir}/#{name}.sql"
-      return path if File.exists?(path)
+      return path if File.exist?(path)
       path = path + '.erb'
-      return path if File.exists?(path)
+      return path if File.exist?(path)
     end
     raise "could not find #{name}.sql"
   end
@@ -53,20 +53,31 @@ module ActiveRecordViews
     end
   end
 
-  def self.create_view(connection, name, class_name, sql)
-    without_transaction connection do |connection|
+  def self.create_view(base_connection, name, class_name, sql, options = {})
+    options.assert_valid_keys :materialized, :unique_columns
+
+    without_transaction base_connection do |connection|
       cache = ActiveRecordViews::ChecksumCache.new(connection)
-      data = {class_name: class_name, checksum: Digest::SHA1.hexdigest(sql)}
+      data = {class_name: class_name, checksum: Digest::SHA1.hexdigest(sql), options: options}
       return if cache.get(name) == data
 
-      begin
-        connection.execute "CREATE OR REPLACE VIEW #{connection.quote_table_name name} AS #{sql}"
-      rescue ActiveRecord::StatementInvalid => original_exception
-        raise unless view_exists?(connection, name)
+      drop_and_create = if options[:materialized]
+        true
+      else
+        raise ArgumentError, 'unique_columns option requires view to be materialized' if options[:unique_columns]
+        begin
+          connection.execute "CREATE OR REPLACE VIEW #{connection.quote_table_name name} AS #{sql}"
+          false
+        rescue ActiveRecord::StatementInvalid
+          true
+        end
+      end
+
+      if drop_and_create
         connection.transaction :requires_new => true do
           without_dependencies connection, name do
-            connection.execute "DROP VIEW #{connection.quote_table_name name}"
-            connection.execute "CREATE VIEW #{connection.quote_table_name name} AS #{sql}"
+            execute_drop_view connection, name
+            execute_create_view connection, name, sql, options
           end
         end
       end
@@ -75,22 +86,66 @@ module ActiveRecordViews
     end
   end
 
-  def self.drop_view(connection, name)
-    without_transaction connection do |connection|
+  def self.drop_view(base_connection, name)
+    without_transaction base_connection do |connection|
       cache = ActiveRecordViews::ChecksumCache.new(connection)
-      connection.execute "DROP VIEW IF EXISTS #{connection.quote_table_name name}"
+      execute_drop_view connection, name
       cache.set name, nil
     end
   end
 
+  def self.execute_create_view(connection, name, sql, options)
+    options.assert_valid_keys :materialized, :unique_columns
+    sql = sql.sub(/;\s*/, '')
+
+    if options[:materialized]
+      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]
+      connection.execute <<-SQL
+        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(', ')}
+        );
+      SQL
+    end
+  end
+
+  def self.execute_drop_view(connection, name)
+    if materialized_view?(connection, name)
+      connection.execute "DROP MATERIALIZED VIEW IF EXISTS #{connection.quote_table_name name};"
+    else
+      connection.execute "DROP VIEW IF EXISTS #{connection.quote_table_name name};"
+    end
+  end
+
   def self.view_exists?(connection, name)
     connection.select_value(<<-SQL).present?
       SELECT 1
       FROM information_schema.views
-      WHERE table_schema = 'public' AND table_name = #{connection.quote name};
+      WHERE table_schema = 'public' AND table_name = #{connection.quote name}
+      UNION ALL
+      SELECT 1
+      FROM pg_matviews
+      WHERE schemaname = 'public' AND matviewname = #{connection.quote name};
+    SQL
+  end
+
+  def self.materialized_view?(connection, name)
+    connection.select_value(<<-SQL).present?
+      SELECT 1
+      FROM pg_matviews
+      WHERE schemaname = 'public' AND matviewname = #{connection.quote name};
     SQL
   end
 
+  def self.supports_concurrent_refresh?(connection)
+    connection.raw_connection.server_version >= 90400
+  end
+
   def self.get_view_dependencies(connection, name)
     connection.select_rows <<-SQL
       WITH RECURSIVE dependants AS (
@@ -111,32 +166,39 @@ module ActiveRecordViews
 
       SELECT
         oid::regclass::text AS name,
-        class_name,
-        pg_catalog.pg_get_viewdef(oid) AS definition
+        MIN(class_name) AS class_name,
+        pg_catalog.pg_get_viewdef(oid) AS definition,
+        MIN(options::text) AS options_json
       FROM dependants
       INNER JOIN active_record_views ON active_record_views.name = oid::regclass::text
       WHERE level > 0
-      GROUP BY oid, class_name
+      GROUP BY oid
       ORDER BY MAX(level)
       ;
     SQL
   end
 
   def self.without_dependencies(connection, name)
+    unless view_exists?(connection, name)
+      yield
+      return
+    end
+
     dependencies = get_view_dependencies(connection, name)
 
-    dependencies.reverse.each do |name, _, _|
-      connection.execute "DROP VIEW #{name};"
+    dependencies.reverse.each do |dependency_name, _, _, _|
+      execute_drop_view connection, dependency_name
     end
 
     yield
 
-    dependencies.each do |name, class_name, definition|
+    dependencies.each do |dependency_name, class_name, definition, options_json|
       begin
         class_name.constantize
       rescue NameError => e
         raise unless e.missing_name?(class_name)
-        connection.execute "CREATE VIEW #{name} AS #{definition};"
+        options = JSON.load(options_json).symbolize_keys
+        execute_create_view connection, dependency_name, definition, options
       end
     end
   end

data/spec/active_record_views_checksum_cache_spec.rb

@@ -4,17 +4,20 @@ describe ActiveRecordViews::ChecksumCache do
   let(:connection) { ActiveRecord::Base.connection }
 
   describe 'initialisation' do
-    context 'with no existing table' do
+    context 'no existing table' do
       it 'creates the table' do
         expect(ActiveRecord::Base.connection).to receive(:execute).with(/\ACREATE TABLE active_record_views/).once.and_call_original
 
         expect(connection.table_exists?('active_record_views')).to eq false
         ActiveRecordViews::ChecksumCache.new(connection)
         expect(connection.table_exists?('active_record_views')).to eq true
+
+        expect(connection.column_exists?('active_record_views', 'class_name')).to eq true
+        expect(connection.column_exists?('active_record_views', 'options')).to eq true
       end
     end
 
-    context 'with existing table' do
+    context 'existing table with current structure' do
       before do
         ActiveRecordViews::ChecksumCache.new(connection)
         expect(connection.table_exists?('active_record_views')).to eq true
@@ -27,7 +30,7 @@ describe ActiveRecordViews::ChecksumCache do
       end
     end
 
-    context 'with old table' do
+    context 'existing table without class name' do
       before do
         connection.execute 'CREATE TABLE active_record_views(name text PRIMARY KEY, checksum text NOT NULL);'
 
@@ -58,5 +61,44 @@ describe ActiveRecordViews::ChecksumCache do
         expect(ActiveRecordViews.view_exists?(connection, 'other_view')).to eq true
       end
     end
+
+    context 'existing table without options' do
+      before do
+        connection.execute 'CREATE TABLE active_record_views(name text PRIMARY KEY, class_name text NOT NULL UNIQUE, checksum text NOT NULL);'
+
+        connection.execute 'CREATE VIEW test_view AS SELECT 42 AS id;'
+        connection.execute "INSERT INTO active_record_views VALUES ('test_view', 'dummy', 'Dummy');"
+      end
+
+      it 'upgrades the table without losing data' do
+        expect(ActiveRecord::Base.connection).to receive(:execute).with("ALTER TABLE active_record_views ADD COLUMN options json NOT NULL DEFAULT '{}';").once.and_call_original
+
+        expect(connection.column_exists?('active_record_views', 'options')).to eq false
+        expect(ActiveRecordViews.view_exists?(connection, 'test_view')).to eq true
+
+        ActiveRecordViews::ChecksumCache.new(connection)
+
+        expect(connection.column_exists?('active_record_views', 'options')).to eq true
+        expect(ActiveRecordViews.view_exists?(connection, 'test_view')).to eq true
+      end
+    end
+  end
+
+  describe 'options serialization' do
+    let(:dummy_data) { {class_name: 'Test', checksum: '12345'} }
+    it 'errors if setting with non-symbol keys' do
+      cache = ActiveRecordViews::ChecksumCache.new(connection)
+      expect {
+        cache.set 'test', dummy_data.merge(options: {'blah' => 123})
+      }.to raise_error ArgumentError, 'option keys must be symbols'
+    end
+
+    it 'retrieves hash with symbolized keys and preserves value types' do
+      options = {foo: 'hi', bar: 123, baz: true}
+
+      cache = ActiveRecordViews::ChecksumCache.new(connection)
+      cache.set 'test', dummy_data.merge(options: options)
+      expect(cache.get('test')[:options]).to eq options
+    end
   end
 end

data/spec/active_record_views_extension_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe ActiveRecordViews::Extension do
-  describe '.as_view' do
+  describe '.is_view' do
     it 'creates database views from heredocs' do
       expect(ActiveRecordViews).to receive(:create_view).once.and_call_original
       expect(HeredocTestModel.first.name).to eq 'Here document'
@@ -34,7 +34,8 @@ describe ActiveRecordViews::Extension do
           anything,
           'modified_file_test_models',
           'ModifiedFileTestModel',
-          sql
+          sql,
+          {}
         ).once.ordered
       end
 
@@ -95,5 +96,75 @@ describe ActiveRecordViews::Extension do
 
       expect(ModifiedB.first.attributes.except(nil)).to eq('new_name' => 22)
     end
+
+    it 'errors if more than one argument is specified' do
+      expect {
+        class TooManyArguments < ActiveRecord::Base
+          is_view 'SELECT 1 AS ID;', 'SELECT 2 AS ID;'
+        end
+      }.to raise_error ArgumentError, 'wrong number of arguments (2 for 0..1)'
+    end
+
+    it 'errors if an invalid option is specified' do
+      expect {
+        class InvalidOption < ActiveRecord::Base
+          is_view 'SELECT 1 AS ID;', blargh: 123
+        end
+      }.to raise_error ArgumentError, /^Unknown key: :?blargh/
+    end
+
+    it 'creates/refreshes/drops materialized views' do
+      with_temp_sql_dir do |temp_dir|
+        sql_file = File.join(temp_dir, 'materialized_view_test_model.sql')
+        File.write sql_file, 'SELECT 123 AS id;'
+
+        class MaterializedViewTestModel < ActiveRecord::Base
+          is_view materialized: true
+        end
+
+        expect {
+          MaterializedViewTestModel.first!
+        }.to raise_error ActiveRecord::StatementInvalid, /materialized view "materialized_view_test_models" has not been populated/
+
+        expect(MaterializedViewTestModel.view_populated?).to eq false
+        MaterializedViewTestModel.refresh_view!
+        expect(MaterializedViewTestModel.view_populated?).to eq true
+
+        expect(MaterializedViewTestModel.first!.id).to eq 123
+
+        File.unlink sql_file
+        test_request
+
+        expect {
+          MaterializedViewTestModel.first!
+        }.to raise_error ActiveRecord::StatementInvalid, /relation "materialized_view_test_models" does not exist/
+      end
+    end
+
+    it 'raises an error for `view_populated?` if view is not materialized' do
+      class NonMaterializedViewPopulatedTestModel < ActiveRecord::Base
+        is_view 'SELECT 1 AS id;'
+      end
+
+      expect {
+        NonMaterializedViewPopulatedTestModel.view_populated?
+      }.to raise_error ArgumentError, 'not a materialized view'
+    end
+
+    it 'supports refreshing materialized views concurrently' do
+      class MaterializedViewRefreshTestModel < ActiveRecord::Base
+        is_view 'SELECT 1 AS id;', materialized: true
+      end
+      class MaterializedViewConcurrentRefreshTestModel < ActiveRecord::Base
+        is_view 'SELECT 1 AS id;', materialized: true, unique_columns: [:id]
+      end
+      MaterializedViewConcurrentRefreshTestModel.refresh_view!
+
+      expect(ActiveRecord::Base.connection).to receive(:execute).with('REFRESH MATERIALIZED VIEW "materialized_view_refresh_test_models";').once.and_call_original
+      expect(ActiveRecord::Base.connection).to receive(:execute).with('REFRESH MATERIALIZED VIEW CONCURRENTLY "materialized_view_concurrent_refresh_test_models";').once.and_call_original
+
+      MaterializedViewRefreshTestModel.refresh_view!
+      MaterializedViewConcurrentRefreshTestModel.refresh_view! concurrent: true
+    end
   end
 end

data/spec/active_record_views_spec.rb

@@ -4,8 +4,12 @@ describe ActiveRecordViews do
   describe '.create_view' do
     let(:connection) { ActiveRecord::Base.connection }
 
-    def create_test_view(sql)
-      ActiveRecordViews.create_view connection, 'test', 'Test', sql
+    def create_test_view(sql, options = {})
+      ActiveRecordViews.create_view connection, 'test', 'Test', sql, options
+    end
+
+    def drop_test_view
+      ActiveRecordViews.drop_view connection, 'test'
     end
 
     def test_view_sql
@@ -24,19 +28,36 @@ describe ActiveRecordViews do
       SQL
     end
 
+    def test_materialized_view_sql
+      connection.select_value(<<-SQL).try(&:squish)
+        SELECT definition
+        FROM pg_matviews
+        WHERE schemaname = 'public' AND matviewname = 'test'
+      SQL
+    end
+
+    def materialized_view_names
+      connection.select_values <<-SQL
+        SELECT matviewname
+        FROM pg_matviews
+        WHERE schemaname = 'public'
+      SQL
+    end
+
     it 'creates database view' do
       expect(test_view_sql).to be_nil
       create_test_view 'select 1 as id'
       expect(test_view_sql).to eq 'SELECT 1 AS id;'
     end
 
-    it 'records checksum and class name' do
-      create_test_view 'select 1 as id'
+    it 'records checksum, class name, and options' do
+      create_test_view 'select 1 as id', materialized: true
       expect(connection.select_all('select * from active_record_views').to_a).to eq [
         {
           'name' => 'test',
           'class_name' => 'Test',
-          'checksum' => Digest::SHA1.hexdigest('select 1 as id')
+          'checksum' => Digest::SHA1.hexdigest('select 1 as id'),
+          'options' => '{"materialized":true}',
         }
       ]
     end
@@ -134,6 +155,57 @@ describe ActiveRecordViews do
         end
       end
     end
+
+    it 'creates and drops materialized views' do
+      create_test_view 'select 123 as id', materialized: true
+      expect(test_view_sql).to eq nil
+      expect(test_materialized_view_sql).to eq 'SELECT 123 AS id;'
+
+      drop_test_view
+      expect(test_view_sql).to eq nil
+      expect(test_materialized_view_sql).to eq nil
+    end
+
+    it 'replaces a normal view with a materialized view' do
+      create_test_view 'select 11 as id'
+      create_test_view 'select 22 as id', materialized: true
+
+      expect(test_view_sql).to eq nil
+      expect(test_materialized_view_sql).to eq 'SELECT 22 AS id;'
+    end
+
+    it 'replaces a materialized view with a normal view' do
+      create_test_view 'select 22 as id', materialized: true
+      create_test_view 'select 11 as id'
+
+      expect(test_view_sql).to eq 'SELECT 11 AS id;'
+      expect(test_materialized_view_sql).to eq nil
+    end
+
+    it 'can test if materialized views can be refreshed concurrently' do
+      expect(ActiveRecordViews.supports_concurrent_refresh?(connection)).to be true
+    end
+
+    it 'preserves materialized view if dropping/recreating' do
+      ActiveRecordViews.create_view connection, 'test1', 'Test1', 'SELECT 1 AS foo'
+      ActiveRecordViews.create_view connection, 'test2', 'Test2', 'SELECT * FROM test1', materialized: true
+      ActiveRecordViews.create_view connection, 'test1', 'Test1', 'SELECT 2 AS bar, 1 AS foo'
+
+      expect(materialized_view_names).to eq %w[test2]
+      expect(view_names).to eq %w[test1]
+    end
+
+    it 'supports creating unique indexes on materialized views' do
+      create_test_view 'select 1 as foo, 2 as bar, 3 as baz', materialized: true, unique_columns: [:foo, 'bar']
+      index_sql = connection.select_value("SELECT indexdef FROM pg_indexes WHERE schemaname = 'public' AND indexname = 'test_pkey';")
+      expect(index_sql).to eq 'CREATE UNIQUE INDEX test_pkey ON test USING btree (foo, bar)'
+    end
+
+    it 'errors if trying to create unique index on non-materialized view' do
+      expect {
+        create_test_view 'select 1 as foo, 2 as bar, 3 as baz', materialized: false, unique_columns: [:foo, 'bar']
+      }.to raise_error ArgumentError, 'unique_columns option requires view to be materialized'
+    end
   end
 
   describe '.without_transaction' do

data/spec/spec_helper.rb

@@ -1,6 +1,9 @@
 require 'bundler'
 Bundler.setup
 
+require 'rails/version'
+$VERBOSE = true unless Rails::VERSION::MAJOR < 4
+
 require 'combustion'
 require 'active_record_views'
 Combustion.initialize! :active_record, :action_controller do
@@ -25,6 +28,15 @@ RSpec.configure do |config|
     view_names.each do |view_name|
       connection.execute "DROP VIEW IF EXISTS #{connection.quote_table_name view_name} CASCADE"
     end
+
+    materialized_view_names = connection.select_values <<-SQL
+      SELECT matviewname
+      FROM pg_matviews
+      WHERE schemaname = 'public'
+    SQL
+    materialized_view_names.each do |view_name|
+      connection.execute "DROP MATERIALIZED VIEW IF EXISTS #{connection.quote_table_name view_name} CASCADE"
+    end
   end
 
 end
@@ -49,7 +61,7 @@ def with_temp_sql_dir
 end
 
 def update_file(file, new_content)
-  time = File.exists?(file) ? File.mtime(file) : Time.parse('2012-01-01')
+  time = File.exist?(file) ? File.mtime(file) : Time.parse('2012-01-01')
   time = time + 1
   File.write file, new_content
   File.utime time, time, file

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord_views
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors:
 - Jason Weathered
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-20 00:00:00.000000000 Z
+date: 2015-01-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord