schema_plus_views 0.3.1 → 0.4.0

data/schema_plus_views.gemspec

@@ -17,13 +17,13 @@ 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"
-  gem.add_dependency "schema_plus_core", "~> 1.0"
+  gem.add_dependency "activerecord", "~> 5.2"
+  gem.add_dependency "schema_plus_core"
 
-  gem.add_development_dependency "bundler", "~> 1.7"
+  gem.add_development_dependency "bundler"
   gem.add_development_dependency "rake", "~> 10.0"
   gem.add_development_dependency "rspec", "~> 3.0"
-  gem.add_development_dependency "schema_dev", "~> 3.6"
+  gem.add_development_dependency "schema_dev", "~> 3.13.1"
   gem.add_development_dependency "simplecov"
   gem.add_development_dependency "simplecov-gem-profile"
 end

data/spec/dumper_spec.rb

@@ -5,8 +5,6 @@ end
 
 describe "Dumper" do
 
-  let(:schema) { ActiveRecord::Schema }
-
   let(:migration) { ActiveRecord::Migration }
 
   let(:connection) { ActiveRecord::Base.connection }
@@ -39,27 +37,77 @@ describe "Dumper" do
     # when in the (say) development database, but then uses it to
     # initialize the test database when testing.  this meant that the
     # test database had views into the development database.
-    db = connection.respond_to?(:current_database)? connection.current_database : SchemaDev::Rspec.db_configuration[:database]
+    db = connection.respond_to?(:current_database) ? connection.current_database : SchemaDev::Rspec.db_configuration[:database]
     expect(dump).not_to match(%r{#{connection.quote_table_name(db)}[.]})
   end
 
+  context 'materialized views', postgresql: :only do
+    before do
+      apply_migration do
+        create_view :materialized, Item.select('b, s').where(:a => 1), materialized: true
+
+        add_index :items, :a, where: 'a = 1'
+
+        add_index :materialized, :s
+        add_index :materialized, :b, unique: true, name: 'index_materialized_unique'
+      end
+    end
+
+    it "include the view definitions" do
+      expect(dump).to match(view_re("materialized", /SELECT .*b.*,.*s.* FROM .*items.* WHERE \(?.*a.* = 1\)?/mi, ', materialized: true'))
+    end
+
+    it 'includes the index definitions' do
+      expect(dump).to match(/index_materialized_on_s/)
+      expect(dump).to match(/index_materialized_unique.+unique/)
+    end
+
+    context 'when indexes are function results', postgresql: :only do
+      before do
+        apply_migration do
+          add_index :materialized, 'length(s)', name: 'index_materialized_function'
+        end
+      end
+
+      it 'includes the index definition' do
+        expect(dump).to match(/length\(.+name.+index_materialized_function/)
+      end
+    end
+
+    context 'when index has a where clause', postgresql: :only do
+      before do
+        apply_migration do
+          add_index :materialized, :s, where: 'b = 1', name: 'index_materialized_conditional'
+        end
+      end
+
+      it 'includes the index definition' do
+        expect(dump).to match(/index_materialized_conditional.+where/)
+      end
+    end
+  end
+
   protected
 
-  def view_re(name, re)
+  def view_re(name, re, extra_config = '')
     heredelim = "END_VIEW_#{name.upcase}"
-    %r{create_view "#{name}", <<-'#{heredelim}', :force => true\n\s*#{re}\s*\n *#{heredelim}$}mi
+    %r{create_view "#{name}", <<-'#{heredelim}', :force => true#{extra_config}\n\s*#{re}\s*\n *#{heredelim}$}mi
   end
 
   def define_schema_and_data
-    connection.views.each do |view| connection.drop_view view end
-    connection.tables.each do |table| connection.drop_table table, cascade: true end
+    connection.views.each do |view|
+      connection.drop_view view
+    end
+    connection.tables.each do |table|
+      connection.drop_table table, cascade: true
+    end
 
-    schema.define do
+    apply_migration do
 
       create_table :items, :force => true do |t|
         t.integer :a
         t.integer :b
-        t.string  :s
+        t.string :s
       end
 
       create_view :a_ones, Item.select('b, s').where(:a => 1)
@@ -71,7 +119,7 @@ describe "Dumper" do
     connection.execute "insert into items (a, b, s) values (2, 2, 'two_two')"
   end
 
-  def dump(opts={})
+  def dump(opts = {})
     StringIO.open { |stream|
       ActiveRecord::SchemaDumper.ignore_tables = Array.wrap(opts[:ignore_tables])
       ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)

data/spec/introspection_spec.rb

@@ -4,9 +4,6 @@ class Item < ActiveRecord::Base
 end
 
 describe "Introspection" do
-
-  let(:schema) { ActiveRecord::Schema }
-
   let(:migration) { ActiveRecord::Migration }
 
   let(:connection) { ActiveRecord::Base.connection }
@@ -17,8 +14,6 @@ describe "Introspection" do
 
   it "should list all views" do
     expect(connection.views.sort).to eq(%W[a_ones ab_ones])
-    expect(connection.view_definition('a_ones')).to match(%r{^SELECT .*b.*,.*s.* FROM .*items.* WHERE .*a.* = 1}mi)
-    expect(connection.view_definition('ab_ones')).to match(%r{^SELECT .*s.* FROM .*a_ones.* WHERE .*b.* = 1}mi)
   end
 
   it "should ignore views named pg_*", postgresql: :only do
@@ -30,6 +25,29 @@ describe "Introspection" do
     end
   end
 
+  context "when using PostGIS", postgresql: :only do
+    before do
+      apply_migration do
+        SchemaPlus::Views::ActiveRecord::ConnectionAdapters::PostgresqlAdapter::POSTGIS_VIEWS.each do |view|
+          create_view view, 'select 1'
+        end
+      end
+    end
+
+    after do
+      apply_migration do
+        SchemaPlus::Views::ActiveRecord::ConnectionAdapters::PostgresqlAdapter::POSTGIS_VIEWS.each do |view|
+          drop_view view
+        end
+      end
+    end
+
+    it "should hide views in postgis views" do
+      expect(connection.views.sort).to eq(%W[a_ones ab_ones])
+    end
+  end
+
+
   it "should not be listed as a table" do
     expect(connection.tables).not_to include('a_ones')
     expect(connection.tables).not_to include('ab_ones')
@@ -40,6 +58,11 @@ describe "Introspection" do
     expect(connection.view_definition('ab_ones')).to match(%r{^SELECT .*s.* FROM .*a_ones.* WHERE .*b.* = 1}mi)
   end
 
+  it 'returns them as view types' do
+    expect(connection.view_type('a_ones')).to eq(:view)
+    expect(connection.view_type('ab_ones')).to eq(:view)
+  end
+
   context "in mysql", :mysql => :only do
 
     around(:each) do |example|
@@ -67,13 +90,36 @@ describe "Introspection" do
     end
   end
 
+  context 'in postgresql', postgresql: :only do
+    context 'for materialized views' do
+      around(:each) do |example|
+        begin
+          migration.drop_view :materialized, materialized: true, if_exists: true
+          example.run
+        ensure
+          migration.drop_view :materialized, materialized: true, if_exists: true
+        end
+      end
+
+      it 'returns the definition' do
+        migration.create_view :materialized, 'SELECT * FROM items WHERE (a=2)', materialized: true
+        expect(connection.view_definition('materialized')).to match(%r{FROM items})
+      end
+
+      it 'returns the type as materialized' do
+        migration.create_view :materialized, 'SELECT * FROM items WHERE (a=2)', materialized: true
+        expect(connection.view_type('materialized')).to eq(:materialized)
+      end
+    end
+  end
+
   protected
 
   def define_schema_and_data
     connection.views.each do |view| connection.drop_view view end
     connection.tables.each do |table| connection.drop_table table, cascade: true end
 
-    schema.define do
+    apply_migration do
 
       create_table :items, :force => true do |t|
         t.integer :a

data/spec/middleware_spec.rb

@@ -4,12 +4,6 @@ module TestMiddleware
   module Middleware
 
     module Schema
-      module Views
-        SPY = []
-        def after(env)
-          SPY << env.to_hash.except(:connection)
-        end
-      end
       module ViewDefinition
         SPY = []
         def after(env)
@@ -40,12 +34,11 @@ SchemaMonkey.register TestMiddleware
 
 context SchemaPlus::Views::Middleware do
 
-  let(:schema) { ActiveRecord::Schema }
   let(:migration) { ActiveRecord::Migration }
   let(:connection) { ActiveRecord::Base.connection }
 
   before(:each) do
-    schema.define do
+    apply_migration do
       create_table :items, force: true do |t|
         t.integer :a
       end
@@ -53,16 +46,6 @@ context SchemaPlus::Views::Middleware do
     end
   end
 
-  context TestMiddleware::Middleware::Schema::Views do
-    it "calls middleware" do
-      expect(spy_on {connection.views 'qn'}).to eq({
-        #connection: connection,
-        views: ['a_view'],
-        query_name: 'qn'
-      })
-    end
-  end
-
   context TestMiddleware::Middleware::Schema::ViewDefinition do
     it "calls middleware" do
       spied = spy_on {connection.view_definition('a_view', 'qn')}

data/spec/migration_spec.rb

@@ -13,100 +13,148 @@ describe "Migration" do
 
   let(:migration) { ActiveRecord::Migration }
   let(:connection) { ActiveRecord::Base.connection }
-  let(:schema) { ActiveRecord::Schema }
 
   before(:each) do
     define_schema_and_data
   end
 
-  context "creation" do
-    it "should create correct views" do
-      expect(AOnes.all.collect(&:s)).to eq(%W[one_one one_two])
-      expect(ABOnes.all.collect(&:s)).to eq(%W[one_one])
+  shared_examples 'view checks' do |options = {}|
+    context "creation" do
+      it "should create correct views" do
+        expect(AOnes.all.collect(&:s)).to eq(%W[one_one one_two])
+        expect(ABOnes.all.collect(&:s)).to eq(%W[one_one])
+      end
     end
-  end
 
-  context "duplicate creation" do
-    before(:each) do
-      migration.create_view('dupe_me', 'SELECT * FROM items WHERE (a=1)')
-    end
+    context "duplicate creation" do
+      before(:each) do
+        migration.create_view('dupe_me', 'SELECT * FROM items WHERE (a=1)', options)
+      end
 
-    it "should raise an error by default" do
-      expect {migration.create_view('dupe_me', 'SELECT * FROM items WHERE (a=2)')}.to raise_error ActiveRecord::StatementInvalid
-    end
+      it "should raise an error by default" do
+        expect { migration.create_view('dupe_me', 'SELECT * FROM items WHERE (a=2)', options) }.to raise_error ActiveRecord::StatementInvalid
+      end
 
-    it "should override existing definition if :force true" do
-      migration.create_view('dupe_me', 'SELECT * FROM items WHERE (a=2)', :force => true)
-      expect(connection.view_definition('dupe_me')).to match(%r{WHERE .*a.*=.*2}i)
-    end
- 
-    context "Postgres and MySQL only", :sqlite3 => :skip do
-      it "should override existing definition if :allow_replace is true" do
-        migration.create_view('dupe_me', 'SELECT * FROM items WHERE (a=2)', :allow_replace => true)
+      it "should override existing definition if :force true" do
+        migration.create_view('dupe_me', 'SELECT * FROM items WHERE (a=2)', options.merge(force: true))
         expect(connection.view_definition('dupe_me')).to match(%r{WHERE .*a.*=.*2}i)
       end
-    end
-  end
 
-  context "dropping" do
-    it "should raise an error if the view doesn't exist" do
-      expect { migration.drop_view('doesnt_exist') }.to raise_error ActiveRecord::StatementInvalid
+      unless options[:materialized]
+        context "Postgres and MySQL only", :sqlite3 => :skip do
+          it "should override existing definition if :allow_replace is true" do
+            migration.create_view('dupe_me', 'SELECT * FROM items WHERE (a=2)', options.merge(allow_replace: true))
+            expect(connection.view_definition('dupe_me')).to match(%r{WHERE .*a.*=.*2}i)
+          end
+        end
+      end
     end
 
-    it "should fail silently when using if_exists option" do
-      expect { migration.drop_view('doesnt_exist', :if_exists => true) }.not_to raise_error
+    context "dropping" do
+      it "should raise an error if the view doesn't exist" do
+        expect { migration.drop_view('doesnt_exist', options) }.to raise_error ActiveRecord::StatementInvalid
+      end
+
+      it "should fail silently when using if_exists option" do
+        expect { migration.drop_view('doesnt_exist', options.merge(if_exists: true)) }.not_to raise_error
+      end
+
+      context "with a view that exists" do
+        before { migration.create_view('view_that_exists', 'SELECT * FROM items WHERE (a=1)', options) }
+
+        it "should succeed" do
+          migration.drop_view('view_that_exists', options)
+          expect(connection.views).not_to include('view_that_exists')
+        end
+      end
     end
 
-    context "with a view that exists" do
-      before { migration.create_view('view_that_exists', 'SELECT * FROM items WHERE (a=1)') }
+    describe "rollback" do
+      it "properly rolls back a create_view" do
+        m = build_migration do
+          define_method(:change) {
+            create_view :copy, "SELECT * FROM items", options
+          }
+        end
+        m.migrate(:up)
+        expect(connection.views).to include("copy")
+        m.migrate(:down)
+        expect(connection.views).not_to include("copy")
+      end
 
-      it "should succeed" do
-        migration.drop_view('view_that_exists')
-        expect(connection.views).not_to include('view_that_exists')
+      it "raises error for drop_view" do
+        m = build_migration do
+          define_method(:change) {
+            drop_view :a_ones, options
+          }
+        end
+        expect { m.migrate(:down) }.to raise_error(::ActiveRecord::IrreversibleMigration)
       end
     end
   end
 
-  describe "rollback" do
-    it "properly rolls back a create_view" do
-      m = Class.new ::ActiveRecord::Migration do
-        define_method(:change) {
-          create_view :copy, "SELECT * FROM items"
-        }
+  describe 'regular views' do
+    before(:each) do
+      apply_migration do
+        create_view :a_ones, Item.select('b, s').where(:a => 1)
+        create_view :ab_ones, "select s from a_ones where b = 1"
       end
-      m.migrate(:up)
-      expect(connection.views).to include("copy")
-      m.migrate(:down)
-      expect(connection.views).not_to include("copy")
     end
 
-    it "raises error for drop_view" do
-      m = Class.new ::ActiveRecord::Migration do
-        define_method(:change) {
-          drop_view :a_ones
-        }
+    include_examples 'view checks'
+  end
+
+  describe 'materialized views', postgresql: :only do
+    before(:each) do
+      apply_migration do
+        create_view :a_ones, Item.select('b, s').where(:a => 1), materialized: true
+        create_view :ab_ones, "select s from items where a = 1 AND b = 1", materialized: true
       end
-      expect { m.migrate(:down) }.to raise_error(::ActiveRecord::IrreversibleMigration)
     end
-  end
 
+    include_examples 'view checks', materialized: true
+
+    describe 'refreshing the view' do
+      it "refreshes the view" do
+        expect(AOnes.count).to eq(2)
+        Item.create!(a: 1, b: 3, s: 'one_three')
+        expect(AOnes.count).to eq(2)
+        connection.refresh_view('a_ones')
+        expect(AOnes.count).to eq(3)
+      end
+    end
+
+    context 'with indexes' do
+      it 'allows creating indexes on the materialized view' do
+        apply_migration do
+          add_index :a_ones, :s
+          add_index :a_ones, :b, unique: true
+        end
+
+        expect(connection.indexes(:a_ones)).to contain_exactly(
+                                                 have_attributes(columns: ['s'], unique: false),
+                                                 have_attributes(columns: ['b'], unique: true)
+                                               )
+      end
+    end
+  end
 
   protected
 
   def define_schema_and_data
-    connection.views.each do |view| connection.drop_view view end
-    connection.tables.each do |table| connection.drop_table table, cascade: true end
-
-    schema.define do
+    connection.views.each do |view|
+      connection.drop_view view
+    end
+    connection.tables.each do |table|
+      connection.drop_table table, cascade: true
+    end
 
+    apply_migration do
       create_table :items, :force => true do |t|
         t.integer :a
         t.integer :b
-        t.string  :s
+        t.string :s
       end
-
-      create_view :a_ones, Item.select('b, s').where(:a => 1)
-      create_view :ab_ones, "select s from a_ones where b = 1"
     end
     connection.execute "insert into items (a, b, s) values (1, 1, 'one_one')"
     connection.execute "insert into items (a, b, s) values (1, 2, 'one_two')"

data/spec/named_schemas_spec.rb

@@ -6,10 +6,10 @@ describe "with multiple schemas" do
   end
 
   before(:each) do
-    newdb = case connection.adapter_name
-            when /^mysql/i then      "CREATE SCHEMA IF NOT EXISTS schema_plus_views_test2"
-            when /^postgresql/i then "CREATE SCHEMA schema_plus_views_test2"
-            when /^sqlite/i then     "ATTACH ':memory:' AS schema_plus_views_test2"
+    newdb = case 
+            when SchemaDev::Rspec::Helpers.mysql? then      "CREATE SCHEMA IF NOT EXISTS schema_plus_views_test2"
+            when SchemaDev::Rspec::Helpers.postgresql? then "CREATE SCHEMA schema_plus_views_test2"
+            when SchemaDev::Rspec::Helpers.sqlite3? then    "ATTACH ':memory:' AS schema_plus_views_test2"
             end
     begin
       ActiveRecord::Base.connection.execute newdb
@@ -28,10 +28,10 @@ describe "with multiple schemas" do
     end
 
     connection.execute 'DROP TABLE IF EXISTS schema_plus_views_test2.users'
-    connection.execute 'CREATE TABLE schema_plus_views_test2.users (id ' + case connection.adapter_name
-          when /^mysql/i then      "integer primary key auto_increment"
-          when /^postgresql/i then "serial primary key"
-          when /^sqlite/i then     "integer primary key autoincrement"
+    connection.execute 'CREATE TABLE schema_plus_views_test2.users (id ' + case
+          when SchemaDev::Rspec::Helpers.mysql? then      "integer primary key auto_increment"
+          when SchemaDev::Rspec::Helpers.postgresql? then "serial primary key"
+          when SchemaDev::Rspec::Helpers.sqlite3? then    "integer primary key autoincrement"
           end + ", login varchar(255))"
   end
 
@@ -60,38 +60,4 @@ describe "with multiple schemas" do
     end
   end
 
-  context "when using PostGIS", :postgresql => :only do
-    before(:all) do
-      begin
-        connection.execute "CREATE SCHEMA postgis"
-      rescue ActiveRecord::StatementInvalid => e
-        raise unless e.message =~ /already exists/
-      end
-    end
-
-    around(:each) do |example|
-      begin
-        connection.execute "SET search_path to '$user','public','postgis'"
-        example.run
-      ensure
-        connection.execute "SET search_path to '$user','public'"
-      end
-    end
-
-    before(:each) do
-      allow(connection).to receive(:adapter_name).and_return('PostGIS')
-    end
-
-    it "should hide views in postgis schema" do
-      begin
-        connection.create_view "postgis.hidden", "select 1", :force => true
-        connection.create_view :myview, "select 2", :force => true
-        expect(connection.views).to eq(["myview"])
-      ensure
-        connection.execute 'DROP VIEW postgis.hidden' rescue nil
-        connection.execute 'DROP VIEW myview' rescue nil
-      end
-    end
-  end
-
 end

data/spec/spec_helper.rb

@@ -12,7 +12,7 @@ require 'schema_dev/rspec'
 
 SchemaDev::Rspec.setup
 
-Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each {|f| require f}
+Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each { |f| require f }
 
 RSpec.configure do |config|
   config.warnings = true
@@ -29,4 +29,16 @@ RSpec.configure do |config|
   end
 end
 
+def apply_migration(config = {}, &block)
+  ActiveRecord::Schema.define do
+    instance_eval &block
+  end
+end
+
+def build_migration(version: 5.0, &block)
+  Class.new(::ActiveRecord::Migration[version]) do
+    instance_eval &block
+  end
+end
+
 SimpleCov.command_name "[ruby #{RUBY_VERSION} - ActiveRecord #{::ActiveRecord::VERSION::STRING} - #{ActiveRecord::Base.connection.adapter_name}]"