schema_plus_views 0.3.1 → 1.0.0

data/lib/schema_plus/views/active_record/connection_adapters/postgresql_adapter.rb

@@ -1,32 +1,91 @@
+# frozen_string_literal: true
+
 module SchemaPlus::Views
   module ActiveRecord
     module ConnectionAdapters
       module PostgresqlAdapter
+        POSTGIS_VIEWS = %W[
+          geography_columns
+          geometry_columns
+          raster_columns
+          raster_overviews
+        ].freeze
+
+        # Create a view given the SQL definition.  Specify :force => true
+        # to first drop the view if it already exists.
+        def create_view(view_name, definition, options={})
+          SchemaMonkey::Middleware::Migration::CreateView.start(connection: self, view_name: view_name, definition: definition, options: options) do |env|
+            definition = env.definition
+            view_name = env.view_name
+            options = env.options
+            definition = definition.to_sql if definition.respond_to? :to_sql
+
+            if options[:materialized] && options[:allow_replace]
+              raise ArgumentError, 'allow_replace is not supported for materialized views'
+            end
+
+            if options[:force]
+              drop_view(view_name, {if_exists: true}.merge(options.slice(:materialized)))
+            end
+
+            command = if options[:materialized]
+                        "CREATE MATERIALIZED"
+                      elsif options[:allow_replace]
+                        "CREATE OR REPLACE"
+                      else
+                        "CREATE"
+                      end
+
+            execute "#{command} VIEW #{quote_table_name(view_name)} AS #{definition}"
+          end
+        end
+
+        # Drop the named view.  Specify :if_exists => true
+        # to fail silently if the view doesn't exist.
+        def drop_view(view_name, options = {})
+          SchemaMonkey::Middleware::Migration::DropView.start(connection: self, view_name: view_name, options: options) do |env|
+            view_name = env.view_name
+            options = env.options
+            materialized = options[:materialized] ? 'MATERIALIZED' : ''
+            sql = "DROP #{materialized} VIEW"
+            sql += " IF EXISTS" if options[:if_exists]
+            sql += " #{quote_table_name(view_name)}"
+            execute sql
+          end
+        end
 
-        def views(name = nil) #:nodoc:
-          SchemaMonkey::Middleware::Schema::Views.start(connection: self, query_name: name, views: []) { |env|
-            sql = <<-SQL
-            SELECT viewname
-              FROM pg_views
-            WHERE schemaname = ANY (current_schemas(false))
-            AND viewname NOT LIKE 'pg\_%'
-            SQL
-            sql += " AND schemaname != 'postgis'" if adapter_name == 'PostGIS'
-            env.views += env.connection.query(sql, env.query_name).map { |row| row[0] }
-          }.views
+        # Refresh a materialized view.
+        def refresh_view(view_name, options = {})
+          SchemaMonkey::Middleware::Migration::RefreshView.start(connection: self, view_name: view_name, options: options) do |env|
+            view_name = env.view_name
+            sql = "REFRESH MATERIALIZED VIEW #{quote_table_name(view_name)}"
+            execute sql
+          end
         end
 
-        def view_definition(view_name, name = nil) #:nodoc:
-          SchemaMonkey::Middleware::Schema::ViewDefinition.start(connection: self, view_name: view_name, query_name: name) { |env|
+        def views #:nodoc:
+          # Filter out any view that begins with "pg_"
+          super.reject do |c|
+            c.start_with?("pg_") || POSTGIS_VIEWS.include?(c)
+          end
+        end
+
+        def view_full_definition(view_name, name = nil) #:nodoc:
+          data = SchemaMonkey::Middleware::Schema::ViewDefinition.start(connection: self, view_name: view_name, query_name: name, view_type: :view) { |env|
               result = env.connection.query(<<-SQL, name)
-                SELECT pg_get_viewdef(oid)
+                SELECT pg_get_viewdef(oid), relkind
                   FROM pg_class
-                WHERE relkind = 'v'
+                WHERE relkind in ('v', 'm')
                   AND relname = '#{env.view_name}'
               SQL
               row = result.first
-              env.definition = row.first.chomp(';').strip unless row.nil?
-          }.definition
+              unless row.nil?
+                env.definition = row.first.chomp(';').strip
+                env.view_type = :materialized if row.second == 'm'
+              end
+          }
+
+          [data.definition, data.view_type]
         end
 
       end

data/lib/schema_plus/views/active_record/connection_adapters/sqlite3_adapter.rb

@@ -1,20 +1,18 @@
+# frozen_string_literal: true
+
 module SchemaPlus::Views
   module ActiveRecord
     module ConnectionAdapters
       module Sqlite3Adapter
 
-        def views(name = nil)
-          SchemaMonkey::Middleware::Schema::Views.start(connection: self, query_name: name, views: []) { |env|
-            env.views += env.connection.execute("SELECT name FROM sqlite_master WHERE type='view'", env.query_name).collect{|row| row["name"]}
-          }.views
-        end
-
-        def view_definition(view_name, name = nil)
-          SchemaMonkey::Middleware::Schema::ViewDefinition.start(connection: self, view_name: view_name, query_name: name) { |env|
+        def view_full_definition(view_name, name = nil)
+          data = SchemaMonkey::Middleware::Schema::ViewDefinition.start(connection: self, view_name: view_name, query_name: name, view_type: :view) { |env|
             sql = env.connection.execute("SELECT sql FROM sqlite_master WHERE type='view' AND name=#{quote(env.view_name)}", env.query_name).collect{|row| row["sql"]}.first
             sql.sub!(/^CREATE VIEW \S* AS\s+/im, '') unless sql.nil?
             env.definition = sql
-          }.definition
+          }
+
+          [data.definition, data.view_type]
         end
 
       end

data/lib/schema_plus/views/active_record/migration/command_recorder.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SchemaPlus::Views
   module ActiveRecord
     module Migration
@@ -11,7 +13,9 @@ module SchemaPlus::Views
         end
 
         def invert_create_view(args)
-          [ :drop_view, [args.first] ]
+          options = {}
+          options[:materialized] = args[2][:materialized] if args[2].has_key?(:materialized)
+          [ :drop_view, [args.first, options] ]
         end
 
       end

data/lib/schema_plus/views/middleware.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SchemaPlus::Views
   module Middleware
 
@@ -9,44 +11,43 @@ 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))
-            env.dump.tables[view.name] = view
-            env.dump.depends(view.name, view.definition.scan(re_view_referent).flatten)
-          end
-        end
+            definition, view_type = env.connection.view_full_definition(view_name)
 
-        # quacks like a SchemaMonkey Dump::Table
-        class View < KeyStruct[:name, :definition]
-          def assemble(stream)
-            heredelim = "END_VIEW_#{name.upcase}"
-            stream.puts <<-ENDVIEW
-  create_view "#{name}", <<-'#{heredelim}', :force => true
-#{definition}
-  #{heredelim}
+            indexes = []
 
-            ENDVIEW
-          end
-        end
-      end
-    end
+            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
 
-    module Schema
-      module Tables
+            view = ::SchemaPlus::Views::SchemaDump::View.new(
+              name:       view_name,
+              definition: definition,
+              view_type:  view_type,
+              indexes:    indexes
+            )
 
-        module Mysql
-          def after(env)
-            Tables.filter_out_views(env)
+            env.dump.tables[view.name] = view
+            env.dump.depends(view.name, view.definition.scan(re_view_referent).flatten)
           end
         end
 
-        module Sqlite3
-          def after(env)
-            Tables.filter_out_views(env)
-          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
 
-        def self.filter_out_views(env)
-          env.tables -= env.connection.views(env.query_name)
+          options
         end
       end
     end
@@ -56,11 +57,8 @@ module SchemaPlus::Views
     # for tables
 
     module Schema
-      module Views
-        ENV = [:connection, :query_name, :views]
-      end
       module ViewDefinition
-        ENV = [:connection, :view_name, :query_name, :definition]
+        ENV = [:connection, :view_name, :query_name, :definition, :view_type]
       end
     end
 
@@ -71,6 +69,9 @@ module SchemaPlus::Views
       module DropView
         ENV = [:connection, :view_name, :options]
       end
+      module RefreshView
+        ENV = [:connection, :view_name, :options]
+      end
     end
   end
 

data/lib/schema_plus/views/schema_dump.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module SchemaPlus
+  module Views
+    class SchemaDump
+      # quacks like a SchemaMonkey Dump::Table
+      class View < Struct.new(:name, :definition, :view_type, :indexes, keyword_init: true)
+        def assemble(stream)
+          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
+          stream.puts
+
+          indexes.each do |index|
+            stream.write "  add_index \"#{name}\", "
+            index.assemble(stream)
+            stream.puts ""
+          end
+          stream.puts ""
+        end
+      end
+    end
+  end
+end

data/lib/schema_plus/views/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module SchemaPlus
   module Views
-    VERSION = "0.3.1"
+    VERSION = '1.0.0'
   end
 end

data/lib/schema_plus/views.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'schema_plus/core'
 
 module SchemaPlus
@@ -9,6 +11,7 @@ require_relative 'views/version'
 require_relative 'views/active_record/connection_adapters/abstract_adapter'
 require_relative 'views/active_record/migration/command_recorder'
 require_relative 'views/middleware'
+require_relative 'views/schema_dump'
 
 module SchemaPlus::Views
   module ActiveRecord

data/lib/schema_plus_views.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 require_relative 'schema_plus/views'

data/schema_dev.yml

@@ -1,8 +1,13 @@
 ruby:
-    - 2.1.5
+    - 2.5
+    - 2.7
+    - 3.0
 activerecord:
-    - 4.2
+    - 5.2
+    - 6.0
 db:
     - mysql2
     - sqlite3
     - postgresql
+dbversions:
+    postgresql: ['9.6', '10', '11', '12']

data/schema_plus_views.gemspec

@@ -1,4 +1,5 @@
-# coding: utf-8
+# frozen_string_literal: true
+
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'schema_plus/views/version'
@@ -17,13 +18,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.required_ruby_version = '>= 2.5'
+
+  gem.add_dependency "activerecord", '>= 5.2', '< 6.1'
+  gem.add_dependency "schema_plus_core", '~> 3.0'
 
-  gem.add_development_dependency "bundler", "~> 1.7"
-  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 "simplecov"
-  gem.add_development_dependency "simplecov-gem-profile"
+  gem.add_development_dependency "bundler"
+  gem.add_development_dependency "rake", '~> 13.0'
+  gem.add_development_dependency "rspec", '~> 3.0'
+  gem.add_development_dependency "schema_dev", '~> 4.1'
 end

data/spec/dumper_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 class Item < ActiveRecord::Base
@@ -5,8 +7,6 @@ end
 
 describe "Dumper" do
 
-  let(:schema) { ActiveRecord::Schema }
-
   let(:migration) { ActiveRecord::Migration }
 
   let(:connection) { ActiveRecord::Base.connection }
@@ -39,27 +39,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 +121,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

@@ -1,12 +1,11 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 class Item < ActiveRecord::Base
 end
 
 describe "Introspection" do
-
-  let(:schema) { ActiveRecord::Schema }
-
   let(:migration) { ActiveRecord::Migration }
 
   let(:connection) { ActiveRecord::Base.connection }
@@ -17,8 +16,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 +27,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 +60,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 +92,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

@@ -1,15 +1,11 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 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 +36,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 +48,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')}