schema_plus_views 0.2.3 → 0.4.1

data/lib/schema_plus/views/middleware.rb

@@ -9,45 +9,86 @@ module SchemaPlus::Views
           re_view_referent = %r{(?:(?i)FROM|JOIN) \S*\b(\S+)\b}
           env.connection.views.each do |view_name|
             next if env.dumper.ignored?(view_name)
-            view = View.new(name: view_name, definition: env.connection.view_definition(view_name))
+            definition, view_type = env.connection.view_full_definition(view_name)
+
+            indexes = []
+
+            if view_type == :materialized
+              env.connection.indexes(view_name).each do |index|
+                indexes << SchemaPlus::Core::SchemaDump::Table::Index.new(
+                  name: index.name, columns: index.columns, options: view_index_options(index, env.connection)
+                )
+              end
+            end
+
+            view = View.new(
+              name:       view_name,
+              definition: definition,
+              view_type:  view_type,
+              indexes:    indexes
+            )
+
             env.dump.tables[view.name] = view
             env.dump.depends(view.name, view.definition.scan(re_view_referent).flatten)
           end
         end
 
+        # Take from ActiveRecord::SchemaDumper#index_parts
+        def view_index_options(index, connection)
+          options = {}
+          options[:unique]  = true if index.unique
+          options[:length]  = index.lengths if index.lengths.present?
+          options[:order]   = index.orders if index.orders.present?
+          options[:opclass] = index.opclasses if index.opclasses.present?
+          options[:where]   = index.where if index.where
+          options[:using]   = index.using if !connection.default_index_type?(index)
+          options[:type]    = index.type if index.type
+          options[:comment] = index.comment if index.comment
+
+          options
+        end
+
         # quacks like a SchemaMonkey Dump::Table
-        class View < KeyStruct[:name, :definition]
+        class View < KeyStruct[:name, :definition, :view_type, :indexes]
           def assemble(stream)
-            heredelim = "END_VIEW_#{name.upcase}"
-            stream.puts <<-ENDVIEW
-  create_view "#{name}", <<-'#{heredelim}', :force => true
-#{definition}
-  #{heredelim}
-
+            extra_options = ", materialized: true" if view_type == :materialized
+            heredelim     = "END_VIEW_#{name.upcase}"
+            stream.puts <<~ENDVIEW
+                create_view "#{name}", <<-'#{heredelim}', :force => true#{extra_options}
+              #{definition}
+                #{heredelim}
             ENDVIEW
+
+            indexes.each do |index|
+              stream.write "add_index \"#{name}\", "
+              index.assemble(stream)
+              stream.puts ""
+            end
+            stream.puts ""
           end
         end
       end
     end
 
-    module Schema
-      module Tables
-
-        module Mysql
-          def after(env)
-            Tables.filter_out_views(env)
-          end
-        end
+    #
+    # Define new middleware stacks patterned on SchemaPlus::Core's naming
+    # for tables
 
-        module Sqlite3
-          def after(env)
-            Tables.filter_out_views(env)
-          end
-        end
+    module Schema
+      module ViewDefinition
+        ENV = [:connection, :view_name, :query_name, :definition, :view_type]
+      end
+    end
 
-        def self.filter_out_views(env)
-          env.tables -= env.connection.views(env.query_name)
-        end
+    module Migration
+      module CreateView
+        ENV = [:connection, :view_name, :definition, :options]
+      end
+      module DropView
+        ENV = [:connection, :view_name, :options]
+      end
+      module RefreshView
+        ENV = [:connection, :view_name, :options]
       end
     end
   end

data/lib/schema_plus/views/version.rb

@@ -1,5 +1,5 @@
 module SchemaPlus
   module Views
-    VERSION = "0.2.3"
+    VERSION = "0.4.1"
   end
 end

data/schema_dev.yml

@@ -1,8 +1,11 @@
 ruby:
-    - 2.1.5
+    - 2.5.9
+    - 2.7.3
 activerecord:
-    - 4.2
+    - 5.2
 db:
     - mysql2
     - sqlite3
     - postgresql
+dbversions:
+    postgresql: ['9.6', '10', '11', '12']

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", "~> 0.1"
+  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.3"
+  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 }
@@ -16,7 +14,6 @@ describe "Dumper" do
   end
 
   it "should include view definitions" do
-    puts dump
     expect(dump).to match(view_re("a_ones", /SELECT .*b.*,.*s.* FROM .*items.* WHERE \(?.*a.* = 1\)?/mi))
     expect(dump).to match(view_re("ab_ones", /SELECT .*s.* FROM .*a_ones.* WHERE \(?.*b.* = 1\)?/mi))
   end
@@ -40,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)
@@ -72,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,14 +25,42 @@ 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')
   end
 
   it "should introspect definition" do
-    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)
+    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 '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
@@ -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

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+module TestMiddleware
+  module Middleware
+
+    module Schema
+      module ViewDefinition
+        SPY = []
+        def after(env)
+          SPY << env.to_hash.except(:connection)
+        end
+      end
+    end
+
+    module Migration
+      module CreateView
+        SPY = []
+        def after(env)
+          SPY << env.to_hash.except(:connection)
+        end
+      end
+      module DropView
+        SPY = []
+        def after(env)
+          SPY << env.to_hash.except(:connection)
+        end
+      end
+    end
+
+  end
+end
+
+SchemaMonkey.register TestMiddleware
+
+context SchemaPlus::Views::Middleware do
+
+  let(:migration) { ActiveRecord::Migration }
+  let(:connection) { ActiveRecord::Base.connection }
+
+  before(:each) do
+    apply_migration do
+      create_table :items, force: true do |t|
+        t.integer :a
+      end
+      create_view 'a_view', "select a from items"
+    end
+  end
+
+  context TestMiddleware::Middleware::Schema::ViewDefinition do
+    it "calls middleware" do
+      spied = spy_on {connection.view_definition('a_view', 'qn')}
+      expect(spied[:view_name]).to eq('a_view')
+      expect(spied[:definition]).to match(%r{SELECT .*a.* FROM .*items.*}mi)
+      expect(spied[:query_name]).to eq('qn')
+    end
+  end
+
+  context TestMiddleware::Middleware::Migration::CreateView do
+    it "calls middleware" do
+      expect(spy_on {migration.create_view('newview', 'select a from items', force: true)}).to eq({
+        #connection: connection,
+        view_name: 'newview',
+        definition: 'select a from items',
+        options: { force: true }
+      })
+    end
+  end
+
+  context TestMiddleware::Middleware::Migration::DropView do
+    it "calls middleware" do
+      expect(spy_on {migration.drop_view('a_items', if_exists: true)}).to eq({
+        #connection: connection,
+        view_name: 'a_items',
+        options: { if_exists: true }
+      })
+    end
+  end
+
+
+  private
+
+  def spy_on 
+    spy = described_class.const_get :SPY
+    spy.clear
+    yield
+    spy.first
+  end
+
+end

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')"